diff --git a/.gitignore b/.gitignore
index 3b88f71..0fee9ee 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,14 @@
 # Datasets
-datasets/
+datasets/*
+!datasets/llm/
+datasets/llm/*
+!datasets/llm/README.md
+
+# Local LLM models
+models/*
+!models/llm/
+models/llm/*
+!models/llm/README.md
 
 # Python
 __pycache__/
@@ -33,4 +42,4 @@ configs/agent_experiment_runs/
 configs/agent_config_*.yaml
 configs/cached/
 
-.pnpm-store/
\ No newline at end of file
+.pnpm-store/
diff --git a/README.md b/README.md
index 04784de..cc2f869 100644
--- a/README.md
+++ b/README.md
@@ -136,6 +136,21 @@ cd apps/frontend && pnpm install && pnpm dev
 - Frontend: `http://localhost:5173`
 - Backend API: `http://localhost:8000/docs`
 
+### LLM PEFT smoke run
+
+The LLM PEFT smoke config uses a tiny local Hugging Face-compatible model so it can run without downloading a base model. Generate it once before selecting `configs/smoke/llm_peft_simulation.yaml` in the Simulation UI:
+
+```bash
+uv run python scripts/create_tiny_llm_fixture.py
+```
+
+For a direct PowerShell smoke run:
+
+```powershell
+$env:PYTHONPATH="libs;apps/backend/runners"
+uv run python -c "from pathlib import Path; from runtime_dispatcher import run_runtime; raise SystemExit(0 if run_runtime(Path('configs/smoke/llm_peft_simulation.yaml')) else 1)"
+```
+
 ### Distributed deployment
 
 ```bash
@@ -194,8 +209,12 @@ figaro/
 │   ├── models/               # CNN / ResNet
 │   ├── data/                 # Data loading & partitioning
 │   ├── privacy/              # CKKS encryption
-│   └── compression/          # Top-K sparsification
+│   ├── compression/          # Top-K sparsification
+│   └── llm/                  # LLM PEFT runtime utilities
 ├── configs/                  # Experiment configs
+├── datasets/llm/             # Local LLM SFT/evaluation JSONL files
+├── models/llm/               # Local Hugging Face-compatible LLM directories
+├── skill/                    # Local operational skill guides
 ├── scripts/                  # Docker deployment scripts
 └── .github/workflows/        # CI pipelines
 ```
@@ -210,14 +229,16 @@ PRs welcome! Figaro is meant to be a readable, research-friendly FL platform.
 - [x] **Interactive Agent Planning** — Multi-turn dialogue support for refining experiments, plus visual topology previews (Plan Preview) before execution.
 - [x] **Execution Transparency** — Real-time tracking of node-level status during execution and automated natural-language interpretation of results.
 - [x] **Strict Configuration Engine** — Implement strict Pydantic/JSON Schema validation to resolve historical inconsistencies between `config_schema` and underlying algorithms.
-- [ ] **Advanced Experiment Tracking** — Multi-dimensional search filtering (by metrics, hyperparameters, status) and configuration version control (diffing).
-
-**Phase 2: LLM & LoRA Federated Fine-Tuning**
-- [ ] **Native LLM Ecosystem Integration** — Seamless Hugging Face model loading (e.g., Llama 3, Qwen) and efficient parsing of JSONL instruction-tuning datasets.
-- [ ] **Parameter-Efficient Runtime** — Deep integration with LoRA/PEFT, including support for QLoRA (4-bit/8-bit quantization) to lower client-side memory barriers.
-- [ ] **Specialized Adapter Aggregation** — Custom aggregation mechanisms for LoRA adapters, exploring support for heterogeneous LoRA ranks across clients.
-- [ ] **LLM Evaluation Metrics** — Built-in evaluation for generative tasks (Rouge, BLEU, Perplexity) and automated LLM-as-a-Judge capabilities.
-- [ ] **Hardware Guardrails** — Pre-run dynamic GPU memory estimation (OOM prevention) and automated tuning of gradient accumulation and checkpointing.
+- [x] **Advanced Experiment Tracking** — Multi-dimensional search filtering (by metrics, hyperparameters, status) and configuration version control (diffing).
+
+**Phase 2: LLM Federated PEFT Fine-Tuning**
+- [x] **Simulation LoRA/PEFT SFT Route** — `task.type=llm_peft_sft` dispatches to a dedicated single-machine simulation runtime that loads a Hugging Face or local causal LM, applies LoRA adapters, and runs per-client supervised fine-tuning from JSONL data.
+- [x] **LLM/PEFT Configuration Surface** — `config_schema` and runtime normalization now cover base model, tokenizer, max sequence length, precision, SFT dataset path/format, prompt template, LoRA hyperparameters, target modules, quantization mode, and adapter resume path.
+- [x] **JSONL SFT Data Pipeline** — Supports prompt/completion and chat messages JSONL formats, deterministic client splitting, and prompt rendering for plain/chat-style templates.
+- [x] **Adapter-Only Federated Aggregation** — Aggregates LoRA/PEFT adapter tensors by client example count, persists global adapter artifacts, records SHA-256 lineage, and supports warm-starting from a previous global adapter.
+- [x] **LLM Runtime Dependencies & Metrics** — Core project dependencies include `transformers`, `peft`, `accelerate`, `safetensors`, and `bitsandbytes`; backend metrics include train loss, perplexity, token throughput, adapter size, runtime status, dataset summary, and adapter artifact lineage.
+- [x] **Frontend & Agent UX for LLM Runs** — Exposes the LLM route in the schema-driven Simulation and Agent planning flows, with task-aware field visibility, LLM-specific metric charts, local model/dataset selection, and Adapter Lineage artifact views.
+- [x] **Evaluation Harness** — Adds validation JSONL configuration, per-round evaluation loss/perplexity calculation after global adapter aggregation, normalized evaluation metrics, and a generated tiny-model smoke config for LLM PEFT runs.
 
 **Phase 3: Enterprise & Team Collaboration**
 - [ ] **Multi-Tenant Workspaces** — Isolated project environments with Role-Based Access Control (RBAC) and comprehensive audit logging.
diff --git a/README.zh-CN.md b/README.zh-CN.md
index 67c527d..5679a4e 100644
--- a/README.zh-CN.md
+++ b/README.zh-CN.md
@@ -195,8 +195,12 @@ figaro/
 │   ├── models/               # CNN / ResNet
 │   ├── data/                 # 数据加载与划分
 │   ├── privacy/              # CKKS 加密
-│   └── compression/          # Top-K 稀疏化
+│   ├── compression/          # Top-K 稀疏化
+│   └── llm/                  # LLM PEFT 运行时工具
 ├── configs/                  # 实验配置
+├── datasets/llm/             # 本地 LLM SFT / 评测 JSONL 文件
+├── models/llm/               # 本地 Hugging Face 兼容 LLM 目录
+├── skill/                    # 本地操作说明 skill
 ├── scripts/                  # Docker 部署脚本
 └── .github/workflows/        # CI 流水线
 ```
@@ -211,14 +215,16 @@ figaro/
 - [x] **Agent 交互体验升级** —— 支持多轮对话微调实验计划，提供实验执行前的Plan Preview。
 - [x] **执行与分析透明化** —— 支持实验节点的实时状态追踪，以及 Agent 驱动的运行结果自动化图表解释。
 - [x] **配置引擎重构** —— 引入基于 Pydantic/JSON Schema 的严格强校验，彻底修复 `config_schema` 与底层算法实现不一致的问题。
-- [ ] **高阶实验管理** —— 支持按指标、超参等多维度搜索过滤实验历史，支持配置文件版本控制与 Diff 差异对比。
-
-**Phase 2：LLM / LoRA 联邦微调支持**
-- [ ] **大模型生态原生接入** —— 内置 Hugging Face 适配层，一键加载主流开源模型，支持 JSONL 格式的指令微调数据集高效解析。
-- [ ] **高效分布式微调** —— 深度集成 LoRA/PEFT 训练环境，支持 QLoRA (4-bit/8-bit 量化) 以显著降低边缘节点的显存门槛。
-- [ ] **专属权重聚合策略** —— 针对 LLM 微调定制的 Adapter 权重聚合机制，探索支持客户端异构 LoRA Rank 的聚合方案。
-- [ ] **大模型专项评估体系** —— 集成生成式 NLP 指标，并引入基于大模型的自动化指令跟随能力评估 (LLM-as-a-Judge)。
-- [ ] **资源护栏与预判** —— 训练任务启动前进行动态 GPU 显存预估（防 OOM 机制），并支持梯度累积与 Checkpointing 的自动调优。
+- [x] **高阶实验管理** —— 支持按指标、超参等多维度搜索过滤实验历史，支持配置文件版本控制与 Diff 差异对比。
+
+**Phase 2：基于现有框架的 LLM 联邦 PEFT 微调支持**
+- [x] **单机仿真 LoRA/PEFT SFT 路线** —— `task.type=llm_peft_sft` 会分发到专用的单机仿真运行时，加载 Hugging Face 或本地 Causal LM，注入 LoRA Adapter，并基于 JSONL 数据执行每个客户端的监督微调。
+- [x] **LLM/PEFT 配置面扩展** —— `config_schema` 与运行时规范化已覆盖基础模型、Tokenizer、最大序列长度、精度、SFT 数据路径/格式、Prompt 模板、LoRA 超参、目标模块、量化模式和 Adapter 续跑路径。
+- [x] **JSONL SFT 数据管线** —— 支持 prompt/completion 与 messages 两类 JSONL 格式，支持确定性的客户端数据切分，并提供 plain/chat 风格的文本渲染。
+- [x] **Adapter 权重联邦聚合** —— 按客户端样本数聚合 LoRA/PEFT Adapter Tensor，持久化全局 Adapter 产物，记录 SHA-256 血缘，并支持从历史全局 Adapter warm start 续跑。
+- [x] **LLM 运行依赖与指标** —— 主项目依赖已包含 `transformers`、`peft`、`accelerate`、`safetensors`、`bitsandbytes`；后端指标已包含 train loss、perplexity、token throughput、adapter size、运行状态、数据摘要和 Adapter artifact lineage。
+- [x] **前端与 Agent 的 LLM 运行体验** —— 已在 schema-driven Simulation UI 与 Agent 规划流中开放 LLM 路线，支持按任务类型显示/隐藏字段、LLM 指标曲线、本地模型/数据集选择，以及 Adapter Lineage 产物视图。
+- [x] **评测与 Smoke 配置** —— 已增加验证集 JSONL 配置、全局 Adapter 聚合后的逐轮 evaluation loss/perplexity 计算、标准化评测指标，以及 tiny-model LLM PEFT smoke fixture/config。
 
 **Phase 3：平台化与企业级协作**
 - [ ] **多租户与细粒度权限** —— 构建多用户隔离的项目空间 (Workspaces)，引入基于角色的访问控制 (RBAC) 和完整的操作审计日志。
diff --git a/apps/backend/app/api/v1/endpoints/agent.py b/apps/backend/app/api/v1/endpoints/agent.py
index 29f6f1b..9d0e902 100644
--- a/apps/backend/app/api/v1/endpoints/agent.py
+++ b/apps/backend/app/api/v1/endpoints/agent.py
@@ -4,12 +4,16 @@
 
 from __future__ import annotations
 
-from fastapi import APIRouter, status, HTTPException
+from datetime import datetime
+
+from fastapi import APIRouter, status, HTTPException, Query
 import json
 
 from app.api.deps import AsyncSessionDep
 from app.schemas.agent import (
+    AgentConfigDiffResponse,
     AgentConfigChangeResponse,
+    AgentConfigVersionResponse,
     AgentCurrentExperimentResponse,
     AgentCurrentPlanResponse,
     AgentExperimentResponse,
@@ -27,7 +31,14 @@
 from app.services.agent import AgentExperimentRunService, AgentExperimentService, AgentOptimizationHistoryService, AgentRuntimeService, AgentState
 from app.services.agent.graph import FederatedAgentGraphBuilder
 from app.services.agent.objectives import AgentOptimizationObjective, resolve_objective
-from app.services.agent.planning import build_schema_prompt_context, dumps_for_prompt
+from app.services.agent.planning import (
+    build_initial_config,
+    build_schema_prompt_context,
+    deep_merge_config,
+    dumps_for_prompt,
+    lock_structured_constraints,
+    merge_llm_resource_constraints,
+)
 from app.services.llm import LLMRegistry, LLMService
 from app.schemas.agent import AgentPlanPreviewRequest, AgentPlanPreviewResponse, ExperimentPlanPreview, AgentPlanReviseRequest
 import uuid
@@ -241,12 +252,52 @@ def _build_history_summary(item) -> AgentOptimizationJobSummaryResponse:
     status_code=status.HTTP_200_OK,
     summary="List persisted agent optimization jobs",
 )
-async def list_optimization_jobs(session: AsyncSessionDep) -> list[AgentOptimizationJobSummaryResponse]:
+async def list_optimization_jobs(
+    session: AsyncSessionDep,
+    job_status: str | None = Query(default=None, alias="status"),
+    q: str | None = Query(default=None),
+    model_name: str | None = Query(default=None),
+    objective: str | None = Query(default=None),
+    best_score_min: float | None = Query(default=None),
+    best_score_max: float | None = Query(default=None),
+    created_from: datetime | None = Query(default=None),
+    created_to: datetime | None = Query(default=None),
+    dataset: str | None = Query(default=None),
+    config_model: str | None = Query(default=None),
+    aggregation: str | None = Query(default=None),
+    num_clients: int | None = Query(default=None),
+    num_rounds: int | None = Query(default=None),
+    dataset_name_alias: str | None = Query(default=None, alias="dataset.name"),
+    config_model_alias: str | None = Query(default=None, alias="model.name"),
+    aggregation_alias: str | None = Query(default=None, alias="federated.aggregation"),
+    num_clients_alias: int | None = Query(default=None, alias="federated.num_clients"),
+    num_rounds_alias: int | None = Query(default=None, alias="federated.num_rounds"),
+) -> list[AgentOptimizationJobSummaryResponse]:
     """
     Return persisted Agent optimization jobs ordered by latest update time.
     """
     service = AgentOptimizationHistoryService(session)
-    jobs = await service.list_jobs()
+    config_filters = {
+        "dataset.name": dataset_name_alias or dataset,
+        "model.name": config_model_alias or config_model,
+        "federated.aggregation": aggregation_alias or aggregation,
+        "federated.num_clients": num_clients_alias if num_clients_alias is not None else num_clients,
+        "federated.num_rounds": num_rounds_alias if num_rounds_alias is not None else num_rounds,
+    }
+    try:
+        jobs = await service.list_jobs(
+            status=job_status,
+            q=q,
+            model_name=model_name,
+            objective=objective,
+            best_score_min=best_score_min,
+            best_score_max=best_score_max,
+            created_from=created_from,
+            created_to=created_to,
+            config_filters=config_filters,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
     return [_build_history_summary(item) for item in jobs]
 
 
@@ -284,6 +335,67 @@ async def get_optimization_job(
     return _build_progress_response(snapshot)
 
 
+def _to_config_version_response(version) -> AgentConfigVersionResponse:
+    return AgentConfigVersionResponse(
+        id=version.id,
+        optimization_job_id=version.optimization_job_id,
+        run_id=version.run_id,
+        iteration=version.iteration,
+        source=version.source,
+        label=version.label,
+        config_hash=version.config_hash,
+        config_json=version.config_json if isinstance(version.config_json, dict) else {},
+        diff_json=[
+            AgentConfigChangeResponse.model_validate(item)
+            for item in (version.diff_json if isinstance(version.diff_json, list) else [])
+        ],
+        created_at=version.created_at,
+    )
+
+
+@agent_router.get(
+    "/optimization-jobs/{optimization_job_id}/config-versions",
+    response_model=list[AgentConfigVersionResponse],
+    status_code=status.HTTP_200_OK,
+    summary="List persisted config versions for an agent optimization job",
+)
+async def list_optimization_job_config_versions(
+    optimization_job_id: int,
+    session: AsyncSessionDep,
+) -> list[AgentConfigVersionResponse]:
+    """Return config versions captured during planning and experiment execution."""
+    service = AgentOptimizationHistoryService(session)
+    versions = await service.list_config_versions(optimization_job_id)
+    return [_to_config_version_response(version) for version in versions]
+
+
+@agent_router.get(
+    "/optimization-jobs/{optimization_job_id}/config-diff",
+    response_model=AgentConfigDiffResponse,
+    status_code=status.HTTP_200_OK,
+    summary="Diff two persisted config versions for an agent optimization job",
+)
+async def diff_optimization_job_config_versions(
+    optimization_job_id: int,
+    session: AsyncSessionDep,
+    to_version_id: int = Query(...),
+    from_version_id: int | None = Query(default=None),
+) -> AgentConfigDiffResponse:
+    """Return a normalized config diff between two persisted versions."""
+    service = AgentOptimizationHistoryService(session)
+    changes = await service.diff_config_versions(
+        optimization_job_id=optimization_job_id,
+        from_version_id=from_version_id,
+        to_version_id=to_version_id,
+    )
+    return AgentConfigDiffResponse(
+        optimization_job_id=optimization_job_id,
+        from_version_id=from_version_id,
+        to_version_id=to_version_id,
+        changes=[AgentConfigChangeResponse.model_validate(item) for item in changes],
+    )
+
+
 @agent_router.post(
     "/optimize/start",
     response_model=AgentOptimizeProgressResponse,
@@ -675,13 +787,39 @@ async def revise_plan_preview(
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Failed to parse LLM response: {str(e)}")
 
-    snapshot["draft_experiments"] = updated_experiments
+    experiment_service = AgentExperimentService(session)
+    schema = experiment_service.get_config_schema()
+    constrained_base = experiment_service.normalize_simulation_config(
+        deep_merge_config(build_initial_config(schema), config_constraints)
+    )
+    effective_constraints = merge_llm_resource_constraints(constrained_base, config_constraints)
+    normalized_experiments = []
+    for idx, exp in enumerate(updated_experiments):
+        if not isinstance(exp, dict):
+            continue
+        raw_config = exp.get("config_patch", exp.get("config", {}))
+        if not isinstance(raw_config, dict):
+            raw_config = {}
+        merged = lock_structured_constraints(
+            deep_merge_config(constrained_base, raw_config),
+            effective_constraints,
+        )
+        normalized_experiments.append(
+            {
+                **exp,
+                "name": exp.get("name", f"exp-{idx + 1}"),
+                "plan_summary": exp.get("plan_summary", snapshot.get("goal", "")),
+                "config_patch": experiment_service.normalize_simulation_config(merged),
+            }
+        )
+
+    snapshot["draft_experiments"] = normalized_experiments
     await history_service.update_job_snapshot(task_id=job.task_id, snapshot=snapshot)
 
     return AgentPlanPreviewResponse(
         optimization_job_id=job.id,
         goal=snapshot.get("goal", ""),
-        experiments=[ExperimentPlanPreview.model_validate(exp) for exp in updated_experiments],
+        experiments=[ExperimentPlanPreview.model_validate(exp) for exp in normalized_experiments],
         system_mode=snapshot.get("system_mode", "simulation"),
         config_constraints=config_constraints,
     )
diff --git a/apps/backend/app/models/__init__.py b/apps/backend/app/models/__init__.py
index e8852bb..9155124 100644
--- a/apps/backend/app/models/__init__.py
+++ b/apps/backend/app/models/__init__.py
@@ -1,8 +1,10 @@
 """Model package marker — import all models so SQLModel registers them."""
 
 from app.models.agent import (  # noqa: F401
+    AgentConfigVersion,
     AgentExperiment,
     AgentExperimentRun,
     AgentExperimentRunLog,
     AgentExperimentRunResult,
+    AgentOptimizationJob,
 )
diff --git a/apps/backend/app/models/agent/__init__.py b/apps/backend/app/models/agent/__init__.py
index 3f6f494..8fe0be4 100644
--- a/apps/backend/app/models/agent/__init__.py
+++ b/apps/backend/app/models/agent/__init__.py
@@ -10,7 +10,7 @@
     AgentExperimentRunStatus,
     AgentExperimentStatus,
 )
-from app.models.agent.optimization_jobs import AgentOptimizationJob, AgentOptimizationJobStatus
+from app.models.agent.optimization_jobs import AgentConfigVersion, AgentOptimizationJob, AgentOptimizationJobStatus
 
 __all__ = [
     "AgentExperiment",
@@ -21,4 +21,5 @@
     "AgentExperimentRunResult",
     "AgentOptimizationJob",
     "AgentOptimizationJobStatus",
+    "AgentConfigVersion",
 ]
diff --git a/apps/backend/app/models/agent/optimization_jobs.py b/apps/backend/app/models/agent/optimization_jobs.py
index 8848516..650c05b 100644
--- a/apps/backend/app/models/agent/optimization_jobs.py
+++ b/apps/backend/app/models/agent/optimization_jobs.py
@@ -93,3 +93,45 @@ class AgentOptimizationJob(SQLModel, table=True):
         default=None,
         sa_column=Column(DateTime(timezone=True), nullable=True),
     )
+
+
+class AgentConfigVersion(SQLModel, table=True):
+    __tablename__ = "agent_config_versions"
+
+    id: int | None = Field(
+        default=None,
+        sa_column=Column(Integer, primary_key=True, nullable=False),
+    )
+    optimization_job_id: int = Field(
+        sa_column=Column(Integer, nullable=False, index=True),
+    )
+    run_id: str | None = Field(
+        default=None,
+        sa_column=Column(String(64), nullable=True, index=True),
+    )
+    iteration: int = Field(
+        default=0,
+        sa_column=Column(Integer, nullable=False, index=True),
+    )
+    source: str = Field(
+        default="experiment",
+        sa_column=Column(String(32), nullable=False, index=True),
+    )
+    label: str = Field(
+        sa_column=Column(String(255), nullable=False),
+    )
+    config_hash: str = Field(
+        sa_column=Column(String(64), nullable=False, index=True),
+    )
+    config_json: dict[str, Any] = Field(
+        default_factory=dict,
+        sa_column=Column(JSON().with_variant(JSONB, "postgresql"), nullable=False),
+    )
+    diff_json: list[dict[str, Any]] = Field(
+        default_factory=list,
+        sa_column=Column(JSON().with_variant(JSONB, "postgresql"), nullable=False),
+    )
+    created_at: datetime = Field(
+        default_factory=utcnow,
+        sa_column=Column(DateTime(timezone=True), nullable=False),
+    )
diff --git a/apps/backend/app/repositories/agent/__init__.py b/apps/backend/app/repositories/agent/__init__.py
index dec957e..c02fe11 100644
--- a/apps/backend/app/repositories/agent/__init__.py
+++ b/apps/backend/app/repositories/agent/__init__.py
@@ -1,6 +1,6 @@
 """Agent repository exports."""
 
 from app.repositories.agent.experiment_repository import AgentExperimentRepository
-from app.repositories.agent.optimization_job_repository import AgentOptimizationJobRepository
+from app.repositories.agent.optimization_job_repository import AgentConfigVersionRepository, AgentOptimizationJobRepository
 
-__all__ = ["AgentExperimentRepository", "AgentOptimizationJobRepository"]
+__all__ = ["AgentExperimentRepository", "AgentOptimizationJobRepository", "AgentConfigVersionRepository"]
diff --git a/apps/backend/app/repositories/agent/optimization_job_repository.py b/apps/backend/app/repositories/agent/optimization_job_repository.py
index 6fa8f95..7953833 100644
--- a/apps/backend/app/repositories/agent/optimization_job_repository.py
+++ b/apps/backend/app/repositories/agent/optimization_job_repository.py
@@ -4,13 +4,14 @@
 
 from __future__ import annotations
 
+from datetime import datetime
 from typing import Any
 
-from sqlalchemy import func
+from sqlalchemy import func, or_
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlmodel import select
 
-from app.models.agent import AgentOptimizationJob, AgentOptimizationJobStatus
+from app.models.agent import AgentConfigVersion, AgentOptimizationJob, AgentOptimizationJobStatus
 from app.models.base import utcnow
 
 
@@ -62,8 +63,38 @@ async def get_job_by_name(self, job_name: str) -> AgentOptimizationJob | None:
         result = await self.session.execute(stmt)
         return result.scalars().first()
 
-    async def list_jobs(self) -> list[AgentOptimizationJob]:
+    async def list_jobs(
+        self,
+        *,
+        status: AgentOptimizationJobStatus | None = None,
+        q: str | None = None,
+        model_name: str | None = None,
+        best_score_min: float | None = None,
+        best_score_max: float | None = None,
+        created_from: datetime | None = None,
+        created_to: datetime | None = None,
+    ) -> list[AgentOptimizationJob]:
         stmt = select(AgentOptimizationJob).order_by(AgentOptimizationJob.updated_at.desc(), AgentOptimizationJob.id.desc())
+        if status is not None:
+            stmt = stmt.where(AgentOptimizationJob.status == status)
+        if q:
+            like_value = f"%{q.lower()}%"
+            stmt = stmt.where(
+                or_(
+                    func.lower(AgentOptimizationJob.goal).like(like_value),
+                    func.lower(AgentOptimizationJob.job_name).like(like_value),
+                )
+            )
+        if model_name:
+            stmt = stmt.where(func.lower(AgentOptimizationJob.model_name) == model_name.lower())
+        if best_score_min is not None:
+            stmt = stmt.where(AgentOptimizationJob.best_score >= best_score_min)
+        if best_score_max is not None:
+            stmt = stmt.where(AgentOptimizationJob.best_score <= best_score_max)
+        if created_from is not None:
+            stmt = stmt.where(AgentOptimizationJob.created_at >= created_from)
+        if created_to is not None:
+            stmt = stmt.where(AgentOptimizationJob.created_at <= created_to)
         result = await self.session.execute(stmt)
         return list(result.scalars().all())
 
@@ -108,3 +139,72 @@ async def update_job(
         self.session.add(job)
         await self.session.flush()
         return job
+
+
+class AgentConfigVersionRepository:
+    """CRUD helpers for persisted agent configuration versions."""
+
+    def __init__(self, session: AsyncSession):
+        self.session = session
+
+    async def create_version(
+        self,
+        *,
+        optimization_job_id: int,
+        run_id: str | None,
+        iteration: int,
+        source: str,
+        label: str,
+        config_hash: str,
+        config_json: dict[str, Any],
+        diff_json: list[dict[str, Any]],
+    ) -> AgentConfigVersion:
+        version = AgentConfigVersion(
+            optimization_job_id=optimization_job_id,
+            run_id=run_id,
+            iteration=iteration,
+            source=source,
+            label=label,
+            config_hash=config_hash,
+            config_json=config_json,
+            diff_json=diff_json,
+        )
+        self.session.add(version)
+        await self.session.flush()
+        return version
+
+    async def find_version(
+        self,
+        *,
+        optimization_job_id: int,
+        run_id: str | None,
+        iteration: int,
+        source: str,
+        config_hash: str,
+    ) -> AgentConfigVersion | None:
+        stmt = select(AgentConfigVersion).where(
+            AgentConfigVersion.optimization_job_id == optimization_job_id,
+            AgentConfigVersion.iteration == iteration,
+            AgentConfigVersion.source == source,
+            AgentConfigVersion.config_hash == config_hash,
+        )
+        if run_id is None:
+            stmt = stmt.where(AgentConfigVersion.run_id.is_(None))
+        else:
+            stmt = stmt.where(AgentConfigVersion.run_id == run_id)
+        result = await self.session.execute(stmt)
+        return result.scalars().first()
+
+    async def get_version(self, version_id: int) -> AgentConfigVersion | None:
+        return await self.session.get(AgentConfigVersion, version_id)
+
+    async def list_versions(self, optimization_job_id: int, *, source: str | None = None) -> list[AgentConfigVersion]:
+        stmt = (
+            select(AgentConfigVersion)
+            .where(AgentConfigVersion.optimization_job_id == optimization_job_id)
+            .order_by(AgentConfigVersion.created_at.asc(), AgentConfigVersion.id.asc())
+        )
+        if source is not None:
+            stmt = stmt.where(AgentConfigVersion.source == source)
+        result = await self.session.execute(stmt)
+        return list(result.scalars().all())
diff --git a/apps/backend/app/schemas/__init__.py b/apps/backend/app/schemas/__init__.py
index b793e9f..ad3ca51 100644
--- a/apps/backend/app/schemas/__init__.py
+++ b/apps/backend/app/schemas/__init__.py
@@ -29,6 +29,8 @@
 )
 from app.schemas.message import Message
 from app.schemas.agent import (
+    AgentConfigDiffResponse,
+    AgentConfigVersionResponse,
     AgentCurrentPlanResponse,
     AgentExperimentSummary,
     AgentOptimizationJobSummaryResponse,
@@ -66,4 +68,6 @@
     "AgentOptimizationJobSummaryResponse",
     "AgentCurrentPlanResponse",
     "AgentExperimentSummary",
+    "AgentConfigVersionResponse",
+    "AgentConfigDiffResponse",
 ]
diff --git a/apps/backend/app/schemas/agent.py b/apps/backend/app/schemas/agent.py
index 3baec67..2425c04 100644
--- a/apps/backend/app/schemas/agent.py
+++ b/apps/backend/app/schemas/agent.py
@@ -67,6 +67,30 @@ class AgentConfigChangeResponse(BaseModel):
     new_value: Any = None
 
 
+class AgentConfigVersionResponse(BaseModel):
+    """One persisted config version for a historical Agent optimization."""
+
+    id: int
+    optimization_job_id: int
+    run_id: str | None = None
+    iteration: int
+    source: str
+    label: str
+    config_hash: str
+    config_json: dict[str, Any] = Field(default_factory=dict)
+    diff_json: list[AgentConfigChangeResponse] = Field(default_factory=list)
+    created_at: datetime
+
+
+class AgentConfigDiffResponse(BaseModel):
+    """Diff payload between two persisted config versions."""
+
+    optimization_job_id: int
+    from_version_id: int | None = None
+    to_version_id: int
+    changes: list[AgentConfigChangeResponse] = Field(default_factory=list)
+
+
 class AgentCurrentPlanResponse(BaseModel):
     """Planner output for the iteration currently being prepared or executed."""
 
diff --git a/apps/backend/app/schemas/simulation/runs.py b/apps/backend/app/schemas/simulation/runs.py
index 9d8f23e..45e2dd3 100644
--- a/apps/backend/app/schemas/simulation/runs.py
+++ b/apps/backend/app/schemas/simulation/runs.py
@@ -68,9 +68,21 @@ class SimulationRunGlobalResults(BaseModel):
     global_accuracy: list[float] = Field(default_factory=list)
 
 
+class SimulationRunLlmResults(BaseModel):
+    """LLM PEFT metric series."""
+
+    rounds: list[int] = Field(default_factory=list)
+    train_loss: list[float] = Field(default_factory=list)
+    validation_loss: list[float] = Field(default_factory=list)
+    perplexity: list[float] = Field(default_factory=list)
+    token_throughput: list[float] = Field(default_factory=list)
+    adapter_size_bytes: list[int] = Field(default_factory=list)
+
+
 class SimulationRunClientSeries(BaseModel):
     """Per-client metric series in simulation mode."""
 
+    rounds: list[int] = Field(default_factory=list)
     train_loss: list[float] = Field(default_factory=list)
     train_acc: list[float] = Field(default_factory=list)
     test_loss: list[float] = Field(default_factory=list)
@@ -90,4 +102,9 @@ class SimulationRunMetricsResponse(BaseModel):
 
     experiment_info: SimulationRunExperimentInfo = Field(default_factory=SimulationRunExperimentInfo)
     global_results: SimulationRunGlobalResults = Field(default_factory=SimulationRunGlobalResults)
+    llm_results: SimulationRunLlmResults = Field(default_factory=SimulationRunLlmResults)
+    llm_dataset: dict[str, Any] = Field(default_factory=dict)
+    llm_evaluation: dict[str, Any] = Field(default_factory=dict)
+    llm_runtime: dict[str, Any] = Field(default_factory=dict)
+    llm_artifacts: list[dict[str, Any]] = Field(default_factory=list)
     client_results: dict[str, SimulationRunClientSeries] = Field(default_factory=dict)
diff --git a/apps/backend/app/services/agent/capabilities.py b/apps/backend/app/services/agent/capabilities.py
index 4b973e2..a6ebfa5 100644
--- a/apps/backend/app/services/agent/capabilities.py
+++ b/apps/backend/app/services/agent/capabilities.py
@@ -1,118 +1,34 @@
 """
-Helpers for inspecting the current federated learning stack capabilities.
+Helpers for exposing executable simulation capabilities to the Agent.
 
-Used by the Agent to ground its proposals in the actually supported
-datasets, models, and aggregations.
+The Agent should plan only combinations that the simulation runtime can
+execute. The source of truth lives in libs/fl_core/simulation_registry.py;
+this module is a thin backend-side adapter.
 """
 
 from __future__ import annotations
 
-import ast
-import re
 from pathlib import Path
-from typing import Any, Dict, List
+from typing import Any, Dict
 
-
-def _read_text(path: Path) -> str:
-    return path.read_text(encoding="utf-8", errors="replace")
-
-
-def _extract_list_literal(text: str) -> List[Any]:
-    """
-    Extract a Python list literal from a string like: [ "a", "b" ].
-    Returns [] on failure.
-    """
-    try:
-        value = ast.literal_eval(text)
-        if isinstance(value, list):
-            return value
-    except Exception:
-        pass
-    return []
-
-
-def _extract_supported_datasets(project_root: Path) -> List[str]:
-    path = project_root / "libs" / "fl_core" / "data" / "data_loader.py"
-    if not path.exists():
-        return []
-    text = _read_text(path)
-    match = re.search(r"supported_datasets\s*=\s*(\[[^\]]*\])", text, flags=re.DOTALL)
-    if not match:
-        return []
-    items = _extract_list_literal(match.group(1))
-    out: List[str] = []
-    for item in items:
-        if isinstance(item, str):
-            out.append(item)
-    return out
-
-
-def _extract_model_registry_keys(project_root: Path) -> List[str]:
-    path = project_root / "libs" / "fl_core" / "models" / "model_manager.py"
-    if not path.exists():
-        return []
-    text = _read_text(path)
-    match = re.search(r"model_registry\s*=\s*\{(.*?)\}\s*\n", text, flags=re.DOTALL)
-    if not match:
-        return []
-    block = match.group(1)
-    keys = re.findall(r"['\"]([a-zA-Z0-9_]+)['\"]\s*:", block)
-    seen: set[str] = set()
-    out: List[str] = []
-    for key in keys:
-        lower = key.lower()
-        if lower not in seen:
-            seen.add(lower)
-            out.append(lower)
-    return out
-
-
-def _extract_aggregation_strategies(project_root: Path) -> List[str]:
-    """
-    Returns aggregation strategies from federated/aggregation.py without imports.
-    """
-    path = project_root / "libs" / "fl_core" / "federated" / "aggregation.py"
-    if not path.exists():
-        return []
-    text = _read_text(path)
-
-    match = re.search(r"_strategies\s*=\s*\{(.*?)\}", text, flags=re.DOTALL)
-    if not match:
-        return []
-    aggregations = re.findall(r"['\"]([a-zA-Z0-9_]+)['\"]\s*:", match.group(1))
-
-    seen: set[str] = set()
-    out: List[str] = []
-    for item in aggregations:
-        lower = item.lower()
-        if lower not in seen:
-            seen.add(lower)
-            out.append(lower)
-    return out
+from app.services.simulation.compatibility import runtime_capabilities
 
 
 def get_platform_capabilities(project_root: Path | None = None) -> Dict[str, Any]:
     """
-    Inspect the current codebase and return the supported configuration options
-    for datasets, models, and aggregations.
+    Return supported simulation datasets, models, aggregations, and compatibility
+    rules. The project_root argument is kept for compatibility with older tests.
     """
-    root = project_root or Path(__file__).resolve().parents[4]
-
-    datasets = _extract_supported_datasets(root)
-    models = _extract_model_registry_keys(root)
-    aggregations = _extract_aggregation_strategies(root)
-
-    metrics = {
-        "global_results": ["rounds", "global_loss", "global_accuracy"],
-        "client_results": ["train_loss", "train_acc", "test_loss", "test_acc"],
-    }
-
-    return {
-        "datasets": datasets,
-        "distributions": ["iid", "non_iid"],
-        "models": models,
-        "aggregations": aggregations,
-        "metrics": metrics,
+    _ = project_root
+    capabilities = runtime_capabilities()
+    capabilities["training_routes"] = {
+        "classic_fl": {
+            "modes": ["simulation", "distributed"],
+            "description": "Classic federated learning route for the built-in small-model datasets.",
+        },
+        "llm_peft_sft": {
+            "modes": ["simulation"],
+            "description": "Simulation-only route for federated LoRA/PEFT supervised fine-tuning on JSONL SFT data.",
+        },
     }
-
-
+    return capabilities
diff --git a/apps/backend/app/services/agent/experiment_service.py b/apps/backend/app/services/agent/experiment_service.py
index a6bbd8d..5b42b2b 100644
--- a/apps/backend/app/services/agent/experiment_service.py
+++ b/apps/backend/app/services/agent/experiment_service.py
@@ -32,6 +32,15 @@
     AgentExperimentStatus,
 )
 from app.repositories.agent import AgentExperimentRepository
+from app.services.llm_resources import augment_config_schema_with_llm_resources
+from app.services.run_artifacts import (
+    legacy_live_results_filename,
+    live_results_filename,
+    run_artifact_timestamp,
+    run_config_filename,
+    run_log_filename,
+)
+from app.services.simulation.compatibility import canonicalize_runtime_config, validate_runtime_config_or_raise
 
 from app.core.logger import get_logger
 
@@ -42,7 +51,7 @@
 # Shared constants (mirrored from simulation run_service / run_metrics_service)
 # ---------------------------------------------------------------------------
 
-RESULT_PATH_PATTERN = re.compile(r"结果已保存到[:：]\s*(.+)$")
+RESULT_PATH_PATTERN = re.compile(r"\u7ed3\u679c\u5df2\u4fdd\u5b58\u5230[:\uff1a]\s*(.+)$")
 LOG_LEVEL_PREFIX_PATTERN = re.compile(
     r"^\s*(DEBUG|INFO|WARNING|WARN|ERROR|CRITICAL)\b[\s:\-]",
     re.IGNORECASE,
@@ -205,7 +214,7 @@ def get_config_schema(cls) -> dict[str, Any]:
         loaded = yaml.safe_load(schema_path.read_text(encoding="utf-8"))
         if not isinstance(loaded, dict):
             raise exceptions.InternalServiceError("Config schema must be a YAML object.")
-        return loaded
+        return augment_config_schema_with_llm_resources(loaded, cls._project_root())
 
     @classmethod
     def normalize_simulation_config(cls, config: dict[str, Any]) -> dict[str, Any]:
@@ -235,7 +244,9 @@ def _normalize_simulation_config(cls, config: dict[str, Any]) -> dict[str, Any]:
         system["mode"] = "simulation"
         system["node_role"] = "server"
 
+        canonicalize_runtime_config(merged)
         cls._validate_config_node(merged, schema, path_prefix="")
+        validate_runtime_config_or_raise(merged)
         return merged
 
     @classmethod
@@ -310,6 +321,12 @@ def _cleanup_run_local_files(self, run_id: str) -> None:
             self._project_root() / "configs" / "agent_experiment_runs" / f"{run_id}.json",
             self._project_root() / "results" / f"live_results_{run_id}.json",
         ]
+        candidates.extend((self._project_root() / "configs" / "agent_experiment_runs").glob(f"{run_id}*.json"))
+        candidates.extend((self._project_root() / "configs" / "agent_experiment_runs").glob(f"*_{run_id}.json"))
+        candidates.extend((self._project_root() / "results").glob(f"live_results_{run_id}*.json"))
+        candidates.extend((self._project_root() / "results").glob(f"*_{run_id}_live_results.json"))
+        candidates.extend((self._project_root() / "logs" / "agent_experiment_runs").glob(f"{run_id}*_server.log"))
+        candidates.extend((self._project_root() / "logs" / "agent_experiment_runs").glob(f"*_{run_id}_server.log"))
         for path in candidates:
             try:
                 if path.exists() and path.is_file():
@@ -476,14 +493,12 @@ async def get_run_metrics(self, run_id: str) -> dict[str, Any]:
         run = await self.repo.get_run(run_id)
         if not run:
             raise exceptions.RunNotFound("Run not found")
-        # If terminal and already has metrics, return them
-        if run.status in TERMINAL_RUN_STATUSES and isinstance(run.metrics_json, dict) and run.metrics_json:
-            return self._normalize_metrics_payload(run.metrics_json)
         # Try live result file
-        live_result_path = self._results_dir() / self._build_live_results_filename(run_id)
-        loaded = self._load_metrics_file(live_result_path)
-        if loaded is not None:
-            return loaded
+        for live_result_path in self._live_result_candidates_for_run(run):
+            loaded = self._load_metrics_file(live_result_path)
+            if loaded is not None:
+                await self._persist_run_metrics_if_changed(run, loaded)
+                return loaded
 
         # Try result artifacts
         results = await self.repo.list_results(run_id)
@@ -492,6 +507,7 @@ async def get_run_metrics(self, run_id: str) -> dict[str, Any]:
             artifact_path = self._resolve_result_artifact_path(artifact.path)
             loaded = self._load_metrics_file(artifact_path)
             if loaded is not None:
+                await self._persist_run_metrics_if_changed(run, loaded)
                 return loaded
 
         if isinstance(run.metrics_json, dict) and run.metrics_json:
@@ -499,6 +515,15 @@ async def get_run_metrics(self, run_id: str) -> dict[str, Any]:
 
         return self._empty_metrics_payload()
 
+    async def _persist_run_metrics_if_changed(self, run: AgentExperimentRun, metrics: dict[str, Any]) -> None:
+        current = run.metrics_json if isinstance(run.metrics_json, dict) else {}
+        if self._stable_json(current) == self._stable_json(metrics):
+            return
+
+        await self.repo.update_run_metrics(run, metrics)
+        await self.session.commit()
+        await self.session.refresh(run)
+
     async def delete_run(self, run_id: str) -> None:
         run = await self.get_run(run_id)
         if run.status in {AgentExperimentRunStatus.QUEUED, AgentExperimentRunStatus.RUNNING}:
@@ -522,18 +547,22 @@ async def _start_run_with_config(self, *, experiment_id: int, config_json: dict[
         )
         await self.repo.create_run(run)
 
-        config_path = self._write_run_config(run.id, config_json)
+        artifact_timestamp = run_artifact_timestamp(run.created_at)
+        config_path = self._write_run_config(run.id, config_json, artifact_timestamp=artifact_timestamp)
         await self.repo.add_result(
             run_id=run.id,
             artifact_type=RUN_CONFIG_ARTIFACT,
             path=str(config_path),
-            metadata_json={"source": "run_config"},
+            metadata_json={"source": "run_config", "artifact_timestamp": artifact_timestamp},
         )
 
         command = self._build_train_command(config_path)
         run.command = " ".join(command)
 
-        live_results_path = self._results_dir() / self._build_live_results_filename(run.id)
+        live_results_path = self._results_dir() / self._build_live_results_filename(
+            run.id,
+            artifact_timestamp=artifact_timestamp,
+        )
         child_env = self._build_run_environment(live_results_path)
         process = await self._spawn_subprocess(command, env=child_env)
 
@@ -548,13 +577,21 @@ async def _start_run_with_config(self, *, experiment_id: int, config_json: dict[
         await self.session.refresh(run)
 
         self._processes[run.id] = process
-        self._tasks[run.id] = asyncio.create_task(self._watch_process(run.id, process))
+        self._tasks[run.id] = asyncio.create_task(
+            self._watch_process(run.id, process, artifact_timestamp=artifact_timestamp)
+        )
         return run
 
-    async def _watch_process(self, run_id: str, process: asyncio.subprocess.Process) -> None:
+    async def _watch_process(
+        self,
+        run_id: str,
+        process: asyncio.subprocess.Process,
+        *,
+        artifact_timestamp: str | None = None,
+    ) -> None:
         """Consume subprocess streams and persist final run status/artifacts."""
         result_path: str | None = None
-        log_path = self._run_log_path(run_id)
+        log_path = self._run_log_path(run_id, artifact_timestamp=artifact_timestamp)
 
         async def consume(stream: asyncio.StreamReader, level: str, prefix: str) -> None:
             nonlocal result_path
@@ -566,7 +603,7 @@ async def consume(stream: asyncio.StreamReader, level: str, prefix: str) -> None
                     message = line.decode("utf-8", errors="replace").rstrip()
                     if not message:
                         continue
-                    file_obj.write(f"[{prefix}] {message}\\n")
+                    file_obj.write(f"[{prefix}] {message}\n")
                     file_obj.flush()
 
                     match = RESULT_PATH_PATTERN.search(message)
@@ -601,21 +638,35 @@ async def consume(stream: asyncio.StreamReader, level: str, prefix: str) -> None
                 )
                 await repo.add_log(run_id, f"run finished with exit_code={exit_code}")
 
+                metrics_persisted = False
                 if result_path:
                     await repo.add_result(
                         run_id=run_id,
                         artifact_type=TRAINING_RESULT_ARTIFACT,
                         path=result_path,
-                        metadata_json={"source": "process_output"},
+                        metadata_json={
+                            "source": "process_output",
+                            "artifact_timestamp": artifact_timestamp,
+                        },
                     )
                     resolved = self._resolve_result_artifact_path(result_path)
                     normalized = self._load_metrics_file(resolved)
                     if normalized is not None:
                         await repo.update_run_metrics(run, normalized)
+                        metrics_persisted = True
 
-                if not run.metrics_json:
+                if not metrics_persisted:
                     guessed = self._guess_live_result_file_for_run(run)
                     if guessed is not None:
+                        await repo.add_result(
+                            run_id=run_id,
+                            artifact_type=TRAINING_RESULT_ARTIFACT,
+                            path=str(guessed),
+                            metadata_json={
+                                "source": "live_results_fallback",
+                                "artifact_timestamp": artifact_timestamp,
+                            },
+                        )
                         normalized = self._load_metrics_file(guessed)
                         if normalized is not None:
                             await repo.update_run_metrics(run, normalized)
@@ -645,17 +696,33 @@ def _runtime_log_dir(self) -> Path:
         path.mkdir(parents=True, exist_ok=True)
         return path
 
-    def _run_log_path(self, run_id: str) -> Path:
-        return self._runtime_log_dir() / f"{run_id}_server.log"
+    def _run_log_path(self, run_id: str, *, artifact_timestamp: str | None = None) -> Path:
+        if artifact_timestamp is None:
+            return self._runtime_log_dir() / f"{run_id}_server.log"
+        return self._runtime_log_dir() / run_log_filename(
+            run_id,
+            timestamp=artifact_timestamp,
+            role="server",
+        )
 
-    def _build_live_results_filename(self, run_id: str) -> str:
-        return f"live_results_{run_id}.json"
+    def _build_live_results_filename(self, run_id: str, *, artifact_timestamp: str | None = None) -> str:
+        if artifact_timestamp is None:
+            return f"live_results_{run_id}.json"
+        return live_results_filename(run_id, timestamp=artifact_timestamp)
 
-    def _run_config_path(self, run_id: str) -> Path:
-        return self._job_config_dir() / f"{run_id}.json"
+    def _run_config_path(self, run_id: str, *, artifact_timestamp: str | None = None) -> Path:
+        if artifact_timestamp is None:
+            return self._job_config_dir() / f"{run_id}.json"
+        return self._job_config_dir() / run_config_filename(run_id, timestamp=artifact_timestamp)
 
-    def _write_run_config(self, run_id: str, config_json: dict[str, Any]) -> Path:
-        path = self._run_config_path(run_id)
+    def _write_run_config(
+        self,
+        run_id: str,
+        config_json: dict[str, Any],
+        *,
+        artifact_timestamp: str | None = None,
+    ) -> Path:
+        path = self._run_config_path(run_id, artifact_timestamp=artifact_timestamp)
         path.write_text(json.dumps(config_json, ensure_ascii=False, indent=2), encoding="utf-8")
         return path
 
@@ -705,17 +772,23 @@ def _derive_final_status(current_status: AgentExperimentRunStatus, exit_code: in
         return AgentExperimentRunStatus.SUCCEEDED if exit_code == 0 else AgentExperimentRunStatus.FAILED
 
     def _cleanup_run_local_files(self, run_id: str) -> None:
-        for path in [
-            self._run_config_path(run_id),
-            self._results_dir() / self._build_live_results_filename(run_id),
-            self._run_log_path(run_id),
-        ]:
+        for path in self._matching_run_local_files(run_id):
             try:
                 if path.exists() and path.is_file():
                     path.unlink()
             except OSError:
                 continue
 
+    def _matching_run_local_files(self, run_id: str) -> list[Path]:
+        return [
+            *self._job_config_dir().glob(f"{run_id}*.json"),
+            *self._job_config_dir().glob(f"*_{run_id}.json"),
+            *self._results_dir().glob(f"live_results_{run_id}*.json"),
+            *self._results_dir().glob(f"*_{run_id}_live_results.json"),
+            *self._runtime_log_dir().glob(f"{run_id}*_server.log"),
+            *self._runtime_log_dir().glob(f"*_{run_id}_server.log"),
+        ]
+
     # -- metrics helpers (mirrored from SimulationRunMetricsService) ------
 
     @staticmethod
@@ -731,6 +804,18 @@ def _empty_metrics_payload() -> dict[str, Any]:
                 "global_loss": [],
                 "global_accuracy": [],
             },
+            "llm_results": {
+                "rounds": [],
+                "train_loss": [],
+                "validation_loss": [],
+                "perplexity": [],
+                "token_throughput": [],
+                "adapter_size_bytes": [],
+            },
+            "llm_dataset": {},
+            "llm_evaluation": {},
+            "llm_runtime": {},
+            "llm_artifacts": [],
             "client_results": {},
         }
 
@@ -755,27 +840,41 @@ def _guess_live_result_file_for_run(self, run: AgentExperimentRun) -> Path | Non
         directory = self._results_dir()
         if not directory.exists():
             return None
-        expected = directory / self._build_live_results_filename(run.id)
-        if expected.exists() and expected.is_file():
-            return expected
+        for expected in self._live_result_candidates_for_run(run):
+            if expected.exists() and expected.is_file():
+                return expected
 
         started_at = run.started_at or run.created_at
         if started_at is None:
             return None
         start_ts = started_at.timestamp()
         candidates: list[Path] = []
-        for path in directory.glob("live_results_*.json"):
-            try:
-                mtime = path.stat().st_mtime
-            except OSError:
-                continue
-            if mtime >= start_ts - 5:
-                candidates.append(path)
+        for pattern in ("*_live_results.json", "live_results_*.json"):
+            for path in directory.glob(pattern):
+                try:
+                    mtime = path.stat().st_mtime
+                except OSError:
+                    continue
+                if mtime >= start_ts - 5:
+                    candidates.append(path)
         if not candidates:
             return None
         candidates.sort(key=lambda p: p.stat().st_mtime, reverse=True)
         return candidates[0]
 
+    def _live_result_candidates_for_run(self, run: AgentExperimentRun) -> list[Path]:
+        directory = self._results_dir()
+        timestamped = directory / self._build_live_results_filename(
+            run.id,
+            artifact_timestamp=run_artifact_timestamp(run.created_at),
+        )
+        legacy_timestamped = directory / legacy_live_results_filename(
+            run.id,
+            timestamp=run_artifact_timestamp(run.created_at),
+        )
+        legacy = directory / self._build_live_results_filename(run.id)
+        return list(dict.fromkeys([timestamped, legacy_timestamped, legacy]))
+
     def _normalize_metrics_payload(self, payload: dict[str, Any]) -> dict[str, Any]:
         normalized = self._empty_metrics_payload()
 
@@ -794,6 +893,35 @@ def _normalize_metrics_payload(self, payload: dict[str, Any]) -> dict[str, Any]:
                 "global_accuracy": self._to_float_list(global_results.get("global_accuracy")),
             }
 
+        llm_results = payload.get("llm_results")
+        if isinstance(llm_results, dict):
+            normalized["llm_results"] = {
+                "rounds": self._to_int_list(llm_results.get("rounds")),
+                "train_loss": self._to_float_list(llm_results.get("train_loss")),
+                "validation_loss": self._to_float_list(llm_results.get("validation_loss")),
+                "perplexity": self._to_float_list(llm_results.get("perplexity")),
+                "token_throughput": self._to_float_list(llm_results.get("token_throughput")),
+                "adapter_size_bytes": self._to_int_list(llm_results.get("adapter_size_bytes")),
+            }
+
+        llm_dataset = payload.get("llm_dataset")
+        if isinstance(llm_dataset, dict):
+            normalized["llm_dataset"] = llm_dataset
+
+        llm_evaluation = payload.get("llm_evaluation")
+        if isinstance(llm_evaluation, dict):
+            normalized["llm_evaluation"] = llm_evaluation
+
+        llm_runtime = payload.get("llm_runtime")
+        if isinstance(llm_runtime, dict):
+            normalized["llm_runtime"] = llm_runtime
+
+        llm_artifacts = payload.get("llm_artifacts")
+        if isinstance(llm_artifacts, list):
+            normalized["llm_artifacts"] = [
+                artifact for artifact in llm_artifacts if isinstance(artifact, dict)
+            ]
+
         client_results = payload.get("client_results")
         if isinstance(client_results, dict):
             normalized_clients: dict[str, dict[str, list[float]]] = {}
@@ -801,6 +929,7 @@ def _normalize_metrics_payload(self, payload: dict[str, Any]) -> dict[str, Any]:
                 if not isinstance(client_name, str) or not isinstance(client_data, dict):
                     continue
                 normalized_clients[client_name] = {
+                    "rounds": self._to_int_list(client_data.get("rounds")),
                     "train_loss": self._to_float_list(client_data.get("train_loss")),
                     "train_acc": self._to_float_list(client_data.get("train_acc")),
                     "test_loss": self._to_float_list(client_data.get("test_loss")),
@@ -834,6 +963,10 @@ def _to_int_list(value: Any) -> list[int]:
                 continue
         return output
 
+    @staticmethod
+    def _stable_json(value: Any) -> str:
+        return json.dumps(value, sort_keys=True, ensure_ascii=False)
+
     # -- log level inference ---------------------------------------------
 
     @staticmethod
diff --git a/apps/backend/app/services/agent/graph.py b/apps/backend/app/services/agent/graph.py
index f9d305f..f704065 100644
--- a/apps/backend/app/services/agent/graph.py
+++ b/apps/backend/app/services/agent/graph.py
@@ -31,11 +31,13 @@
     build_schema_prompt_context,
     collect_disabled_option_errors,
     deep_merge_config,
+    lock_structured_constraints,
+    merge_llm_resource_constraints,
     select_llm_model,
 )
 from .prompts import build_plan_prompt, build_plan_system_instructions
 from .state import AgentState, ExperimentPlan, ExperimentRecord
-from .summary import build_results_table, build_summary_text, get_last_global_accuracy
+from .summary import build_results_table, build_summary_text, get_agent_run_score
 
 
 class FederatedAgentGraphBuilder:
@@ -86,6 +88,7 @@ async def _node_parse(self, state: AgentState) -> AgentState:
         constrained_base = experiment_service.normalize_simulation_config(
             deep_merge_config(base_config, state.config_constraints)
         )
+        effective_constraints = merge_llm_resource_constraints(constrained_base, state.config_constraints)
         disabled_errors = collect_disabled_option_errors(constrained_base, schema)
         if disabled_errors:
             raise exceptions.BadRequestError("; ".join(disabled_errors))
@@ -97,8 +100,12 @@ async def _node_parse(self, state: AgentState) -> AgentState:
                 raw_config = exp.get("config_patch", exp.get("config", {}))
                 if not isinstance(raw_config, dict):
                     raw_config = {}
+                merged = lock_structured_constraints(
+                    deep_merge_config(constrained_base, raw_config),
+                    effective_constraints,
+                )
                 normalized = experiment_service.normalize_simulation_config(
-                    deep_merge_config(constrained_base, raw_config)
+                    merged
                 )
                 disabled_errors = collect_disabled_option_errors(normalized, schema)
                 if disabled_errors:
@@ -127,7 +134,7 @@ async def _node_parse(self, state: AgentState) -> AgentState:
             capabilities=capabilities,
             base_config=constrained_base,
             schema_context=schema_context,
-            config_constraints=state.config_constraints,
+            config_constraints=effective_constraints,
         )
 
         logger.info("llm input instructions=%s", instructions)
@@ -165,8 +172,12 @@ async def _node_parse(self, state: AgentState) -> AgentState:
                         patch_config = exp.get("config", {})
                         if not isinstance(patch_config, dict):
                             patch_config = {}
-                        # Merge with constrained base config and normalize.
-                        merged = deep_merge_config(constrained_base, patch_config)
+                        # Merge with constrained base config, then re-apply
+                        # structured controls so prompt drift cannot override them.
+                        merged = lock_structured_constraints(
+                            deep_merge_config(constrained_base, patch_config),
+                            effective_constraints,
+                        )
                         try:
                             normalized = experiment_service.normalize_simulation_config(merged)
                             disabled_errors = collect_disabled_option_errors(normalized, schema)
@@ -222,6 +233,7 @@ async def _node_run_sequential(self, state: AgentState) -> AgentState:
         base_config = experiment_service.normalize_simulation_config(
             deep_merge_config(build_initial_config(schema), state.config_constraints)
         )
+        effective_constraints = merge_llm_resource_constraints(base_config, state.config_constraints)
 
         max_wait_seconds = 3600
         poll_interval = 2
@@ -232,7 +244,10 @@ async def _node_run_sequential(self, state: AgentState) -> AgentState:
             state.iteration = idx + 1
 
             # -- Build config --
-            merged = deep_merge_config(base_config, plan.config_patch)
+            merged = lock_structured_constraints(
+                deep_merge_config(base_config, plan.config_patch),
+                effective_constraints,
+            )
             config = experiment_service.normalize_simulation_config(merged)
             disabled_errors = collect_disabled_option_errors(config, schema)
             if disabled_errors:
@@ -295,7 +310,7 @@ async def _node_run_sequential(self, state: AgentState) -> AgentState:
                 name=plan.name,
                 iteration_goal=plan.iteration_goal,
                 plan_summary=plan.plan_summary,
-                score=get_last_global_accuracy(metrics),
+                score=get_agent_run_score(metrics),
                 decision="recorded",
             )
             state.experiment_results.append(record)
diff --git a/apps/backend/app/services/agent/history_service.py b/apps/backend/app/services/agent/history_service.py
index 7dce611..a9b4b96 100644
--- a/apps/backend/app/services/agent/history_service.py
+++ b/apps/backend/app/services/agent/history_service.py
@@ -5,6 +5,8 @@
 from __future__ import annotations
 
 import copy
+import hashlib
+import json
 from datetime import datetime
 from typing import Any
 
@@ -12,10 +14,11 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core import exceptions
-from app.models.agent import AgentOptimizationJob, AgentOptimizationJobStatus
-from app.repositories.agent import AgentOptimizationJobRepository
+from app.models.agent import AgentConfigVersion, AgentOptimizationJob, AgentOptimizationJobStatus
+from app.repositories.agent import AgentConfigVersionRepository, AgentOptimizationJobRepository
 
-from .summary import get_last_global_accuracy
+from .memory import compute_config_diff
+from .summary import get_agent_run_score
 
 
 class AgentOptimizationHistoryService:
@@ -26,6 +29,7 @@ class AgentOptimizationHistoryService:
     def __init__(self, session: AsyncSession):
         self.session = session
         self.repository = AgentOptimizationJobRepository(session)
+        self.config_version_repository = AgentConfigVersionRepository(session)
 
     async def create_job(
         self,
@@ -47,6 +51,7 @@ async def create_job(
             resolved_status = AgentOptimizationJobStatus(status.lower())
 
         try:
+            safe_snapshot = self._to_json_safe(snapshot)
             job = await self.repository.create_job(
                 task_id=task_id,
                 job_name=job_name,
@@ -55,8 +60,9 @@ async def create_job(
                 model_name=model_name,
                 status=resolved_status,
                 max_iterations=max_iterations,
-                snapshot_json=self._to_json_safe(snapshot),
+                snapshot_json=safe_snapshot,
             )
+            await self._sync_config_versions(job, safe_snapshot)
             await self.session.commit()
             await self.session.refresh(job)
             return job
@@ -64,8 +70,38 @@ async def create_job(
             await self.session.rollback()
             raise exceptions.JobAlreadyExists(self.JOB_NAME_CONFLICT_MESSAGE) from exc
 
-    async def list_jobs(self) -> list[AgentOptimizationJob]:
-        return await self.repository.list_jobs()
+    async def list_jobs(
+        self,
+        *,
+        status: AgentOptimizationJobStatus | str | None = None,
+        q: str | None = None,
+        model_name: str | None = None,
+        objective: str | None = None,
+        best_score_min: float | None = None,
+        best_score_max: float | None = None,
+        created_from: datetime | None = None,
+        created_to: datetime | None = None,
+        config_filters: dict[str, Any] | None = None,
+    ) -> list[AgentOptimizationJob]:
+        resolved_status = self._resolve_status(status)
+        jobs = await self.repository.list_jobs(
+            status=resolved_status,
+            q=q,
+            model_name=model_name,
+            best_score_min=best_score_min,
+            best_score_max=best_score_max,
+            created_from=created_from,
+            created_to=created_to,
+        )
+        return [
+            job
+            for job in jobs
+            if self._matches_snapshot_filters(
+                job.snapshot_json if isinstance(job.snapshot_json, dict) else {},
+                objective=objective,
+                config_filters=config_filters or {},
+            )
+        ]
 
     async def get_job_or_raise(self, optimization_job_id: int) -> AgentOptimizationJob:
         job = await self.repository.get_job(optimization_job_id)
@@ -93,9 +129,10 @@ async def update_job_snapshot(
         status = AgentOptimizationJobStatus(str(snapshot.get("status", AgentOptimizationJobStatus.QUEUED.value)))
         finished_at = snapshot.get("finished_at") if snapshot.get("finished_at") is not None else ...
         best_metrics = snapshot.get("best_metrics")
-        best_score = get_last_global_accuracy(best_metrics) if isinstance(best_metrics, dict) else None
+        best_score = get_agent_run_score(best_metrics) if isinstance(best_metrics, dict) else None
 
         try:
+            safe_snapshot = self._to_json_safe(snapshot)
             await self.repository.update_job(
                 job,
                 job_name=str(job_name) if job_name is not None else None,
@@ -105,9 +142,10 @@ async def update_job_snapshot(
                 completed_iterations=int(snapshot.get("completed_iterations") or 0),
                 simulation_job_id=self._extract_simulation_job_id(snapshot),
                 best_score=best_score,
-                snapshot_json=self._to_json_safe(snapshot),
+                snapshot_json=safe_snapshot,
                 finished_at=finished_at,
             )
+            await self._sync_config_versions(job, safe_snapshot)
             await self.session.commit()
             await self.session.refresh(job)
             return job
@@ -132,6 +170,241 @@ async def _ensure_unique_job_name(self, job_name: str, *, exclude_job_id: int |
                 await self.session.flush()
             else:
                 raise exceptions.JobAlreadyExists(self.JOB_NAME_CONFLICT_MESSAGE)
+
+    async def list_config_versions(self, optimization_job_id: int) -> list[AgentConfigVersion]:
+        job = await self.get_job_or_raise(optimization_job_id)
+        versions = await self.config_version_repository.list_versions(optimization_job_id, source="experiment")
+        if versions:
+            return versions
+        snapshot = job.snapshot_json if isinstance(job.snapshot_json, dict) else {}
+        if not self._build_config_version_candidates(snapshot):
+            return []
+        await self._sync_config_versions(job, snapshot)
+        await self.session.commit()
+        return await self.config_version_repository.list_versions(optimization_job_id, source="experiment")
+
+    async def get_config_version_or_raise(self, optimization_job_id: int, version_id: int) -> AgentConfigVersion:
+        await self.get_job_or_raise(optimization_job_id)
+        version = await self.config_version_repository.get_version(version_id)
+        if version is None or version.optimization_job_id != optimization_job_id:
+            raise exceptions.ResourceNotFound("Agent config version not found")
+        return version
+
+    async def diff_config_versions(
+        self,
+        *,
+        optimization_job_id: int,
+        from_version_id: int | None,
+        to_version_id: int,
+    ) -> list[dict[str, Any]]:
+        to_version = await self.get_config_version_or_raise(optimization_job_id, to_version_id)
+        previous_config = None
+        if from_version_id is not None:
+            from_version = await self.get_config_version_or_raise(optimization_job_id, from_version_id)
+            previous_config = from_version.config_json if isinstance(from_version.config_json, dict) else {}
+        changes = compute_config_diff(previous_config, to_version.config_json if isinstance(to_version.config_json, dict) else {})
+        return [self._serialize_config_change(change) for change in changes]
+
+    async def _sync_config_versions(self, job: AgentOptimizationJob, snapshot: dict[str, Any]) -> None:
+        if job.id is None:
+            return
+        for candidate in self._build_config_version_candidates(snapshot):
+            existing = await self.config_version_repository.find_version(
+                optimization_job_id=job.id,
+                run_id=candidate["run_id"],
+                iteration=candidate["iteration"],
+                source=candidate["source"],
+                config_hash=candidate["config_hash"],
+            )
+            if existing is not None:
+                continue
+            await self.config_version_repository.create_version(
+                optimization_job_id=job.id,
+                run_id=candidate["run_id"],
+                iteration=candidate["iteration"],
+                source=candidate["source"],
+                label=candidate["label"],
+                config_hash=candidate["config_hash"],
+                config_json=candidate["config_json"],
+                diff_json=candidate["diff_json"],
+            )
+
+    @classmethod
+    def _build_config_version_candidates(cls, snapshot: dict[str, Any]) -> list[dict[str, Any]]:
+        candidates: list[dict[str, Any]] = []
+        previous_config: dict[str, Any] | None = None
+
+        experiments = snapshot.get("experiments")
+        if isinstance(experiments, list):
+            for index, item in enumerate(experiments, start=1):
+                if not isinstance(item, dict):
+                    continue
+                config = item.get("config")
+                if not isinstance(config, dict):
+                    continue
+                candidates.append(
+                    cls._build_config_version_candidate(
+                        config=config,
+                        previous_config=previous_config,
+                        iteration=int(item.get("iteration") or index),
+                        source="experiment",
+                        run_id=str(item.get("run_id")) if item.get("run_id") is not None else None,
+                        label=str(item.get("name") or item.get("plan_summary") or f"Experiment {index}"),
+                        diff_json=item.get("config_diff"),
+                    )
+                )
+                previous_config = config
+
+        return candidates
+
+    @classmethod
+    def _build_config_version_candidate(
+        cls,
+        *,
+        config: dict[str, Any],
+        previous_config: dict[str, Any] | None,
+        iteration: int,
+        source: str,
+        run_id: str | None,
+        label: str,
+        diff_json: Any,
+    ) -> dict[str, Any]:
+        safe_config = cls._to_json_safe(config)
+        if isinstance(diff_json, list):
+            safe_diff = cls._to_json_safe(diff_json)
+        else:
+            safe_diff = [
+                cls._serialize_config_change(change)
+                for change in compute_config_diff(previous_config, safe_config)
+            ]
+        return {
+            "run_id": run_id,
+            "iteration": iteration,
+            "source": source,
+            "label": label[:255],
+            "config_hash": cls._config_hash(safe_config),
+            "config_json": safe_config,
+            "diff_json": safe_diff,
+        }
+
+    @staticmethod
+    def _best_snapshot_experiment(snapshot: dict[str, Any]) -> dict[str, Any] | None:
+        experiments = snapshot.get("experiments")
+        if not isinstance(experiments, list):
+            return None
+        best_record = None
+        best_score = None
+        for item in experiments:
+            if not isinstance(item, dict):
+                continue
+            score = item.get("score")
+            if score is None:
+                continue
+            try:
+                numeric_score = float(score)
+            except (TypeError, ValueError):
+                continue
+            if best_score is None or numeric_score > best_score:
+                best_record = item
+                best_score = numeric_score
+        return best_record
+
+    @staticmethod
+    def _serialize_config_change(change: Any) -> dict[str, Any]:
+        if isinstance(change, dict):
+            return {
+                "path": str(change.get("path", "$")),
+                "change_type": str(change.get("change_type", "updated")),
+                "old_value": copy.deepcopy(change.get("old_value")),
+                "new_value": copy.deepcopy(change.get("new_value")),
+            }
+        return {
+            "path": change.path,
+            "change_type": change.change_type,
+            "old_value": copy.deepcopy(change.old_value),
+            "new_value": copy.deepcopy(change.new_value),
+        }
+
+    @staticmethod
+    def _config_hash(config: dict[str, Any]) -> str:
+        payload = json.dumps(config, sort_keys=True, separators=(",", ":"), default=str)
+        return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+    @classmethod
+    def _resolve_status(cls, status: AgentOptimizationJobStatus | str | None) -> AgentOptimizationJobStatus | None:
+        if status is None:
+            return None
+        if isinstance(status, AgentOptimizationJobStatus):
+            return status
+        status_text = str(status).strip().lower()
+        if not status_text or status_text == "all":
+            return None
+        return AgentOptimizationJobStatus(status_text)
+
+    @classmethod
+    def _matches_snapshot_filters(
+        cls,
+        snapshot: dict[str, Any],
+        *,
+        objective: str | None,
+        config_filters: dict[str, Any],
+    ) -> bool:
+        if objective and str(snapshot.get("objective", "")).lower() != objective.lower():
+            return False
+        for path, expected in config_filters.items():
+            if expected is None or str(expected).strip() == "":
+                continue
+            if not cls._snapshot_has_config_value(snapshot, path, expected):
+                return False
+        return True
+
+    @classmethod
+    def _snapshot_has_config_value(cls, snapshot: dict[str, Any], path: str, expected: Any) -> bool:
+        for config in cls._iter_snapshot_configs(snapshot):
+            value = cls._get_value_by_path(config, path)
+            if value is not None and cls._values_equal(value, expected):
+                return True
+        return False
+
+    @classmethod
+    def _iter_snapshot_configs(cls, snapshot: dict[str, Any]):
+        for key in ("best_config", "config_constraints"):
+            value = snapshot.get(key)
+            if isinstance(value, dict):
+                yield value
+        current_experiment = snapshot.get("current_experiment")
+        if isinstance(current_experiment, dict) and isinstance(current_experiment.get("config"), dict):
+            yield current_experiment["config"]
+        for collection_key in ("experiments", "draft_experiments"):
+            collection = snapshot.get(collection_key)
+            if not isinstance(collection, list):
+                continue
+            for item in collection:
+                if not isinstance(item, dict):
+                    continue
+                for config_key in ("config", "config_patch"):
+                    config = item.get(config_key)
+                    if isinstance(config, dict):
+                        yield config
+
+    @staticmethod
+    def _get_value_by_path(obj: dict[str, Any], path: str) -> Any:
+        current: Any = obj
+        for part in path.split("."):
+            if not isinstance(current, dict) or part not in current:
+                return None
+            current = current[part]
+        return current
+
+    @staticmethod
+    def _values_equal(actual: Any, expected: Any) -> bool:
+        if isinstance(actual, (int, float)) and isinstance(expected, str):
+            try:
+                return float(actual) == float(expected)
+            except ValueError:
+                return False
+        return str(actual).lower() == str(expected).lower()
+
     @staticmethod
     def _extract_simulation_job_id(snapshot: dict[str, Any]) -> int | None:
         current_experiment = snapshot.get("current_experiment")
diff --git a/apps/backend/app/services/agent/objectives.py b/apps/backend/app/services/agent/objectives.py
index 583b0cd..56d6724 100644
--- a/apps/backend/app/services/agent/objectives.py
+++ b/apps/backend/app/services/agent/objectives.py
@@ -1,14 +1,13 @@
 """
 Objective helpers for the bench-mode experiment executor.
 
-Bench mode does not optimize — it runs experiments and reports results.
-The objective system is kept minimal for compatibility.
+Bench mode runs a planned batch of experiments and reports comparable scores.
+The objective surface is intentionally small for API compatibility.
 """
 
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any
 
 
 class AgentOptimizationObjective(str, Enum):
@@ -35,7 +34,11 @@ def resolve_objective(
     goal: str,
     requested_objective: str | AgentOptimizationObjective | None,
 ) -> AgentOptimizationObjective:
-    """Resolve the effective objective — always accuracy in bench mode."""
+    """Resolve the effective objective.
+
+    LLM PEFT runs are scored by negative loss in the summary layer, but the
+    public objective enum remains accuracy-only for the current Agent API.
+    """
     return AgentOptimizationObjective.ACCURACY
 
 
@@ -57,7 +60,7 @@ def is_better_score(
     candidate_score: float | None,
     reference_score: float | None,
 ) -> bool:
-    """Higher accuracy is always better in bench mode."""
+    """Higher comparable score is better."""
     if candidate_score is None:
         return False
     if reference_score is None:
diff --git a/apps/backend/app/services/agent/planning.py b/apps/backend/app/services/agent/planning.py
index c66570c..20e0615 100644
--- a/apps/backend/app/services/agent/planning.py
+++ b/apps/backend/app/services/agent/planning.py
@@ -48,8 +48,9 @@ def build_initial_config(schema: dict[str, Any]) -> dict[str, Any]:
     """
     if not schema:
         return {
+            "task": {"type": "classic_fl"},
             "dataset": {"name": "CIFAR-10", "distribution": "non_iid", "alpha": 0.5},
-            "model": {"name": "CNN"},
+            "model": {"name": "Auto"},
             "federated": {
                 "num_clients": 3,
                 "num_rounds": 10,
@@ -88,6 +89,77 @@ def deep_merge_config(base: dict[str, Any], override: dict[str, Any] | None) ->
     return merged
 
 
+def lock_structured_constraints(config: dict[str, Any], constraints: dict[str, Any] | None) -> dict[str, Any]:
+    """Apply user-selected structured constraints as final locked values."""
+    if not isinstance(constraints, dict) or not constraints:
+        return copy.deepcopy(config)
+    return deep_merge_config(config, constraints)
+
+
+def infer_sft_settings_for_dataset_path(dataset_path: str) -> dict[str, str]:
+    """Infer hidden SFT format selectors from a concrete dataset path."""
+    normalized = dataset_path.strip().lower()
+    if normalized.endswith(".jsonl"):
+        file_format = "jsonl"
+    elif normalized.endswith(".parquet"):
+        file_format = "parquet"
+    else:
+        file_format = "auto"
+
+    if "alpaca" in normalized:
+        data_format = "alpaca"
+    elif "messages" in normalized or "chat" in normalized:
+        data_format = "messages"
+    else:
+        data_format = "prompt_completion"
+
+    return {"file_format": file_format, "format": data_format}
+
+
+def llm_resource_constraints_from_config(config: dict[str, Any]) -> dict[str, Any]:
+    """Lock concrete LLM PEFT resources from the effective base config."""
+    task = config.get("task")
+    if not isinstance(task, dict) or task.get("type") != "llm_peft_sft":
+        return {}
+
+    constraints: dict[str, Any] = {"task": {"type": "llm_peft_sft"}}
+    llm = config.get("llm")
+    if isinstance(llm, dict) and isinstance(llm.get("base_model"), str) and llm["base_model"].strip():
+        constraints["llm"] = {"base_model": llm["base_model"]}
+
+    sft = config.get("sft")
+    if isinstance(sft, dict) and isinstance(sft.get("dataset_path"), str) and sft["dataset_path"].strip():
+        constraints["sft"] = {
+            "dataset_path": sft["dataset_path"],
+            **infer_sft_settings_for_dataset_path(sft["dataset_path"]),
+        }
+
+    evaluation = config.get("evaluation")
+    if isinstance(evaluation, dict):
+        evaluation_constraints: dict[str, Any] = {}
+        if isinstance(evaluation.get("enable"), bool):
+            evaluation_constraints["enable"] = evaluation["enable"]
+        if (
+            evaluation.get("enable") is True
+            and isinstance(evaluation.get("dataset_path"), str)
+            and evaluation["dataset_path"].strip()
+        ):
+            evaluation_constraints["dataset_path"] = evaluation["dataset_path"]
+        if evaluation_constraints:
+            constraints["evaluation"] = evaluation_constraints
+
+    return constraints
+
+
+def merge_llm_resource_constraints(
+    config: dict[str, Any],
+    constraints: dict[str, Any] | None,
+) -> dict[str, Any]:
+    """Merge effective LLM resource defaults with explicit user constraints."""
+    resource_constraints = llm_resource_constraints_from_config(config)
+    return deep_merge_config(resource_constraints, constraints or {})
+
+
 def _option_ui(definition: dict[str, Any]) -> dict[str, Any]:
     ui = definition.get("ui")
     if not isinstance(ui, dict):
diff --git a/apps/backend/app/services/agent/prompts/__init__.py b/apps/backend/app/services/agent/prompts/__init__.py
index 73a3276..a7ebb78 100644
--- a/apps/backend/app/services/agent/prompts/__init__.py
+++ b/apps/backend/app/services/agent/prompts/__init__.py
@@ -48,7 +48,12 @@ def build_plan_prompt(
         f"Default base config after applying user constraints:\n{dumps_for_prompt(base_config)}\n\n"
         f"User-selected structured constraints:\n{dumps_for_prompt(constraints)}\n\n"
         "Parse the request into experiment configurations.\n"
-        "Every experiment must inherit the structured constraints unless the user's request explicitly changes them.\n"
+        "User-selected structured constraints are locked controls and have higher priority than natural-language text.\n"
+        "Every experiment must inherit the structured constraints. If text conflicts with them, keep the structured constraints.\n"
         "Use executable_options for select fields. Do not use disabled_options.\n"
+        "For LLM PEFT simulation requests, set task.type=\"llm_peft_sft\" and use llm/sft/peft/federated fields.\n"
+        "For LLM validation or perplexity requests, set evaluation.enable=true and include evaluation.dataset_path when available.\n"
+        "Respect dataset_model_compatibility. Use model.name=\"Auto\" when the user changes dataset without naming a model.\n"
+        "Respect privacy/compression compatibility rules from Runtime capabilities.\n"
         "Return ONLY a JSON object with plan_summary and experiments list, no commentary."
     )
diff --git a/apps/backend/app/services/agent/prompts/plan_instructions.txt b/apps/backend/app/services/agent/prompts/plan_instructions.txt
index 316aaa1..b624d30 100644
--- a/apps/backend/app/services/agent/prompts/plan_instructions.txt
+++ b/apps/backend/app/services/agent/prompts/plan_instructions.txt
@@ -5,9 +5,15 @@ Rules:
 - Treat config_schema.yaml as the source of truth for fields, defaults, selectable options, and disabled future options.
 - If the user mentions multiple parameter values, generate one experiment per value.
 - If the user mentions multiple dimensions, generate the Cartesian product.
-- If the user does not specify a field, inherit the default base config and structured constraints from the prompt.
+- User-selected structured constraints are locked controls. Every experiment must inherit them, even if the natural-language text or an example mentions a different value.
+- If the user does not specify a field, inherit the default base config from the prompt.
 - Each experiment's "config" should contain the actual parameter values that make that experiment distinct.
 - Do not use any option listed under disabled_options.
+- For LLM PEFT simulation requests, set task.type="llm_peft_sft" and use the llm, sft, peft, and federated fields. Do not vary classic dataset/model/privacy/compression fields unless the user explicitly asks for the classic FL route.
+- For LLM PEFT validation or perplexity requests, set evaluation.enable=true and provide evaluation.dataset_path when the user names a validation JSONL file.
+- Respect Runtime capabilities, especially dataset_model_compatibility and privacy/compression/aggregation compatibility.
+- Never combine CKKS with compression or secure aggregation. Secure aggregation is only valid with fedavg/simple_avg in simulation. Differential privacy can be combined with supported compression/encryption.
+- If the user changes dataset but does not ask for a model, use model.name="Auto" or the dataset's default_model.
 - `federated.seed` controls random seed for full reproducibility. Do not vary it unless the user asks for repeats, variance, or specific seeds.
 - Return ONLY a JSON object with:
   - "plan_summary": brief description of what will be tested
@@ -15,7 +21,7 @@ Rules:
 
 Example: user says "test alpha=0.1, 0.3, 0.5":
 {
-  "plan_summary": "Compare non-IID alpha values 0.1, 0.3, 0.5 on CIFAR-10",
+  "plan_summary": "Compare non-IID alpha values 0.1, 0.3, 0.5 on the selected dataset",
   "experiments": [
     {"name": "alpha_0.1", "config": {"dataset": {"alpha": 0.1}}},
     {"name": "alpha_0.3", "config": {"dataset": {"alpha": 0.3}}},
diff --git a/apps/backend/app/services/agent/summary.py b/apps/backend/app/services/agent/summary.py
index 04e0b5c..16a3d59 100644
--- a/apps/backend/app/services/agent/summary.py
+++ b/apps/backend/app/services/agent/summary.py
@@ -19,12 +19,63 @@ def get_last_global_accuracy(metrics: dict[str, Any]) -> float | None:
     return float(last) if isinstance(last, (int, float)) else None
 
 
+def get_last_llm_train_loss(metrics: dict[str, Any]) -> float | None:
+    """Extract the final LLM train loss from run metrics."""
+    llm_results = metrics.get("llm_results") or {}
+    train_loss = llm_results.get("train_loss") or []
+    if not train_loss:
+        return None
+    last = train_loss[-1]
+    return float(last) if isinstance(last, (int, float)) else None
+
+
+def get_last_llm_validation_loss(metrics: dict[str, Any]) -> float | None:
+    """Extract the final non-zero LLM validation loss from run metrics."""
+    llm_results = metrics.get("llm_results") or {}
+    validation_loss = llm_results.get("validation_loss") or []
+    for value in reversed(validation_loss):
+        if isinstance(value, (int, float)) and float(value) > 0:
+            return float(value)
+    return None
+
+
+def get_last_llm_loss(metrics: dict[str, Any]) -> float | None:
+    """Return validation loss when present, otherwise train loss."""
+    return get_last_llm_validation_loss(metrics) or get_last_llm_train_loss(metrics)
+
+
+def get_agent_run_score(metrics: dict[str, Any]) -> float | None:
+    """Return the comparable score used by Agent result ranking.
+
+    Classic FL keeps higher-is-better accuracy. LLM PEFT uses negative loss
+    so lower loss ranks higher while preserving the same max() flow.
+    """
+    llm_loss = get_last_llm_loss(metrics)
+    if llm_loss is not None:
+        return -llm_loss
+    return get_last_global_accuracy(metrics)
+
+
 def _format_score(value: float | None) -> str:
     if value is None:
         return "-"
     return f"{value:.4f}"
 
 
+def _is_llm_record(record: ExperimentRecord) -> bool:
+    return get_last_llm_loss(record.metrics) is not None
+
+
+def _format_record_metric(record: ExperimentRecord) -> str:
+    validation_loss = get_last_llm_validation_loss(record.metrics)
+    if validation_loss is not None:
+        return f"val_loss={validation_loss:.4f}"
+    llm_loss = get_last_llm_train_loss(record.metrics)
+    if llm_loss is not None:
+        return f"train_loss={llm_loss:.4f}"
+    return _format_score(record.score)
+
+
 def _get_federated_summary(config: dict[str, Any]) -> str:
     federated = config.get("federated") or {}
     if not isinstance(federated, dict):
@@ -49,15 +100,17 @@ def build_results_table(state: AgentState) -> str:
         return "No experiment results available."
 
     lines: list[str] = []
-    header = f"{'Name':<30} {'Accuracy':<12} {'Rounds':<8} {'Config Summary'}"
+    metric_header = "Metric" if any(_is_llm_record(record) for record in state.experiment_results) else "Accuracy"
+    header = f"{'Name':<30} {metric_header:<12} {'Rounds':<8} {'Config Summary'}"
     lines.append(header)
     lines.append("-" * len(header))
 
     for record in state.experiment_results:
         name = record.name or f"exp-{record.iteration}"
-        score = _format_score(record.score)
+        score = _format_record_metric(record)
         global_results = record.metrics.get("global_results") or {}
-        rounds = len(global_results.get("rounds") or [])
+        llm_results = record.metrics.get("llm_results") or {}
+        rounds = len((llm_results.get("rounds") if isinstance(llm_results, dict) else None) or global_results.get("rounds") or [])
         config_summary = _get_federated_summary(record.config)
         lines.append(f"{name:<30} {score:<12} {rounds:<8} {config_summary}")
 
@@ -78,12 +131,20 @@ def build_summary_text(*, state: AgentState) -> str:
     if scored:
         best = max(scored, key=lambda r: r.score)  # type: ignore[arg-type]
         worst = min(scored, key=lambda r: r.score)  # type: ignore[arg-type]
-        lines.append(
-            f"Best accuracy: {_format_score(best.score)} ({best.name or f'exp-{best.iteration}'})"
-        )
-        lines.append(
-            f"Worst accuracy: {_format_score(worst.score)} ({worst.name or f'exp-{worst.iteration}'})"
-        )
+        if any(_is_llm_record(record) for record in scored):
+            lines.append(
+                f"Best LLM loss: {_format_record_metric(best)} ({best.name or f'exp-{best.iteration}'})"
+            )
+            lines.append(
+                f"Worst LLM loss: {_format_record_metric(worst)} ({worst.name or f'exp-{worst.iteration}'})"
+            )
+        else:
+            lines.append(
+                f"Best accuracy: {_format_score(best.score)} ({best.name or f'exp-{best.iteration}'})"
+            )
+            lines.append(
+                f"Worst accuracy: {_format_score(worst.score)} ({worst.name or f'exp-{worst.iteration}'})"
+            )
 
     lines.append("")
     lines.append(build_results_table(state))
@@ -156,4 +217,4 @@ def get_best_experiment(state: AgentState) -> ExperimentRecord | None:
     scored = [r for r in state.experiment_results if r.score is not None]
     if not scored:
         return None
-    return max(scored, key=lambda r: r.score)
\ No newline at end of file
+    return max(scored, key=lambda r: r.score)
diff --git a/apps/backend/app/services/distributed/config_service.py b/apps/backend/app/services/distributed/config_service.py
index cd8e14e..bf091d9 100644
--- a/apps/backend/app/services/distributed/config_service.py
+++ b/apps/backend/app/services/distributed/config_service.py
@@ -10,6 +10,7 @@
 from typing import Any
 
 from app.core import exceptions
+from app.services.simulation.compatibility import validate_llm_simulation_mode_or_raise
 from app.services.simulation.job_service import SimulationJobService
 
 
@@ -41,6 +42,7 @@ def normalize_server_config(cls, config_json: dict[str, Any]) -> dict[str, Any]:
         expected_clients = cls.extract_expected_clients(normalized)
         cls._set_value_by_path(normalized, "federated.num_clients", expected_clients)
         cls._set_value_by_path(normalized, "dataset.num_clients", expected_clients)
+        validate_llm_simulation_mode_or_raise(normalized)
         return normalized
 
 
@@ -86,6 +88,7 @@ def build_participant_runtime_config(
         cls._set_value_by_path(normalized, "distributed.client_id", assigned_participant_id)
         cls._set_value_by_path(normalized, "federated.num_clients", expected_clients)
         cls._set_value_by_path(normalized, "dataset.num_clients", expected_clients)
+        validate_llm_simulation_mode_or_raise(normalized)
         return normalized
 
 
@@ -117,7 +120,7 @@ def _init_defaults_from_schema(cls, schema: dict[str, Any]) -> dict[str, Any]:
         """
         output: dict[str, Any] = {}
         for key, raw_definition in schema.items():
-            if key in {"role", "depends_on", "hidden"}:
+            if key in {"role", "depends_on", "hidden", "ui"}:
                 continue
             if not isinstance(raw_definition, dict):
                 continue
diff --git a/apps/backend/app/services/llm_resources.py b/apps/backend/app/services/llm_resources.py
new file mode 100644
index 0000000..8452621
--- /dev/null
+++ b/apps/backend/app/services/llm_resources.py
@@ -0,0 +1,215 @@
+"""Local LLM model and dataset discovery for schema-backed UI options."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+LLM_MODEL_ROOT = Path("models") / "llm"
+LLM_DATASET_ROOT = Path("datasets") / "llm"
+DEFAULT_LLM_BASE_MODEL = "Qwen/Qwen2.5-0.5B-Instruct"
+DEFAULT_LLM_DATASET_PATH = "./datasets/llm/train.jsonl"
+DEFAULT_LLM_EVALUATION_DATASET_PATH = "./datasets/llm/validation.jsonl"
+SFT_DATASET_SUFFIXES = {".jsonl", ".parquet"}
+EVALUATION_DATASET_MARKERS = ("eval", "valid", "validation")
+
+
+def discover_llm_model_options(project_root: Path) -> list[str]:
+    """Return local model directory paths under models/llm as schema option values."""
+    root = project_root / LLM_MODEL_ROOT
+    if not root.exists() or not root.is_dir():
+        return []
+
+    candidates: list[Path] = []
+    for child in root.iterdir():
+        if child.is_dir() and _is_visible_relative(child, project_root):
+            candidates.append(child)
+
+    for config_file in root.rglob("config.json"):
+        model_dir = _model_option_dir_for_config(config_file, root)
+        if model_dir.is_dir() and _is_visible_relative(model_dir, project_root):
+            candidates.append(model_dir)
+
+    return _unique_sorted_relative_options(candidates, project_root)
+
+
+def discover_llm_dataset_options(project_root: Path) -> list[str]:
+    """Return local SFT training files and dataset directories under datasets/llm."""
+    return _discover_llm_dataset_options(project_root, include_evaluation_files=False)
+
+
+def discover_llm_evaluation_dataset_options(project_root: Path) -> list[str]:
+    """Return local evaluation files and dataset directories under datasets/llm."""
+    return _discover_llm_dataset_options(project_root, include_evaluation_files=True)
+
+
+def get_llm_resource_options(project_root: Path) -> dict[str, Any]:
+    """Return dynamic local LLM resource options for API and schema callers."""
+    model_options = discover_llm_model_options(project_root)
+    dataset_options = discover_llm_dataset_options(project_root)
+    evaluation_dataset_options = discover_llm_evaluation_dataset_options(project_root)
+    return {
+        "models": model_options,
+        "datasets": dataset_options,
+        "evaluation_datasets": evaluation_dataset_options,
+        "default_model": model_options[0] if model_options else "",
+        "default_dataset": dataset_options[0] if dataset_options else "",
+        "default_evaluation_dataset": _preferred_evaluation_dataset(evaluation_dataset_options),
+    }
+
+
+def augment_config_schema_with_llm_resources(schema: dict[str, Any], project_root: Path) -> dict[str, Any]:
+    """Inject discovered local LLM resource options into the mutable config schema."""
+    resources = get_llm_resource_options(project_root)
+
+    _set_field_options(
+        schema,
+        ("llm", "base_model"),
+        resources["models"],
+        source_dir=f"./{LLM_MODEL_ROOT.as_posix()}",
+        default_value=resources["default_model"],
+        empty_message="No local models found",
+    )
+    _set_field_options(
+        schema,
+        ("sft", "dataset_path"),
+        resources["datasets"],
+        source_dir=f"./{LLM_DATASET_ROOT.as_posix()}",
+        default_value=resources["default_dataset"],
+        empty_message="No training datasets found",
+    )
+    _set_field_options(
+        schema,
+        ("evaluation", "dataset_path"),
+        resources["evaluation_datasets"],
+        source_dir=f"./{LLM_DATASET_ROOT.as_posix()}",
+        default_value=resources["default_evaluation_dataset"],
+        empty_message="No evaluation datasets found",
+    )
+    _set_field_default(schema, ("evaluation", "enable"), bool(resources["default_evaluation_dataset"]))
+    return schema
+
+
+def _discover_llm_dataset_options(project_root: Path, *, include_evaluation_files: bool) -> list[str]:
+    root = project_root / LLM_DATASET_ROOT
+    if not root.exists() or not root.is_dir():
+        return []
+
+    candidates: list[Path] = []
+    for path in root.rglob("*"):
+        if (
+            not path.is_file()
+            or path.suffix.lower() not in SFT_DATASET_SUFFIXES
+            or not _is_visible_relative(path, project_root)
+        ):
+            continue
+        if not include_evaluation_files and _is_evaluation_dataset(path):
+            continue
+        if path.suffix.lower() == ".parquet":
+            dataset_dir = _dataset_option_dir_for_parquet(path, root)
+            if dataset_dir is not None and _is_visible_relative(dataset_dir, project_root):
+                candidates.append(dataset_dir)
+                continue
+        candidates.append(path)
+    return _unique_sorted_relative_options(candidates, project_root)
+
+
+def _model_option_dir_for_config(config_file: Path, model_root: Path) -> Path:
+    try:
+        relative = config_file.relative_to(model_root)
+    except ValueError:
+        return config_file.parent
+
+    parts = relative.parts
+    if "snapshots" in parts:
+        snapshot_index = parts.index("snapshots")
+        if snapshot_index > 0:
+            return model_root.joinpath(*parts[:snapshot_index])
+    return config_file.parent
+
+
+def _dataset_option_dir_for_parquet(path: Path, dataset_root: Path) -> Path | None:
+    try:
+        relative = path.relative_to(dataset_root)
+    except ValueError:
+        return None
+    if len(relative.parts) <= 1:
+        return None
+    return dataset_root / relative.parts[0]
+
+
+def _set_field_options(
+    schema: dict[str, Any],
+    path: tuple[str, ...],
+    options: list[str],
+    *,
+    source_dir: str,
+    default_value: str,
+    empty_message: str,
+) -> None:
+    node: Any = schema
+    for part in path:
+        if not isinstance(node, dict):
+            return
+        node = node.get(part)
+    if not isinstance(node, dict):
+        return
+
+    node["options"] = options
+    node["default"] = default_value
+    ui = node.setdefault("ui", {})
+    if isinstance(ui, dict):
+        ui["option_source"] = {
+            "type": "local_directory",
+            "path": source_dir,
+        }
+        ui["empty_message"] = empty_message
+
+
+def _preferred_evaluation_dataset(dataset_options: list[str]) -> str:
+    for option in dataset_options:
+        if _is_evaluation_option(option):
+            return option
+    return ""
+
+
+def _is_evaluation_option(option: str) -> bool:
+    stem = Path(option).stem.lower()
+    return any(marker in stem for marker in EVALUATION_DATASET_MARKERS)
+
+
+def _is_evaluation_dataset(path: Path) -> bool:
+    stem = path.stem.lower()
+    return any(marker in stem for marker in EVALUATION_DATASET_MARKERS)
+
+
+def _set_field_default(schema: dict[str, Any], path: tuple[str, ...], default_value: Any) -> None:
+    node: Any = schema
+    for part in path:
+        if not isinstance(node, dict):
+            return
+        node = node.get(part)
+    if isinstance(node, dict):
+        node["default"] = default_value
+
+
+def _unique_sorted_relative_options(paths: list[Path], project_root: Path) -> list[str]:
+    options = {_relative_option(path, project_root) for path in paths}
+    return sorted(options, key=str.lower)
+
+
+def _relative_option(path: Path, project_root: Path) -> str:
+    try:
+        relative = path.relative_to(project_root)
+    except ValueError:
+        return path.as_posix()
+    return f"./{relative.as_posix()}"
+
+
+def _is_visible_relative(path: Path, project_root: Path) -> bool:
+    try:
+        relative = path.relative_to(project_root)
+    except ValueError:
+        return False
+    return all(part and not part.startswith(".") for part in relative.parts)
diff --git a/apps/backend/app/services/run_artifacts.py b/apps/backend/app/services/run_artifacts.py
new file mode 100644
index 0000000..ae2907d
--- /dev/null
+++ b/apps/backend/app/services/run_artifacts.py
@@ -0,0 +1,39 @@
+"""Shared naming helpers for run-local config, log, and result files."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+
+def run_artifact_timestamp(value: datetime | None = None) -> str:
+    """Return a stable UTC timestamp prefix for one run's local artifacts."""
+    moment = value or datetime.now(timezone.utc)
+    if moment.tzinfo is None:
+        moment = moment.replace(tzinfo=timezone.utc)
+    else:
+        moment = moment.astimezone(timezone.utc)
+    return moment.strftime("%Y%m%d_%H%M%SZ")
+
+
+def run_artifact_stem(run_id: str, *, timestamp: str) -> str:
+    return f"{timestamp}_{run_id}"
+
+
+def legacy_run_artifact_stem(run_id: str, *, timestamp: str) -> str:
+    return f"{run_id}_{timestamp}"
+
+
+def run_config_filename(run_id: str, *, timestamp: str) -> str:
+    return f"{run_artifact_stem(run_id, timestamp=timestamp)}.json"
+
+
+def run_log_filename(run_id: str, *, timestamp: str, role: str) -> str:
+    return f"{run_artifact_stem(run_id, timestamp=timestamp)}_{role}.log"
+
+
+def live_results_filename(run_id: str, *, timestamp: str) -> str:
+    return f"{run_artifact_stem(run_id, timestamp=timestamp)}_live_results.json"
+
+
+def legacy_live_results_filename(run_id: str, *, timestamp: str) -> str:
+    return f"live_results_{legacy_run_artifact_stem(run_id, timestamp=timestamp)}.json"
diff --git a/apps/backend/app/services/simulation/compatibility.py b/apps/backend/app/services/simulation/compatibility.py
new file mode 100644
index 0000000..a280543
--- /dev/null
+++ b/apps/backend/app/services/simulation/compatibility.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from app.core import exceptions
+
+CLASSIC_FL_TASK = "classic_fl"
+LLM_PEFT_SFT_TASK = "llm_peft_sft"
+LLM_SIMULATION_ONLY_MESSAGE = "LLM PEFT is currently supported in simulation mode only"
+
+
+def _project_root() -> Path:
+    return Path(__file__).resolve().parents[5]
+
+
+def _ensure_fl_core_path() -> None:
+    libs_path = _project_root() / "libs"
+    if str(libs_path) not in sys.path:
+        sys.path.insert(0, str(libs_path))
+
+
+def _registry():
+    _ensure_fl_core_path()
+    from fl_core import simulation_registry
+
+    return simulation_registry
+
+
+def runtime_task_type(config: dict[str, Any]) -> str:
+    """Return the training route encoded in config, defaulting legacy configs to classic FL."""
+    task = config.get("task")
+    if not isinstance(task, dict):
+        return CLASSIC_FL_TASK
+    raw_task_type = task.get("type", CLASSIC_FL_TASK)
+    if not isinstance(raw_task_type, str) or not raw_task_type.strip():
+        return CLASSIC_FL_TASK
+    return raw_task_type.strip()
+
+
+def runtime_mode(config: dict[str, Any]) -> str:
+    """Return the selected runtime mode, defaulting missing legacy configs to simulation."""
+    system = config.get("system")
+    if not isinstance(system, dict):
+        return "simulation"
+    raw_mode = system.get("mode", "simulation")
+    if not isinstance(raw_mode, str) or not raw_mode.strip():
+        return "simulation"
+    return raw_mode.strip()
+
+
+def validate_llm_simulation_mode_or_raise(config: dict[str, Any]) -> None:
+    if runtime_task_type(config) == LLM_PEFT_SFT_TASK and runtime_mode(config) != "simulation":
+        raise exceptions.BadRequestError(LLM_SIMULATION_ONLY_MESSAGE)
+
+
+def canonicalize_runtime_config(config: dict[str, Any]) -> None:
+    if runtime_task_type(config) != CLASSIC_FL_TASK:
+        return
+
+    registry = _registry()
+
+    dataset = config.get("dataset")
+    if not isinstance(dataset, dict):
+        return
+    raw_dataset_name = dataset.get("name")
+    if isinstance(raw_dataset_name, str):
+        dataset["name"] = registry.canonical_dataset_name(raw_dataset_name)
+
+    spec = registry.get_dataset_spec(dataset.get("name"))
+
+    model = config.get("model")
+    if not isinstance(model, dict):
+        return
+    raw_model_name = model.get("name")
+    if isinstance(raw_model_name, str) and raw_model_name.strip().lower() != "auto":
+        model["name"] = registry.canonical_model_name(raw_model_name)
+    if spec is not None:
+        model["input_shape"] = list(spec.input_shape)
+        model["num_classes"] = spec.num_classes
+
+
+def validate_runtime_config_or_raise(config: dict[str, Any]) -> None:
+    validate_llm_simulation_mode_or_raise(config)
+
+    if runtime_task_type(config) != CLASSIC_FL_TASK:
+        return
+
+    registry = _registry()
+    errors = registry.validate_training_combination(config)
+    if errors:
+        raise exceptions.BadRequestError("; ".join(errors))
+
+
+def runtime_capabilities() -> dict[str, Any]:
+    return _registry().capabilities_payload()
diff --git a/apps/backend/app/services/simulation/job_service.py b/apps/backend/app/services/simulation/job_service.py
index 59b4386..1cb7b4d 100644
--- a/apps/backend/app/services/simulation/job_service.py
+++ b/apps/backend/app/services/simulation/job_service.py
@@ -15,6 +15,8 @@
 from app.core import exceptions
 from app.models.simulation import SimulationJob, SimulationJobStatus, SimulationRunStatus
 from app.repositories.simulation import SimulationJobRepository, SimulationRunRepository
+from app.services.llm_resources import augment_config_schema_with_llm_resources
+from app.services.simulation.compatibility import canonicalize_runtime_config, validate_runtime_config_or_raise
 
 
 class SimulationJobService:
@@ -192,7 +194,7 @@ def get_config_schema(cls) -> dict[str, Any]:
         loaded = yaml.safe_load(schema_path.read_text(encoding="utf-8"))
         if not isinstance(loaded, dict):
             raise exceptions.InternalServiceError("Config schema must be a YAML object.")
-        return loaded
+        return augment_config_schema_with_llm_resources(loaded, cls._project_root())
 
     @classmethod
     def normalize_simulation_config(cls, config: dict[str, Any]) -> dict[str, Any]:
@@ -230,7 +232,9 @@ def _normalize_simulation_config(cls, config: dict[str, Any]) -> dict[str, Any]:
         system["mode"] = "simulation"
         system["node_role"] = "server"
 
+        canonicalize_runtime_config(merged)
         cls._validate_config_node(merged, schema, path_prefix="")
+        validate_runtime_config_or_raise(merged)
         return merged
 
     @classmethod
@@ -349,6 +353,12 @@ def _cleanup_run_local_files(self, run_id: str) -> None:
             self._project_root() / "config" / "runs" / f"{run_id}.json",
             self._project_root() / "results" / f"live_results_{run_id}.json",
         ]
+        candidates.extend((self._project_root() / "configs" / "simulation_runs").glob(f"{run_id}*.json"))
+        candidates.extend((self._project_root() / "configs" / "simulation_runs").glob(f"*_{run_id}.json"))
+        candidates.extend((self._project_root() / "results").glob(f"live_results_{run_id}*.json"))
+        candidates.extend((self._project_root() / "results").glob(f"*_{run_id}_live_results.json"))
+        candidates.extend((self._project_root() / "logs" / "simulation_runs").glob(f"{run_id}*_server.log"))
+        candidates.extend((self._project_root() / "logs" / "simulation_runs").glob(f"*_{run_id}_server.log"))
         for path in candidates:
             try:
                 if path.exists() and path.is_file():
diff --git a/apps/backend/app/services/simulation/run_metrics_service.py b/apps/backend/app/services/simulation/run_metrics_service.py
index 6da54fe..253e393 100644
--- a/apps/backend/app/services/simulation/run_metrics_service.py
+++ b/apps/backend/app/services/simulation/run_metrics_service.py
@@ -15,6 +15,7 @@
 from app.core import exceptions
 from app.models.simulation import SimulationRun, SimulationRunStatus
 from app.repositories.simulation import SimulationRunRepository
+from app.services.run_artifacts import legacy_live_results_filename, live_results_filename, run_artifact_timestamp
 
 TRAINING_RESULT_ARTIFACT = "training_result"
 TERMINAL_RUN_STATUSES = {
@@ -43,14 +44,11 @@ async def get_run_metrics(self, run_id: str) -> dict[str, Any]:
         if not run:
             raise exceptions.RunNotFound("Run not found")
 
-        if run.status in TERMINAL_RUN_STATUSES and isinstance(run.metrics_json, dict) and run.metrics_json:
-            return self._normalize_metrics_payload(run.metrics_json)
-
-        live_result_path = self._results_dir() / self._build_live_results_filename(run_id)
-        loaded = self._load_metrics_file(live_result_path)
-        if loaded is not None:
-            await self._persist_run_metrics_if_changed(run, loaded)
-            return loaded
+        for live_result_path in self._live_result_candidates_for_run(run):
+            loaded = self._load_metrics_file(live_result_path)
+            if loaded is not None:
+                await self._persist_run_metrics_if_changed(run, loaded)
+                return loaded
 
         results = await self.run_repository.list_results(run_id)
         training_results = [result for result in results if result.artifact_type == TRAINING_RESULT_ARTIFACT]
@@ -120,6 +118,18 @@ def empty_metrics_payload() -> dict[str, Any]:
                 "global_loss": [],
                 "global_accuracy": [],
             },
+            "llm_results": {
+                "rounds": [],
+                "train_loss": [],
+                "validation_loss": [],
+                "perplexity": [],
+                "token_throughput": [],
+                "adapter_size_bytes": [],
+            },
+            "llm_dataset": {},
+            "llm_evaluation": {},
+            "llm_runtime": {},
+            "llm_artifacts": [],
             "client_results": {},
         }
 
@@ -147,11 +157,32 @@ def _results_dir(self) -> Path:
         return path
 
 
-    def _build_live_results_filename(self, run_id: str) -> str:
+    def _build_live_results_filename(
+        self,
+        run_id: str,
+        *,
+        artifact_timestamp: str | None = None,
+    ) -> str:
         """
         Build live result filename for one run ID.
         """
-        return f"live_results_{run_id}.json"
+        if artifact_timestamp is None:
+            return f"live_results_{run_id}.json"
+        return live_results_filename(run_id, timestamp=artifact_timestamp)
+
+
+    def _live_result_candidates_for_run(self, run: SimulationRun) -> list[Path]:
+        directory = self._results_dir()
+        timestamped = directory / self._build_live_results_filename(
+            run.id,
+            artifact_timestamp=run_artifact_timestamp(run.created_at),
+        )
+        legacy_timestamped = directory / legacy_live_results_filename(
+            run.id,
+            timestamp=run_artifact_timestamp(run.created_at),
+        )
+        legacy = directory / self._build_live_results_filename(run.id)
+        return list(dict.fromkeys([timestamped, legacy_timestamped, legacy]))
 
 
     def _load_metrics_file(self, file_path: Path) -> dict[str, Any] | None:
@@ -179,9 +210,9 @@ def _guess_live_result_file_for_run(self, run: SimulationRun) -> Path | None:
         if not directory.exists():
             return None
 
-        expected = directory / self._build_live_results_filename(run.id)
-        if expected.exists() and expected.is_file():
-            return expected
+        for expected in self._live_result_candidates_for_run(run):
+            if expected.exists() and expected.is_file():
+                return expected
 
         started_at = run.started_at or run.created_at
         if started_at is None:
@@ -189,13 +220,14 @@ def _guess_live_result_file_for_run(self, run: SimulationRun) -> Path | None:
 
         start_ts = started_at.timestamp()
         candidates: list[Path] = []
-        for path in directory.glob("live_results_*.json"):
-            try:
-                mtime = path.stat().st_mtime
-            except OSError:
-                continue
-            if mtime >= start_ts - 5:
-                candidates.append(path)
+        for pattern in ("*_live_results.json", "live_results_*.json"):
+            for path in directory.glob(pattern):
+                try:
+                    mtime = path.stat().st_mtime
+                except OSError:
+                    continue
+                if mtime >= start_ts - 5:
+                    candidates.append(path)
 
         if not candidates:
             return None
@@ -231,6 +263,35 @@ def _normalize_metrics_payload(self, payload: dict[str, Any]) -> dict[str, Any]:
                 "global_accuracy": self._to_float_list(global_results.get("global_accuracy")),
             }
 
+        llm_results = payload.get("llm_results")
+        if isinstance(llm_results, dict):
+            normalized["llm_results"] = {
+                "rounds": self._to_int_list(llm_results.get("rounds")),
+                "train_loss": self._to_float_list(llm_results.get("train_loss")),
+                "validation_loss": self._to_float_list(llm_results.get("validation_loss")),
+                "perplexity": self._to_float_list(llm_results.get("perplexity")),
+                "token_throughput": self._to_float_list(llm_results.get("token_throughput")),
+                "adapter_size_bytes": self._to_int_list(llm_results.get("adapter_size_bytes")),
+            }
+
+        llm_dataset = payload.get("llm_dataset")
+        if isinstance(llm_dataset, dict):
+            normalized["llm_dataset"] = llm_dataset
+
+        llm_evaluation = payload.get("llm_evaluation")
+        if isinstance(llm_evaluation, dict):
+            normalized["llm_evaluation"] = llm_evaluation
+
+        llm_runtime = payload.get("llm_runtime")
+        if isinstance(llm_runtime, dict):
+            normalized["llm_runtime"] = llm_runtime
+
+        llm_artifacts = payload.get("llm_artifacts")
+        if isinstance(llm_artifacts, list):
+            normalized["llm_artifacts"] = [
+                artifact for artifact in llm_artifacts if isinstance(artifact, dict)
+            ]
+
         client_results = payload.get("client_results")
         if isinstance(client_results, dict):
             normalized_clients: dict[str, dict[str, list[float]]] = {}
@@ -238,6 +299,7 @@ def _normalize_metrics_payload(self, payload: dict[str, Any]) -> dict[str, Any]:
                 if not isinstance(client_name, str) or not isinstance(client_data, dict):
                     continue
                 normalized_clients[client_name] = {
+                    "rounds": self._to_int_list(client_data.get("rounds")),
                     "train_loss": self._to_float_list(client_data.get("train_loss")),
                     "train_acc": self._to_float_list(client_data.get("train_acc")),
                     "test_loss": self._to_float_list(client_data.get("test_loss")),
diff --git a/apps/backend/app/services/simulation/run_service.py b/apps/backend/app/services/simulation/run_service.py
index eedb92a..ef107b4 100644
--- a/apps/backend/app/services/simulation/run_service.py
+++ b/apps/backend/app/services/simulation/run_service.py
@@ -19,9 +19,15 @@
 from app.core.db import AsyncSessionLocal
 from app.models.simulation import SimulationRun, SimulationRunLog, SimulationRunResult, SimulationRunStatus
 from app.repositories.simulation import SimulationJobRepository, SimulationRunRepository
+from app.services.run_artifacts import (
+    live_results_filename,
+    run_artifact_timestamp,
+    run_config_filename,
+    run_log_filename,
+)
 from app.services.simulation.run_metrics_service import SimulationRunMetricsService
 
-RESULT_PATH_PATTERN = re.compile(r"结果已保存到[:：]\s*(.+)$")
+RESULT_PATH_PATTERN = re.compile(r"\u7ed3\u679c\u5df2\u4fdd\u5b58\u5230[:\uff1a]\s*(.+)$")
 LOG_LEVEL_PREFIX_PATTERN = re.compile(
     r"^\s*(DEBUG|INFO|WARNING|WARN|ERROR|CRITICAL)\b[\s:\-]",
     re.IGNORECASE,
@@ -199,18 +205,22 @@ async def _start_run_with_config(self, *, job_id: int, config_json: dict[str, An
         )
         await self.run_repository.create_run(run)
 
-        config_path = self._write_run_config(run.id, config_json)
+        artifact_timestamp = run_artifact_timestamp(run.created_at)
+        config_path = self._write_run_config(run.id, config_json, artifact_timestamp=artifact_timestamp)
         await self.run_repository.add_result(
             run_id=run.id,
             artifact_type=RUN_CONFIG_ARTIFACT,
             path=str(config_path),
-            metadata_json={"source": "run_config"},
+            metadata_json={"source": "run_config", "artifact_timestamp": artifact_timestamp},
         )
 
         command = self._build_train_command(config_path)
         run.command = " ".join(command)
 
-        live_results_path = self._results_dir() / self._build_live_results_filename(run.id)
+        live_results_path = self._results_dir() / self._build_live_results_filename(
+            run.id,
+            artifact_timestamp=artifact_timestamp,
+        )
         child_env = self._build_run_environment(live_results_path)
         process = await self._spawn_subprocess(command, env=child_env)
 
@@ -225,16 +235,24 @@ async def _start_run_with_config(self, *, job_id: int, config_json: dict[str, An
         await self.session.refresh(run)
 
         self._processes[run.id] = process
-        self._tasks[run.id] = asyncio.create_task(self._watch_process(run.id, process))
+        self._tasks[run.id] = asyncio.create_task(
+            self._watch_process(run.id, process, artifact_timestamp=artifact_timestamp)
+        )
         return run
 
 
-    async def _watch_process(self, run_id: str, process: asyncio.subprocess.Process) -> None:
+    async def _watch_process(
+        self,
+        run_id: str,
+        process: asyncio.subprocess.Process,
+        *,
+        artifact_timestamp: str | None = None,
+    ) -> None:
         """
         Consume subprocess streams and persist final run status/artifacts.
         """
         result_path: str | None = None
-        log_path = self._simulation_log_path(run_id)
+        log_path = self._simulation_log_path(run_id, artifact_timestamp=artifact_timestamp)
 
         async def consume(stream: asyncio.StreamReader, level: str, prefix: str) -> None:
             nonlocal result_path
@@ -248,7 +266,7 @@ async def consume(stream: asyncio.StreamReader, level: str, prefix: str) -> None
                     if not message:
                         continue
 
-                    file_obj.write(f"[{prefix}] {message}\\n")
+                    file_obj.write(f"[{prefix}] {message}\n")
                     file_obj.flush()
 
                     match = RESULT_PATH_PATTERN.search(message)
@@ -283,22 +301,36 @@ async def consume(stream: asyncio.StreamReader, level: str, prefix: str) -> None
                 )
                 await repository.add_log(run_id, f"run finished with exit_code={exit_code}")
 
+                metrics_persisted = False
                 if result_path:
                     await repository.add_result(
                         run_id=run_id,
                         artifact_type=TRAINING_RESULT_ARTIFACT,
                         path=result_path,
-                        metadata_json={"source": "process_output"},
+                        metadata_json={
+                            "source": "process_output",
+                            "artifact_timestamp": artifact_timestamp,
+                        },
                     )
                     normalized = self.metrics_service.load_metrics_file(
                         self.metrics_service.resolve_result_artifact_path(result_path)
                     )
                     if normalized is not None:
                         await repository.update_run_metrics(run, normalized)
+                        metrics_persisted = True
 
-                if not run.metrics_json:
+                if not metrics_persisted:
                     guessed = self.metrics_service.guess_live_result_file_for_run(run)
                     if guessed is not None:
+                        await repository.add_result(
+                            run_id=run_id,
+                            artifact_type=TRAINING_RESULT_ARTIFACT,
+                            path=str(guessed),
+                            metadata_json={
+                                "source": "live_results_fallback",
+                                "artifact_timestamp": artifact_timestamp,
+                            },
+                        )
                         normalized = self.metrics_service.load_metrics_file(guessed)
                         if normalized is not None:
                             await repository.update_run_metrics(run, normalized)
@@ -343,33 +375,55 @@ def _runtime_log_dir(self) -> Path:
         return path
 
 
-    def _simulation_log_path(self, run_id: str, client_id: int | None = None) -> Path:
+    def _simulation_log_path(
+        self,
+        run_id: str,
+        client_id: int | None = None,
+        *,
+        artifact_timestamp: str | None = None,
+    ) -> Path:
         """
         Build simulation log path for server or client role.
         """
         suffix = "server" if client_id is None else f"client_{client_id}"
-        return self._runtime_log_dir() / f"{run_id}_{suffix}.log"
+        if artifact_timestamp is None:
+            return self._runtime_log_dir() / f"{run_id}_{suffix}.log"
+        return self._runtime_log_dir() / run_log_filename(
+            run_id,
+            timestamp=artifact_timestamp,
+            role=suffix,
+        )
 
 
-    def _build_live_results_filename(self, run_id: str) -> str:
+    def _build_live_results_filename(self, run_id: str, *, artifact_timestamp: str | None = None) -> str:
         """
         Build live result filename for one run ID.
         """
-        return f"live_results_{run_id}.json"
+        if artifact_timestamp is None:
+            return f"live_results_{run_id}.json"
+        return live_results_filename(run_id, timestamp=artifact_timestamp)
 
 
-    def _run_config_path(self, run_id: str) -> Path:
+    def _run_config_path(self, run_id: str, *, artifact_timestamp: str | None = None) -> Path:
         """
         Build local run config path.
         """
-        return self._job_config_dir() / f"{run_id}.json"
+        if artifact_timestamp is None:
+            return self._job_config_dir() / f"{run_id}.json"
+        return self._job_config_dir() / run_config_filename(run_id, timestamp=artifact_timestamp)
 
 
-    def _write_run_config(self, run_id: str, config_json: dict[str, Any]) -> Path:
+    def _write_run_config(
+        self,
+        run_id: str,
+        config_json: dict[str, Any],
+        *,
+        artifact_timestamp: str | None = None,
+    ) -> Path:
         """
         Write run config payload to JSON file.
         """
-        path = self._run_config_path(run_id)
+        path = self._run_config_path(run_id, artifact_timestamp=artifact_timestamp)
         path.write_text(json.dumps(config_json, ensure_ascii=False, indent=2), encoding="utf-8")
         return path
 
@@ -457,9 +511,19 @@ def _cleanup_run_local_files(self, run_id: str) -> None:
         """
         Cleanup local config/results/log files for a run ID.
         """
-        self._delete_file_if_exists(self._run_config_path(run_id))
-        self._delete_file_if_exists(self._results_dir() / self._build_live_results_filename(run_id))
-        self._delete_file_if_exists(self._simulation_log_path(run_id))
+        for path in self._matching_run_local_files(run_id):
+            self._delete_file_if_exists(path)
+
+
+    def _matching_run_local_files(self, run_id: str) -> list[Path]:
+        return [
+            *self._job_config_dir().glob(f"{run_id}*.json"),
+            *self._job_config_dir().glob(f"*_{run_id}.json"),
+            *self._results_dir().glob(f"live_results_{run_id}*.json"),
+            *self._results_dir().glob(f"*_{run_id}_live_results.json"),
+            *self._runtime_log_dir().glob(f"{run_id}*_server.log"),
+            *self._runtime_log_dir().glob(f"*_{run_id}_server.log"),
+        ]
 
 
     @staticmethod
diff --git a/apps/backend/runners/classic_fl_runtime.py b/apps/backend/runners/classic_fl_runtime.py
new file mode 100644
index 0000000..7bb1ef7
--- /dev/null
+++ b/apps/backend/runners/classic_fl_runtime.py
@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from core_runtime import FederatedLearningFramework
+
+
+def run_classic_fl_runtime(config_path: Path) -> bool:
+    """Run the existing classic small-model federated learning runtime."""
+    framework = FederatedLearningFramework(config_path=str(config_path))
+    return framework.run()
+
diff --git a/apps/backend/runners/core_runtime.py b/apps/backend/runners/core_runtime.py
index 48fce22..732eac3 100644
--- a/apps/backend/runners/core_runtime.py
+++ b/apps/backend/runners/core_runtime.py
@@ -22,11 +22,14 @@
 from fl_core.data.data_loader import DataManager
 from fl_core.data.data_splitter import DataSplitter, FederatedDataManager
 from fl_core.models.model_manager import ModelManager
+from fl_core.simulation_registry import resolve_model_name_for_dataset
 from fl_core.federated.server import FederatedServer
 from fl_core.federated.client import FederatedClient
 from fl_core.federated.client_manager import ClientManager
-from fl_core.compression.sparsification import GlobalTopKSparsifier
+from fl_core.compression.sparsification import CompressionFactory
+from fl_core.privacy.differential_privacy import DifferentialPrivacyManager
 from fl_core.privacy.encryption import CKKSManager
+from fl_core.privacy.secure_aggregation import SecureAggregationMasker
 from fl_core.federated.communication import GRPCServer, GRPCWorker, GRPCClientProxy
 WebApp = None
 
@@ -96,14 +99,36 @@ def initialize_system(self) -> bool:
             
             self.sparsifier = None
             if sparsify_conf.get('enable', False):
+                method = sparsify_conf.get('method', 'global_topk')
                 ratio = sparsify_conf.get('ratio', 0.5)
-                self.sparsifier = GlobalTopKSparsifier(ratio=ratio)
+                threshold = sparsify_conf.get('threshold', 1e-3)
+                self.sparsifier = CompressionFactory.create(method=method, ratio=ratio, threshold=threshold)
                 print(f"✓ 通信压缩: 稀疏化已启用 (Ratio: {ratio})")
             
 
             privacy_config = self.config_manager.config.get('privacy', {})
             ckks_conf = privacy_config.get('homomorphic_encryption', {})
-            
+            dp_conf = privacy_config.get('differential_privacy', {})
+            secure_agg_conf = privacy_config.get('secure_aggregation', {})
+            
+            self.dp_manager = None
+            if dp_conf.get('enable', False):
+                self.dp_manager = DifferentialPrivacyManager(
+                    clipping_norm=dp_conf.get('clipping_norm', 1.0),
+                    noise_multiplier=dp_conf.get('noise_multiplier', 0.0),
+                )
+                print(
+                    "Differential privacy enabled: "
+                    f"clip={self.dp_manager.clipping_norm}, noise={self.dp_manager.noise_multiplier}"
+                )
+
+            self.secure_aggregation = None
+            if secure_agg_conf.get('enable', False):
+                self.secure_aggregation = SecureAggregationMasker(
+                    mask_std=secure_agg_conf.get('mask_std', 1.0),
+                )
+                print(f"Secure aggregation masking enabled: std={self.secure_aggregation.mask_std}")
+
             self.ckks_manager = None
             if ckks_conf.get('enable', False):
                 # 暂不支持同时开启
@@ -155,7 +180,10 @@ def _get_experiment_info(self) -> Dict[str, Any]:
                 "dataset_name": dataset_cfg.get('name', 'Unknown'),
                 "distribution": dataset_cfg.get('distribution', 'iid'),
                 "alpha": dataset_cfg.get('alpha', 'N/A'),
-                "model_name": model_cfg.get('name', 'Unknown'),
+                "model_name": resolve_model_name_for_dataset(
+                    model_cfg.get('name'),
+                    dataset_cfg.get('name', 'CIFAR-10'),
+                ),
                 "num_classes": model_cfg.get('num_classes', 10)
             },
             "federated": {
@@ -169,13 +197,23 @@ def _get_experiment_info(self) -> Dict[str, Any]:
             "security": {
                 "encryption": {
                     "enabled": privacy_cfg.get('homomorphic_encryption', {}).get('enable', False),
-                    "type": "CKKS",
+                    "type": privacy_cfg.get('homomorphic_encryption', {}).get('method', 'ckks'),
                     "poly_modulus_degree": privacy_cfg.get('homomorphic_encryption', {}).get('poly_modulus_degree', 0)
                 },
+                "differential_privacy": {
+                    "enabled": privacy_cfg.get('differential_privacy', {}).get('enable', False),
+                    "clipping_norm": privacy_cfg.get('differential_privacy', {}).get('clipping_norm', 1.0),
+                    "noise_multiplier": privacy_cfg.get('differential_privacy', {}).get('noise_multiplier', 0.0),
+                },
+                "secure_aggregation": {
+                    "enabled": privacy_cfg.get('secure_aggregation', {}).get('enable', False),
+                    "mask_std": privacy_cfg.get('secure_aggregation', {}).get('mask_std', 1.0),
+                },
                 "compression": {
                     "enabled": compression_cfg.get('sparsification', {}).get('enable', False),
-                    "type": "Global Top-K",
-                    "ratio": compression_cfg.get('sparsification', {}).get('ratio', 0.0)
+                    "type": compression_cfg.get('sparsification', {}).get('method', 'global_topk'),
+                    "ratio": compression_cfg.get('sparsification', {}).get('ratio', 0.0),
+                    "threshold": compression_cfg.get('sparsification', {}).get('threshold', 1e-3),
                 }
             }
         }
@@ -248,7 +286,9 @@ def run_distributed_server(self):
         self.client_manager = ClientManager(
             clients=[],
             sparsifier=self.sparsifier,
-            ckks_manager=self.ckks_manager
+            ckks_manager=self.ckks_manager,
+            dp_manager=self.dp_manager,
+            secure_aggregation=self.secure_aggregation,
         )
 
         self.logger.log_info(f"等待 {federated_config.get('num_clients')} 个远程客户端连接...")
@@ -422,11 +462,16 @@ def setup_models(self) -> bool:
             self.model_manager = ModelManager(model_config)
             
             dataset_info = self.data_manager.get_dataset_info()
+            model_name = resolve_model_name_for_dataset(
+                model_config.get('name'),
+                dataset_info['name'],
+            )
             
             global_model = self.model_manager.create_model(
-                model_name=model_config.get('name'),
+                model_name=model_name,
                 input_shape=dataset_info['input_shape'],
-                num_classes=dataset_info['num_classes']
+                num_classes=dataset_info['num_classes'],
+                dataset_info=dataset_info,
             )
             
             self.global_model = global_model
@@ -479,6 +524,8 @@ def setup_federated_components(self) -> bool:
                 clients=clients,
                 sparsifier=self.sparsifier,
                 ckks_manager=self.ckks_manager,
+                dp_manager=self.dp_manager,
+                secure_aggregation=self.secure_aggregation,
                 selection_strategy="random"
             )
             # Parallel client training races the global torch RNG inside
@@ -524,7 +571,7 @@ def run_federated_training(self) -> bool:
                 self.client_manager.broadcast_model_to_clients(all_clients, global_params)
                 
                 training_results = self.client_manager.train_clients(
-                    selected_clients=all_clients,
+                    selected_clients=selected_clients,
                     epochs=local_epochs,
                     learning_rate=learning_rate,
                     round_num=round_num
diff --git a/apps/backend/runners/experiment_runner.py b/apps/backend/runners/experiment_runner.py
index bded743..e5ccdc5 100644
--- a/apps/backend/runners/experiment_runner.py
+++ b/apps/backend/runners/experiment_runner.py
@@ -9,7 +9,7 @@
 
 import yaml
 
-from core_runtime import FederatedLearningFramework
+from runtime_dispatcher import run_runtime
 
 
 def _set_value_by_path(obj: dict[str, Any], path: str, value: Any) -> None:
@@ -49,8 +49,7 @@ def _apply_runtime_profile(config: dict[str, Any], *, mode: str, role: str | Non
 
 
 def _run_framework(config_path: Path) -> int:
-    framework = FederatedLearningFramework(config_path=str(config_path))
-    return 0 if framework.run() else 1
+    return 0 if run_runtime(config_path) else 1
 
 
 def main() -> int:
diff --git a/apps/backend/runners/llm_peft_runtime.py b/apps/backend/runners/llm_peft_runtime.py
new file mode 100644
index 0000000..e13cd65
--- /dev/null
+++ b/apps/backend/runners/llm_peft_runtime.py
@@ -0,0 +1,402 @@
+from __future__ import annotations
+
+import json
+import os
+import random
+import re
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+import torch
+import yaml
+
+PROJECT_ROOT = Path(__file__).resolve().parents[3]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+FL_CORE_PARENT = PROJECT_ROOT / "libs"
+if str(FL_CORE_PARENT) not in sys.path:
+    sys.path.insert(0, str(FL_CORE_PARENT))
+
+from fl_core.llm.config import LlmPeftRuntimeConfig, normalize_llm_peft_config
+from fl_core.llm.data import load_sft_records, split_records_by_client
+from fl_core.llm.aggregation import aggregate_adapter_state_dicts
+from fl_core.llm.artifacts import (
+    adapter_artifact_record,
+    adapter_state_size_bytes,
+    load_adapter_artifact,
+    save_adapter_artifact,
+    sha256_file,
+)
+from fl_core.llm.metrics import append_llm_round_metrics, empty_llm_metrics_payload
+from fl_core.llm.modeling import missing_llm_runtime_dependencies
+from fl_core.llm.trainer import LlmPeftTrainer
+
+
+class LlmPeftRuntimeNotImplemented(RuntimeError):
+    """Raised when the planned LLM PEFT route is selected before implementation."""
+
+
+SFT_DATA_FORMATS = ("prompt_completion", "messages", "alpaca")
+
+
+def run_llm_peft_runtime(config_path: Path) -> bool:
+    """
+    Bootstrap the Phase 2 LLM PEFT federated fine-tuning route.
+
+    This route already owns config/data/metrics preparation. The heavy
+    Transformers/PEFT training is routed through this entrypoint while keeping
+    a clear metrics record when the deployed runtime environment is incomplete.
+    """
+    try:
+        raw_config = _load_config(config_path)
+        runtime_config = normalize_llm_peft_config(raw_config)
+        metrics = empty_llm_metrics_payload(runtime_config)
+        _write_metrics(runtime_config, metrics)
+
+        print("LLM_PEFT_RUNTIME_SELECTED")
+        print(f"LLM_BASE_MODEL: {runtime_config.llm.base_model}")
+        print(f"SFT_DATASET: {runtime_config.sft.dataset_path}")
+        print(f"PEFT_ADAPTER: method={runtime_config.peft.method} rank={runtime_config.peft.rank}")
+
+        dataset_path = _resolve_runtime_path(runtime_config.sft.dataset_path)
+        dataset_file_format = _effective_sft_file_format(
+            dataset_path,
+            configured_file_format=runtime_config.sft.file_format,
+        )
+        records = load_sft_records(
+            dataset_path,
+            data_format=runtime_config.sft.format,
+            file_format=runtime_config.sft.file_format,
+        )
+        client_splits = split_records_by_client(
+            records,
+            num_clients=runtime_config.federated.num_clients,
+            seed=runtime_config.federated.seed,
+        )
+        metrics["llm_dataset"] = {
+            "num_records": len(records),
+            "client_record_counts": [len(client_records) for client_records in client_splits],
+            "format": runtime_config.sft.format,
+            "file_format": dataset_file_format,
+            "prompt_template": runtime_config.sft.prompt_template,
+            "path": str(dataset_path),
+        }
+        evaluation_records = None
+        if runtime_config.evaluation.enabled:
+            if runtime_config.evaluation.dataset_path is None:
+                raise ValueError("evaluation.dataset_path must be set when evaluation.enable is true")
+            evaluation_path = _resolve_runtime_path(runtime_config.evaluation.dataset_path)
+            evaluation_file_format = _effective_sft_file_format(
+                evaluation_path,
+                configured_file_format="auto",
+            )
+            evaluation_records, evaluation_data_format = _load_sft_records_with_format_fallback(
+                evaluation_path,
+                preferred_format=runtime_config.sft.format,
+                file_format="auto",
+            )
+            evaluation_records = evaluation_records[: runtime_config.evaluation.max_samples]
+            metrics["llm_evaluation"] = {
+                "enabled": True,
+                "path": str(evaluation_path),
+                "file_format": evaluation_file_format,
+                "format": evaluation_data_format,
+                "num_records": len(evaluation_records),
+                "batch_size": runtime_config.evaluation.batch_size,
+                "max_samples": runtime_config.evaluation.max_samples,
+            }
+            print(
+                "LLM_EVALUATION_ENABLED: "
+                f"path={evaluation_path} records={len(evaluation_records)} "
+                f"format={evaluation_data_format} batch_size={runtime_config.evaluation.batch_size}"
+            )
+        else:
+            metrics["llm_evaluation"] = {"enabled": False}
+            print("LLM_EVALUATION_DISABLED")
+        _write_metrics(runtime_config, metrics)
+
+        missing = missing_llm_runtime_dependencies()
+        if missing:
+            print(
+                "LLM_PEFT_RUNTIME_BLOCKED: missing LLM runtime dependencies: "
+                + ", ".join(missing)
+            )
+            metrics["llm_runtime"] = {
+                "status": "blocked",
+                "reason": "missing_llm_runtime_dependencies",
+                "missing_dependencies": missing,
+            }
+            _write_metrics(runtime_config, metrics)
+            print(f"\u7ed3\u679c\u5df2\u4fdd\u5b58\u5230: {_result_path(runtime_config)}")
+            return False
+
+        trainer = LlmPeftTrainer(runtime_config)
+        global_adapter_state: dict[str, torch.Tensor] | None = None
+        parent_adapter_path: str | None = None
+        parent_adapter_sha256: str | None = None
+        if runtime_config.peft.resume_adapter_path is not None:
+            resume_path = _resolve_runtime_path(runtime_config.peft.resume_adapter_path)
+            global_adapter_state, resume_metadata = load_adapter_artifact(resume_path)
+            parent_adapter_path = str(resume_path)
+            parent_adapter_sha256 = sha256_file(resume_path)
+            metrics["llm_runtime"] = {
+                "status": "resumed",
+                "resume_adapter_path": parent_adapter_path,
+                "resume_adapter_sha256": parent_adapter_sha256,
+                "resume_metadata": resume_metadata,
+            }
+            _write_metrics(runtime_config, metrics)
+            print(f"LLM_PEFT_RESUME_ADAPTER: {resume_path}")
+
+        rng = random.Random(runtime_config.federated.seed)
+        work_dir = _runtime_work_dir(runtime_config)
+        adapter_dir = _adapter_dir(runtime_config)
+        nonempty_client_ids = [idx for idx, client_records in enumerate(client_splits) if client_records]
+        if not nonempty_client_ids:
+            raise ValueError("No clients have SFT records")
+
+        for round_num in range(1, runtime_config.federated.num_rounds + 1):
+            started_at = time.perf_counter()
+            selected_ids = _select_clients(
+                nonempty_client_ids,
+                clients_per_round=runtime_config.federated.clients_per_round,
+                rng=rng,
+            )
+            print(f"LLM_PEFT_ROUND_START: round={round_num} clients={selected_ids}")
+            updates = []
+            for client_id in selected_ids:
+                print(
+                    "LLM_PEFT_CLIENT_START: "
+                    f"round={round_num} client={client_id} records={len(client_splits[client_id])}"
+                )
+                update = trainer.train_client(
+                    client_id=client_id,
+                    records=client_splits[client_id],
+                    round_num=round_num,
+                    initial_adapter_state=global_adapter_state,
+                    output_dir=work_dir / f"round_{round_num}" / f"client_{client_id}",
+                )
+                updates.append(update)
+                _append_client_metrics(metrics, client_id=client_id, round_num=round_num, update=update)
+                print(
+                    "LLM_PEFT_CLIENT_DONE: "
+                    f"round={round_num} client={client_id} "
+                    f"train_loss={float(update.metrics.get('train_loss', 0.0)):.6f} "
+                    f"records={update.num_examples} tokens={update.num_tokens}"
+                )
+
+            global_adapter_state = aggregate_adapter_state_dicts(
+                updates,
+                strategy=runtime_config.federated.aggregation,
+            )
+            adapter_size = adapter_state_size_bytes(global_adapter_state)
+            adapter_path = save_adapter_artifact(
+                adapter_dir / f"round_{round_num}_global_adapter.pt",
+                global_adapter_state,
+                metadata={
+                    "round": round_num,
+                    "selected_clients": selected_ids,
+                    "aggregation": runtime_config.federated.aggregation,
+                    "base_model": runtime_config.llm.base_model,
+                    "peft_method": runtime_config.peft.method,
+                    "parent_adapter_path": parent_adapter_path,
+                    "parent_adapter_sha256": parent_adapter_sha256,
+                },
+            )
+            artifact_record = adapter_artifact_record(
+                adapter_path,
+                round_num=round_num,
+                size_bytes=adapter_size,
+                selected_clients=selected_ids,
+                parent_path=parent_adapter_path,
+                parent_sha256=parent_adapter_sha256,
+            )
+            metrics.setdefault("llm_artifacts", []).append(artifact_record)
+            parent_adapter_path = artifact_record["path"]
+            parent_adapter_sha256 = artifact_record["sha256"]
+            elapsed = max(time.perf_counter() - started_at, 1e-9)
+            total_tokens = sum(update.num_tokens for update in updates)
+            train_loss = _weighted_train_loss(updates)
+            validation_loss = None
+            if evaluation_records is not None:
+                evaluation_metrics = trainer.evaluate_adapter(
+                    records=evaluation_records,
+                    adapter_state=global_adapter_state,
+                    output_dir=work_dir / f"round_{round_num}" / "evaluation",
+                )
+                validation_loss = float(evaluation_metrics.get("validation_loss", 0.0))
+                metrics["llm_evaluation"] = {
+                    **metrics.get("llm_evaluation", {}),
+                    "last_round": round_num,
+                    "last_validation_loss": validation_loss,
+                    "last_num_examples": int(evaluation_metrics.get("num_examples", len(evaluation_records))),
+                    "last_num_tokens": int(evaluation_metrics.get("num_tokens", 0)),
+                }
+                print(
+                    "LLM_PEFT_EVAL_DONE: "
+                    f"round={round_num} validation_loss={validation_loss:.6f} "
+                    f"records={int(evaluation_metrics.get('num_examples', len(evaluation_records)))}"
+                )
+            append_llm_round_metrics(
+                metrics,
+                round_num=round_num,
+                train_loss=train_loss,
+                validation_loss=validation_loss,
+                token_throughput=total_tokens / elapsed,
+                adapter_size_bytes=adapter_size,
+            )
+            metrics["llm_runtime"] = {
+                "status": "running",
+                "last_round": round_num,
+                "latest_adapter_path": artifact_record["path"],
+                "latest_adapter_sha256": artifact_record["sha256"],
+            }
+            _write_metrics(runtime_config, metrics)
+            print(f"LLM_PEFT_ROUND_DONE: round={round_num} train_loss={train_loss:.6f}")
+
+        metrics["llm_runtime"] = {
+            "status": "completed",
+            "completed_rounds": runtime_config.federated.num_rounds,
+            "latest_adapter_path": parent_adapter_path,
+            "latest_adapter_sha256": parent_adapter_sha256,
+        }
+        _write_metrics(runtime_config, metrics)
+        print("LLM_PEFT_RUNTIME_COMPLETED")
+        print(f"\u7ed3\u679c\u5df2\u4fdd\u5b58\u5230: {_result_path(runtime_config)}")
+        return True
+    except Exception as exc:
+        print(f"LLM_PEFT_RUNTIME_FAILED: {exc}")
+        return False
+
+
+def _load_config(path: Path) -> dict[str, Any]:
+    loaded = yaml.safe_load(path.read_text(encoding="utf-8"))
+    if loaded is None:
+        return {}
+    if not isinstance(loaded, dict):
+        raise ValueError("Config must be a YAML/JSON object")
+    return loaded
+
+
+def _write_metrics(config: LlmPeftRuntimeConfig, payload: dict[str, Any]) -> None:
+    result_path = _result_path(config)
+    result_path.parent.mkdir(parents=True, exist_ok=True)
+    result_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def _result_path(config: LlmPeftRuntimeConfig) -> Path:
+    override_name = os.environ.get("FIGARO_RESULTS_FILE", "").strip()
+    if override_name:
+        return PROJECT_ROOT / config.results_dir / Path(override_name).name
+    return PROJECT_ROOT / config.results_dir / "live_results_llm_peft.json"
+
+
+def _runtime_work_dir(config: LlmPeftRuntimeConfig) -> Path:
+    path = PROJECT_ROOT / config.results_dir / "llm_peft_work" / _run_artifact_id()
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _adapter_dir(config: LlmPeftRuntimeConfig) -> Path:
+    path = PROJECT_ROOT / config.results_dir / "llm_peft_adapters" / _run_artifact_id()
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _load_sft_records_with_format_fallback(
+    path: Path,
+    *,
+    preferred_format: str,
+    file_format: str,
+) -> tuple[list[Any], str]:
+    tried_formats: list[str] = []
+    last_error: ValueError | None = None
+    for data_format in (preferred_format, *SFT_DATA_FORMATS):
+        if data_format in tried_formats:
+            continue
+        tried_formats.append(data_format)
+        try:
+            return load_sft_records(path, data_format=data_format, file_format=file_format), data_format
+        except ValueError as exc:
+            last_error = exc
+    formats = ", ".join(tried_formats)
+    raise ValueError(f"Unable to load SFT records from {path} using formats: {formats}") from last_error
+
+
+def _resolve_runtime_path(path: Path) -> Path:
+    return path if path.is_absolute() else PROJECT_ROOT / path
+
+
+def _effective_sft_file_format(path: Path, *, configured_file_format: str) -> str:
+    if configured_file_format != "auto":
+        return configured_file_format
+    if path.is_file():
+        detected = _sft_file_format_from_suffix(path)
+        return detected or "auto"
+    if path.is_dir():
+        formats = {
+            detected
+            for candidate in path.rglob("*")
+            if candidate.is_file()
+            and (detected := _sft_file_format_from_suffix(candidate)) is not None
+        }
+        if len(formats) == 1:
+            return next(iter(formats))
+        if len(formats) > 1:
+            return "mixed"
+    return "auto"
+
+
+def _sft_file_format_from_suffix(path: Path) -> str | None:
+    suffix = path.suffix.lower()
+    if suffix == ".jsonl":
+        return "jsonl"
+    if suffix == ".parquet":
+        return "parquet"
+    return None
+
+
+def _run_artifact_id() -> str:
+    override_name = os.environ.get("FIGARO_RESULTS_FILE", "").strip()
+    if not override_name:
+        return "manual"
+    stem = Path(override_name).name
+    if stem.endswith(".json"):
+        stem = stem[:-5]
+    prefix = "live_results_"
+    if stem.startswith(prefix):
+        stem = stem[len(prefix):]
+    sanitized = re.sub(r"[^A-Za-z0-9_.-]+", "_", stem).strip("._-")
+    return sanitized or "manual"
+
+
+def _select_clients(client_ids: list[int], *, clients_per_round: int, rng: random.Random) -> list[int]:
+    selected_count = min(clients_per_round, len(client_ids))
+    return sorted(rng.sample(client_ids, selected_count))
+
+
+def _append_client_metrics(metrics: dict[str, Any], *, client_id: int, round_num: int, update) -> None:
+    client_key = f"client_{client_id}"
+    clients = metrics.setdefault("client_results", {})
+    series = clients.setdefault(
+        client_key,
+        {"rounds": [], "train_loss": [], "train_acc": [], "test_loss": [], "test_acc": []},
+    )
+    train_loss = float(update.metrics.get("train_loss", 0.0))
+    series.setdefault("rounds", []).append(int(round_num))
+    series["train_loss"].append(train_loss)
+    series["train_acc"].append(0.0)
+    series["test_loss"].append(0.0)
+    series["test_acc"].append(0.0)
+
+
+def _weighted_train_loss(updates) -> float:
+    total_examples = sum(max(0, int(update.num_examples)) for update in updates)
+    if total_examples <= 0:
+        return 0.0
+    weighted = 0.0
+    for update in updates:
+        weighted += float(update.metrics.get("train_loss", 0.0)) * max(0, int(update.num_examples))
+    return weighted / total_examples
diff --git a/apps/backend/runners/runtime_dispatcher.py b/apps/backend/runners/runtime_dispatcher.py
new file mode 100644
index 0000000..e92b2d8
--- /dev/null
+++ b/apps/backend/runners/runtime_dispatcher.py
@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+CLASSIC_FL_TASK = "classic_fl"
+LLM_PEFT_SFT_TASK = "llm_peft_sft"
+SUPPORTED_TASK_TYPES = {CLASSIC_FL_TASK, LLM_PEFT_SFT_TASK}
+LLM_SIMULATION_ONLY_MESSAGE = "LLM PEFT is currently supported in simulation mode only"
+
+
+def load_runtime_config(config_path: Path) -> dict[str, Any]:
+    loaded = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+    if loaded is None:
+        return {}
+    if not isinstance(loaded, dict):
+        raise ValueError("Config must be a YAML/JSON object")
+    return loaded
+
+
+def get_task_type(config: dict[str, Any]) -> str:
+    """Return the selected training route, defaulting legacy configs to classic FL."""
+    task = config.get("task")
+    if not isinstance(task, dict):
+        return CLASSIC_FL_TASK
+
+    task_type = task.get("type", CLASSIC_FL_TASK)
+    if not isinstance(task_type, str) or not task_type.strip():
+        return CLASSIC_FL_TASK
+    return task_type.strip()
+
+
+def get_runtime_mode(config: dict[str, Any]) -> str:
+    """Return the runtime mode, defaulting missing legacy configs to simulation."""
+    system = config.get("system")
+    if not isinstance(system, dict):
+        return "simulation"
+    mode = system.get("mode", "simulation")
+    if not isinstance(mode, str) or not mode.strip():
+        return "simulation"
+    return mode.strip()
+
+
+def validate_runtime_route(config: dict[str, Any]) -> None:
+    if get_task_type(config) == LLM_PEFT_SFT_TASK and get_runtime_mode(config) != "simulation":
+        raise ValueError(LLM_SIMULATION_ONLY_MESSAGE)
+
+
+def run_runtime(config_path: Path) -> bool:
+    config = load_runtime_config(config_path)
+    validate_runtime_route(config)
+    task_type = get_task_type(config)
+
+    if task_type == CLASSIC_FL_TASK:
+        from classic_fl_runtime import run_classic_fl_runtime
+
+        return run_classic_fl_runtime(config_path)
+
+    if task_type == LLM_PEFT_SFT_TASK:
+        from llm_peft_runtime import run_llm_peft_runtime
+
+        return run_llm_peft_runtime(config_path)
+
+    supported = ", ".join(sorted(SUPPORTED_TASK_TYPES))
+    raise ValueError(f"Unsupported task.type={task_type!r}. Supported task types: {supported}")
diff --git a/apps/backend/tests/api/v1/endpoints/test_agent.py b/apps/backend/tests/api/v1/endpoints/test_agent.py
index 44d5b2b..ecd32f9 100644
--- a/apps/backend/tests/api/v1/endpoints/test_agent.py
+++ b/apps/backend/tests/api/v1/endpoints/test_agent.py
@@ -22,7 +22,41 @@ def test_agent_config_schema_endpoint_returns_ui_metadata(client):
 
     assert response.status_code == 200
     payload = response.json()
-    assert payload["model"]["name"]["options"] == ["CNN", "LeNet", "ResNet"]
+    assert "Auto" in payload["model"]["name"]["options"]
+    assert "FedAvgCNN" in payload["model"]["name"]["options"]
+    assert "TextDNN" in payload["model"]["name"]["options"]
+    assert "CharLSTM" in payload["model"]["name"]["options"]
+    llm_task_ui = payload["task"]["type"]["ui"]["options"]["llm_peft_sft"]
+    assert llm_task_ui["badge"] == "simulation"
+    assert "disabled" not in llm_task_ui
+    assert payload["llm"]["base_model"]["type"] == "text"
+    assert "Qwen/Qwen2.5-0.5B-Instruct" not in payload["llm"]["base_model"]["options"]
+    if payload["llm"]["base_model"]["options"]:
+        assert payload["llm"]["base_model"]["default"] in payload["llm"]["base_model"]["options"]
+    else:
+        assert payload["llm"]["base_model"]["default"] == ""
+        assert payload["llm"]["base_model"]["ui"]["empty_message"] == "No local models found"
+    assert payload["llm"]["base_model"]["ui"]["option_source"]["path"] == "./models/llm"
+    if payload["sft"]["dataset_path"]["options"]:
+        assert payload["sft"]["dataset_path"]["default"] in payload["sft"]["dataset_path"]["options"]
+    else:
+        assert payload["sft"]["dataset_path"]["default"] == ""
+        assert payload["sft"]["dataset_path"]["ui"]["empty_message"] == "No training datasets found"
+    assert payload["sft"]["dataset_path"]["ui"]["option_source"]["path"] == "./datasets/llm"
+    assert payload["sft"]["file_format"]["options"] == ["auto", "jsonl", "parquet"]
+    assert payload["sft"]["validation_split"]["default"] == 0.0
+    assert "alpaca" in payload["sft"]["format"]["options"]
+    if payload["evaluation"]["dataset_path"]["options"]:
+        if payload["evaluation"]["dataset_path"]["default"]:
+            assert payload["evaluation"]["dataset_path"]["default"] in payload["evaluation"]["dataset_path"]["options"]
+            assert payload["evaluation"]["enable"]["default"] is True
+        else:
+            assert payload["evaluation"]["enable"]["default"] is False
+    else:
+        assert payload["evaluation"]["dataset_path"]["default"] == ""
+        assert payload["evaluation"]["dataset_path"]["ui"]["empty_message"] == "No evaluation datasets found"
+        assert payload["evaluation"]["enable"]["default"] is False
+    assert payload["evaluation"]["dataset_path"]["ui"]["option_source"]["path"] == "./datasets/llm"
     aggregation_ui = payload["federated"]["aggregation"]["ui"]
     assert aggregation_ui["featured"] is True
     assert aggregation_ui["options"]["fedprox"]["disabled"] is True
@@ -367,7 +401,7 @@ class _FakeHistoryService:
         def __init__(self, _session):
             self._session = _session
 
-        async def list_jobs(self):
+        async def list_jobs(self, **_filters):
             return [history_job]
 
         async def get_job_or_raise(self, optimization_job_id):
@@ -390,3 +424,104 @@ async def get_job_or_raise(self, optimization_job_id):
     assert detail_payload["optimization_job_id"] == 7
     assert detail_payload["job_name"] == "cifar10-alpha-sweep"
     assert detail_payload["resolved_objective"] == "accuracy"
+
+
+def test_agent_optimization_jobs_history_filters_are_forwarded(client, monkeypatch):
+    import app.api.v1.endpoints.agent as agent_module
+
+    captured = {}
+
+    class _FakeHistoryService:
+        def __init__(self, _session):
+            self._session = _session
+
+        async def list_jobs(self, **filters):
+            captured.update(filters)
+            return []
+
+    monkeypatch.setattr(agent_module, "AgentOptimizationHistoryService", _FakeHistoryService)
+
+    response = client.get(
+        "/api/v1/agent/optimization-jobs"
+        "?status=completed"
+        "&q=cifar"
+        "&model_name=gpt-test"
+        "&objective=accuracy"
+        "&best_score_min=0.8"
+        "&best_score_max=0.95"
+        "&dataset=CIFAR-10"
+        "&config_model=FedAvgCNN"
+        "&aggregation=fedavg"
+        "&num_clients=3"
+        "&num_rounds=10"
+    )
+
+    assert response.status_code == 200
+    assert captured["status"] == "completed"
+    assert captured["q"] == "cifar"
+    assert captured["model_name"] == "gpt-test"
+    assert captured["objective"] == "accuracy"
+    assert captured["best_score_min"] == 0.8
+    assert captured["best_score_max"] == 0.95
+    assert captured["config_filters"] == {
+        "dataset.name": "CIFAR-10",
+        "model.name": "FedAvgCNN",
+        "federated.aggregation": "fedavg",
+        "federated.num_clients": 3,
+        "federated.num_rounds": 10,
+    }
+
+
+def test_agent_config_version_endpoints(client, monkeypatch):
+    import app.api.v1.endpoints.agent as agent_module
+
+    now = datetime.now(timezone.utc)
+    version = SimpleNamespace(
+        id=3,
+        optimization_job_id=7,
+        run_id="run-1",
+        iteration=1,
+        source="experiment",
+        label="alpha 0.1",
+        config_hash="abc123",
+        config_json={"dataset": {"alpha": 0.1}},
+        diff_json=[
+            {
+                "path": "dataset.alpha",
+                "change_type": "updated",
+                "old_value": 0.5,
+                "new_value": 0.1,
+            }
+        ],
+        created_at=now,
+    )
+
+    class _FakeHistoryService:
+        def __init__(self, _session):
+            self._session = _session
+
+        async def list_config_versions(self, optimization_job_id):
+            assert optimization_job_id == 7
+            return [version]
+
+        async def diff_config_versions(self, *, optimization_job_id, from_version_id, to_version_id):
+            assert optimization_job_id == 7
+            assert from_version_id is None
+            assert to_version_id == 3
+            return version.diff_json
+
+    monkeypatch.setattr(agent_module, "AgentOptimizationHistoryService", _FakeHistoryService)
+
+    versions_response = client.get("/api/v1/agent/optimization-jobs/7/config-versions")
+    assert versions_response.status_code == 200
+    versions_payload = versions_response.json()
+    assert versions_payload[0]["id"] == 3
+    assert versions_payload[0]["label"] == "alpha 0.1"
+    assert versions_payload[0]["diff_json"][0]["path"] == "dataset.alpha"
+
+    diff_response = client.get("/api/v1/agent/optimization-jobs/7/config-diff?to_version_id=3")
+    assert diff_response.status_code == 200
+    diff_payload = diff_response.json()
+    assert diff_payload["optimization_job_id"] == 7
+    assert diff_payload["to_version_id"] == 3
+    assert diff_payload["changes"][0]["new_value"] == 0.1
diff --git a/apps/backend/tests/llm/test_llm_core.py b/apps/backend/tests/llm/test_llm_core.py
new file mode 100644
index 0000000..e41c508
--- /dev/null
+++ b/apps/backend/tests/llm/test_llm_core.py
@@ -0,0 +1,295 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+import torch
+
+PROJECT_ROOT = Path(__file__).resolve().parents[4]
+LIBS_DIR = PROJECT_ROOT / "libs"
+if str(LIBS_DIR) not in sys.path:
+    sys.path.insert(0, str(LIBS_DIR))
+
+from fl_core.llm.aggregation import AdapterClientUpdate, aggregate_adapter_state_dicts
+from fl_core.llm.artifacts import (
+    adapter_artifact_record,
+    load_adapter_artifact,
+    save_adapter_artifact,
+    sha256_file,
+)
+from fl_core.llm.config import normalize_llm_peft_config, parse_target_modules
+from fl_core.llm.data import SftRecord, format_sft_record_text, load_jsonl_sft_records, load_sft_records, split_records_by_client
+from fl_core.llm.metrics import append_llm_round_metrics, empty_llm_metrics_payload
+from fl_core.llm import trainer as llm_trainer
+from fl_core.llm.trainer import TokenizedSftDataset
+
+
+def _base_config(tmp_path: Path) -> dict:
+    dataset_path = tmp_path / "train.jsonl"
+    dataset_path.write_text(
+        "\n".join(
+            [
+                json.dumps({"prompt": "Q1", "completion": "A1"}),
+                json.dumps({"prompt": "Q2", "completion": "A2"}),
+            ]
+        ),
+        encoding="utf-8",
+    )
+    return {
+        "task": {"type": "llm_peft_sft"},
+        "llm": {
+            "base_model": "Qwen/Qwen2.5-0.5B-Instruct",
+            "tokenizer": "auto",
+            "max_seq_length": 512,
+            "precision": "bf16",
+        },
+        "sft": {
+            "dataset_path": str(dataset_path),
+            "format": "prompt_completion",
+            "prompt_template": "plain",
+        },
+        "peft": {
+            "method": "lora",
+            "rank": 8,
+            "alpha": 16,
+            "dropout": 0.05,
+            "target_modules": "q_proj, v_proj",
+            "quantization": "none",
+        },
+        "federated": {
+            "num_clients": 2,
+            "num_rounds": 1,
+            "clients_per_round": 1,
+            "local_epochs": 1,
+            "learning_rate": 0.0002,
+            "aggregation": "fedavg",
+            "seed": 7,
+        },
+    }
+
+
+def test_normalize_llm_peft_config_parses_nested_sections(tmp_path):
+    resume_path = tmp_path / "adapter.pt"
+    config = _base_config(tmp_path)
+    config["peft"]["resume_adapter_path"] = str(resume_path)
+
+    normalized = normalize_llm_peft_config(config)
+
+    assert normalized.task_type == "llm_peft_sft"
+    assert normalized.llm.base_model == "Qwen/Qwen2.5-0.5B-Instruct"
+    assert normalized.sft.dataset_path.name == "train.jsonl"
+    assert normalized.sft.per_device_train_batch_size == 1
+    assert normalized.sft.gradient_accumulation_steps == 1
+    assert normalized.sft.file_format == "auto"
+    assert normalized.sft.validation_split == 0.0
+    assert normalized.peft.target_modules == ("q_proj", "v_proj")
+    assert normalized.peft.resume_adapter_path == resume_path
+    assert normalized.federated.num_clients == 2
+    assert normalized.evaluation.enabled is False
+    assert normalized.evaluation.batch_size == 1
+
+
+def test_parse_target_modules_rejects_empty_values():
+    with pytest.raises(ValueError, match="target_modules"):
+        parse_target_modules(" , ")
+
+
+def test_normalize_llm_peft_config_parses_evaluation_section(tmp_path):
+    evaluation_path = tmp_path / "validation.jsonl"
+    evaluation_path.write_text(json.dumps({"prompt": "Q", "completion": "A"}), encoding="utf-8")
+    config = _base_config(tmp_path)
+    config["evaluation"] = {
+        "enable": True,
+        "dataset_path": str(evaluation_path),
+        "batch_size": 2,
+        "max_samples": 8,
+    }
+
+    normalized = normalize_llm_peft_config(config)
+
+    assert normalized.evaluation.enabled is True
+    assert normalized.evaluation.dataset_path == evaluation_path
+    assert normalized.evaluation.batch_size == 2
+    assert normalized.evaluation.max_samples == 8
+
+
+def test_load_jsonl_sft_records_prompt_completion_and_split(tmp_path):
+    config = normalize_llm_peft_config(_base_config(tmp_path))
+    records = load_jsonl_sft_records(config.sft.dataset_path, data_format=config.sft.format)
+    splits = split_records_by_client(records, num_clients=2, seed=123)
+
+    assert len(records) == 2
+    assert sorted(len(split) for split in splits) == [1, 1]
+    assert format_sft_record_text(records[0], data_format="prompt_completion", prompt_template="plain") == "Q1A1"
+
+
+def test_load_jsonl_sft_records_messages_format(tmp_path):
+    dataset_path = tmp_path / "messages.jsonl"
+    dataset_path.write_text(
+        json.dumps(
+            {
+                "messages": [
+                    {"role": "user", "content": "Hello"},
+                    {"role": "assistant", "content": "Hi"},
+                ]
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    [record] = load_jsonl_sft_records(dataset_path, data_format="messages")
+
+    assert record.messages[0]["role"] == "user"
+    assert "<|im_start|>user" in format_sft_record_text(record, data_format="messages", prompt_template="chatml")
+
+
+def test_load_sft_records_jsonl_still_works(tmp_path):
+    dataset_path = tmp_path / "train.jsonl"
+    dataset_path.write_text(json.dumps({"prompt": "Q", "completion": "A"}), encoding="utf-8")
+
+    [record] = load_sft_records(dataset_path, data_format="prompt_completion", file_format="auto")
+
+    assert record.prompt == "Q"
+    assert record.completion == "A"
+
+
+def test_load_alpaca_parquet_sft_records(tmp_path):
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    dataset_dir = tmp_path / "alpaca"
+    data_dir = dataset_dir / "data"
+    data_dir.mkdir(parents=True)
+    parquet_path = data_dir / "train-00000-of-00001-a09b74b3ef9c3b56.parquet"
+    table = pa.Table.from_pylist(
+        [
+            {
+                "instruction": "Summarize the note",
+                "input": "The run finished with lower loss.",
+                "output": "The run improved loss.",
+            },
+            {
+                "instruction": "Say hello",
+                "input": "",
+                "output": "Hello.",
+            },
+        ]
+    )
+    pq.write_table(table, parquet_path)
+
+    records = load_sft_records(dataset_dir, data_format="alpaca", file_format="auto")
+
+    assert len(records) == 2
+    assert records[0].prompt == (
+        "Instruction: Summarize the note\n"
+        "Input: The run finished with lower loss.\n"
+        "Answer:"
+    )
+    assert records[0].completion == " The run improved loss."
+    assert records[1].prompt == "Instruction: Say hello\nAnswer:"
+    assert records[1].completion == " Hello."
+    assert format_sft_record_text(records[0], data_format="alpaca", prompt_template="plain").endswith(
+        " The run improved loss."
+    )
+
+
+def test_aggregate_adapter_state_dicts_weighted_by_examples():
+    update_a = AdapterClientUpdate(
+        adapter_state={"lora_A": torch.tensor([1.0, 3.0])},
+        num_examples=1,
+    )
+    update_b = AdapterClientUpdate(
+        adapter_state={"lora_A": torch.tensor([3.0, 5.0])},
+        num_examples=3,
+    )
+
+    aggregated = aggregate_adapter_state_dicts([update_a, update_b])
+
+    assert torch.allclose(aggregated["lora_A"], torch.tensor([2.5, 4.5]))
+
+
+def test_aggregate_adapter_state_dicts_rejects_shape_mismatch():
+    update_a = AdapterClientUpdate(adapter_state={"lora_A": torch.tensor([1.0])}, num_examples=1)
+    update_b = AdapterClientUpdate(adapter_state={"lora_A": torch.tensor([[1.0]])}, num_examples=1)
+
+    with pytest.raises(ValueError, match="mismatched shape"):
+        aggregate_adapter_state_dicts([update_a, update_b])
+
+
+def test_adapter_artifact_round_trip_and_lineage_record(tmp_path):
+    artifact_path = save_adapter_artifact(
+        tmp_path / "adapter.pt",
+        {"lora_A": torch.tensor([1.0, 2.0])},
+        metadata={"round": 1},
+    )
+
+    adapter_state, metadata = load_adapter_artifact(artifact_path)
+    record = adapter_artifact_record(
+        artifact_path,
+        round_num=1,
+        size_bytes=8,
+        selected_clients=[0, 1],
+        parent_path="previous.pt",
+        parent_sha256="abc",
+    )
+
+    assert torch.allclose(adapter_state["lora_A"], torch.tensor([1.0, 2.0]))
+    assert metadata["round"] == 1
+    assert record["sha256"] == sha256_file(artifact_path)
+    assert record["parent_sha256"] == "abc"
+
+
+def test_empty_llm_metrics_payload_and_round_append(tmp_path):
+    config = normalize_llm_peft_config(_base_config(tmp_path))
+    payload = empty_llm_metrics_payload(config)
+    append_llm_round_metrics(payload, round_num=1, train_loss=2.0, validation_loss=1.0, token_throughput=12.5)
+
+    assert payload["experiment_info"]["basic"]["task_type"] == "llm_peft_sft"
+    assert payload["llm_results"]["rounds"] == [1]
+    assert payload["llm_artifacts"] == []
+    assert payload["llm_evaluation"] == {}
+    assert payload["llm_results"]["perplexity"][0] == pytest.approx(2.71828, rel=1e-4)
+    assert payload["global_results"]["global_loss"] == [1.0]
+
+
+def test_llm_round_append_without_validation_keeps_validation_series_empty(tmp_path):
+    config = normalize_llm_peft_config(_base_config(tmp_path))
+    payload = empty_llm_metrics_payload(config)
+    append_llm_round_metrics(payload, round_num=1, train_loss=2.0, token_throughput=12.5)
+
+    assert payload["llm_results"]["rounds"] == [1]
+    assert payload["llm_results"]["train_loss"] == [2.0]
+    assert payload["llm_results"]["validation_loss"] == []
+    assert payload["llm_results"]["perplexity"][0] == pytest.approx(7.38905, rel=1e-4)
+    assert payload["global_results"]["global_loss"] == [2.0]
+
+
+def test_tokenized_sft_dataset_uses_rendered_text():
+    class FakeTokenizer:
+        def __call__(self, text, *, truncation, max_length, padding):
+            assert truncation is True
+            assert padding is False
+            input_ids = [ord(ch) for ch in text[:max_length]]
+            return {"input_ids": input_ids, "attention_mask": [1] * len(input_ids)}
+
+    dataset = TokenizedSftDataset(
+        [SftRecord(prompt="abc", completion="def")],
+        tokenizer=FakeTokenizer(),
+        data_format="prompt_completion",
+        prompt_template="plain",
+        max_seq_length=4,
+    )
+
+    item = dataset[0]
+    assert item["input_ids"] == [97, 98, 99, 100]
+    assert item["labels"] == [-100, -100, -100, 100]
+    assert dataset.num_tokens == 4
+
+
+def test_llm_peft_progress_callback_handles_trainer_lifecycle_methods():
+    callback = llm_trainer._LlmPeftProgressCallback(round_num=1, client_id=0, total_steps=100)
+
+    assert callback.on_init_end(None, None, None) is None
+    assert callback.on_train_begin(None, None, None) is None
diff --git a/apps/backend/tests/runners/test_llm_peft_runtime.py b/apps/backend/tests/runners/test_llm_peft_runtime.py
new file mode 100644
index 0000000..df6e4dd
--- /dev/null
+++ b/apps/backend/tests/runners/test_llm_peft_runtime.py
@@ -0,0 +1,416 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import yaml
+import torch
+
+RUNNERS_DIR = Path(__file__).resolve().parents[2] / "runners"
+if str(RUNNERS_DIR) not in sys.path:
+    sys.path.insert(0, str(RUNNERS_DIR))
+
+import llm_peft_runtime  # noqa: E402
+from fl_core.llm.aggregation import AdapterClientUpdate  # noqa: E402
+from fl_core.llm.artifacts import save_adapter_artifact, sha256_file  # noqa: E402
+
+
+def test_llm_peft_runtime_writes_blocked_metrics_for_missing_dependencies(tmp_path, monkeypatch):
+    dataset_path = tmp_path / "train.jsonl"
+    dataset_path.write_text(
+        "\n".join(
+            [
+                json.dumps({"prompt": "hello", "completion": "world"}),
+                json.dumps({"prompt": "foo", "completion": "bar"}),
+            ]
+        ),
+        encoding="utf-8",
+    )
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text(
+        yaml.safe_dump(
+            {
+                "task": {"type": "llm_peft_sft"},
+                "llm": {"base_model": "tiny-model", "tokenizer": "auto", "max_seq_length": 128, "precision": "fp32"},
+                "sft": {"dataset_path": str(dataset_path), "format": "prompt_completion", "prompt_template": "plain"},
+                "peft": {
+                    "method": "lora",
+                    "rank": 4,
+                    "alpha": 8,
+                    "dropout": 0.0,
+                    "target_modules": "q_proj",
+                    "quantization": "none",
+                },
+                "federated": {
+                    "num_clients": 2,
+                    "num_rounds": 1,
+                    "clients_per_round": 1,
+                    "local_epochs": 1,
+                    "learning_rate": 0.0002,
+                    "aggregation": "fedavg",
+                    "seed": 1,
+                },
+                "logging": {"results_dir": "results"},
+            },
+            sort_keys=False,
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(llm_peft_runtime, "PROJECT_ROOT", tmp_path)
+    monkeypatch.setenv("FIGARO_RESULTS_FILE", "live_results_test.json")
+    monkeypatch.setattr(llm_peft_runtime, "missing_llm_runtime_dependencies", lambda: ["transformers", "peft"])
+
+    assert llm_peft_runtime.run_llm_peft_runtime(config_path) is False
+
+    metrics_path = tmp_path / "results" / "live_results_test.json"
+    metrics = json.loads(metrics_path.read_text(encoding="utf-8"))
+    assert metrics["llm_dataset"]["num_records"] == 2
+    assert metrics["llm_dataset"]["format"] == "prompt_completion"
+    assert metrics["llm_dataset"]["file_format"] == "jsonl"
+    assert metrics["llm_dataset"]["client_record_counts"] == [1, 1]
+    assert metrics["llm_runtime"]["reason"] == "missing_llm_runtime_dependencies"
+    assert metrics["llm_runtime"]["missing_dependencies"] == ["transformers", "peft"]
+
+
+def test_llm_peft_runtime_runs_client_training_and_aggregates_adapters(tmp_path, monkeypatch):
+    dataset_path = tmp_path / "train.jsonl"
+    dataset_path.write_text(
+        "\n".join(
+            [
+                json.dumps({"prompt": "p0", "completion": "c0"}),
+                json.dumps({"prompt": "p1", "completion": "c1"}),
+            ]
+        ),
+        encoding="utf-8",
+    )
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text(
+        yaml.safe_dump(
+            {
+                "task": {"type": "llm_peft_sft"},
+                "llm": {"base_model": "tiny-model", "tokenizer": "auto", "max_seq_length": 128, "precision": "fp32"},
+                "sft": {
+                    "dataset_path": str(dataset_path),
+                    "format": "prompt_completion",
+                    "prompt_template": "plain",
+                    "per_device_train_batch_size": 1,
+                    "gradient_accumulation_steps": 1,
+                },
+                "peft": {
+                    "method": "lora",
+                    "rank": 4,
+                    "alpha": 8,
+                    "dropout": 0.0,
+                    "target_modules": "q_proj",
+                    "quantization": "none",
+                },
+                "federated": {
+                    "num_clients": 2,
+                    "num_rounds": 1,
+                    "clients_per_round": 2,
+                    "local_epochs": 1,
+                    "learning_rate": 0.0002,
+                    "aggregation": "fedavg",
+                    "seed": 1,
+                },
+                "logging": {"results_dir": "results"},
+            },
+            sort_keys=False,
+        ),
+        encoding="utf-8",
+    )
+
+    class FakeTrainer:
+        def __init__(self, config):
+            self.config = config
+
+        def train_client(self, *, client_id, records, round_num, initial_adapter_state=None, output_dir=None):
+            assert round_num == 1
+            assert initial_adapter_state is None
+            assert output_dir is not None
+            value = float(client_id + 1)
+            return AdapterClientUpdate(
+                adapter_state={"lora_A": torch.tensor([value])},
+                num_examples=len(records),
+                num_tokens=10,
+                metrics={"train_loss": value},
+            )
+
+    monkeypatch.setattr(llm_peft_runtime, "PROJECT_ROOT", tmp_path)
+    monkeypatch.setenv("FIGARO_RESULTS_FILE", "live_results_test.json")
+    monkeypatch.setattr(llm_peft_runtime, "missing_llm_runtime_dependencies", lambda: [])
+    monkeypatch.setattr(llm_peft_runtime, "LlmPeftTrainer", FakeTrainer)
+
+    assert llm_peft_runtime.run_llm_peft_runtime(config_path) is True
+
+    metrics_path = tmp_path / "results" / "live_results_test.json"
+    metrics = json.loads(metrics_path.read_text(encoding="utf-8"))
+    assert metrics["llm_results"]["rounds"] == [1]
+    assert metrics["llm_results"]["train_loss"] == [1.5]
+    assert metrics["llm_results"]["validation_loss"] == []
+    assert metrics["client_results"]["client_0"]["rounds"] == [1]
+    assert metrics["client_results"]["client_1"]["rounds"] == [1]
+    assert metrics["llm_runtime"]["status"] == "completed"
+    assert len(metrics["llm_artifacts"]) == 1
+    assert metrics["llm_artifacts"][0]["round"] == 1
+    assert metrics["llm_artifacts"][0]["selected_clients"] == [0, 1]
+    adapter_path = Path(metrics["llm_runtime"]["latest_adapter_path"])
+    assert adapter_path.exists()
+    assert metrics["llm_runtime"]["latest_adapter_sha256"] == sha256_file(adapter_path)
+
+
+def test_llm_peft_runtime_evaluates_global_adapter_when_enabled(tmp_path, monkeypatch):
+    dataset_path = tmp_path / "train.jsonl"
+    dataset_path.write_text(
+        "\n".join(
+            [
+                json.dumps({"prompt": "p0", "completion": "c0"}),
+                json.dumps({"prompt": "p1", "completion": "c1"}),
+            ]
+        ),
+        encoding="utf-8",
+    )
+    evaluation_path = tmp_path / "validation.jsonl"
+    evaluation_path.write_text(
+        "\n".join(
+            [
+                json.dumps({"prompt": "v0", "completion": "a0"}),
+                json.dumps({"prompt": "v1", "completion": "a1"}),
+            ]
+        ),
+        encoding="utf-8",
+    )
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text(
+        yaml.safe_dump(
+            {
+                "task": {"type": "llm_peft_sft"},
+                "llm": {"base_model": "tiny-model", "tokenizer": "auto", "max_seq_length": 128, "precision": "fp32"},
+                "sft": {
+                    "dataset_path": str(dataset_path),
+                    "format": "prompt_completion",
+                    "prompt_template": "plain",
+                },
+                "peft": {
+                    "method": "lora",
+                    "rank": 4,
+                    "alpha": 8,
+                    "dropout": 0.0,
+                    "target_modules": "q_proj",
+                    "quantization": "none",
+                },
+                "evaluation": {
+                    "enable": True,
+                    "dataset_path": str(evaluation_path),
+                    "batch_size": 1,
+                    "max_samples": 1,
+                },
+                "federated": {
+                    "num_clients": 2,
+                    "num_rounds": 1,
+                    "clients_per_round": 2,
+                    "local_epochs": 1,
+                    "learning_rate": 0.0002,
+                    "aggregation": "fedavg",
+                    "seed": 1,
+                },
+                "logging": {"results_dir": "results"},
+            },
+            sort_keys=False,
+        ),
+        encoding="utf-8",
+    )
+
+    class FakeTrainer:
+        def __init__(self, config):
+            self.config = config
+
+        def train_client(self, *, client_id, records, round_num, initial_adapter_state=None, output_dir=None):
+            return AdapterClientUpdate(
+                adapter_state={"lora_A": torch.tensor([float(client_id + 1)])},
+                num_examples=len(records),
+                num_tokens=10,
+                metrics={"train_loss": float(client_id + 1)},
+            )
+
+        def evaluate_adapter(self, *, records, adapter_state, output_dir=None):
+            assert len(records) == 1
+            assert adapter_state is not None
+            assert torch.allclose(adapter_state["lora_A"], torch.tensor([1.5]))
+            assert output_dir is not None
+            return {"validation_loss": 0.25, "num_examples": len(records), "num_tokens": 4}
+
+    monkeypatch.setattr(llm_peft_runtime, "PROJECT_ROOT", tmp_path)
+    monkeypatch.setenv("FIGARO_RESULTS_FILE", "live_results_eval.json")
+    monkeypatch.setattr(llm_peft_runtime, "missing_llm_runtime_dependencies", lambda: [])
+    monkeypatch.setattr(llm_peft_runtime, "LlmPeftTrainer", FakeTrainer)
+
+    assert llm_peft_runtime.run_llm_peft_runtime(config_path) is True
+
+    metrics = json.loads((tmp_path / "results" / "live_results_eval.json").read_text(encoding="utf-8"))
+    assert metrics["llm_evaluation"]["enabled"] is True
+    assert metrics["llm_evaluation"]["num_records"] == 1
+    assert metrics["llm_evaluation"]["last_validation_loss"] == 0.25
+    assert metrics["llm_results"]["validation_loss"] == [0.25]
+    assert metrics["global_results"]["global_loss"] == [0.25]
+
+
+def test_llm_peft_runtime_allows_prompt_completion_eval_for_alpaca_training(tmp_path, monkeypatch):
+    dataset_path = tmp_path / "alpaca.jsonl"
+    dataset_path.write_text(
+        "\n".join(
+            [
+                json.dumps({"instruction": "Do one thing", "input": "", "output": "done"}),
+                json.dumps({"instruction": "Do another thing", "input": "x", "output": "done x"}),
+            ]
+        ),
+        encoding="utf-8",
+    )
+    evaluation_path = tmp_path / "validation.jsonl"
+    evaluation_path.write_text(
+        json.dumps({"prompt": "v0", "completion": "a0"}),
+        encoding="utf-8",
+    )
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text(
+        yaml.safe_dump(
+            {
+                "task": {"type": "llm_peft_sft"},
+                "llm": {"base_model": "tiny-model", "tokenizer": "auto", "max_seq_length": 128, "precision": "fp32"},
+                "sft": {
+                    "dataset_path": str(dataset_path),
+                    "format": "alpaca",
+                    "file_format": "auto",
+                    "prompt_template": "plain",
+                },
+                "peft": {
+                    "method": "lora",
+                    "rank": 4,
+                    "alpha": 8,
+                    "dropout": 0.0,
+                    "target_modules": "q_proj",
+                    "quantization": "none",
+                },
+                "evaluation": {
+                    "enable": True,
+                    "dataset_path": str(evaluation_path),
+                    "batch_size": 1,
+                    "max_samples": 1,
+                },
+                "federated": {
+                    "num_clients": 2,
+                    "num_rounds": 1,
+                    "clients_per_round": 2,
+                    "local_epochs": 1,
+                    "learning_rate": 0.0002,
+                    "aggregation": "fedavg",
+                    "seed": 1,
+                },
+                "logging": {"results_dir": "results"},
+            },
+            sort_keys=False,
+        ),
+        encoding="utf-8",
+    )
+
+    class FakeTrainer:
+        def __init__(self, config):
+            self.config = config
+
+        def train_client(self, *, client_id, records, round_num, initial_adapter_state=None, output_dir=None):
+            assert records[0].prompt.startswith("Instruction:")
+            return AdapterClientUpdate(
+                adapter_state={"lora_A": torch.tensor([float(client_id + 1)])},
+                num_examples=len(records),
+                num_tokens=10,
+                metrics={"train_loss": float(client_id + 1)},
+            )
+
+        def evaluate_adapter(self, *, records, adapter_state, output_dir=None):
+            assert records[0].prompt == "v0"
+            return {"validation_loss": 0.5, "num_examples": len(records), "num_tokens": 4}
+
+    monkeypatch.setattr(llm_peft_runtime, "PROJECT_ROOT", tmp_path)
+    monkeypatch.setenv("FIGARO_RESULTS_FILE", "live_results_eval_mixed.json")
+    monkeypatch.setattr(llm_peft_runtime, "missing_llm_runtime_dependencies", lambda: [])
+    monkeypatch.setattr(llm_peft_runtime, "LlmPeftTrainer", FakeTrainer)
+
+    assert llm_peft_runtime.run_llm_peft_runtime(config_path) is True
+
+    metrics = json.loads((tmp_path / "results" / "live_results_eval_mixed.json").read_text(encoding="utf-8"))
+    assert metrics["llm_dataset"]["format"] == "alpaca"
+    assert metrics["llm_evaluation"]["format"] == "prompt_completion"
+    assert metrics["llm_results"]["validation_loss"] == [0.5]
+
+
+def test_llm_peft_runtime_resumes_from_adapter_artifact(tmp_path, monkeypatch):
+    dataset_path = tmp_path / "train.jsonl"
+    dataset_path.write_text(json.dumps({"prompt": "p0", "completion": "c0"}), encoding="utf-8")
+    resume_path = save_adapter_artifact(
+        tmp_path / "resume_adapter.pt",
+        {"lora_A": torch.tensor([9.0])},
+        metadata={"round": 7},
+    )
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text(
+        yaml.safe_dump(
+            {
+                "task": {"type": "llm_peft_sft"},
+                "llm": {"base_model": "tiny-model", "tokenizer": "auto", "max_seq_length": 128, "precision": "fp32"},
+                "sft": {
+                    "dataset_path": str(dataset_path),
+                    "format": "prompt_completion",
+                    "prompt_template": "plain",
+                },
+                "peft": {
+                    "method": "lora",
+                    "rank": 4,
+                    "alpha": 8,
+                    "dropout": 0.0,
+                    "target_modules": "q_proj",
+                    "resume_adapter_path": str(resume_path),
+                    "quantization": "none",
+                },
+                "federated": {
+                    "num_clients": 1,
+                    "num_rounds": 1,
+                    "clients_per_round": 1,
+                    "local_epochs": 1,
+                    "learning_rate": 0.0002,
+                    "aggregation": "fedavg",
+                    "seed": 1,
+                },
+                "logging": {"results_dir": "results"},
+            },
+            sort_keys=False,
+        ),
+        encoding="utf-8",
+    )
+
+    class FakeTrainer:
+        def __init__(self, config):
+            self.config = config
+
+        def train_client(self, *, client_id, records, round_num, initial_adapter_state=None, output_dir=None):
+            assert initial_adapter_state is not None
+            assert torch.allclose(initial_adapter_state["lora_A"], torch.tensor([9.0]))
+            return AdapterClientUpdate(
+                adapter_state={"lora_A": torch.tensor([10.0])},
+                num_examples=len(records),
+                num_tokens=5,
+                metrics={"train_loss": 0.5},
+            )
+
+    monkeypatch.setattr(llm_peft_runtime, "PROJECT_ROOT", tmp_path)
+    monkeypatch.setenv("FIGARO_RESULTS_FILE", "live_results_resume.json")
+    monkeypatch.setattr(llm_peft_runtime, "missing_llm_runtime_dependencies", lambda: [])
+    monkeypatch.setattr(llm_peft_runtime, "LlmPeftTrainer", FakeTrainer)
+
+    assert llm_peft_runtime.run_llm_peft_runtime(config_path) is True
+
+    metrics = json.loads((tmp_path / "results" / "live_results_resume.json").read_text(encoding="utf-8"))
+    artifact = metrics["llm_artifacts"][0]
+    assert artifact["parent_path"] == str(resume_path)
+    assert artifact["parent_sha256"] == sha256_file(resume_path)
+    assert metrics["llm_runtime"]["latest_adapter_sha256"] == artifact["sha256"]
diff --git a/apps/backend/tests/runners/test_runtime_dispatcher.py b/apps/backend/tests/runners/test_runtime_dispatcher.py
new file mode 100644
index 0000000..3239be5
--- /dev/null
+++ b/apps/backend/tests/runners/test_runtime_dispatcher.py
@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import sys
+import types
+from pathlib import Path
+
+import pytest
+import yaml
+
+RUNNERS_DIR = Path(__file__).resolve().parents[2] / "runners"
+if str(RUNNERS_DIR) not in sys.path:
+    sys.path.insert(0, str(RUNNERS_DIR))
+
+from runtime_dispatcher import get_runtime_mode, get_task_type, run_runtime  # noqa: E402
+
+
+def _write_config(tmp_path: Path, config: dict) -> Path:
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text(yaml.safe_dump(config, sort_keys=False), encoding="utf-8")
+    return config_path
+
+
+def test_get_task_type_defaults_legacy_configs_to_classic_fl():
+    assert get_task_type({}) == "classic_fl"
+    assert get_task_type({"task": {}}) == "classic_fl"
+
+
+def test_get_runtime_mode_defaults_legacy_configs_to_simulation():
+    assert get_runtime_mode({}) == "simulation"
+    assert get_runtime_mode({"system": {}}) == "simulation"
+
+
+def test_run_runtime_dispatches_classic_route(tmp_path, monkeypatch):
+    called = {}
+
+    def fake_run(path: Path) -> bool:
+        called["path"] = path
+        return True
+
+    fake_module = types.SimpleNamespace(run_classic_fl_runtime=fake_run)
+    monkeypatch.setitem(sys.modules, "classic_fl_runtime", fake_module)
+
+    config_path = _write_config(tmp_path, {"task": {"type": "classic_fl"}})
+
+    assert run_runtime(config_path) is True
+    assert called["path"] == config_path
+
+
+def test_run_runtime_dispatches_llm_peft_route(tmp_path, monkeypatch):
+    called = {}
+
+    def fake_run(path: Path) -> bool:
+        called["path"] = path
+        return False
+
+    fake_module = types.SimpleNamespace(run_llm_peft_runtime=fake_run)
+    monkeypatch.setitem(sys.modules, "llm_peft_runtime", fake_module)
+
+    config_path = _write_config(tmp_path, {"task": {"type": "llm_peft_sft"}})
+
+    assert run_runtime(config_path) is False
+    assert called["path"] == config_path
+
+
+def test_run_runtime_rejects_llm_peft_distributed_route(tmp_path):
+    config_path = _write_config(
+        tmp_path,
+        {
+            "task": {"type": "llm_peft_sft"},
+            "system": {"mode": "distributed"},
+        },
+    )
+
+    with pytest.raises(ValueError, match="simulation mode only"):
+        run_runtime(config_path)
+
+
+def test_run_runtime_rejects_unknown_task_type(tmp_path):
+    config_path = _write_config(tmp_path, {"task": {"type": "unknown"}})
+
+    with pytest.raises(ValueError, match="Unsupported task.type"):
+        run_runtime(config_path)
diff --git a/apps/backend/tests/schemas/test_contracts.py b/apps/backend/tests/schemas/test_contracts.py
index 488a136..27dbc57 100644
--- a/apps/backend/tests/schemas/test_contracts.py
+++ b/apps/backend/tests/schemas/test_contracts.py
@@ -85,6 +85,10 @@ def test_metrics_and_progress_schema_defaults_and_parsing():
     assert metrics.global_results.rounds == []
     assert metrics.global_results.global_loss == []
     assert metrics.global_results.global_accuracy == []
+    assert metrics.llm_results.rounds == []
+    assert metrics.llm_dataset == {}
+    assert metrics.llm_evaluation == {}
+    assert metrics.llm_artifacts == []
     assert metrics.client_results == {}
 
     parsed = SimulationRunMetricsResponse.model_validate(
diff --git a/apps/backend/tests/services/agent/test_experiment_run_artifacts.py b/apps/backend/tests/services/agent/test_experiment_run_artifacts.py
new file mode 100644
index 0000000..8522b76
--- /dev/null
+++ b/apps/backend/tests/services/agent/test_experiment_run_artifacts.py
@@ -0,0 +1,20 @@
+from app.services.agent.experiment_service import AgentExperimentRunService
+
+
+class _DummySession:
+    pass
+
+
+def test_agent_experiment_run_artifact_paths_share_timestamp(tmp_path):
+    service = AgentExperimentRunService(session=_DummySession())  # type: ignore[arg-type]
+    service._job_config_dir = lambda: tmp_path / "configs"  # type: ignore[method-assign]
+    service._results_dir = lambda: tmp_path / "results"  # type: ignore[method-assign]
+    service._runtime_log_dir = lambda: tmp_path / "logs"  # type: ignore[method-assign]
+    timestamp = "20260603_151122Z"
+    run_id = "abc12345"
+
+    assert service._run_config_path(run_id, artifact_timestamp=timestamp).name == f"{timestamp}_{run_id}.json"
+    assert service._build_live_results_filename(run_id, artifact_timestamp=timestamp) == (
+        f"{timestamp}_{run_id}_live_results.json"
+    )
+    assert service._run_log_path(run_id, artifact_timestamp=timestamp).name == f"{timestamp}_{run_id}_server.log"
diff --git a/apps/backend/tests/services/agent/test_history_service.py b/apps/backend/tests/services/agent/test_history_service.py
new file mode 100644
index 0000000..5a86db6
--- /dev/null
+++ b/apps/backend/tests/services/agent/test_history_service.py
@@ -0,0 +1,19 @@
+from app.services.agent.history_service import AgentOptimizationHistoryService
+
+
+def test_config_version_candidates_only_include_experiments():
+    snapshot = {
+        "draft_experiments": [
+            {"name": "draft alpha", "config_patch": {"dataset": {"alpha": 0.2}}},
+        ],
+        "experiments": [
+            {"run_id": "run-1", "iteration": 1, "name": "alpha_0.1", "config": {"dataset": {"alpha": 0.1}}},
+            {"run_id": "run-2", "iteration": 2, "name": "alpha_0.3", "config": {"dataset": {"alpha": 0.3}}},
+        ],
+        "best_config": {"dataset": {"alpha": 0.3}},
+    }
+
+    candidates = AgentOptimizationHistoryService._build_config_version_candidates(snapshot)
+
+    assert [candidate["source"] for candidate in candidates] == ["experiment", "experiment"]
+    assert [candidate["label"] for candidate in candidates] == ["alpha_0.1", "alpha_0.3"]
diff --git a/apps/backend/tests/services/agent/test_planning.py b/apps/backend/tests/services/agent/test_planning.py
index 0fa66db..9470397 100644
--- a/apps/backend/tests/services/agent/test_planning.py
+++ b/apps/backend/tests/services/agent/test_planning.py
@@ -3,6 +3,10 @@
     build_initial_config,
     build_schema_prompt_context,
     collect_disabled_option_errors,
+    deep_merge_config,
+    infer_sft_settings_for_dataset_path,
+    lock_structured_constraints,
+    merge_llm_resource_constraints,
     select_llm_model,
 )
 
@@ -43,12 +47,70 @@ def test_build_initial_config_uses_schema_defaults():
 
 def test_build_initial_config_hardcoded_defaults_on_empty_schema():
     cfg = build_initial_config({})
+    assert cfg["task"]["type"] == "classic_fl"
     assert cfg["dataset"]["name"] == "CIFAR-10"
-    assert cfg["model"]["name"] == "CNN"
+    assert cfg["model"]["name"] == "Auto"
     assert cfg["federated"]["num_clients"] == 3
     assert cfg["federated"]["num_rounds"] == 10
 
 
+def test_lock_structured_constraints_override_llm_patch_values():
+    constrained_base = {
+        "dataset": {"name": "FEMNIST", "alpha": 0.5},
+        "model": {"name": "LeNet"},
+        "federated": {"aggregation": "fedavg"},
+    }
+    llm_patch = {
+        "dataset": {"name": "CIFAR-10", "alpha": 0.1},
+        "model": {"name": "Auto"},
+    }
+    constraints = {"dataset": {"name": "FEMNIST"}, "model": {"name": "LeNet"}}
+
+    merged = deep_merge_config(constrained_base, llm_patch)
+    locked = lock_structured_constraints(merged, constraints)
+
+    assert locked["dataset"]["name"] == "FEMNIST"
+    assert locked["dataset"]["alpha"] == 0.1
+    assert locked["model"]["name"] == "LeNet"
+
+
+def test_llm_resource_constraints_lock_effective_dataset_defaults():
+    constrained_base = {
+        "task": {"type": "llm_peft_sft"},
+        "llm": {"base_model": "./models/llm/tiny"},
+        "sft": {"dataset_path": "./datasets/llm/alpaca"},
+        "evaluation": {"enable": True, "dataset_path": "./datasets/llm/validation.jsonl"},
+    }
+    llm_patch = {
+        "sft": {"dataset_path": "./datasets/llm/train.jsonl"},
+        "evaluation": {"dataset_path": "./datasets/llm/train.jsonl"},
+    }
+
+    constraints = merge_llm_resource_constraints(constrained_base, {})
+    locked = lock_structured_constraints(deep_merge_config(constrained_base, llm_patch), constraints)
+
+    assert locked["llm"]["base_model"] == "./models/llm/tiny"
+    assert locked["sft"]["dataset_path"] == "./datasets/llm/alpaca"
+    assert locked["sft"]["file_format"] == "auto"
+    assert locked["sft"]["format"] == "alpaca"
+    assert locked["evaluation"]["dataset_path"] == "./datasets/llm/validation.jsonl"
+
+
+def test_infer_sft_settings_from_dataset_path():
+    assert infer_sft_settings_for_dataset_path("./datasets/llm/train.jsonl") == {
+        "file_format": "jsonl",
+        "format": "prompt_completion",
+    }
+    assert infer_sft_settings_for_dataset_path("./datasets/llm/alpaca") == {
+        "file_format": "auto",
+        "format": "alpaca",
+    }
+    assert infer_sft_settings_for_dataset_path("./datasets/llm/chat.parquet") == {
+        "file_format": "parquet",
+        "format": "messages",
+    }
+
+
 def test_schema_prompt_context_marks_disabled_options():
     schema = {
         "federated": {
diff --git a/apps/backend/tests/services/agent/test_prompts.py b/apps/backend/tests/services/agent/test_prompts.py
index 7e22388..b7916ba 100644
--- a/apps/backend/tests/services/agent/test_prompts.py
+++ b/apps/backend/tests/services/agent/test_prompts.py
@@ -17,6 +17,8 @@ def test_build_plan_system_instructions_includes_global_prompt():
     instructions = build_plan_system_instructions("test alpha=0.1,0.3")
     assert "User experiment request" in instructions
     assert "test alpha=0.1,0.3" in instructions
+    assert "LLM PEFT simulation" in instructions
+    assert "validation or perplexity" in instructions
 
 
 def test_build_plan_prompt_includes_history_and_context():
@@ -49,5 +51,6 @@ def test_build_plan_prompt_includes_history_and_context():
     assert "Schema context from config_schema.yaml" in prompt
     assert "User-selected structured constraints" in prompt
     assert "disabled_options" in prompt
+    assert "evaluation.enable=true" in prompt
     assert "ResNet" in prompt
     assert "Return ONLY a JSON object" in prompt
diff --git a/apps/backend/tests/services/agent/test_summary.py b/apps/backend/tests/services/agent/test_summary.py
index 1fbab80..43ed771 100644
--- a/apps/backend/tests/services/agent/test_summary.py
+++ b/apps/backend/tests/services/agent/test_summary.py
@@ -2,7 +2,10 @@
 from app.services.agent.summary import (
     build_results_table,
     build_summary_text,
+    get_agent_run_score,
     get_last_global_accuracy,
+    get_last_llm_train_loss,
+    get_last_llm_validation_loss,
 )
 
 
@@ -16,6 +19,18 @@ def test_get_last_global_accuracy_returns_none_for_empty():
     assert get_last_global_accuracy({"global_results": {}}) is None
 
 
+def test_agent_run_score_uses_negative_llm_train_loss():
+    metrics = {"llm_results": {"train_loss": [1.2, 0.8]}}
+    assert get_last_llm_train_loss(metrics) == 0.8
+    assert get_agent_run_score(metrics) == -0.8
+
+
+def test_agent_run_score_prefers_llm_validation_loss():
+    metrics = {"llm_results": {"train_loss": [0.8], "validation_loss": [0.6]}}
+    assert get_last_llm_validation_loss(metrics) == 0.6
+    assert get_agent_run_score(metrics) == -0.6
+
+
 def test_build_results_table_formats_experiments():
     state = AgentState(goal="test experiments")
     state.experiment_results = [
@@ -89,3 +104,31 @@ def test_build_summary_text_reports_best_and_worst():
     assert "Completed 2 experiments" in summary
     assert "Best accuracy: 0.8500 (high)" in summary
     assert "Worst accuracy: 0.3300 (low)" in summary
+
+
+def test_build_summary_text_reports_llm_loss_when_present():
+    state = AgentState(goal="test llm")
+    state.experiment_results = [
+        ExperimentRecord(
+            iteration=1,
+            run_id="run-1",
+            job_id=10,
+            name="rank-8",
+            config={"task": {"type": "llm_peft_sft"}, "federated": {}},
+            metrics={"llm_results": {"rounds": [1], "train_loss": [0.9]}},
+            score=-0.9,
+        ),
+        ExperimentRecord(
+            iteration=2,
+            run_id="run-2",
+            job_id=11,
+            name="rank-16",
+            config={"task": {"type": "llm_peft_sft"}, "federated": {}},
+            metrics={"llm_results": {"rounds": [1], "train_loss": [0.7]}},
+            score=-0.7,
+        ),
+    ]
+
+    summary = build_summary_text(state=state)
+    assert "Best LLM loss: train_loss=0.7000 (rank-16)" in summary
+    assert "Worst LLM loss: train_loss=0.9000 (rank-8)" in summary
diff --git a/apps/backend/tests/services/distributed/test_distributed_job_service.py b/apps/backend/tests/services/distributed/test_distributed_job_service.py
index c3f5657..70244fe 100644
--- a/apps/backend/tests/services/distributed/test_distributed_job_service.py
+++ b/apps/backend/tests/services/distributed/test_distributed_job_service.py
@@ -129,6 +129,18 @@ async def _run():
     asyncio.run(_run())
 
 
+def test_normalize_server_config_rejects_llm_peft_route():
+    service = DistributedJobService(session=_DummySession())  # type: ignore[arg-type]
+
+    with pytest.raises(exceptions.BadRequestError, match="simulation mode only"):
+        service.config_service.normalize_server_config(
+            {
+                "task": {"type": "llm_peft_sft"},
+                "federated": {"num_clients": 2},
+            }
+        )
+
+
 def test_update_job_config_normalizes_and_persists(monkeypatch):
     async def _run():
         session = _DummySession()
diff --git a/apps/backend/tests/services/test_job_service.py b/apps/backend/tests/services/test_job_service.py
index 9bd3220..02662c6 100644
--- a/apps/backend/tests/services/test_job_service.py
+++ b/apps/backend/tests/services/test_job_service.py
@@ -6,6 +6,7 @@
 
 def test_normalize_simulation_config_public_api_returns_invariants():
     normalized = SimulationJobService.normalize_simulation_config({})
+    assert normalized["task"]["type"] == "classic_fl"
     assert normalized["system"]["mode"] == "simulation"
     assert normalized["system"]["node_role"] == "server"
 
@@ -25,3 +26,95 @@ def test_normalize_simulation_config_keeps_dataset_and_federated_client_counts_a
 
     assert normalized["federated"]["num_clients"] == 5
     assert normalized["dataset"]["num_clients"] == 5
+
+
+def test_normalize_simulation_config_allows_auto_model_for_dataset_switch():
+    normalized = SimulationJobService.normalize_simulation_config(
+        {
+            "dataset": {"name": "MNIST"},
+            "model": {"name": "Auto"},
+        }
+    )
+
+    assert normalized["dataset"]["name"] == "MNIST"
+    assert normalized["model"]["name"] == "Auto"
+    assert normalized["model"]["input_shape"] == [1, 28, 28]
+    assert normalized["model"]["num_classes"] == 10
+
+
+def test_normalize_simulation_config_rejects_incompatible_model():
+    with pytest.raises(exceptions.BadRequestError, match="not compatible"):
+        SimulationJobService.normalize_simulation_config(
+            {
+                "dataset": {"name": "AG News"},
+                "model": {"name": "ResNet18"},
+            }
+        )
+
+
+def test_normalize_simulation_config_bypasses_classic_compatibility_for_llm_peft_route():
+    normalized = SimulationJobService.normalize_simulation_config(
+        {
+            "task": {"type": "llm_peft_sft"},
+            "dataset": {"name": "AG News"},
+            "model": {"name": "ResNet18"},
+        }
+    )
+
+    assert normalized["task"]["type"] == "llm_peft_sft"
+    assert normalized["dataset"]["name"] == "AG News"
+    assert normalized["model"]["name"] == "ResNet18"
+
+
+def test_normalize_simulation_config_rejects_ckks_with_sparsification():
+    with pytest.raises(exceptions.BadRequestError, match="not compatible"):
+        SimulationJobService.normalize_simulation_config(
+            {
+                "privacy": {"homomorphic_encryption": {"enable": True}},
+                "compression": {"sparsification": {"enable": True}},
+            }
+        )
+
+
+def test_normalize_simulation_config_accepts_dp_with_compression():
+    normalized = SimulationJobService.normalize_simulation_config(
+        {
+            "privacy": {
+                "differential_privacy": {
+                    "enable": True,
+                    "clipping_norm": 1.0,
+                    "noise_multiplier": 0.1,
+                }
+            },
+            "compression": {
+                "sparsification": {
+                    "enable": True,
+                    "method": "random_k",
+                    "ratio": 0.25,
+                }
+            },
+        }
+    )
+
+    assert normalized["privacy"]["differential_privacy"]["enable"] is True
+    assert normalized["compression"]["sparsification"]["method"] == "random_k"
+
+
+def test_normalize_simulation_config_rejects_secure_aggregation_with_weighted_avg():
+    with pytest.raises(exceptions.BadRequestError, match="equal-weight"):
+        SimulationJobService.normalize_simulation_config(
+            {
+                "federated": {"aggregation": "weighted_avg"},
+                "privacy": {"secure_aggregation": {"enable": True}},
+            }
+        )
+
+
+def test_normalize_simulation_config_rejects_secure_aggregation_with_compression():
+    with pytest.raises(exceptions.BadRequestError, match="not compatible"):
+        SimulationJobService.normalize_simulation_config(
+            {
+                "privacy": {"secure_aggregation": {"enable": True}},
+                "compression": {"sparsification": {"enable": True}},
+            }
+        )
diff --git a/apps/backend/tests/services/test_llm_resources.py b/apps/backend/tests/services/test_llm_resources.py
new file mode 100644
index 0000000..14b2ea0
--- /dev/null
+++ b/apps/backend/tests/services/test_llm_resources.py
@@ -0,0 +1,196 @@
+from app.services.llm_resources import (
+    DEFAULT_LLM_BASE_MODEL,
+    DEFAULT_LLM_DATASET_PATH,
+    DEFAULT_LLM_EVALUATION_DATASET_PATH,
+    augment_config_schema_with_llm_resources,
+    discover_llm_dataset_options,
+    discover_llm_evaluation_dataset_options,
+    discover_llm_model_options,
+    get_llm_resource_options,
+)
+
+
+def test_discovers_local_llm_model_directories(tmp_path):
+    model_dir = tmp_path / "models" / "llm" / "tiny-model"
+    model_dir.mkdir(parents=True)
+    nested_model_dir = tmp_path / "models" / "llm" / "nested" / "snapshot"
+    nested_model_dir.mkdir(parents=True)
+    (nested_model_dir / "config.json").write_text("{}", encoding="utf-8")
+    hidden_model_dir = tmp_path / "models" / "llm" / ".hidden-model"
+    hidden_model_dir.mkdir(parents=True)
+
+    options = discover_llm_model_options(tmp_path)
+
+    assert "./models/llm/tiny-model" in options
+    assert "./models/llm/nested/snapshot" in options
+    assert "./models/llm/.hidden-model" not in options
+
+
+def test_discovers_hf_snapshot_model_directory(tmp_path):
+    snapshot_dir = tmp_path / "models" / "llm" / "Qwen2.5-7B-Instruct" / "snapshots" / "abc"
+    snapshot_dir.mkdir(parents=True)
+    (snapshot_dir / "config.json").write_text("{}", encoding="utf-8")
+
+    options = discover_llm_model_options(tmp_path)
+
+    assert "./models/llm/Qwen2.5-7B-Instruct" in options
+    assert "./models/llm/Qwen2.5-7B-Instruct/snapshots/abc" not in options
+
+
+def test_discovers_local_llm_jsonl_datasets(tmp_path):
+    dataset_dir = tmp_path / "datasets" / "llm"
+    dataset_dir.mkdir(parents=True)
+    (dataset_dir / "train.jsonl").write_text('{"prompt":"p","completion":"c"}\n', encoding="utf-8")
+    (dataset_dir / "custom.jsonl").write_text('{"prompt":"p","completion":"c"}\n', encoding="utf-8")
+    (dataset_dir / "validation.jsonl").write_text('{"prompt":"p","completion":"c"}\n', encoding="utf-8")
+    nested_dir = dataset_dir / "alpaca"
+    nested_dir.mkdir()
+    (nested_dir / "train.jsonl").write_text('{"prompt":"p","completion":"c"}\n', encoding="utf-8")
+    (dataset_dir / "notes.txt").write_text("ignore me", encoding="utf-8")
+
+    options = discover_llm_dataset_options(tmp_path)
+
+    assert options == [
+        "./datasets/llm/alpaca/train.jsonl",
+        "./datasets/llm/custom.jsonl",
+        "./datasets/llm/train.jsonl",
+    ]
+
+
+def test_discovers_parquet_dataset_directory(tmp_path):
+    parquet_path = (
+        tmp_path
+        / "datasets"
+        / "llm"
+        / "alpaca"
+        / "data"
+        / "train-00000-of-00001.parquet"
+    )
+    parquet_path.parent.mkdir(parents=True)
+    parquet_path.write_bytes(b"parquet-placeholder")
+
+    options = discover_llm_dataset_options(tmp_path)
+
+    assert "./datasets/llm/alpaca" in options
+    assert "./datasets/llm/alpaca/data/train-00000-of-00001.parquet" not in options
+
+
+def test_discovers_evaluation_dataset_options_including_validation(tmp_path):
+    dataset_dir = tmp_path / "datasets" / "llm"
+    dataset_dir.mkdir(parents=True)
+    (dataset_dir / "train.jsonl").write_text('{"prompt":"p","completion":"c"}\n', encoding="utf-8")
+    (dataset_dir / "validation.jsonl").write_text('{"prompt":"p","completion":"c"}\n', encoding="utf-8")
+
+    options = discover_llm_evaluation_dataset_options(tmp_path)
+
+    assert options == [
+        "./datasets/llm/train.jsonl",
+        "./datasets/llm/validation.jsonl",
+    ]
+
+
+def test_augments_schema_with_default_and_discovered_llm_options(tmp_path):
+    (tmp_path / "models" / "llm" / "tiny-model").mkdir(parents=True)
+    dataset_dir = tmp_path / "datasets" / "llm"
+    dataset_dir.mkdir(parents=True)
+    (dataset_dir / "train.jsonl").write_text('{"prompt":"p","completion":"c"}\n', encoding="utf-8")
+    (dataset_dir / "custom.jsonl").write_text('{"prompt":"p","completion":"c"}\n', encoding="utf-8")
+    (dataset_dir / "validation.jsonl").write_text('{"prompt":"p","completion":"c"}\n', encoding="utf-8")
+    schema = {
+        "llm": {
+            "base_model": {
+                "type": "text",
+                "default": DEFAULT_LLM_BASE_MODEL,
+                "ui": {},
+            }
+        },
+        "sft": {
+            "dataset_path": {
+                "type": "text",
+                "default": DEFAULT_LLM_DATASET_PATH,
+                "ui": {},
+            }
+        },
+        "evaluation": {
+            "enable": {
+                "type": "bool",
+                "default": False,
+                "ui": {},
+            },
+            "dataset_path": {
+                "type": "text",
+                "default": DEFAULT_LLM_EVALUATION_DATASET_PATH,
+                "ui": {},
+            }
+        },
+    }
+
+    augmented = augment_config_schema_with_llm_resources(schema, tmp_path)
+
+    assert augmented["llm"]["base_model"]["options"] == [
+        "./models/llm/tiny-model",
+    ]
+    assert augmented["llm"]["base_model"]["default"] == "./models/llm/tiny-model"
+    assert augmented["llm"]["base_model"]["ui"]["option_source"]["path"] == "./models/llm"
+    assert augmented["sft"]["dataset_path"]["options"] == [
+        "./datasets/llm/custom.jsonl",
+        "./datasets/llm/train.jsonl",
+    ]
+    assert augmented["sft"]["dataset_path"]["default"] == "./datasets/llm/custom.jsonl"
+    assert augmented["sft"]["dataset_path"]["ui"]["option_source"]["path"] == "./datasets/llm"
+    assert augmented["evaluation"]["dataset_path"]["options"] == [
+        "./datasets/llm/custom.jsonl",
+        "./datasets/llm/train.jsonl",
+        "./datasets/llm/validation.jsonl",
+    ]
+    assert augmented["evaluation"]["dataset_path"]["default"] == "./datasets/llm/validation.jsonl"
+    assert augmented["evaluation"]["dataset_path"]["ui"]["option_source"]["path"] == "./datasets/llm"
+    assert augmented["evaluation"]["enable"]["default"] is True
+
+
+def test_get_llm_resource_options_returns_defaults_and_discovered_values(tmp_path):
+    (tmp_path / "models" / "llm" / "tiny-model" / "config.json").parent.mkdir(parents=True)
+    (tmp_path / "models" / "llm" / "tiny-model" / "config.json").write_text("{}", encoding="utf-8")
+    dataset_path = tmp_path / "datasets" / "llm" / "custom.jsonl"
+    dataset_path.parent.mkdir(parents=True)
+    dataset_path.write_text('{"prompt":"p","completion":"c"}\n', encoding="utf-8")
+
+    resources = get_llm_resource_options(tmp_path)
+
+    assert resources["default_model"] == "./models/llm/tiny-model"
+    assert resources["models"] == ["./models/llm/tiny-model"]
+    assert resources["datasets"] == ["./datasets/llm/custom.jsonl"]
+    assert resources["evaluation_datasets"] == ["./datasets/llm/custom.jsonl"]
+    assert resources["default_evaluation_dataset"] == ""
+
+
+def test_augments_schema_with_empty_resource_messages_when_no_local_resources(tmp_path):
+    schema = {
+        "llm": {"base_model": {"type": "text", "default": DEFAULT_LLM_BASE_MODEL, "ui": {}}},
+        "sft": {"dataset_path": {"type": "text", "default": DEFAULT_LLM_DATASET_PATH, "ui": {}}},
+        "evaluation": {
+            "enable": {
+                "type": "bool",
+                "default": True,
+                "ui": {},
+            },
+            "dataset_path": {
+                "type": "text",
+                "default": DEFAULT_LLM_EVALUATION_DATASET_PATH,
+                "ui": {},
+            }
+        },
+    }
+
+    augmented = augment_config_schema_with_llm_resources(schema, tmp_path)
+
+    assert augmented["llm"]["base_model"]["options"] == []
+    assert augmented["llm"]["base_model"]["default"] == ""
+    assert augmented["llm"]["base_model"]["ui"]["empty_message"] == "No local models found"
+    assert augmented["sft"]["dataset_path"]["options"] == []
+    assert augmented["sft"]["dataset_path"]["default"] == ""
+    assert augmented["sft"]["dataset_path"]["ui"]["empty_message"] == "No training datasets found"
+    assert augmented["evaluation"]["dataset_path"]["options"] == []
+    assert augmented["evaluation"]["dataset_path"]["default"] == ""
+    assert augmented["evaluation"]["dataset_path"]["ui"]["empty_message"] == "No evaluation datasets found"
+    assert augmented["evaluation"]["enable"]["default"] is False
diff --git a/apps/backend/tests/services/test_run_metrics_service.py b/apps/backend/tests/services/test_run_metrics_service.py
new file mode 100644
index 0000000..5deafbc
--- /dev/null
+++ b/apps/backend/tests/services/test_run_metrics_service.py
@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from app.services.simulation.run_metrics_service import SimulationRunMetricsService
+
+
+def test_normalize_metrics_payload_preserves_llm_sections():
+    service = SimulationRunMetricsService.__new__(SimulationRunMetricsService)
+
+    normalized = service._normalize_metrics_payload(
+        {
+            "llm_results": {
+                "rounds": [1, "2"],
+                "train_loss": [1.5],
+                "validation_loss": [1.2],
+                "perplexity": [3.32],
+                "token_throughput": [42],
+                "adapter_size_bytes": [1024],
+            },
+            "llm_dataset": {"num_records": 12},
+            "llm_evaluation": {"enabled": True, "num_records": 4},
+            "llm_runtime": {"status": "blocked"},
+            "llm_artifacts": [{"round": 1, "path": "adapter.pt"}, "not-an-object"],
+            "client_results": {
+                "client_0": {
+                    "rounds": [1, "3"],
+                    "train_loss": [1.0, 0.8],
+                    "train_acc": [],
+                    "test_loss": [],
+                    "test_acc": [],
+                }
+            },
+        }
+    )
+
+    assert normalized["llm_results"]["rounds"] == [1, 2]
+    assert normalized["llm_results"]["token_throughput"] == [42.0]
+    assert normalized["llm_dataset"]["num_records"] == 12
+    assert normalized["llm_evaluation"]["num_records"] == 4
+    assert normalized["llm_runtime"]["status"] == "blocked"
+    assert normalized["llm_artifacts"] == [{"round": 1, "path": "adapter.pt"}]
+    assert normalized["client_results"]["client_0"]["rounds"] == [1, 3]
diff --git a/apps/backend/tests/services/test_run_service.py b/apps/backend/tests/services/test_run_service.py
index b04fa63..2d7cf02 100644
--- a/apps/backend/tests/services/test_run_service.py
+++ b/apps/backend/tests/services/test_run_service.py
@@ -1,4 +1,5 @@
 import asyncio
+import re
 from pathlib import Path
 
 from app.models.simulation import SimulationJob, SimulationJobStatus, SimulationRun, SimulationRunStatus
@@ -17,6 +18,11 @@ def test_run_service_start_run_flow_without_real_subprocess(monkeypatch, tmp_pat
     async def _run_test():
         service = SimulationRunService(session=_DummySession())
         service._job_config_dir = lambda: Path(tmp_path)  # type: ignore[method-assign]
+        service._results_dir = lambda: Path(tmp_path) / "results"  # type: ignore[method-assign]
+        service._runtime_log_dir = lambda: Path(tmp_path) / "logs"  # type: ignore[method-assign]
+        service._results_dir().mkdir(parents=True, exist_ok=True)
+        service._runtime_log_dir().mkdir(parents=True, exist_ok=True)
+        captured: dict[str, object] = {"results": []}
 
         class _FakeProcess:
             def __init__(self):
@@ -42,9 +48,11 @@ async def readline(self):
                 return b""
 
         async def _fake_spawn(self, _command, env=None):
+            captured["env"] = env
             return _FakeProcess()
 
-        async def _fake_watch(self, run_id, process):
+        async def _fake_watch(self, run_id, process, *, artifact_timestamp=None):
+            captured["artifact_timestamp"] = artifact_timestamp
             self._processes.pop(run_id, None)
             self._tasks.pop(run_id, None)
 
@@ -66,6 +74,7 @@ async def _add_log(_run_id, _msg, level="INFO"):
             return None
 
         async def _add_result(**_kwargs):
+            captured["results"].append(_kwargs)
             return None
 
         monkeypatch.setattr(SimulationRunService, "_spawn_subprocess", _fake_spawn)
@@ -81,5 +90,19 @@ async def _add_result(**_kwargs):
         assert run is not None
         assert run.status == SimulationRunStatus.RUNNING
         assert run.process_id == 111
+        env = captured["env"]
+        assert isinstance(env, dict)
+        result_filename = env["FIGARO_RESULTS_FILE"]
+        result_match = re.fullmatch(rf"(\d{{8}}_\d{{6}}Z)_{run.id}_live_results\.json", result_filename)
+        assert result_match is not None
+        timestamp = result_match.group(1)
+
+        results = captured["results"]
+        assert isinstance(results, list)
+        config_artifact = results[0]
+        config_path = Path(config_artifact["path"])
+        assert config_path.name == f"{timestamp}_{run.id}.json"
+        assert config_artifact["metadata_json"]["artifact_timestamp"] == timestamp
+        assert service._simulation_log_path(run.id, artifact_timestamp=timestamp).name == f"{timestamp}_{run.id}_server.log"
 
     asyncio.run(_run_test())
diff --git a/apps/backend/tests/test_project_dependencies.py b/apps/backend/tests/test_project_dependencies.py
new file mode 100644
index 0000000..df1b6a2
--- /dev/null
+++ b/apps/backend/tests/test_project_dependencies.py
@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from pathlib import Path
+import tomllib
+
+
+def test_llm_peft_dependencies_are_core_project_dependencies():
+    project_root = Path(__file__).resolve().parents[3]
+    pyproject = tomllib.loads((project_root / "pyproject.toml").read_text(encoding="utf-8"))
+    dependencies = "\n".join(pyproject["project"]["dependencies"])
+
+    for package in ("transformers", "peft", "accelerate", "safetensors", "bitsandbytes"):
+        assert package in dependencies
diff --git a/apps/frontend/src/api/agent.ts b/apps/frontend/src/api/agent.ts
index 0e0cda6..876d06d 100644
--- a/apps/frontend/src/api/agent.ts
+++ b/apps/frontend/src/api/agent.ts
@@ -21,6 +21,42 @@ export type AgentConfigChange = {
   new_value: unknown;
 };
 
+export type AgentHistoryFilters = {
+  q?: string;
+  status?: string;
+  model_name?: string;
+  objective?: AgentOptimizationObjective | "all";
+  best_score_min?: string;
+  best_score_max?: string;
+  created_from?: string;
+  created_to?: string;
+  dataset?: string;
+  config_model?: string;
+  aggregation?: string;
+  num_clients?: string;
+  num_rounds?: string;
+};
+
+export type AgentConfigVersion = {
+  id: number;
+  optimization_job_id: number;
+  run_id: string | null;
+  iteration: number;
+  source: string;
+  label: string;
+  config_hash: string;
+  config_json: Record<string, unknown>;
+  diff_json: AgentConfigChange[];
+  created_at: string;
+};
+
+export type AgentConfigDiffResponse = {
+  optimization_job_id: number;
+  from_version_id: number | null;
+  to_version_id: number;
+  changes: AgentConfigChange[];
+};
+
 export type AgentCurrentPlan = {
   iteration: number;
   iteration_goal: string;
@@ -192,6 +228,33 @@ async function readJson<T>(response: Response): Promise<T> {
   return (await response.json()) as T;
 }
 
+function addOptionalParam(params: URLSearchParams, key: string, value: unknown): void {
+  if (value === undefined || value === null) return;
+  const text = String(value).trim();
+  if (!text || text === "all") return;
+  params.set(key, text);
+}
+
+function historyFiltersToParams(filters?: AgentHistoryFilters): string {
+  const params = new URLSearchParams();
+  if (!filters) return "";
+  addOptionalParam(params, "q", filters.q);
+  addOptionalParam(params, "status", filters.status);
+  addOptionalParam(params, "model_name", filters.model_name);
+  addOptionalParam(params, "objective", filters.objective);
+  addOptionalParam(params, "best_score_min", filters.best_score_min);
+  addOptionalParam(params, "best_score_max", filters.best_score_max);
+  addOptionalParam(params, "created_from", filters.created_from);
+  addOptionalParam(params, "created_to", filters.created_to);
+  addOptionalParam(params, "dataset", filters.dataset);
+  addOptionalParam(params, "config_model", filters.config_model);
+  addOptionalParam(params, "aggregation", filters.aggregation);
+  addOptionalParam(params, "num_clients", filters.num_clients);
+  addOptionalParam(params, "num_rounds", filters.num_rounds);
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+
 export const agentApi = {
   async getConfigSchema(): Promise<Record<string, unknown>> {
     const response = await fetch(`${baseUrl}/api/v1/agent/config/schema`);
@@ -226,8 +289,8 @@ export const agentApi = {
     return readJson<AgentOptimizeProgressResponse>(response);
   },
 
-  async listOptimizationJobs(): Promise<AgentOptimizationJobSummary[]> {
-    const response = await fetch(`${baseUrl}/api/v1/agent/optimization-jobs`);
+  async listOptimizationJobs(filters?: AgentHistoryFilters): Promise<AgentOptimizationJobSummary[]> {
+    const response = await fetch(`${baseUrl}/api/v1/agent/optimization-jobs${historyFiltersToParams(filters)}`);
     return readJson<AgentOptimizationJobSummary[]>(response);
   },
 
@@ -303,4 +366,18 @@ export const agentApi = {
     }
     return response.json();
   },
+
+  async listConfigVersions(optimizationJobId: number): Promise<AgentConfigVersion[]> {
+    const response = await fetch(`${baseUrl}/api/v1/agent/optimization-jobs/${encodeURIComponent(optimizationJobId)}/config-versions`);
+    return readJson<AgentConfigVersion[]>(response);
+  },
+
+  async getConfigDiff(optimizationJobId: number, toVersionId: number, fromVersionId?: number | null): Promise<AgentConfigDiffResponse> {
+    const params = new URLSearchParams({ to_version_id: String(toVersionId) });
+    if (fromVersionId != null) {
+      params.set("from_version_id", String(fromVersionId));
+    }
+    const response = await fetch(`${baseUrl}/api/v1/agent/optimization-jobs/${encodeURIComponent(optimizationJobId)}/config-diff?${params.toString()}`);
+    return readJson<AgentConfigDiffResponse>(response);
+  },
 };
diff --git a/apps/frontend/src/api/runs.ts b/apps/frontend/src/api/runs.ts
index 799cddd..a0446b3 100644
--- a/apps/frontend/src/api/runs.ts
+++ b/apps/frontend/src/api/runs.ts
@@ -4,6 +4,7 @@ import { getHttpErrorMessage } from "./error";
 type Run = components["schemas"]["RunResponse"];
 
 export type RunClientMetricSeries = {
+  rounds?: number[];
   train_loss: number[];
   train_acc: number[];
   test_loss: number[];
@@ -21,6 +22,18 @@ export type RunMetrics = {
     global_loss: number[];
     global_accuracy: number[];
   };
+  llm_results?: {
+    rounds: number[];
+    train_loss: number[];
+    validation_loss: number[];
+    perplexity: number[];
+    token_throughput: number[];
+    adapter_size_bytes: number[];
+  };
+  llm_dataset?: Record<string, unknown>;
+  llm_evaluation?: Record<string, unknown>;
+  llm_runtime?: Record<string, unknown>;
+  llm_artifacts?: Record<string, unknown>[];
   client_results: Record<string, RunClientMetricSeries>;
 };
 
diff --git a/apps/frontend/src/features/agent/components/AgentExperimentStudio.tsx b/apps/frontend/src/features/agent/components/AgentExperimentStudio.tsx
index ef8e760..fe49c69 100644
--- a/apps/frontend/src/features/agent/components/AgentExperimentStudio.tsx
+++ b/apps/frontend/src/features/agent/components/AgentExperimentStudio.tsx
@@ -1,5 +1,5 @@
-import { ArrowRight, Loader2, SlidersHorizontal, Sparkles, X } from "lucide-react";
-import { useMemo } from "react";
+import { ArrowRight, Loader2, RefreshCw, SlidersHorizontal, Sparkles, X } from "lucide-react";
+import { useMemo, useState } from "react";
 
 import { Badge } from "../../../components/ui/badge";
 import { Button } from "../../../components/ui/button";
@@ -12,17 +12,23 @@ import { Textarea } from "../../../components/ui/textarea";
 import type { AgentPageProps } from "../../../pages/types";
 import { getValueByPath } from "../../simulation/utils";
 import {
+  booleanDisabledForConfig,
+  booleanDisableReasonForConfig,
+  agentFieldVisibleForConfig,
   buildAgentConfig,
-  checkDependency,
   coerceFieldValue,
   collectAgentSchemaFields,
+  fieldEmptyMessage,
+  fieldCompatibilityHint,
   formatFieldValue,
-  optionDisabled,
+  optionDisableReasonForConfig,
+  optionDisabledForConfig,
   optionLabel,
   optionMeta,
   selectedConstraintChips,
   type AgentSchemaField,
 } from "../schema";
+import { isModelCompatibleWithDataset } from "../../config/compatibility";
 
 export function AgentExperimentStudio(props: AgentPageProps) {
   const {
@@ -37,7 +43,10 @@ export function AgentExperimentStudio(props: AgentPageProps) {
     presets,
     busy,
     handleGeneratePlan,
+    notifyError,
+    refreshLlmResources,
   } = props;
+  const [refreshingResources, setRefreshingResources] = useState(false);
 
   const fields = useMemo(() => collectAgentSchemaFields(configSchema, { featuredOnly: true }), [configSchema]);
   const effectiveConfig = useMemo(
@@ -45,10 +54,21 @@ export function AgentExperimentStudio(props: AgentPageProps) {
     [configConstraints, configSchema],
   );
   const chips = useMemo(
-    () => selectedConstraintChips(configSchema, configConstraints),
-    [configConstraints, configSchema],
+    () => selectedConstraintChips(configSchema, configConstraints, effectiveConfig),
+    [configConstraints, configSchema, effectiveConfig],
   );
-  const visibleFields = fields.filter((field) => checkDependency(effectiveConfig, field.definition.depends_on));
+  const visibleFields = fields.filter((field) => agentFieldVisibleForConfig(field, effectiveConfig));
+
+  async function handleRefreshResources(): Promise<void> {
+    setRefreshingResources(true);
+    try {
+      await refreshLlmResources();
+    } catch (error) {
+      notifyError(error, "agent-llm-resources-refresh");
+    } finally {
+      setRefreshingResources(false);
+    }
+  }
 
   return (
     <div className="flex h-full w-full flex-col items-center justify-center space-y-6 max-w-3xl mx-auto py-12">
@@ -72,7 +92,7 @@ export function AgentExperimentStudio(props: AgentPageProps) {
             <label className="text-sm font-medium">Experiment Goal</label>
             <Textarea 
               className="min-h-[120px] text-base resize-none"
-              placeholder="E.g., Compare FedAvg vs FedProx on CIFAR-10 with high data heterogeneity (alpha=0.1)..."
+              placeholder="E.g., Compare FedAvg on CIFAR-10, or run LLM PEFT SFT with LoRA rank 8 on a JSONL dataset..."
               value={goal}
               onChange={(e) => setGoal(e.target.value)}
             />
@@ -96,6 +116,21 @@ export function AgentExperimentStudio(props: AgentPageProps) {
                 <SlidersHorizontal className="h-4 w-4 text-primary" />
                 <p className="text-sm font-semibold">Default Config</p>
               </div>
+              <Button
+                type="button"
+                variant="outline"
+                size="sm"
+                className="h-8 gap-2 px-2.5 text-xs"
+                disabled={refreshingResources}
+                onClick={() => { void handleRefreshResources(); }}
+              >
+                {refreshingResources ? (
+                  <Loader2 className="h-3.5 w-3.5 animate-spin" />
+                ) : (
+                  <RefreshCw className="h-3.5 w-3.5" />
+                )}
+                <span>Refresh resources</span>
+              </Button>
             </div>
 
             {visibleFields.length === 0 && (
@@ -106,9 +141,19 @@ export function AgentExperimentStudio(props: AgentPageProps) {
                 {visibleFields.map((field) => (
                   <ConstraintField
                     key={field.path}
+                    config={effectiveConfig}
                     field={field}
                     value={getValueByPath(configConstraints, field.path) ?? field.defaultValue}
-                    onChange={(value) => setConfigConstraint(field.path, coerceFieldValue(field, value))}
+                    onChange={(value) => {
+                      const coerced = coerceFieldValue(field, value);
+                      setConfigConstraint(field.path, coerced);
+                      if (field.path === "dataset.name") {
+                        const currentModel = getValueByPath(effectiveConfig, "model.name");
+                        if (!isModelCompatibleWithDataset(currentModel, String(coerced))) {
+                          setConfigConstraint("model.name", "Auto");
+                        }
+                      }
+                    }}
                   />
                 ))}
               </div>
@@ -167,10 +212,12 @@ function parseOptionalNumber(value: unknown): number | undefined {
 }
 
 function ConstraintField({
+  config,
   field,
   value,
   onChange,
 }: {
+  config: Record<string, unknown>;
   field: AgentSchemaField;
   value: unknown;
   onChange: (value: unknown) => void;
@@ -178,6 +225,14 @@ function ConstraintField({
   const hint = field.definition.ui && typeof field.definition.ui.prompt_hint === "string"
     ? field.definition.ui.prompt_hint
     : null;
+  const compatibilityHint = fieldCompatibilityHint(field.path, config);
+  const boolDisabled = booleanDisabledForConfig(field.path, value, config);
+  const boolReason = booleanDisableReasonForConfig(field.path, value, config);
+  const textOptions = field.options.map((option) => String(option));
+  const textValue = formatFieldValue(value);
+  const selectedTextOption = textOptions.includes(textValue) ? textValue : "";
+  const customTextOption = textValue !== "-" && selectedTextOption === "" ? textValue : null;
+  const emptyMessage = field.options.length === 0 ? fieldEmptyMessage(field) : null;
 
   return (
     <div className="space-y-1 rounded-md border border-border/70 bg-background/60 p-3">
@@ -186,6 +241,9 @@ function ConstraintField({
         <span className="text-[10px] uppercase tracking-wide text-muted-foreground">{field.section}</span>
       </div>
       {field.type === "select" && (
+        emptyMessage ? (
+          <Input className="font-mono text-muted-foreground" value={emptyMessage} disabled />
+        ) : (
         <Select value={String(value ?? "")} onValueChange={onChange}>
           <SelectTrigger className="font-mono">
             <SelectValue placeholder="Select option" />
@@ -193,22 +251,28 @@ function ConstraintField({
           <SelectContent>
             {field.options.map((option) => {
               const meta = optionMeta(field.definition, option);
+              const disabled = optionDisabledForConfig(field.definition, option, field.path, config);
+              const reason = optionDisableReasonForConfig(field.definition, option, field.path, config);
               return (
                 <SelectItem
                   key={`${field.path}-${String(option)}`}
                   value={String(option)}
-                  disabled={optionDisabled(field.definition, option)}
+                  disabled={disabled}
                   className="font-mono"
                 >
-                  <span className="flex items-center gap-2">
-                    {optionLabel(field.definition, option)}
-                    {typeof meta.badge === "string" && <span className="text-[10px] text-amber-400">{meta.badge}</span>}
+                  <span className="flex flex-col gap-0.5">
+                    <span className="flex items-center gap-2">
+                      {optionLabel(field.definition, option)}
+                      {typeof meta.badge === "string" && <span className="text-[10px] text-amber-400">{meta.badge}</span>}
+                    </span>
+                    {reason && <span className="text-[10px] text-muted-foreground">{reason}</span>}
                   </span>
                 </SelectItem>
               );
             })}
           </SelectContent>
         </Select>
+        )
       )}
       {field.type === "number" && (
         <NumberStepper
@@ -223,12 +287,57 @@ function ConstraintField({
       {field.type === "bool" && (
         <div className="flex h-10 items-center justify-between rounded-md border border-input bg-background/40 px-3">
           <span className="text-sm">{formatFieldValue(value)}</span>
-          <Switch checked={Boolean(value)} onCheckedChange={onChange} />
+          <Switch checked={Boolean(value)} onCheckedChange={onChange} disabled={boolDisabled} />
         </div>
       )}
       {field.type !== "select" && field.type !== "number" && field.type !== "bool" && (
-        <Input className="font-mono" value={formatFieldValue(value)} onChange={(event) => onChange(event.target.value)} />
+        emptyMessage ? (
+          <Input className="font-mono text-muted-foreground" value={emptyMessage} disabled />
+        ) : textOptions.length > 0 ? (
+          <Select value={customTextOption ?? selectedTextOption} onValueChange={onChange}>
+            <SelectTrigger
+              className="font-mono overflow-hidden [&>span]:block [&>span]:truncate [&>span]:whitespace-nowrap"
+              title={textValue}
+            >
+              <SelectValue placeholder="Choose option" />
+            </SelectTrigger>
+            <SelectContent className="max-w-[min(36rem,calc(100vw-2rem))]">
+              {customTextOption && (
+                <SelectItem
+                  value={customTextOption}
+                  className="font-mono"
+                  title={customTextOption}
+                >
+                  <span className="block max-w-full truncate">{customTextOption}</span>
+                </SelectItem>
+              )}
+              {field.options.map((option) => {
+                const disabled = optionDisabledForConfig(field.definition, option, field.path, config);
+                const label = optionLabel(field.definition, option);
+                return (
+                  <SelectItem
+                    key={`${field.path}-text-option-${String(option)}`}
+                    value={String(option)}
+                    disabled={disabled}
+                    className="font-mono"
+                    title={String(option)}
+                  >
+                    <span className="block max-w-full truncate">{label}</span>
+                  </SelectItem>
+                );
+              })}
+            </SelectContent>
+          </Select>
+        ) : (
+          <Input
+            className="font-mono"
+            value={textValue}
+            onChange={(event) => onChange(event.target.value)}
+          />
+        )
       )}
+      {compatibilityHint && <p className="text-[11px] text-muted-foreground">{compatibilityHint}</p>}
+      {boolReason && <p className="text-[11px] text-muted-foreground">{boolReason}</p>}
       {hint && <p className="text-[11px] text-muted-foreground">{hint}</p>}
     </div>
   );
diff --git a/apps/frontend/src/features/agent/components/AgentPlanPreview.tsx b/apps/frontend/src/features/agent/components/AgentPlanPreview.tsx
index 10dc599..1b30f46 100644
--- a/apps/frontend/src/features/agent/components/AgentPlanPreview.tsx
+++ b/apps/frontend/src/features/agent/components/AgentPlanPreview.tsx
@@ -15,18 +15,27 @@ import { Textarea } from "../../../components/ui/textarea";
 import type { AgentPageProps } from "../../../pages/types";
 import { getValueByPath, isRecord } from "../../simulation/utils";
 import {
+  applyConfigConstraints,
+  booleanDisabledForConfig,
+  booleanDisableReasonForConfig,
+  agentFieldVisibleForConfig,
   buildAgentConfig,
-  checkDependency,
   coerceFieldValue,
   collectAgentSchemaFields,
+  fieldEmptyMessage,
+  fieldCompatibilityHint,
   formatFieldValue,
-  optionDisabled,
+  inferSftSettingsForDatasetPath,
+  materializeAgentConfigConstraints,
+  optionDisableReasonForConfig,
+  optionDisabledForConfig,
   optionLabel,
   optionMeta,
   setConfigValue,
   validateDisabledOptions,
   type AgentSchemaField,
 } from "../schema";
+import { isModelCompatibleWithDataset } from "../../config/compatibility";
 
 type LocalExperiment = {
   name: string;
@@ -61,6 +70,7 @@ export function AgentPlanPreview(props: AgentPageProps) {
 
   if (!draftPlan) return null;
   const isBusy = globalBusy || isRevising;
+  const lockedConstraints = materializeAgentConfigConstraints(configSchema, draftPlan.config_constraints ?? {});
 
   const handleRevise = async () => {
     if (!instruction.trim() || !draftPlan.job_id) return;
@@ -91,7 +101,19 @@ export function AgentPlanPreview(props: AgentPageProps) {
     setLocalExperiments((current) =>
       current.map((exp, idx) => {
         if (idx !== index) return exp;
-        const nextConfig = setConfigValue(exp.config_patch ?? {}, path, value);
+        let nextConfig = setConfigValue(exp.config_patch ?? {}, path, value);
+        if (path === "dataset.name") {
+          const fullConfig = buildAgentConfig(configSchema, nextConfig);
+          const currentModel = getValueByPath(fullConfig, "model.name");
+          if (!isModelCompatibleWithDataset(currentModel, String(value))) {
+            nextConfig = setConfigValue(nextConfig, "model.name", "Auto");
+          }
+        }
+        if (path === "sft.dataset_path") {
+          for (const [inferredPath, inferredValue] of Object.entries(inferSftSettingsForDatasetPath(value))) {
+            nextConfig = setConfigValue(nextConfig, inferredPath, inferredValue);
+          }
+        }
         return {
           ...exp,
           config_patch: nextConfig,
@@ -126,7 +148,10 @@ export function AgentPlanPreview(props: AgentPageProps) {
     }
 
     const disabledErrors = localExperiments.flatMap((exp) =>
-      validateDisabledOptions(buildAgentConfig(configSchema, exp.config_patch ?? {}), configSchema),
+      validateDisabledOptions(
+        buildAgentConfig(configSchema, applyConfigConstraints(exp.config_patch ?? {}, lockedConstraints)),
+        configSchema,
+      ),
     );
     if (disabledErrors.length > 0) {
       toast.error(disabledErrors[0]);
@@ -135,7 +160,10 @@ export function AgentPlanPreview(props: AgentPageProps) {
 
     const cleanExperiments = localExperiments.map((exp) => {
       const { _rawJsonString, _jsonError, _activeTab, ...rest } = exp;
-      return rest;
+      return {
+        ...rest,
+        config_patch: applyConfigConstraints(rest.config_patch ?? {}, lockedConstraints),
+      };
     });
     void handleExecutePlan(cleanExperiments);
   };
@@ -203,6 +231,7 @@ export function AgentPlanPreview(props: AgentPageProps) {
                 disabled={isBusy}
                 experiment={exp}
                 index={idx}
+                lockedConstraints={lockedConstraints}
                 schema={configSchema}
                 fields={schemaFields}
                 onConfigChange={(path, value) => handleFormConfigChange(idx, path, value)}
@@ -231,6 +260,7 @@ function ExperimentCard({
   experiment,
   fields,
   index,
+  lockedConstraints,
   onConfigChange,
   onJsonChange,
   onTabChange,
@@ -240,22 +270,24 @@ function ExperimentCard({
   experiment: LocalExperiment;
   fields: AgentSchemaField[];
   index: number;
+  lockedConstraints: Record<string, unknown>;
   onConfigChange: (path: string, value: unknown) => void;
   onJsonChange: (text: string) => void;
   onTabChange: (tab: "form" | "json") => void;
   schema: Record<string, unknown> | null;
 }) {
-  const fullConfig = buildAgentConfig(schema, experiment.config_patch ?? {});
-  const visibleFields = fields.filter((field) => checkDependency(fullConfig, field.definition.depends_on));
+  const effectivePatch = applyConfigConstraints(experiment.config_patch ?? {}, lockedConstraints);
+  const fullConfig = buildAgentConfig(schema, effectivePatch);
+  const visibleFields = fields.filter((field) => agentFieldVisibleForConfig(field, fullConfig));
   const grouped = visibleFields.reduce<Record<string, AgentSchemaField[]>>((acc, field) => {
     const section = field.section;
     acc[section] = [...(acc[section] ?? []), field];
     return acc;
   }, {});
-  const jsonString = experiment._rawJsonString ?? JSON.stringify(experiment.config_patch ?? {}, null, 2);
+  const jsonString = experiment._rawJsonString ?? JSON.stringify(effectivePatch, null, 2);
   const disabledErrors = validateDisabledOptions(fullConfig, schema);
   const summaryFields = fields
-    .filter((field) => field.featured)
+    .filter((field) => field.featured && agentFieldVisibleForConfig(field, fullConfig))
     .map((field) => ({ field, value: getValueByPath(fullConfig, field.path) }))
     .filter((item) => item.value !== undefined)
     .slice(0, 8);
@@ -300,6 +332,7 @@ function ExperimentCard({
                     {sectionFields.map((field) => (
                       <SchemaFieldControl
                         key={field.path}
+                        config={fullConfig}
                         disabled={disabled}
                         field={field}
                         value={getValueByPath(fullConfig, field.path) ?? field.defaultValue}
@@ -329,20 +362,34 @@ function ExperimentCard({
 }
 
 function SchemaFieldControl({
+  config,
   disabled,
   field,
   value,
   onChange,
 }: {
+  config: Record<string, unknown>;
   disabled: boolean;
   field: AgentSchemaField;
   value: unknown;
   onChange: (value: unknown) => void;
 }) {
+  const compatibilityHint = fieldCompatibilityHint(field.path, config);
+  const boolDisabled = disabled || booleanDisabledForConfig(field.path, value, config);
+  const boolReason = booleanDisableReasonForConfig(field.path, value, config);
+  const textOptions = field.options.map((option) => String(option));
+  const textValue = formatFieldValue(value);
+  const selectedTextOption = textOptions.includes(textValue) ? textValue : "";
+  const customTextOption = textValue !== "-" && selectedTextOption === "" ? textValue : null;
+  const emptyMessage = field.options.length === 0 ? fieldEmptyMessage(field) : null;
+
   return (
     <div className="space-y-1 rounded-md border border-border/70 bg-background/60 p-2">
       <p className="text-xs text-muted-foreground">{field.label}</p>
       {field.type === "select" && (
+        emptyMessage ? (
+          <Input className="font-mono text-muted-foreground" disabled value={emptyMessage} />
+        ) : (
         <Select value={String(value ?? "")} onValueChange={onChange} disabled={disabled}>
           <SelectTrigger className="font-mono">
             <SelectValue placeholder="Select option" />
@@ -350,22 +397,28 @@ function SchemaFieldControl({
           <SelectContent>
             {field.options.map((option) => {
               const meta = optionMeta(field.definition, option);
+              const optionDisabled = optionDisabledForConfig(field.definition, option, field.path, config);
+              const reason = optionDisableReasonForConfig(field.definition, option, field.path, config);
               return (
                 <SelectItem
                   key={`${field.path}-${String(option)}`}
                   value={String(option)}
-                  disabled={optionDisabled(field.definition, option)}
+                  disabled={optionDisabled}
                   className="font-mono"
                 >
-                  <span className="flex items-center gap-2">
-                    {optionLabel(field.definition, option)}
-                    {typeof meta.badge === "string" && <span className="text-[10px] text-amber-400">{meta.badge}</span>}
+                  <span className="flex flex-col gap-0.5">
+                    <span className="flex items-center gap-2">
+                      {optionLabel(field.definition, option)}
+                      {typeof meta.badge === "string" && <span className="text-[10px] text-amber-400">{meta.badge}</span>}
+                    </span>
+                    {reason && <span className="text-[10px] text-muted-foreground">{reason}</span>}
                   </span>
                 </SelectItem>
               );
             })}
           </SelectContent>
         </Select>
+        )
       )}
       {field.type === "number" && (
         <NumberStepper
@@ -381,17 +434,58 @@ function SchemaFieldControl({
       {field.type === "bool" && (
         <div className="flex h-10 items-center justify-between rounded-md border border-input bg-background/40 px-3">
           <span className="text-sm">{formatFieldValue(value)}</span>
-          <Switch checked={Boolean(value)} onCheckedChange={onChange} disabled={disabled} />
+          <Switch checked={Boolean(value)} onCheckedChange={onChange} disabled={boolDisabled} />
         </div>
       )}
       {field.type !== "select" && field.type !== "number" && field.type !== "bool" && (
-        <Input
-          className="font-mono"
-          disabled={disabled}
-          value={formatFieldValue(value)}
-          onChange={(event) => onChange(event.target.value)}
-        />
+        emptyMessage ? (
+          <Input className="font-mono text-muted-foreground" disabled value={emptyMessage} />
+        ) : textOptions.length > 0 ? (
+          <Select value={customTextOption ?? selectedTextOption} onValueChange={onChange} disabled={disabled}>
+            <SelectTrigger
+              className="font-mono overflow-hidden [&>span]:block [&>span]:truncate [&>span]:whitespace-nowrap"
+              title={textValue}
+            >
+              <SelectValue placeholder="Choose option" />
+            </SelectTrigger>
+            <SelectContent className="max-w-[min(36rem,calc(100vw-2rem))]">
+              {customTextOption && (
+                <SelectItem
+                  value={customTextOption}
+                  className="font-mono"
+                  title={customTextOption}
+                >
+                  <span className="block max-w-full truncate">{customTextOption}</span>
+                </SelectItem>
+              )}
+              {field.options.map((option) => {
+                const itemDisabled = optionDisabledForConfig(field.definition, option, field.path, config);
+                const label = optionLabel(field.definition, option);
+                return (
+                  <SelectItem
+                    key={`${field.path}-text-option-${String(option)}`}
+                    value={String(option)}
+                    disabled={itemDisabled}
+                    className="font-mono"
+                    title={String(option)}
+                  >
+                    <span className="block max-w-full truncate">{label}</span>
+                  </SelectItem>
+                );
+              })}
+            </SelectContent>
+          </Select>
+        ) : (
+          <Input
+            className="font-mono"
+            disabled={disabled}
+            value={textValue}
+            onChange={(event) => onChange(event.target.value)}
+          />
+        )
       )}
+      {compatibilityHint && <p className="text-[11px] text-muted-foreground">{compatibilityHint}</p>}
+      {boolReason && <p className="text-[11px] text-muted-foreground">{boolReason}</p>}
     </div>
   );
 }
diff --git a/apps/frontend/src/features/agent/components/AgentResultsCompare.tsx b/apps/frontend/src/features/agent/components/AgentResultsCompare.tsx
index a9d608d..22c7a7e 100644
--- a/apps/frontend/src/features/agent/components/AgentResultsCompare.tsx
+++ b/apps/frontend/src/features/agent/components/AgentResultsCompare.tsx
@@ -1,17 +1,32 @@
 import { useEffect, useMemo, useState } from "react";
-import { History, Bot, Activity, Trophy, ArrowRight, Target, Calendar, FileJson, Settings2 } from "lucide-react";
+import { History, Bot, Activity, Trophy, ArrowRight, Target, Calendar, FileJson, Settings2, Search, RotateCcw, GitCompare } from "lucide-react";
 import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "../../../components/ui/card";
 import { Badge } from "../../../components/ui/badge";
 import { Button } from "../../../components/ui/button";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../../../components/ui/select";
 import { Separator } from "../../../components/ui/separator";
 import { MiniLineChart } from "../../simulation/components/MiniLineChart";
-import { getValueByPath, isRecord } from "../../simulation/utils";
+import { getValueByPath, isRecord, toClientSeries } from "../../simulation/utils";
+import {
+  formatBytes,
+  isLlmRunMetrics,
+  llmAdapterSizeSeries,
+  llmPerplexitySeries,
+  llmRounds,
+  llmThroughputSeries,
+  llmTrainLossSeries,
+  llmValidationLossSeries,
+  latestLlmLoss,
+  selectedClientsText,
+  shortHash,
+} from "../../simulation/llm-metrics";
 import { fmt } from "../../../lib/time";
 import type { AgentPageProps } from "../../../pages/types";
-import { baseUrl } from "../../../../src/api/client";
+import { baseUrl } from "../../../api/client";
+import { agentApi, type AgentConfigChange, type AgentConfigVersion, type AgentHistoryFilters } from "../../../api/agent";
 import ReactMarkdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
-import { collectAgentSchemaFields, formatFieldValue, optionLabel, type AgentSchemaField } from "../schema";
+import { collectAgentSchemaFields, formatFieldValue, optionDisabled, optionLabel, type AgentSchemaField } from "../schema";
 
 const CHART_COLORS = [
   "hsl(var(--primary))", "#10b981", "#f59e0b", "#ef4444", "#8b5cf6", "#ec4899", "#06b6d4"
@@ -35,6 +50,26 @@ type ConfigSummaryItem = {
   value: string;
 };
 
+const HISTORY_STATUS_OPTIONS = [
+  { value: "all", label: "All status" },
+  { value: "completed", label: "Completed" },
+  { value: "running", label: "Running" },
+  { value: "pending_review", label: "Pending review" },
+  { value: "failed", label: "Failed" },
+  { value: "queued", label: "Queued" },
+];
+
+const OBJECTIVE_OPTIONS = [
+  { value: "all", label: "All objectives" },
+  { value: "auto", label: "Auto" },
+  { value: "accuracy", label: "Accuracy" },
+];
+
+type SelectOption = {
+  value: string;
+  label: string;
+};
+
 function asConfigRecord(value: unknown): Record<string, unknown> | null {
   return isRecord(value) ? value : null;
 }
@@ -80,16 +115,84 @@ function buildConfigSummary(
     .filter((item): item is ConfigSummaryItem => item !== null);
 }
 
+function formatDiffValue(value: unknown): string {
+  if (value === null || value === undefined) return "-";
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+
+function experimentRankScore(experiment: any): number {
+  const llmLoss = latestLlmLoss(experiment?.metrics);
+  if (llmLoss !== null) return -llmLoss;
+  const score = Number(experiment?.score);
+  return Number.isFinite(score) ? score : Number.NEGATIVE_INFINITY;
+}
+
+function diffBadgeClass(changeType: string): string {
+  if (changeType === "added" || changeType === "initialize") return "border-emerald-500/70 text-emerald-600";
+  if (changeType === "removed") return "border-red-500/70 text-red-600";
+  return "border-amber-500/70 text-amber-600";
+}
+
+function schemaSelectOptions(schema: Record<string, unknown> | null, path: string): SelectOption[] {
+  const field = collectAgentSchemaFields(schema, { featuredOnly: false }).find((item) => item.path === path);
+  if (!field) return [];
+  return field.options
+    .filter((option) => !optionDisabled(field.definition, option))
+    .map((option) => ({ value: String(option), label: optionLabel(field.definition, option) }));
+}
+
+function optionSelect(
+  label: string,
+  value: string | undefined,
+  options: SelectOption[],
+  onChange: (value: string) => void,
+) {
+  return (
+    <div className="space-y-1">
+      <div className="text-[10px] font-semibold uppercase text-muted-foreground">{label}</div>
+      <Select value={value || "all"} onValueChange={onChange}>
+        <SelectTrigger className="h-8 text-xs">
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value="all">Any</SelectItem>
+          {options.map((option) => (
+            <SelectItem key={option.value} value={option.value}>
+              {option.label}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+    </div>
+  );
+}
+
 export function AgentResultsCompare(props: AgentPageProps) {
-  const { historyJobs, selectedHistory, selectHistoryJob, setWorkflowStep, configSchema } = props;
+  const {
+    historyFilters,
+    historyJobs,
+    selectedHistory,
+    selectHistoryJob,
+    setHistoryFilters,
+    refreshHistoryJobs,
+    setWorkflowStep,
+    configSchema,
+    modelOptions,
+    notifyError,
+  } = props;
 
-  const jobs = (historyJobs || []).filter((job: any) => job.status === "completed");
+  const jobs = historyJobs || [];
   const [selectedRunId, setSelectedRunId] = useState<string | null>(null);
   const [metrics, setMetrics] = useState<any>(null);
+  const [configVersions, setConfigVersions] = useState<AgentConfigVersion[]>([]);
+  const [fromVersionKey, setFromVersionKey] = useState("");
+  const [toVersionKey, setToVersionKey] = useState("");
+  const [configDiff, setConfigDiff] = useState<AgentConfigChange[]>([]);
 
   const experiments = selectedHistory?.experiments || [];
-  const bestExp = experiments.reduce((prev: any, curr: any) => 
-    (curr.score || 0) > (prev?.score || 0) ? curr : prev, experiments[0] || null);
+  const bestExp = experiments.reduce((prev: any, curr: any) =>
+    experimentRankScore(curr) > experimentRankScore(prev) ? curr : prev, experiments[0] || null);
   const bestConfig = asConfigRecord(selectedHistory?.best_config) ?? asConfigRecord(bestExp?.config);
   const bestConfigSummary = useMemo(
     () => buildConfigSummary(bestConfig, configSchema),
@@ -99,6 +202,13 @@ export function AgentResultsCompare(props: AgentPageProps) {
     () => (bestConfig ? JSON.stringify(bestConfig, null, 2) : ""),
     [bestConfig],
   );
+  const datasetOptions = useMemo(() => schemaSelectOptions(configSchema, "dataset.name"), [configSchema]);
+  const configModelOptions = useMemo(() => schemaSelectOptions(configSchema, "model.name"), [configSchema]);
+  const aggregationOptions = useMemo(() => schemaSelectOptions(configSchema, "federated.aggregation"), [configSchema]);
+  const llmModelOptions = useMemo(
+    () => modelOptions.map((item) => ({ value: item, label: item })),
+    [modelOptions],
+  );
 
   useEffect(() => {
     if (bestExp) {
@@ -122,22 +232,116 @@ export function AgentResultsCompare(props: AgentPageProps) {
       .catch(() => {});
   }, [selectedRunId]);
 
+  useEffect(() => {
+    const optimizationJobId = selectedHistory?.optimization_job_id;
+    if (!optimizationJobId) {
+      setConfigVersions([]);
+      setFromVersionKey("");
+      setToVersionKey("");
+      setConfigDiff([]);
+      return;
+    }
+
+    let cancelled = false;
+    agentApi.listConfigVersions(optimizationJobId)
+      .then((versions) => {
+        if (cancelled) return;
+        const experimentVersions = versions.filter((version) => version.source === "experiment");
+        const firstVersion = experimentVersions[0];
+        const lastVersion = experimentVersions[experimentVersions.length - 1];
+        setConfigVersions(experimentVersions);
+        setFromVersionKey(firstVersion ? String(firstVersion.id) : "");
+        setToVersionKey(lastVersion ? String(lastVersion.id) : "");
+        setConfigDiff([]);
+      })
+      .catch((error) => {
+        if (!cancelled) {
+          setConfigVersions([]);
+          setFromVersionKey("");
+          setToVersionKey("");
+          setConfigDiff([]);
+          notifyError(error, "agent-config-versions");
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedHistory?.optimization_job_id]);
+
+  useEffect(() => {
+    const optimizationJobId = selectedHistory?.optimization_job_id;
+    const fromVersionId = Number(fromVersionKey);
+    const toVersionId = Number(toVersionKey);
+    if (
+      !optimizationJobId ||
+      !fromVersionKey ||
+      !toVersionKey ||
+      !Number.isFinite(fromVersionId) ||
+      !Number.isFinite(toVersionId) ||
+      fromVersionId === toVersionId
+    ) {
+      setConfigDiff([]);
+      return;
+    }
+
+    let cancelled = false;
+    agentApi.getConfigDiff(
+      optimizationJobId,
+      toVersionId,
+      fromVersionId,
+    )
+      .then((payload) => {
+        if (!cancelled) {
+          setConfigDiff(payload.changes);
+        }
+      })
+      .catch((error) => {
+        if (!cancelled) {
+          setConfigDiff([]);
+          notifyError(error, "agent-config-diff");
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedHistory?.optimization_job_id, fromVersionKey, toVersionKey]);
+
+  function updateHistoryFilter<K extends keyof AgentHistoryFilters>(key: K, value: AgentHistoryFilters[K]): void {
+    setHistoryFilters((current) => ({ ...current, [key]: value }));
+  }
+
+  async function applyHistoryFilters(): Promise<void> {
+    const { q: _unusedTextFilter, ...selectableFilters } = historyFilters;
+    await refreshHistoryJobs(selectableFilters);
+  }
+
+  function resetHistoryFilters(): void {
+    const next: AgentHistoryFilters = { status: "all", objective: "all" };
+    setHistoryFilters(next);
+    void refreshHistoryJobs(next).catch((error: unknown) => notifyError(error, "agent-history-filter-reset"));
+  }
+
+  const isLlmRun = isLlmRunMetrics(metrics);
   const globalResults = metrics?.global_results || {};
-  const clientResults = metrics?.client_results || {};
-  const actualDataLength = globalResults.global_accuracy?.length || 0;
-  const rounds = globalResults.rounds ? globalResults.rounds.slice(0, actualDataLength) : Array.from({ length: actualDataLength }, (_, i) => i + 1);
+  const actualDataLength = isLlmRun
+    ? (metrics?.llm_results?.rounds?.length || metrics?.llm_results?.train_loss?.length || 0)
+    : (globalResults.global_accuracy?.length || 0);
+  const rounds = isLlmRun
+    ? llmRounds(metrics)
+    : globalResults.rounds ? globalResults.rounds.slice(0, actualDataLength) : Array.from({ length: actualDataLength }, (_, i) => i + 1);
   const safeSlice = (arr: any[]) => (arr || []).slice(0, actualDataLength);
 
   const globalAccSeries = [{ key: "g_acc", label: "Global Accuracy", color: CHART_COLORS[0], values: safeSlice(globalResults.global_accuracy) }];
   const globalLossSeries = [{ key: "g_loss", label: "Global Loss", color: CHART_COLORS[3], values: safeSlice(globalResults.global_loss) }];
-  const clientIds = Object.keys(clientResults);
-  const clientTrainAccSeries = clientIds.map((cId, idx) => ({ key: `${cId}_train_acc`, label: cId, color: CHART_COLORS[(idx + 1) % CHART_COLORS.length], values: safeSlice(clientResults[cId].train_acc) }));
-  const clientTrainLossSeries = clientIds.map((cId, idx) => ({ key: `${cId}_train_loss`, label: cId, color: CHART_COLORS[(idx + 1) % CHART_COLORS.length], values: safeSlice(clientResults[cId].train_loss) }));
-  const clientTestAccSeries = clientIds.map((cId, idx) => ({ key: `${cId}_test_acc`, label: cId, color: CHART_COLORS[(idx + 1) % CHART_COLORS.length], values: safeSlice(clientResults[cId].test_acc) }));
-  const clientTestLossSeries = clientIds.map((cId, idx) => ({ key: `${cId}_test_loss`, label: cId, color: CHART_COLORS[(idx + 1) % CHART_COLORS.length], values: safeSlice(clientResults[cId].test_loss) }));
+  const clientTrainAccSeries = toClientSeries(metrics, "train_acc", rounds);
+  const clientTrainLossSeries = toClientSeries(metrics, "train_loss", rounds);
+  const clientTestAccSeries = toClientSeries(metrics, "test_acc", rounds);
+  const clientTestLossSeries = toClientSeries(metrics, "test_loss", rounds);
 
   return (
-    <div className="grid h-full gap-4 xl:grid-cols-[300px_1fr]">
+    <div className="grid h-full gap-4 xl:grid-cols-[360px_1fr]">
       
       <Card className="flex flex-col min-h-0 bg-muted/10 border-r shadow-none rounded-none sm:rounded-xl">
         <CardHeader className="pb-3 px-4">
@@ -147,6 +351,48 @@ export function AgentResultsCompare(props: AgentPageProps) {
           <CardDescription className="text-xs">Past agent optimizations</CardDescription>
         </CardHeader>
         <CardContent className="flex-1 overflow-auto space-y-3 px-3 pb-4">
+          <div className="space-y-3 rounded-lg border bg-background/70 p-3">
+            <div className="flex items-center gap-2 text-xs font-semibold text-foreground">
+              <Search className="h-4 w-4 text-muted-foreground" />
+              Filter history
+            </div>
+            <div className="grid grid-cols-2 gap-2">
+              <Select value={historyFilters.status ?? "all"} onValueChange={(value) => updateHistoryFilter("status", value)}>
+                <SelectTrigger className="h-8 text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {HISTORY_STATUS_OPTIONS.map((option) => (
+                    <SelectItem key={option.value} value={option.value}>{option.label}</SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+              <Select value={historyFilters.objective ?? "all"} onValueChange={(value) => updateHistoryFilter("objective", value as AgentHistoryFilters["objective"])}>
+                <SelectTrigger className="h-8 text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {OBJECTIVE_OPTIONS.map((option) => (
+                    <SelectItem key={option.value} value={option.value}>{option.label}</SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+            <div className="grid grid-cols-2 gap-2">
+              {optionSelect("Dataset", historyFilters.dataset, datasetOptions, (value) => updateHistoryFilter("dataset", value))}
+              {optionSelect("Model", historyFilters.config_model, configModelOptions, (value) => updateHistoryFilter("config_model", value))}
+              {optionSelect("Aggregation", historyFilters.aggregation, aggregationOptions, (value) => updateHistoryFilter("aggregation", value))}
+              {optionSelect("LLM", historyFilters.model_name, llmModelOptions, (value) => updateHistoryFilter("model_name", value))}
+            </div>
+            <div className="flex gap-2">
+              <Button type="button" size="sm" className="h-8 flex-1 text-xs" onClick={() => void applyHistoryFilters().catch((error: unknown) => notifyError(error, "agent-history-filter"))}>
+                <Search className="mr-2 h-3.5 w-3.5" /> Apply
+              </Button>
+              <Button type="button" variant="outline" size="sm" className="h-8 px-2" onClick={resetHistoryFilters} title="Reset filters">
+                <RotateCcw className="h-3.5 w-3.5" />
+              </Button>
+            </div>
+          </div>
           {jobs.length === 0 && <div className="text-xs text-muted-foreground text-center py-8">No history yet.</div>}
           
           {jobs.map((job: any) => {
@@ -212,10 +458,16 @@ export function AgentResultsCompare(props: AgentPageProps) {
                     <p className="font-bold text-emerald-800 dark:text-emerald-300">Optimal Configuration</p>
                   </div>
                   <div className="text-3xl font-black text-emerald-700 dark:text-emerald-400 mb-2">
-                    {bestExp?.score != null ? `${(bestExp.score * 100).toFixed(2)}%` : "N/A"}
+                    {isLlmRunMetrics(bestExp?.metrics)
+                      ? latestLlmLoss(bestExp?.metrics) !== null
+                        ? latestLlmLoss(bestExp?.metrics)?.toFixed(4)
+                        : "N/A"
+                      : bestExp?.score != null
+                        ? `${(bestExp.score * 100).toFixed(2)}%`
+                        : "N/A"}
                   </div>
                   <p className="text-xs text-emerald-700/70 dark:text-emerald-400/70">
-                    Experiment <strong>"{bestExp?.name}"</strong> yielded the highest accuracy.
+                    Experiment <strong>"{bestExp?.name}"</strong> yielded the {isLlmRunMetrics(bestExp?.metrics) ? "lowest visible LLM loss" : "highest accuracy"}.
                   </p>
                   {bestConfig ? (
                     <>
@@ -292,6 +544,90 @@ export function AgentResultsCompare(props: AgentPageProps) {
               </Card>
             </div>
 
+            <Card className="shadow-sm">
+              <CardHeader className="pb-3">
+                <CardTitle className="text-sm flex items-center gap-2">
+                  <GitCompare className="h-4 w-4 text-primary" /> Configuration Versions
+                </CardTitle>
+                <CardDescription className="text-xs">Compare captured experiment configs</CardDescription>
+              </CardHeader>
+              <CardContent className="space-y-3">
+                {configVersions.length === 0 ? (
+                  <div className="rounded-md border border-dashed py-6 text-center text-xs text-muted-foreground">
+                    No experiment configs for this job.
+                  </div>
+                ) : (
+                  <>
+                    <div className="grid gap-2 md:grid-cols-[1fr_1fr]">
+                      <Select value={fromVersionKey} onValueChange={setFromVersionKey}>
+                        <SelectTrigger className="h-9 text-xs">
+                          <SelectValue placeholder="From experiment" />
+                        </SelectTrigger>
+                        <SelectContent>
+                          {configVersions.map((version) => (
+                            <SelectItem key={version.id} value={String(version.id)}>
+                              {version.label}
+                            </SelectItem>
+                          ))}
+                        </SelectContent>
+                      </Select>
+                      <Select value={toVersionKey} onValueChange={setToVersionKey}>
+                        <SelectTrigger className="h-9 text-xs">
+                          <SelectValue placeholder="To experiment" />
+                        </SelectTrigger>
+                        <SelectContent>
+                          {configVersions.map((version) => (
+                            <SelectItem key={version.id} value={String(version.id)}>
+                              {version.label}
+                            </SelectItem>
+                          ))}
+                        </SelectContent>
+                      </Select>
+                    </div>
+                    <div className="grid gap-2 md:grid-cols-3">
+                      {configVersions.slice(-3).map((version) => (
+                        <div key={version.id} className="rounded-md border bg-muted/20 px-3 py-2">
+                          <div className="flex items-center justify-between gap-2">
+                            <span className="truncate text-xs font-semibold">{version.label}</span>
+                            <Badge variant="outline" className="shrink-0 text-[10px]">{version.source}</Badge>
+                          </div>
+                          <div className="mt-1 text-[10px] text-muted-foreground">
+                            Iteration {version.iteration || "-"} - {fmt(version.created_at)}
+                          </div>
+                        </div>
+                      ))}
+                    </div>
+                    <div className="max-h-72 overflow-auto rounded-md border">
+                      {configDiff.length === 0 ? (
+                        <div className="p-4 text-center text-xs text-muted-foreground">No config changes.</div>
+                      ) : (
+                        <div className="divide-y">
+                          {configDiff.map((change, index) => (
+                            <div key={`${change.path}-${index}`} className="grid gap-2 p-3 text-xs md:grid-cols-[180px_90px_1fr]">
+                              <div className="break-all font-semibold text-foreground">{change.path}</div>
+                              <Badge variant="outline" className={`h-5 w-fit text-[10px] ${diffBadgeClass(change.change_type)}`}>
+                                {change.change_type}
+                              </Badge>
+                              <div className="grid gap-1 text-muted-foreground sm:grid-cols-2">
+                                <div className="min-w-0 rounded bg-muted/30 px-2 py-1">
+                                  <span className="font-semibold text-foreground/70">Before </span>
+                                  <span className="break-all">{formatDiffValue(change.old_value)}</span>
+                                </div>
+                                <div className="min-w-0 rounded bg-muted/30 px-2 py-1">
+                                  <span className="font-semibold text-foreground/70">After </span>
+                                  <span className="break-all">{formatDiffValue(change.new_value)}</span>
+                                </div>
+                              </div>
+                            </div>
+                          ))}
+                        </div>
+                      )}
+                    </div>
+                  </>
+                )}
+              </CardContent>
+            </Card>
+
             <div className="mt-4">
               <h3 className="text-sm font-bold tracking-tight flex items-center gap-2 mb-3">
                 <Activity className="h-4 w-4 text-primary" /> 
@@ -321,14 +657,66 @@ export function AgentResultsCompare(props: AgentPageProps) {
             </div>
 
             {selectedRunId ? (
-              <div className="grid grid-cols-1 md:grid-cols-2 gap-4 mt-2">
-                <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Global Accuracy" xValues={rounds} series={globalAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} /></CardContent></Card>
-                <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Global Loss" xValues={rounds} series={globalLossSeries} formatter={(v: number) => v.toFixed(4)} /></CardContent></Card>
-                <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Client Train Accuracy" xValues={rounds} series={clientTrainAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} /></CardContent></Card>
-                <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Client Test Accuracy" xValues={rounds} series={clientTestAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} /></CardContent></Card>
-                <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Client Train Loss" xValues={rounds} series={clientTrainLossSeries} formatter={(v: number) => v.toFixed(4)} /></CardContent></Card>
-                <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Client Test Loss" xValues={rounds} series={clientTestLossSeries} formatter={(v: number) => v.toFixed(4)} /></CardContent></Card>
-              </div>
+              <>
+                {!isLlmRun && (
+                  <div className="grid grid-cols-1 md:grid-cols-2 gap-4 mt-2">
+                    <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Global Accuracy" xValues={rounds} series={globalAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} /></CardContent></Card>
+                    <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Global Loss" xValues={rounds} series={globalLossSeries} formatter={(v: number) => v.toFixed(4)} /></CardContent></Card>
+                    <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Client Train Accuracy" xValues={rounds} series={clientTrainAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} /></CardContent></Card>
+                    <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Client Test Accuracy" xValues={rounds} series={clientTestAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} /></CardContent></Card>
+                    <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Client Train Loss" xValues={rounds} series={clientTrainLossSeries} formatter={(v: number) => v.toFixed(4)} /></CardContent></Card>
+                    <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Client Test Loss" xValues={rounds} series={clientTestLossSeries} formatter={(v: number) => v.toFixed(4)} /></CardContent></Card>
+                  </div>
+                )}
+                {isLlmRun && (
+                  <div className="space-y-4 mt-2">
+                    <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+                      <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="LLM Train Loss" xValues={rounds} series={llmTrainLossSeries(metrics)} formatter={(v: number) => v.toFixed(4)} /></CardContent></Card>
+                      <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="LLM Validation Loss" xValues={rounds} series={llmValidationLossSeries(metrics)} formatter={(v: number) => v.toFixed(4)} emptyMessage="No validation data available." /></CardContent></Card>
+                      <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Perplexity" xValues={rounds} series={llmPerplexitySeries(metrics)} formatter={(v: number) => v.toFixed(2)} /></CardContent></Card>
+                      <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Token Throughput" xValues={rounds} series={llmThroughputSeries(metrics)} formatter={(v: number) => `${v.toFixed(1)} tok/s`} /></CardContent></Card>
+                      <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Adapter Size" xValues={rounds} series={llmAdapterSizeSeries(metrics)} formatter={(v: number) => formatBytes(v)} /></CardContent></Card>
+                      <Card className="shadow-sm"><CardContent className="p-4"><MiniLineChart title="Client Train Loss" xValues={rounds} series={clientTrainLossSeries} formatter={(v: number) => v.toFixed(4)} /></CardContent></Card>
+                    </div>
+                    <Card className="shadow-sm">
+                      <CardHeader className="pb-2">
+                        <CardTitle className="text-sm">Adapter Lineage</CardTitle>
+                      </CardHeader>
+                      <CardContent>
+                        <div className="overflow-auto rounded-md border">
+                          <table className="w-full min-w-[680px] text-left text-xs">
+                            <thead className="border-b bg-muted/40 text-muted-foreground">
+                              <tr>
+                                <th className="px-3 py-2 font-medium">Round</th>
+                                <th className="px-3 py-2 font-medium">Clients</th>
+                                <th className="px-3 py-2 font-medium">Size</th>
+                                <th className="px-3 py-2 font-medium">SHA-256</th>
+                                <th className="px-3 py-2 font-medium">Parent</th>
+                              </tr>
+                            </thead>
+                            <tbody>
+                              {(metrics?.llm_artifacts ?? []).map((artifact: Record<string, unknown>, index: number) => (
+                                <tr key={`${artifact.path ?? index}`} className="border-b last:border-none">
+                                  <td className="px-3 py-2 font-mono">{formatFieldValue(artifact.round)}</td>
+                                  <td className="px-3 py-2 font-mono">{selectedClientsText(artifact.selected_clients)}</td>
+                                  <td className="px-3 py-2 font-mono">{formatBytes(artifact.size_bytes)}</td>
+                                  <td className="px-3 py-2 font-mono" title={String(artifact.sha256 ?? "")}>{shortHash(artifact.sha256)}</td>
+                                  <td className="px-3 py-2 font-mono" title={String(artifact.parent_sha256 ?? "")}>{shortHash(artifact.parent_sha256)}</td>
+                                </tr>
+                              ))}
+                              {(metrics?.llm_artifacts ?? []).length === 0 && (
+                                <tr>
+                                  <td colSpan={5} className="px-3 py-6 text-center text-muted-foreground">No adapter artifacts recorded yet.</td>
+                                </tr>
+                              )}
+                            </tbody>
+                          </table>
+                        </div>
+                      </CardContent>
+                    </Card>
+                  </div>
+                )}
+              </>
             ) : (
                <div className="text-center py-10 text-sm text-muted-foreground border border-dashed rounded-lg">
                  Select an experiment above to load its charts.
diff --git a/apps/frontend/src/features/agent/components/AgentRunDashboard.tsx b/apps/frontend/src/features/agent/components/AgentRunDashboard.tsx
index d5d82fa..01c3035 100644
--- a/apps/frontend/src/features/agent/components/AgentRunDashboard.tsx
+++ b/apps/frontend/src/features/agent/components/AgentRunDashboard.tsx
@@ -3,9 +3,21 @@ import { Activity, Bot, TerminalSquare, CheckCircle2, CircleDashed, LayoutGrid }
 import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "../../../components/ui/card";
 import { Separator } from "../../../components/ui/separator";
 import { MiniLineChart } from "../../simulation/components/MiniLineChart";
+import { toClientSeries } from "../../simulation/utils";
 import { fmt } from "../../../lib/time";
 import type { AgentPageProps } from "../../../pages/types";
 import { baseUrl } from "../../../../src/api/client";
+import {
+  formatBytes,
+  isLlmRunMetrics,
+  llmAdapterSizeSeries,
+  llmPerplexitySeries,
+  llmRounds,
+  llmThroughputSeries,
+  llmTrainLossSeries,
+  llmValidationLossSeries,
+  latestLlmLoss,
+} from "../../simulation/llm-metrics";
 import ReactMarkdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
 
@@ -23,11 +35,9 @@ export function AgentRunDashboard({ progress }: AgentPageProps) {
   const [selectedRunId, setSelectedRunId] = useState<string | null>(null);
   const [liveMetrics, setLiveMetrics] = useState<any>(null);
 
-  if (!progress) return null;
-
-  const currentExp = progress.current_experiment;
-  const currentPlan = progress.current_plan;
-  const experiments = progress.experiments || [];
+  const currentExp = progress?.current_experiment;
+  const currentPlan = progress?.current_plan;
+  const experiments = progress?.experiments || [];
   const activeRunId = selectedRunId 
     || currentExp?.run_id 
     || (experiments.length > 0 ? experiments[experiments.length - 1].run_id : null);
@@ -61,15 +71,19 @@ export function AgentRunDashboard({ progress }: AgentPageProps) {
     };
   }, [activeRunId]);
 
+  if (!progress) return null;
+
   const activeExpMetadata = experiments.find((e: any) => e.run_id === activeRunId) 
                          || (currentExp?.run_id === activeRunId ? currentExp : null);
 
   const metrics = liveMetrics || activeExpMetadata?.metrics || {};
+  const isLlmRun = isLlmRunMetrics(metrics);
   const globalResults = metrics.global_results || {};
-  const clientResults = metrics.client_results || {};
-  const actualDataLength = globalResults.global_accuracy?.length || 0;
+  const actualDataLength = isLlmRun
+    ? (metrics.llm_results?.rounds?.length || metrics.llm_results?.train_loss?.length || 0)
+    : (globalResults.global_accuracy?.length || 0);
 
-  const rounds = globalResults.rounds 
+  const rounds = isLlmRun ? llmRounds(metrics) : globalResults.rounds
     ? globalResults.rounds.slice(0, actualDataLength) 
     : Array.from({ length: actualDataLength }, (_, i) => i + 1);
 
@@ -87,31 +101,17 @@ export function AgentRunDashboard({ progress }: AgentPageProps) {
     values: safeSlice(globalResults.global_loss) 
   }];
 
-  const clientIds = Object.keys(clientResults);
-  
   // 3. Client Train Acc
-  const clientTrainAccSeries = clientIds.map((cId, idx) => ({
-    key: `${cId}_train_acc`, label: cId, color: CHART_COLORS[(idx + 1) % CHART_COLORS.length],
-    values: safeSlice(clientResults[cId].train_acc)
-  }));
+  const clientTrainAccSeries = toClientSeries(metrics, "train_acc", rounds);
 
   // 4. Client Train Loss
-  const clientTrainLossSeries = clientIds.map((cId, idx) => ({
-    key: `${cId}_train_loss`, label: cId, color: CHART_COLORS[(idx + 1) % CHART_COLORS.length],
-    values: safeSlice(clientResults[cId].train_loss)
-  }));
+  const clientTrainLossSeries = toClientSeries(metrics, "train_loss", rounds);
 
   // 5. Client Test Acc
-  const clientTestAccSeries = clientIds.map((cId, idx) => ({
-    key: `${cId}_test_acc`, label: cId, color: CHART_COLORS[(idx + 1) % CHART_COLORS.length],
-    values: safeSlice(clientResults[cId].test_acc)
-  }));
+  const clientTestAccSeries = toClientSeries(metrics, "test_acc", rounds);
 
   // 6. Client Test Loss
-  const clientTestLossSeries = clientIds.map((cId, idx) => ({
-    key: `${cId}_test_loss`, label: cId, color: CHART_COLORS[(idx + 1) % CHART_COLORS.length],
-    values: safeSlice(clientResults[cId].test_loss)
-  }));
+  const clientTestLossSeries = toClientSeries(metrics, "test_loss", rounds);
 
   return (
     <div className="grid h-full gap-4 xl:grid-cols-[240px_1fr_300px]">
@@ -136,7 +136,14 @@ export function AgentRunDashboard({ progress }: AgentPageProps) {
                   <span className={`font-semibold truncate ${isSelected ? 'text-primary' : 'text-foreground'}`}>
                     {`Exp ${idx + 1}`}
                   </span>
-                  {exp.score != null && <span className="text-[10px] text-muted-foreground mt-0.5">Acc: {(exp.score * 100).toFixed(2)}%</span>}
+                  {isLlmRunMetrics(exp.metrics) && latestLlmLoss(exp.metrics) !== null && (
+                    <span className="text-[10px] text-muted-foreground mt-0.5">
+                      Loss: {latestLlmLoss(exp.metrics)?.toFixed(4)}
+                    </span>
+                  )}
+                  {!isLlmRunMetrics(exp.metrics) && exp.score != null && (
+                    <span className="text-[10px] text-muted-foreground mt-0.5">Acc: {(exp.score * 100).toFixed(2)}%</span>
+                  )}
                 </div>
                 <CheckCircle2 className="h-4 w-4 text-emerald-500 shrink-0 ml-2" />
               </div>
@@ -184,37 +191,51 @@ export function AgentRunDashboard({ progress }: AgentPageProps) {
           </h3>
         </div>
 
-        <div className="grid grid-cols-1 md:grid-cols-2 gap-4 pb-4">
-          {/* Chart 1: Global Acc */}
-          <Card className="shadow-sm"><CardContent className="p-4">
-            <MiniLineChart title="Global Accuracy" xValues={rounds} series={globalAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} />
-          </CardContent></Card>
-          
-          {/* Chart 2: Global Loss */}
-          <Card className="shadow-sm"><CardContent className="p-4">
-            <MiniLineChart title="Global Loss" xValues={rounds} series={globalLossSeries} formatter={(v: number) => v.toFixed(4)} />
-          </CardContent></Card>
-
-          {/* Chart 3: Client Train Acc */}
-          <Card className="shadow-sm"><CardContent className="p-4">
-            <MiniLineChart title="Client Train Accuracy" xValues={rounds} series={clientTrainAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} />
-          </CardContent></Card>
-
-          {/* Chart 4: Client Test Acc */}
-          <Card className="shadow-sm"><CardContent className="p-4">
-            <MiniLineChart title="Client Test Accuracy" xValues={rounds} series={clientTestAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} />
-          </CardContent></Card>
+        {!isLlmRun && (
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-4 pb-4">
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="Global Accuracy" xValues={rounds} series={globalAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} />
+            </CardContent></Card>
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="Global Loss" xValues={rounds} series={globalLossSeries} formatter={(v: number) => v.toFixed(4)} />
+            </CardContent></Card>
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="Client Train Accuracy" xValues={rounds} series={clientTrainAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} />
+            </CardContent></Card>
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="Client Test Accuracy" xValues={rounds} series={clientTestAccSeries} formatter={(v: number) => `${(v * 100).toFixed(2)}%`} />
+            </CardContent></Card>
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="Client Train Loss" xValues={rounds} series={clientTrainLossSeries} formatter={(v: number) => v.toFixed(4)} />
+            </CardContent></Card>
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="Client Test Loss" xValues={rounds} series={clientTestLossSeries} formatter={(v: number) => v.toFixed(4)} />
+            </CardContent></Card>
+          </div>
+        )}
 
-          {/* Chart 5: Client Train Loss */}
-          <Card className="shadow-sm"><CardContent className="p-4">
-            <MiniLineChart title="Client Train Loss" xValues={rounds} series={clientTrainLossSeries} formatter={(v: number) => v.toFixed(4)} />
-          </CardContent></Card>
-
-          {/* Chart 6: Client Test Loss */}
-          <Card className="shadow-sm"><CardContent className="p-4">
-            <MiniLineChart title="Client Test Loss" xValues={rounds} series={clientTestLossSeries} formatter={(v: number) => v.toFixed(4)} />
-          </CardContent></Card>
-        </div>
+        {isLlmRun && (
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-4 pb-4">
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="LLM Train Loss" xValues={rounds} series={llmTrainLossSeries(metrics)} formatter={(v: number) => v.toFixed(4)} />
+            </CardContent></Card>
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="LLM Validation Loss" xValues={rounds} series={llmValidationLossSeries(metrics)} formatter={(v: number) => v.toFixed(4)} emptyMessage="No validation data available." />
+            </CardContent></Card>
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="Perplexity" xValues={rounds} series={llmPerplexitySeries(metrics)} formatter={(v: number) => v.toFixed(2)} />
+            </CardContent></Card>
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="Token Throughput" xValues={rounds} series={llmThroughputSeries(metrics)} formatter={(v: number) => `${v.toFixed(1)} tok/s`} />
+            </CardContent></Card>
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="Adapter Size" xValues={rounds} series={llmAdapterSizeSeries(metrics)} formatter={(v: number) => formatBytes(v)} />
+            </CardContent></Card>
+            <Card className="shadow-sm"><CardContent className="p-4">
+              <MiniLineChart title="Client Train Loss" xValues={rounds} series={clientTrainLossSeries} formatter={(v: number) => v.toFixed(4)} />
+            </CardContent></Card>
+          </div>
+        )}
       </div>
 
       <div className="flex flex-col gap-4 min-h-0 overflow-auto pb-4">
@@ -282,4 +303,4 @@ export function AgentRunDashboard({ progress }: AgentPageProps) {
       
     </div>
   );
-}
\ No newline at end of file
+}
diff --git a/apps/frontend/src/features/agent/schema.ts b/apps/frontend/src/features/agent/schema.ts
index aa558c3..ed48bad 100644
--- a/apps/frontend/src/features/agent/schema.ts
+++ b/apps/frontend/src/features/agent/schema.ts
@@ -9,9 +9,29 @@ import {
   setValueByPath,
   type SchemaNode,
 } from "../simulation/utils";
+import {
+  dynamicBooleanState,
+  dynamicOptionState,
+  fieldHint,
+  optionLabel as compatibilityOptionLabel,
+  optionMeta as compatibilityOptionMeta,
+  staticOptionDisabled,
+} from "../config/compatibility";
 
 const META_KEYS = new Set(["role", "depends_on", "hidden", "ui"]);
-const AGENT_SECTIONS = new Set(["dataset", "model", "federated", "compression", "privacy"]);
+const AGENT_SECTIONS = new Set([
+  "task",
+  "dataset",
+  "model",
+  "llm",
+  "sft",
+  "peft",
+  "evaluation",
+  "federated",
+  "compression",
+  "privacy",
+]);
+const REQUIRED_LLM_RESOURCE_FIELDS = new Set(["llm.base_model", "sft.dataset_path", "evaluation.dataset_path"]);
 
 export type AgentSchemaField = {
   path: string;
@@ -24,6 +44,7 @@ export type AgentSchemaField = {
   featured: boolean;
   group: string;
   options: unknown[];
+  dependsOn?: string;
 };
 
 function labelize(key: string): string {
@@ -44,19 +65,60 @@ export function fieldLabel(key: string, definition: SchemaNode): string {
 }
 
 export function optionMeta(definition: SchemaNode, option: unknown): Record<string, unknown> {
-  const options = fieldUi(definition).options;
-  if (!isRecord(options)) return {};
-  const meta = options[String(option)];
-  return isRecord(meta) ? meta : {};
+  return compatibilityOptionMeta(definition, option);
 }
 
 export function optionLabel(definition: SchemaNode, option: unknown): string {
-  const meta = optionMeta(definition, option);
-  return typeof meta.label === "string" && meta.label.trim() ? meta.label : String(option);
+  return compatibilityOptionLabel(definition, option);
 }
 
 export function optionDisabled(definition: SchemaNode, option: unknown): boolean {
-  return optionMeta(definition, option).disabled === true;
+  return staticOptionDisabled(definition, option);
+}
+
+export function optionDisabledForConfig(
+  definition: SchemaNode,
+  option: unknown,
+  path: string,
+  config: Record<string, unknown>,
+): boolean {
+  return optionDisabled(definition, option) || dynamicOptionState(path, option, config).disabled;
+}
+
+export function optionDisableReasonForConfig(
+  definition: SchemaNode,
+  option: unknown,
+  path: string,
+  config: Record<string, unknown>,
+): string | null {
+  const meta = optionMeta(definition, option);
+  if (optionDisabled(definition, option)) {
+    return typeof meta.description === "string" ? meta.description : "Not executable yet.";
+  }
+  return dynamicOptionState(path, option, config).reason ?? null;
+}
+
+export function booleanDisabledForConfig(path: string, value: unknown, config: Record<string, unknown>): boolean {
+  return dynamicBooleanState(path, value, config).disabled;
+}
+
+export function booleanDisableReasonForConfig(path: string, value: unknown, config: Record<string, unknown>): string | null {
+  return dynamicBooleanState(path, value, config).reason ?? null;
+}
+
+export function fieldCompatibilityHint(path: string, config: Record<string, unknown>): string | null {
+  return fieldHint(path, config);
+}
+
+export function fieldEmptyMessage(field: AgentSchemaField): string | null {
+  const ui = fieldUi(field.definition);
+  if (typeof ui.empty_message === "string" && ui.empty_message.trim().length > 0) {
+    return ui.empty_message;
+  }
+  if (field.path === "llm.base_model") return "No local models found";
+  if (field.path === "sft.dataset_path") return "No training datasets found";
+  if (field.path === "evaluation.dataset_path") return "No evaluation datasets found";
+  return null;
 }
 
 function isAgentVisible(definition: SchemaNode): boolean {
@@ -79,6 +141,15 @@ export function checkDependency(properties: Record<string, unknown>, dependsOn?:
   });
 }
 
+function combineDependencies(parent?: string, child?: string): string | undefined {
+  const dependencies = [parent, child].filter((value): value is string => typeof value === "string" && value.trim().length > 0);
+  return dependencies.length > 0 ? dependencies.join(" && ") : undefined;
+}
+
+export function agentFieldVisibleForConfig(field: AgentSchemaField, config: Record<string, unknown>): boolean {
+  return checkDependency(config, field.dependsOn ?? field.definition.depends_on);
+}
+
 export function collectAgentSchemaFields(
   schema: Record<string, unknown> | null,
   options: { featuredOnly?: boolean } = {},
@@ -86,13 +157,14 @@ export function collectAgentSchemaFields(
   if (!schema) return [];
   const fields: AgentSchemaField[] = [];
 
-  function walk(node: Record<string, unknown>, prefix: string, section: string): void {
+  function walk(node: Record<string, unknown>, prefix: string, section: string, inheritedDependsOn?: string): void {
     for (const [key, rawDefinition] of Object.entries(node)) {
       if (META_KEYS.has(key) || !isRecord(rawDefinition)) continue;
       const definition = rawDefinition as SchemaNode;
       const path = prefix ? `${prefix}.${key}` : key;
       const currentSection = prefix ? section : key;
       if (!AGENT_SECTIONS.has(currentSection)) continue;
+      const dependsOn = combineDependencies(inheritedDependsOn, definition.depends_on);
 
       if (isFieldDefinition(definition)) {
         const ui = fieldUi(definition);
@@ -110,11 +182,12 @@ export function collectAgentSchemaFields(
           featured,
           group: typeof ui.group === "string" ? ui.group : "Advanced",
           options: Array.isArray(definition.options) ? definition.options : [],
+          dependsOn,
         });
         continue;
       }
 
-      walk(definition, path, currentSection);
+      walk(definition, path, currentSection, dependsOn);
     }
   }
 
@@ -124,7 +197,74 @@ export function collectAgentSchemaFields(
 
 export function buildAgentConfig(schema: Record<string, unknown> | null, patch: Record<string, unknown>): Record<string, unknown> {
   const defaults = schema ? initDefaultsFromSchema(schema) : {};
-  return deepMerge(defaults, patch);
+  const config = deepMerge(defaults, patch);
+  setValueByPath(config, "system.mode", "simulation");
+  setValueByPath(config, "system.node_role", "server");
+  return config;
+}
+
+export function applyConfigConstraints(
+  config: Record<string, unknown>,
+  constraints: Record<string, unknown> | null | undefined,
+): Record<string, unknown> {
+  return deepMerge(config, constraints ?? {});
+}
+
+export function materializeAgentConfigConstraints(
+  schema: Record<string, unknown> | null,
+  constraints: Record<string, unknown>,
+): Record<string, unknown> {
+  const config = buildAgentConfig(schema, constraints);
+  if (getValueByPath(config, "task.type") !== "llm_peft_sft") {
+    return constraints;
+  }
+
+  let next = structuredClone(constraints);
+  for (const path of ["task.type", "llm.base_model"]) {
+    const value = getValueByPath(config, path);
+    if (typeof value === "string" && value.trim().length > 0) {
+      setValueByPath(next, path, value);
+    }
+  }
+
+  const datasetPath = getValueByPath(config, "sft.dataset_path");
+  if (typeof datasetPath === "string" && datasetPath.trim().length > 0) {
+    setValueByPath(next, "sft.dataset_path", datasetPath);
+    for (const [inferredPath, inferredValue] of Object.entries(inferSftSettingsForDatasetPath(datasetPath))) {
+      setValueByPath(next, inferredPath, inferredValue);
+    }
+  }
+
+  const evaluationEnabled = getValueByPath(config, "evaluation.enable");
+  if (typeof evaluationEnabled === "boolean") {
+    setValueByPath(next, "evaluation.enable", evaluationEnabled);
+  }
+  const evaluationPath = getValueByPath(config, "evaluation.dataset_path");
+  if (evaluationEnabled === true && typeof evaluationPath === "string" && evaluationPath.trim().length > 0) {
+    setValueByPath(next, "evaluation.dataset_path", evaluationPath);
+  }
+
+  return next;
+}
+
+export function missingLlmResourceMessages(
+  schema: Record<string, unknown> | null,
+  config: Record<string, unknown>,
+): string[] {
+  const messages: string[] = [];
+  for (const field of collectAgentSchemaFields(schema, { featuredOnly: false })) {
+    if (!REQUIRED_LLM_RESOURCE_FIELDS.has(field.path)) continue;
+    if (!agentFieldVisibleForConfig(field, config)) continue;
+    if (field.options.length === 0) {
+      messages.push(fieldEmptyMessage(field) ?? (field.path === "llm.base_model" ? "No local models found" : "No training datasets found"));
+      continue;
+    }
+    const value = getValueByPath(config, field.path);
+    if (typeof value !== "string" || value.trim().length === 0) {
+      messages.push(`${field.label} is required`);
+    }
+  }
+  return Array.from(new Set(messages));
 }
 
 export function removeValueByPath(obj: Record<string, unknown>, path: string): Record<string, unknown> {
@@ -170,13 +310,35 @@ export function setConfigValue(config: Record<string, unknown>, path: string, va
   return next;
 }
 
+export function inferSftSettingsForDatasetPath(value: unknown): Record<string, string> {
+  const datasetPath = String(value ?? "").trim().toLowerCase();
+  const fileFormat = datasetPath.endsWith(".jsonl")
+    ? "jsonl"
+    : datasetPath.endsWith(".parquet")
+      ? "parquet"
+      : "auto";
+  const dataFormat = datasetPath.includes("alpaca")
+    ? "alpaca"
+    : datasetPath.includes("messages") || datasetPath.includes("chat")
+      ? "messages"
+      : "prompt_completion";
+
+  return {
+    "sft.file_format": fileFormat,
+    "sft.format": dataFormat,
+  };
+}
+
 export function validateDisabledOptions(config: Record<string, unknown>, schema: Record<string, unknown> | null): string[] {
   const errors: string[] = [];
   for (const field of collectAgentSchemaFields(schema, { featuredOnly: false })) {
+    if (!agentFieldVisibleForConfig(field, config)) continue;
     if (field.type !== "select") continue;
     const value = getValueByPath(config, field.path);
-    if (value !== undefined && optionDisabled(field.definition, value)) {
-      errors.push(`${field.label}: ${optionLabel(field.definition, value)} is experimental and not executable yet.`);
+    if (value !== undefined && optionDisabledForConfig(field.definition, value, field.path, config)) {
+      const reason = optionDisableReasonForConfig(field.definition, value, field.path, config);
+      const suffix = reason ? ` ${reason}` : " It is not compatible with the current configuration.";
+      errors.push(`${field.label}: ${optionLabel(field.definition, value)} is unavailable.${suffix}`);
     }
   }
   return errors;
@@ -192,8 +354,10 @@ export function formatFieldValue(value: unknown): string {
 export function selectedConstraintChips(
   schema: Record<string, unknown> | null,
   constraints: Record<string, unknown>,
+  config?: Record<string, unknown>,
 ): Array<{ path: string; label: string; value: string }> {
   return collectAgentSchemaFields(schema, { featuredOnly: true })
+    .filter((field) => (config ? agentFieldVisibleForConfig(field, config) : true))
     .map((field) => {
       const value = getValueByPath(constraints, field.path);
       if (value === undefined) return null;
diff --git a/apps/frontend/src/features/agent/useAgentController.ts b/apps/frontend/src/features/agent/useAgentController.ts
index 8e0dc25..a9f2d2a 100644
--- a/apps/frontend/src/features/agent/useAgentController.ts
+++ b/apps/frontend/src/features/agent/useAgentController.ts
@@ -4,6 +4,7 @@ import { toast } from "sonner";
 import {
   agentApi,
   type AgentExperimentResponse,
+  type AgentHistoryFilters,
   type AgentOptimizationObjective,
   type AgentOptimizationJobSummary,
   type AgentOptimizeProgressResponse,
@@ -11,10 +12,19 @@ import {
   type AgentRunResponse,
 } from "../../api/agent";
 import type { AgentPageProps, AgentWorkflowStep, AgentPlanDraft } from "../../pages/types";
+import { latestLlmLoss } from "../simulation/llm-metrics";
 import { toErrorMessage } from "../simulation/utils";
-import { removeValueByPath, setConfigValue } from "./schema";
+import {
+  buildAgentConfig,
+  applyConfigConstraints,
+  inferSftSettingsForDatasetPath,
+  materializeAgentConfigConstraints,
+  missingLlmResourceMessages,
+  removeValueByPath,
+  setConfigValue,
+} from "./schema";
 
-const DEFAULT_GOAL = "Compare CIFAR-10 non-IID with alpha=0.1, 0.3, 0.5";
+const DEFAULT_GOAL = "Compare non-IID alpha=0.1, 0.3, 0.5 on the selected dataset";
 const POLL_INTERVAL_MS = 1500;
 
 function makeDefaultJobName(): string {
@@ -42,12 +52,12 @@ function toHistorySummary(progress: AgentOptimizeProgressResponse): AgentOptimiz
   if (progress.optimization_job_id === null) {
     return null;
   }
-  const bestMetrics = progress.best_metrics as Record<string, unknown> | null;
-  const globalResults = (bestMetrics?.global_results ?? null) as Record<string, unknown> | null;
-  const accuracy = Array.isArray(globalResults?.global_accuracy) ? globalResults?.global_accuracy : [];
+  const llmLoss = latestLlmLoss(progress.best_metrics);
+  const accuracy = progress.best_metrics?.global_results?.global_accuracy ?? [];
   const lastAccuracy = accuracy.length > 0 && typeof accuracy[accuracy.length - 1] === "number"
-    ? (accuracy[accuracy.length - 1] as number)
+    ? accuracy[accuracy.length - 1]
     : null;
+  const bestScore = llmLoss !== null ? -llmLoss : lastAccuracy;
   return {
     optimization_job_id: progress.optimization_job_id,
     task_id: progress.task_id,
@@ -61,7 +71,7 @@ function toHistorySummary(progress: AgentOptimizeProgressResponse): AgentOptimiz
     max_iterations: progress.max_iterations,
     current_iteration: progress.current_iteration,
     completed_iterations: progress.completed_iterations,
-    best_score: lastAccuracy,
+    best_score: bestScore,
     created_at: progress.created_at ?? new Date().toISOString(),
     updated_at: progress.updated_at ?? new Date().toISOString(),
     finished_at: progress.finished_at,
@@ -86,6 +96,7 @@ export function useAgentController(): AgentPageProps {
   const [experimentRuns, setExperimentRuns] = useState<AgentRunResponse[]>([]);
   const [selectedExperimentId, setSelectedExperimentId] = useState<number | null>(null);
   const [historyJobs, setHistoryJobs] = useState<AgentOptimizationJobSummary[]>([]);
+  const [historyFilters, setHistoryFilters] = useState<AgentHistoryFilters>({ status: "all", objective: "all" });
   const [progress, setProgress] = useState<AgentOptimizeProgressResponse | null>(null);
   const [result, setResult] = useState<AgentOptimizeResponse | null>(null);
   const [selectedHistory, setSelectedHistory] = useState<AgentOptimizeProgressResponse | null>(null);
@@ -108,8 +119,8 @@ export function useAgentController(): AgentPageProps {
     });
   }
 
-  async function refreshHistoryJobs(): Promise<void> {
-    const jobs = await agentApi.listOptimizationJobs();
+  async function refreshHistoryJobs(filters: AgentHistoryFilters = historyFilters): Promise<void> {
+    const jobs = await agentApi.listOptimizationJobs(filters);
     setHistoryJobs(jobs);
     if (jobs.length > 0 && selectedHistoryJobId === null && !busy && !progress) {
       const first = jobs[0];
@@ -128,6 +139,17 @@ export function useAgentController(): AgentPageProps {
     setExperiments(list);
   }
 
+  async function refreshLlmResources(): Promise<void> {
+    const [models, schema] = await Promise.all([
+      agentApi.listModels(),
+      agentApi.getConfigSchema(),
+    ]);
+
+    setModelOptions(models.models);
+    setDefaultModelName(models.default_model);
+    setConfigSchema(schema);
+  }
+
   async function selectExperiment(experimentId: number): Promise<void> {
     setSelectedExperimentId(experimentId);
     try {
@@ -173,6 +195,15 @@ export function useAgentController(): AgentPageProps {
       toast.warning("Please provide a job name.");
       return;
     }
+    const submissionConstraints = materializeAgentConfigConstraints(configSchema, configConstraints);
+    const missingResources = missingLlmResourceMessages(
+      configSchema,
+      buildAgentConfig(configSchema, submissionConstraints),
+    );
+    if (missingResources.length > 0) {
+      toast.error(missingResources.join(", "));
+      return;
+    }
   
     setBusy(true);
     try {
@@ -181,14 +212,14 @@ export function useAgentController(): AgentPageProps {
         job_name: trimmedJobName,
         model_name: modelName.trim().length > 0 ? modelName.trim() : null,
         system_mode: "simulation",
-        config_constraints: configConstraints,
+        config_constraints: submissionConstraints,
       });
   
       setDraftPlan({
         job_id: data.optimization_job_id!,
         goal: data.goal,
         experiments: data.experiments,
-        config_constraints: data.config_constraints ?? configConstraints,
+        config_constraints: data.config_constraints ?? submissionConstraints,
       });
       
       setWorkflowStep("preview");
@@ -202,6 +233,20 @@ export function useAgentController(): AgentPageProps {
   
   async function handleExecutePlan(editedExperiments: any[]): Promise<void> {
     if (!draftPlan) return;
+    const submissionConstraints = materializeAgentConfigConstraints(
+      configSchema,
+      draftPlan.config_constraints ?? configConstraints,
+    );
+    const disabledResources = editedExperiments.flatMap((exp) =>
+      missingLlmResourceMessages(
+        configSchema,
+        buildAgentConfig(configSchema, applyConfigConstraints(exp.config_patch ?? {}, submissionConstraints)),
+      ),
+    );
+    if (disabledResources.length > 0) {
+      toast.error(Array.from(new Set(disabledResources)).join(", "));
+      return;
+    }
     
     setBusy(true);
     setResult(null);
@@ -216,11 +261,16 @@ export function useAgentController(): AgentPageProps {
         model_name: modelName.trim().length > 0 ? modelName.trim() : null,
         objective: objective,
         planned_experiments: editedExperiments, // Bypass LLM parse in backend
-        config_constraints: draftPlan.config_constraints ?? configConstraints,
+        config_constraints: submissionConstraints,
       });
       
       setProgress(data);
       setActiveTaskId(data.task_id);
+      setSelectedHistory(data);
+      if (data.optimization_job_id !== null) {
+        setSelectedHistoryJobId(data.optimization_job_id);
+      }
+      upsertHistoryJob(toHistorySummary(data));
       setWorkflowStep("running");
     } catch (error) {
       notifyError(error, "agent-execute");
@@ -239,6 +289,15 @@ export function useAgentController(): AgentPageProps {
       toast.warning("Please provide a job name for this experiment.");
       return;
     }
+    const submissionConstraints = materializeAgentConfigConstraints(configSchema, configConstraints);
+    const missingResources = missingLlmResourceMessages(
+      configSchema,
+      buildAgentConfig(configSchema, submissionConstraints),
+    );
+    if (missingResources.length > 0) {
+      toast.error(missingResources.join(", "));
+      return;
+    }
 
     setBusy(true);
     setResult(null);
@@ -252,7 +311,7 @@ export function useAgentController(): AgentPageProps {
         model_name: modelName.trim().length > 0 ? modelName.trim() : null,
         job_name: trimmedJobName,
         objective,
-        config_constraints: configConstraints,
+        config_constraints: submissionConstraints,
       });
       setProgress(data);
       setActiveTaskId(data.task_id);
@@ -262,6 +321,7 @@ export function useAgentController(): AgentPageProps {
       }
       upsertHistoryJob(toHistorySummary(data));
       setJobName(makeDefaultJobName());
+      setWorkflowStep("running");
     } catch (error) {
       notifyError(error, "agent-optimize");
       setBusy(false);
@@ -277,44 +337,21 @@ export function useAgentController(): AgentPageProps {
 
   const presets = useMemo(
     () => [
-      "Compare CIFAR-10 non-IID with alpha=0.1, 0.3, 0.5",
+      "Compare non-IID alpha=0.1, 0.3, 0.5 on the selected dataset",
       "Compare 10 clients vs 20 clients with FedAvg",
       "Test training rounds 10, 20, 50 on accuracy",
+      "Run LLM PEFT SFT with LoRA rank 8 and rank 16 on a JSONL prompt/completion dataset",
     ],
     [],
   );
 
   useEffect(() => {
     let cancelled = false;
-    const loadModelOptions = async () => {
-      try {
-        const response = await agentApi.listModels();
-        if (cancelled) {
-          return;
-        }
-        setModelOptions(response.models);
-        setDefaultModelName(response.default_model);
-      } catch (error) {
-        if (cancelled) {
-          return;
-        }
-        toast.error(toErrorMessage(error), { id: "agent-models" });
-      }
-    };
-    const loadConfigSchema = async () => {
-      try {
-        const schema = await agentApi.getConfigSchema();
-        if (!cancelled) {
-          setConfigSchema(schema);
-        }
-      } catch (error) {
-        if (!cancelled) {
-          toast.error(toErrorMessage(error), { id: "agent-config-schema" });
-        }
+    void refreshLlmResources().catch((error: unknown) => {
+      if (!cancelled) {
+        toast.error(toErrorMessage(error), { id: "agent-llm-resources" });
       }
-    };
-    void loadModelOptions();
-    void loadConfigSchema();
+    });
     void refreshHistoryJobs().catch((error: unknown) => {
       if (!cancelled) {
         notifyError(error, "agent-history-jobs");
@@ -392,7 +429,15 @@ export function useAgentController(): AgentPageProps {
   }, [activeTaskId]);
 
   function setConfigConstraint(path: string, value: unknown): void {
-    setConfigConstraints((current) => setConfigValue(current, path, value));
+    setConfigConstraints((current) => {
+      let next = setConfigValue(current, path, value);
+      if (path === "sft.dataset_path") {
+        for (const [inferredPath, inferredValue] of Object.entries(inferSftSettingsForDatasetPath(value))) {
+          next = setConfigValue(next, inferredPath, inferredValue);
+        }
+      }
+      return next;
+    });
   }
 
   function clearConfigConstraint(path: string): void {
@@ -411,6 +456,7 @@ export function useAgentController(): AgentPageProps {
     experimentRuns,
     goal,
     handleOptimize,
+    historyFilters,
     historyJobs,
     jobName,
     lastSubmittedGoal,
@@ -427,12 +473,15 @@ export function useAgentController(): AgentPageProps {
     selectedHistoryJobId,
     selectExperiment,
     selectHistoryJob,
+    refreshHistoryJobs,
+    refreshLlmResources,
     setConfigConstraint,
     setGoal,
     setJobName,
     setMaxIterations,
     setModelName,
     setObjective,
+    setHistoryFilters,
     workflowStep,
     setWorkflowStep,
     draftPlan,
diff --git a/apps/frontend/src/features/config/compatibility.ts b/apps/frontend/src/features/config/compatibility.ts
new file mode 100644
index 0000000..efb926d
--- /dev/null
+++ b/apps/frontend/src/features/config/compatibility.ts
@@ -0,0 +1,207 @@
+import { getValueByPath, isRecord, type SchemaNode } from "../simulation/utils";
+
+const DATASET_MODEL_COMPATIBILITY: Record<string, string[]> = {
+  MNIST: ["Mclr_Logistic", "LeNet", "DNN"],
+  EMNIST: ["Mclr_Logistic", "LeNet", "DNN"],
+  FEMNIST: ["Mclr_Logistic", "LeNet", "DNN"],
+  "Fashion-MNIST": ["Mclr_Logistic", "LeNet", "DNN"],
+  "CIFAR-10": ["Mclr_Logistic", "FedAvgCNN", "DNN", "ResNet18", "AlexNet", "MobileNet", "GoogleNet"],
+  "CIFAR-100": ["Mclr_Logistic", "FedAvgCNN", "DNN", "ResNet18", "AlexNet", "MobileNet", "GoogleNet"],
+  "AG News": ["TextLogistic", "TextDNN", "TextCNN"],
+  "Sogou News": ["TextLogistic", "TextDNN", "TextCNN"],
+  "Tiny-ImageNet": ["Mclr_Logistic", "FedAvgCNN", "DNN", "ResNet18", "AlexNet", "MobileNet", "GoogleNet"],
+  Country211: ["FedAvgCNN", "DNN", "ResNet18", "ResNet34", "AlexNet", "MobileNet", "GoogleNet"],
+  Flowers102: ["FedAvgCNN", "DNN", "ResNet18", "ResNet34", "AlexNet", "MobileNet", "GoogleNet"],
+  GTSRB: ["FedAvgCNN", "DNN", "ResNet18", "ResNet34", "AlexNet", "MobileNet", "GoogleNet"],
+  Shakespeare: ["CharLSTM"],
+  "Stanford Cars": ["FedAvgCNN", "DNN", "ResNet18", "ResNet34", "AlexNet", "MobileNet", "GoogleNet"],
+  COVIDx: ["FedAvgCNN", "DNN", "ResNet18", "ResNet34", "AlexNet", "MobileNet", "GoogleNet"],
+  Kvasir: ["FedAvgCNN", "DNN", "ResNet18", "ResNet34", "AlexNet", "MobileNet", "GoogleNet"],
+};
+
+const DATASET_DEFAULT_MODELS: Record<string, string> = {
+  MNIST: "LeNet",
+  EMNIST: "LeNet",
+  FEMNIST: "LeNet",
+  "Fashion-MNIST": "LeNet",
+  "CIFAR-10": "FedAvgCNN",
+  "CIFAR-100": "FedAvgCNN",
+  "AG News": "TextDNN",
+  "Sogou News": "TextDNN",
+  "Tiny-ImageNet": "FedAvgCNN",
+  Country211: "MobileNet",
+  Flowers102: "MobileNet",
+  GTSRB: "MobileNet",
+  Shakespeare: "CharLSTM",
+  "Stanford Cars": "MobileNet",
+  COVIDx: "MobileNet",
+  Kvasir: "MobileNet",
+};
+
+const LINEAR_AGGREGATIONS = new Set(["fedavg", "weighted_avg", "simple_avg"]);
+const EQUAL_WEIGHT_AGGREGATIONS = new Set(["fedavg", "simple_avg"]);
+
+export type OptionState = {
+  disabled: boolean;
+  reason?: string;
+};
+
+function boolAt(properties: Record<string, unknown>, path: string): boolean {
+  return getValueByPath(properties, path) === true;
+}
+
+function stringAt(properties: Record<string, unknown>, path: string, fallback = ""): string {
+  const value = getValueByPath(properties, path);
+  return typeof value === "string" ? value : fallback;
+}
+
+export function optionMeta(definition: SchemaNode, option: unknown): Record<string, unknown> {
+  const ui = definition.ui;
+  if (!isRecord(ui)) return {};
+  const options = ui.options;
+  if (!isRecord(options)) return {};
+  const meta = options[String(option)];
+  return isRecord(meta) ? meta : {};
+}
+
+export function optionLabel(definition: SchemaNode, option: unknown): string {
+  const meta = optionMeta(definition, option);
+  return typeof meta.label === "string" && meta.label.trim() ? meta.label : String(option);
+}
+
+export function staticOptionDisabled(definition: SchemaNode, option: unknown): boolean {
+  return optionMeta(definition, option).disabled === true;
+}
+
+export function compatibleModelsForDataset(datasetName: string): string[] {
+  return DATASET_MODEL_COMPATIBILITY[datasetName] ?? [];
+}
+
+export function defaultModelForDataset(datasetName: string): string | null {
+  return DATASET_DEFAULT_MODELS[datasetName] ?? null;
+}
+
+export function isModelCompatibleWithDataset(modelName: unknown, datasetName: string): boolean {
+  if (modelName === "Auto") return true;
+  if (typeof modelName !== "string") return false;
+  const models = compatibleModelsForDataset(datasetName);
+  return models.length === 0 || models.includes(modelName);
+}
+
+export function dynamicOptionState(
+  path: string,
+  option: unknown,
+  properties: Record<string, unknown>,
+): OptionState {
+  const optionText = String(option);
+  const systemMode = stringAt(properties, "system.mode", "simulation");
+  const aggregation = stringAt(properties, "federated.aggregation", "fedavg");
+  const ckksEnabled = boolAt(properties, "privacy.homomorphic_encryption.enable");
+  const dpEnabled = boolAt(properties, "privacy.differential_privacy.enable");
+  const compressionEnabled = boolAt(properties, "compression.sparsification.enable");
+  const secureAggEnabled = boolAt(properties, "privacy.secure_aggregation.enable");
+
+  if (path === "task.type" && optionText === "llm_peft_sft" && systemMode === "distributed") {
+    return {
+      disabled: true,
+      reason: "LLM PEFT is currently supported in simulation mode only.",
+    };
+  }
+
+  if (path === "model.name") {
+    const datasetName = stringAt(properties, "dataset.name", "CIFAR-10");
+    if (!isModelCompatibleWithDataset(optionText, datasetName)) {
+      return {
+        disabled: true,
+        reason: `${optionText} is not compatible with ${datasetName}.`,
+      };
+    }
+  }
+
+  if (path === "federated.aggregation") {
+    if ((ckksEnabled || compressionEnabled) && !LINEAR_AGGREGATIONS.has(optionText)) {
+      return {
+        disabled: true,
+        reason: "CKKS and compression only support linear aggregation.",
+      };
+    }
+    if (secureAggEnabled && !EQUAL_WEIGHT_AGGREGATIONS.has(optionText)) {
+      return {
+        disabled: true,
+        reason: "Secure aggregation masking requires equal-weight aggregation.",
+      };
+    }
+  }
+
+  if (path === "privacy.homomorphic_encryption.method" && optionText !== "ckks") {
+    return { disabled: true, reason: "Only CKKS is currently executable." };
+  }
+
+  if (path === "compression.sparsification.method") {
+    if (ckksEnabled) return { disabled: true, reason: "Turn off CKKS before enabling compression." };
+    if (secureAggEnabled) return { disabled: true, reason: "Turn off secure aggregation before enabling compression." };
+  }
+
+  if (path === "privacy.differential_privacy.enable" && dpEnabled) {
+    return { disabled: false };
+  }
+
+  void aggregation;
+  return { disabled: false };
+}
+
+export function dynamicBooleanState(path: string, value: unknown, properties: Record<string, unknown>): OptionState {
+  if (value === true) return { disabled: false };
+
+  const aggregation = stringAt(properties, "federated.aggregation", "fedavg");
+  const ckksEnabled = boolAt(properties, "privacy.homomorphic_encryption.enable");
+  const compressionEnabled = boolAt(properties, "compression.sparsification.enable");
+  const secureAggEnabled = boolAt(properties, "privacy.secure_aggregation.enable");
+
+  if (path === "privacy.homomorphic_encryption.enable") {
+    if (!LINEAR_AGGREGATIONS.has(aggregation)) {
+      return { disabled: true, reason: "CKKS requires fedavg, weighted_avg, or simple_avg." };
+    }
+    if (compressionEnabled) return { disabled: true, reason: "Turn off compression before enabling CKKS." };
+    if (secureAggEnabled) return { disabled: true, reason: "Turn off secure aggregation before enabling CKKS." };
+  }
+
+  if (path === "compression.sparsification.enable") {
+    if (!LINEAR_AGGREGATIONS.has(aggregation)) {
+      return { disabled: true, reason: "Compression requires fedavg, weighted_avg, or simple_avg." };
+    }
+    if (ckksEnabled) return { disabled: true, reason: "Turn off CKKS before enabling compression." };
+    if (secureAggEnabled) return { disabled: true, reason: "Turn off secure aggregation before enabling compression." };
+  }
+
+  if (path === "privacy.secure_aggregation.enable") {
+    if (!EQUAL_WEIGHT_AGGREGATIONS.has(aggregation)) {
+      return { disabled: true, reason: "Secure aggregation requires fedavg or simple_avg." };
+    }
+    if (ckksEnabled) return { disabled: true, reason: "Turn off CKKS before enabling secure aggregation." };
+    if (compressionEnabled) return { disabled: true, reason: "Turn off compression before enabling secure aggregation." };
+  }
+
+  return { disabled: false };
+}
+
+export function fieldHint(path: string, properties: Record<string, unknown>): string | null {
+  if (path === "model.name") {
+    const datasetName = stringAt(properties, "dataset.name", "CIFAR-10");
+    const models = compatibleModelsForDataset(datasetName);
+    if (models.length === 0) return null;
+    const defaultModel = defaultModelForDataset(datasetName);
+    const defaultText = defaultModel ? ` Default: ${defaultModel}.` : "";
+    return `${datasetName} supports: Auto, ${models.join(", ")}.${defaultText}`;
+  }
+
+  if (path === "federated.aggregation") {
+    const ckksEnabled = boolAt(properties, "privacy.homomorphic_encryption.enable");
+    const compressionEnabled = boolAt(properties, "compression.sparsification.enable");
+    const secureAggEnabled = boolAt(properties, "privacy.secure_aggregation.enable");
+    if (secureAggEnabled) return "Secure aggregation masking allows fedavg or simple_avg.";
+    if (ckksEnabled || compressionEnabled) return "CKKS and compression allow fedavg, weighted_avg, or simple_avg.";
+  }
+
+  return null;
+}
diff --git a/apps/frontend/src/features/config/render-schema-section.tsx b/apps/frontend/src/features/config/render-schema-section.tsx
index f12f556..6e64552 100644
--- a/apps/frontend/src/features/config/render-schema-section.tsx
+++ b/apps/frontend/src/features/config/render-schema-section.tsx
@@ -6,6 +6,15 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from ".
 import { Switch } from "../../components/ui/switch";
 import type { NodeRole } from "../../pages/types";
 import { getValueByPath, isFieldDefinition, isRecord, normalizeListInt, type SchemaNode } from "../simulation/utils";
+import {
+  dynamicBooleanState,
+  dynamicOptionState,
+  fieldHint,
+  isModelCompatibleWithDataset,
+  optionLabel,
+  optionMeta,
+  staticOptionDisabled,
+} from "./compatibility";
 
 function checkDependency(properties: Record<string, unknown>, dependsOn?: string): boolean {
   if (!dependsOn) return true;
@@ -43,6 +52,15 @@ function parseOptionalNumber(value: unknown): number | undefined {
   return undefined;
 }
 
+function textOptions(definition: SchemaNode): string[] {
+  if (!Array.isArray(definition.options)) return [];
+  return definition.options.map((option) => String(option));
+}
+
+function datalistIdForPath(path: string): string {
+  return `schema-options-${path.replace(/[^a-zA-Z0-9_-]/g, "-")}`;
+}
+
 export function renderSchemaSection(
   schemaSection: Record<string, unknown>,
   pathPrefix: string,
@@ -70,17 +88,22 @@ export function renderSchemaSection(
       const value = getValueByPath(properties, fullPath);
       if (definition.type === "bool") {
         const label = labelize(key);
+        const state = dynamicBooleanState(fullPath, value, properties);
         blocks.push(
           <div
             key={fullPath}
-            className="flex items-center justify-between rounded-md border border-border/70 bg-muted/25 px-3 py-2 text-sm"
+            className="space-y-1 rounded-md border border-border/70 bg-muted/25 px-3 py-2 text-sm"
           >
-            <span>{label}</span>
-            <Switch
-              checked={Boolean(value)}
-              onCheckedChange={(checked) => onChangeProperty(fullPath, checked)}
-              aria-label={label}
-            />
+            <div className="flex items-center justify-between">
+              <span>{label}</span>
+              <Switch
+                checked={Boolean(value)}
+                disabled={state.disabled}
+                onCheckedChange={(checked) => onChangeProperty(fullPath, checked)}
+                aria-label={label}
+              />
+            </div>
+            {state.reason && <p className="text-[11px] text-muted-foreground">{state.reason}</p>}
           </div>,
         );
         continue;
@@ -88,6 +111,7 @@ export function renderSchemaSection(
 
       if (definition.type === "select") {
         const options = Array.isArray(definition.options) ? definition.options : [];
+        const hint = fieldHint(fullPath, properties);
         blocks.push(
           <div key={fullPath} className="space-y-1 rounded-md border border-border/70 bg-muted/25 p-2">
             <p className="text-xs text-muted-foreground">{labelize(key)}</p>
@@ -95,20 +119,50 @@ export function renderSchemaSection(
               value={String(value ?? "")}
               onValueChange={(nextValue) => {
                 const matched = options.find((option) => String(option) === nextValue);
-                onChangeProperty(fullPath, matched ?? nextValue);
+                const next = matched ?? nextValue;
+                onChangeProperty(fullPath, next);
+                if (fullPath === "dataset.name") {
+                  const currentModel = getValueByPath(properties, "model.name");
+                  if (!isModelCompatibleWithDataset(currentModel, String(next))) {
+                    onChangeProperty("model.name", "Auto");
+                  }
+                }
               }}
             >
               <SelectTrigger className="font-mono">
                 <SelectValue placeholder="Select option" />
               </SelectTrigger>
               <SelectContent>
-                {options.map((option) => (
-                  <SelectItem key={`${fullPath}-${String(option)}`} value={String(option)} className="font-mono">
-                    {String(option)}
-                  </SelectItem>
-                ))}
+                {options.map((option) => {
+                  const staticDisabled = staticOptionDisabled(definition, option);
+                  const dynamicState = dynamicOptionState(fullPath, option, properties);
+                  const disabled = staticDisabled || dynamicState.disabled;
+                  const meta = optionMeta(definition, option);
+                  const reason = staticDisabled
+                    ? typeof meta.description === "string"
+                      ? meta.description
+                      : "Not executable yet."
+                    : dynamicState.reason;
+                  return (
+                    <SelectItem
+                      key={`${fullPath}-${String(option)}`}
+                      value={String(option)}
+                      disabled={disabled}
+                      className="font-mono"
+                    >
+                      <span className="flex flex-col gap-0.5">
+                        <span className="flex items-center gap-2">
+                          {optionLabel(definition, option)}
+                          {typeof meta.badge === "string" && <span className="text-[10px] text-amber-400">{meta.badge}</span>}
+                        </span>
+                        {reason && <span className="text-[10px] text-muted-foreground">{reason}</span>}
+                      </span>
+                    </SelectItem>
+                  );
+                })}
               </SelectContent>
             </Select>
+            {hint && <p className="text-[11px] text-muted-foreground">{hint}</p>}
           </div>,
         );
         continue;
@@ -154,7 +208,18 @@ export function renderSchemaSection(
       blocks.push(
         <div key={fullPath} className="space-y-1 rounded-md border border-border/70 bg-muted/25 p-2">
           <p className="text-xs text-muted-foreground">{labelize(key)}</p>
-          <Input value={String(value ?? "")} onChange={(event) => onChangeProperty(fullPath, event.target.value)} />
+          <Input
+            list={textOptions(definition).length > 0 ? datalistIdForPath(fullPath) : undefined}
+            value={String(value ?? "")}
+            onChange={(event) => onChangeProperty(fullPath, event.target.value)}
+          />
+          {textOptions(definition).length > 0 && (
+            <datalist id={datalistIdForPath(fullPath)}>
+              {textOptions(definition).map((option) => (
+                <option key={`${fullPath}-${option}`} value={option} />
+              ))}
+            </datalist>
+          )}
         </div>,
       );
       continue;
diff --git a/apps/frontend/src/features/simulation/components/MiniLineChart.tsx b/apps/frontend/src/features/simulation/components/MiniLineChart.tsx
index fbf81b4..e2e85a9 100644
--- a/apps/frontend/src/features/simulation/components/MiniLineChart.tsx
+++ b/apps/frontend/src/features/simulation/components/MiniLineChart.tsx
@@ -7,16 +7,29 @@ type MiniLineChartProps = {
   xValues: number[];
   series: LineSeries[];
   formatter?: (value: number) => string;
+  emptyMessage?: string;
 };
 
-export function MiniLineChart({ title, xValues, series, formatter }: MiniLineChartProps) {
+function isFinitePoint(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function latestFiniteValue(values: Array<number | null | undefined>): number | null {
+  for (let index = values.length - 1; index >= 0; index -= 1) {
+    const value = values[index];
+    if (isFinitePoint(value)) return value;
+  }
+  return null;
+}
+
+export function MiniLineChart({ title, xValues, series, formatter, emptyMessage = "Waiting for training metrics..." }: MiniLineChartProps) {
   const chartWidth = 520;
   const chartHeight = 220;
   const margin = { top: 12, right: 14, bottom: 36, left: 58 };
   const plotWidth = chartWidth - margin.left - margin.right;
   const plotHeight = chartHeight - margin.top - margin.bottom;
   const maxSeriesLength = Math.max(xValues.length, ...series.map((item) => item.values.length));
-  const hasData = maxSeriesLength > 0 && series.some((item) => item.values.length > 0);
+  const hasData = maxSeriesLength > 0 && series.some((item) => item.values.some(isFinitePoint));
   const bounds = getLineSeriesBounds(series);
   const formatValue = formatter ?? ((value: number) => value.toFixed(4));
   const yTickCount = 5;
@@ -41,7 +54,7 @@ export function MiniLineChart({ title, xValues, series, formatter }: MiniLineCha
         <CardTitle className="text-sm">{title}</CardTitle>
       </CardHeader>
       <CardContent className="space-y-2">
-        {!hasData && <p className="text-xs text-muted-foreground">Waiting for training metrics...</p>}
+        {!hasData && <p className="text-xs text-muted-foreground">{emptyMessage}</p>}
         {hasData && (
           <>
             <div className="rounded-md border bg-muted/20 p-2">
@@ -169,6 +182,7 @@ export function MiniLineChart({ title, xValues, series, formatter }: MiniLineCha
                         />
                       )}
                       {item.values.map((value, index) => {
+                        if (!isFinitePoint(value)) return null;
                         const x = maxSeriesLength <= 1 ? margin.left + plotWidth / 2 : margin.left + xStep * index;
                         const normalized = (value - bounds.min) / ySpan;
                         const y = margin.top + (plotHeight - normalized * plotHeight);
@@ -181,12 +195,12 @@ export function MiniLineChart({ title, xValues, series, formatter }: MiniLineCha
             </div>
             <div className="flex flex-wrap items-center gap-2 text-xs">
               {series.map((item) => {
-                const latestValue = item.values[item.values.length - 1];
+                const latestValue = latestFiniteValue(item.values);
                 return (
                   <span key={`legend-${item.key}`} className="inline-flex items-center gap-1.5 rounded-md border bg-muted/20 px-2 py-1">
                     <span className="inline-block h-2 w-2 rounded-full" style={{ backgroundColor: item.color }} />
                     <span className="font-medium">{item.label}</span>
-                    <span className="text-muted-foreground">{latestValue === undefined ? "-" : formatValue(latestValue)}</span>
+                    <span className="text-muted-foreground">{latestValue === null ? "-" : formatValue(latestValue)}</span>
                   </span>
                 );
               })}
diff --git a/apps/frontend/src/features/simulation/llm-metrics.ts b/apps/frontend/src/features/simulation/llm-metrics.ts
new file mode 100644
index 0000000..2a653c5
--- /dev/null
+++ b/apps/frontend/src/features/simulation/llm-metrics.ts
@@ -0,0 +1,116 @@
+import type { LineSeries } from "../../pages/types";
+import type { RunMetrics } from "../../api/runs";
+
+const LLM_COLORS = {
+  trainLoss: "#dc2626",
+  validationLoss: "#f59e0b",
+  perplexity: "#7c3aed",
+  throughput: "#0891b2",
+  adapterSize: "#16a34a",
+};
+
+function numericList(value: unknown): number[] {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => Number(item)).filter((item) => Number.isFinite(item));
+}
+
+function lastFiniteNumber(value: unknown): number | null {
+  const values = numericList(value);
+  return values.length > 0 ? values[values.length - 1] : null;
+}
+
+function lastPositiveNumber(value: unknown): number | null {
+  const values = numericList(value).filter((item) => item > 0);
+  return values.length > 0 ? values[values.length - 1] : null;
+}
+
+function recordOf(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+export function isLlmRunMetrics(metrics: RunMetrics | null | undefined): boolean {
+  if (!metrics) return false;
+  const basic = recordOf(metrics.experiment_info?.basic);
+  const llmResults = recordOf(metrics.llm_results);
+  const llmEvaluation = recordOf(metrics.llm_evaluation);
+  const llmRuntime = recordOf(metrics.llm_runtime);
+  return (
+    basic.task_type === "llm_peft_sft" ||
+    numericList(llmResults.rounds).length > 0 ||
+    Object.keys(llmEvaluation).length > 0 ||
+    Object.keys(llmRuntime).length > 0 ||
+    (metrics.llm_artifacts?.length ?? 0) > 0
+  );
+}
+
+export function llmRounds(metrics: RunMetrics | null | undefined): number[] {
+  if (!metrics) return [];
+  const explicitRounds = numericList(metrics.llm_results?.rounds);
+  if (explicitRounds.length > 0) return explicitRounds;
+  return numericList(metrics.global_results?.rounds);
+}
+
+export function llmMetricSeries(
+  metrics: RunMetrics | null | undefined,
+  key: keyof NonNullable<RunMetrics["llm_results"]>,
+  label: string,
+  color: string,
+): LineSeries[] {
+  if (key === "rounds") return [];
+  return [
+    {
+      key: `llm-${String(key)}`,
+      label,
+      color,
+      values: numericList(metrics?.llm_results?.[key]),
+    },
+  ];
+}
+
+export function llmTrainLossSeries(metrics: RunMetrics | null | undefined): LineSeries[] {
+  return llmMetricSeries(metrics, "train_loss", "Train Loss", LLM_COLORS.trainLoss);
+}
+
+export function llmValidationLossSeries(metrics: RunMetrics | null | undefined): LineSeries[] {
+  return llmMetricSeries(metrics, "validation_loss", "Validation Loss", LLM_COLORS.validationLoss);
+}
+
+export function latestLlmLoss(metrics: RunMetrics | null | undefined): number | null {
+  return lastPositiveNumber(metrics?.llm_results?.validation_loss) ?? lastFiniteNumber(metrics?.llm_results?.train_loss);
+}
+
+export function llmPerplexitySeries(metrics: RunMetrics | null | undefined): LineSeries[] {
+  return llmMetricSeries(metrics, "perplexity", "Perplexity", LLM_COLORS.perplexity);
+}
+
+export function llmThroughputSeries(metrics: RunMetrics | null | undefined): LineSeries[] {
+  return llmMetricSeries(metrics, "token_throughput", "Tokens/s", LLM_COLORS.throughput);
+}
+
+export function llmAdapterSizeSeries(metrics: RunMetrics | null | undefined): LineSeries[] {
+  return llmMetricSeries(metrics, "adapter_size_bytes", "Adapter Size", LLM_COLORS.adapterSize);
+}
+
+export function formatBytes(value: unknown): string {
+  const bytes = Number(value);
+  if (!Number.isFinite(bytes) || bytes < 0) return "-";
+  if (bytes < 1024) return `${bytes.toFixed(0)} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let scaled = bytes / 1024;
+  let unitIndex = 0;
+  while (scaled >= 1024 && unitIndex < units.length - 1) {
+    scaled /= 1024;
+    unitIndex += 1;
+  }
+  return `${scaled.toFixed(scaled >= 10 ? 1 : 2)} ${units[unitIndex]}`;
+}
+
+export function shortHash(value: unknown): string {
+  if (typeof value !== "string" || value.length === 0) return "-";
+  return value.length <= 12 ? value : `${value.slice(0, 12)}...`;
+}
+
+export function selectedClientsText(value: unknown): string {
+  if (!Array.isArray(value)) return "-";
+  return value.map((item) => String(item)).join(", ");
+}
diff --git a/apps/frontend/src/features/simulation/useSimulationController.ts b/apps/frontend/src/features/simulation/useSimulationController.ts
index 298a1be..31e3b48 100644
--- a/apps/frontend/src/features/simulation/useSimulationController.ts
+++ b/apps/frontend/src/features/simulation/useSimulationController.ts
@@ -777,6 +777,7 @@ export function useSimulationController(): SimulationPageProps {
     requestDeleteJob,
     runLogs,
     runLogsRef,
+    runMetrics,
     runRounds,
     runStatusVariant,
     runs,
diff --git a/apps/frontend/src/features/simulation/utils.ts b/apps/frontend/src/features/simulation/utils.ts
index b46756b..ed1036c 100644
--- a/apps/frontend/src/features/simulation/utils.ts
+++ b/apps/frontend/src/features/simulation/utils.ts
@@ -15,6 +15,7 @@ const CLIENT_LAYOUT = {
 };
 
 export const DEFAULT_JOB_CONFIG = {
+  task: { type: "classic_fl" },
   system: { mode: "simulation" as SystemMode },
   dataset: { name: "CIFAR-10", data_dir: "./datasets", distribution: "non_iid", alpha: 0.5 },
   federated: { num_clients: 3, num_rounds: 10, clients_per_round: 3, local_epochs: 5, learning_rate: 0.01 },
@@ -85,6 +86,18 @@ export const EMPTY_RUN_METRICS: RunMetrics = {
     global_loss: [],
     global_accuracy: [],
   },
+  llm_results: {
+    rounds: [],
+    train_loss: [],
+    validation_loss: [],
+    perplexity: [],
+    token_throughput: [],
+    adapter_size_bytes: [],
+  },
+  llm_dataset: {},
+  llm_evaluation: {},
+  llm_runtime: {},
+  llm_artifacts: [],
   client_results: {},
 };
 
@@ -481,7 +494,9 @@ export function topologyFromConfig(
 }
 
 export function getLineSeriesBounds(series: LineSeries[]): { min: number; max: number } {
-  const values = series.flatMap((item) => item.values).filter((value) => Number.isFinite(value));
+  const values = series
+    .flatMap((item) => item.values)
+    .filter((value): value is number => typeof value === "number" && Number.isFinite(value));
   if (values.length === 0) {
     return { min: 0, max: 1 };
   }
@@ -496,7 +511,14 @@ export function getLineSeriesBounds(series: LineSeries[]): { min: number; max: n
   return { min: min - padding, max: max + padding };
 }
 
-export function polylinePoints(values: number[], pointsCount: number, yMin: number, yMax: number, width: number, height: number): string {
+export function polylinePoints(
+  values: Array<number | null | undefined>,
+  pointsCount: number,
+  yMin: number,
+  yMax: number,
+  width: number,
+  height: number,
+): string {
   if (values.length === 0 || pointsCount <= 1) {
     return "";
   }
@@ -506,11 +528,15 @@ export function polylinePoints(values: number[], pointsCount: number, yMin: numb
 
   return values
     .map((value, index) => {
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        return null;
+      }
       const x = xStep * index;
       const normalized = (value - yMin) / ySpan;
       const y = height - normalized * height;
       return `${x.toFixed(2)},${y.toFixed(2)}`;
     })
+    .filter((point): point is string => point !== null)
     .join(" ");
 }
 
@@ -520,13 +546,78 @@ function parseClientOrder(clientName: string): number {
   return Number(match[1]);
 }
 
-export function toClientSeries(metrics: RunMetrics, key: keyof RunMetrics["client_results"][string]): LineSeries[] {
+function numericRoundList(value: unknown): number[] {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => Number(item)).filter((item) => Number.isFinite(item));
+}
+
+function roundFromArtifact(artifact: Record<string, unknown>, fallback: number): number {
+  const round = Number(artifact.round);
+  return Number.isFinite(round) ? round : fallback;
+}
+
+function clientNumberFromName(clientName: string): number | null {
+  const match = clientName.match(/(\d+)$/);
+  return match ? Number(match[1]) : null;
+}
+
+function inferClientRoundsFromArtifacts(metrics: RunMetrics, clientName: string, valueCount: number): number[] {
+  const clientId = clientNumberFromName(clientName);
+  if (clientId === null || !Array.isArray(metrics.llm_artifacts)) return [];
+  const rounds: number[] = [];
+  for (const [index, artifact] of metrics.llm_artifacts.entries()) {
+    if (!artifact || typeof artifact !== "object" || Array.isArray(artifact)) continue;
+    const selectedClients = (artifact as Record<string, unknown>).selected_clients;
+    if (!Array.isArray(selectedClients)) continue;
+    if (selectedClients.map((item) => Number(item)).includes(clientId)) {
+      rounds.push(roundFromArtifact(artifact as Record<string, unknown>, index + 1));
+    }
+    if (rounds.length >= valueCount) break;
+  }
+  return rounds;
+}
+
+function alignValuesToRounds(
+  values: Array<number | null | undefined>,
+  valueRounds: number[],
+  xValues: number[],
+): Array<number | null> {
+  if (values.length === 0) return [];
+  if (valueRounds.length === 0 || xValues.length === 0) {
+    return values.map((value) => (typeof value === "number" && Number.isFinite(value) ? value : null));
+  }
+
+  const byRound = new Map<number, number | null>();
+  values.forEach((value, index) => {
+    const round = valueRounds[index];
+    if (round === undefined) return;
+    byRound.set(round, typeof value === "number" && Number.isFinite(value) ? value : null);
+  });
+  return xValues.map((round) => byRound.get(round) ?? null);
+}
+
+export function toClientSeries(
+  metrics: RunMetrics | null | undefined,
+  key: keyof Omit<RunMetrics["client_results"][string], "rounds">,
+  xValues?: number[],
+): LineSeries[] {
+  if (!metrics?.client_results) return [];
+
+  const llmRounds = numericRoundList(metrics.llm_results?.rounds);
+  const rounds = xValues ?? (llmRounds.length > 0 ? llmRounds : (metrics.global_results?.rounds ?? []));
   return Object.entries(metrics.client_results)
     .sort(([a], [b]) => parseClientOrder(a) - parseClientOrder(b) || a.localeCompare(b))
-    .map(([clientName, values], index) => ({
-      key: `${key}-${clientName}`,
-      label: clientName,
-      color: CLIENT_SERIES_COLORS[index % CLIENT_SERIES_COLORS.length],
-      values: values[key],
-    }));
+    .map(([clientName, values], index) => {
+      const rawValues = values[key] ?? [];
+      const valueRounds = numericRoundList(values.rounds);
+      const inferredRounds = valueRounds.length > 0
+        ? valueRounds
+        : inferClientRoundsFromArtifacts(metrics, clientName, rawValues.length);
+      return {
+        key: `${key}-${clientName}`,
+        label: clientName,
+        color: CLIENT_SERIES_COLORS[index % CLIENT_SERIES_COLORS.length],
+        values: alignValuesToRounds(rawValues, inferredRounds, rounds),
+      };
+    });
 }
diff --git a/apps/frontend/src/pages/AgentPage.tsx b/apps/frontend/src/pages/AgentPage.tsx
index 784f8a2..ec37529 100644
--- a/apps/frontend/src/pages/AgentPage.tsx
+++ b/apps/frontend/src/pages/AgentPage.tsx
@@ -73,7 +73,7 @@ export function AgentPage(props: AgentPageProps) {
         {props.workflowStep === "home" && <AgentExperimentStudio {...props} />}
         {props.workflowStep === "preview" && <AgentPlanPreview {...props} />}
         {props.workflowStep === "running" && <AgentRunDashboard {...props} />}
-        {/* {props.workflowStep === "results" && <AgentResultsCompare {...props} />} */}
+        {props.workflowStep === "results" && <AgentResultsCompare {...props} />}
       </main>
     </div>
   );
diff --git a/apps/frontend/src/pages/simulation/SimulationRunsTab.tsx b/apps/frontend/src/pages/simulation/SimulationRunsTab.tsx
index 8732556..aad202d 100644
--- a/apps/frontend/src/pages/simulation/SimulationRunsTab.tsx
+++ b/apps/frontend/src/pages/simulation/SimulationRunsTab.tsx
@@ -1,4 +1,4 @@
-import { BarChart3, FileText, Play, RefreshCcw, Square, TerminalSquare, Trash2 } from "lucide-react";
+import { BarChart3, FileText, GitBranch, Play, RefreshCcw, Square, TerminalSquare, Trash2 } from "lucide-react";
 
 import {
   AlertDialog,
@@ -15,6 +15,18 @@ import { Badge } from "../../components/ui/badge";
 import { Button } from "../../components/ui/button";
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "../../components/ui/card";
 import { Separator } from "../../components/ui/separator";
+import {
+  formatBytes,
+  isLlmRunMetrics,
+  llmAdapterSizeSeries,
+  llmPerplexitySeries,
+  llmRounds,
+  llmThroughputSeries,
+  llmTrainLossSeries,
+  llmValidationLossSeries,
+  selectedClientsText,
+  shortHash,
+} from "../../features/simulation/llm-metrics";
 import { fmt } from "../../lib/time";
 import type { Run, RunLog, SimulationPageProps } from "../types";
 
@@ -41,6 +53,7 @@ export function SimulationRunsTab(props: SimulationPageProps) {
     notifyError,
     runLogs,
     runLogsRef,
+    runMetrics,
     runRounds,
     runStatusVariant,
     runs,
@@ -51,6 +64,12 @@ export function SimulationRunsTab(props: SimulationPageProps) {
     toDisplayText,
     toNumber,
   } = props;
+  const isLlmRun = isLlmRunMetrics(runMetrics);
+  const llmMetricRounds = llmRounds(runMetrics);
+  const llmDataset = runMetrics.llm_dataset ?? {};
+  const llmEvaluation = runMetrics.llm_evaluation ?? {};
+  const llmRuntime = runMetrics.llm_runtime ?? {};
+  const llmArtifacts = runMetrics.llm_artifacts ?? [];
 
   return (
     <div className="grid min-h-[calc(100vh-180px)] gap-4 xl:grid-cols-[330px_minmax(0,1fr)]">
@@ -224,28 +243,54 @@ export function SimulationRunsTab(props: SimulationPageProps) {
                   Experiment Context
                 </p>
                 <div className="grid gap-3 xl:grid-cols-2">
-                  <Card className="border-blue-200/60 bg-blue-50/40 dark:border-blue-900/40 dark:bg-blue-950/20">
-                    <CardHeader className="pb-2">
-                      <CardTitle className="text-sm">Basic Context</CardTitle>
-                    </CardHeader>
-                    <CardContent className="space-y-2 text-sm">
-                      <div>
-                        <p className="text-xs text-muted-foreground">Dataset</p>
-                        <p>{toDisplayText(experimentBasic.dataset_name)}</p>
-                      </div>
-                      <div>
-                        <p className="text-xs text-muted-foreground">Distribution</p>
-                        <p>
-                          {toDisplayText(experimentBasic.distribution)}
-                          {toNumber(experimentBasic.alpha) !== null ? ` (alpha=${toNumber(experimentBasic.alpha)})` : ""}
-                        </p>
-                      </div>
-                      <div>
-                        <p className="text-xs text-muted-foreground">Model</p>
-                        <p>{toDisplayText(experimentBasic.model_name)}</p>
-                      </div>
-                    </CardContent>
-                  </Card>
+                  {!isLlmRun && (
+                    <Card className="border-blue-200/60 bg-blue-50/40 dark:border-blue-900/40 dark:bg-blue-950/20">
+                      <CardHeader className="pb-2">
+                        <CardTitle className="text-sm">Basic Context</CardTitle>
+                      </CardHeader>
+                      <CardContent className="space-y-2 text-sm">
+                        <div>
+                          <p className="text-xs text-muted-foreground">Dataset</p>
+                          <p>{toDisplayText(experimentBasic.dataset_name)}</p>
+                        </div>
+                        <div>
+                          <p className="text-xs text-muted-foreground">Distribution</p>
+                          <p>
+                            {toDisplayText(experimentBasic.distribution)}
+                            {toNumber(experimentBasic.alpha) !== null ? ` (alpha=${toNumber(experimentBasic.alpha)})` : ""}
+                          </p>
+                        </div>
+                        <div>
+                          <p className="text-xs text-muted-foreground">Model</p>
+                          <p>{toDisplayText(experimentBasic.model_name)}</p>
+                        </div>
+                      </CardContent>
+                    </Card>
+                  )}
+
+                  {isLlmRun && (
+                    <Card className="border-blue-200/60 bg-blue-50/40 dark:border-blue-900/40 dark:bg-blue-950/20">
+                      <CardHeader className="pb-2">
+                        <CardTitle className="text-sm">LLM Context</CardTitle>
+                      </CardHeader>
+                      <CardContent className="space-y-2 text-sm">
+                        <div>
+                          <p className="text-xs text-muted-foreground">Base Model</p>
+                          <p className="break-all">{toDisplayText(experimentBasic.base_model)}</p>
+                        </div>
+                        <div>
+                          <p className="text-xs text-muted-foreground">SFT / PEFT</p>
+                          <p>
+                            {toDisplayText(experimentBasic.sft_format)} / {toDisplayText(experimentBasic.peft_method)}
+                          </p>
+                        </div>
+                        <div>
+                          <p className="text-xs text-muted-foreground">Runtime</p>
+                          <p>{toDisplayText(llmRuntime.status)}</p>
+                        </div>
+                      </CardContent>
+                    </Card>
+                  )}
 
                   <Card className="border-indigo-200/60 bg-indigo-50/40 dark:border-indigo-900/40 dark:bg-indigo-950/20">
                     <CardHeader className="pb-2">
@@ -275,7 +320,8 @@ export function SimulationRunsTab(props: SimulationPageProps) {
                     </CardContent>
                   </Card>
 
-                  <Card className="border-emerald-200/60 bg-emerald-50/40 dark:border-emerald-900/40 dark:bg-emerald-950/20">
+                  {!isLlmRun && (
+                    <Card className="border-emerald-200/60 bg-emerald-50/40 dark:border-emerald-900/40 dark:bg-emerald-950/20">
                     <CardHeader className="pb-2">
                       <CardTitle className="text-sm">Security</CardTitle>
                     </CardHeader>
@@ -294,6 +340,53 @@ export function SimulationRunsTab(props: SimulationPageProps) {
                       </div>
                     </CardContent>
                   </Card>
+                  )}
+
+                  {isLlmRun && (
+                    <Card className="border-cyan-200/60 bg-cyan-50/40 dark:border-cyan-900/40 dark:bg-cyan-950/20">
+                      <CardHeader className="pb-2">
+                        <CardTitle className="text-sm">SFT Dataset</CardTitle>
+                      </CardHeader>
+                      <CardContent className="space-y-2 text-sm">
+                        <div>
+                          <p className="text-xs text-muted-foreground">Records</p>
+                          <p>{toDisplayText(llmDataset.num_records)}</p>
+                        </div>
+                        <div>
+                          <p className="text-xs text-muted-foreground">Client Split</p>
+                          <p className="break-all">
+                            {Array.isArray(llmDataset.client_record_counts) ? llmDataset.client_record_counts.join(", ") : "-"}
+                          </p>
+                        </div>
+                        <div>
+                          <p className="text-xs text-muted-foreground">Prompt Template</p>
+                          <p>{toDisplayText(llmDataset.prompt_template)}</p>
+                        </div>
+                      </CardContent>
+                    </Card>
+                  )}
+
+                  {isLlmRun && (
+                    <Card className="border-amber-200/60 bg-amber-50/40 dark:border-amber-900/40 dark:bg-amber-950/20">
+                      <CardHeader className="pb-2">
+                        <CardTitle className="text-sm">Evaluation</CardTitle>
+                      </CardHeader>
+                      <CardContent className="space-y-2 text-sm">
+                        <div>
+                          <p className="text-xs text-muted-foreground">Status</p>
+                          <p>{Boolean(llmEvaluation.enabled) ? "Enabled" : "Disabled"}</p>
+                        </div>
+                        <div>
+                          <p className="text-xs text-muted-foreground">Validation Records</p>
+                          <p>{toDisplayText(llmEvaluation.num_records)}</p>
+                        </div>
+                        <div>
+                          <p className="text-xs text-muted-foreground">Last Validation Loss</p>
+                          <p>{toDisplayText(llmEvaluation.last_validation_loss)}</p>
+                        </div>
+                      </CardContent>
+                    </Card>
+                  )}
                 </div>
               </div>
 
@@ -321,47 +414,138 @@ export function SimulationRunsTab(props: SimulationPageProps) {
               <div className="space-y-2">
                 <p className="flex items-center gap-2 text-xs text-muted-foreground">
                   <BarChart3 className="h-4 w-4" />
-                  Training Curves
+                  {isLlmRun ? "LLM Training Curves" : "Training Curves"}
                 </p>
-                <div className="grid gap-3 xl:grid-cols-2">
-                  <MiniLineChart
-                    title="Global Accuracy"
-                    xValues={runRounds}
-                    series={globalAccuracySeries}
-                    formatter={(value: number) => `${(value * 100).toFixed(2)}%`}
-                  />
-                  <MiniLineChart
-                    title="Global Loss"
-                    xValues={runRounds}
-                    series={globalLossSeries}
-                    formatter={(value: number) => value.toFixed(4)}
-                  />
-                  <MiniLineChart
-                    title="Client Train Acc"
-                    xValues={runRounds}
-                    series={clientTrainAccSeries}
-                    formatter={(value: number) => `${(value * 100).toFixed(2)}%`}
-                  />
-                  <MiniLineChart
-                    title="Client Train Loss"
-                    xValues={runRounds}
-                    series={clientTrainLossSeries}
-                    formatter={(value: number) => value.toFixed(4)}
-                  />
-                  <MiniLineChart
-                    title="Client Test Acc"
-                    xValues={runRounds}
-                    series={clientTestAccSeries}
-                    formatter={(value: number) => `${(value * 100).toFixed(2)}%`}
-                  />
-                  <MiniLineChart
-                    title="Client Test Loss"
-                    xValues={runRounds}
-                    series={clientTestLossSeries}
-                    formatter={(value: number) => value.toFixed(4)}
-                  />
-                </div>
+                {!isLlmRun && (
+                  <div className="grid gap-3 xl:grid-cols-2">
+                    <MiniLineChart
+                      title="Global Accuracy"
+                      xValues={runRounds}
+                      series={globalAccuracySeries}
+                      formatter={(value: number) => `${(value * 100).toFixed(2)}%`}
+                    />
+                    <MiniLineChart
+                      title="Global Loss"
+                      xValues={runRounds}
+                      series={globalLossSeries}
+                      formatter={(value: number) => value.toFixed(4)}
+                    />
+                    <MiniLineChart
+                      title="Client Train Acc"
+                      xValues={runRounds}
+                      series={clientTrainAccSeries}
+                      formatter={(value: number) => `${(value * 100).toFixed(2)}%`}
+                    />
+                    <MiniLineChart
+                      title="Client Train Loss"
+                      xValues={runRounds}
+                      series={clientTrainLossSeries}
+                      formatter={(value: number) => value.toFixed(4)}
+                    />
+                    <MiniLineChart
+                      title="Client Test Acc"
+                      xValues={runRounds}
+                      series={clientTestAccSeries}
+                      formatter={(value: number) => `${(value * 100).toFixed(2)}%`}
+                    />
+                    <MiniLineChart
+                      title="Client Test Loss"
+                      xValues={runRounds}
+                      series={clientTestLossSeries}
+                      formatter={(value: number) => value.toFixed(4)}
+                    />
+                  </div>
+                )}
+                {isLlmRun && (
+                  <div className="grid gap-3 xl:grid-cols-2">
+                    <MiniLineChart
+                      title="LLM Train Loss"
+                      xValues={llmMetricRounds}
+                      series={llmTrainLossSeries(runMetrics)}
+                      formatter={(value: number) => value.toFixed(4)}
+                    />
+                    <MiniLineChart
+                      title="LLM Validation Loss"
+                      xValues={llmMetricRounds}
+                      series={llmValidationLossSeries(runMetrics)}
+                      formatter={(value: number) => value.toFixed(4)}
+                      emptyMessage="No validation data available."
+                    />
+                    <MiniLineChart
+                      title="Perplexity"
+                      xValues={llmMetricRounds}
+                      series={llmPerplexitySeries(runMetrics)}
+                      formatter={(value: number) => value.toFixed(2)}
+                    />
+                    <MiniLineChart
+                      title="Token Throughput"
+                      xValues={llmMetricRounds}
+                      series={llmThroughputSeries(runMetrics)}
+                      formatter={(value: number) => `${value.toFixed(1)} tok/s`}
+                    />
+                    <MiniLineChart
+                      title="Adapter Size"
+                      xValues={llmMetricRounds}
+                      series={llmAdapterSizeSeries(runMetrics)}
+                      formatter={(value: number) => formatBytes(value)}
+                    />
+                    <MiniLineChart
+                      title="Client Train Loss"
+                      xValues={llmMetricRounds}
+                      series={clientTrainLossSeries}
+                      formatter={(value: number) => value.toFixed(4)}
+                    />
+                  </div>
+                )}
               </div>
+
+              {isLlmRun && (
+                <div className="space-y-2">
+                  <p className="flex items-center gap-2 text-xs text-muted-foreground">
+                    <GitBranch className="h-4 w-4" />
+                    Adapter Lineage
+                  </p>
+                  <div className="overflow-auto rounded-md border">
+                    <table className="w-full min-w-[720px] text-left text-xs">
+                      <thead className="border-b bg-muted/40 text-muted-foreground">
+                        <tr>
+                          <th className="px-3 py-2 font-medium">Round</th>
+                          <th className="px-3 py-2 font-medium">Selected Clients</th>
+                          <th className="px-3 py-2 font-medium">Size</th>
+                          <th className="px-3 py-2 font-medium">SHA-256</th>
+                          <th className="px-3 py-2 font-medium">Parent</th>
+                          <th className="px-3 py-2 font-medium">Path</th>
+                        </tr>
+                      </thead>
+                      <tbody>
+                        {llmArtifacts.map((artifact, index) => (
+                          <tr key={`${artifact.path ?? index}`} className="border-b last:border-none">
+                            <td className="px-3 py-2 font-mono">{toDisplayText(artifact.round)}</td>
+                            <td className="px-3 py-2 font-mono">{selectedClientsText(artifact.selected_clients)}</td>
+                            <td className="px-3 py-2 font-mono">{formatBytes(artifact.size_bytes)}</td>
+                            <td className="px-3 py-2 font-mono" title={String(artifact.sha256 ?? "")}>
+                              {shortHash(artifact.sha256)}
+                            </td>
+                            <td className="px-3 py-2 font-mono" title={String(artifact.parent_sha256 ?? "")}>
+                              {shortHash(artifact.parent_sha256)}
+                            </td>
+                            <td className="max-w-[260px] truncate px-3 py-2 font-mono" title={String(artifact.path ?? "")}>
+                              {toDisplayText(artifact.path)}
+                            </td>
+                          </tr>
+                        ))}
+                        {llmArtifacts.length === 0 && (
+                          <tr>
+                            <td colSpan={6} className="px-3 py-6 text-center text-muted-foreground">
+                              No adapter artifacts recorded yet.
+                            </td>
+                          </tr>
+                        )}
+                      </tbody>
+                    </table>
+                  </div>
+                </div>
+              )}
             </>
           )}
         </CardContent>
diff --git a/apps/frontend/src/pages/types.ts b/apps/frontend/src/pages/types.ts
index dcc0038..f32ef8c 100644
--- a/apps/frontend/src/pages/types.ts
+++ b/apps/frontend/src/pages/types.ts
@@ -10,6 +10,7 @@ import type {
 import type { DistributedClient, DistributedJob, DistributedSession, DistributedSessionProgress } from "../api/distributed";
 import type {
   AgentExperimentResponse,
+  AgentHistoryFilters,
   AgentOptimizationJobSummary,
   AgentOptimizeProgressResponse,
   AgentOptimizeResponse,
@@ -58,7 +59,7 @@ export type LineSeries = {
   key: string;
   label: string;
   color: string;
-  values: number[];
+  values: Array<number | null | undefined>;
 };
 
 export type MiniLineChartProps = {
@@ -66,6 +67,7 @@ export type MiniLineChartProps = {
   xValues: number[];
   series: LineSeries[];
   formatter?: (value: number) => string;
+  emptyMessage?: string;
 };
 
 export type SimulationPageProps = {
@@ -134,6 +136,7 @@ export type SimulationPageProps = {
   requestDeleteJob: (job: Job) => void;
   runLogs: RunLog[];
   runLogsRef: RefObject<HTMLDivElement | null>;
+  runMetrics: RunMetrics;
   runRounds: number[];
   runStatusVariant: Record<string, BadgeVariant>;
   runs: Run[];
@@ -241,6 +244,7 @@ export type AgentPageProps = {
   experimentRuns: AgentRunResponse[];
   goal: string;
   handleOptimize: () => Promise<void>;
+  historyFilters: AgentHistoryFilters;
   historyJobs: AgentOptimizationJobSummary[];
   jobName: string;
   lastSubmittedGoal: string | null;
@@ -257,6 +261,8 @@ export type AgentPageProps = {
   selectedHistoryJobId: number | null;
   selectExperiment: (experimentId: number) => Promise<void>;
   selectHistoryJob: (optimizationJobId: number) => Promise<void>;
+  refreshHistoryJobs: (filters?: AgentHistoryFilters) => Promise<void>;
+  refreshLlmResources: () => Promise<void>;
   setConfigConstraint: (path: string, value: unknown) => void;
   clearConfigConstraint: (path: string) => void;
   setGoal: Dispatch<SetStateAction<string>>;
@@ -264,6 +270,7 @@ export type AgentPageProps = {
   setMaxIterations: Dispatch<SetStateAction<number>>;
   setModelName: Dispatch<SetStateAction<string>>;
   setObjective: Dispatch<SetStateAction<AgentOptimizationObjective>>;
+  setHistoryFilters: Dispatch<SetStateAction<AgentHistoryFilters>>;
   workflowStep: AgentWorkflowStep;
   setWorkflowStep: Dispatch<SetStateAction<AgentWorkflowStep>>;
   draftPlan: AgentPlanDraft | null;
diff --git a/apps/frontend/tsconfig.tsbuildinfo b/apps/frontend/tsconfig.tsbuildinfo
index 196ff97..91bf920 100644
--- a/apps/frontend/tsconfig.tsbuildinfo
+++ b/apps/frontend/tsconfig.tsbuildinfo
@@ -1 +1 @@
-{"root":["./src/App.tsx","./src/main.tsx","./src/api/agent.ts","./src/api/client.ts","./src/api/distributed.ts","./src/api/error.ts","./src/api/jobs.ts","./src/api/openapi.d.ts","./src/api/runs.ts","./src/components/ui/alert-dialog.tsx","./src/components/ui/badge.tsx","./src/components/ui/button.tsx","./src/components/ui/card.tsx","./src/components/ui/dropdown-menu.tsx","./src/components/ui/input.tsx","./src/components/ui/number-stepper.tsx","./src/components/ui/select.tsx","./src/components/ui/separator.tsx","./src/components/ui/sonner.tsx","./src/components/ui/switch.tsx","./src/components/ui/tabs.tsx","./src/components/ui/textarea.tsx","./src/features/agent/useAgentController.ts","./src/features/config/SchemaConfigDialog.tsx","./src/features/config/render-schema-section.tsx","./src/features/distributed/useDistributedController.ts","./src/features/simulation/useSimulationController.ts","./src/features/simulation/utils.ts","./src/features/simulation/components/MiniLineChart.tsx","./src/lib/time.ts","./src/lib/utils.ts","./src/pages/AgentPage.tsx","./src/pages/DistributedPage.tsx","./src/pages/SimulationPage.tsx","./src/pages/types.ts","./src/pages/distributed/DistributedClientPanel.tsx","./src/pages/distributed/DistributedServerPanel.tsx","./src/pages/simulation/SimulationJobsTab.tsx","./src/pages/simulation/SimulationRunsTab.tsx"],"version":"5.9.3"}
\ No newline at end of file
+{"root":["./src/app.tsx","./src/main.tsx","./src/api/agent.ts","./src/api/client.ts","./src/api/distributed.ts","./src/api/error.ts","./src/api/jobs.ts","./src/api/openapi.d.ts","./src/api/runs.ts","./src/components/ui/alert-dialog.tsx","./src/components/ui/badge.tsx","./src/components/ui/button.tsx","./src/components/ui/card.tsx","./src/components/ui/dropdown-menu.tsx","./src/components/ui/input.tsx","./src/components/ui/number-stepper.tsx","./src/components/ui/select.tsx","./src/components/ui/separator.tsx","./src/components/ui/sonner.tsx","./src/components/ui/switch.tsx","./src/components/ui/tabs.tsx","./src/components/ui/textarea.tsx","./src/features/agent/schema.ts","./src/features/agent/useagentcontroller.ts","./src/features/agent/components/agentexperimentstudio.tsx","./src/features/agent/components/agentplanpreview.tsx","./src/features/agent/components/agentresultscompare.tsx","./src/features/agent/components/agentrundashboard.tsx","./src/features/config/schemaconfigdialog.tsx","./src/features/config/compatibility.ts","./src/features/config/render-schema-section.tsx","./src/features/distributed/usedistributedcontroller.ts","./src/features/simulation/llm-metrics.ts","./src/features/simulation/usesimulationcontroller.ts","./src/features/simulation/utils.ts","./src/features/simulation/components/minilinechart.tsx","./src/features/simulation/components/miniscatterchart.tsx","./src/lib/time.ts","./src/lib/utils.ts","./src/pages/agentpage.tsx","./src/pages/distributedpage.tsx","./src/pages/simulationpage.tsx","./src/pages/types.ts","./src/pages/distributed/distributedclientpanel.tsx","./src/pages/distributed/distributedserverpanel.tsx","./src/pages/simulation/simulationjobstab.tsx","./src/pages/simulation/simulationrunstab.tsx"],"version":"5.9.3"}
\ No newline at end of file
diff --git a/config_schema.yaml b/config_schema.yaml
index 4beefb1..fb487b3 100644
--- a/config_schema.yaml
+++ b/config_schema.yaml
@@ -1,11 +1,35 @@
+task:
+  role: "server"
+  ui:
+    label: "Task"
+    group: "Core"
+  type:
+    type: "select"
+    options: ["classic_fl", "llm_peft_sft"]
+    default: "classic_fl"
+    ui:
+      label: "Training route"
+      featured: true
+      group: "Core"
+      prompt_hint: "Choose the runtime family for this experiment."
+      options:
+        classic_fl:
+          label: "Classic FL"
+          description: "Executable runtime for the current CNN/ResNet/TextCNN-style federated experiments."
+        llm_peft_sft:
+          label: "LLM PEFT SFT"
+          badge: "simulation"
+          description: "Executable simulation route for federated LoRA/PEFT supervised fine-tuning."
+
 dataset:
   role: "server"
+  depends_on: "task.type == classic_fl"
   ui:
     label: "Dataset"
     group: "Data"
   name:
     type: "select"
-    options: ["CIFAR-10", "CIFAR-100", "MNIST", "Fashion-MNIST"]
+    options: ["MNIST", "EMNIST", "FEMNIST", "Fashion-MNIST", "CIFAR-10", "CIFAR-100", "AG News", "Sogou News", "Tiny-ImageNet", "Country211", "Flowers102", "GTSRB", "Shakespeare", "Stanford Cars", "COVIDx", "Kvasir"]
     default: "CIFAR-10"
     ui:
       label: "Dataset"
@@ -50,13 +74,14 @@ dataset:
 
 model:
   role: "server"
+  depends_on: "task.type == classic_fl"
   ui:
     label: "Model"
     group: "Model"
   name:
     type: "select"
-    options: ["CNN", "LeNet", "ResNet"]
-    default: "CNN"
+    options: ["Auto", "Mclr_Logistic", "LeNet", "DNN", "FedAvgCNN", "ResNet18", "ResNet34", "ResNet50", "AlexNet", "MobileNet", "GoogleNet", "TextLogistic", "TextDNN", "TextCNN", "CharLSTM"]
+    default: "Auto"
     ui:
       label: "Model"
       featured: true
@@ -64,7 +89,7 @@ model:
       prompt_hint: "Neural network architecture for every client."
   input_shape:
     type: "list_int"
-    default: [32, 32, 3]
+    default: [3, 32, 32]
     ui:
       label: "Input shape"
   num_classes:
@@ -73,6 +98,245 @@ model:
     ui:
       label: "Number of classes"
 
+llm:
+  role: "server"
+  depends_on: "task.type == llm_peft_sft"
+  ui:
+    label: "LLM"
+    group: "LLM PEFT"
+  base_model:
+    type: "text"
+    options: []
+    default: ""
+    ui:
+      label: "Base model"
+      featured: true
+      group: "LLM PEFT"
+      prompt_hint: "Hugging Face model id or a local model directory under ./models/llm."
+      empty_message: "No local models found"
+  tokenizer:
+    type: "text"
+    default: "auto"
+    ui:
+      label: "Tokenizer"
+      prompt_hint: "Use 'auto' to load the tokenizer from the base model."
+  max_seq_length:
+    type: "number"
+    min: 128
+    max: 8192
+    default: 1024
+    ui:
+      label: "Max sequence length"
+      featured: true
+      group: "LLM PEFT"
+  precision:
+    type: "select"
+    options: ["fp32", "fp16", "bf16"]
+    default: "bf16"
+    ui:
+      label: "Precision"
+      options:
+        fp32:
+          label: "FP32"
+        fp16:
+          label: "FP16"
+        bf16:
+          label: "BF16"
+
+sft:
+  role: "server"
+  depends_on: "task.type == llm_peft_sft"
+  ui:
+    label: "SFT Dataset"
+    group: "LLM PEFT"
+  dataset_path:
+    type: "text"
+    options: []
+    default: ""
+    ui:
+      label: "Dataset path"
+      featured: true
+      group: "LLM PEFT"
+      prompt_hint: "Training JSONL file, standalone Parquet file, or dataset directory under ./datasets/llm."
+      empty_message: "No training datasets found"
+  file_format:
+    type: "select"
+    options: ["auto", "jsonl", "parquet"]
+    default: "auto"
+    hidden: true
+    ui:
+      label: "File format"
+      group: "LLM PEFT"
+      options:
+        auto:
+          label: "Auto"
+        jsonl:
+          label: "JSONL"
+        parquet:
+          label: "Parquet"
+  format:
+    type: "select"
+    options: ["prompt_completion", "messages", "alpaca"]
+    default: "prompt_completion"
+    hidden: true
+    ui:
+      label: "Dataset format"
+      group: "LLM PEFT"
+      options:
+        prompt_completion:
+          label: "Prompt/Completion"
+        messages:
+          label: "Messages"
+        alpaca:
+          label: "Alpaca"
+  validation_split:
+    type: "number"
+    default: 0.0
+    min: 0
+    max: 0.5
+    step: 0.01
+    ui:
+      label: "Validation split"
+      group: "LLM PEFT"
+  prompt_template:
+    type: "select"
+    options: ["plain", "chatml"]
+    default: "plain"
+    ui:
+      label: "Prompt template"
+  per_device_train_batch_size:
+    type: "number"
+    min: 1
+    max: 128
+    default: 1
+    ui:
+      label: "Batch size"
+      featured: true
+      group: "LLM PEFT"
+      prompt_hint: "Per-device SFT batch size for each federated client."
+  gradient_accumulation_steps:
+    type: "number"
+    min: 1
+    max: 128
+    default: 1
+    ui:
+      label: "Gradient accumulation"
+      featured: true
+      group: "LLM PEFT"
+
+peft:
+  role: "server"
+  depends_on: "task.type == llm_peft_sft"
+  ui:
+    label: "PEFT Adapter"
+    group: "LLM PEFT"
+  method:
+    type: "select"
+    options: ["lora"]
+    default: "lora"
+    ui:
+      label: "PEFT method"
+  rank:
+    type: "number"
+    min: 1
+    max: 256
+    default: 8
+    ui:
+      label: "LoRA rank"
+      featured: true
+      group: "LLM PEFT"
+  alpha:
+    type: "number"
+    min: 1
+    max: 512
+    default: 16
+    ui:
+      label: "LoRA alpha"
+      featured: true
+      group: "LLM PEFT"
+  dropout:
+    type: "number"
+    min: 0
+    max: 1
+    step: 0.01
+    default: 0.05
+    ui:
+      label: "LoRA dropout"
+  target_modules:
+    type: "text"
+    default: "q_proj,v_proj"
+    ui:
+      label: "Target modules"
+      prompt_hint: "Comma-separated module names for LoRA injection."
+  resume_adapter_path:
+    type: "text"
+    default: ""
+    ui:
+      label: "Resume adapter path"
+      prompt_hint: "Optional path to a saved global adapter artifact for warm-starting this run."
+  quantization:
+    type: "select"
+    options: ["none", "int8", "nf4_4bit"]
+    default: "none"
+    ui:
+      label: "Quantization"
+      options:
+        none:
+          label: "None"
+        int8:
+          label: "Int8"
+          badge: "planned"
+          disabled: true
+          description: "Reserved for the QLoRA runtime milestone."
+        nf4_4bit:
+          label: "NF4 4-bit"
+          badge: "planned"
+          disabled: true
+          description: "Reserved for the QLoRA runtime milestone."
+
+evaluation:
+  role: "server"
+  depends_on: "task.type == llm_peft_sft"
+  ui:
+    label: "LLM Evaluation"
+    group: "LLM PEFT"
+  enable:
+    type: "bool"
+    default: false
+    ui:
+      label: "Enable evaluation"
+      featured: true
+      group: "LLM PEFT"
+      prompt_hint: "Run validation loss/perplexity after each global adapter aggregation round."
+  dataset_path:
+    type: "text"
+    options: []
+    default: ""
+    depends_on: "evaluation.enable == true"
+    ui:
+      label: "Validation dataset"
+      featured: true
+      group: "LLM PEFT"
+      prompt_hint: "Validation JSONL file, standalone Parquet file, or dataset directory under ./datasets/llm."
+      empty_message: "No evaluation datasets found"
+  max_samples:
+    type: "number"
+    min: 1
+    default: 128
+    depends_on: "evaluation.enable == true"
+    ui:
+      label: "Eval max samples"
+      group: "LLM PEFT"
+  batch_size:
+    type: "number"
+    min: 1
+    max: 128
+    default: 1
+    depends_on: "evaluation.enable == true"
+    ui:
+      label: "Eval batch size"
+      group: "LLM PEFT"
+
 federated:
   role: "server"
   ui:
@@ -125,7 +389,7 @@ federated:
       prompt_hint: "Optimizer learning rate for local training."
   aggregation:
     type: "select"
-    options: ["fedavg", "fedprox", "scaffold"]
+    options: ["fedavg", "weighted_avg", "simple_avg", "fedprox", "scaffold"]
     default: "fedavg"
     ui:
       label: "Aggregation"
@@ -136,6 +400,12 @@ federated:
         fedavg:
           label: "FedAvg"
           description: "Executable default aggregation strategy."
+        weighted_avg:
+          label: "Weighted Avg"
+          description: "Executable sample-weighted averaging strategy."
+        simple_avg:
+          label: "Simple Avg"
+          description: "Executable unweighted averaging strategy."
         fedprox:
           label: "FedProx"
           badge: "experimental"
@@ -156,6 +426,7 @@ federated:
 
 compression:
   role: "server"
+  depends_on: "task.type == classic_fl"
   ui:
     label: "Compression"
     group: "Advanced"
@@ -164,8 +435,32 @@ compression:
       type: "bool"
       default: false
       ui:
-        label: "Enable sparsification"
+        label: "Enable compression"
+        group: "Advanced"
+    method:
+      type: "select"
+      options: ["global_topk", "random_k", "threshold", "sign", "quant_int8"]
+      default: "global_topk"
+      depends_on: "compression.sparsification.enable == true"
+      ui:
+        label: "Compression method"
         group: "Advanced"
+        options:
+          global_topk:
+            label: "Global Top-K"
+            description: "Keep the largest update values globally."
+          random_k:
+            label: "Random-K"
+            description: "Keep a random subset of update values."
+          threshold:
+            label: "Threshold"
+            description: "Drop update values below an absolute threshold."
+          sign:
+            label: "Sign"
+            description: "Send sign-only updates scaled by mean magnitude."
+          quant_int8:
+            label: "Int8 Quantization"
+            description: "Quantize updates to int8 and dequantize before aggregation."
     ratio:
       type: "number"
       default: 0.5
@@ -173,11 +468,21 @@ compression:
       max: 1.0
       depends_on: "compression.sparsification.enable == true"
       ui:
-        label: "Top-K ratio"
+        label: "Keep ratio"
+        group: "Advanced"
+    threshold:
+      type: "number"
+      default: 0.001
+      min: 0
+      step: 0.0001
+      depends_on: "compression.sparsification.enable == true"
+      ui:
+        label: "Threshold"
         group: "Advanced"
 
 privacy:
   role: "server"
+  depends_on: "task.type == classic_fl"
   ui:
     label: "Privacy"
     group: "Advanced"
@@ -188,6 +493,14 @@ privacy:
       ui:
         label: "Enable CKKS"
         group: "Advanced"
+    method:
+      type: "select"
+      options: ["ckks"]
+      default: "ckks"
+      depends_on: "privacy.homomorphic_encryption.enable == true"
+      ui:
+        label: "Encryption method"
+        group: "Advanced"
     poly_modulus_degree:
       type: "select"
       options: [4096, 8192, 16384]
@@ -196,6 +509,47 @@ privacy:
       ui:
         label: "Polynomial modulus degree"
         group: "Advanced"
+  differential_privacy:
+    enable:
+      type: "bool"
+      default: false
+      ui:
+        label: "Enable DP"
+        group: "Advanced"
+    clipping_norm:
+      type: "number"
+      default: 1.0
+      min: 0.0001
+      step: 0.1
+      depends_on: "privacy.differential_privacy.enable == true"
+      ui:
+        label: "Clipping norm"
+        group: "Advanced"
+    noise_multiplier:
+      type: "number"
+      default: 0.0
+      min: 0
+      step: 0.1
+      depends_on: "privacy.differential_privacy.enable == true"
+      ui:
+        label: "Noise multiplier"
+        group: "Advanced"
+  secure_aggregation:
+    enable:
+      type: "bool"
+      default: false
+      ui:
+        label: "Enable secure aggregation"
+        group: "Advanced"
+    mask_std:
+      type: "number"
+      default: 1.0
+      min: 0
+      step: 0.1
+      depends_on: "privacy.secure_aggregation.enable == true"
+      ui:
+        label: "Mask std"
+        group: "Advanced"
 
 system:
   hidden: true
diff --git a/configs/simulation_config.yaml b/configs/simulation_config.yaml
index 073f5b0..c972866 100644
--- a/configs/simulation_config.yaml
+++ b/configs/simulation_config.yaml
@@ -1,3 +1,5 @@
+task:
+  type: classic_fl
 dataset:
   name: CIFAR-10
   data_dir: ./datasets
@@ -5,11 +7,11 @@ dataset:
   alpha: 0.5
   num_clients: 3
 model:
-  name: CNN
+  name: Auto
   input_shape:
+  - 3
   - 32
   - 32
-  - 3
   num_classes: 10
 federated:
   num_rounds: 10
@@ -22,11 +24,21 @@ federated:
 compression:
   sparsification:
     enable: false
+    method: global_topk
     ratio: 0.5
+    threshold: 0.001
 privacy:
   homomorphic_encryption:
     enable: false
+    method: ckks
     poly_modulus_degree: 8192
+  differential_privacy:
+    enable: false
+    clipping_norm: 1.0
+    noise_multiplier: 0.0
+  secure_aggregation:
+    enable: false
+    mask_std: 1.0
 system:
   mode: simulation
   node_role: server
diff --git a/configs/smoke/llm_peft/train.jsonl b/configs/smoke/llm_peft/train.jsonl
new file mode 100644
index 0000000..9e4e1af
--- /dev/null
+++ b/configs/smoke/llm_peft/train.jsonl
@@ -0,0 +1,5 @@
+{"prompt":"Question: What is federated learning?\nAnswer:","completion":" Training a shared model across clients without centralizing their raw data."}
+{"prompt":"Question: What does LoRA train?\nAnswer:","completion":" Low-rank adapter weights while keeping the base model frozen."}
+{"prompt":"Question: Why use a validation set?\nAnswer:","completion":" To estimate generalization with loss and perplexity after training rounds."}
+{"prompt":"Question: What is PEFT?\nAnswer:","completion":" Parameter-efficient fine-tuning that updates a small set of trainable parameters."}
+
diff --git a/configs/smoke/llm_peft/validation.jsonl b/configs/smoke/llm_peft/validation.jsonl
new file mode 100644
index 0000000..ae900d9
--- /dev/null
+++ b/configs/smoke/llm_peft/validation.jsonl
@@ -0,0 +1,3 @@
+{"prompt":"Question: What is adapter aggregation?\nAnswer:","completion":" Combining client adapter weights into a new global adapter."}
+{"prompt":"Question: What does perplexity measure?\nAnswer:","completion":" How well the model predicts validation tokens, derived from language-model loss."}
+
diff --git a/configs/smoke/llm_peft_simulation.yaml b/configs/smoke/llm_peft_simulation.yaml
new file mode 100644
index 0000000..440c5d6
--- /dev/null
+++ b/configs/smoke/llm_peft_simulation.yaml
@@ -0,0 +1,48 @@
+task:
+  type: llm_peft_sft
+
+system:
+  mode: simulation
+  node_role: server
+
+llm:
+  base_model: ./models/llm/tiny-causal-lm
+  tokenizer: auto
+  max_seq_length: 128
+  precision: fp32
+
+sft:
+  dataset_path: ./configs/smoke/llm_peft/train.jsonl
+  format: prompt_completion
+  prompt_template: plain
+  per_device_train_batch_size: 1
+  gradient_accumulation_steps: 1
+
+peft:
+  method: lora
+  rank: 4
+  alpha: 8
+  dropout: 0.0
+  target_modules: q_proj,v_proj
+  resume_adapter_path: ""
+  quantization: none
+
+evaluation:
+  enable: true
+  dataset_path: ./configs/smoke/llm_peft/validation.jsonl
+  max_samples: 4
+  batch_size: 1
+
+federated:
+  num_clients: 2
+  num_rounds: 1
+  clients_per_round: 2
+  local_epochs: 1
+  learning_rate: 0.0002
+  aggregation: fedavg
+  seed: 42
+
+logging:
+  results_dir: ./results
+  save_results: true
+
diff --git a/datasets/llm/README.md b/datasets/llm/README.md
new file mode 100644
index 0000000..ad1c2a9
--- /dev/null
+++ b/datasets/llm/README.md
@@ -0,0 +1,23 @@
+# Local LLM Datasets
+
+Place supervised fine-tuning JSONL files here.
+
+Example:
+
+```text
+datasets/llm/train.jsonl
+datasets/llm/validation.jsonl
+datasets/llm/alpaca/train.jsonl
+```
+
+Each JSONL row should use either prompt/completion fields:
+
+```json
+{"prompt":"Question","completion":"Answer"}
+```
+
+or messages fields when `sft.format` is set to `messages`.
+
+JSONL files under this path are discovered by the backend and exposed as selectable `sft.dataset_path` options in the frontend.
+
+Validation JSONL files under this path are also exposed as selectable `evaluation.dataset_path` options for LLM PEFT evaluation.
diff --git a/libs/fl_core/compression/__init__.py b/libs/fl_core/compression/__init__.py
index e69de29..9311568 100644
--- a/libs/fl_core/compression/__init__.py
+++ b/libs/fl_core/compression/__init__.py
@@ -0,0 +1,19 @@
+from .sparsification import (
+    CompressionFactory,
+    CompressionStrategy,
+    GlobalTopKSparsifier,
+    QuantInt8Compressor,
+    RandomKSparsifier,
+    SignCompressor,
+    ThresholdSparsifier,
+)
+
+__all__ = [
+    "CompressionFactory",
+    "CompressionStrategy",
+    "GlobalTopKSparsifier",
+    "RandomKSparsifier",
+    "ThresholdSparsifier",
+    "SignCompressor",
+    "QuantInt8Compressor",
+]
diff --git a/libs/fl_core/compression/sparsification.py b/libs/fl_core/compression/sparsification.py
index 453d84a..d8ef63b 100644
--- a/libs/fl_core/compression/sparsification.py
+++ b/libs/fl_core/compression/sparsification.py
@@ -1,46 +1,167 @@
-import torch
-from typing import Dict
+from __future__ import annotations
+
 import logging
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+import torch
+
+
+def _is_trainable_float(name: str, tensor: torch.Tensor) -> bool:
+    return (
+        tensor.is_floating_point()
+        and tensor.dim() > 0
+        and "num_batches_tracked" not in name
+        and "running_" not in name
+    )
 
-class GlobalTopKSparsifier:
-    def __init__(self, ratio: float = 0.5):
-        self.ratio = ratio
-        self.logger = logging.getLogger("Sparsifier")
 
+class CompressionStrategy(ABC):
+    method = "none"
+
+    @abstractmethod
     def sparsify(self, update_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+        pass
+
+
+class GlobalTopKSparsifier(CompressionStrategy):
+    method = "global_topk"
 
+    def __init__(self, ratio: float = 0.5, **_: Any):
+        self.ratio = ratio
+        self.logger = logging.getLogger("GlobalTopKSparsifier")
+
+    def sparsify(self, update_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
         if self.ratio >= 1.0:
             return update_dict
 
-        # 1. 收集所有参与训练的参数（排除BN层统计量和标量）
-        trainable_tensors = []
-        for name, tensor in update_dict.items():
-            if tensor.dim() > 0 and 'num_batches_tracked' not in name and 'running_' not in name:
-                trainable_tensors.append(tensor.abs().view(-1))
-        
+        trainable_tensors = [
+            tensor.abs().view(-1)
+            for name, tensor in update_dict.items()
+            if _is_trainable_float(name, tensor)
+        ]
         if not trainable_tensors:
             return update_dict
 
-        # 2. 全局拼接并计算阈值
         all_abs_params = torch.cat(trainable_tensors)
         k = int(all_abs_params.numel() * self.ratio)
-        
         if k == 0:
-            return {k: torch.zeros_like(v) for k, v in update_dict.items()}
+            return {
+                name: torch.zeros_like(tensor) if _is_trainable_float(name, tensor) else tensor
+                for name, tensor in update_dict.items()
+            }
 
-        # 获取第 k 大的值作为阈值
         threshold = torch.kthvalue(all_abs_params, all_abs_params.numel() - k + 1).values.item()
+        sparse_update = {}
+        for name, tensor in update_dict.items():
+            if not _is_trainable_float(name, tensor):
+                sparse_update[name] = tensor
+                continue
+            sparse_update[name] = tensor * (torch.abs(tensor) >= threshold).to(tensor.dtype)
+        return sparse_update
+
+
+class RandomKSparsifier(CompressionStrategy):
+    method = "random_k"
+
+    def __init__(self, ratio: float = 0.5, **_: Any):
+        self.ratio = ratio
+        self.logger = logging.getLogger("RandomKSparsifier")
+
+    def sparsify(self, update_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+        if self.ratio >= 1.0:
+            return update_dict
+        sparse_update = {}
+        for name, tensor in update_dict.items():
+            if not _is_trainable_float(name, tensor):
+                sparse_update[name] = tensor
+                continue
+            flat = tensor.view(-1)
+            k = int(flat.numel() * self.ratio)
+            if k <= 0:
+                sparse_update[name] = torch.zeros_like(tensor)
+                continue
+            mask = torch.zeros(flat.numel(), device=tensor.device, dtype=torch.bool)
+            indices = torch.randperm(flat.numel(), device=tensor.device)[:k]
+            mask[indices] = True
+            sparse_update[name] = (flat * mask.to(flat.dtype)).view_as(tensor)
+        return sparse_update
+
+
+class ThresholdSparsifier(CompressionStrategy):
+    method = "threshold"
 
-        # 3. 应用掩码
+    def __init__(self, threshold: float = 1e-3, **_: Any):
+        self.threshold = float(threshold)
+        self.ratio = 1.0
+        self.logger = logging.getLogger("ThresholdSparsifier")
+
+    def sparsify(self, update_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
         sparse_update = {}
         for name, tensor in update_dict.items():
-            # 不处理统计量
-            if tensor.dim() == 0 or 'num_batches_tracked' in name or 'running_' in name:
+            if not _is_trainable_float(name, tensor):
                 sparse_update[name] = tensor
                 continue
+            sparse_update[name] = tensor * (torch.abs(tensor) >= self.threshold).to(tensor.dtype)
+        return sparse_update
+
+
+class SignCompressor(CompressionStrategy):
+    method = "sign"
+
+    def __init__(self, **_: Any):
+        self.ratio = 1.0
+        self.logger = logging.getLogger("SignCompressor")
+
+    def sparsify(self, update_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+        compressed = {}
+        for name, tensor in update_dict.items():
+            if not _is_trainable_float(name, tensor):
+                compressed[name] = tensor
+                continue
+            mean_abs = tensor.abs().mean().clamp_min(1e-12)
+            compressed[name] = tensor.sign() * mean_abs
+        return compressed
+
+
+class QuantInt8Compressor(CompressionStrategy):
+    method = "quant_int8"
+
+    def __init__(self, **_: Any):
+        self.ratio = 1.0
+        self.logger = logging.getLogger("QuantInt8Compressor")
+
+    def sparsify(self, update_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+        compressed = {}
+        for name, tensor in update_dict.items():
+            if not _is_trainable_float(name, tensor):
+                compressed[name] = tensor
+                continue
+            scale = tensor.abs().max().clamp_min(1e-12) / 127.0
+            quantized = torch.clamp(torch.round(tensor / scale), -127, 127)
+            compressed[name] = quantized * scale
+        return compressed
+
+
+class CompressionFactory:
+    _strategies = {
+        "global_topk": GlobalTopKSparsifier,
+        "topk": GlobalTopKSparsifier,
+        "random_k": RandomKSparsifier,
+        "randomk": RandomKSparsifier,
+        "threshold": ThresholdSparsifier,
+        "sign": SignCompressor,
+        "quant_int8": QuantInt8Compressor,
+        "int8": QuantInt8Compressor,
+    }
+
+    @classmethod
+    def create(cls, method: str = "global_topk", **kwargs: Any) -> CompressionStrategy:
+        key = method.lower()
+        if key not in cls._strategies:
+            raise ValueError(f"Unsupported compression method: {method}. Supported: {list(cls._strategies.keys())}")
+        return cls._strategies[key](**kwargs)
 
-            # 生成掩码
-            mask = torch.abs(tensor) >= threshold
-            sparse_update[name] = tensor * mask.float()
-            
-        return sparse_update
\ No newline at end of file
+    @classmethod
+    def supported_methods(cls) -> list[str]:
+        return ["global_topk", "random_k", "threshold", "sign", "quant_int8"]
diff --git a/libs/fl_core/data/data_loader.py b/libs/fl_core/data/data_loader.py
index 6b604bc..f6415ff 100644
--- a/libs/fl_core/data/data_loader.py
+++ b/libs/fl_core/data/data_loader.py
@@ -1,154 +1,404 @@
+from __future__ import annotations
+
+import csv
+import hashlib
+import json
 import os
+from pathlib import Path
+from typing import Any, Dict, Iterable, Tuple
+
+import numpy as np
 import torch
 import torchvision
 import torchvision.transforms as transforms
-from torch.utils.data import DataLoader
-import numpy as np
-from typing import Tuple, Dict, Any
+from PIL import Image
+from torch.utils.data import DataLoader, Dataset
+
+from fl_core.simulation_registry import (
+    DatasetSpec,
+    canonical_dataset_name,
+    get_dataset_spec,
+    list_dataset_names,
+)
+
+
+def _safe_dataset_class(name: str):
+    return getattr(torchvision.datasets, name, None)
+
+
+def _image_transform(input_shape: tuple[int, int, int], mean: tuple[float, ...] | None = None, std: tuple[float, ...] | None = None):
+    channels, height, width = input_shape
+    steps: list[Any] = []
+    if (height, width) not in {(28, 28), (32, 32)}:
+        steps.append(transforms.Resize((height, width)))
+    steps.append(transforms.Grayscale(num_output_channels=channels) if channels == 1 else transforms.Lambda(lambda image: image.convert("RGB")))
+    steps.append(transforms.ToTensor())
+    if mean is not None and std is not None:
+        steps.append(transforms.Normalize(mean, std))
+    return transforms.Compose(steps)
+
+
+def _hash_text_to_vector(text: str, feature_dim: int) -> np.ndarray:
+    vector = np.zeros(feature_dim, dtype=np.float32)
+    for token in text.lower().split():
+        if not token:
+            continue
+        digest = hashlib.md5(token.encode("utf-8")).hexdigest()
+        vector[int(digest[:8], 16) % feature_dim] += 1.0
+    norm = np.linalg.norm(vector)
+    if norm > 0:
+        vector /= norm
+    return vector
+
+
+class CsvTextClassificationDataset(Dataset):
+    def __init__(self, path: Path, *, feature_dim: int):
+        if not path.exists():
+            raise FileNotFoundError(f"Text dataset file not found: {path}")
+        self.samples: list[tuple[np.ndarray, int]] = []
+        with path.open("r", encoding="utf-8", errors="replace", newline="") as fp:
+            reader = csv.reader(fp)
+            for row in reader:
+                if len(row) < 2:
+                    continue
+                try:
+                    label = int(row[0])
+                except ValueError:
+                    continue
+                if label > 0:
+                    label -= 1
+                text = " ".join(row[1:])
+                self.samples.append((_hash_text_to_vector(text, feature_dim), label))
+        if not self.samples:
+            raise ValueError(f"No text samples found in {path}")
+
+    def __len__(self) -> int:
+        return len(self.samples)
+
+    def __getitem__(self, index: int):
+        data, label = self.samples[index]
+        return torch.from_numpy(data), int(label)
+
+
+class ShakespeareDataset(Dataset):
+    def __init__(self, path: Path, *, sequence_length: int = 80, vocab_size: int = 128):
+        if not path.exists():
+            raise FileNotFoundError(f"Shakespeare text file not found: {path}")
+        text = path.read_text(encoding="utf-8", errors="replace")
+        encoded = np.array([min(ord(ch), vocab_size - 1) for ch in text], dtype=np.int64)
+        if len(encoded) <= sequence_length:
+            raise ValueError(f"Shakespeare file {path} is too short for sequence_length={sequence_length}")
+        self.x = []
+        self.y = []
+        for start in range(0, len(encoded) - sequence_length):
+            end = start + sequence_length
+            self.x.append(encoded[start:end])
+            self.y.append(int(encoded[end]))
+
+    def __len__(self) -> int:
+        return len(self.y)
+
+    def __getitem__(self, index: int):
+        return torch.from_numpy(self.x[index]), self.y[index]
+
+
+class LeafFEMNISTDataset(Dataset):
+    def __init__(self, root: Path, split: str):
+        files = sorted((root / split).glob("*.json"))
+        if not files:
+            raise FileNotFoundError(
+                f"FEMNIST LEAF files not found. Expected JSON files under {root / split}"
+            )
+        data: list[np.ndarray] = []
+        labels: list[int] = []
+        for path in files:
+            loaded = json.loads(path.read_text(encoding="utf-8"))
+            user_data = loaded.get("user_data", {})
+            for user_payload in user_data.values():
+                xs = user_payload.get("x", [])
+                ys = user_payload.get("y", [])
+                for x, y in zip(xs, ys):
+                    arr = np.asarray(x, dtype=np.float32).reshape(1, 28, 28)
+                    data.append(arr)
+                    labels.append(int(y))
+        if not data:
+            raise ValueError(f"No FEMNIST samples found under {root / split}")
+        self.data = np.stack(data, axis=0)
+        self.labels = np.asarray(labels, dtype=np.int64)
+
+    def __len__(self) -> int:
+        return len(self.labels)
+
+    def __getitem__(self, index: int):
+        return torch.from_numpy(self.data[index]), int(self.labels[index])
+
+
+class TinyImageNetValDataset(Dataset):
+    def __init__(self, root: Path, transform, class_to_idx: dict[str, int] | None = None):
+        val_dir = root / "val"
+        annotation_path = val_dir / "val_annotations.txt"
+        if not annotation_path.exists():
+            raise FileNotFoundError(f"Tiny-ImageNet val annotations not found: {annotation_path}")
+        if class_to_idx is None:
+            wnids = _read_tiny_imagenet_wnids(root)
+            class_to_idx = {wnid: idx for idx, wnid in enumerate(wnids)}
+        self.class_to_idx = class_to_idx
+        self.samples: list[tuple[Path, int]] = []
+        with annotation_path.open("r", encoding="utf-8") as fp:
+            for line in fp:
+                parts = line.strip().split("\t")
+                if len(parts) < 2:
+                    continue
+                image_name, wnid = parts[:2]
+                if wnid not in self.class_to_idx:
+                    continue
+                self.samples.append((val_dir / "images" / image_name, self.class_to_idx[wnid]))
+        self.transform = transform
+        if not self.samples:
+            raise ValueError(f"No Tiny-ImageNet validation samples found under {val_dir}")
+
+    def __len__(self) -> int:
+        return len(self.samples)
+
+    def __getitem__(self, index: int):
+        path, label = self.samples[index]
+        image = Image.open(path)
+        if self.transform:
+            image = self.transform(image)
+        return image, label
+
+
+def _read_tiny_imagenet_wnids(root: Path) -> list[str]:
+    wnids_path = root / "wnids.txt"
+    if wnids_path.exists():
+        return [line.strip() for line in wnids_path.read_text(encoding="utf-8").splitlines() if line.strip()]
+    train_dir = root / "train"
+    if train_dir.exists():
+        return sorted(path.name for path in train_dir.iterdir() if path.is_dir())
+    raise FileNotFoundError(f"Tiny-ImageNet class list not found under {root}")
 
 
 class DatasetLoader:
-    
     def __init__(self, data_dir: str = "./datasets"):
         self.data_dir = data_dir
-        self.supported_datasets = ["CIFAR-10", "CIFAR-100", "MNIST", "Fashion-MNIST"]
-        
+        self.supported_datasets = list_dataset_names()
         os.makedirs(self.data_dir, exist_ok=True)
-        
-        self.dataset_configs = {
+        self.dataset_configs = self._build_dataset_configs()
+
+    def _build_dataset_configs(self) -> dict[str, dict[str, Any]]:
+        return {
+            "MNIST": {
+                "dataset_class": torchvision.datasets.MNIST,
+                "style": "train_bool",
+                "transform": _image_transform((1, 28, 28), (0.1307,), (0.3081,)),
+            },
+            "EMNIST": {
+                "dataset_class": torchvision.datasets.EMNIST,
+                "style": "emnist",
+                "split": "balanced",
+                "transform": _image_transform((1, 28, 28), (0.1751,), (0.3332,)),
+            },
+            "Fashion-MNIST": {
+                "dataset_class": torchvision.datasets.FashionMNIST,
+                "style": "train_bool",
+                "transform": _image_transform((1, 28, 28), (0.2860,), (0.3530,)),
+            },
             "CIFAR-10": {
                 "dataset_class": torchvision.datasets.CIFAR10,
-                "num_classes": 10,
-                "input_shape": (3, 32, 32),
-                "transform": transforms.Compose([
-                    transforms.ToTensor(),
-                    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
-                ])
+                "style": "train_bool",
+                "transform": _image_transform((3, 32, 32), (0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
             },
             "CIFAR-100": {
                 "dataset_class": torchvision.datasets.CIFAR100,
-                "num_classes": 100,
-                "input_shape": (3, 32, 32),
-                "transform": transforms.Compose([
-                    transforms.ToTensor(),
-                    transforms.Normalize((0.5071, 0.4867, 0.4408), (0.2675, 0.2565, 0.2761))
-                ])
+                "style": "train_bool",
+                "transform": _image_transform((3, 32, 32), (0.5071, 0.4867, 0.4408), (0.2675, 0.2565, 0.2761)),
             },
-            "MNIST": {
-                "dataset_class": torchvision.datasets.MNIST,
-                "num_classes": 10,
-                "input_shape": (1, 28, 28),
-                "transform": transforms.Compose([
-                    transforms.ToTensor(),
-                    transforms.Normalize((0.1307,), (0.3081,))
-                ])
+            "Country211": {
+                "dataset_class": _safe_dataset_class("Country211"),
+                "style": "split",
+                "train_split": "train",
+                "test_split": "test",
+                "transform": _image_transform((3, 64, 64)),
+            },
+            "Flowers102": {
+                "dataset_class": _safe_dataset_class("Flowers102"),
+                "style": "split",
+                "train_split": "train",
+                "test_split": "test",
+                "transform": _image_transform((3, 64, 64)),
+            },
+            "GTSRB": {
+                "dataset_class": _safe_dataset_class("GTSRB"),
+                "style": "split",
+                "train_split": "train",
+                "test_split": "test",
+                "transform": _image_transform((3, 64, 64)),
+            },
+            "Stanford Cars": {
+                "dataset_class": _safe_dataset_class("StanfordCars"),
+                "style": "split",
+                "train_split": "train",
+                "test_split": "test",
+                "transform": _image_transform((3, 64, 64)),
             },
-            "Fashion-MNIST": {
-                "dataset_class": torchvision.datasets.FashionMNIST,
-                "num_classes": 10,
-                "input_shape": (1, 28, 28),
-                "transform": transforms.Compose([
-                    transforms.ToTensor(),
-                    transforms.Normalize((0.2860,), (0.3530,))
-                ])
-            }
         }
-    
-    def load_dataset(self, dataset_name: str) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
 
-        if dataset_name not in self.supported_datasets:
-            raise ValueError(f"不支持的数据集: {dataset_name}. 支持的数据集: {self.supported_datasets}")
+    def load_dataset(self, dataset_name: str) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        dataset_name = canonical_dataset_name(dataset_name)
+        spec = get_dataset_spec(dataset_name)
+        if spec is None:
+            raise ValueError(f"Unsupported dataset: {dataset_name}. Supported datasets: {self.supported_datasets}")
 
         already_cached = self.check_dataset_exists(dataset_name)
         if already_cached:
             print(f"DATASET_READY: {dataset_name} (cached at {self.data_dir})", flush=True)
         else:
-            print(
-                f"DATASET_DOWNLOAD_START: {dataset_name} (first-time download, this may take several minutes)",
-                flush=True,
-            )
+            print(f"DATASET_DOWNLOAD_START: {dataset_name} (first-time load, this may take several minutes)", flush=True)
 
-        config = self.dataset_configs[dataset_name]
-        dataset_class = config["dataset_class"]
-        transform = config["transform"]
+        train_dataset, test_dataset = self._create_datasets(spec)
 
-        try:
-            # 加载训练集
-            train_dataset = dataset_class(
-                root=self.data_dir,
-                train=True,
-                download=True,
-                transform=transform
+        if not already_cached:
+            print(f"DATASET_DOWNLOAD_DONE: {dataset_name}", flush=True)
+        print(f"DATASET_LOADED: {dataset_name} train={len(train_dataset)} test={len(test_dataset)}", flush=True)
+
+        train_data, train_labels = self._dataset_to_numpy(train_dataset)
+        test_data, test_labels = self._dataset_to_numpy(test_dataset)
+        return train_data, train_labels, test_data, test_labels
+
+    def _create_datasets(self, spec: DatasetSpec):
+        if spec.loader == "torchvision":
+            return self._create_torchvision_datasets(spec)
+        if spec.loader == "tiny_imagenet":
+            return self._create_tiny_imagenet_datasets(spec)
+        if spec.loader == "local_image_folder":
+            return self._create_local_image_folder_datasets(spec)
+        if spec.loader == "leaf_femnist":
+            root = Path(self.data_dir) / spec.name
+            return LeafFEMNISTDataset(root, "train"), LeafFEMNISTDataset(root, "test")
+        if spec.loader == "csv_text":
+            root = Path(self.data_dir) / spec.name.replace(" ", "_")
+            if not root.exists():
+                root = Path(self.data_dir) / spec.name
+            feature_dim = int(spec.metadata.get("feature_dim", spec.input_shape[0]))
+            return (
+                CsvTextClassificationDataset(root / "train.csv", feature_dim=feature_dim),
+                CsvTextClassificationDataset(root / "test.csv", feature_dim=feature_dim),
             )
+        if spec.loader == "shakespeare":
+            root = Path(self.data_dir) / spec.name
+            seq_len = int(spec.metadata.get("sequence_length", spec.input_shape[0]))
+            vocab_size = int(spec.metadata.get("vocab_size", spec.num_classes))
+            return (
+                ShakespeareDataset(root / "train.txt", sequence_length=seq_len, vocab_size=vocab_size),
+                ShakespeareDataset(root / "test.txt", sequence_length=seq_len, vocab_size=vocab_size),
+            )
+        raise ValueError(f"Unsupported dataset loader: {spec.loader}")
 
-            # 加载测试集
-            test_dataset = dataset_class(
-                root=self.data_dir,
-                train=False,
-                download=True,
-                transform=transform
+    def _create_torchvision_datasets(self, spec: DatasetSpec):
+        config = self.dataset_configs.get(spec.name)
+        if not config:
+            raise ValueError(f"Missing torchvision config for dataset: {spec.name}")
+        dataset_class = config.get("dataset_class")
+        if dataset_class is None:
+            raise ValueError(f"torchvision does not provide dataset class for {spec.name}")
+        transform = config["transform"]
+        style = config["style"]
+        if style == "train_bool":
+            return (
+                dataset_class(root=self.data_dir, train=True, download=True, transform=transform),
+                dataset_class(root=self.data_dir, train=False, download=True, transform=transform),
             )
+        if style == "emnist":
+            split = config.get("split", "balanced")
+            return (
+                dataset_class(root=self.data_dir, split=split, train=True, download=True, transform=transform),
+                dataset_class(root=self.data_dir, split=split, train=False, download=True, transform=transform),
+            )
+        if style == "split":
+            return (
+                dataset_class(root=self.data_dir, split=config["train_split"], download=True, transform=transform),
+                dataset_class(root=self.data_dir, split=config["test_split"], download=True, transform=transform),
+            )
+        raise ValueError(f"Unsupported torchvision loader style: {style}")
 
-            if not already_cached:
-                print(f"DATASET_DOWNLOAD_DONE: {dataset_name}", flush=True)
-            
-            print(
-                f"DATASET_LOADED: {dataset_name} train={len(train_dataset)} test={len(test_dataset)}",
-                flush=True,
+    def _create_tiny_imagenet_datasets(self, spec: DatasetSpec):
+        root = Path(self.data_dir) / "Tiny-ImageNet"
+        if not root.exists():
+            root = Path(self.data_dir) / "tiny-imagenet-200"
+        transform = _image_transform(spec.input_shape)
+        train_dir = root / "train"
+        if not train_dir.exists():
+            raise FileNotFoundError(f"Tiny-ImageNet train directory not found: {train_dir}")
+        train_dataset = torchvision.datasets.ImageFolder(str(train_dir), transform=transform)
+        test_dataset = TinyImageNetValDataset(root, transform, train_dataset.class_to_idx)
+        return train_dataset, test_dataset
+
+    def _create_local_image_folder_datasets(self, spec: DatasetSpec):
+        root = Path(self.data_dir) / spec.name
+        if not root.exists():
+            root = Path(self.data_dir) / spec.name.lower()
+        train_dir = root / "train"
+        test_dir = root / "test"
+        if not train_dir.exists() or not test_dir.exists():
+            raise FileNotFoundError(
+                f"{spec.name} expects ImageFolder layout under {root}: train/<class>/*.jpg and test/<class>/*.jpg"
             )
-            
-            # 转换为numpy数组
-            train_data, train_labels = self._dataset_to_numpy(train_dataset)
-            test_data, test_labels = self._dataset_to_numpy(test_dataset)
-            
-            return train_data, train_labels, test_data, test_labels
-            
-        except Exception as e:
-            print(f"加载数据集 {dataset_name} 时出错: {str(e)}")
-            raise
-    
+        transform = _image_transform(spec.input_shape)
+        return (
+            torchvision.datasets.ImageFolder(str(train_dir), transform=transform),
+            torchvision.datasets.ImageFolder(str(test_dir), transform=transform),
+        )
+
     def _dataset_to_numpy(self, dataset) -> Tuple[np.ndarray, np.ndarray]:
         data_list = []
         labels_list = []
-        
         dataloader = DataLoader(dataset, batch_size=1000, shuffle=False)
-        
         for batch_data, batch_labels in dataloader:
             data_list.append(batch_data.numpy())
             labels_list.append(batch_labels.numpy())
-        
         data = np.concatenate(data_list, axis=0)
         labels = np.concatenate(labels_list, axis=0)
-        
         return data, labels
-    
+
     def get_dataset_info(self, dataset_name: str) -> Dict[str, Any]:
-        if dataset_name not in self.supported_datasets:
-            raise ValueError(f"不支持的数据集: {dataset_name}")
-        
-        config = self.dataset_configs[dataset_name]
-        return {
-            "name": dataset_name,
-            "num_classes": config["num_classes"],
-            "input_shape": config["input_shape"],
-            "supported": True
+        dataset_name = canonical_dataset_name(dataset_name)
+        spec = get_dataset_spec(dataset_name)
+        if spec is None:
+            raise ValueError(f"Unsupported dataset: {dataset_name}")
+        info = {
+            "name": spec.name,
+            "num_classes": spec.num_classes,
+            "input_shape": spec.input_shape,
+            "modality": spec.modality,
+            "task_type": spec.task_type,
+            "default_model": spec.default_model,
+            "compatible_models": list(spec.compatible_models),
+            "supported": True,
         }
-    
+        info.update(spec.metadata)
+        return info
+
     def list_supported_datasets(self) -> list:
         return self.supported_datasets.copy()
-    
+
     def check_dataset_exists(self, dataset_name: str) -> bool:
+        dataset_name = canonical_dataset_name(dataset_name)
         if dataset_name not in self.supported_datasets:
             return False
-        
+
         dataset_dir_map = {
             "CIFAR-10": "cifar-10-batches-py",
-            "CIFAR-100": "cifar-100-python", 
+            "CIFAR-100": "cifar-100-python",
             "MNIST": "MNIST",
-            "Fashion-MNIST": "FashionMNIST"
+            "EMNIST": "EMNIST",
+            "Fashion-MNIST": "FashionMNIST",
+            "Tiny-ImageNet": "Tiny-ImageNet",
+            "FEMNIST": "FEMNIST",
+            "AG News": "AG_News",
+            "Sogou News": "Sogou_News",
+            "Shakespeare": "Shakespeare",
         }
-        
-        dataset_dir = os.path.join(self.data_dir, dataset_dir_map[dataset_name])
+        dataset_dir = os.path.join(self.data_dir, dataset_dir_map.get(dataset_name, dataset_name))
         return os.path.exists(dataset_dir)
 
 
@@ -157,15 +407,13 @@ def __init__(self, config: Dict[str, Any]):
         self.config = config
         self.data_dir = config.get("data_dir", "./datasets")
         self.loader = DatasetLoader(self.data_dir)
-    
+
     def load_dataset(self, dataset_name: str = None) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
         if dataset_name is None:
             dataset_name = self.config.get("name", "CIFAR-10")
-        
         return self.loader.load_dataset(dataset_name)
-    
+
     def get_dataset_info(self, dataset_name: str = None) -> Dict[str, Any]:
         if dataset_name is None:
             dataset_name = self.config.get("name", "CIFAR-10")
-        
-        return self.loader.get_dataset_info(dataset_name)
\ No newline at end of file
+        return self.loader.get_dataset_info(dataset_name)
diff --git a/libs/fl_core/federated/client_manager.py b/libs/fl_core/federated/client_manager.py
index bbb6c07..8d546ee 100644
--- a/libs/fl_core/federated/client_manager.py
+++ b/libs/fl_core/federated/client_manager.py
@@ -11,8 +11,10 @@
 
 from .client import FederatedClient
 
-from fl_core.compression.sparsification import GlobalTopKSparsifier
+from fl_core.compression.sparsification import CompressionStrategy, GlobalTopKSparsifier
+from fl_core.privacy.differential_privacy import DifferentialPrivacyManager
 from fl_core.privacy.encryption import CKKSManager
+from fl_core.privacy.secure_aggregation import SecureAggregationMasker
 
 
 class ClientManager:
@@ -22,8 +24,10 @@ def __init__(self,
                  selection_strategy: str = "random",
                  max_workers: Optional[int] = None,
                  device: torch.device = None,
-                 sparsifier: Optional[GlobalTopKSparsifier] = None,
-                 ckks_manager: Optional[CKKSManager] = None):
+                 sparsifier: Optional[CompressionStrategy] = None,
+                 ckks_manager: Optional[CKKSManager] = None,
+                 dp_manager: Optional[DifferentialPrivacyManager] = None,
+                 secure_aggregation: Optional[SecureAggregationMasker] = None):
         # if not clients:
         #     raise ValueError("客户端列表不能为空")
         
@@ -47,6 +51,8 @@ def __init__(self,
 
         self.sparsifier = sparsifier
         self.ckks_manager = ckks_manager
+        self.dp_manager = dp_manager
+        self.secure_aggregation = secure_aggregation
         
         self.training_stats = {
             'total_rounds': 0,
@@ -353,7 +359,7 @@ def evaluate_single_client(client: FederatedClient) -> Dict[str, Any]:
     def get_client_models(self, selected_clients: List[FederatedClient],
                           global_model_params: Optional[Dict[str, torch.Tensor]] = None) -> List[Dict[str, torch.Tensor]]:
 
-        client_models = []
+        delta_models = []
 
         for client in selected_clients:
             try:
@@ -370,6 +376,9 @@ def get_client_models(self, selected_clients: List[FederatedClient],
                 else:
                     delta = {k: v.to(self.device) for k, v in model_params.items()}
 
+                if self.dp_manager:
+                    delta = self.dp_manager.apply(delta)
+
                 payload = delta
 
                 if self.ckks_manager:
@@ -379,13 +388,16 @@ def get_client_models(self, selected_clients: List[FederatedClient],
                     # 稀疏化
                     payload = self.sparsifier.sparsify(delta)
                 
-                client_models.append(payload)
+                delta_models.append(payload)
                 
             except Exception as e:
                 self.logger.error(f"获取客户端 {client.client_id} 模型参数失败: {str(e)}")
-                client_models.append({})
+                delta_models.append({})
         
-        return client_models
+        if self.secure_aggregation:
+            delta_models = self.secure_aggregation.mask_models(delta_models)
+
+        return delta_models
     
     def broadcast_model_to_clients(self, 
                                   selected_clients: List[FederatedClient],
@@ -459,4 +471,4 @@ def __str__(self) -> str:
                 f"max_workers={self.max_workers})")
     
     def __repr__(self) -> str:
-        return self.__str__()
\ No newline at end of file
+        return self.__str__()
diff --git a/libs/fl_core/llm/__init__.py b/libs/fl_core/llm/__init__.py
new file mode 100644
index 0000000..05b1550
--- /dev/null
+++ b/libs/fl_core/llm/__init__.py
@@ -0,0 +1,23 @@
+"""LLM PEFT utilities for Figaro's Phase 2 federated fine-tuning route."""
+
+from .aggregation import AdapterClientUpdate, aggregate_adapter_state_dicts
+from .artifacts import adapter_artifact_record, load_adapter_artifact, save_adapter_artifact, sha256_file
+from .config import LlmPeftRuntimeConfig, normalize_llm_peft_config, parse_target_modules
+from .data import SftRecord, load_jsonl_sft_records, split_records_by_client
+from .metrics import empty_llm_metrics_payload
+
+__all__ = [
+    "AdapterClientUpdate",
+    "LlmPeftRuntimeConfig",
+    "SftRecord",
+    "aggregate_adapter_state_dicts",
+    "adapter_artifact_record",
+    "empty_llm_metrics_payload",
+    "load_adapter_artifact",
+    "load_jsonl_sft_records",
+    "normalize_llm_peft_config",
+    "parse_target_modules",
+    "save_adapter_artifact",
+    "sha256_file",
+    "split_records_by_client",
+]
diff --git a/libs/fl_core/llm/aggregation.py b/libs/fl_core/llm/aggregation.py
new file mode 100644
index 0000000..f1b8e68
--- /dev/null
+++ b/libs/fl_core/llm/aggregation.py
@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Mapping
+
+import torch
+
+
+@dataclass(frozen=True)
+class AdapterClientUpdate:
+    """A client-side PEFT adapter update plus weighting metadata."""
+
+    adapter_state: Mapping[str, torch.Tensor]
+    num_examples: int
+    num_tokens: int = 0
+    metrics: dict[str, Any] = field(default_factory=dict)
+
+
+def aggregate_adapter_state_dicts(
+    updates: list[AdapterClientUpdate],
+    *,
+    strategy: str = "weighted_avg",
+    device: torch.device | str | None = None,
+) -> dict[str, torch.Tensor]:
+    """Weighted-average LoRA/PEFT adapter tensors by client example count."""
+    if not updates:
+        raise ValueError("updates must not be empty")
+
+    reference_keys = tuple(updates[0].adapter_state.keys())
+    if not reference_keys:
+        raise ValueError("adapter_state must not be empty")
+
+    target_device = torch.device(device) if device is not None else torch.device("cpu")
+    weights = _normalized_weights(updates, strategy=strategy)
+    aggregated: dict[str, torch.Tensor] = {}
+
+    for key in reference_keys:
+        first_tensor = updates[0].adapter_state[key]
+        if not torch.is_floating_point(first_tensor):
+            raise TypeError(f"Adapter tensor {key!r} must be floating point")
+        accumulator = torch.zeros_like(first_tensor, device=target_device)
+
+        for update, weight in zip(updates, weights):
+            _validate_update_tensor(update, key, first_tensor)
+            accumulator += update.adapter_state[key].to(target_device) * weight
+        aggregated[key] = accumulator.detach().cpu()
+
+    return aggregated
+
+
+def _normalized_weights(updates: list[AdapterClientUpdate], *, strategy: str) -> list[float]:
+    normalized_strategy = strategy.strip().lower()
+    if normalized_strategy in {"fedavg", "weighted_avg"}:
+        return _normalized_example_weights(updates)
+    if normalized_strategy == "simple_avg":
+        return [1.0 / len(updates)] * len(updates)
+    raise ValueError(f"Unsupported LLM adapter aggregation strategy: {strategy}")
+
+
+def _normalized_example_weights(updates: list[AdapterClientUpdate]) -> list[float]:
+    raw_weights = [max(0, int(update.num_examples)) for update in updates]
+    total = sum(raw_weights)
+    if total <= 0:
+        return [1.0 / len(updates)] * len(updates)
+    return [weight / total for weight in raw_weights]
+
+
+def _validate_update_tensor(update: AdapterClientUpdate, key: str, reference: torch.Tensor) -> None:
+    if key not in update.adapter_state:
+        raise ValueError(f"Adapter update is missing key: {key}")
+    tensor = update.adapter_state[key]
+    if tensor.shape != reference.shape:
+        raise ValueError(f"Adapter tensor {key!r} has mismatched shape: {tuple(tensor.shape)} != {tuple(reference.shape)}")
+    if tensor.dtype != reference.dtype:
+        raise ValueError(f"Adapter tensor {key!r} has mismatched dtype: {tensor.dtype} != {reference.dtype}")
+    if not torch.is_floating_point(tensor):
+        raise TypeError(f"Adapter tensor {key!r} must be floating point")
diff --git a/libs/fl_core/llm/artifacts.py b/libs/fl_core/llm/artifacts.py
new file mode 100644
index 0000000..5ad8154
--- /dev/null
+++ b/libs/fl_core/llm/artifacts.py
@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Any, Mapping
+
+import torch
+
+
+ADAPTER_STATE_KEY = "adapter_state"
+METADATA_KEY = "metadata"
+
+
+def save_adapter_artifact(
+    path: str | Path,
+    adapter_state: Mapping[str, torch.Tensor],
+    *,
+    metadata: Mapping[str, Any] | None = None,
+) -> Path:
+    """Persist an adapter state dict with lightweight metadata."""
+    resolved = Path(path)
+    resolved.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        ADAPTER_STATE_KEY: {key: value.detach().cpu() for key, value in adapter_state.items()},
+        METADATA_KEY: dict(metadata or {}),
+    }
+    torch.save(payload, resolved)
+    return resolved
+
+
+def load_adapter_artifact(path: str | Path) -> tuple[dict[str, torch.Tensor], dict[str, Any]]:
+    """Load an adapter artifact saved by save_adapter_artifact."""
+    payload = torch.load(Path(path), map_location="cpu")
+    if not isinstance(payload, dict):
+        raise ValueError("Adapter artifact must contain a dictionary payload")
+    adapter_state = payload.get(ADAPTER_STATE_KEY)
+    metadata = payload.get(METADATA_KEY, {})
+    if not isinstance(adapter_state, dict):
+        raise ValueError("Adapter artifact is missing adapter_state")
+    if not isinstance(metadata, dict):
+        metadata = {}
+    return adapter_state, metadata
+
+
+def adapter_state_size_bytes(adapter_state: Mapping[str, torch.Tensor]) -> int:
+    """Return the total tensor storage size for an adapter state dict."""
+    return sum(tensor.numel() * tensor.element_size() for tensor in adapter_state.values())
+
+
+def sha256_file(path: str | Path) -> str:
+    """Return a SHA-256 digest for an artifact file."""
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as file_obj:
+        for chunk in iter(lambda: file_obj.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def adapter_artifact_record(
+    path: str | Path,
+    *,
+    round_num: int,
+    size_bytes: int,
+    selected_clients: list[int],
+    parent_path: str | None = None,
+    parent_sha256: str | None = None,
+) -> dict[str, Any]:
+    """Build serializable lineage metadata for one global adapter artifact."""
+    resolved = Path(path)
+    return {
+        "round": int(round_num),
+        "path": str(resolved),
+        "sha256": sha256_file(resolved),
+        "size_bytes": int(size_bytes),
+        "selected_clients": list(selected_clients),
+        "parent_path": parent_path,
+        "parent_sha256": parent_sha256,
+    }
diff --git a/libs/fl_core/llm/config.py b/libs/fl_core/llm/config.py
new file mode 100644
index 0000000..5f0bd61
--- /dev/null
+++ b/libs/fl_core/llm/config.py
@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping
+
+
+LLM_PEFT_TASK_TYPE = "llm_peft_sft"
+
+
+@dataclass(frozen=True)
+class LlmModelConfig:
+    base_model: str
+    tokenizer: str
+    max_seq_length: int
+    precision: str
+
+
+@dataclass(frozen=True)
+class SftDatasetConfig:
+    dataset_path: Path
+    format: str
+    file_format: str
+    validation_split: float
+    prompt_template: str
+    per_device_train_batch_size: int
+    gradient_accumulation_steps: int
+
+
+@dataclass(frozen=True)
+class PeftAdapterConfig:
+    method: str
+    rank: int
+    alpha: int
+    dropout: float
+    target_modules: tuple[str, ...]
+    resume_adapter_path: Path | None
+    quantization: str
+
+
+@dataclass(frozen=True)
+class LlmFederatedConfig:
+    num_clients: int
+    num_rounds: int
+    clients_per_round: int
+    local_epochs: int
+    learning_rate: float
+    aggregation: str
+    seed: int
+
+
+@dataclass(frozen=True)
+class LlmEvaluationConfig:
+    enabled: bool
+    dataset_path: Path | None
+    batch_size: int
+    max_samples: int
+
+
+@dataclass(frozen=True)
+class LlmPeftRuntimeConfig:
+    task_type: str
+    llm: LlmModelConfig
+    sft: SftDatasetConfig
+    peft: PeftAdapterConfig
+    federated: LlmFederatedConfig
+    evaluation: LlmEvaluationConfig
+    results_dir: Path
+
+
+def parse_target_modules(value: Any) -> tuple[str, ...]:
+    """Normalize LoRA target_modules from comma-separated text or a list."""
+    if isinstance(value, str):
+        modules = [part.strip() for part in value.split(",")]
+    elif isinstance(value, (list, tuple)):
+        modules = [str(part).strip() for part in value]
+    else:
+        modules = []
+
+    normalized = tuple(module for module in modules if module)
+    if not normalized:
+        raise ValueError("peft.target_modules must contain at least one module name")
+    return normalized
+
+
+def normalize_llm_peft_config(config: Mapping[str, Any]) -> LlmPeftRuntimeConfig:
+    """Validate and normalize the LLM PEFT subset of a Figaro runtime config."""
+    task_cfg = _mapping(config.get("task"))
+    task_type = _text(task_cfg.get("type", LLM_PEFT_TASK_TYPE), "task.type")
+    if task_type != LLM_PEFT_TASK_TYPE:
+        raise ValueError(f"Expected task.type={LLM_PEFT_TASK_TYPE!r}, got {task_type!r}")
+
+    llm_cfg = _mapping(config.get("llm"))
+    sft_cfg = _mapping(config.get("sft"))
+    peft_cfg = _mapping(config.get("peft"))
+    federated_cfg = _mapping(config.get("federated"))
+    evaluation_cfg = _mapping(config.get("evaluation"))
+    logging_cfg = _mapping(config.get("logging"))
+
+    llm = LlmModelConfig(
+        base_model=_text(llm_cfg.get("base_model"), "llm.base_model"),
+        tokenizer=_text(llm_cfg.get("tokenizer", "auto"), "llm.tokenizer"),
+        max_seq_length=_positive_int(llm_cfg.get("max_seq_length", 1024), "llm.max_seq_length"),
+        precision=_choice(llm_cfg.get("precision", "bf16"), {"fp32", "fp16", "bf16"}, "llm.precision"),
+    )
+    sft = SftDatasetConfig(
+        dataset_path=Path(_text(sft_cfg.get("dataset_path"), "sft.dataset_path")),
+        format=_choice(
+            sft_cfg.get("format", "prompt_completion"),
+            {"prompt_completion", "messages", "alpaca"},
+            "sft.format",
+        ),
+        file_format=_choice(sft_cfg.get("file_format", "auto"), {"auto", "jsonl", "parquet"}, "sft.file_format"),
+        validation_split=_bounded_float(
+            sft_cfg.get("validation_split", 0.0),
+            "sft.validation_split",
+            minimum=0.0,
+            maximum=0.5,
+        ),
+        prompt_template=_choice(sft_cfg.get("prompt_template", "plain"), {"plain", "chatml"}, "sft.prompt_template"),
+        per_device_train_batch_size=_positive_int(
+            sft_cfg.get("per_device_train_batch_size", 1),
+            "sft.per_device_train_batch_size",
+        ),
+        gradient_accumulation_steps=_positive_int(
+            sft_cfg.get("gradient_accumulation_steps", 1),
+            "sft.gradient_accumulation_steps",
+        ),
+    )
+    peft = PeftAdapterConfig(
+        method=_choice(peft_cfg.get("method", "lora"), {"lora"}, "peft.method"),
+        rank=_positive_int(peft_cfg.get("rank", 8), "peft.rank"),
+        alpha=_positive_int(peft_cfg.get("alpha", 16), "peft.alpha"),
+        dropout=_bounded_float(peft_cfg.get("dropout", 0.05), "peft.dropout", minimum=0.0, maximum=1.0),
+        target_modules=parse_target_modules(peft_cfg.get("target_modules", "q_proj,v_proj")),
+        resume_adapter_path=_optional_path(peft_cfg.get("resume_adapter_path")),
+        quantization=_choice(peft_cfg.get("quantization", "none"), {"none", "int8", "nf4_4bit"}, "peft.quantization"),
+    )
+    federated = LlmFederatedConfig(
+        num_clients=_positive_int(federated_cfg.get("num_clients", 1), "federated.num_clients"),
+        num_rounds=_positive_int(federated_cfg.get("num_rounds", 1), "federated.num_rounds"),
+        clients_per_round=_positive_int(federated_cfg.get("clients_per_round", 1), "federated.clients_per_round"),
+        local_epochs=_positive_int(federated_cfg.get("local_epochs", 1), "federated.local_epochs"),
+        learning_rate=_positive_float(federated_cfg.get("learning_rate", 0.0002), "federated.learning_rate"),
+        aggregation=_choice(
+            federated_cfg.get("aggregation", "fedavg"),
+            {"fedavg", "weighted_avg", "simple_avg"},
+            "federated.aggregation",
+        ),
+        seed=_int(federated_cfg.get("seed", 42), "federated.seed"),
+    )
+
+    if federated.clients_per_round > federated.num_clients:
+        raise ValueError("federated.clients_per_round cannot exceed federated.num_clients")
+
+    evaluation = LlmEvaluationConfig(
+        enabled=_bool(evaluation_cfg.get("enable", False), "evaluation.enable"),
+        dataset_path=_optional_path(evaluation_cfg.get("dataset_path")),
+        batch_size=_positive_int(evaluation_cfg.get("batch_size", 1), "evaluation.batch_size"),
+        max_samples=_positive_int(evaluation_cfg.get("max_samples", 128), "evaluation.max_samples"),
+    )
+    if evaluation.enabled and evaluation.dataset_path is None:
+        raise ValueError("evaluation.dataset_path must be set when evaluation.enable is true")
+
+    return LlmPeftRuntimeConfig(
+        task_type=task_type,
+        llm=llm,
+        sft=sft,
+        peft=peft,
+        federated=federated,
+        evaluation=evaluation,
+        results_dir=Path(str(logging_cfg.get("results_dir", "./results"))),
+    )
+
+
+def _mapping(value: Any) -> Mapping[str, Any]:
+    return value if isinstance(value, Mapping) else {}
+
+
+def _optional_path(value: Any) -> Path | None:
+    if value is None:
+        return None
+    if isinstance(value, str):
+        stripped = value.strip()
+        return Path(stripped) if stripped else None
+    return Path(str(value))
+
+
+def _text(value: Any, path: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"{path} must be a non-empty string")
+    return value.strip()
+
+
+def _bool(value: Any, path: str) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        lowered = value.strip().lower()
+        if lowered in {"true", "1", "yes", "on"}:
+            return True
+        if lowered in {"false", "0", "no", "off", ""}:
+            return False
+    raise ValueError(f"{path} must be a boolean")
+
+
+def _int(value: Any, path: str) -> int:
+    if isinstance(value, bool):
+        raise ValueError(f"{path} must be an integer")
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float) and value.is_integer():
+        return int(value)
+    if isinstance(value, str) and value.strip():
+        parsed = float(value)
+        if parsed.is_integer():
+            return int(parsed)
+    raise ValueError(f"{path} must be an integer")
+
+
+def _positive_int(value: Any, path: str) -> int:
+    parsed = _int(value, path)
+    if parsed <= 0:
+        raise ValueError(f"{path} must be positive")
+    return parsed
+
+
+def _positive_float(value: Any, path: str) -> float:
+    parsed = _float(value, path)
+    if parsed <= 0:
+        raise ValueError(f"{path} must be positive")
+    return parsed
+
+
+def _bounded_float(value: Any, path: str, *, minimum: float, maximum: float) -> float:
+    parsed = _float(value, path)
+    if parsed < minimum or parsed > maximum:
+        raise ValueError(f"{path} must be between {minimum} and {maximum}")
+    return parsed
+
+
+def _float(value: Any, path: str) -> float:
+    if isinstance(value, bool):
+        raise ValueError(f"{path} must be a number")
+    try:
+        return float(value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"{path} must be a number") from exc
+
+
+def _choice(value: Any, choices: set[str], path: str) -> str:
+    parsed = _text(value, path)
+    if parsed not in choices:
+        allowed = ", ".join(sorted(choices))
+        raise ValueError(f"{path} must be one of: {allowed}")
+    return parsed
diff --git a/libs/fl_core/llm/data.py b/libs/fl_core/llm/data.py
new file mode 100644
index 0000000..c2d8e29
--- /dev/null
+++ b/libs/fl_core/llm/data.py
@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import json
+import random
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Mapping
+
+
+@dataclass(frozen=True)
+class SftRecord:
+    """One supervised fine-tuning record before tokenization."""
+
+    prompt: str | None = None
+    completion: str | None = None
+    messages: tuple[dict[str, str], ...] = field(default_factory=tuple)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+def load_sft_records(
+    path: str | Path,
+    *,
+    data_format: str,
+    file_format: str = "auto",
+) -> list[SftRecord]:
+    """Load SFT records from a JSONL/Parquet file or a dataset directory."""
+    resolved = Path(path)
+    parsed_file_format = _normalize_file_format(file_format)
+    files = _resolve_sft_files(resolved, file_format=parsed_file_format)
+
+    records: list[SftRecord] = []
+    for file_path in files:
+        detected_format = _detect_file_format(file_path)
+        if detected_format == "jsonl":
+            records.extend(_load_jsonl_sft_records_file(file_path, data_format=data_format))
+        elif detected_format == "parquet":
+            records.extend(_load_parquet_sft_records_file(file_path, data_format=data_format))
+
+    if not records:
+        raise ValueError(f"SFT dataset is empty: {resolved}")
+    return records
+
+
+def load_jsonl_sft_records(path: str | Path, *, data_format: str) -> list[SftRecord]:
+    """Load prompt/completion or chat messages SFT records from JSONL."""
+    return load_sft_records(path, data_format=data_format, file_format="jsonl")
+
+
+def _load_jsonl_sft_records_file(path: Path, *, data_format: str) -> list[SftRecord]:
+    resolved = Path(path)
+    if not resolved.exists() or not resolved.is_file():
+        raise FileNotFoundError(f"SFT dataset not found: {resolved}")
+
+    records: list[SftRecord] = []
+    for line_number, raw_line in enumerate(resolved.read_text(encoding="utf-8").splitlines(), start=1):
+        line = raw_line.strip()
+        if not line:
+            continue
+        try:
+            payload = json.loads(line)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Invalid JSONL at line {line_number}: {exc.msg}") from exc
+        if not isinstance(payload, Mapping):
+            raise ValueError(f"SFT JSONL line {line_number} must be an object")
+        records.append(_record_from_payload(payload, data_format=data_format, line_number=line_number))
+
+    return records
+
+
+def _load_parquet_sft_records_file(path: Path, *, data_format: str) -> list[SftRecord]:
+    try:
+        import pyarrow.parquet as pq
+    except ImportError as exc:
+        raise RuntimeError(
+            "Parquet SFT datasets require pyarrow. Install the project dependencies before loading parquet data."
+        ) from exc
+
+    table = pq.read_table(path)
+    records: list[SftRecord] = []
+    for row_number, payload in enumerate(table.to_pylist(), start=1):
+        if not isinstance(payload, Mapping):
+            raise ValueError(f"Parquet row {row_number} must be an object")
+        records.append(_record_from_payload(payload, data_format=data_format, line_number=row_number))
+    return records
+
+
+def split_records_by_client(
+    records: list[SftRecord],
+    *,
+    num_clients: int,
+    seed: int,
+    shuffle: bool = True,
+) -> list[list[SftRecord]]:
+    """Deterministically partition SFT records across clients."""
+    if num_clients <= 0:
+        raise ValueError("num_clients must be positive")
+    if not records:
+        raise ValueError("records must not be empty")
+
+    ordered = list(records)
+    if shuffle:
+        rng = random.Random(seed)
+        rng.shuffle(ordered)
+
+    clients = [[] for _ in range(num_clients)]
+    for idx, record in enumerate(ordered):
+        clients[idx % num_clients].append(record)
+    return clients
+
+
+def format_sft_record_text(record: SftRecord, *, data_format: str, prompt_template: str) -> str:
+    """Render a record into text for rough token accounting or simple tokenizers."""
+    if data_format in {"prompt_completion", "alpaca"}:
+        return f"{record.prompt or ''}{record.completion or ''}"
+    if data_format != "messages":
+        raise ValueError(f"Unsupported SFT format: {data_format}")
+
+    if prompt_template == "chatml":
+        chunks = []
+        for message in record.messages:
+            chunks.append(f"<|im_start|>{message['role']}\n{message['content']}<|im_end|>")
+        return "\n".join(chunks)
+
+    chunks = [f"{message['role']}: {message['content']}" for message in record.messages]
+    return "\n".join(chunks)
+
+
+def _record_from_payload(payload: Mapping[str, Any], *, data_format: str, line_number: int) -> SftRecord:
+    if data_format == "prompt_completion":
+        prompt = payload.get("prompt")
+        completion = payload.get("completion")
+        if not isinstance(prompt, str) or not isinstance(completion, str):
+            raise ValueError(f"Line {line_number} must contain string prompt and completion fields")
+        metadata = {key: value for key, value in payload.items() if key not in {"prompt", "completion"}}
+        return SftRecord(prompt=prompt, completion=completion, metadata=metadata)
+
+    if data_format == "messages":
+        messages = payload.get("messages")
+        if not isinstance(messages, list) or not messages:
+            raise ValueError(f"Line {line_number} must contain a non-empty messages list")
+        normalized_messages: list[dict[str, str]] = []
+        for message_index, message in enumerate(messages):
+            if not isinstance(message, Mapping):
+                raise ValueError(f"Line {line_number} message {message_index} must be an object")
+            role = message.get("role")
+            content = message.get("content")
+            if not isinstance(role, str) or not isinstance(content, str):
+                raise ValueError(f"Line {line_number} message {message_index} must contain role and content")
+            normalized_messages.append({"role": role, "content": content})
+        metadata = {key: value for key, value in payload.items() if key != "messages"}
+        return SftRecord(messages=tuple(normalized_messages), metadata=metadata)
+
+    if data_format == "alpaca":
+        instruction = payload.get("instruction")
+        input_text = payload.get("input", "")
+        output = payload.get("output")
+        if not isinstance(instruction, str) or not isinstance(output, str):
+            raise ValueError(f"Line {line_number} must contain string instruction and output fields")
+        if input_text is None:
+            input_text = ""
+        if not isinstance(input_text, str):
+            raise ValueError(f"Line {line_number} input field must be a string when present")
+        if input_text.strip():
+            prompt = f"Instruction: {instruction}\nInput: {input_text}\nAnswer:"
+        else:
+            prompt = f"Instruction: {instruction}\nAnswer:"
+        metadata = {
+            key: value
+            for key, value in payload.items()
+            if key not in {"instruction", "input", "output"}
+        }
+        return SftRecord(prompt=prompt, completion=f" {output}", metadata=metadata)
+
+    raise ValueError(f"Unsupported SFT format: {data_format}")
+
+
+def _resolve_sft_files(path: Path, *, file_format: str) -> list[Path]:
+    if not path.exists():
+        raise FileNotFoundError(f"SFT dataset not found: {path}")
+
+    if path.is_file():
+        detected_format = _detect_file_format(path)
+        if detected_format is None:
+            raise ValueError(f"Unsupported SFT dataset file extension: {path.suffix}")
+        if file_format != "auto" and detected_format != file_format:
+            raise ValueError(f"SFT dataset file is {detected_format}, not {file_format}: {path}")
+        return [path]
+
+    if not path.is_dir():
+        raise FileNotFoundError(f"SFT dataset not found: {path}")
+
+    files = [
+        candidate
+        for candidate in path.rglob("*")
+        if candidate.is_file()
+        and (detected_format := _detect_file_format(candidate)) is not None
+        and (file_format == "auto" or detected_format == file_format)
+    ]
+    if not files:
+        expected = "JSONL or Parquet" if file_format == "auto" else file_format.upper()
+        raise FileNotFoundError(f"No {expected} SFT files found in dataset directory: {path}")
+    return sorted(files, key=lambda item: item.as_posix().lower())
+
+
+def _detect_file_format(path: Path) -> str | None:
+    suffix = path.suffix.lower()
+    if suffix == ".jsonl":
+        return "jsonl"
+    if suffix == ".parquet":
+        return "parquet"
+    return None
+
+
+def _normalize_file_format(file_format: str) -> str:
+    normalized = str(file_format).strip().lower()
+    if normalized not in {"auto", "jsonl", "parquet"}:
+        raise ValueError("file_format must be one of: auto, jsonl, parquet")
+    return normalized
diff --git a/libs/fl_core/llm/metrics.py b/libs/fl_core/llm/metrics.py
new file mode 100644
index 0000000..0a4ab29
--- /dev/null
+++ b/libs/fl_core/llm/metrics.py
@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from .config import LlmPeftRuntimeConfig
+
+
+def empty_llm_metrics_payload(config: LlmPeftRuntimeConfig | None = None) -> dict[str, Any]:
+    """Return a metrics payload compatible with Figaro plus LLM-specific series."""
+    experiment_info = {
+        "basic": {"task_type": "llm_peft_sft"},
+        "federated": {},
+        "security": {},
+    }
+    if config is not None:
+        experiment_info["basic"].update(
+            {
+                "base_model": config.llm.base_model,
+                "sft_format": config.sft.format,
+                "peft_method": config.peft.method,
+            }
+        )
+        experiment_info["federated"] = {
+            "num_rounds": config.federated.num_rounds,
+            "num_clients": config.federated.num_clients,
+            "clients_per_round": config.federated.clients_per_round,
+            "local_epochs": config.federated.local_epochs,
+            "learning_rate": config.federated.learning_rate,
+            "aggregation": config.federated.aggregation,
+        }
+
+    return {
+        "experiment_info": experiment_info,
+        "global_results": {
+            "rounds": [],
+            "global_loss": [],
+            "global_accuracy": [],
+        },
+        "llm_results": {
+            "rounds": [],
+            "train_loss": [],
+            "validation_loss": [],
+            "perplexity": [],
+            "token_throughput": [],
+            "adapter_size_bytes": [],
+        },
+        "llm_dataset": {},
+        "llm_evaluation": {},
+        "llm_runtime": {},
+        "llm_artifacts": [],
+        "client_results": {},
+    }
+
+
+def append_llm_round_metrics(
+    payload: dict[str, Any],
+    *,
+    round_num: int,
+    train_loss: float,
+    validation_loss: float | None = None,
+    token_throughput: float | None = None,
+    adapter_size_bytes: int | None = None,
+) -> None:
+    """Append one global LLM round to a metrics payload in-place."""
+    llm_results = payload.setdefault("llm_results", {})
+    llm_results.setdefault("rounds", []).append(int(round_num))
+    llm_results.setdefault("train_loss", []).append(float(train_loss))
+    if validation_loss is not None:
+        llm_results.setdefault("validation_loss", []).append(float(validation_loss))
+    else:
+        llm_results.setdefault("validation_loss", [])
+    llm_results.setdefault("perplexity", []).append(_perplexity(validation_loss if validation_loss is not None else train_loss))
+    llm_results.setdefault("token_throughput", []).append(float(token_throughput) if token_throughput is not None else 0.0)
+    llm_results.setdefault("adapter_size_bytes", []).append(int(adapter_size_bytes or 0))
+
+    global_results = payload.setdefault("global_results", {})
+    global_results.setdefault("rounds", []).append(int(round_num))
+    global_results.setdefault("global_loss", []).append(float(validation_loss if validation_loss is not None else train_loss))
+    global_results.setdefault("global_accuracy", []).append(0.0)
+
+
+def _perplexity(loss: float) -> float:
+    try:
+        return float(math.exp(float(loss)))
+    except OverflowError:
+        return float("inf")
diff --git a/libs/fl_core/llm/modeling.py b/libs/fl_core/llm/modeling.py
new file mode 100644
index 0000000..c84c3da
--- /dev/null
+++ b/libs/fl_core/llm/modeling.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import importlib.util
+
+
+LLM_RUNTIME_DEPENDENCIES = ("transformers", "peft", "accelerate")
+
+
+def missing_llm_runtime_dependencies() -> list[str]:
+    """Return required LLM runtime dependencies that are not importable."""
+    return [name for name in LLM_RUNTIME_DEPENDENCIES if importlib.util.find_spec(name) is None]
+
+
+def require_llm_runtime_dependencies() -> None:
+    missing = missing_llm_runtime_dependencies()
+    if missing:
+        joined = ", ".join(missing)
+        raise RuntimeError(f"Missing LLM PEFT runtime dependencies: {joined}")
diff --git a/libs/fl_core/llm/trainer.py b/libs/fl_core/llm/trainer.py
new file mode 100644
index 0000000..4252ada
--- /dev/null
+++ b/libs/fl_core/llm/trainer.py
@@ -0,0 +1,544 @@
+from __future__ import annotations
+
+import importlib.util
+import math
+import sys
+import tempfile
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+from torch.utils.data import Dataset
+
+from .aggregation import AdapterClientUpdate
+from .config import LlmPeftRuntimeConfig
+from .data import SftRecord, format_sft_record_text
+from .modeling import require_llm_runtime_dependencies
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[3]
+
+
+class TokenizedSftDataset(Dataset):
+    """Tiny torch Dataset wrapper for tokenizer-ready SFT records."""
+
+    def __init__(
+        self,
+        records: list[SftRecord],
+        *,
+        tokenizer: Any,
+        data_format: str,
+        prompt_template: str,
+        max_seq_length: int,
+    ) -> None:
+        if not records:
+            raise ValueError("records must not be empty")
+        self._items: list[dict[str, list[int]]] = []
+        self.num_tokens = 0
+
+        for record in records:
+            text = format_sft_record_text(
+                record,
+                data_format=data_format,
+                prompt_template=prompt_template,
+            )
+            encoded = _tokenize_text(tokenizer, text, max_seq_length=max_seq_length)
+            input_ids = list(encoded.get("input_ids") or [])
+            attention_mask = list(encoded.get("attention_mask") or [1] * len(input_ids))
+            if not input_ids:
+                continue
+            labels = _labels_for_record(
+                record,
+                input_ids=input_ids,
+                tokenizer=tokenizer,
+                data_format=data_format,
+                max_seq_length=max_seq_length,
+            )
+            self.num_tokens += len(input_ids)
+            self._items.append(
+                {
+                    "input_ids": input_ids,
+                    "attention_mask": attention_mask,
+                    "labels": labels,
+                }
+            )
+
+        if not self._items:
+            raise ValueError("No non-empty tokenized SFT records")
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def __getitem__(self, index: int) -> dict[str, list[int]]:
+        return self._items[index]
+
+
+class CausalLmSftDataCollator:
+    """Pad causal-LM SFT batches while preserving label masks."""
+
+    def __init__(self, tokenizer: Any) -> None:
+        self.pad_token_id = int(getattr(tokenizer, "pad_token_id", 0) or 0)
+
+    def __call__(self, features: list[dict[str, list[int]]]) -> dict[str, torch.Tensor]:
+        max_length = max(len(feature["input_ids"]) for feature in features)
+        input_ids: list[list[int]] = []
+        attention_mask: list[list[int]] = []
+        labels: list[list[int]] = []
+
+        for feature in features:
+            pad_len = max_length - len(feature["input_ids"])
+            input_ids.append(list(feature["input_ids"]) + [self.pad_token_id] * pad_len)
+            attention_mask.append(list(feature.get("attention_mask") or [1] * len(feature["input_ids"])) + [0] * pad_len)
+            labels.append(list(feature["labels"]) + [-100] * pad_len)
+
+        return {
+            "input_ids": torch.tensor(input_ids, dtype=torch.long),
+            "attention_mask": torch.tensor(attention_mask, dtype=torch.long),
+            "labels": torch.tensor(labels, dtype=torch.long),
+        }
+
+
+@dataclass
+class LlmPeftTrainer:
+    """Training facade for a single-client Transformers/PEFT LoRA loop."""
+
+    config: LlmPeftRuntimeConfig
+
+    def ensure_ready(self) -> None:
+        """Validate that LLM runtime dependencies are installed."""
+        require_llm_runtime_dependencies()
+        if self.config.peft.quantization != "none" and importlib.util.find_spec("bitsandbytes") is None:
+            raise RuntimeError("Missing QLoRA runtime dependency: bitsandbytes")
+
+    def train_client(
+        self,
+        *,
+        client_id: int,
+        records: list[SftRecord],
+        round_num: int,
+        initial_adapter_state: dict[str, torch.Tensor] | None = None,
+        output_dir: str | Path | None = None,
+    ) -> AdapterClientUpdate:
+        """Run local LoRA SFT for one client and return adapter-only weights."""
+        self.ensure_ready()
+
+        transformers = self._transformers_module()
+        peft = self._peft_module()
+        tokenizer, model = self._build_lora_model(
+            transformers,
+            peft,
+            adapter_state=initial_adapter_state,
+        )
+
+        dataset = self._tokenized_dataset(records, tokenizer)
+        data_collator = CausalLmSftDataCollator(tokenizer)
+        estimated_steps = _estimated_train_steps(
+            num_records=len(dataset),
+            batch_size=self.config.sft.per_device_train_batch_size,
+            gradient_accumulation_steps=self.config.sft.gradient_accumulation_steps,
+            local_epochs=self.config.federated.local_epochs,
+        )
+        progress_logging_steps = _progress_logging_steps(estimated_steps)
+        print(
+            "LLM_PEFT_CLIENT_TRAINING: "
+            f"round={round_num} client={client_id} local_epochs={self.config.federated.local_epochs} "
+            f"batch_size={self.config.sft.per_device_train_batch_size} "
+            f"gradient_accumulation_steps={self.config.sft.gradient_accumulation_steps} "
+            f"estimated_steps={estimated_steps} progress_every_steps={progress_logging_steps}",
+            flush=True,
+        )
+
+        train_output_dir = Path(output_dir) if output_dir is not None else Path(tempfile.mkdtemp(prefix="figaro-llm-client-"))
+        train_output_dir.mkdir(parents=True, exist_ok=True)
+        training_args = transformers.TrainingArguments(
+            output_dir=str(train_output_dir),
+            per_device_train_batch_size=self.config.sft.per_device_train_batch_size,
+            gradient_accumulation_steps=self.config.sft.gradient_accumulation_steps,
+            num_train_epochs=self.config.federated.local_epochs,
+            learning_rate=self.config.federated.learning_rate,
+            logging_strategy="steps",
+            logging_steps=progress_logging_steps,
+            save_strategy="no",
+            disable_tqdm=True,
+            report_to=[],
+            remove_unused_columns=False,
+            fp16=self.config.llm.precision == "fp16" and torch.cuda.is_available(),
+            bf16=self.config.llm.precision == "bf16" and torch.cuda.is_available(),
+        )
+        trainer = transformers.Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=dataset,
+            data_collator=data_collator,
+            callbacks=[
+                _LlmPeftProgressCallback(
+                    round_num=round_num,
+                    client_id=client_id,
+                    total_steps=estimated_steps,
+                )
+            ],
+        )
+        _remove_default_transformers_printers(trainer, transformers)
+        train_output = trainer.train()
+        adapter_state = {
+            key: value.detach().cpu()
+            for key, value in peft.get_peft_model_state_dict(model).items()
+        }
+        train_loss = _extract_train_loss(train_output)
+        return AdapterClientUpdate(
+            adapter_state=adapter_state,
+            num_examples=len(records),
+            num_tokens=dataset.num_tokens,
+            metrics={
+                "client_id": client_id,
+                "round": round_num,
+                "train_loss": train_loss,
+                "num_examples": len(records),
+                "num_tokens": dataset.num_tokens,
+            },
+        )
+
+    def evaluate_adapter(
+        self,
+        *,
+        records: list[SftRecord],
+        adapter_state: dict[str, torch.Tensor] | None,
+        output_dir: str | Path | None = None,
+    ) -> dict[str, float]:
+        """Evaluate a global LoRA adapter on validation SFT records."""
+        self.ensure_ready()
+
+        transformers = self._transformers_module()
+        peft = self._peft_module()
+        tokenizer, model = self._build_lora_model(
+            transformers,
+            peft,
+            adapter_state=adapter_state,
+        )
+
+        dataset = self._tokenized_dataset(records, tokenizer)
+        data_collator = CausalLmSftDataCollator(tokenizer)
+
+        eval_output_dir = Path(output_dir) if output_dir is not None else Path(tempfile.mkdtemp(prefix="figaro-llm-eval-"))
+        eval_output_dir.mkdir(parents=True, exist_ok=True)
+        training_args = transformers.TrainingArguments(
+            output_dir=str(eval_output_dir),
+            per_device_eval_batch_size=self.config.evaluation.batch_size,
+            disable_tqdm=True,
+            report_to=[],
+            remove_unused_columns=False,
+            fp16=self.config.llm.precision == "fp16" and torch.cuda.is_available(),
+            bf16=self.config.llm.precision == "bf16" and torch.cuda.is_available(),
+        )
+        trainer = transformers.Trainer(
+            model=model,
+            args=training_args,
+            eval_dataset=dataset,
+            data_collator=data_collator,
+        )
+        metrics = trainer.evaluate()
+        loss = _extract_eval_loss(metrics)
+        return {
+            "validation_loss": loss,
+            "num_examples": float(len(records)),
+            "num_tokens": float(dataset.num_tokens),
+        }
+
+    def _transformers_module(self) -> Any:
+        with _without_project_root_on_sys_path():
+            transformers = __import__("transformers", fromlist=[
+                "AutoModelForCausalLM",
+                "AutoTokenizer",
+                "DataCollatorForLanguageModeling",
+                "Trainer",
+                "TrainingArguments",
+            ])
+        _quiet_transformers(transformers)
+        return transformers
+
+    def _peft_module(self) -> Any:
+        return __import__("peft", fromlist=[
+            "LoraConfig",
+            "TaskType",
+            "get_peft_model",
+            "get_peft_model_state_dict",
+            "set_peft_model_state_dict",
+            "prepare_model_for_kbit_training",
+        ])
+
+    def _build_lora_model(
+        self,
+        transformers: Any,
+        peft: Any,
+        *,
+        adapter_state: dict[str, torch.Tensor] | None = None,
+    ) -> tuple[Any, Any]:
+        tokenizer = self._load_tokenizer(transformers)
+        model = transformers.AutoModelForCausalLM.from_pretrained(
+            self.config.llm.base_model,
+            **self._model_load_kwargs(transformers),
+        )
+        if self.config.peft.quantization != "none":
+            model = peft.prepare_model_for_kbit_training(model)
+
+        lora_config = peft.LoraConfig(
+            r=self.config.peft.rank,
+            lora_alpha=self.config.peft.alpha,
+            lora_dropout=self.config.peft.dropout,
+            target_modules=list(self.config.peft.target_modules),
+            task_type=peft.TaskType.CAUSAL_LM,
+        )
+        model = peft.get_peft_model(model, lora_config)
+        if adapter_state:
+            peft.set_peft_model_state_dict(model, adapter_state)
+        return tokenizer, model
+
+    def _load_tokenizer(self, transformers: Any) -> Any:
+        tokenizer_name = self.config.llm.base_model if self.config.llm.tokenizer == "auto" else self.config.llm.tokenizer
+        tokenizer = transformers.AutoTokenizer.from_pretrained(tokenizer_name, use_fast=True)
+        if getattr(tokenizer, "pad_token", None) is None:
+            tokenizer.pad_token = getattr(tokenizer, "eos_token", None)
+        return tokenizer
+
+    def _tokenized_dataset(self, records: list[SftRecord], tokenizer: Any) -> TokenizedSftDataset:
+        return TokenizedSftDataset(
+            records,
+            tokenizer=tokenizer,
+            data_format=self.config.sft.format,
+            prompt_template=self.config.sft.prompt_template,
+            max_seq_length=self.config.llm.max_seq_length,
+        )
+
+    def _model_load_kwargs(self, transformers: Any) -> dict[str, Any]:
+        kwargs: dict[str, Any] = {}
+        dtype = self._torch_dtype()
+        if dtype is not None:
+            kwargs["dtype"] = dtype
+
+        if torch.cuda.is_available():
+            kwargs["device_map"] = "auto"
+
+        if self.config.peft.quantization == "int8":
+            kwargs["quantization_config"] = transformers.BitsAndBytesConfig(load_in_8bit=True)
+        elif self.config.peft.quantization == "nf4_4bit":
+            kwargs["quantization_config"] = transformers.BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=dtype or torch.float16,
+            )
+        return kwargs
+
+    def _torch_dtype(self):
+        if self.config.llm.precision == "fp16":
+            return torch.float16
+        if self.config.llm.precision == "bf16":
+            return torch.bfloat16
+        return None
+
+
+def _extract_train_loss(train_output: Any) -> float:
+    if hasattr(train_output, "training_loss"):
+        try:
+            return float(train_output.training_loss)
+        except (TypeError, ValueError):
+            pass
+    metrics = getattr(train_output, "metrics", None)
+    if isinstance(metrics, dict):
+        for key in ("train_loss", "loss"):
+            if key in metrics:
+                try:
+                    return float(metrics[key])
+                except (TypeError, ValueError):
+                    continue
+    return 0.0
+
+
+def _quiet_transformers(transformers: Any) -> None:
+    logging_module = getattr(transformers, "logging", None)
+    if logging_module is None:
+        return
+
+    disable_progress_bar = getattr(logging_module, "disable_progress_bar", None)
+    if callable(disable_progress_bar):
+        disable_progress_bar()
+
+    set_verbosity_error = getattr(logging_module, "set_verbosity_error", None)
+    if callable(set_verbosity_error):
+        set_verbosity_error()
+
+
+class _LlmPeftProgressCallback:
+    def __init__(self, *, round_num: int, client_id: int, total_steps: int) -> None:
+        self.round_num = round_num
+        self.client_id = client_id
+        self.total_steps = total_steps
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("on_"):
+            return _noop_trainer_callback
+        raise AttributeError(name)
+
+    def on_log(self, args: Any, state: Any, control: Any, logs: dict[str, Any] | None = None, **kwargs: Any) -> None:
+        if not logs:
+            return
+        step = int(getattr(state, "global_step", 0) or 0)
+        max_steps = int(getattr(state, "max_steps", 0) or self.total_steps or 0)
+        parts = [
+            "LLM_PEFT_TRAIN_PROGRESS:",
+            f"round={self.round_num}",
+            f"client={self.client_id}",
+            f"step={step}/{max_steps}" if max_steps else f"step={step}",
+        ]
+
+        epoch = _optional_float(logs.get("epoch"))
+        if epoch is not None:
+            parts.append(f"local_epoch={epoch:.3f}")
+        loss = _optional_float(logs.get("loss"))
+        if loss is not None:
+            parts.append(f"loss={loss:.6f}")
+        learning_rate = _optional_float(logs.get("learning_rate"))
+        if learning_rate is not None:
+            parts.append(f"learning_rate={learning_rate:.6g}")
+        print(" ".join(parts), flush=True)
+
+
+def _noop_trainer_callback(*args: Any, **kwargs: Any) -> None:
+    return None
+
+
+def _remove_default_transformers_printers(trainer: Any, transformers: Any) -> None:
+    for callback_name in ("PrinterCallback", "ProgressCallback"):
+        callback_cls = getattr(transformers, callback_name, None)
+        if callback_cls is None:
+            continue
+        try:
+            trainer.remove_callback(callback_cls)
+        except (AttributeError, ValueError):
+            continue
+
+
+def _estimated_train_steps(
+    *,
+    num_records: int,
+    batch_size: int,
+    gradient_accumulation_steps: int,
+    local_epochs: int,
+) -> int:
+    effective_batch_size = max(1, int(batch_size)) * max(1, int(gradient_accumulation_steps))
+    steps_per_epoch = math.ceil(max(1, int(num_records)) / effective_batch_size)
+    return max(1, steps_per_epoch * max(1, int(local_epochs)))
+
+
+def _progress_logging_steps(total_steps: int) -> int:
+    return max(10, min(500, max(1, int(total_steps)) // 20 or 1))
+
+
+def _optional_float(value: Any) -> float | None:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _tokenize_text(
+    tokenizer: Any,
+    text: str,
+    *,
+    max_seq_length: int,
+    add_special_tokens: bool | None = None,
+) -> dict[str, Any]:
+    kwargs: dict[str, Any] = {
+        "truncation": True,
+        "max_length": max_seq_length,
+        "padding": False,
+    }
+    if add_special_tokens is not None:
+        kwargs["add_special_tokens"] = add_special_tokens
+    try:
+        return tokenizer(text, **kwargs)
+    except TypeError:
+        kwargs.pop("add_special_tokens", None)
+        return tokenizer(text, **kwargs)
+
+
+def _labels_for_record(
+    record: SftRecord,
+    *,
+    input_ids: list[int],
+    tokenizer: Any,
+    data_format: str,
+    max_seq_length: int,
+) -> list[int]:
+    labels = list(input_ids)
+    if data_format not in {"prompt_completion", "alpaca"}:
+        return labels
+
+    prompt_text = record.prompt or ""
+    if not prompt_text:
+        return labels
+
+    prompt_encoded = _tokenize_text(
+        tokenizer,
+        prompt_text,
+        max_seq_length=max_seq_length,
+        add_special_tokens=False,
+    )
+    prompt_length = min(len(list(prompt_encoded.get("input_ids") or [])), len(labels))
+    for index in range(prompt_length):
+        labels[index] = -100
+    return labels
+
+
+def _extract_eval_loss(metrics: Any) -> float:
+    if isinstance(metrics, dict):
+        for key in ("eval_loss", "validation_loss", "loss"):
+            if key in metrics:
+                try:
+                    return float(metrics[key])
+                except (TypeError, ValueError):
+                    continue
+    return 0.0
+
+
+@contextmanager
+def _without_project_root_on_sys_path():
+    """Avoid shadowing optional third-party packages with repo data directories."""
+    original_path = list(sys.path)
+    sys.path[:] = [
+        entry
+        for entry in original_path
+        if _resolve_sys_path_entry(entry) != PROJECT_ROOT
+    ]
+    _drop_local_datasets_module()
+    try:
+        yield
+    finally:
+        sys.path[:] = original_path
+
+
+def _resolve_sys_path_entry(entry: str) -> Path | None:
+    try:
+        return Path(entry or ".").resolve()
+    except OSError:
+        return None
+
+
+def _drop_local_datasets_module() -> None:
+    module = sys.modules.get("datasets")
+    if module is None:
+        return
+
+    module_paths = [getattr(module, "__file__", None)]
+    module_paths.extend(list(getattr(module, "__path__", []) or []))
+    for value in module_paths:
+        if value is None:
+            continue
+        try:
+            path = Path(value).resolve()
+        except OSError:
+            continue
+        if path == PROJECT_ROOT / "datasets" or path.is_relative_to(PROJECT_ROOT / "datasets"):
+            sys.modules.pop("datasets", None)
+            return
diff --git a/libs/fl_core/models/__init__.py b/libs/fl_core/models/__init__.py
index ca9209e..36cd1e7 100644
--- a/libs/fl_core/models/__init__.py
+++ b/libs/fl_core/models/__init__.py
@@ -3,6 +3,15 @@
 
 from .lenet import LeNet, LeNetCIFAR
 from .cnn import SimpleCNN, DeepCNN, CNNMNIST
+from .basic import (
+    MclrLogistic,
+    DNN,
+    FedAvgCNN,
+    TextLogistic,
+    TextDNN,
+    TextCNN,
+    CharLSTM,
+)
 from .resnet import (
     ResNet18, ResNet34, ResNet50,
     ResNet18CIFAR, ResNet34CIFAR,
@@ -12,9 +21,11 @@
 
 __all__ = [
     'LeNet', 'LeNetCIFAR',
+    'MclrLogistic', 'DNN', 'FedAvgCNN',
+    'TextLogistic', 'TextDNN', 'TextCNN', 'CharLSTM',
     'SimpleCNN', 'DeepCNN', 'CNNMNIST',
     'ResNet18', 'ResNet34', 'ResNet50',
     'ResNet18CIFAR', 'ResNet34CIFAR',
     'ResNet18MNIST',
     'ModelManager'
-]
\ No newline at end of file
+]
diff --git a/libs/fl_core/models/basic.py b/libs/fl_core/models/basic.py
new file mode 100644
index 0000000..71304a5
--- /dev/null
+++ b/libs/fl_core/models/basic.py
@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def _flatten_dim(input_shape: tuple[int, ...] | list[int] | int | None, input_channels: int = 1) -> int:
+    if isinstance(input_shape, int):
+        return input_shape
+    if input_shape:
+        total = 1
+        for dim in input_shape:
+            total *= int(dim)
+        return total
+    return int(input_channels) * 28 * 28
+
+
+class MclrLogistic(nn.Module):
+    def __init__(
+        self,
+        num_classes: int = 10,
+        input_channels: int = 1,
+        input_shape: tuple[int, ...] | list[int] | int | None = None,
+        input_dim: int | None = None,
+    ):
+        super().__init__()
+        self.input_dim = int(input_dim or _flatten_dim(input_shape, input_channels))
+        self.linear = nn.Linear(self.input_dim, num_classes)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.linear(x.view(x.size(0), -1).float())
+
+
+class DNN(nn.Module):
+    def __init__(
+        self,
+        num_classes: int = 10,
+        input_channels: int = 1,
+        input_shape: tuple[int, ...] | list[int] | int | None = None,
+        input_dim: int | None = None,
+        hidden_dim: int = 100,
+    ):
+        super().__init__()
+        self.input_dim = int(input_dim or _flatten_dim(input_shape, input_channels))
+        self.fc1 = nn.Linear(self.input_dim, hidden_dim)
+        self.fc2 = nn.Linear(hidden_dim, num_classes)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = x.view(x.size(0), -1).float()
+        x = F.relu(self.fc1(x))
+        return self.fc2(x)
+
+
+class FedAvgCNN(nn.Module):
+    def __init__(self, num_classes: int = 10, input_channels: int = 3):
+        super().__init__()
+        self.conv1 = nn.Conv2d(input_channels, 32, kernel_size=5, padding=2)
+        self.conv2 = nn.Conv2d(32, 64, kernel_size=5, padding=2)
+        self.pool = nn.MaxPool2d(2)
+        self.adaptive_pool = nn.AdaptiveAvgPool2d((4, 4))
+        self.fc1 = nn.Linear(64 * 4 * 4, 512)
+        self.fc2 = nn.Linear(512, num_classes)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.pool(F.relu(self.conv1(x.float())))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = self.adaptive_pool(x)
+        x = x.view(x.size(0), -1)
+        x = F.relu(self.fc1(x))
+        return self.fc2(x)
+
+
+class TextLogistic(MclrLogistic):
+    pass
+
+
+class TextDNN(DNN):
+    pass
+
+
+class TextCNN(nn.Module):
+    def __init__(
+        self,
+        num_classes: int = 4,
+        input_dim: int = 5000,
+        hidden_dim: int = 128,
+    ):
+        super().__init__()
+        self.input_dim = int(input_dim)
+        self.conv1 = nn.Conv1d(1, 64, kernel_size=5, padding=2)
+        self.conv2 = nn.Conv1d(64, hidden_dim, kernel_size=5, padding=2)
+        self.pool = nn.AdaptiveMaxPool1d(1)
+        self.fc = nn.Linear(hidden_dim, num_classes)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = x.view(x.size(0), 1, -1).float()
+        x = F.relu(self.conv1(x))
+        x = F.relu(self.conv2(x))
+        x = self.pool(x).squeeze(-1)
+        return self.fc(x)
+
+
+class CharLSTM(nn.Module):
+    def __init__(
+        self,
+        num_classes: int = 128,
+        vocab_size: int = 128,
+        embed_dim: int = 32,
+        hidden_dim: int = 128,
+    ):
+        super().__init__()
+        self.vocab_size = int(vocab_size)
+        self.embedding = nn.Embedding(self.vocab_size, embed_dim)
+        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True)
+        self.fc = nn.Linear(hidden_dim, num_classes)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        token_ids = x.long().clamp(min=0, max=self.vocab_size - 1)
+        embedded = self.embedding(token_ids)
+        _, (hidden, _) = self.lstm(embedded)
+        return self.fc(hidden[-1])
diff --git a/libs/fl_core/models/model_manager.py b/libs/fl_core/models/model_manager.py
index c00579e..bdf3447 100644
--- a/libs/fl_core/models/model_manager.py
+++ b/libs/fl_core/models/model_manager.py
@@ -1,105 +1,237 @@
-import torch
-import torch.nn as nn
+from __future__ import annotations
+
 import copy
 import pickle
-from typing import Dict, Any, Optional, Union
-from collections import OrderedDict
+from typing import Any, Dict, Optional
+
+import torch
+import torch.nn as nn
 
+from fl_core.simulation_registry import canonical_model_name, list_model_names
+
+from .basic import (
+    CharLSTM,
+    DNN,
+    FedAvgCNN,
+    MclrLogistic,
+    TextCNN,
+    TextDNN,
+    TextLogistic,
+)
+from .cnn import CNNMNIST, DeepCNN, SimpleCNN
 from .lenet import LeNet, LeNetCIFAR
-from .cnn import SimpleCNN, DeepCNN, CNNMNIST
 from .resnet import (
-    ResNet18, ResNet34, ResNet50,
-    ResNet18CIFAR, ResNet34CIFAR,
-    ResNet18MNIST
+    ResNet18,
+    ResNet18CIFAR,
+    ResNet18MNIST,
+    ResNet34,
+    ResNet34CIFAR,
+    ResNet50,
 )
 
 
 class ModelManager:
-    
     def __init__(self, config: Dict[str, Any]):
         self.config = config
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        
-        self.model_registry = {
-            'lenet': LeNet,
-            'lenet_cifar': LeNetCIFAR,
-            
-            'cnn': SimpleCNN,
-            'simple_cnn': SimpleCNN,
-            'deep_cnn': DeepCNN,
-            'cnn_mnist': CNNMNIST,
-            
-            'resnet18': ResNet18,
-            'resnet34': ResNet34,
-            'resnet50': ResNet50,
-            'resnet18_cifar': ResNet18CIFAR,
-            'resnet34_cifar': ResNet34CIFAR,
-            'resnet18_mnist': ResNet18MNIST,
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+        self.model_registry: dict[str, Any] = {
+            "mclr_logistic": MclrLogistic,
+            "mclr": MclrLogistic,
+            "logistic": MclrLogistic,
+            "logistic_regression": MclrLogistic,
+            "dnn": DNN,
+            "mlp": DNN,
+            "fedavgcnn": FedAvgCNN,
+            "fedavg_cnn": FedAvgCNN,
+            "lenet": LeNet,
+            "lenet_cifar": LeNetCIFAR,
+            "cnn": SimpleCNN,
+            "simple_cnn": SimpleCNN,
+            "deep_cnn": DeepCNN,
+            "cnn_mnist": CNNMNIST,
+            "resnet18": ResNet18,
+            "resnet34": ResNet34,
+            "resnet50": ResNet50,
+            "resnet18_cifar": ResNet18CIFAR,
+            "resnet34_cifar": ResNet34CIFAR,
+            "resnet18_mnist": ResNet18MNIST,
+            "alexnet": "torchvision_alexnet",
+            "mobilenet": "torchvision_mobilenet_v2",
+            "mobilenet_v2": "torchvision_mobilenet_v2",
+            "mobilenetv2": "torchvision_mobilenet_v2",
+            "googlenet": "torchvision_googlenet",
+            "google_net": "torchvision_googlenet",
+            "textlogistic": TextLogistic,
+            "text_logistic": TextLogistic,
+            "textdnn": TextDNN,
+            "text_dnn": TextDNN,
+            "textcnn": TextCNN,
+            "text_cnn": TextCNN,
+            "charlstm": CharLSTM,
+            "char_lstm": CharLSTM,
+            "char_rnn": CharLSTM,
         }
-    
-    def create_model(self, model_name: str, input_shape: tuple, num_classes: int) -> nn.Module:
-        model_name_lower = model_name.lower()
-        
-        if model_name_lower not in self.model_registry:
-            raise ValueError(f"不支持的模型类型: {model_name}. 支持的模型: {list(self.model_registry.keys())}")
-        
-        model_class = self.model_registry[model_name_lower]
-        input_channels = input_shape[0] if len(input_shape) == 3 else 1
-        
-        if model_name_lower == 'lenet':
-            if input_shape[1:] == (32, 32):  # CIFAR数据集
+
+    def create_model(
+        self,
+        model_name: str,
+        input_shape: tuple,
+        num_classes: int,
+        dataset_info: Optional[Dict[str, Any]] = None,
+    ) -> nn.Module:
+        canonical_name = canonical_model_name(model_name)
+        registry_key = canonical_name.lower().replace("-", "_")
+
+        if registry_key not in self.model_registry:
+            raise ValueError(
+                f"Unsupported model type: {model_name}. "
+                f"Supported models: {list(self.model_registry.keys())}"
+            )
+
+        model_class = self.model_registry[registry_key]
+        dataset_info = dataset_info or {}
+        input_shape_tuple = tuple(input_shape or ())
+        input_channels = input_shape_tuple[0] if len(input_shape_tuple) == 3 else 1
+        input_dim = self._flatten_dim(input_shape_tuple)
+        modality = dataset_info.get("modality", "image")
+
+        if registry_key == "lenet":
+            if len(input_shape_tuple) == 3 and input_shape_tuple[1:] == (32, 32):
                 model = LeNetCIFAR(num_classes=num_classes, input_channels=input_channels)
-            else:  # MNIST数据集
+            else:
                 model = LeNet(num_classes=num_classes, input_channels=input_channels)
-        elif model_name_lower in ['cnn', 'simple_cnn']:
-            if input_shape[1:] == (28, 28):  # MNIST数据集
+        elif registry_key == "fedavgcnn":
+            model = FedAvgCNN(num_classes=num_classes, input_channels=input_channels)
+        elif registry_key in {"cnn", "simple_cnn"}:
+            if len(input_shape_tuple) == 3 and input_shape_tuple[1:] == (28, 28):
                 model = CNNMNIST(num_classes=num_classes, input_channels=input_channels)
-            else:  # CIFAR数据集
+            else:
                 model = SimpleCNN(num_classes=num_classes, input_channels=input_channels)
-        elif model_name_lower == 'resnet18':
-            if input_shape[1:] == (32, 32):  # CIFAR数据集
+        elif registry_key == "resnet18":
+            if len(input_shape_tuple) == 3 and input_shape_tuple[1:] == (32, 32):
                 model = ResNet18CIFAR(num_classes=num_classes, input_channels=input_channels)
-            elif input_shape[1:] == (28, 28):  # MNIST数据集
+            elif len(input_shape_tuple) == 3 and input_shape_tuple[1:] == (28, 28):
                 model = ResNet18MNIST(num_classes=num_classes, input_channels=input_channels)
-            else:  # 标准ImageNet尺寸
+            else:
                 model = ResNet18(num_classes=num_classes, input_channels=input_channels)
+        elif registry_key in {"mclr_logistic", "mclr", "logistic", "logistic_regression"}:
+            model = MclrLogistic(num_classes=num_classes, input_shape=input_shape_tuple, input_dim=input_dim)
+        elif registry_key in {"dnn", "mlp"}:
+            model = DNN(
+                num_classes=num_classes,
+                input_shape=input_shape_tuple,
+                input_dim=input_dim,
+                hidden_dim=int(self.config.get("hidden_dim", 100)),
+            )
+        elif registry_key in {"textlogistic", "text_logistic"}:
+            model = TextLogistic(
+                num_classes=num_classes,
+                input_dim=input_dim or int(dataset_info.get("feature_dim", 5000)),
+            )
+        elif registry_key in {"textdnn", "text_dnn"}:
+            model = TextDNN(
+                num_classes=num_classes,
+                input_dim=input_dim or int(dataset_info.get("feature_dim", 5000)),
+                hidden_dim=int(self.config.get("hidden_dim", 100)),
+            )
+        elif registry_key in {"textcnn", "text_cnn"}:
+            model = TextCNN(
+                num_classes=num_classes,
+                input_dim=input_dim or int(dataset_info.get("feature_dim", 5000)),
+            )
+        elif registry_key in {"charlstm", "char_lstm", "char_rnn"}:
+            model = CharLSTM(
+                num_classes=num_classes,
+                vocab_size=int(dataset_info.get("vocab_size", num_classes)),
+                hidden_dim=int(self.config.get("hidden_dim", 128)),
+            )
+        elif isinstance(model_class, str) and model_class.startswith("torchvision_"):
+            if modality != "image":
+                raise ValueError(f"{canonical_name} only supports image datasets")
+            model = self._create_torchvision_model(model_class, num_classes, input_channels)
         else:
-            # 直接使用指定的模型类
-            model = model_class(num_classes=num_classes, input_channels=input_channels)
-        
+            try:
+                model = model_class(num_classes=num_classes, input_channels=input_channels)
+            except TypeError:
+                model = model_class(num_classes=num_classes)
+
         model.to(self.device)
         return model
-    
+
+    @staticmethod
+    def _flatten_dim(input_shape: tuple) -> Optional[int]:
+        if not input_shape:
+            return None
+        total = 1
+        for dim in input_shape:
+            total *= int(dim)
+        return total
+
+    def _create_torchvision_model(self, model_key: str, num_classes: int, input_channels: int) -> nn.Module:
+        import torchvision.models as tv_models
+
+        if model_key == "torchvision_alexnet":
+            model = tv_models.alexnet(weights=None, num_classes=num_classes)
+            if input_channels != 3:
+                model.features[0] = nn.Conv2d(input_channels, 64, kernel_size=11, stride=4, padding=2)
+            return model
+
+        if model_key == "torchvision_mobilenet_v2":
+            model = tv_models.mobilenet_v2(weights=None, num_classes=num_classes)
+            if input_channels != 3:
+                model.features[0][0] = nn.Conv2d(
+                    input_channels,
+                    32,
+                    kernel_size=3,
+                    stride=2,
+                    padding=1,
+                    bias=False,
+                )
+            return model
+
+        if model_key == "torchvision_googlenet":
+            model = tv_models.googlenet(weights=None, aux_logits=False, num_classes=num_classes)
+            if input_channels != 3:
+                model.conv1.conv = nn.Conv2d(
+                    input_channels,
+                    64,
+                    kernel_size=7,
+                    stride=2,
+                    padding=3,
+                    bias=False,
+                )
+            return model
+
+        raise ValueError(f"Unsupported torchvision model key: {model_key}")
+
     def get_model_parameters(self, model: nn.Module) -> Dict[str, torch.Tensor]:
         return {name: param.clone().detach() for name, param in model.named_parameters()}
-    
+
     def get_model_state_dict(self, model: nn.Module) -> Dict[str, torch.Tensor]:
         return {name: param.clone().detach() for name, param in model.state_dict().items()}
-    
+
     def set_model_parameters(self, model: nn.Module, parameters: Dict[str, torch.Tensor]) -> None:
         model_dict = model.state_dict()
-        
-        # 验证参数键是否匹配
+
         param_keys = set(parameters.keys())
         model_keys = set(model_dict.keys())
-        
         if param_keys != model_keys:
             missing_keys = model_keys - param_keys
             unexpected_keys = param_keys - model_keys
-            
             if missing_keys:
-                print(f"警告: 缺少参数键: {missing_keys}")
+                print(f"Warning: missing parameter keys: {missing_keys}")
             if unexpected_keys:
-                print(f"警告: 意外的参数键: {unexpected_keys}")
-        
+                print(f"Warning: unexpected parameter keys: {unexpected_keys}")
+
         for name, param in parameters.items():
             if name in model_dict:
                 model_dict[name].copy_(param.to(self.device))
-    
+
     def set_model_state_dict(self, model: nn.Module, state_dict: Dict[str, torch.Tensor]) -> None:
         device_state_dict = {name: param.to(self.device) for name, param in state_dict.items()}
         model.load_state_dict(device_state_dict)
-    
+
     def get_model_gradients(self, model: nn.Module) -> Dict[str, torch.Tensor]:
         gradients = {}
         for name, param in model.named_parameters():
@@ -108,7 +240,7 @@ def get_model_gradients(self, model: nn.Module) -> Dict[str, torch.Tensor]:
             else:
                 gradients[name] = torch.zeros_like(param)
         return gradients
-    
+
     def set_model_gradients(self, model: nn.Module, gradients: Dict[str, torch.Tensor]) -> None:
         for name, param in model.named_parameters():
             if name in gradients:
@@ -116,68 +248,68 @@ def set_model_gradients(self, model: nn.Module, gradients: Dict[str, torch.Tenso
                     param.grad = gradients[name].clone().to(self.device)
                 else:
                     param.grad.copy_(gradients[name].to(self.device))
-    
+
     def serialize_parameters(self, parameters: Dict[str, torch.Tensor]) -> bytes:
         cpu_parameters = {name: param.cpu() for name, param in parameters.items()}
         return pickle.dumps(cpu_parameters)
-    
+
     def deserialize_parameters(self, data: bytes) -> Dict[str, torch.Tensor]:
         parameters = pickle.loads(data)
         return {name: param.to(self.device) for name, param in parameters.items()}
-    
+
     def save_model(self, model: nn.Module, filepath: str) -> None:
-        torch.save({
-            'model_state_dict': model.state_dict(),
-            'model_config': self.config,
-            'model_class': model.__class__.__name__
-        }, filepath)
-    
+        torch.save(
+            {
+                "model_state_dict": model.state_dict(),
+                "model_config": self.config,
+                "model_class": model.__class__.__name__,
+            },
+            filepath,
+        )
+
     def load_model(self, filepath: str, model_name: str, input_shape: tuple, num_classes: int) -> nn.Module:
         checkpoint = torch.load(filepath, map_location=self.device)
-        
         model = self.create_model(model_name, input_shape, num_classes)
-        
-        model.load_state_dict(checkpoint['model_state_dict'])
-        
+        model.load_state_dict(checkpoint["model_state_dict"])
         return model
-    
+
     def clone_model(self, model: nn.Module) -> nn.Module:
         cloned_model = copy.deepcopy(model)
         cloned_model.to(self.device)
         return cloned_model
-    
+
     def get_model_size(self, model: nn.Module) -> int:
         return sum(p.numel() for p in model.parameters())
-    
+
     def get_trainable_parameters(self, model: nn.Module) -> int:
         return sum(p.numel() for p in model.parameters() if p.requires_grad)
-    
+
     def freeze_layers(self, model: nn.Module, layer_names: list) -> None:
         for name, param in model.named_parameters():
             if any(layer_name in name for layer_name in layer_names):
                 param.requires_grad = False
-    
+
     def unfreeze_layers(self, model: nn.Module, layer_names: list) -> None:
         for name, param in model.named_parameters():
             if any(layer_name in name for layer_name in layer_names):
                 param.requires_grad = True
-    
+
     def get_supported_models(self) -> list:
-        return list(self.model_registry.keys())
-    
+        return list_model_names()
+
     def model_summary(self, model: nn.Module, input_shape: tuple) -> str:
         total_params = self.get_model_size(model)
         trainable_params = self.get_trainable_parameters(model)
-        
+
         summary = f"""
-模型摘要:
+Model summary:
 ========
-模型类型: {model.__class__.__name__}
-输入形状: {input_shape}
-总参数数: {total_params:,}
-可训练参数: {trainable_params:,}
-设备: {self.device}
+Model type: {model.__class__.__name__}
+Input shape: {input_shape}
+Total parameters: {total_params:,}
+Trainable parameters: {trainable_params:,}
+Device: {self.device}
 ========
         """
-        
-        return summary.strip()
\ No newline at end of file
+
+        return summary.strip()
diff --git a/libs/fl_core/models/resnet.py b/libs/fl_core/models/resnet.py
index cfc8c2d..6445c4a 100644
--- a/libs/fl_core/models/resnet.py
+++ b/libs/fl_core/models/resnet.py
@@ -88,7 +88,7 @@ def forward(self, x):
         out = self.layer2(out)
         out = self.layer3(out)
         out = self.layer4(out)
-        out = F.avg_pool2d(out, 4)
+        out = F.adaptive_avg_pool2d(out, 1)
         out = out.view(out.size(0), -1)
         out = self.linear(out)
         return out
@@ -138,7 +138,7 @@ def forward(self, x):
         out = self.layer1(out)
         out = self.layer2(out)
         out = self.layer3(out)
-        out = F.avg_pool2d(out, 8)
+        out = F.adaptive_avg_pool2d(out, 1)
         out = out.view(out.size(0), -1)
         out = self.linear(out)
         return out
@@ -185,7 +185,7 @@ def forward(self, x):
         out = self.layer1(out)
         out = self.layer2(out)
         out = self.layer3(out)
-        out = F.avg_pool2d(out, 7)
+        out = F.adaptive_avg_pool2d(out, 1)
         out = out.view(out.size(0), -1)
         out = self.linear(out)
         return out
@@ -195,4 +195,4 @@ def get_feature_dim(self):
 
 
 def ResNet18MNIST(num_classes=10, input_channels=1):
-    return ResNetMNIST(BasicBlock, [2, 2, 2], num_classes, input_channels)
\ No newline at end of file
+    return ResNetMNIST(BasicBlock, [2, 2, 2], num_classes, input_channels)
diff --git a/libs/fl_core/privacy/__init__.py b/libs/fl_core/privacy/__init__.py
index e69de29..ee404a8 100644
--- a/libs/fl_core/privacy/__init__.py
+++ b/libs/fl_core/privacy/__init__.py
@@ -0,0 +1,9 @@
+from .differential_privacy import DifferentialPrivacyManager
+from .encryption import CKKSManager
+from .secure_aggregation import SecureAggregationMasker
+
+__all__ = [
+    "CKKSManager",
+    "DifferentialPrivacyManager",
+    "SecureAggregationMasker",
+]
diff --git a/libs/fl_core/privacy/differential_privacy.py b/libs/fl_core/privacy/differential_privacy.py
new file mode 100644
index 0000000..19d81f2
--- /dev/null
+++ b/libs/fl_core/privacy/differential_privacy.py
@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import logging
+from typing import Dict
+
+import torch
+
+
+def _is_trainable_float(name: str, tensor: torch.Tensor) -> bool:
+    return (
+        tensor.is_floating_point()
+        and tensor.dim() > 0
+        and "num_batches_tracked" not in name
+        and "running_" not in name
+    )
+
+
+class DifferentialPrivacyManager:
+    def __init__(self, clipping_norm: float = 1.0, noise_multiplier: float = 0.0):
+        self.clipping_norm = float(clipping_norm)
+        self.noise_multiplier = float(noise_multiplier)
+        self.logger = logging.getLogger("DifferentialPrivacyManager")
+
+    def apply(self, update_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
+        trainable = {
+            name: tensor
+            for name, tensor in update_dict.items()
+            if _is_trainable_float(name, tensor)
+        }
+        if not trainable:
+            return update_dict
+
+        total_norm = torch.sqrt(
+            sum(torch.sum(tensor.detach() ** 2) for tensor in trainable.values())
+        )
+        clip_factor = min(1.0, self.clipping_norm / (total_norm.item() + 1e-12))
+        noise_std = self.noise_multiplier * self.clipping_norm
+
+        protected = {}
+        for name, tensor in update_dict.items():
+            if not _is_trainable_float(name, tensor):
+                protected[name] = tensor
+                continue
+            value = tensor * clip_factor
+            if noise_std > 0:
+                value = value + torch.normal(
+                    mean=0.0,
+                    std=noise_std,
+                    size=tensor.shape,
+                    device=tensor.device,
+                    dtype=tensor.dtype,
+                )
+            protected[name] = value
+        return protected
diff --git a/libs/fl_core/privacy/secure_aggregation.py b/libs/fl_core/privacy/secure_aggregation.py
new file mode 100644
index 0000000..4d4e501
--- /dev/null
+++ b/libs/fl_core/privacy/secure_aggregation.py
@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import logging
+from typing import Dict, List
+
+import torch
+
+
+def _is_trainable_float(name: str, tensor: torch.Tensor) -> bool:
+    return (
+        tensor.is_floating_point()
+        and tensor.dim() > 0
+        and "num_batches_tracked" not in name
+        and "running_" not in name
+    )
+
+
+class SecureAggregationMasker:
+    """
+    Simulation-only additive masking.
+
+    Masks are generated so their unweighted sum is zero. This is suitable for
+    equal-weight FedAvg/simple average in local simulation; it is intentionally
+    not a production secure aggregation protocol.
+    """
+
+    def __init__(self, mask_std: float = 1.0):
+        self.mask_std = float(mask_std)
+        self.logger = logging.getLogger("SecureAggregationMasker")
+
+    def mask_models(self, updates: List[Dict[str, torch.Tensor]]) -> List[Dict[str, torch.Tensor]]:
+        if len(updates) <= 1 or self.mask_std <= 0:
+            return updates
+
+        masked = [{name: tensor.clone() for name, tensor in update.items()} for update in updates]
+        reference = updates[0]
+
+        for name, tensor in reference.items():
+            if not _is_trainable_float(name, tensor):
+                continue
+            running_sum = torch.zeros_like(tensor)
+            for idx in range(len(updates) - 1):
+                mask = torch.normal(
+                    mean=0.0,
+                    std=self.mask_std,
+                    size=tensor.shape,
+                    device=tensor.device,
+                    dtype=tensor.dtype,
+                )
+                masked[idx][name] = masked[idx][name] + mask
+                running_sum = running_sum + mask
+            masked[-1][name] = masked[-1][name] - running_sum
+
+        return masked
diff --git a/libs/fl_core/simulation_registry.py b/libs/fl_core/simulation_registry.py
new file mode 100644
index 0000000..1f71563
--- /dev/null
+++ b/libs/fl_core/simulation_registry.py
@@ -0,0 +1,528 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class DatasetSpec:
+    name: str
+    aliases: tuple[str, ...]
+    modality: str
+    task_type: str
+    input_shape: tuple[int, ...]
+    num_classes: int
+    default_model: str
+    compatible_models: tuple[str, ...]
+    supported_splits: tuple[str, ...] = ("iid", "non_iid")
+    loader: str = "torchvision"
+    requires_local_data: bool = False
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class ModelSpec:
+    name: str
+    aliases: tuple[str, ...]
+    modalities: tuple[str, ...]
+    task_types: tuple[str, ...]
+    description: str = ""
+
+
+LINEAR_AGGREGATIONS = ("fedavg", "weighted_avg", "simple_avg")
+EQUAL_WEIGHT_AGGREGATIONS = ("fedavg", "simple_avg")
+EXECUTABLE_AGGREGATIONS = (*LINEAR_AGGREGATIONS,)
+COMPRESSION_METHODS = ("global_topk", "random_k", "threshold", "sign", "quant_int8")
+
+
+MODEL_SPECS: tuple[ModelSpec, ...] = (
+    ModelSpec(
+        name="Mclr_Logistic",
+        aliases=("mclr", "logistic", "logistic_regression", "MCLR"),
+        modalities=("image", "text"),
+        task_types=("classification",),
+        description="Multiclass logistic regression over flattened features.",
+    ),
+    ModelSpec(
+        name="LeNet",
+        aliases=("lenet",),
+        modalities=("image",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="DNN",
+        aliases=("dnn", "mlp"),
+        modalities=("image", "text"),
+        task_types=("classification",),
+        description="Two-layer dense network with configurable flattened input.",
+    ),
+    ModelSpec(
+        name="FedAvgCNN",
+        aliases=("cnn", "simple_cnn", "fedavg_cnn"),
+        modalities=("image",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="ResNet18",
+        aliases=("resnet", "resnet18"),
+        modalities=("image",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="ResNet34",
+        aliases=("resnet34",),
+        modalities=("image",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="ResNet50",
+        aliases=("resnet50",),
+        modalities=("image",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="AlexNet",
+        aliases=("alexnet",),
+        modalities=("image",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="MobileNet",
+        aliases=("mobilenet", "mobilenet_v2", "mobilenetv2"),
+        modalities=("image",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="GoogleNet",
+        aliases=("googlenet", "google_net"),
+        modalities=("image",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="TextLogistic",
+        aliases=("text_logistic",),
+        modalities=("text",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="TextDNN",
+        aliases=("text_dnn",),
+        modalities=("text",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="TextCNN",
+        aliases=("text_cnn",),
+        modalities=("text",),
+        task_types=("classification",),
+    ),
+    ModelSpec(
+        name="CharLSTM",
+        aliases=("char_lstm", "lstm", "char_rnn"),
+        modalities=("sequence",),
+        task_types=("next_char",),
+    ),
+)
+
+
+DIGIT_MODELS = ("Mclr_Logistic", "LeNet", "DNN")
+SMALL_IMAGE_MODELS = (
+    "Mclr_Logistic",
+    "FedAvgCNN",
+    "DNN",
+    "ResNet18",
+    "AlexNet",
+    "MobileNet",
+    "GoogleNet",
+)
+GENERAL_IMAGE_MODELS = (
+    "FedAvgCNN",
+    "DNN",
+    "ResNet18",
+    "ResNet34",
+    "AlexNet",
+    "MobileNet",
+    "GoogleNet",
+)
+TEXT_MODELS = ("TextLogistic", "TextDNN", "TextCNN")
+SEQUENCE_MODELS = ("CharLSTM",)
+
+
+DATASET_SPECS: tuple[DatasetSpec, ...] = (
+    DatasetSpec(
+        name="MNIST",
+        aliases=("mnist",),
+        modality="image",
+        task_type="classification",
+        input_shape=(1, 28, 28),
+        num_classes=10,
+        default_model="LeNet",
+        compatible_models=DIGIT_MODELS,
+    ),
+    DatasetSpec(
+        name="EMNIST",
+        aliases=("emnist",),
+        modality="image",
+        task_type="classification",
+        input_shape=(1, 28, 28),
+        num_classes=47,
+        default_model="LeNet",
+        compatible_models=DIGIT_MODELS,
+        metadata={"split": "balanced"},
+    ),
+    DatasetSpec(
+        name="FEMNIST",
+        aliases=("femnist",),
+        modality="image",
+        task_type="classification",
+        input_shape=(1, 28, 28),
+        num_classes=62,
+        default_model="LeNet",
+        compatible_models=DIGIT_MODELS,
+        loader="leaf_femnist",
+        requires_local_data=True,
+    ),
+    DatasetSpec(
+        name="Fashion-MNIST",
+        aliases=("fashion-mnist", "fashion_mnist", "fashionmnist"),
+        modality="image",
+        task_type="classification",
+        input_shape=(1, 28, 28),
+        num_classes=10,
+        default_model="LeNet",
+        compatible_models=DIGIT_MODELS,
+    ),
+    DatasetSpec(
+        name="CIFAR-10",
+        aliases=("cifar10", "cifar-10", "Cifar10"),
+        modality="image",
+        task_type="classification",
+        input_shape=(3, 32, 32),
+        num_classes=10,
+        default_model="FedAvgCNN",
+        compatible_models=SMALL_IMAGE_MODELS,
+    ),
+    DatasetSpec(
+        name="CIFAR-100",
+        aliases=("cifar100", "cifar-100", "Cifar100"),
+        modality="image",
+        task_type="classification",
+        input_shape=(3, 32, 32),
+        num_classes=100,
+        default_model="FedAvgCNN",
+        compatible_models=SMALL_IMAGE_MODELS,
+    ),
+    DatasetSpec(
+        name="AG News",
+        aliases=("ag_news", "agnews"),
+        modality="text",
+        task_type="classification",
+        input_shape=(5000,),
+        num_classes=4,
+        default_model="TextDNN",
+        compatible_models=TEXT_MODELS,
+        loader="csv_text",
+        requires_local_data=True,
+        metadata={"feature_dim": 5000},
+    ),
+    DatasetSpec(
+        name="Sogou News",
+        aliases=("sogou_news", "sogou"),
+        modality="text",
+        task_type="classification",
+        input_shape=(8000,),
+        num_classes=5,
+        default_model="TextDNN",
+        compatible_models=TEXT_MODELS,
+        loader="csv_text",
+        requires_local_data=True,
+        metadata={"feature_dim": 8000},
+    ),
+    DatasetSpec(
+        name="Tiny-ImageNet",
+        aliases=("tiny_imagenet", "tinyimagenet", "tiny-imagenet"),
+        modality="image",
+        task_type="classification",
+        input_shape=(3, 32, 32),
+        num_classes=200,
+        default_model="FedAvgCNN",
+        compatible_models=SMALL_IMAGE_MODELS,
+        loader="tiny_imagenet",
+        requires_local_data=True,
+    ),
+    DatasetSpec(
+        name="Country211",
+        aliases=("country211",),
+        modality="image",
+        task_type="classification",
+        input_shape=(3, 64, 64),
+        num_classes=211,
+        default_model="MobileNet",
+        compatible_models=GENERAL_IMAGE_MODELS,
+    ),
+    DatasetSpec(
+        name="Flowers102",
+        aliases=("flowers102", "flowers-102"),
+        modality="image",
+        task_type="classification",
+        input_shape=(3, 64, 64),
+        num_classes=102,
+        default_model="MobileNet",
+        compatible_models=GENERAL_IMAGE_MODELS,
+    ),
+    DatasetSpec(
+        name="GTSRB",
+        aliases=("gtsrb",),
+        modality="image",
+        task_type="classification",
+        input_shape=(3, 64, 64),
+        num_classes=43,
+        default_model="MobileNet",
+        compatible_models=GENERAL_IMAGE_MODELS,
+    ),
+    DatasetSpec(
+        name="Shakespeare",
+        aliases=("shakespeare",),
+        modality="sequence",
+        task_type="next_char",
+        input_shape=(80,),
+        num_classes=128,
+        default_model="CharLSTM",
+        compatible_models=SEQUENCE_MODELS,
+        loader="shakespeare",
+        requires_local_data=True,
+        metadata={"sequence_length": 80, "vocab_size": 128},
+    ),
+    DatasetSpec(
+        name="Stanford Cars",
+        aliases=("stanford_cars", "stanford-cars", "cars"),
+        modality="image",
+        task_type="classification",
+        input_shape=(3, 64, 64),
+        num_classes=196,
+        default_model="MobileNet",
+        compatible_models=GENERAL_IMAGE_MODELS,
+    ),
+    DatasetSpec(
+        name="COVIDx",
+        aliases=("covidx", "covid-x"),
+        modality="image",
+        task_type="classification",
+        input_shape=(3, 64, 64),
+        num_classes=3,
+        default_model="MobileNet",
+        compatible_models=GENERAL_IMAGE_MODELS,
+        loader="local_image_folder",
+        requires_local_data=True,
+    ),
+    DatasetSpec(
+        name="Kvasir",
+        aliases=("kvasir",),
+        modality="image",
+        task_type="classification",
+        input_shape=(3, 64, 64),
+        num_classes=8,
+        default_model="MobileNet",
+        compatible_models=GENERAL_IMAGE_MODELS,
+        loader="local_image_folder",
+        requires_local_data=True,
+    ),
+)
+
+
+def _normalize_key(value: str) -> str:
+    return value.strip().lower().replace("_", "-").replace(" ", "-")
+
+
+DATASET_BY_NAME: dict[str, DatasetSpec] = {
+    _normalize_key(spec.name): spec for spec in DATASET_SPECS
+}
+for _spec in DATASET_SPECS:
+    for _alias in _spec.aliases:
+        DATASET_BY_NAME[_normalize_key(_alias)] = _spec
+
+
+MODEL_BY_NAME: dict[str, ModelSpec] = {
+    _normalize_key(spec.name): spec for spec in MODEL_SPECS
+}
+for _spec in MODEL_SPECS:
+    for _alias in _spec.aliases:
+        MODEL_BY_NAME[_normalize_key(_alias)] = _spec
+
+
+def canonical_dataset_name(name: str) -> str:
+    spec = get_dataset_spec(name)
+    if spec is None:
+        return name
+    return spec.name
+
+
+def canonical_model_name(name: str) -> str:
+    spec = get_model_spec(name)
+    if spec is None:
+        return name
+    return spec.name
+
+
+def get_dataset_spec(name: str | None) -> DatasetSpec | None:
+    if not name:
+        return None
+    return DATASET_BY_NAME.get(_normalize_key(str(name)))
+
+
+def get_model_spec(name: str | None) -> ModelSpec | None:
+    if not name:
+        return None
+    return MODEL_BY_NAME.get(_normalize_key(str(name)))
+
+
+def list_dataset_names() -> list[str]:
+    return [spec.name for spec in DATASET_SPECS]
+
+
+def list_model_names() -> list[str]:
+    return [spec.name for spec in MODEL_SPECS]
+
+
+def is_model_compatible_with_dataset(model_name: str, dataset_name: str) -> bool:
+    dataset = get_dataset_spec(dataset_name)
+    model = get_model_spec(model_name)
+    if dataset is None or model is None:
+        return False
+    return model.name in dataset.compatible_models
+
+
+def get_compatible_models(dataset_name: str) -> list[str]:
+    dataset = get_dataset_spec(dataset_name)
+    if dataset is None:
+        return []
+    return list(dataset.compatible_models)
+
+
+def resolve_model_name_for_dataset(model_name: str | None, dataset_name: str) -> str:
+    dataset = get_dataset_spec(dataset_name)
+    if model_name is None or not str(model_name).strip() or str(model_name).strip().lower() == "auto":
+        return dataset.default_model if dataset is not None else "FedAvgCNN"
+    return canonical_model_name(str(model_name))
+
+
+def validate_training_combination(config: dict[str, Any]) -> list[str]:
+    errors: list[str] = []
+    dataset_cfg = config.get("dataset") if isinstance(config.get("dataset"), dict) else {}
+    model_cfg = config.get("model") if isinstance(config.get("model"), dict) else {}
+    federated_cfg = config.get("federated") if isinstance(config.get("federated"), dict) else {}
+    privacy_cfg = config.get("privacy") if isinstance(config.get("privacy"), dict) else {}
+    compression_cfg = config.get("compression") if isinstance(config.get("compression"), dict) else {}
+
+    dataset_name = str(dataset_cfg.get("name", ""))
+    raw_model_name = model_cfg.get("name")
+    aggregation = str(federated_cfg.get("aggregation", "fedavg")).lower()
+
+    dataset = get_dataset_spec(dataset_name)
+    model_name = resolve_model_name_for_dataset(raw_model_name, dataset_name)
+    model = get_model_spec(model_name)
+
+    if dataset is None:
+        errors.append(f"Unsupported dataset: {dataset_name}")
+    if model is None:
+        errors.append(f"Unsupported model: {model_name}")
+    if dataset is not None and model is not None and model.name not in dataset.compatible_models:
+        allowed = ", ".join(dataset.compatible_models)
+        errors.append(f"Model {model.name} is not compatible with dataset {dataset.name}. Allowed models: {allowed}")
+
+    if aggregation not in EXECUTABLE_AGGREGATIONS:
+        allowed = ", ".join(EXECUTABLE_AGGREGATIONS)
+        errors.append(f"Aggregation {aggregation} is not executable in simulation. Allowed aggregations: {allowed}")
+
+    he_cfg = privacy_cfg.get("homomorphic_encryption") if isinstance(privacy_cfg, dict) else {}
+    ckks_enabled = isinstance(he_cfg, dict) and he_cfg.get("enable") is True
+    dp_cfg = privacy_cfg.get("differential_privacy") if isinstance(privacy_cfg, dict) else {}
+    dp_enabled = isinstance(dp_cfg, dict) and dp_cfg.get("enable") is True
+    secure_agg_cfg = privacy_cfg.get("secure_aggregation") if isinstance(privacy_cfg, dict) else {}
+    secure_agg_enabled = isinstance(secure_agg_cfg, dict) and secure_agg_cfg.get("enable") is True
+    sparsification_cfg = compression_cfg.get("sparsification") if isinstance(compression_cfg, dict) else {}
+    sparsification_enabled = isinstance(sparsification_cfg, dict) and sparsification_cfg.get("enable") is True
+    compression_method = str(sparsification_cfg.get("method", "global_topk")).lower() if isinstance(sparsification_cfg, dict) else "global_topk"
+
+    if ckks_enabled and aggregation not in LINEAR_AGGREGATIONS:
+        allowed = ", ".join(LINEAR_AGGREGATIONS)
+        errors.append(f"CKKS is only compatible with linear aggregations: {allowed}")
+    if ckks_enabled and sparsification_enabled:
+        errors.append("CKKS homomorphic encryption and sparsification are not compatible yet")
+    if ckks_enabled and secure_agg_enabled:
+        errors.append("CKKS homomorphic encryption and secure aggregation masking cannot be enabled together")
+    if secure_agg_enabled and aggregation not in EQUAL_WEIGHT_AGGREGATIONS:
+        allowed = ", ".join(EQUAL_WEIGHT_AGGREGATIONS)
+        errors.append(f"Secure aggregation masking is only compatible with equal-weight aggregations: {allowed}")
+    if secure_agg_enabled and sparsification_enabled:
+        errors.append("Secure aggregation masking and compression are not compatible yet")
+    if sparsification_enabled and aggregation not in LINEAR_AGGREGATIONS:
+        allowed = ", ".join(LINEAR_AGGREGATIONS)
+        errors.append(f"Sparsification is only compatible with linear aggregations: {allowed}")
+    if sparsification_enabled and compression_method not in COMPRESSION_METHODS:
+        allowed = ", ".join(COMPRESSION_METHODS)
+        errors.append(f"Unsupported compression method: {compression_method}. Allowed methods: {allowed}")
+    if dp_enabled:
+        clipping_norm = dp_cfg.get("clipping_norm", 1.0)
+        noise_multiplier = dp_cfg.get("noise_multiplier", 0.0)
+        if isinstance(clipping_norm, bool) or not isinstance(clipping_norm, (int, float)) or clipping_norm <= 0:
+            errors.append("Differential privacy clipping_norm must be greater than 0")
+        if isinstance(noise_multiplier, bool) or not isinstance(noise_multiplier, (int, float)) or noise_multiplier < 0:
+            errors.append("Differential privacy noise_multiplier must be greater than or equal to 0")
+
+    return errors
+
+
+def capabilities_payload() -> dict[str, Any]:
+    return {
+        "datasets": list_dataset_names(),
+        "distributions": ["iid", "non_iid"],
+        "models": ["Auto", *list_model_names()],
+        "dataset_model_compatibility": {
+            spec.name: list(spec.compatible_models) for spec in DATASET_SPECS
+        },
+        "dataset_defaults": {
+            spec.name: {
+                "default_model": spec.default_model,
+                "modality": spec.modality,
+                "task_type": spec.task_type,
+                "input_shape": list(spec.input_shape),
+                "num_classes": spec.num_classes,
+                "requires_local_data": spec.requires_local_data,
+            }
+            for spec in DATASET_SPECS
+        },
+        "aggregations": list(EXECUTABLE_AGGREGATIONS),
+        "privacy": {
+            "homomorphic_encryption": {
+                "methods": ["ckks"],
+                "compatible_aggregations": list(LINEAR_AGGREGATIONS),
+                "incompatible_with": ["compression.sparsification", "privacy.secure_aggregation"],
+            },
+            "differential_privacy": {
+                "methods": ["clip_and_noise"],
+                "compatible_aggregations": list(EXECUTABLE_AGGREGATIONS),
+                "compatible_with": [
+                    "privacy.homomorphic_encryption",
+                    "privacy.secure_aggregation",
+                    "compression.sparsification",
+                ],
+            },
+            "secure_aggregation": {
+                "methods": ["additive_masking_simulation"],
+                "compatible_aggregations": list(EQUAL_WEIGHT_AGGREGATIONS),
+                "incompatible_with": ["privacy.homomorphic_encryption", "compression.sparsification"],
+            },
+        },
+        "compression": {
+            "sparsification": {
+                "methods": list(COMPRESSION_METHODS),
+                "compatible_aggregations": list(LINEAR_AGGREGATIONS),
+                "incompatible_with": ["privacy.homomorphic_encryption", "privacy.secure_aggregation"],
+            }
+        },
+        "metrics": {
+            "global_results": ["rounds", "global_loss", "global_accuracy"],
+            "client_results": ["train_loss", "train_acc", "test_loss", "test_acc"],
+        },
+    }
diff --git a/libs/fl_core/utils/config.py b/libs/fl_core/utils/config.py
index b455844..061f433 100644
--- a/libs/fl_core/utils/config.py
+++ b/libs/fl_core/utils/config.py
@@ -2,6 +2,8 @@
 import os
 from typing import Dict, Any
 
+from fl_core.simulation_registry import validate_training_combination
+
 
 class ConfigManager:
     
@@ -78,4 +80,8 @@ def validate_config(self) -> bool:
             if param not in federated_config:
                 raise ValueError(f"联邦学习配置缺少{param}参数")
         
-        return True
\ No newline at end of file
+        compatibility_errors = validate_training_combination(self.config)
+        if compatibility_errors:
+            raise ValueError("; ".join(compatibility_errors))
+
+        return True
diff --git a/models/llm/README.md b/models/llm/README.md
new file mode 100644
index 0000000..3d6b43a
--- /dev/null
+++ b/models/llm/README.md
@@ -0,0 +1,14 @@
+# Local LLM Models
+
+Place local Hugging Face-compatible model directories here.
+
+Example:
+
+```text
+models/llm/Qwen2.5-0.5B-Instruct/config.json
+models/llm/Qwen2.5-0.5B-Instruct/model.safetensors
+models/llm/Qwen2.5-0.5B-Instruct/tokenizer.json
+```
+
+Directories under this path are discovered by the backend and exposed as selectable `llm.base_model` options in the frontend.
+
diff --git a/pyproject.toml b/pyproject.toml
index ad0a3ff..3573a7e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,22 +5,28 @@ description = "Figaro — An intelligent federated learning platform with AI-dri
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
+    "accelerate>=0.34.0",
     "asyncpg>=0.30.0",
+    "bitsandbytes>=0.44.0",
     "fastapi>=0.116.1",
     "grpcio>=1.76.0",
+    "langchain-openai>=1.0.0",
+    "langgraph>=1.1.2",
     "numpy>=2.0.1",
+    "peft>=0.13.0",
     "pydantic-settings>=2.10.1",
     "psycopg[binary]>=3.2.9",
     "protobuf>=6.31.1",
+    "pyarrow>=16.1.0",
     "pyyaml>=6.0.3",
+    "safetensors>=0.4.5",
     "sqlalchemy>=2.0.43",
     "sqlmodel>=0.0.24",
     "tenseal>=0.3.16",
     "torch>=2.5.1",
     "torchvision>=0.20.1",
+    "transformers>=4.45.0",
     "uvicorn>=0.35.0",
-    "langgraph>=1.1.2",
-    "langchain-openai>=1.0.0",
 ]
 
 [dependency-groups]
diff --git a/scripts/create_tiny_llm_fixture.py b/scripts/create_tiny_llm_fixture.py
new file mode 100644
index 0000000..8572a29
--- /dev/null
+++ b/scripts/create_tiny_llm_fixture.py
@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+DEFAULT_OUTPUT_DIR = Path("models") / "llm" / "tiny-causal-lm"
+
+
+def build_tokenizer(output_dir: Path):
+    from tokenizers import Tokenizer
+    from tokenizers.models import WordLevel
+    from tokenizers.pre_tokenizers import Whitespace
+    from tokenizers.trainers import WordLevelTrainer
+    from transformers import PreTrainedTokenizerFast
+
+    corpus = [
+        "Question What is federated learning Answer Training a shared model across clients without centralizing their raw data",
+        "Question What does LoRA train Answer Low rank adapter weights while keeping the base model frozen",
+        "Question Why use a validation set Answer To estimate generalization with loss and perplexity after training rounds",
+        "Question What is PEFT Answer Parameter efficient fine tuning that updates a small set of trainable parameters",
+    ]
+    tokenizer = Tokenizer(WordLevel(unk_token="<unk>"))
+    tokenizer.pre_tokenizer = Whitespace()
+    trainer = WordLevelTrainer(
+        special_tokens=["<pad>", "<unk>", "<bos>", "<eos>"],
+        min_frequency=1,
+    )
+    tokenizer.train_from_iterator(corpus, trainer=trainer)
+
+    fast_tokenizer = PreTrainedTokenizerFast(
+        tokenizer_object=tokenizer,
+        pad_token="<pad>",
+        unk_token="<unk>",
+        bos_token="<bos>",
+        eos_token="<eos>",
+    )
+    fast_tokenizer.save_pretrained(output_dir)
+    return fast_tokenizer
+
+
+def build_model(output_dir: Path) -> None:
+    from transformers import LlamaConfig, LlamaForCausalLM
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    tokenizer = build_tokenizer(output_dir)
+    config = LlamaConfig(
+        vocab_size=len(tokenizer),
+        hidden_size=32,
+        intermediate_size=64,
+        num_hidden_layers=1,
+        num_attention_heads=4,
+        num_key_value_heads=4,
+        max_position_embeddings=256,
+        bos_token_id=tokenizer.bos_token_id,
+        eos_token_id=tokenizer.eos_token_id,
+        pad_token_id=tokenizer.pad_token_id,
+        tie_word_embeddings=False,
+    )
+    model = LlamaForCausalLM(config)
+    model.save_pretrained(output_dir, safe_serialization=True)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Create a tiny local causal LM fixture for Figaro LLM PEFT smoke runs.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=DEFAULT_OUTPUT_DIR,
+        help=f"Model output directory. Default: {DEFAULT_OUTPUT_DIR.as_posix()}",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    build_model(args.output_dir)
+    print(f"Tiny LLM fixture written to {args.output_dir.as_posix()}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/skill/add-llm-dataset/SKILL.md b/skill/add-llm-dataset/SKILL.md
new file mode 100644
index 0000000..ce61a8a
--- /dev/null
+++ b/skill/add-llm-dataset/SKILL.md
@@ -0,0 +1,98 @@
+---
+name: add-llm-dataset
+description: Use when adding or documenting a local supervised fine-tuning dataset for Figaro LLM PEFT runs. Explains how to place JSONL files under datasets/llm, supported prompt_completion and messages formats, frontend sft.dataset_path discovery, and verification.
+---
+
+# Add Local LLM Dataset
+
+Use this workflow when the user wants Figaro to recognize a local SFT dataset in the frontend.
+
+## Target Directory
+
+Place LLM supervised fine-tuning datasets under:
+
+```text
+datasets/llm/
+```
+
+The backend discovers `.jsonl` files recursively. The frontend option value will be the project-relative file path:
+
+```text
+./datasets/llm/<dataset>.jsonl
+```
+
+Nested paths are supported:
+
+```text
+./datasets/llm/alpaca/train.jsonl
+```
+
+Use a separate validation file when enabling LLM evaluation:
+
+```text
+./datasets/llm/validation.jsonl
+```
+
+## Supported Formats
+
+Use JSON Lines: one JSON object per line.
+
+For `sft.format = prompt_completion`, each row should contain:
+
+```json
+{"prompt":"Question","completion":"Answer"}
+```
+
+For `sft.format = messages`, each row should contain a chat-style message list:
+
+```json
+{"messages":[{"role":"user","content":"Question"},{"role":"assistant","content":"Answer"}]}
+```
+
+Keep every line valid JSON. Do not wrap the file in a top-level array.
+
+## Discovery Rules
+
+Figaro scans `datasets/llm/` when the backend returns config schema.
+
+- Files ending in `.jsonl` are exposed as selectable `sft.dataset_path` options.
+- The same JSONL files are exposed as selectable `evaluation.dataset_path` options.
+- Non-JSONL files are ignored.
+- Hidden paths are ignored.
+- Dataset files are ignored by Git; only `datasets/llm/README.md` should be tracked.
+
+Restart or refresh the backend schema after adding a dataset if the option does not appear.
+
+## Frontend Selection
+
+In Simulation or Agent config:
+
+1. Select `task.type = llm_peft_sft`.
+2. Open the SFT Dataset fields.
+3. Choose the JSONL file from `Dataset path`, or type it manually.
+4. Set `Dataset format` to match the JSONL rows.
+5. To compute validation loss/perplexity, enable `evaluation.enable` and select a validation JSONL file.
+
+Example values:
+
+```text
+sft.dataset_path = ./datasets/llm/train.jsonl
+sft.format = prompt_completion
+evaluation.dataset_path = ./datasets/llm/validation.jsonl
+```
+
+## Verification
+
+Check that the schema exposes the dataset:
+
+```bash
+curl http://localhost:8000/api/v1/jobs/config/schema
+```
+
+Look for the path in:
+
+```text
+sft.dataset_path.options
+```
+
+Then run a small LLM PEFT simulation config and confirm the runtime metrics include `llm_dataset.num_records` and `llm_dataset.client_record_counts`.
diff --git a/skill/add-llm-model/SKILL.md b/skill/add-llm-model/SKILL.md
new file mode 100644
index 0000000..b5409c6
--- /dev/null
+++ b/skill/add-llm-model/SKILL.md
@@ -0,0 +1,81 @@
+---
+name: add-llm-model
+description: Use when adding or documenting a local LLM model for Figaro. Explains how to place Hugging Face-compatible model directories under models/llm, how Figaro discovers them as llm.base_model options, and how to verify the frontend/runtime selection.
+---
+
+# Add Local LLM Model
+
+Use this workflow when the user wants Figaro to recognize a local LLM model in the frontend.
+
+## Target Directory
+
+Place local model directories under:
+
+```text
+models/llm/
+```
+
+Use one directory per model. The frontend option value will be the project-relative path:
+
+```text
+./models/llm/<model-directory>
+```
+
+## Expected Model Layout
+
+Use a Hugging Face-compatible causal language model directory. A typical layout is:
+
+```text
+models/llm/Qwen2.5-0.5B-Instruct/
+  config.json
+  model.safetensors
+  tokenizer.json
+  tokenizer_config.json
+  special_tokens_map.json
+```
+
+Sharded weights are also fine if `transformers.AutoModelForCausalLM.from_pretrained()` can load the directory.
+
+## Discovery Rules
+
+Figaro scans `models/llm/` when the backend returns config schema.
+
+- Direct child directories under `models/llm/` are exposed as selectable `llm.base_model` options.
+- Nested directories that contain `config.json` are also exposed.
+- Hidden directories are ignored.
+- Model files are ignored by Git; only `models/llm/README.md` should be tracked.
+
+Restart or refresh the backend schema after adding a model if the option does not appear.
+
+## Frontend Selection
+
+In Simulation or Agent config:
+
+1. Select `task.type = llm_peft_sft`.
+2. Open the LLM fields.
+3. Choose the local model path from `Base model`, or type it manually.
+
+Example value:
+
+```text
+./models/llm/Qwen2.5-0.5B-Instruct
+```
+
+Keep `llm.tokenizer = auto` unless the tokenizer lives in a different directory.
+
+## Verification
+
+Check that the schema exposes the model:
+
+```bash
+curl http://localhost:8000/api/v1/jobs/config/schema
+```
+
+Look for the path in:
+
+```text
+llm.base_model.options
+```
+
+Then run a small LLM PEFT simulation config and confirm the runtime log prints `LLM_BASE_MODEL` with the selected local path.
+
diff --git a/uv.lock b/uv.lock
index 1faa6a4..ad38bac 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2,6 +2,24 @@ version = 1
 revision = 3
 requires-python = ">=3.11"
 
+[[package]]
+name = "accelerate"
+version = "1.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "psutil" },
+    { name = "pyyaml" },
+    { name = "safetensors" },
+    { name = "torch" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ca/14/787e5498cd062640f0f3d92ef4ae4063174f76f9afd29d13fc52a319daae/accelerate-1.13.0.tar.gz", hash = "sha256:d631b4e0f5b3de4aff2d7e9e6857d164810dfc3237d54d017f075122d057b236", size = 402835, upload-time = "2026-03-04T19:34:12.359Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/46/02ac5e262d4af18054b3e922b2baedbb2a03289ee792162de60a865defc5/accelerate-1.13.0-py3-none-any.whl", hash = "sha256:cf1a3efb96c18f7b152eb0fa7490f3710b19c3f395699358f08decca2b8b62e0", size = 383744, upload-time = "2026-03-04T19:34:10.313Z" },
+]
+
 [[package]]
 name = "aiosqlite"
 version = "0.22.1"
@@ -90,6 +108,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3c/d7/8fb3044eaef08a310acfe23dae9a8e2e07d305edc29a53497e52bc76eca7/asyncpg-0.31.0-cp314-cp314t-win_amd64.whl", hash = "sha256:bd4107bb7cdd0e9e65fae66a62afd3a249663b844fa34d479f6d5b3bef9c04c3", size = 706062, upload-time = "2025-11-24T23:26:44.086Z" },
 ]
 
+[[package]]
+name = "bitsandbytes"
+version = "0.49.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "torch" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d8/7d/f1fe0992334b18cd8494f89aeec1dcc674635584fcd9f115784fea3a1d05/bitsandbytes-0.49.2-py3-none-macosx_14_0_arm64.whl", hash = "sha256:87be5975edeac5396d699ecbc39dfc47cf2c026daaf2d5852a94368611a6823f", size = 131940, upload-time = "2026-02-16T21:26:04.572Z" },
+    { url = "https://files.pythonhosted.org/packages/29/71/acff7af06c818664aa87ff73e17a52c7788ad746b72aea09d3cb8e424348/bitsandbytes-0.49.2-py3-none-manylinux_2_24_aarch64.whl", hash = "sha256:2fc0830c5f7169be36e60e11f2be067c8f812dfcb829801a8703735842450750", size = 31442815, upload-time = "2026-02-16T21:26:06.783Z" },
+    { url = "https://files.pythonhosted.org/packages/19/57/3443d6f183436fbdaf5000aac332c4d5ddb056665d459244a5608e98ae92/bitsandbytes-0.49.2-py3-none-manylinux_2_24_x86_64.whl", hash = "sha256:54b771f06e1a3c73af5c7f16ccf0fc23a846052813d4b008d10cb6e017dd1c8c", size = 60651714, upload-time = "2026-02-16T21:26:11.579Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/d4/501655842ad6771fb077f576d78cbedb5445d15b1c3c91343ed58ca46f0e/bitsandbytes-0.49.2-py3-none-win_amd64.whl", hash = "sha256:2e0ddd09cd778155388023cbe81f00afbb7c000c214caef3ce83386e7144df7d", size = 55372289, upload-time = "2026-02-16T21:26:16.267Z" },
+]
+
 [[package]]
 name = "certifi"
 version = "2026.2.25"
@@ -310,21 +344,27 @@ name = "figaro"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "accelerate" },
     { name = "asyncpg" },
+    { name = "bitsandbytes" },
     { name = "fastapi" },
     { name = "grpcio" },
     { name = "langchain-openai" },
     { name = "langgraph" },
     { name = "numpy" },
+    { name = "peft" },
     { name = "protobuf" },
     { name = "psycopg", extra = ["binary"] },
+    { name = "pyarrow" },
     { name = "pydantic-settings" },
     { name = "pyyaml" },
+    { name = "safetensors" },
     { name = "sqlalchemy" },
     { name = "sqlmodel" },
     { name = "tenseal" },
     { name = "torch" },
     { name = "torchvision" },
+    { name = "transformers" },
     { name = "uvicorn" },
 ]
 
@@ -337,21 +377,27 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "accelerate", specifier = ">=0.34.0" },
     { name = "asyncpg", specifier = ">=0.30.0" },
+    { name = "bitsandbytes", specifier = ">=0.44.0" },
     { name = "fastapi", specifier = ">=0.116.1" },
     { name = "grpcio", specifier = ">=1.76.0" },
     { name = "langchain-openai", specifier = ">=1.0.0" },
     { name = "langgraph", specifier = ">=1.1.2" },
     { name = "numpy", specifier = ">=2.0.1" },
+    { name = "peft", specifier = ">=0.13.0" },
     { name = "protobuf", specifier = ">=6.31.1" },
     { name = "psycopg", extras = ["binary"], specifier = ">=3.2.9" },
+    { name = "pyarrow", specifier = ">=16.1.0" },
     { name = "pydantic-settings", specifier = ">=2.10.1" },
     { name = "pyyaml", specifier = ">=6.0.3" },
+    { name = "safetensors", specifier = ">=0.4.5" },
     { name = "sqlalchemy", specifier = ">=2.0.43" },
     { name = "sqlmodel", specifier = ">=0.0.24" },
     { name = "tenseal", specifier = ">=0.3.16" },
     { name = "torch", specifier = ">=2.5.1" },
     { name = "torchvision", specifier = ">=0.20.1" },
+    { name = "transformers", specifier = ">=4.45.0" },
     { name = "uvicorn", specifier = ">=0.35.0" },
 ]
 
@@ -487,6 +533,38 @@ 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.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/d8/5c06fc76461418326a7decf8367480c35be11a41fd938633929c60a9ec6b/hf_xet-1.5.0.tar.gz", hash = "sha256:e0fb0a34d9f406eed88233e829a67ec016bec5af19e480eac65a233ea289a948", size = 837196, upload-time = "2026-05-06T06:18:15.583Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/9b/6912c99070915a4f28119e3c5b52a9abd1eec0ad5cb293b8c967a0c6f5a2/hf_xet-1.5.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:7d70fe2ce97b9db73b9c9b9c81fe3693640aec83416a966c446afea54acfae3c", size = 4023383, upload-time = "2026-05-06T06:17:53.947Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/6d/9563cfde59b5d8128a9c7ec972a087f4c782e4f7bac5a85234edfd5d5e49/hf_xet-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:73a0dae8c71de3b0633a45c73f4a4a5ed09e94b43441d82981a781d4f12baa42", size = 3792751, upload-time = "2026-05-06T06:17:51.791Z" },
+    { url = "https://files.pythonhosted.org/packages/07/a5/ed5a0cf35b49a0571af5a8f53416dad1877a718c021c9937c3a53cb45781/hf_xet-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a60290ec57e9b71767fba7c3645ddafdd0759974b540441510c629c6db6db24a", size = 4456058, upload-time = "2026-05-06T06:17:40.735Z" },
+    { url = "https://files.pythonhosted.org/packages/60/fb/3ae8bf2a7a37a4197d0195d7247fd25b3952e15cb8a599e285dfaa6f52b3/hf_xet-1.5.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:e5de0f6deada0dada870bb376a11bcd1f08abf3a968a6d118f33e72d1b1eb480", size = 4250783, upload-time = "2026-05-06T06:17:38.412Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/9b/8bae40d4d91525085137196e84eb0ed49cf65b5e96e5c3ecdadd8bd0fac2/hf_xet-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c799d49f1a5544a0ef7591c0ee75e0d6b93d6f56dc7a4979f59f7518d2872216", size = 4445594, upload-time = "2026-05-06T06:18:04.219Z" },
+    { url = "https://files.pythonhosted.org/packages/13/59/c74efbbd4e8728172b2cc72a2bc014d2947a4b7bdced932fbd3f5da1a4e5/hf_xet-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2baea1b0b989e5c152fe81425f7745ddc8901280ba3d97c98d8cdece7b706c60", size = 4663995, upload-time = "2026-05-06T06:18:06.1Z" },
+    { url = "https://files.pythonhosted.org/packages/73/32/8e1e0410af64cda9b139d1dcebdc993a8ff9c8c7c0e2696ae356d75ccc0d/hf_xet-1.5.0-cp313-cp313t-win_amd64.whl", hash = "sha256:526345b3ed45f374f6317349df489167606736c876241ba984105afe7fd4839d", size = 3966608, upload-time = "2026-05-06T06:18:19.74Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/34/a8febc8f4edbea8b3e21b02ebc8b628679b84ba7e45cde624a7736b51500/hf_xet-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:786d28e2eb8315d5035544b9d137b4a842d600c434bb91bf7d0d953cce906ad4", size = 3796946, upload-time = "2026-05-06T06:18:17.568Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/20/8fc8996afe5815fa1a6be8e9e5c02f24500f409d599e905800d498a4e14d/hf_xet-1.5.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:872d5601e6deea30d15865ede55d29eac6daf5a534ab417b99b6ef6b076dd96c", size = 4023495, upload-time = "2026-05-06T06:18:01.94Z" },
+    { url = "https://files.pythonhosted.org/packages/32/6a/93d84463c00cecb561a7508aa6303e35ee2894294eac14245526924415fe/hf_xet-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9929561f5abf4581c8ea79587881dfef6b8abb2a0d8a51915936fc2a614f4e73", size = 3792731, upload-time = "2026-05-06T06:18:00.021Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/5a/8ec8e0c863b382d00b3c2e2af6ded6b06371be617144a625903a6d562f4b/hf_xet-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f7b7bbae318e583a86fb21e5a4a175d6721d628a2874f4bd022d0e660c32a682", size = 4456738, upload-time = "2026-05-06T06:17:49.574Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/ca/f7effa1a67717da2bcc6b6c28f71c6ca648c77acaec4e2c32f40cbe16d85/hf_xet-1.5.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:cf7b2dc6f31a4ea754bb50f74cde482dcf5d366d184076d8530b9872787f3761", size = 4251622, upload-time = "2026-05-06T06:17:47.096Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f2/19247dba3e231cf77dec59ddfb878f00057635ff773d099c9b59d37812c3/hf_xet-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8dbcbab554c9ef158ef2c991545c3e970ddd8cc7acdcd0a78c5a41095dab4ded", size = 4445667, upload-time = "2026-05-06T06:18:11.983Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/64/6f116801a3bcfb6f59f5c251f48cadc47ea54026441c4a385079286a94fa/hf_xet-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5906bf7718d3636dc13402914736abe723492cb730f744834f5f5b67d3a12702", size = 4664619, upload-time = "2026-05-06T06:18:13.771Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e8/069542d37946ed08669b127e1496fa99e78196d71de8d41eda5e9f1b7a58/hf_xet-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5f3dc2248fc01cc0a00cd392ab497f1ca373fcbc7e3f2da1f452480b384e839e", size = 3966802, upload-time = "2026-05-06T06:18:28.162Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/91/fc6fdec27b14d04e88c386ac0a0129732b53fa23f7c4a78f4b83a039c567/hf_xet-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b285cea1b5bab46b758772716ba8d6854a1a0310fed1c249d678a8b38601e5a0", size = 3797168, upload-time = "2026-05-06T06:18:26.287Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/fb/69ff198a82cae7eb1a69fb84d93b3a3e4816564d76817fe541ddc96874eb/hf_xet-1.5.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:dad0dc84e941b8ba3c860659fe1fdc35c049d47cce293f003287757e971a8f56", size = 4030814, upload-time = "2026-05-06T06:17:57.933Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/ff/edcc2b40162bef3ff78e14ab637e5f3b89243d6aee72f5949d3bb6a5af83/hf_xet-1.5.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:fd6e5a9b0fdac4ed03ed45ef79254a655b1aaab514a02202617fbf643f5fdf7a", size = 3798444, upload-time = "2026-05-06T06:17:55.79Z" },
+    { url = "https://files.pythonhosted.org/packages/49/4d/103f76b04310e5e57656696cc184690d20c466af0bca3ca88f8c8ea5d4f3/hf_xet-1.5.0-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3531b1823a0e6d77d80f9ed15ca0e00f0d115094f8ac033d5cae88f4564cc949", size = 4465986, upload-time = "2026-05-06T06:17:44.886Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a2/546f47f464737b3edbab6f8ddb57f2599b93d2cbb66f06abb475ccb48651/hf_xet-1.5.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:9a0ee58cd18d5ea799f7ed11290bbccbe56bdd8b1d97ca74b9cc49a3945d7a3b", size = 4259865, upload-time = "2026-05-06T06:17:42.639Z" },
+    { url = "https://files.pythonhosted.org/packages/95/7f/1be593c1f28613be2e196473481cd81bfc5910795e30a34e8f744f6cac4f/hf_xet-1.5.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1e60df5a42e9bed8628b6416af2cba4cba57ae9f02de226a06b020d98e1aab18", size = 4459835, upload-time = "2026-05-06T06:18:08.026Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b2/703569fc881f3284487e68cda7b42179978480da3c438042a6bbbb4a671c/hf_xet-1.5.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:4b35549ce62601b84da4ff9b24d970032ace3d4430f52d91bcbb26c901d6c690", size = 4672414, upload-time = "2026-05-06T06:18:09.864Z" },
+    { url = "https://files.pythonhosted.org/packages/af/37/1b6def445c567286b50aa3b33828158e135b1be44938dde59f11382a500c/hf_xet-1.5.0-cp37-abi3-win_amd64.whl", hash = "sha256:2806c7c17b4d23f8d88f7c4814f838c3b6150773fe339c20af23e1cfaf2797e4", size = 3977238, upload-time = "2026-05-06T06:18:23.621Z" },
+    { url = "https://files.pythonhosted.org/packages/62/94/3b66b148778ee100dcfd69c2ca22b57b41b44d3063ceec934f209e9184ce/hf_xet-1.5.0-cp37-abi3-win_arm64.whl", hash = "sha256:b6c9df403040248c76d808d3e047d64db2d923bae593eb244c41e425cf6cd7be", size = 3806916, upload-time = "2026-05-06T06:18:21.7Z" },
+]
+
 [[package]]
 name = "httpcore"
 version = "1.0.9"
@@ -515,6 +593,26 @@ 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 = "huggingface-hub"
+version = "1.15.0"
+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/bb/b6/e22bd20a25299c34b8c5922c1545a6320825b13906eb0f7298edfd034a0b/huggingface_hub-1.15.0.tar.gz", hash = "sha256:28abfdddda3927fd4de6a63cf26ab012498a2c24dae52baf150c5c6edf98a1d5", size = 784100, upload-time = "2026-05-15T11:42:52.149Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6e/11/0b64cc9024329b76d7547c19a67604a61d21d3ba678a69d1b220c29d5112/huggingface_hub-1.15.0-py3-none-any.whl", hash = "sha256:a4a59af04cbc41a3fe3fec429b171ef994ef8c971eda10136746f408dd4e3744", size = 663602, upload-time = "2026-05-15T11:42:50.487Z" },
+]
+
 [[package]]
 name = "idna"
 version = "3.11"
@@ -760,6 +858,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/37/19/96250cf58070c5563446651b03bb76c2eb5afbf08e754840ab639532d8c6/langsmith-0.7.30-py3-none-any.whl", hash = "sha256:43dd9f8d290e4d406606d6cc0bd62f5d1050963f05fe0ab6ffe50acf41f2f55a", size = 372682, upload-time = "2026-04-09T21:12:00.481Z" },
 ]
 
+[[package]]
+name = "markdown-it-py"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
+]
+
 [[package]]
 name = "markupsafe"
 version = "3.0.3"
@@ -834,6 +944,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
 ]
 
+[[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 = "mpmath"
 version = "1.3.0"
@@ -1224,6 +1343,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
 ]
 
+[[package]]
+name = "peft"
+version = "0.19.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "accelerate" },
+    { name = "huggingface-hub" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "psutil" },
+    { name = "pyyaml" },
+    { name = "safetensors" },
+    { name = "torch" },
+    { name = "tqdm" },
+    { name = "transformers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/86/cf/037f1e3d5186496c05513a6754639e2dab3038a05f384284d49a9bd06a2d/peft-0.19.1.tar.gz", hash = "sha256:0d97542fe96dcdaa20d3b81c06f26f988618f416a73544ab23c3618ccb674a40", size = 763738, upload-time = "2026-04-16T15:46:45.105Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/b6/f54d676ed93cc2dd2234c3b172ea9c8c3d7d29361e66b1b23dec57a67465/peft-0.19.1-py3-none-any.whl", hash = "sha256:2113f72a81621b5913ef28f9022204c742df111890c5f49d812716a4a301e356", size = 680692, upload-time = "2026-04-16T15:46:42.886Z" },
+]
+
 [[package]]
 name = "pillow"
 version = "12.2.0"
@@ -1335,6 +1475,34 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/88/95/608f665226bca68b736b79e457fded9a2a38c4f4379a4a7614303d9db3bc/protobuf-7.34.1-py3-none-any.whl", hash = "sha256:bb3812cd53aefea2b028ef42bd780f5b96407247f20c6ef7c679807e9d188f11", size = 170715, upload-time = "2026-03-20T17:34:45.384Z" },
 ]
 
+[[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 = "psycopg"
 version = "3.3.3"
@@ -1404,6 +1572,56 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/98/5a/291d89f44d3820fffb7a04ebc8f3ef5dda4f542f44a5daea0c55a84abf45/psycopg_binary-3.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:165f22ab5a9513a3d7425ffb7fcc7955ed8ccaeef6d37e369d6cc1dff1582383", size = 3652796, upload-time = "2026-02-18T16:52:14.02Z" },
 ]
 
+[[package]]
+name = "pyarrow"
+version = "24.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/91/13/13e1069b351bdc3881266e11147ffccf687505dbb0ea74036237f5d454a5/pyarrow-24.0.0.tar.gz", hash = "sha256:85fe721a14dd823aca09127acbb06c3ca723efbd436c004f16bca601b04dcc83", size = 1180261, upload-time = "2026-04-21T10:51:25.837Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/c9/a47ab7ece0d86cbe6678418a0fbd1ac4bb493b9184a3891dfa0e7f287ae0/pyarrow-24.0.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:b0e131f880cda8d04e076cee175a46fc0e8bc8b65c99c6c09dff6669335fde74", size = 35068898, upload-time = "2026-04-21T10:46:36.599Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/bc/8db86617a9a58008acf8913d6fed68ea2a46acb6de928db28d724c891a68/pyarrow-24.0.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:1b2fe7f9a5566401a0ef2571f197eb92358925c1f0c8dba305d6e43ea0871bb3", size = 36679915, upload-time = "2026-04-21T10:46:42.602Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/8e/fb178720400ef69db251eb4a9c3ccf4af269bc1feb5055529b8fc87170d1/pyarrow-24.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:0b3537c00fb8d384f15ac1e79b6eb6db04a16514c8c1d22e59a9b95c8ba42868", size = 45697931, upload-time = "2026-04-21T10:46:48.403Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/27/99c42abe8e21b44f4917f62631f3aa31404882a2c41d8a4cd5c110e13d52/pyarrow-24.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:14e31a3c9e35f1ab6356c6378f6f72830e6d2d5f1791df3774a7b097d18a6a1e", size = 48837449, upload-time = "2026-04-21T10:46:55.329Z" },
+    { url = "https://files.pythonhosted.org/packages/36/b6/333749e2666e9032891125bf9c691146e92901bece62030ac1430e2e7c88/pyarrow-24.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b7d9a514e73bc42711e6a35aaccf3587c520024fe0a25d830a1a8a27c15f4f57", size = 49395949, upload-time = "2026-04-21T10:47:01.869Z" },
+    { url = "https://files.pythonhosted.org/packages/17/25/c5201706a2dd374e8ba6ee3fd7a8c89fb7ffc16eed5217a91fd2bd7f7626/pyarrow-24.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b196eb3f931862af3fa84c2a253514d859c08e0d8fe020e07be12e75a5a9780c", size = 51912986, upload-time = "2026-04-21T10:47:09.872Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d2/4d1bbba65320b21a49678d6fbdc6ff7c649251359fdcfc03568c4136231d/pyarrow-24.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:35405aecb474e683fb36af650618fd5340ee5471fc65a21b36076a18bbc6c981", size = 27255371, upload-time = "2026-04-21T10:47:15.943Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/a9/9686d9f07837f91f775e8932659192e02c74f9d8920524b480b85212cc68/pyarrow-24.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:6233c9ed9ab9d1db47de57d9753256d9dcffbf42db341576099f0fd9f6bf4810", size = 34981559, upload-time = "2026-04-21T10:47:22.17Z" },
+    { url = "https://files.pythonhosted.org/packages/80/b6/0ddf0e9b6ead3474ab087ae598c76b031fc45532bf6a63f3a553440fb258/pyarrow-24.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:f7616236ec1bc2b15bfdec22a71ab38851c86f8f05ff64f379e1278cf20c634a", size = 36663654, upload-time = "2026-04-21T10:47:28.315Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/3b/926382efe8ce27ba729071d3566ade6dfb86bdf112f366000196b2f5780a/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:1617043b99bd33e5318ae18eb2919af09c71322ef1ca46566cdafc6e6712fb66", size = 45679394, upload-time = "2026-04-21T10:47:34.821Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/7a/829f7d9dfd37c207206081d6dad474d81dde29952401f07f2ba507814818/pyarrow-24.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6165461f55ef6314f026de6638d661188e3455d3ec49834556a0ebbdbace18bb", size = 48863122, upload-time = "2026-04-21T10:47:42.056Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e8/f88ce625fe8babaae64e8db2d417c7653adb3019b08aae85c5ed787dc816/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b13dedfe76a0ad2d1d859b0811b53827a4e9d93a0bcb05cf59333ab4980cc7e", size = 49376032, upload-time = "2026-04-21T10:47:48.967Z" },
+    { url = "https://files.pythonhosted.org/packages/36/7a/82c363caa145fff88fb475da50d3bf52bb024f61917be5424c3392eaf878/pyarrow-24.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:25ea65d868eb04015cd18e6df2fbe98f07e5bda2abefabcb88fce39a947716f6", size = 51929490, upload-time = "2026-04-21T10:47:55.981Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1c/e3e72c8014ad2743ca64a701652c733cc5cbcee15c0463a32a8c55518d9e/pyarrow-24.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:295f0a7f2e242dabd513737cf076007dc5b2d59237e3eca37b05c0c6446f3826", size = 27355660, upload-time = "2026-04-21T10:48:01.718Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d3/a1abf004482026ddc17f4503db227787fa3cfe41ec5091ff20e4fea55e57/pyarrow-24.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:02b001b3ed4723caa44f6cd1af2d5c86aa2cf9971dacc2ffa55b21237713dfba", size = 34976759, upload-time = "2026-04-21T10:48:07.258Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/4a/34f0a36d28a2dd32225301b79daad44e243dc1a2bb77d43b60749be255c4/pyarrow-24.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:04920d6a71aabd08a0417709efce97d45ea8e6fb733d9ca9ecffb13c67839f68", size = 36658471, upload-time = "2026-04-21T10:48:13.347Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/78/543b94712ae8bb1a6023bcc1acf1a740fbff8286747c289cd9468fced2a5/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:a964266397740257f16f7bb2e4f08a0c81454004beab8ff59dd531b73610e9f2", size = 45675981, upload-time = "2026-04-21T10:48:20.201Z" },
+    { url = "https://files.pythonhosted.org/packages/84/9f/8fb7c222b100d314137fa40ec050de56cd8c6d957d1cfff685ce72f15b17/pyarrow-24.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6f066b179d68c413374294bc1735f68475457c933258df594443bb9d88ddc2a0", size = 48859172, upload-time = "2026-04-21T10:48:27.541Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/d3/1ea72538e6c8b3b475ed78d1049a2c518e655761ea50fe1171fc855fcab7/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1183baeb14c5f587b1ec52831e665718ce632caab84b7cd6b85fd44f96114495", size = 49385733, upload-time = "2026-04-21T10:48:34.7Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/be/c3d8b06a1ba35f2260f8e1f771abbee7d5e345c0937aab90675706b1690a/pyarrow-24.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:806f24b4085453c197a5078218d1ee08783ebbba271badd153d1ae22a3ee804f", size = 51934335, upload-time = "2026-04-21T10:48:42.099Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/62/89e07a1e7329d2cde3e3c6994ba0839a24977a2beda8be6005ea3d860b99/pyarrow-24.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:e4505fc6583f7b05ab854934896bcac8253b04ac1171a77dfb73efef92076d91", size = 27271748, upload-time = "2026-04-21T10:49:42.532Z" },
+    { url = "https://files.pythonhosted.org/packages/17/1a/cff3a59f80b5b1658549d46611b67163f65e0664431c076ad728bf9d5af4/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:1a4e45017efbf115032e4475ee876d525e0e36c742214fbe405332480ecd6275", size = 35238554, upload-time = "2026-04-21T10:48:48.526Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/99/cce0f42a327bfef2c420fb6078a3eb834826e5d6697bf3009fe11d2ad051/pyarrow-24.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:7986f1fa71cee060ad00758bcc79d3a93bab8559bf978fab9e53472a2e25a17b", size = 36782301, upload-time = "2026-04-21T10:48:55.181Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/66/8e560d5ff6793ca29aca213c53eec0dd482dd46cb93b2819e5aab52e4252/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:d3e0b61e8efb24ed38898e5cdc5fffa9124be480008d401a1f8071500494ae42", size = 45721929, upload-time = "2026-04-21T10:49:03.676Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0c/a26e25505d030716e078d9f16eb74973cbf0b33b672884e9f9da1c83b871/pyarrow-24.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:55a3bc1e3df3b5567b7d27ef551b2283f0c68a5e86f1cd56abc569da4f31335b", size = 48825365, upload-time = "2026-04-21T10:49:11.714Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/eb/771f9ecb0c65e73fe9dccdd1717901b9594f08c4515d000c7c62df573811/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:641f795b361874ac9da5294f8f443dfdbee355cf2bd9e3b8d97aaac2306b9b37", size = 49451819, upload-time = "2026-04-21T10:49:21.474Z" },
+    { url = "https://files.pythonhosted.org/packages/48/da/61ae89a88732f5a785646f3ec6125dbb640fa98a540eb2b9889caa561403/pyarrow-24.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8adc8e6ce5fccf5dc707046ae4914fd537def529709cc0d285d37a7f9cd442ca", size = 51909252, upload-time = "2026-04-21T10:49:31.164Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1a/8dd5cafab7b66573fa91c03d06d213356ad4edd71813aa75e08ce2b3a844/pyarrow-24.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:9b18371ad2f44044b81a8d23bc2d8a9b6a6226dca775e8e16cfee640473d6c5d", size = 27388127, upload-time = "2026-04-21T10:49:37.334Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/80/d022a34ff05d2cbedd8ccf841fc1f532ecfa9eb5ed1711b56d0e0ea71fc9/pyarrow-24.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:1cc9057f0319e26333b357e17f3c2c022f1a83739b48a88b25bfd5fa2dc18838", size = 35007997, upload-time = "2026-04-21T10:49:48.796Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/ff/f01485fda6f4e5d441afb8dd5e7681e4db18826c1e271852f5d3957d6a80/pyarrow-24.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e6f1278ee4785b6db21229374a1c9e54ec7c549de5d1efc9630b6207de7e170b", size = 36678720, upload-time = "2026-04-21T10:49:55.858Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c2/2d2d5fea814237923f71b36495211f20b43a1576f9a4d6da7e751a64ec6f/pyarrow-24.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:adbbedc55506cbdabb830890444fb856bfb0060c46c6f8026c6c2f2cf86ae795", size = 45741852, upload-time = "2026-04-21T10:50:04.624Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/3a/28ba9c1c1ebdbb5f1b94dfebb46f207e52e6a554b7fe4132540fde29a3a0/pyarrow-24.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:ae8a1145af31d903fa9bb166824d7abe9b4681a000b0159c9fb99c11bc11ad26", size = 48889852, upload-time = "2026-04-21T10:50:12.293Z" },
+    { url = "https://files.pythonhosted.org/packages/df/51/4a389acfd31dca009f8fb82d7f510bb4130f2b3a8e18cf00194d0687d8ac/pyarrow-24.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d7027eba1df3b2069e2e8d80f644fa0918b68c46432af3d088ddd390d063ecde", size = 49445207, upload-time = "2026-04-21T10:50:20.677Z" },
+    { url = "https://files.pythonhosted.org/packages/19/4b/0bab2b23d2ae901b1b9a03c0efd4b2d070256f8ce3fc43f6e58c167b2081/pyarrow-24.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e56a1ffe9bf7b727432b89104cc0849c21582949dd7bdcb34f17b2001a351a76", size = 51954117, upload-time = "2026-04-21T10:50:29.14Z" },
+    { url = "https://files.pythonhosted.org/packages/29/88/f4e9145da0417b3d2c12035a8492b35ff4a3dbc653e614fcfb51d9dedb38/pyarrow-24.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:38be1808cdd068605b787e6ca9119b27eb275a0234e50212c3492331680c3b1e", size = 28001155, upload-time = "2026-04-21T10:51:22.337Z" },
+    { url = "https://files.pythonhosted.org/packages/79/4f/46a49a63f43526da895b1a45bbb51d5baf8e4d77159f8528fc3e5490007f/pyarrow-24.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:418e48ce50a45a6a6c73c454677203a9c75c966cb1e92ca3370959185f197a05", size = 35250387, upload-time = "2026-04-21T10:50:35.552Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/da/d5e0cd5ef00796922404806d5f00325cdadc3441ce2c13fe7115f2df9a64/pyarrow-24.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:2f16197705a230a78270cdd4ea8a1d57e86b2fdcbc34a1f6aebc72e65c986f9a", size = 36797102, upload-time = "2026-04-21T10:50:42.417Z" },
+    { url = "https://files.pythonhosted.org/packages/34/c7/5904145b0a593a05236c882933d439b5720f0a145381179063722fbfc123/pyarrow-24.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:fb24ac194bfc5e86839d7dcd52092ee31e5fe6733fe11f5e3b06ef0812b20072", size = 45745118, upload-time = "2026-04-21T10:50:49.324Z" },
+    { url = "https://files.pythonhosted.org/packages/13/d3/cca42fe166d1c6e4d5b80e530b7949104d10e17508a90ae202dac205ce2a/pyarrow-24.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:9700ebd9a51f5895ce75ff4ac4b3c47a7d4b42bc618be8e713e5d56bacf5f931", size = 48844765, upload-time = "2026-04-21T10:50:55.579Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/49/942c3b79878ba928324d1e17c274ed84581db8c0a749b24bcf4cbdf15bd3/pyarrow-24.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d8ddd2768da81d3ee08cfea9b597f4abb4e8e1dc8ae7e204b608d23a0d3ab699", size = 49471890, upload-time = "2026-04-21T10:51:02.439Z" },
+    { url = "https://files.pythonhosted.org/packages/76/97/ff71431000a75d84135a1ace5ca4ba11726a231a8007bbb320a4c54075d5/pyarrow-24.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:61a3d7eaa97a14768b542f3d284dc6400dd2470d9f080708b13cd46b6ae18136", size = 51932250, upload-time = "2026-04-21T10:51:10.576Z" },
+    { url = "https://files.pythonhosted.org/packages/51/be/6f79d55816d5c22557cf27533543d5d70dfe692adfbee4b99f2760674f38/pyarrow-24.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c91d00057f23b8d353039520dc3a6c09d8608164c692e9f59a175a42b2ae0c19", size = 28131282, upload-time = "2026-04-21T10:51:16.815Z" },
+]
+
 [[package]]
 name = "pydantic"
 version = "2.12.5"
@@ -1750,6 +1968,41 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" },
 ]
 
+[[package]]
+name = "rich"
+version = "15.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
+]
+
+[[package]]
+name = "safetensors"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", hash = "sha256:07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0", size = 200878, upload-time = "2025-11-19T15:18:43.199Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/47/aef6c06649039accf914afef490268e1067ed82be62bcfa5b7e886ad15e8/safetensors-0.7.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c82f4d474cf725255d9e6acf17252991c3c8aac038d6ef363a4bf8be2f6db517", size = 467781, upload-time = "2025-11-19T15:18:35.84Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/00/374c0c068e30cd31f1e1b46b4b5738168ec79e7689ca82ee93ddfea05109/safetensors-0.7.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:94fd4858284736bb67a897a41608b5b0c2496c9bdb3bf2af1fa3409127f20d57", size = 447058, upload-time = "2025-11-19T15:18:34.416Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/06/578ffed52c2296f93d7fd2d844cabfa92be51a587c38c8afbb8ae449ca89/safetensors-0.7.0-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e07d91d0c92a31200f25351f4acb2bc6aff7f48094e13ebb1d0fb995b54b6542", size = 491748, upload-time = "2025-11-19T15:18:09.79Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/33/1debbbb70e4791dde185edb9413d1fe01619255abb64b300157d7f15dddd/safetensors-0.7.0-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8469155f4cb518bafb4acf4865e8bb9d6804110d2d9bdcaa78564b9fd841e104", size = 503881, upload-time = "2025-11-19T15:18:16.145Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/1c/40c2ca924d60792c3be509833df711b553c60effbd91da6f5284a83f7122/safetensors-0.7.0-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:54bef08bf00a2bff599982f6b08e8770e09cc012d7bba00783fc7ea38f1fb37d", size = 623463, upload-time = "2025-11-19T15:18:21.11Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/3a/13784a9364bd43b0d61eef4bea2845039bc2030458b16594a1bd787ae26e/safetensors-0.7.0-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:42cb091236206bb2016d245c377ed383aa7f78691748f3bb6ee1bfa51ae2ce6a", size = 532855, upload-time = "2025-11-19T15:18:25.719Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48", size = 507152, upload-time = "2025-11-19T15:18:33.023Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a8/4b45e4e059270d17af60359713ffd83f97900d45a6afa73aaa0d737d48b6/safetensors-0.7.0-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1d060c70284127fa805085d8f10fbd0962792aed71879d00864acda69dbab981", size = 541856, upload-time = "2025-11-19T15:18:31.075Z" },
+    { url = "https://files.pythonhosted.org/packages/06/87/d26d8407c44175d8ae164a95b5a62707fcc445f3c0c56108e37d98070a3d/safetensors-0.7.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:cdab83a366799fa730f90a4ebb563e494f28e9e92c4819e556152ad55e43591b", size = 674060, upload-time = "2025-11-19T15:18:37.211Z" },
+    { url = "https://files.pythonhosted.org/packages/11/f5/57644a2ff08dc6325816ba7217e5095f17269dada2554b658442c66aed51/safetensors-0.7.0-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:672132907fcad9f2aedcb705b2d7b3b93354a2aec1b2f706c4db852abe338f85", size = 771715, upload-time = "2025-11-19T15:18:38.689Z" },
+    { url = "https://files.pythonhosted.org/packages/86/31/17883e13a814bd278ae6e266b13282a01049b0c81341da7fd0e3e71a80a3/safetensors-0.7.0-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:5d72abdb8a4d56d4020713724ba81dac065fedb7f3667151c4a637f1d3fb26c0", size = 714377, upload-time = "2025-11-19T15:18:40.162Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d8/0c8a7dc9b41dcac53c4cbf9df2b9c83e0e0097203de8b37a712b345c0be5/safetensors-0.7.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b0f6d66c1c538d5a94a73aa9ddca8ccc4227e6c9ff555322ea40bdd142391dd4", size = 677368, upload-time = "2025-11-19T15:18:41.627Z" },
+    { url = "https://files.pythonhosted.org/packages/05/e5/cb4b713c8a93469e3c5be7c3f8d77d307e65fe89673e731f5c2bfd0a9237/safetensors-0.7.0-cp38-abi3-win32.whl", hash = "sha256:c74af94bf3ac15ac4d0f2a7c7b4663a15f8c2ab15ed0fc7531ca61d0835eccba", size = 326423, upload-time = "2025-11-19T15:18:45.74Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/e6/ec8471c8072382cb91233ba7267fd931219753bb43814cbc71757bfd4dab/safetensors-0.7.0-cp38-abi3-win_amd64.whl", hash = "sha256:d1239932053f56f3456f32eb9625590cc7582e905021f94636202a864d470755", size = 341380, upload-time = "2025-11-19T15:18:44.427Z" },
+]
+
 [[package]]
 name = "setuptools"
 version = "81.0.0"
@@ -1759,6 +2012,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e1/e3/c164c88b2e5ce7b24d667b9bd83589cf4f3520d97cad01534cd3c4f55fdb/setuptools-81.0.0-py3-none-any.whl", hash = "sha256:fdd925d5c5d9f62e4b74b30d6dd7828ce236fd6ed998a08d81de62ce5a6310d6", size = 1062021, upload-time = "2026-02-06T21:10:37.175Z" },
 ]
 
+[[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 = "sniffio"
 version = "1.3.1"
@@ -1942,6 +2204,32 @@ wheels = [
     { 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 = "torch"
 version = "2.11.0"
@@ -2037,6 +2325,26 @@ 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 = "transformers"
+version = "5.8.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "huggingface-hub" },
+    { name = "numpy" },
+    { name = "packaging" },
+    { name = "pyyaml" },
+    { name = "regex" },
+    { name = "safetensors" },
+    { name = "tokenizers" },
+    { name = "tqdm" },
+    { name = "typer" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e7/e6/4134ea2fbea322cddc7ffc94a0d8ee47fe32ce8e876b320cd37d88edfc4d/transformers-5.8.1.tar.gz", hash = "sha256:4dd5b6de4105725104d84fd6abd74b305f4debfc251b38c648ee5dd087cf543b", size = 8532019, upload-time = "2026-05-13T03:21:57.234Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fc/b1/8be7e7ef0b5200491312201918b6125ef9c9df9dd0f0240ccef9ac824e6b/transformers-5.8.1-py3-none-any.whl", hash = "sha256:5340fb95962162cdfdae5cc91d7f8fedd92ed75216c1154c5e1f590fcf56dd0e", size = 10632882, upload-time = "2026-05-13T03:21:52.876Z" },
+]
+
 [[package]]
 name = "triton"
 version = "3.6.0"
@@ -2056,6 +2364,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f6/56/6113c23ff46c00aae423333eb58b3e60bdfe9179d542781955a5e1514cb3/triton-3.6.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:46bd1c1af4b6704e554cad2eeb3b0a6513a980d470ccfa63189737340c7746a7", size = 188397994, upload-time = "2026-01-20T16:01:14.236Z" },
 ]
 
+[[package]]
+name = "typer"
+version = "0.25.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "click" },
+    { name = "rich" },
+    { name = "shellingham" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/51/9aed62104cea109b820bbd6c14245af756112017d309da813ef107d42e7e/typer-0.25.1.tar.gz", hash = "sha256:9616eb8853a09ffeabab1698952f33c6f29ffdbceb4eaeecf571880e8d7664cc", size = 122276, upload-time = "2026-04-30T19:32:16.964Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/f9/2b3ff4e56e5fa7debfaf9eb135d0da96f3e9a1d5b27222223c7296336e5f/typer-0.25.1-py3-none-any.whl", hash = "sha256:75caa44ed46a03fb2dab8808753ffacdbfea88495e74c85a28c5eefcf5f39c89", size = 58409, upload-time = "2026-04-30T19:32:18.271Z" },
+]
+
 [[package]]
 name = "typing-extensions"
 version = "4.15.0"