diff --git a/backend/app/alembic/versions/084_assessment_submissions_and_result_files.py b/backend/app/alembic/versions/084_assessment_submissions_and_result_files.py
new file mode 100644
index 000000000..df1bd6453
--- /dev/null
+++ b/backend/app/alembic/versions/084_assessment_submissions_and_result_files.py
@@ -0,0 +1,162 @@
+"""Assessment submissions table, submission/result-file pointers, provider error file id
+
+Revision ID: 084
+Revises: 083
+Create Date: 2026-09-09 00:00:00.000000
+
+Assessment submissions leave `evaluation_dataset`, whose type-agnostic name uniqueness
+let an eval dataset block an assessment one. Multi-MB payloads leave Postgres too:
+`submission_input` and `result_files` hold s3:// urls, and `provider_error_file_id`
+keeps OpenAI's error dump fetchable after the poll that surfaced it. `dataset_id` is
+dropped without a backfill: no assessment rows exist in any environment yet.
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision = "084"
+down_revision = "083"
+branch_labels = None
+depends_on = None
+
+RESULT_FILES_CHECK = "ck_assessment_result_files_is_object"
+
+
+def upgrade() -> None:
+    op.create_table(
+        "assessment_submission",
+        sa.Column(
+            "id",
+            postgresql.UUID(as_uuid=True),
+            primary_key=True,
+            comment="Unique identifier for the submission",
+        ),
+        sa.Column(
+            "name",
+            sa.String(),
+            nullable=False,
+            comment="Sanitized name; the object key is derived from it",
+        ),
+        sa.Column(
+            "description", sa.String(), nullable=True, comment="Optional description"
+        ),
+        sa.Column(
+            "object_store_url",
+            sa.String(),
+            nullable=False,
+            comment="Object-store url of the uploaded file; its suffix gives the format",
+        ),
+        sa.Column(
+            "total_items",
+            sa.Integer(),
+            nullable=False,
+            server_default="0",
+            comment="Row count, excluding the header",
+        ),
+        sa.Column(
+            "organization_id",
+            sa.Integer(),
+            sa.ForeignKey("organization.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column(
+            "project_id",
+            sa.Integer(),
+            sa.ForeignKey("project.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column("inserted_at", sa.DateTime(), nullable=False),
+        sa.Column("updated_at", sa.DateTime(), nullable=False),
+        sa.UniqueConstraint(
+            "name",
+            "organization_id",
+            "project_id",
+            name="uq_assessment_submission_name_org_project",
+        ),
+    )
+    op.create_index("ix_assessment_submission_name", "assessment_submission", ["name"])
+
+    op.add_column(
+        "assessment",
+        sa.Column(
+            "result_files",
+            postgresql.JSONB(astext_type=sa.Text()),
+            nullable=False,
+            server_default=sa.text("'{}'::jsonb"),
+            comment=(
+                "Result-file kind (results / errors / <stage>_results) to "
+                "{object_store_url} for every provider batch dump held; raw s3:// in the "
+                "column, presigned per delivery in the BATCH callback"
+            ),
+        ),
+    )
+    op.add_column(
+        "assessment",
+        sa.Column(
+            "submission_input",
+            sa.String(),
+            nullable=True,
+            comment=(
+                "Object-store url of the API-client BATCH submission rows "
+                "(submission.jsonl); the rows are never stored in this table"
+            ),
+        ),
+    )
+    op.drop_column("assessment", "dataset_id")
+    op.add_column(
+        "assessment",
+        sa.Column(
+            "submission_id",
+            postgresql.UUID(as_uuid=True),
+            sa.ForeignKey("assessment_submission.id", ondelete="SET NULL"),
+            nullable=True,
+            comment=(
+                "Uploaded submission the rows came from; set by RUN and by a BATCH "
+                "submitted with `submission_doc_id`. NULL when BATCH sent rows inline"
+            ),
+        ),
+    )
+    op.create_index("ix_assessment_submission_id", "assessment", ["submission_id"])
+
+    op.add_column(
+        "batch_job",
+        sa.Column(
+            "provider_error_file_id",
+            sa.String(),
+            nullable=True,
+            comment=(
+                "Provider's error file ID (OpenAI only; Anthropic and Gemini report "
+                "per-item errors inline)"
+            ),
+        ),
+    )
+    op.create_check_constraint(
+        RESULT_FILES_CHECK,
+        "assessment",
+        "jsonb_typeof(result_files) = 'object'",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint(RESULT_FILES_CHECK, "assessment", type_="check")
+    op.drop_column("batch_job", "provider_error_file_id")
+
+    op.drop_index("ix_assessment_submission_id", table_name="assessment")
+    op.drop_column("assessment", "submission_id")
+    op.add_column(
+        "assessment",
+        sa.Column(
+            "dataset_id",
+            sa.Integer(),
+            sa.ForeignKey("evaluation_dataset.id", ondelete="SET NULL"),
+            nullable=True,
+            comment="External dataset (RUN); binding lives in `input`",
+        ),
+    )
+
+    op.drop_column("assessment", "submission_input")
+    op.drop_column("assessment", "result_files")
+
+    op.drop_index("ix_assessment_submission_name", table_name="assessment_submission")
+    op.drop_table("assessment_submission")
diff --git a/backend/app/api/docs/assessment/create.md b/backend/app/api/docs/assessment/create.md
index 5e956c4d4..d8c140205 100644
--- a/backend/app/api/docs/assessment/create.md
+++ b/backend/app/api/docs/assessment/create.md
@@ -1,4 +1,4 @@
-Submit an assessment against a saved LLM configuration; results are delivered by webhook.
+Submit an assessment against a saved LLM configuration; poll for the result, or have it pushed to a webhook.
 
 An assessment grades one or more items with a config-defined LLM call, optionally gated by
 pre-filters (topic relevance / duplicate detection). The run mode is **inferred from the input
@@ -10,8 +10,8 @@ shape** — you do not pass a mode flag.
 * Pins to a saved config **version** (`config.id` + `config.version`); the config must be tagged
   `ASSESSMENT` (see the config-create docs for the `config_blob` assessment shape).
 * Optional pre-filters run before the grading call and can gate it per item.
-* **Webhook-only delivery** — the result is POSTed to the request's `callback_url` on completion.
-  There is no status or result poll endpoint.
+* **Two ways to get the result** — poll `GET /assessments/{assessment_id}`, and/or supply a
+  `callback_url` to have the finished result POSTed to you on completion.
 * `request_metadata` is echoed back unchanged in the callback for correlation.
 
 > **RESPONSE mode is not wired yet** — a single-object input currently returns `501 Not Implemented`.
@@ -53,12 +53,15 @@ shape** — you do not pass a mode flag.
   * **BATCH** — `{ "query": "<template>", "data": [ {<column>: <value>}, ... ] }`
     * `query` (required, non-empty) — a template with `{column}` placeholders substituted per row.
     * `data` (required, ≥ 1 row) — submission rows. Each row is a flat `column -> string` map. The
-      config's `assessment.params.input_schema` is **mandatory** and defines every column and its
-      `type` (`text` / `image` / `pdf`, with an attachment `format`). Every row is validated against
-      it: each declared column must be present, no undeclared columns are allowed, and `image`/`pdf`
-      columns must carry a URL. A row that does not match fails with `422` (see Errors).
+      config's `input_schema` is **mandatory** and defines every column: its `type` (`text` / `image` /
+      `pdf`, with an attachment `format`) and `strict` (default `false`). Every row is validated
+      against it: a `strict: true` column must be present and non-blank, any other column may be
+      omitted or left blank, an inline `data` row may not carry undeclared columns (a
+      `submission_doc_id` sheet's undeclared columns are ignored, so the schema selects which
+      columns take part), and a non-blank `image`/`pdf` value must be a URL. A row that does not
+      match fails with `422` (see Errors).
   * **RESPONSE** — `{ "query": "<text>", "attachments": [ ... ] }` *(deferred — returns 501)*.
-* `callback_url` (required) — the webhook the result is POSTed to on completion.
+* `callback_url` (optional) — the webhook the result is POSTed to on completion. Omit it to poll instead.
 * `request_metadata` (optional) — arbitrary object passed through unchanged in the callback.
 
 The two input shapes are strictly discriminated: a body carrying `data` is BATCH, one carrying
@@ -142,6 +145,6 @@ On completion the platform POSTs this payload to `callback_url`:
 
 * `501 Not Implemented` — RESPONSE-mode input (single object) is not wired yet; send a BATCH `data` list.
 * `422 Unprocessable Entity` — the body failed validation (e.g. `config.id`/`config.version` missing,
-  `callback_url` missing, or an input shape that carries both `data` and `attachments`), or a
-  submission row does not match the config's `input_schema` (a missing declared column, an
+  an input shape carrying both `data` and `submission_doc_id`, or neither), or a
+  submission row does not match the config's `input_schema` (a strict column absent or blank, an
   undeclared extra column, or a non-URL `image`/`pdf` value). The row index is named in the error.
diff --git a/backend/app/api/docs/assessment/export_assessment_results.md b/backend/app/api/docs/assessment/export_assessment_results.md
index f832400d3..692fa50d2 100644
--- a/backend/app/api/docs/assessment/export_assessment_results.md
+++ b/backend/app/api/docs/assessment/export_assessment_results.md
@@ -1,4 +1,7 @@
-Export results for all child runs under an assessment.
+Export results for all child runs under a RUN assessment.
 
 For `json`, returns a flat list in the API response. For `csv`/`xlsx`,
 returns one file for a single run or a ZIP archive when multiple runs exist.
+
+Returns `422` for a BATCH assessment: its rows are served by
+`GET /assessments/{assessment_id}`.
diff --git a/backend/app/api/docs/assessment/get_assessment_detail.md b/backend/app/api/docs/assessment/get_assessment_detail.md
new file mode 100644
index 000000000..53f4fb2a6
--- /dev/null
+++ b/backend/app/api/docs/assessment/get_assessment_detail.md
@@ -0,0 +1,21 @@
+Fetch a BATCH assessment's status and every row it has produced so far.
+
+Safe to poll while the run is in flight. `items` always holds exactly `total_items`
+entries, in submission order, including placeholders for rows the provider has not
+returned yet (`output.assessment` is `null`) and for rows a pre-filter gated out.
+
+Each row carries:
+
+- `row_index` — position in the original submission; the stable correlator.
+- `input` — the submitted row, echoed back only when `include_input=true`. That flag
+  re-reads the stored submission from object storage on every call, so leave it off in
+  a tight poll loop and set it once the run is terminal. `null` if the stored submission
+  could not be read.
+- `output` — identical in shape to the webhook payload's item, so one parser serves both.
+- `error` — the provider's error for that row, when it failed.
+
+Stop polling once `status` is `COMPLETED`, `COMPLETED_WITH_ERRORS` or `FAILED`. On a
+failed run, `error` carries the reason.
+
+Returns 404 when the assessment does not exist in this project, and 422 when it is not
+a BATCH assessment.
diff --git a/backend/app/api/docs/assessment/list_assessments.md b/backend/app/api/docs/assessment/list_assessments.md
index 3e0f6f2c1..a9789c2f9 100644
--- a/backend/app/api/docs/assessment/list_assessments.md
+++ b/backend/app/api/docs/assessment/list_assessments.md
@@ -1,3 +1,14 @@
-List assessments runs for the current organization/project.
+List this project's BATCH assessments, newest first.
 
-Each record includes aggregate status counters across its child runs.
+Each row carries where the run is and what it was pinned to — status, stage, the config
+id and version, and the row count. It deliberately carries **no per-row counts or
+results**: those need the provider dump streamed back from object storage, which a list
+must not pay for. Fetch `GET /assessments/{assessment_id}` for a single run's rows.
+
+**Filtering**
+
+- `config_id` — return only the runs pinned to that config. Omit it for every run.
+- `version` — narrow further to one version of that config. Applied only with
+  `config_id`; omit it for every version.
+
+`limit` defaults to 50 (max 100) and `offset` pages through.
diff --git a/backend/app/api/docs/assessment/upload_dataset.md b/backend/app/api/docs/assessment/upload_dataset.md
index 358803c5f..49b51051e 100644
--- a/backend/app/api/docs/assessment/upload_dataset.md
+++ b/backend/app/api/docs/assessment/upload_dataset.md
@@ -2,3 +2,7 @@ Upload a CSV or Excel dataset for assessment workflows.
 
 The file is stored in object storage and indexed as an assessment dataset
 for the current organization and project.
+
+Excel files are cleaned on read: blank rows are dropped, then any column with no
+header or no values. `total_items`, the preview and the run all see the cleaned
+sheet, so a 1000-row sheet with 100 filled rows reports `total_items: 100`.
diff --git a/backend/app/api/docs/config/create.md b/backend/app/api/docs/config/create.md
index c4a84b0b4..4c3740468 100644
--- a/backend/app/api/docs/config/create.md
+++ b/backend/app/api/docs/config/create.md
@@ -83,13 +83,17 @@ When `tag` is `"ASSESSMENT"`, `config_blob` uses the assessment shape instead of
 not rendered in the OpenAPI spec (so the default `config_blob` schema stays stable) — the
 shape is documented here:
 
+* `input_schema` (required, at the `config_blob` root) — **non-empty** mapping of each
+  submission column name to `{ type, format, strict }` (`type` is **required**: `text` |
+  `image` | `pdf`; `format`: `url` for attachment columns; `strict` defaults to `false`).
+  A `strict: true` column must be present and non-blank in every submission row; any other
+  column may be omitted or blank (see the submit docs for per-row validation). Unknown keys
+  in a column spec are rejected. Shared by the pre-filter and the assessment call.
 * `assessment` (required) — the grading call. `provider` is `openai` | `google` |
   `anthropic`, `type` is `"text"`. `params` carries the `model`, the `instructions`
-  (system prompt), an optional `json_output_schema` (structured-output JSON schema), and a
-  **mandatory, non-empty** `input_schema` mapping each column name to `{ type, format }`
-  (`type` is **required**: `text` | `image` | `pdf`; `format`: `url` for attachment
-  columns). Every declared column must be present in every submission row (see the submit
-  docs for per-row validation).
+  (system prompt), the **mandatory** per-row `submission` template (`{column}`
+  placeholders must name `input_schema` keys), and an optional `json_output_schema`
+  (structured-output JSON schema).
 * `pre_filters` (optional) — `topic_relevance` and/or `duplicate_detection`. Each runs its
   own llm call, so it carries `provider` (default `openai`) + its own `params`
   (a `TextLLMParams` object: `model`, `temperature`, …). Its criteria live in
@@ -101,6 +105,10 @@ shape is documented here:
 
 ```json
 "config_blob": {
+  "input_schema": {
+    "gcs_url": { "type": "image", "format": "url", "strict": true },
+    "rubric":  { "type": "text" }
+  },
   "pre_filters": {
     "topic_relevance": {
       "provider": "openai",
@@ -118,10 +126,7 @@ shape is documented here:
     "params": {
       "model": "gpt-4o",
       "instructions": "You are an AI Assessment Evaluator ...",
-      "input_schema": {
-        "gcs_url": { "type": "image", "format": "url" },
-        "rubric":  { "type": "text" }
-      },
+      "submission": "Grade the attached answer sheet against this rubric: {rubric}",
       "json_output_schema": {
         "type": "object",
         "properties": { "grade": { "type": "string" }, "feedback": { "type": "string" } },
diff --git a/backend/app/api/docs/config/create_version.md b/backend/app/api/docs/config/create_version.md
index cbee8895f..f1922e54a 100644
--- a/backend/app/api/docs/config/create_version.md
+++ b/backend/app/api/docs/config/create_version.md
@@ -6,13 +6,15 @@ create a new version under the same configuration with an incremented version nu
 Version numbers are automatically incremented sequentially (1, 2, 3, etc.)
 and cannot be manually set or skipped.
 
-## Examples
+The `config_blob` shape follows the parent config: the `completion` shape for a
+`default` config, the `assessment` shape for an `ASSESSMENT` config. How the body is
+applied differs between the two, so read the matching section below.
 
-Send only the fields you want to change. The `config_blob` shape follows the parent
-config: the `completion` shape for a `default` config, the `assessment` shape for an
-`ASSESSMENT` config.
+## default configs — partial update
+
+Send only the fields you want to change. They are merged onto the latest version, so
+anything you omit is carried forward.
 
-**When the parent config is `default` (completion shape):**
 ```json
 {
   "config_blob": {
@@ -24,24 +26,44 @@ config: the `completion` shape for a `default` config, the `assessment` shape fo
 }
 ```
 
-**When the parent config is `ASSESSMENT` (assessment shape):**
+## ASSESSMENT configs — full blob
+
+Send the **whole** `config_blob` every time. It replaces the previous version rather than
+merging onto it, so a column dropped from `input_schema`, a removed `json_output_schema`
+field, or an omitted `pre_filters` block is genuinely gone in the new version. A partial
+body is rejected with `422`, because `input_schema` and `assessment` are mandatory.
+
 ```json
 {
   "config_blob": {
+    "input_schema": {
+      "rubric": { "type": "text" },
+      "answer": { "type": "text", "strict": true }
+    },
     "pre_filters": {
       "topic_relevance": {
-        "params": { "model": "gpt-4o", "instructions": "Is this a Class 7 answer sheet?" }
+        "provider": "openai",
+        "params": { "model": "gpt-4o", "instructions": "Is this a Class 7 answer sheet?" },
+        "stop_on_fail": true
       }
     },
     "assessment": {
-      "params": { "model": "gpt-4o" }
+      "provider": "openai",
+      "type": "text",
+      "params": {
+        "model": "gpt-4o",
+        "instructions": "You are an AI Assessment Evaluator ...",
+        "submission": "Grade this answer against the rubric: {rubric}\n\nAnswer: {answer}"
+      }
     }
   },
-  "commit_message": "Switch grading model"
+  "commit_message": "Drop the unused columns"
 }
 ```
 
 ## Important
-- This endpoint accepts partial updates using dict[str, Any] for config_blob.
-- Only the fields that need to be updated should be provided.
-- The `type` field is inherited from the existing configuration and cannot be changed. Provider and model can change between versions.
+- Every field inside `config_blob` can change between versions, including provider and model.
+- `tag` belongs to the parent configuration and is never part of a version body.
+- `type` is inherited from the existing configuration and cannot be changed.
+- A run pins the `config_id` and `version` it was submitted with, so a new version never
+  alters a run that is already in flight or finished.
diff --git a/backend/app/api/routes/assessment/api.py b/backend/app/api/routes/assessment/api.py
index 41494e662..c8246a4e8 100644
--- a/backend/app/api/routes/assessment/api.py
+++ b/backend/app/api/routes/assessment/api.py
@@ -4,22 +4,29 @@
     - RESPONSE: single object input (`input` key) — deferred, returns 501.
     - BATCH: submission-list input (`data` key) — N items over one provider batch series.
 
-Results are delivered by webhook only (the request's required `callback_url`); there is no
-status or result poll endpoint.
+Results are delivered to the request's `callback_url` when one is given, and are always
+readable from `GET /assessments/{assessment_id}`.
 """
 
 import logging
+from typing import Annotated
+from uuid import UUID
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Query
 
 from app.api.deps import AuthContextDep, SessionDep
 from app.api.permissions import Permission, require_permission
+from app.crud.assessment import api as api_crud
+from app.crud.assessment.core import get_assessment_by_id
 from app.models.assessment import (
     AssessmentCreate,
+    AssessmentDetailResponse,
+    AssessmentMethod,
     AssessmentSubmitResponse,
+    AssessmentSummary,
     BatchInput,
 )
-from app.services.assessment.api import submission
+from app.services.assessment.api import results, submission
 from app.utils import APIResponse, load_description
 
 logger = logging.getLogger(__name__)
@@ -44,7 +51,7 @@ def create_assessment(
     auth_context: AuthContextDep,
 ) -> APIResponse[AssessmentSubmitResponse]:
     """Submit an assessment; the method is inferred from the input shape. The result is
-    delivered to the request's `callback_url` on completion (webhook only)."""
+    pushed to `callback_url` when one is given, and is polled from GET otherwise."""
     if not isinstance(request.input, BatchInput):
         raise HTTPException(status_code=501, detail=_RESPONSE_NOT_WIRED)
 
@@ -55,3 +62,79 @@ def create_assessment(
         project_id=auth_context.project_.id,
     )
     return APIResponse.success_response(data=result)
+
+
+@router.get(
+    "",
+    description=load_description("assessment/list_assessments.md"),
+    response_model=APIResponse[list[AssessmentSummary]],
+    dependencies=[Depends(require_permission(Permission.REQUIRE_PROJECT))],
+)
+def list_assessments(
+    session: SessionDep,
+    auth_context: AuthContextDep,
+    config_id: Annotated[
+        UUID | None,
+        Query(description="Only runs pinned to this config; omit for every run"),
+    ] = None,
+    version: Annotated[
+        int | None,
+        Query(ge=1, description="Config version; omit for every version of config_id"),
+    ] = None,
+    limit: Annotated[int, Query(ge=1, le=100)] = 50,
+    offset: Annotated[int, Query(ge=0)] = 0,
+) -> APIResponse[list[AssessmentSummary]]:
+    """BATCH assessments newest-first, optionally narrowed to one config or version."""
+    rows = api_crud.list_assessments_with_execution(
+        session=session,
+        organization_id=auth_context.organization_.id,
+        project_id=auth_context.project_.id,
+        config_id=config_id,
+        config_version=version,
+        limit=limit,
+        offset=offset,
+    )
+    return APIResponse.success_response(
+        data=[
+            results.build_summary(assessment, execution, submission_name)
+            for assessment, execution, submission_name in rows
+        ]
+    )
+
+
+@router.get(
+    "/{assessment_id}",
+    description=load_description("assessment/get_assessment_detail.md"),
+    response_model=APIResponse[AssessmentDetailResponse],
+    dependencies=[Depends(require_permission(Permission.REQUIRE_PROJECT))],
+)
+def get_assessment_detail(
+    assessment_id: UUID,
+    session: SessionDep,
+    auth_context: AuthContextDep,
+    include_input: Annotated[
+        bool,
+        Query(description="Echo each row's submitted columns (one extra storage read)"),
+    ] = False,
+) -> APIResponse[AssessmentDetailResponse]:
+    """Status plus every row produced so far; safe to poll while the run is in flight."""
+    assessment = get_assessment_by_id(
+        session=session,
+        assessment_id=assessment_id,
+        organization_id=auth_context.organization_.id,
+        project_id=auth_context.project_.id,
+    )
+    if assessment.method != AssessmentMethod.BATCH:
+        raise HTTPException(
+            status_code=422,
+            detail=(
+                f"Assessment {assessment_id} is a {assessment.method} assessment; "
+                f"this endpoint serves BATCH only."
+            ),
+        )
+
+    return APIResponse.success_response(
+        data=results.build_detail(
+            session=session, assessment=assessment, include_input=include_input
+        )
+    )
diff --git a/backend/app/api/routes/assessment/assessments.py b/backend/app/api/routes/assessment/assessments.py
index 287fabb94..56dde8729 100644
--- a/backend/app/api/routes/assessment/assessments.py
+++ b/backend/app/api/routes/assessment/assessments.py
@@ -1,14 +1,14 @@
 """Parent-assessment endpoints (LEGACY RUN pipeline).
 
-Serves dataset-based RUN assessments only. The new API-client BATCH path
-(`api.py`) delivers results by webhook and never surfaces here.
+Serves submission-based RUN assessments only. The API-client BATCH path (`api.py`) has
+its own list/detail endpoints; its rows never surface here.
 """
 
 import logging
 from typing import Any, Literal
 from uuid import UUID
 
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Depends, HTTPException, Query
 from fastapi.responses import StreamingResponse
 
 from sqlmodel import Session
@@ -25,10 +25,11 @@
 )
 from app.models.assessment import (
     Assessment,
+    AssessmentMethod,
     AssessmentPublic,
     AssessmentResponse,
+    AssessmentSubmission,
 )
-from app.models.evaluation import EvaluationDataset
 from app.services.assessment.service import retry_assessment as retry_assessment_service
 from app.services.assessment.utils import build_assessment_results_response
 from app.utils import APIResponse, load_description
@@ -47,12 +48,13 @@ def _build_assessment_public(
         session=session, assessment_id=assessment.id
     )
     counts = compute_run_counts(runs)
-    dataset = session.get(EvaluationDataset, assessment.dataset_id)
+    submission = session.get(AssessmentSubmission, assessment.submission_id)
     return AssessmentPublic(
         id=assessment.id,
         experiment_name=assessment.experiment_name,
-        dataset_id=assessment.dataset_id,
-        dataset_name=dataset.name if dataset else None,
+        method=assessment.method,
+        submission_id=assessment.submission_id,
+        submission_name=submission.name if submission else None,
         status=assessment.status,
         counts=counts,
         run_stats=build_run_stats(runs),
@@ -76,7 +78,7 @@ def retry_assessment(
     session: SessionDep,
     auth_context: AuthContextDep,
 ) -> APIResponse[AssessmentResponse]:
-    """Retry a parent assessment using the same dataset/config inputs."""
+    """Retry a parent assessment using the same submission/config inputs."""
     assessment = get_assessment_by_id(
         session=session,
         assessment_id=assessment_id,
@@ -167,6 +169,14 @@ def export_assessment_results(
         organization_id=auth_context.organization_.id,
         project_id=auth_context.project_.id,
     )
+    if assessment.method != AssessmentMethod.RUN:
+        raise HTTPException(
+            status_code=422,
+            detail=(
+                f"Assessment {assessment_id} is a {assessment.method} assessment; this "
+                f"export serves RUN only. Read its rows from GET /assessments/{assessment_id}."
+            ),
+        )
 
     runs = get_assessment_runs_for_assessment(
         session=session, assessment_id=assessment_id
diff --git a/backend/app/api/routes/assessment/datasets.py b/backend/app/api/routes/assessment/datasets.py
index 22f000c4d..7ac4ea8dc 100644
--- a/backend/app/api/routes/assessment/datasets.py
+++ b/backend/app/api/routes/assessment/datasets.py
@@ -1,27 +1,25 @@
-"""Assessment dataset endpoints."""
+"""Assessment submission-file endpoints."""
 
 import logging
 from typing import Annotated
+from uuid import UUID
 
 from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, UploadFile
 
 from app.api.deps import AuthContextDep, SessionDep
 from app.api.permissions import Permission, require_permission
 from app.core.cloud import get_cloud_storage
-from app.crud.assessment.dataset import (
-    delete_assessment_dataset,
-    get_assessment_dataset_by_id,
-    list_assessment_datasets,
+from app.crud.assessment.submission import (
+    delete_submission,
+    get_submission_by_id,
+    list_submissions,
 )
 from app.models.assessment import (
-    AssessmentDatasetPreview,
-    AssessmentDatasetResponse,
+    AssessmentSubmission,
+    AssessmentSubmissionPreview,
+    AssessmentSubmissionResponse,
 )
-from app.models.evaluation import EvaluationDataset
-from app.services.assessment.dataset import (
-    preview_dataset as preview_assessment_dataset,
-)
-from app.services.assessment.dataset import upload_dataset as upload_assessment_dataset
+from app.services.assessment.submission import preview_submission, upload_submission
 from app.services.assessment.validators import validate_dataset_file
 from app.utils import APIResponse, load_description
 
@@ -30,19 +28,17 @@
 router = APIRouter()
 
 
-def _dataset_to_response(
-    dataset: EvaluationDataset,
+def _submission_to_response(
+    submission: AssessmentSubmission,
     signed_url: str | None = None,
-    preview: AssessmentDatasetPreview | None = None,
-) -> AssessmentDatasetResponse:
-    metadata = dataset.dataset_metadata or {}
-    return AssessmentDatasetResponse(
-        dataset_id=dataset.id,
-        dataset_name=dataset.name,
-        description=dataset.description,
-        total_items=metadata.get("total_items_count", 0),
-        file_extension=metadata.get("file_extension"),
-        object_store_url=dataset.object_store_url,
+    preview: AssessmentSubmissionPreview | None = None,
+) -> AssessmentSubmissionResponse:
+    return AssessmentSubmissionResponse(
+        submission_id=submission.id,
+        name=submission.name,
+        description=submission.description,
+        total_items=submission.total_items,
+        object_store_url=submission.object_store_url,
         signed_url=signed_url,
         preview=preview,
     )
@@ -51,50 +47,48 @@ def _dataset_to_response(
 @router.post(
     "/datasets",
     description=load_description("assessment/upload_dataset.md"),
-    response_model=APIResponse[AssessmentDatasetResponse],
+    response_model=APIResponse[AssessmentSubmissionResponse],
     dependencies=[Depends(require_permission(Permission.REQUIRE_PROJECT))],
 )
 async def upload_dataset(
     session: SessionDep,
     auth_context: AuthContextDep,
-    file: UploadFile = File(
-        ..., description="CSV or Excel file to upload as a dataset"
-    ),
-    dataset_name: str = Form(..., description="Name for the dataset"),
-    description: str | None = Form(None, description="Optional dataset description"),
-) -> APIResponse[AssessmentDatasetResponse]:
-    """Upload an assessment dataset (any CSV/Excel file, no column requirements)."""
+    file: UploadFile = File(..., description="CSV or Excel file to upload"),
+    dataset_name: str = Form(..., description="Name for the submission"),
+    description: str | None = Form(None, description="Optional description"),
+) -> APIResponse[AssessmentSubmissionResponse]:
+    """Upload a submission file (any CSV/Excel file, no column requirements)."""
     file_content, file_ext = await validate_dataset_file(file)
 
-    dataset = upload_assessment_dataset(
+    submission = upload_submission(
         session=session,
         file_content=file_content,
         file_ext=file_ext,
-        dataset_name=dataset_name,
+        submission_name=dataset_name,
         description=description,
         organization_id=auth_context.organization_.id,
         project_id=auth_context.project_.id,
     )
 
-    return APIResponse.success_response(data=_dataset_to_response(dataset))
+    return APIResponse.success_response(data=_submission_to_response(submission))
 
 
 @router.get(
     "/datasets",
     description=load_description("assessment/list_datasets.md"),
-    response_model=APIResponse[list[AssessmentDatasetResponse]],
+    response_model=APIResponse[list[AssessmentSubmissionResponse]],
     dependencies=[Depends(require_permission(Permission.REQUIRE_PROJECT))],
 )
 def list_datasets(
     session: SessionDep,
     auth_context: AuthContextDep,
     limit: int = Query(
-        default=50, ge=1, le=100, description="Maximum number of datasets to return"
+        default=50, ge=1, le=100, description="Maximum number of records to return"
     ),
-    offset: int = Query(default=0, ge=0, description="Number of datasets to skip"),
-) -> APIResponse[list[AssessmentDatasetResponse]]:
-    """List assessment datasets."""
-    datasets = list_assessment_datasets(
+    offset: int = Query(default=0, ge=0, description="Number of records to skip"),
+) -> APIResponse[list[AssessmentSubmissionResponse]]:
+    """List uploaded submission files."""
+    submissions = list_submissions(
         session=session,
         organization_id=auth_context.organization_.id,
         project_id=auth_context.project_.id,
@@ -103,18 +97,18 @@ def list_datasets(
     )
 
     return APIResponse.success_response(
-        data=[_dataset_to_response(dataset) for dataset in datasets]
+        data=[_submission_to_response(submission) for submission in submissions]
     )
 
 
 @router.get(
     "/datasets/{dataset_id}",
     description=load_description("assessment/get_dataset.md"),
-    response_model=APIResponse[AssessmentDatasetResponse],
+    response_model=APIResponse[AssessmentSubmissionResponse],
     dependencies=[Depends(require_permission(Permission.REQUIRE_PROJECT))],
 )
 def get_dataset(
-    dataset_id: int,
+    dataset_id: UUID,
     session: SessionDep,
     auth_context: AuthContextDep,
     include_signed_url: bool = Query(
@@ -132,31 +126,31 @@ def get_dataset(
             ),
         ),
     ] = None,
-) -> APIResponse[AssessmentDatasetResponse]:
-    """Get a specific assessment dataset."""
-    dataset = get_assessment_dataset_by_id(
+) -> APIResponse[AssessmentSubmissionResponse]:
+    """Get one uploaded submission file."""
+    submission = get_submission_by_id(
         session=session,
-        dataset_id=dataset_id,
+        submission_id=dataset_id,
         organization_id=auth_context.organization_.id,
         project_id=auth_context.project_.id,
     )
 
     signed_url = None
-    if include_signed_url and dataset.object_store_url:
+    if include_signed_url and submission.object_store_url:
         storage = get_cloud_storage(
             session=session, project_id=auth_context.project_.id
         )
-        signed_url = storage.get_signed_url(dataset.object_store_url)
+        signed_url = storage.get_signed_url(submission.object_store_url)
 
-    preview: AssessmentDatasetPreview | None = None
+    preview: AssessmentSubmissionPreview | None = None
     if limit_rows is not None:
-        headers, rows = preview_assessment_dataset(
+        headers, rows = preview_submission(
             session=session,
-            dataset=dataset,
+            submission=submission,
             project_id=auth_context.project_.id,
             limit=limit_rows,
         )
-        preview = AssessmentDatasetPreview(
+        preview = AssessmentSubmissionPreview(
             headers=headers,
             rows=rows,
             returned_rows=len(rows),
@@ -164,7 +158,7 @@ def get_dataset(
         )
 
     return APIResponse.success_response(
-        data=_dataset_to_response(dataset, signed_url=signed_url, preview=preview)
+        data=_submission_to_response(submission, signed_url=signed_url, preview=preview)
     )
 
 
@@ -175,28 +169,28 @@ def get_dataset(
     dependencies=[Depends(require_permission(Permission.REQUIRE_PROJECT))],
 )
 def delete_dataset(
-    dataset_id: int,
+    dataset_id: UUID,
     session: SessionDep,
     auth_context: AuthContextDep,
 ) -> APIResponse[dict]:
-    """Delete an assessment dataset."""
-    dataset = get_assessment_dataset_by_id(
+    """Delete an uploaded submission file."""
+    submission = get_submission_by_id(
         session=session,
-        dataset_id=dataset_id,
+        submission_id=dataset_id,
         organization_id=auth_context.organization_.id,
         project_id=auth_context.project_.id,
     )
 
-    dataset_name = dataset.name
-    error = delete_assessment_dataset(session=session, dataset=dataset)
+    submission_name = submission.name
+    error = delete_submission(session=session, submission=submission)
     if error:
         raise HTTPException(status_code=400, detail=error)
 
     return APIResponse.success_response(
         data={
             "message": (
-                f"Successfully deleted dataset '{dataset_name}' (id={dataset_id})"
+                f"Successfully deleted submission '{submission_name}' (id={dataset_id})"
             ),
-            "dataset_id": dataset_id,
+            "submission_id": str(dataset_id),
         }
     )
diff --git a/backend/app/api/routes/assessment/runs.py b/backend/app/api/routes/assessment/runs.py
index 473b5dad9..a1c6a7332 100644
--- a/backend/app/api/routes/assessment/runs.py
+++ b/backend/app/api/routes/assessment/runs.py
@@ -1,6 +1,6 @@
 """Assessment run endpoints — one row per config-run inside a parent assessment (LEGACY RUN pipeline).
 
-Serves dataset-based RUN assessments only. The new API-client BATCH path
+Serves submission-based RUN assessments only. The new API-client BATCH path
 (`api.py`) delivers results by webhook and never surfaces here.
 """
 
@@ -30,7 +30,7 @@
     AssessmentRunPublic,
     AssessmentRunResponse,
 )
-from app.models.evaluation import EvaluationDataset
+from app.models.assessment import AssessmentSubmission
 from app.services.assessment.service import (
     resume_assessment_run as resume_run,
 )
@@ -58,7 +58,7 @@ def _build_run_public(
     session: SessionDep,
     run: AssessmentRun,
 ) -> AssessmentRunPublic:
-    """Build AssessmentRunPublic with parent-derived experiment/dataset info."""
+    """Build AssessmentRunPublic with parent-derived experiment/submission info."""
     parent = session.get(Assessment, run.assessment_id)
     if parent is None:
         logger.warning(
@@ -66,13 +66,15 @@ def _build_run_public(
             run.assessment_id,
             run.id,
         )
-    dataset = session.get(EvaluationDataset, parent.dataset_id) if parent else None
+    submission = (
+        session.get(AssessmentSubmission, parent.submission_id) if parent else None
+    )
     return AssessmentRunPublic(
         id=run.id,
         assessment_id=run.assessment_id,
         experiment_name=parent.experiment_name if parent else None,
-        dataset_id=parent.dataset_id if parent else None,
-        dataset_name=dataset.name if dataset else None,
+        submission_id=parent.submission_id if parent else None,
+        submission_name=submission.name if submission else None,
         config_id=run.config_id,
         config_version=run.config_version,
         status=run.status,
@@ -104,9 +106,9 @@ def create_assessment_runs(
 ) -> APIResponse[AssessmentRunResponse]:
     """Submit an assessment and create one child run per config."""
     logger.info(
-        "[create_assessment_runs] Assessment run submission | experiment=%s | dataset_id=%s | configs=%s",
+        "[create_assessment_runs] Assessment run submission | experiment=%s | submission_id=%s | configs=%s",
         request.experiment_name,
-        request.dataset_id,
+        request.submission_id,
         len(request.configs),
     )
 
diff --git a/backend/app/celery/tasks/job_execution.py b/backend/app/celery/tasks/job_execution.py
index e49be35d9..483384364 100644
--- a/backend/app/celery/tasks/job_execution.py
+++ b/backend/app/celery/tasks/job_execution.py
@@ -18,6 +18,7 @@
 
 from asgi_correlation_id import correlation_id
 from celery import Task, current_task
+from gevent import Timeout
 from opentelemetry import context as otel_context
 from opentelemetry import trace
 from opentelemetry.propagate import extract
@@ -357,7 +358,15 @@ def run_assessment_pipeline(
     )
 
 
-@celery_app.task(bind=True, queue="default", priority=2)
+@celery_app.task(
+    bind=True,
+    queue="default",
+    priority=2,
+    autoretry_for=(Exception, Timeout),
+    retry_backoff=True,
+    # A task whose worker is lost is acked, not re-queued, so it cannot redeliver in a loop.
+    reject_on_worker_lost=False,
+)
 @gevent_timeout(settings.CELERY_TASK_SOFT_TIME_LIMIT, "run_assessment_api_batch")
 def run_assessment_api_batch(
     self,
@@ -367,11 +376,9 @@ def run_assessment_api_batch(
     trace_id: str,
     **kwargs,
 ):
-    """Drive one tick of the BATCH API-client staged pipeline.
+    """Run one step of the BATCH API-client staged pipeline.
 
-    Self-re-enqueues (``apply_async(countdown=...)``) while a stage batch is still
-    in flight or a next stage was just submitted, and stops once the run finalises
-    or fails. Idempotent — the service keys off the stage_status in the exec bag.
+    Self-re-enqueues while a stage is in flight; idempotent, so a failed task is retried.
     """
     from app.services.assessment.api.batch import (
         POLL_COUNTDOWN_SECONDS,
diff --git a/backend/app/core/batch/operations.py b/backend/app/core/batch/operations.py
index bcd51866b..d8db4151b 100644
--- a/backend/app/core/batch/operations.py
+++ b/backend/app/core/batch/operations.py
@@ -118,12 +118,12 @@ def process_completed_batch(
     provider: BatchProvider,
     batch_job: BatchJob,
     upload_to_object_store: bool = True,
+    subdirectory: str | None = None,
 ) -> tuple[list[dict[str, Any]], str | None]:
-    """
-    Process a completed batch: download results and optionally upload to object store.
+    """Download a completed batch's results and optionally store them.
 
-    Returns:
-        Tuple of (results, object_store_url)
+    ``subdirectory`` overrides the default ``<job_type>/batch-<id>`` prefix.
+    Returns ``(results, object_store_url)``.
     """
     logger.info(f"[process_completed_batch] Processing | id={batch_job.id}")
 
@@ -134,7 +134,10 @@ def process_completed_batch(
         if upload_to_object_store:
             try:
                 object_store_url = upload_batch_results_to_object_store(
-                    session=session, batch_job=batch_job, results=results
+                    session=session,
+                    batch_job=batch_job,
+                    results=results,
+                    subdirectory=subdirectory,
                 )
                 logger.info(
                     f"[process_completed_batch] Uploaded to object store | {object_store_url}"
@@ -160,9 +163,12 @@ def process_completed_batch(
 
 
 def upload_batch_results_to_object_store(
-    session: Session, batch_job: BatchJob, results: list[dict[str, Any]]
+    session: Session,
+    batch_job: BatchJob,
+    results: list[dict[str, Any]],
+    subdirectory: str | None = None,
 ) -> str | None:
-    """Upload batch results to object store."""
+    """Upload batch results to object store; ``subdirectory`` overrides the default prefix."""
     logger.info(
         f"[upload_batch_results_to_object_store] Uploading | batch_job_id={batch_job.id}"
     )
@@ -170,7 +176,7 @@ def upload_batch_results_to_object_store(
     try:
         storage = get_cloud_storage(session=session, project_id=batch_job.project_id)
 
-        subdirectory = f"{batch_job.job_type}/batch-{batch_job.id}"
+        subdirectory = subdirectory or f"{batch_job.job_type}/batch-{batch_job.id}"
         filename = "results.jsonl"
 
         object_store_url = shared_upload_jsonl(
diff --git a/backend/app/core/batch/polling.py b/backend/app/core/batch/polling.py
index c364aeb3d..27d8e45a0 100644
--- a/backend/app/core/batch/polling.py
+++ b/backend/app/core/batch/polling.py
@@ -11,6 +11,30 @@
 
 logger = logging.getLogger(__name__)
 
+# Status-result key -> batch_job column; the provider's transient `error_file_id` is ours.
+_STATUS_RESULT_TO_COLUMN = {
+    "provider_status": "provider_status",
+    "provider_output_file_id": "provider_output_file_id",
+    "error_file_id": "provider_error_file_id",
+    "error_message": "error_message",
+}
+
+
+def _changed_columns(
+    status_result: dict[str, Any], batch_job: BatchJob
+) -> dict[str, str]:
+    """Columns whose polled value differs from the row's.
+
+    A field the provider omits (or reports empty) is left alone rather than nulled —
+    OpenAI only fills the file ids once the batch reaches a terminal state.
+    """
+    changed: dict[str, str] = {}
+    for result_key, column in _STATUS_RESULT_TO_COLUMN.items():
+        value = status_result.get(result_key)
+        if value and value != getattr(batch_job, column):
+            changed[column] = value
+    return changed
+
 
 def poll_batch_status(
     session: Session, provider: BatchProvider, batch_job: BatchJob
@@ -24,26 +48,20 @@ def poll_batch_status(
     try:
         status_result = provider.get_batch_status(batch_job.provider_batch_id)
 
-        provider_status = status_result["provider_status"]
-        if provider_status != batch_job.provider_status:
-            update_data = {"provider_status": provider_status}
-
-            if status_result.get("provider_output_file_id"):
-                update_data["provider_output_file_id"] = status_result[
-                    "provider_output_file_id"
-                ]
-
-            if status_result.get("error_message"):
-                update_data["error_message"] = status_result["error_message"]
-
-            batch_job_update = BatchJobUpdate(**update_data)
+        # Per field, not gated on a status flip: an error file landing mid-status was dropped.
+        changed = _changed_columns(status_result, batch_job)
+        if changed:
+            previous_status = batch_job.provider_status
             batch_job = update_batch_job(
-                session=session, batch_job=batch_job, batch_job_update=batch_job_update
+                session=session,
+                batch_job=batch_job,
+                batch_job_update=BatchJobUpdate.model_validate(changed),
             )
 
             logger.info(
                 f"[poll_batch_status] Updated | id={batch_job.id} | "
-                f"{batch_job.provider_status} -> {provider_status}"
+                f"fields={sorted(changed)} | "
+                f"{previous_status} -> {batch_job.provider_status}"
             )
 
         return status_result
diff --git a/backend/app/crud/assessment/__init__.py b/backend/app/crud/assessment/__init__.py
index a5cbb23b9..15a1f0714 100644
--- a/backend/app/crud/assessment/__init__.py
+++ b/backend/app/crud/assessment/__init__.py
@@ -21,11 +21,12 @@
     update_assessment_run_status,
     update_run_post_processing_config,
 )
-from app.crud.assessment.dataset import (
-    create_assessment_dataset,
-    delete_assessment_dataset,
-    get_assessment_dataset_by_id,
-    list_assessment_datasets,
+from app.crud.assessment.submission import (
+    create_submission,
+    delete_submission,
+    get_submission_by_id,
+    get_submission_by_name,
+    list_submissions,
 )
 from app.models.assessment import AssessmentRunCounts, AssessmentRunStat
 
@@ -35,18 +36,19 @@
     "api",
     "build_run_stats",
     "compute_run_counts",
-    "create_assessment_dataset",
+    "create_submission",
     "create_assessment",
     "create_assessment_run",
-    "delete_assessment_dataset",
+    "delete_submission",
     "derive_aggregate_error",
     "derive_assessment_status",
     "get_assessment_by_id",
-    "get_assessment_dataset_by_id",
+    "get_submission_by_id",
+    "get_submission_by_name",
     "get_assessment_run_by_id",
     "get_assessment_runs_for_assessment",
     "list_assessment_runs",
-    "list_assessment_datasets",
+    "list_submissions",
     "list_assessments",
     "recompute_assessment_status",
     "update_assessment_run_prefilter_stats",
diff --git a/backend/app/crud/assessment/api.py b/backend/app/crud/assessment/api.py
index 33271ce24..f6f7cd360 100644
--- a/backend/app/crud/assessment/api.py
+++ b/backend/app/crud/assessment/api.py
@@ -1,16 +1,19 @@
 """Assessment API-client CRUD — method-based Assessment / AssessmentRun writes.
 
-Kept separate from the legacy RUN-pipeline crud (core/cron/processing/batch):
+Kept separate from the UI-only crud (core/cron/processing/batch):
 writes only the new method-based columns and leaves the RUN-only `execution`
-and `dataset_id` fields NULL.
+and `submission_id` fields NULL.
 """
 
 import logging
 from typing import Any, TypeVar, cast
-from uuid import UUID
+from uuid import UUID, uuid4
 
+from sqlalchemy import cast as sa_cast
+from sqlalchemy import update
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.orm.attributes import flag_modified
-from sqlmodel import Session, select
+from sqlmodel import Session, col, select
 
 from app.core.util import now
 from app.models.assessment import (
@@ -18,6 +21,7 @@
     AssessmentMethod,
     AssessmentRun,
     AssessmentStatus,
+    AssessmentSubmission,
     BatchRunState,
 )
 
@@ -31,13 +35,22 @@ def create_assessment(
     *,
     session: Session,
     method: AssessmentMethod,
-    input: dict[str, Any],
+    input: dict[str, Any] | None,
     organization_id: int,
     project_id: int,
+    assessment_id: UUID | None = None,
+    submission_id: UUID | None = None,
+    submission_input: str | None = None,
+    experiment_name: str | None = None,
 ) -> Assessment:
+    """Insert the parent row; pass ``assessment_id`` when the object key already used it."""
     assessment = Assessment(
+        id=assessment_id or uuid4(),
         method=method,
         input=input,
+        submission_id=submission_id,
+        submission_input=submission_input,
+        experiment_name=experiment_name,
         status=AssessmentStatus.PENDING,
         organization_id=organization_id,
         project_id=project_id,
@@ -129,6 +142,37 @@ def save_execution_state(
     return execution
 
 
+def set_result_files(
+    *, session: Session, assessment: Assessment, files: dict[str, dict[str, Any]]
+) -> Assessment:
+    """Shallow-merge ``files`` into ``assessment.result_files``, one record per file kind.
+
+    The merge is server-side (``||``, right-hand side wins per key) because two drivers
+    can touch this row within the same second; a read-modify-write would drop the loser's
+    kinds instead of keeping both.
+    """
+    statement = (
+        update(Assessment)
+        .where(col(Assessment.id) == assessment.id)
+        .values(
+            result_files=col(Assessment.result_files).op("||")(sa_cast(files, JSONB)),
+            updated_at=now(),
+        )
+    )
+    try:
+        session.exec(statement)
+        session.commit()
+    except Exception:
+        session.rollback()
+        raise
+    session.refresh(assessment)
+    logger.info(
+        f"[set_result_files] Merged result files | assessment_id: {assessment.id} | "
+        f"kinds: {sorted(files)}"
+    )
+    return assessment
+
+
 def update_status(
     *, session: Session, obj: StatusModel, status: AssessmentStatus
 ) -> StatusModel:
@@ -144,6 +188,53 @@ def update_status(
     return obj
 
 
+def list_assessments_with_execution(
+    *,
+    session: Session,
+    organization_id: int,
+    project_id: int,
+    config_id: UUID | None = None,
+    config_version: int | None = None,
+    limit: int = 50,
+    offset: int = 0,
+) -> list[tuple[Assessment, AssessmentRun | None, str | None]]:
+    """BATCH assessments newest-first, each with its execution and submission name.
+
+    BATCH only: it has exactly one execution, so the join yields one row per assessment;
+    a RUN parent has one run per config and would repeat. Outer joins so an inline BATCH
+    (no submission) and a failed execution insert still list.
+    """
+    statement = (
+        select(Assessment, AssessmentRun, AssessmentSubmission.name)
+        .join(
+            AssessmentRun,
+            col(AssessmentRun.assessment_id) == col(Assessment.id),
+            isouter=True,
+        )
+        .join(
+            AssessmentSubmission,
+            col(AssessmentSubmission.id) == col(Assessment.submission_id),
+            isouter=True,
+        )
+        .where(Assessment.method == AssessmentMethod.BATCH)
+        .where(Assessment.organization_id == organization_id)
+        .where(Assessment.project_id == project_id)
+    )
+    if config_id is not None:
+        statement = statement.where(AssessmentRun.config_id == config_id)
+        if config_version is not None:
+            statement = statement.where(AssessmentRun.config_version == config_version)
+
+    statement = (
+        statement.order_by(
+            col(Assessment.inserted_at).desc(), col(Assessment.id).desc()
+        )
+        .limit(limit)
+        .offset(offset)
+    )
+    return list(session.exec(statement).all())
+
+
 def list_executions(*, session: Session, assessment_id: UUID) -> list[AssessmentRun]:
     statement = (
         select(AssessmentRun)
diff --git a/backend/app/crud/assessment/batch.py b/backend/app/crud/assessment/batch.py
index 1c4464525..47abcbe58 100644
--- a/backend/app/crud/assessment/batch.py
+++ b/backend/app/crud/assessment/batch.py
@@ -1,16 +1,12 @@
 """Assessment batch JSONL construction and submission.
 
-Builds provider-specific JSONL files from dataset rows + config,
+Builds provider-specific JSONL files from submission rows + config,
 then submits them via the core batch infrastructure.
 """
 
-import csv
-import io
 import logging
 from typing import Any
 
-import openpyxl
-from openpyxl.utils.exceptions import InvalidFileException
 from sqlmodel import Session
 
 from app.core.batch import (
@@ -26,16 +22,15 @@
     Assessment,
     AssessmentAttachment,
     AssessmentRun,
+    AssessmentSubmission,
 )
 from app.models.batch_job import BatchJob, BatchJobType
-from app.models.evaluation import EvaluationDataset
 from app.models.llm.constants import DEFAULT_ASSESSMENT_BATCH_MAX_TOKENS
 from app.models.llm.request import ConfigBlob
-from app.services.assessment.mappers import (
+from app.services.llm.mappers import (
     map_kaapi_to_anthropic_params,
     map_kaapi_to_google_params,
     map_kaapi_to_openai_params,
-    normalize_llm_text,
 )
 from app.services.assessment.utils.attachments import (
     attachment_type_for_row,
@@ -44,6 +39,11 @@
     resolve_attachment_values,
     rewrite_gcs_attachment_urls,
 )
+from app.services.assessment.validators import (
+    file_extension_of,
+    normalize_llm_text,
+    parse_rows,
+)
 from app.services.llm.mappers import kaapi_params_as_dict
 from app.services.llm.providers.registry import LLMProvider
 from app.utils import get_anthropic_client, get_openai_client
@@ -51,92 +51,23 @@
 logger = logging.getLogger(__name__)
 
 
-def _load_dataset_rows(
+def load_submission_file_rows(
+    *,
     session: Session,
-    dataset: EvaluationDataset,
+    submission: AssessmentSubmission,
 ) -> list[dict[str, str]]:
-    """Load dataset rows from object store.
-
-    Returns a list of dicts (one per row) with column-name keys.
-    """
-    if not dataset.object_store_url:
-        raise ValueError(f"Dataset {dataset.id} has no object_store_url")
-
-    storage = get_cloud_storage(session=session, project_id=dataset.project_id)
+    """Parse an uploaded submission's original file. Prefer the rows stored at upload."""
+    if not submission.object_store_url:
+        raise ValueError(f"Submission {submission.id} has no object_store_url")
 
-    # Download the file content via stream()
-    body = storage.stream(dataset.object_store_url)
-    file_content = body.read()
+    storage = get_cloud_storage(session=session, project_id=submission.project_id)
+    file_content = storage.stream(submission.object_store_url).read()
     if not file_content:
-        raise ValueError(f"Failed to download dataset from {dataset.object_store_url}")
-
-    metadata = dataset.dataset_metadata or {}
-    file_ext = metadata.get("file_extension", ".csv")
-
-    if file_ext == ".xls":
         raise ValueError(
-            "Legacy Excel format (.xls) is not supported. Please upload .xlsx or .csv."
+            f"Failed to download submission from {submission.object_store_url}"
         )
-    if file_ext == ".xlsx":
-        return _parse_excel_rows(file_content)
-    return _parse_csv_rows(file_content)
-
-
-def _parse_csv_rows(content: bytes) -> list[dict[str, str]]:
-    """Parse CSV content into list of row dicts."""
-    for encoding in ("utf-8-sig", "utf-8", "latin-1"):
-        try:
-            text = content.decode(encoding)
-            break
-        except (UnicodeDecodeError, ValueError):
-            continue
-    else:
-        text = content.decode("utf-8", errors="replace")
-
-    reader = csv.DictReader(io.StringIO(text))
-    return [row for row in reader if any(v and v.strip() for v in row.values())]
-
 
-def _parse_excel_rows(content: bytes) -> list[dict[str, str]]:
-    """Parse Excel content into list of row dicts."""
-    wb = None
-    try:
-        wb = openpyxl.load_workbook(io.BytesIO(content), read_only=True, data_only=True)
-        ws = wb.active
-        if ws is None:
-            return []
-
-        rows_iter = ws.iter_rows(values_only=True)
-        header = next(rows_iter, None)
-        if header is None:
-            return []
-
-        columns = [
-            str(col_header) if col_header is not None else f"col_{idx}"
-            for idx, col_header in enumerate(header)
-        ]
-        result = []
-        for row in rows_iter:
-            if row and any(cell is not None for cell in row):
-                row_dict = {
-                    columns[idx]: str(cell) if cell is not None else ""
-                    for idx, cell in enumerate(row)
-                    if idx < len(columns)
-                }
-                result.append(row_dict)
-
-        return result
-    except InvalidFileException as e:
-        logger.warning("[_parse_excel_rows] Invalid XLSX file content: %s", e)
-        raise
-    except Exception as e:
-        logger.warning(
-            "[_parse_excel_rows] Failed to parse XLSX rows | %s", e, exc_info=True
-        )
-        raise ValueError("Failed to parse XLSX dataset rows") from e
-    finally:
-        if wb is not None:
-            wb.close()
+    return parse_rows(file_content, file_extension_of(submission.object_store_url))
 
 
 def _build_text_prompt(
@@ -147,20 +78,19 @@ def _build_text_prompt(
     """Build the text prompt for a single row.
 
     If prompt_template is provided, placeholders like {column_name} are replaced.
-    Otherwise, all text column values are concatenated with newlines.
+    Otherwise, all text column values are concatenated with newlines. Row values go
+    through verbatim; only the stored template is unescaped.
     """
     if prompt_template:
         prompt = normalize_llm_text(prompt_template)
         for col in text_columns:
             placeholder = "{" + col + "}"
-            prompt = prompt.replace(placeholder, normalize_llm_text(row.get(col, "")))
+            prompt = prompt.replace(placeholder, row.get(col, ""))
         return prompt
 
     # No template: concatenate text columns
     parts = [
-        normalize_llm_text(row.get(col, ""))
-        for col in text_columns
-        if row.get(col, "").strip()
+        col_value for col in text_columns if (col_value := row.get(col, "")).strip()
     ]
     return "\n".join(parts)
 
@@ -173,7 +103,7 @@ def build_openai_jsonl(
     openai_params: dict,
     row_indices: list[int] | None = None,
 ) -> list[dict[str, Any]]:
-    """Build OpenAI batch JSONL data from dataset rows.
+    """Build OpenAI batch JSONL data from submission rows.
 
     Each line follows the OpenAI batch format:
     {
@@ -239,7 +169,7 @@ def build_google_jsonl(
     google_params: dict,
     row_indices: list[int] | None = None,
 ) -> list[dict[str, Any]]:
-    """Build Google (Gemini) batch JSONL data from dataset rows.
+    """Build Google (Gemini) batch JSONL data from submission rows.
 
     Each line follows the Gemini batch format:
     {
@@ -318,7 +248,7 @@ def build_anthropic_jsonl(
     anthropic_params: dict,
     row_indices: list[int] | None = None,
 ) -> list[dict[str, Any]]:
-    """Build Anthropic batch request data from dataset rows.
+    """Build Anthropic batch request data from submission rows.
 
     Each line follows the Anthropic Message Batches format:
     {
@@ -368,7 +298,7 @@ def submit_assessment_batch(
     session: Session,
     run: AssessmentRun,
     assessment: Assessment,
-    dataset: EvaluationDataset,
+    submission: AssessmentSubmission,
     config_blob: ConfigBlob,
     assessment_input: dict[str, Any],
     organization_id: int,
@@ -378,20 +308,10 @@ def submit_assessment_batch(
 ) -> BatchJob:
     """Build JSONL and submit a batch for one assessment run.
 
-    Args:
-        session: Database session
-        run: The AssessmentRun to process
-        dataset: The dataset to read rows from
-        config_blob: Resolved configuration blob
-        assessment_input: Parent InputBinding (prompt, text_columns, attachments)
-        organization_id: Organization ID
-        project_id: Project ID
-
-    Returns:
-        Created BatchJob record
+    Rows come from ``preloaded_rows`` when the caller already filtered them
+    (post-prefilter), else from the submission file.
     """
-    # `assessment_input` is the parent InputBinding (prompt/text_columns/attachments);
-    # system_instruction / output_schema now live in the resolved config blob.
+    # `assessment_input` is the parent InputBinding; the rest lives in the config blob.
     text_columns = assessment_input.get("text_columns", [])
     prompt_template = assessment_input.get("prompt")
     attachments_raw = assessment_input.get("attachments", [])
@@ -401,9 +321,9 @@ def submit_assessment_batch(
     if preloaded_rows is not None:
         rows = preloaded_rows
     else:
-        rows = _load_dataset_rows(session, dataset)
+        rows = load_submission_file_rows(session=session, submission=submission)
     if not rows:
-        raise ValueError(f"Dataset {dataset.id} has no rows")
+        raise ValueError(f"Submission {submission.id} has no rows")
 
     logger.info(
         "[submit_assessment_batch] Building JSONL | run_id=%s | rows=%s | provider=%s",
@@ -420,6 +340,9 @@ def submit_assessment_batch(
     # compact wire format (None fields and an unset temperature dropped), so
     # the batch never forwards defaults the caller didn't set.
     params = kaapi_params_as_dict(completion.params)
+    # Normalised here, not in the mapper, so only this path's prompts are rewritten.
+    if params.get("instructions"):
+        params["instructions"] = normalize_llm_text(params["instructions"])
 
     # Determine the base provider (openai or google)
     base_provider = provider_name.replace("-native", "")
diff --git a/backend/app/crud/assessment/core.py b/backend/app/crud/assessment/core.py
index 450a74ed3..c51820be8 100644
--- a/backend/app/crud/assessment/core.py
+++ b/backend/app/crud/assessment/core.py
@@ -35,7 +35,7 @@ def _write_exec(run: AssessmentRun, **values: Any) -> None:
 def create_assessment(
     session: Session,
     experiment_name: str,
-    dataset_id: int,
+    submission_id: UUID,
     organization_id: int,
     project_id: int,
     input_binding: dict[str, Any] | None = None,
@@ -48,7 +48,7 @@ def create_assessment(
     assessment = Assessment(
         experiment_name=experiment_name,
         method=AssessmentMethod.RUN,
-        dataset_id=dataset_id,
+        submission_id=submission_id,
         input=input_binding,
         status=AssessmentStatus.PENDING,
         organization_id=organization_id,
diff --git a/backend/app/crud/assessment/cron.py b/backend/app/crud/assessment/cron.py
index 342a4e247..3d874914b 100644
--- a/backend/app/crud/assessment/cron.py
+++ b/backend/app/crud/assessment/cron.py
@@ -18,6 +18,7 @@
 )
 from app.models.assessment import (
     Assessment,
+    AssessmentMethod,
     AssessmentRun,
     AssessmentStatus,
     StageStatus,
@@ -25,6 +26,9 @@
 
 logger = logging.getLogger(__name__)
 
+# Programming errors: a retry just re-runs the same broken code, so fail the run instead.
+DETERMINISTIC_ERRORS = (ValueError, AttributeError, TypeError, KeyError, IndexError)
+
 
 def _log_config_progress(
     result: dict[str, Any], run: AssessmentRun, assessment: Assessment
@@ -52,8 +56,13 @@ def _log_config_progress(
 async def poll_all_pending_assessment_evaluations(
     session: Session,
 ) -> dict[str, Any]:
-    """Poll all non-terminal parent assessments and their active child runs."""
+    """Poll all non-terminal RUN parent assessments and their active child runs.
+
+    RUN only: the BATCH API path is driven by its own Celery self-re-enqueue and stores a
+    differently shaped ``execution`` bag that this poller corrupts.
+    """
     statement = select(Assessment).where(
+        Assessment.method == AssessmentMethod.RUN,
         Assessment.status.in_((AssessmentStatus.PENDING, AssessmentStatus.PROCESSING)),
     )
     pending_assessments = list(session.exec(statement).all())
@@ -127,7 +136,7 @@ async def poll_all_pending_assessment_evaluations(
                 else:
                     still_processing += 1
 
-            except ValueError as e:
+            except DETERMINISTIC_ERRORS as e:
                 session.rollback()
                 message = format_assessment_failure_message(e)
                 logger.error(
diff --git a/backend/app/crud/assessment/dataset.py b/backend/app/crud/assessment/dataset.py
deleted file mode 100644
index d195ae8e5..000000000
--- a/backend/app/crud/assessment/dataset.py
+++ /dev/null
@@ -1,163 +0,0 @@
-"""CRUD operations for assessment datasets."""
-
-import logging
-from typing import Any
-
-from fastapi import HTTPException
-from sqlalchemy.exc import IntegrityError
-from sqlmodel import Session, select
-
-from app.core.util import now
-from app.models.assessment import Assessment
-from app.models.evaluation import EvaluationDataset
-from app.models.stt_evaluation import EvaluationType
-
-logger = logging.getLogger(__name__)
-
-
-def create_assessment_dataset(
-    *,
-    session: Session,
-    name: str,
-    dataset_metadata: dict[str, Any],
-    organization_id: int,
-    project_id: int,
-    description: str | None = None,
-    object_store_url: str | None = None,
-    langfuse_dataset_id: str | None = None,
-) -> EvaluationDataset:
-    """Create an assessment dataset backed by the shared evaluation_dataset table."""
-    dataset = EvaluationDataset(
-        name=name,
-        description=description,
-        type=EvaluationType.ASSESSMENT.value,
-        dataset_metadata=dataset_metadata,
-        object_store_url=object_store_url,
-        langfuse_dataset_id=langfuse_dataset_id,
-        organization_id=organization_id,
-        project_id=project_id,
-        inserted_at=now(),
-        updated_at=now(),
-    )
-
-    try:
-        session.add(dataset)
-        session.commit()
-        session.refresh(dataset)
-    except IntegrityError as e:
-        session.rollback()
-        logger.warning(
-            "[create_assessment_dataset] Dataset name already exists | "
-            "name=%s | org_id=%s | project_id=%s",
-            name,
-            organization_id,
-            project_id,
-            exc_info=True,
-        )
-        raise HTTPException(
-            status_code=409,
-            detail=(
-                f"Dataset with name '{name}' already exists in this "
-                "organization and project. Please choose a different name."
-            ),
-        ) from e
-    except Exception as e:
-        session.rollback()
-        logger.error(
-            "[create_assessment_dataset] Failed to create dataset | name=%s",
-            name,
-            exc_info=True,
-        )
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to save assessment dataset metadata",
-        ) from e
-
-    logger.info(
-        "[create_assessment_dataset] Created assessment dataset | "
-        "id=%s | name=%s | org_id=%s | project_id=%s",
-        dataset.id,
-        name,
-        organization_id,
-        project_id,
-    )
-    return dataset
-
-
-def get_assessment_dataset_by_id(
-    *,
-    session: Session,
-    dataset_id: int,
-    organization_id: int,
-    project_id: int,
-) -> EvaluationDataset:
-    """Fetch an assessment dataset by ID, scoped to organization and project."""
-    statement = (
-        select(EvaluationDataset)
-        .where(EvaluationDataset.id == dataset_id)
-        .where(EvaluationDataset.organization_id == organization_id)
-        .where(EvaluationDataset.project_id == project_id)
-        .where(EvaluationDataset.type == EvaluationType.ASSESSMENT.value)
-    )
-    dataset = session.exec(statement).first()
-    if not dataset:
-        raise HTTPException(
-            status_code=404,
-            detail=f"Dataset {dataset_id} not found or not accessible",
-        )
-    return dataset
-
-
-def list_assessment_datasets(
-    *,
-    session: Session,
-    organization_id: int,
-    project_id: int,
-    limit: int = 50,
-    offset: int = 0,
-) -> list[EvaluationDataset]:
-    """List assessment datasets for an organization and project."""
-    statement = (
-        select(EvaluationDataset)
-        .where(EvaluationDataset.organization_id == organization_id)
-        .where(EvaluationDataset.project_id == project_id)
-        .where(EvaluationDataset.type == EvaluationType.ASSESSMENT.value)
-        .order_by(EvaluationDataset.inserted_at.desc())
-        .limit(limit)
-        .offset(offset)
-    )
-    return list(session.exec(statement).all())
-
-
-def delete_assessment_dataset(
-    *, session: Session, dataset: EvaluationDataset
-) -> str | None:
-    """Delete an unused assessment dataset."""
-    statement = select(Assessment).where(Assessment.dataset_id == dataset.id)
-    assessments = session.exec(statement).all()
-    if assessments:
-        return (
-            f"Cannot delete dataset {dataset.id}: it is being used by "
-            f"{len(assessments)} assessment(s). Please delete the assessments first."
-        )
-
-    try:
-        dataset_id = dataset.id
-        dataset_name = dataset.name
-        session.delete(dataset)
-        session.commit()
-    except Exception as e:
-        session.rollback()
-        logger.error(
-            "[delete_assessment_dataset] Failed to delete dataset | dataset_id=%s",
-            dataset.id,
-            exc_info=True,
-        )
-        return f"Failed to delete dataset: {e}"
-
-    logger.info(
-        "[delete_assessment_dataset] Deleted assessment dataset | id=%s | name=%s",
-        dataset_id,
-        dataset_name,
-    )
-    return None
diff --git a/backend/app/crud/assessment/submission.py b/backend/app/crud/assessment/submission.py
new file mode 100644
index 000000000..4205ac0a2
--- /dev/null
+++ b/backend/app/crud/assessment/submission.py
@@ -0,0 +1,168 @@
+"""CRUD operations for uploaded assessment submissions."""
+
+import logging
+from uuid import UUID, uuid4
+
+from fastapi import HTTPException
+from sqlalchemy.exc import IntegrityError
+from sqlmodel import Session, select
+
+from app.core.util import now
+from app.models.assessment import Assessment, AssessmentSubmission
+
+logger = logging.getLogger(__name__)
+
+
+def get_submission_by_name(
+    *, session: Session, name: str, organization_id: int, project_id: int
+) -> AssessmentSubmission | None:
+    """Fetch a submission by the columns the unique constraint covers."""
+    statement = (
+        select(AssessmentSubmission)
+        .where(AssessmentSubmission.name == name)
+        .where(AssessmentSubmission.organization_id == organization_id)
+        .where(AssessmentSubmission.project_id == project_id)
+    )
+    return session.exec(statement).first()
+
+
+def create_submission(
+    *,
+    session: Session,
+    name: str,
+    object_store_url: str,
+    total_items: int,
+    organization_id: int,
+    project_id: int,
+    submission_id: UUID | None = None,
+    description: str | None = None,
+) -> AssessmentSubmission:
+    """Record an uploaded submission file; pass ``submission_id`` when the key used it."""
+    submission = AssessmentSubmission(
+        id=submission_id or uuid4(),
+        name=name,
+        description=description,
+        object_store_url=object_store_url,
+        total_items=total_items,
+        organization_id=organization_id,
+        project_id=project_id,
+        inserted_at=now(),
+        updated_at=now(),
+    )
+
+    try:
+        session.add(submission)
+        session.commit()
+        session.refresh(submission)
+    except IntegrityError as e:
+        # Backstop for two concurrent uploads; the caller already checks the name.
+        session.rollback()
+        logger.warning(
+            "[create_submission] Name already exists | name=%s | org_id=%s | project_id=%s",
+            name,
+            organization_id,
+            project_id,
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=409,
+            detail=(
+                f"Submission with name '{name}' already exists in this "
+                "organization and project. Please choose a different name."
+            ),
+        ) from e
+    except Exception as e:
+        session.rollback()
+        logger.error(
+            "[create_submission] Failed to create submission | name=%s",
+            name,
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=500, detail="Failed to save the submission metadata."
+        ) from e
+
+    logger.info(
+        "[create_submission] Created | id=%s | name=%s | rows=%s | org_id=%s | project_id=%s",
+        submission.id,
+        name,
+        total_items,
+        organization_id,
+        project_id,
+    )
+    return submission
+
+
+def get_submission_by_id(
+    *,
+    session: Session,
+    submission_id: UUID,
+    organization_id: int,
+    project_id: int,
+) -> AssessmentSubmission:
+    """Fetch a submission by id, scoped to organization and project."""
+    statement = (
+        select(AssessmentSubmission)
+        .where(AssessmentSubmission.id == submission_id)
+        .where(AssessmentSubmission.organization_id == organization_id)
+        .where(AssessmentSubmission.project_id == project_id)
+    )
+    submission = session.exec(statement).first()
+    if not submission:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Submission {submission_id} not found or not accessible",
+        )
+    return submission
+
+
+def list_submissions(
+    *,
+    session: Session,
+    organization_id: int,
+    project_id: int,
+    limit: int = 50,
+    offset: int = 0,
+) -> list[AssessmentSubmission]:
+    """List submissions for an organization and project, newest first."""
+    statement = (
+        select(AssessmentSubmission)
+        .where(AssessmentSubmission.organization_id == organization_id)
+        .where(AssessmentSubmission.project_id == project_id)
+        .order_by(AssessmentSubmission.inserted_at.desc())
+        .limit(limit)
+        .offset(offset)
+    )
+    return list(session.exec(statement).all())
+
+
+def delete_submission(
+    *, session: Session, submission: AssessmentSubmission
+) -> str | None:
+    """Delete a submission no assessment references. Returns a reason when refused."""
+    statement = select(Assessment).where(Assessment.submission_id == submission.id)
+    assessments = session.exec(statement).all()
+    if assessments:
+        return (
+            f"Cannot delete submission {submission.id}: it is being used by "
+            f"{len(assessments)} assessment(s). Please delete the assessments first."
+        )
+
+    submission_id = submission.id
+    submission_name = submission.name
+    try:
+        session.delete(submission)
+        session.commit()
+    except Exception as e:
+        session.rollback()
+        logger.error(
+            "[delete_submission] Failed to delete | submission_id=%s",
+            submission.id,
+            exc_info=True,
+        )
+        return f"Failed to delete submission: {e}"
+
+    logger.info(
+        "[delete_submission] Deleted | id=%s | name=%s", submission_id, submission_name
+    )
+    return None
diff --git a/backend/app/crud/config/version.py b/backend/app/crud/config/version.py
index 9e7c4be73..313a4e27c 100644
--- a/backend/app/crud/config/version.py
+++ b/backend/app/crud/config/version.py
@@ -54,14 +54,10 @@ def __init__(
         self.tag = tag
 
     def create_or_raise(self, version_create: ConfigVersionUpdate) -> ConfigVersion:
-        """
-        Create a new version from a partial config update.
-
-        Fetches the latest version, merges the partial config with it,
-        validates the result, and creates the new version.
+        """Create the next version from the submitted config blob.
 
-        Fields 'type' is inherited from the existing config
-        and cannot be changed.
+        A DEFAULT blob is a partial patch merged onto the latest version, with
+        `completion.type` immutable. An ASSESSMENT blob replaces it outright.
         """
         self._config_exists_or_raise(self.config_id)
 
@@ -73,15 +69,13 @@ def create_or_raise(self, version_create: ConfigVersionUpdate) -> ConfigVersion:
                 detail="Cannot create partial version: no existing version found. Use full config for initial version.",
             )
 
-        # Merge partial config with existing config
-        merged_config = self._deep_merge(
-            base=latest_version.config_blob,
-            updates=version_create.config_blob,
-        )
-
-        # These operate on a top-level `completion` block, which assessment
-        # blobs don't have — skip them for the ASSESSMENT tag.
-        if self.tag != ConfigTag.ASSESSMENT:
+        if self.tag == ConfigTag.ASSESSMENT:
+            merged_config = dict(version_create.config_blob)
+        else:
+            merged_config = self._deep_merge(
+                base=latest_version.config_blob,
+                updates=version_create.config_blob,
+            )
             self._strip_unsupported_params(merged_config)
             self._validate_immutable_fields(latest_version.config_blob, merged_config)
 
diff --git a/backend/app/models/assessment/__init__.py b/backend/app/models/assessment/__init__.py
index dbc581713..019ab08c8 100644
--- a/backend/app/models/assessment/__init__.py
+++ b/backend/app/models/assessment/__init__.py
@@ -1,19 +1,14 @@
 """Assessment models package.
 
-Split across two files so the API-client surface is separate from the legacy UI one:
-  - ``assessment.py``      — the shared DB tables/enums + the legacy Assessment Run UI models.
-  - ``assessment_api.py``  — the API-client request/response models for ``/assessments``.
-
-Everything is re-exported here, so ``from app.models.assessment import X`` resolves a
-symbol from either file, unchanged for every existing importer.
+Split by surface: ``assessment.py`` (shared tables/enums + legacy RUN UI),
+``assessment_api.py`` (``/assessments`` request/response), ``submission.py`` (uploaded
+submission files). All re-exported here, so ``from app.models.assessment import X`` works.
 """
 
 from app.models.assessment.assessment import (
     Assessment,
     AssessmentAttachment,
     AssessmentConfigRef,
-    AssessmentDatasetPreview,
-    AssessmentDatasetResponse,
     AssessmentExecutionPublic,
     AssessmentExportRow,
     AssessmentMethod,
@@ -38,11 +33,14 @@
     AssessmentCallback,
     AssessmentCounts,
     AssessmentCreate,
+    AssessmentDetailResponse,
     AssessmentInput,
     AssessmentOutput,
     AssessmentResult,
     AssessmentResultData,
+    AssessmentResultRow,
     AssessmentSubmitResponse,
+    AssessmentSummary,
     Attachment,
     BatchInput,
     BatchRunState,
@@ -54,6 +52,11 @@
     Verdict,
     derive_method,
 )
+from app.models.assessment.submission import (
+    AssessmentSubmission,
+    AssessmentSubmissionPreview,
+    AssessmentSubmissionResponse,
+)
 
 __all__ = [
     # shared tables + enums
@@ -79,8 +82,10 @@
     "AssessmentRunPublic",
     "AssessmentRunResponse",
     "AssessmentRunOverview",
-    "AssessmentDatasetPreview",
-    "AssessmentDatasetResponse",
+    # uploaded submission files
+    "AssessmentSubmission",
+    "AssessmentSubmissionPreview",
+    "AssessmentSubmissionResponse",
     # API-client surface
     "Attachment",
     "ResponseInput",
@@ -98,7 +103,10 @@
     "PreFilter",
     "AssessmentOutput",
     "AssessmentResult",
+    "AssessmentResultRow",
     "AssessmentCounts",
     "AssessmentBatchResult",
     "AssessmentResultData",
+    "AssessmentDetailResponse",
+    "AssessmentSummary",
 ]
diff --git a/backend/app/models/assessment/assessment.py b/backend/app/models/assessment/assessment.py
index 3b4d9d249..ca1277009 100644
--- a/backend/app/models/assessment/assessment.py
+++ b/backend/app/models/assessment/assessment.py
@@ -1,7 +1,7 @@
-"""Assessment DB tables, shared enums, and legacy Assessment Run UI models.
+"""Assessment DB tables, shared enums, and the UI-only Assessment Run models.
 
 Tables + ``AssessmentStatus``/``AssessmentMethod`` enums are shared by every method; the
-rest is the legacy RUN surface. API-client models live in ``assessment_api.py``.
+rest is the UI-only RUN surface. API-client models live in ``assessment_api.py``.
 """
 
 from datetime import datetime
@@ -52,9 +52,9 @@ def terminal(cls) -> frozenset["AssessmentStatus"]:
         return frozenset({cls.COMPLETED, cls.COMPLETED_WITH_ERRORS, cls.FAILED})
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class Stage(StrEnum):
-    """Legacy RUN pipeline stages, in order."""
+    """RUN pipeline stages, in order; only used for UI."""
 
     PRE_FILTER_TOPIC_RELEVANCE = "PRE_FILTER_TOPIC_RELEVANCE"
     PRE_FILTER_DUPLICATE_DETECTION = "PRE_FILTER_DUPLICATE_DETECTION"
@@ -63,7 +63,7 @@ class Stage(StrEnum):
     FAILED = "FAILED"
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class StageStatus(StrEnum):
     PENDING = "PENDING"
     PROCESSING = "PROCESSING"
@@ -72,13 +72,13 @@ class StageStatus(StrEnum):
 
 
 class AssessmentConfigRef(BaseModel):
-    """Pin to a saved config version; shared by the API create and the legacy run create."""
+    """Pin to a saved config version; shared by the API create and the UI run create."""
 
     id: UUID
     version: int = Field(ge=1)
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentAttachment(BaseModel):
     """External-dataset attachment column config (RUN / BATCH-by-ref)."""
 
@@ -106,7 +106,7 @@ def _validate_mixed(self) -> "AssessmentAttachment":
         return self
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class InputBinding(BaseModel):
     """External-dataset column mapping + prompt template."""
 
@@ -117,13 +117,14 @@ class InputBinding(BaseModel):
     attachments: list[AssessmentAttachment] = Field(default_factory=list)
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class RunExecution(BaseModel):
-    """Legacy RUN pipeline runtime state (assessment_run.execution)."""
+    """RUN pipeline runtime state (assessment_run.execution); only used for UI."""
 
     stage: Stage | None = None
     stage_status: StageStatus | None = None
-    pipeline: dict[str, Any] | None = None
+    # Two writers, one column: RUN stores {"stages": [...]}, the BATCH API a bare list.
+    pipeline: dict[str, Any] | list[dict[str, str]] | None = None
     stage_batches: dict[str, int] | None = None
     prefilter_total_rows: int | None = None
     prefilter_total_passed: int | None = None
@@ -185,17 +186,43 @@ class Assessment(SQLModel, table=True):
         sa_column=Column(
             JSONB,
             nullable=True,
-            comment="Method-shaped: ResponseInput (RESPONSE) / BatchInput (BATCH) / InputBinding (RUN)",
+            comment="Method-shaped: ResponseInput (RESPONSE) / InputBinding (RUN); NULL for API-client BATCH, which uses submission_input",
         ),
     )
-    # NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
-    dataset_id: int | None = SQLField(
+    submission_input: str | None = SQLField(
         default=None,
-        foreign_key="evaluation_dataset.id",
+        sa_column_kwargs={
+            "comment": (
+                "Object-store url of the API-client BATCH submission rows "
+                "(submission.jsonl); the rows are never stored in this table"
+            )
+        },
+    )
+    # NOT NULL '{}': an empty map is a real state, not the siblings' "not applicable".
+    result_files: dict[str, Any] = SQLField(
+        default_factory=dict,
+        sa_column=Column(
+            JSONB,
+            nullable=False,
+            server_default=text("'{}'::jsonb"),
+            comment=(
+                "Result-file kind (results / errors / <stage>_results) to "
+                "{object_store_url} for every provider batch dump held; raw s3:// in the "
+                "column, presigned per delivery in the BATCH callback"
+            ),
+        ),
+    )
+    submission_id: UUID | None = SQLField(
+        default=None,
+        foreign_key="assessment_submission.id",
         nullable=True,
+        index=True,
         ondelete="SET NULL",
         sa_column_kwargs={
-            "comment": "External dataset (RUN); binding lives in `input`"
+            "comment": (
+                "Uploaded submission the rows came from; set by RUN and by a BATCH "
+                "submitted with `submission_doc_id`. NULL when BATCH sent rows inline"
+            )
         },
     )
 
@@ -249,7 +276,7 @@ class AssessmentRun(SQLModel, table=True):
             "comment": "BATCH job; RUN tracks its batches inside execution"
         },
     )
-    # Staged-batch runtime bag (RunExecution shape). Used by the legacy RUN UI
+    # Staged-batch runtime bag (RunExecution shape). Used by the RUN UI
     # pipeline AND by the new BATCH API-client path when the config carries
     # pre-filters — both drive stage/verdict/gate state through this JSONB.
     execution: dict[str, Any] | None = SQLField(
@@ -277,7 +304,7 @@ class AssessmentRun(SQLModel, table=True):
     )
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentExecutionPublic(BaseModel):
     config_id: UUID
     config_version: int
@@ -288,17 +315,29 @@ class AssessmentExecutionPublic(BaseModel):
     updated_at: datetime
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentResponse(BaseModel):
     assessment_id: UUID
     executions: list[AssessmentExecutionPublic] = []
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentPublic(BaseModel):
+    """Console list/detail row. Declares everything `_build_assessment_public` passes.
+
+    The `method` field lets a client tell a RUN row from a BATCH one, which decides
+    where its results are read from.
+    """
+
     id: UUID
     experiment_name: str | None = None
+    method: AssessmentMethod
     status: AssessmentStatus
+    submission_id: UUID | None = None
+    submission_name: str | None = None
+    counts: "AssessmentRunCounts | None" = None
+    run_stats: list["AssessmentRunStat"] = []
+    error_message: str | None = None
     executions: list[AssessmentExecutionPublic] = []
     organization_id: int
     project_id: int
@@ -306,7 +345,7 @@ class AssessmentPublic(BaseModel):
     updated_at: datetime
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentExportRow(BaseModel):
     """Flattened result row for CSV/XLSX/JSON export."""
 
@@ -330,16 +369,16 @@ class AssessmentExportRow(BaseModel):
     updated_at: datetime
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentRunCreate(BaseModel):
     experiment_name: str
-    dataset_id: int
+    submission_id: UUID
     input_binding: InputBinding
     configs: list[AssessmentConfigRef] = Field(min_length=1, max_length=4)
     post_processing_config: dict[str, Any] | None = None
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentRunCounts(BaseModel):
     total: int = 0
     pending: int = 0
@@ -348,7 +387,7 @@ class AssessmentRunCounts(BaseModel):
     failed: int = 0
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentRunStat(BaseModel):
     run_id: int
     config_id: UUID | None
@@ -359,7 +398,7 @@ class AssessmentRunStat(BaseModel):
     updated_at: datetime | None = None
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentRunSummary(BaseModel):
     run_id: int
     assessment_id: UUID
@@ -368,7 +407,7 @@ class AssessmentRunSummary(BaseModel):
     status: AssessmentStatus
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentRunPublic(BaseModel):
     id: int
     assessment_id: UUID
@@ -384,23 +423,23 @@ class AssessmentRunPublic(BaseModel):
     updated_at: datetime
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentRunResponse(BaseModel):
     assessment_id: UUID
     experiment_name: str | None = None
-    dataset_id: int | None = None
-    dataset_name: str | None = None
+    submission_id: UUID | None = None
+    submission_name: str | None = None
     num_configs: int
     runs: list[AssessmentRunSummary] = []
 
 
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
+# NOTE: Only used for UI. The API-client Assessment pipeline does not use this.
 class AssessmentRunOverview(BaseModel):
     id: UUID
     experiment_name: str | None = None
     status: AssessmentStatus
-    dataset_id: int | None = None
-    dataset_name: str | None = None
+    submission_id: UUID | None = None
+    submission_name: str | None = None
     input_binding: InputBinding | None = None
     counts: AssessmentRunCounts = AssessmentRunCounts()
     run_stats: list[AssessmentRunStat] = []
@@ -408,23 +447,3 @@ class AssessmentRunOverview(BaseModel):
     project_id: int
     inserted_at: datetime
     updated_at: datetime
-
-
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
-class AssessmentDatasetPreview(BaseModel):
-    headers: list[str]
-    rows: list[list[str]]
-    returned_rows: int = 0
-    truncated: bool = False
-
-
-# NOTE: Legacy, this is for Assessment Run UI only. The new Assessment pipeline does not use this.
-class AssessmentDatasetResponse(BaseModel):
-    dataset_id: int
-    dataset_name: str
-    description: str | None = None
-    total_items: int = 0
-    file_extension: str | None = None
-    object_store_url: str | None = None
-    signed_url: str | None = None
-    preview: AssessmentDatasetPreview | None = None
diff --git a/backend/app/models/assessment/assessment_api.py b/backend/app/models/assessment/assessment_api.py
index 21b363222..8ffcaf0f3 100644
--- a/backend/app/models/assessment/assessment_api.py
+++ b/backend/app/models/assessment/assessment_api.py
@@ -1,14 +1,14 @@
 """API-client request/response models for ``POST /assessments``.
 
-Method (RESPONSE vs BATCH) inferred from input shape. Shared enums, tables, and legacy
-RUN models live in ``assessment.py``.
+Method (RESPONSE vs BATCH) inferred from input shape. Shared enums, tables, and the
+UI-only RUN models live in ``assessment.py``.
 """
 
 from datetime import datetime
 from typing import Annotated, Any, NotRequired, TypedDict
 from uuid import UUID
 
-from pydantic import BaseModel, ConfigDict, Field, HttpUrl
+from pydantic import BaseModel, ConfigDict, Field, HttpUrl, model_validator
 from sqlmodel import SQLModel
 
 from app.models.assessment.assessment import (
@@ -35,14 +35,32 @@ class ResponseInput(SQLModel):
 
 
 class BatchInput(SQLModel):
-    """BATCH input — a list of submission rows. The prompt template lives in the config."""
+    """BATCH input — rows inline, or a pointer to an uploaded submission file.
+
+    The two are mutually exclusive: exactly one must be given. The prompt template
+    lives in the config either way.
+    """
 
     model_config = ConfigDict(extra="forbid")
 
-    data: list[Submission] = Field(
-        ..., min_length=1, description="Submission rows; one assessed item each"
+    data: list[Submission] | None = Field(
+        default=None,
+        min_length=1,
+        description="Submission rows; one assessed item each",
+    )
+    submission_doc_id: UUID | None = Field(
+        default=None,
+        description="Id of an uploaded submission file to read the rows from",
     )
 
+    @model_validator(mode="after")
+    def _exactly_one_row_source(self) -> "BatchInput":
+        if (self.data is None) == (self.submission_doc_id is None):
+            raise ValueError(
+                "Provide exactly one of 'data' (inline rows) or 'submission_doc_id'."
+            )
+        return self
+
 
 class Verdict(TypedDict):
     """A pre-filter's parsed judgement for one row."""
@@ -75,13 +93,15 @@ class BatchRunState(TypedDict):
     # raw_output_url is Optional, so the map value types must admit None.
     stage_batches: dict[str, int | None]  # stage -> provider batch_job id
     stage_output_urls: dict[str, str | None]  # stage -> raw result url
+    # stage -> {row_index -> error}, captured at parse time (raw dumps are too big here)
+    stage_errors: NotRequired[dict[str, dict[str, str]]]
     verdicts: dict[str, dict[str, Verdict]]  # stage -> {item_idx -> verdict}
     counters: dict[str, dict[str, int]]  # stage -> {total,passed,rejected}
     gate_passed: list[bool]  # per-item still-eligible flag
     provider: str
     model: str
     input_schema: dict[str, Any] | None
-    callback_url: str
+    callback_url: str | None  # None when the client polls instead of receiving a push
     request_metadata: dict[str, Any] | None
     error: NotRequired[str]  # only set on failure (_fail)
 
@@ -93,16 +113,16 @@ class BatchRunState(TypedDict):
 
 
 def derive_method(
-    input_: AssessmentInput | None, dataset_id: int | None
+    input_: AssessmentInput | None, submission_id: UUID | None
 ) -> AssessmentMethod:
-    """Infer method: ResponseInput ⇒ RESPONSE, BatchInput ⇒ BATCH, else dataset_id ⇒ RUN."""
+    """Infer method: ResponseInput ⇒ RESPONSE, BatchInput ⇒ BATCH, else submission_id ⇒ RUN."""
     if isinstance(input_, ResponseInput):
         return AssessmentMethod.RESPONSE
     if isinstance(input_, BatchInput):
         return AssessmentMethod.BATCH
-    if dataset_id is not None:
+    if submission_id is not None:
         return AssessmentMethod.RUN
-    raise ValueError("[derive_method] Provide inline `input` or `dataset_id`")
+    raise ValueError("[derive_method] Provide inline `input` or `submission_id`")
 
 
 class AssessmentCreate(BaseModel):
@@ -110,8 +130,15 @@ class AssessmentCreate(BaseModel):
 
     config: AssessmentConfigRef
     input: AssessmentInput
-    callback_url: HttpUrl = Field(
-        ..., description="Webhook the result is POSTed to on completion (required)"
+    experiment_name: str | None = Field(
+        default=None, description="Run label shown in the console"
+    )
+    callback_url: HttpUrl | None = Field(
+        default=None,
+        description=(
+            "Webhook the result is POSTed to on completion; omit to poll "
+            "GET /assessments/{assessment_id} instead"
+        ),
     )
     request_metadata: dict[str, Any] | None = Field(
         default=None,
@@ -176,6 +203,52 @@ class AssessmentBatchResult(BaseModel):
     items: list[AssessmentResult] = []
 
 
+class AssessmentResultRow(AssessmentResult):
+    """One row as the poll endpoint returns it: the webhook item plus its origin.
+
+    ``output`` is byte-identical to the webhook's, so one client parser handles both.
+    ``input`` is null when the stored submission rows could not be read.
+    """
+
+    row_index: int
+    input: Submission | None = None
+
+
+class AssessmentSummary(BaseModel):
+    """One row of the assessment list: everything readable without touching storage.
+
+    Deliberately carries no per-row counts — those need the provider dump streamed
+    back, which a list (and a poll on it) must not pay for. Use the detail endpoint.
+    """
+
+    assessment_id: UUID
+    method: AssessmentMethod
+    status: AssessmentStatus
+    experiment_name: str | None = None
+    submission_id: UUID | None = None
+    submission_name: str | None = None
+    config: AssessmentConfigRef | None = None
+    total_items: int = 0
+    # This run's own stages, in order — a run with no pre-filter has one entry.
+    stages: list[str] = []
+    stage: str | None = None
+    stage_status: str | None = None
+    error: str | None = None
+    inserted_at: datetime
+    updated_at: datetime
+
+
+class AssessmentDetailResponse(AssessmentSummary):
+    """Poll response: the summary plus every row produced so far.
+
+    Safe to read mid-run — rows the provider has not returned yet carry
+    ``output.assessment = null``.
+    """
+
+    counts: AssessmentCounts = AssessmentCounts()
+    items: list[AssessmentResultRow] = []
+
+
 # The `data` body of a response, keyed by inference method: a single AssessmentResult
 # (RESPONSE) or an AssessmentBatchResult carrying the per-row list (BATCH).
 AssessmentResultData = AssessmentResult | AssessmentBatchResult
diff --git a/backend/app/models/assessment/submission.py b/backend/app/models/assessment/submission.py
new file mode 100644
index 000000000..acaf2a39b
--- /dev/null
+++ b/backend/app/models/assessment/submission.py
@@ -0,0 +1,82 @@
+"""Uploaded submission files for the assessment domain.
+
+Its own table rather than a row in ``evaluation_dataset``: that table multiplexes four
+surfaces behind a ``type`` column, carries eval-only fields, and its name uniqueness is
+type-agnostic, so an eval dataset name blocks an assessment one.
+"""
+
+from datetime import datetime
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel
+from sqlmodel import Field as SQLField
+from sqlmodel import SQLModel, UniqueConstraint
+
+from app.core.util import now
+
+
+class AssessmentSubmission(SQLModel, table=True):
+    """One uploaded submission file (CSV/XLSX) an assessment can be run against."""
+
+    __tablename__ = "assessment_submission"
+    __table_args__ = (
+        UniqueConstraint(
+            "name",
+            "organization_id",
+            "project_id",
+            name="uq_assessment_submission_name_org_project",
+        ),
+    )
+
+    id: UUID = SQLField(
+        default_factory=uuid4,
+        primary_key=True,
+        sa_column_kwargs={"comment": "Unique identifier for the submission"},
+    )
+    name: str = SQLField(
+        index=True,
+        sa_column_kwargs={
+            "comment": "Sanitized name; the object key is derived from it"
+        },
+    )
+    description: str | None = SQLField(
+        default=None, sa_column_kwargs={"comment": "Optional description"}
+    )
+    object_store_url: str = SQLField(
+        sa_column_kwargs={
+            "comment": "Object-store url of the uploaded file; its suffix gives the format"
+        }
+    )
+    total_items: int = SQLField(
+        default=0, sa_column_kwargs={"comment": "Row count, excluding the header"}
+    )
+
+    organization_id: int = SQLField(
+        foreign_key="organization.id", nullable=False, ondelete="CASCADE"
+    )
+    project_id: int = SQLField(
+        foreign_key="project.id", nullable=False, ondelete="CASCADE"
+    )
+    inserted_at: datetime = SQLField(default_factory=now, nullable=False)
+    updated_at: datetime = SQLField(default_factory=now, nullable=False)
+
+
+class AssessmentSubmissionPreview(BaseModel):
+    """First N rows of a submission file, for the upload confirmation screen."""
+
+    headers: list[str]
+    rows: list[list[str]]
+    returned_rows: int = 0
+    truncated: bool = False
+
+
+class AssessmentSubmissionResponse(BaseModel):
+    """API shape for a stored submission; ``signed_url`` is minted per request."""
+
+    submission_id: UUID
+    name: str
+    description: str | None = None
+    total_items: int = 0
+    object_store_url: str | None = None
+    signed_url: str | None = None
+    preview: AssessmentSubmissionPreview | None = None
diff --git a/backend/app/models/batch_job.py b/backend/app/models/batch_job.py
index 426d44f59..92e5763c7 100644
--- a/backend/app/models/batch_job.py
+++ b/backend/app/models/batch_job.py
@@ -83,6 +83,16 @@ class BatchJob(SQLModel, table=True):
         description="Provider's output file ID",
         sa_column_kwargs={"comment": "Provider's output file ID"},
     )
+    provider_error_file_id: str | None = Field(
+        default=None,
+        description="Provider's error file ID (OpenAI only)",
+        sa_column_kwargs={
+            "comment": (
+                "Provider's error file ID (OpenAI only; Anthropic and Gemini report "
+                "per-item errors inline)"
+            )
+        },
+    )
 
     # Provider status tracking
     provider_status: str | None = Field(
@@ -171,6 +181,7 @@ class BatchJobUpdate(SQLModel):
     provider_batch_id: str | None = None
     provider_file_id: str | None = None
     provider_output_file_id: str | None = None
+    provider_error_file_id: str | None = None
     provider_status: str | None = None
     raw_output_url: str | None = None
     total_items: int | None = None
@@ -187,6 +198,7 @@ class BatchJobPublic(SQLModel):
     provider_batch_id: str | None
     provider_file_id: str | None
     provider_output_file_id: str | None
+    provider_error_file_id: str | None
     provider_status: str | None
     raw_output_url: str | None
     total_items: int
diff --git a/backend/app/models/config/assessment_blob.py b/backend/app/models/config/assessment_blob.py
index d9a9600cf..f30f9f6ab 100644
--- a/backend/app/models/config/assessment_blob.py
+++ b/backend/app/models/config/assessment_blob.py
@@ -27,11 +27,18 @@
 
 
 class InputColumn(SQLModel):
-    """One BATCH input column: its type (required, no default — every column must
-    declare one), and how an attachment value is provided (`format`)."""
+    """One BATCH input column: its type (required), attachment `format`, and `strict`.
+
+    ``strict: true`` rejects a row where the column is absent or blank. Off by default:
+    the console declares every sheet column, and sheets have blanks. Unknown keys are
+    rejected so a misspelt flag fails at config save.
+    """
+
+    model_config = {"extra": "forbid"}
 
     type: Literal["text", "image", "pdf"]
     format: Literal["url", "base64"] | None = None
+    strict: bool = False
 
 
 class PreFilterParams(TextLLMParams):
@@ -160,9 +167,10 @@ class AssessmentConfigBlob(SQLModel):
         ...,
         min_length=1,
         description=(
-            "Per-column spec for the BATCH `data` rows ({type, format}). Shared by the "
-            "pre-filter and assessment consumers, so it lives once at the blob root. "
-            "Mandatory and non-empty; every declared column must be present in every row."
+            "Per-column spec for the BATCH `data` rows ({type, format, strict}). Shared by "
+            "the pre-filter and assessment consumers, so it lives once at the blob root. "
+            "Mandatory and non-empty; a column declared strict must be present and "
+            "non-blank in every row, any other column may be omitted or blank."
         ),
     )
     pre_filters: AssessmentPreFilters | None = None
diff --git a/backend/app/models/llm/request.py b/backend/app/models/llm/request.py
index f18e6af4e..870d1ef1c 100644
--- a/backend/app/models/llm/request.py
+++ b/backend/app/models/llm/request.py
@@ -82,6 +82,17 @@ class TextLLMParams(ParamSerialization, SQLModel):
             "Model-specific reasoning summary preference. " "Use null/None to disable."
         ),
     )
+    thinking: dict[str, Any] | None = Field(
+        default=None,
+        description=(
+            "Anthropic adaptive-thinking container, forwarded to the provider as-is "
+            "(e.g. {'type': 'enabled', 'budget_tokens': 4096})"
+        ),
+    )
+    thinking_level: Literal["low", "medium", "high"] | None = Field(
+        default=None,
+        description="Google thinking level for thinking-capable Gemini models",
+    )
     temperature: float | None = Field(
         default=0.1,
         ge=0.0,
diff --git a/backend/app/services/assessment/api/batch.py b/backend/app/services/assessment/api/batch.py
index 79e464edd..ec8dfdba9 100644
--- a/backend/app/services/assessment/api/batch.py
+++ b/backend/app/services/assessment/api/batch.py
@@ -18,17 +18,19 @@
 import logging
 from enum import StrEnum
 from typing import Any, cast
+from uuid import UUID
 
-from sqlmodel import Session
+from fastapi import HTTPException
+from sqlmodel import Session, col, select
 
 from app.core.batch import (
     BATCH_KEY,
     AnthropicBatchProvider,
     BatchJobState,
+    GeminiBatchProvider,
     GoogleGCPBatchProvider,
     MessageBatchStatus,
     OpenAIBatchProvider,
-    GeminiBatchProvider,
     extract_text_from_response_dict,
     poll_batch_status,
     process_completed_batch,
@@ -36,17 +38,15 @@
 )
 from app.core.batch.base import BatchProvider
 from app.core.batch.client import GeminiClient
-from fastapi import HTTPException
 from app.core.config import settings
 from app.core.db import engine
 from app.crud.assessment import api
-from app.crud.credentials import get_provider_credential
 from app.crud.assessment.batch import (
     build_anthropic_jsonl,
     build_google_jsonl,
     build_openai_jsonl,
 )
-from app.services.assessment.utils.attachments import rewrite_gcs_attachment_urls
+from app.crud.credentials import get_provider_credential
 from app.crud.job import get_batch_job
 from app.models.assessment import (
     Assessment,
@@ -66,11 +66,13 @@
     TopicRelevanceFilter,
 )
 from app.models.llm.constants import DEFAULT_ASSESSMENT_BATCH_MAX_TOKENS
-from app.services.assessment.mappers import (
+from app.services.llm.mappers import (
     map_kaapi_to_anthropic_params,
     map_kaapi_to_google_params,
     map_kaapi_to_openai_params,
 )
+from app.services.assessment.utils.attachments import rewrite_gcs_attachment_urls
+from app.services.assessment.validators import normalize_llm_text, stage_batch_prefix
 from app.services.llm.providers.registry import LLMProvider
 from app.utils import (
     get_anthropic_client,
@@ -98,7 +100,7 @@ def _google_gcp_credential(
     return cred
 
 
-# Re-poll cadence for a stage's provider batch, mirroring the assessment cron tick.
+# Re-poll cadence for a stage's provider batch, mirroring the assessment cron interval.
 POLL_COUNTDOWN_SECONDS = settings.CRON_INTERVAL_MINUTES * 60
 
 
@@ -199,21 +201,13 @@ def _stage_kind(pipeline: list[dict[str, str]], stage: str) -> str:
     raise ValueError(f"[_stage_kind] Stage {stage} not in pipeline")
 
 
-def build_rows(
-    batch_input: BatchInput,
-    input_columns: dict[str, Any] | None = None,
-) -> tuple[list[dict[str, str]], list[str], list[AssessmentAttachment]]:
-    """Split each submission into text cells + attachment specs for the JSONL builders.
+def column_kinds(
+    columns: list[str], input_columns: dict[str, Any]
+) -> tuple[list[str], list[AssessmentAttachment]]:
+    """Split columns into text names and attachment specs per the config's ``input_schema``.
 
-    Column kinds come from the config's ``input_schema``: a column typed image/pdf is
-    an attachment column (url-format only); any column not declared there is text. Cells are
-    plain strings (an attachment cell holds the url), so the URL-only JSONL builders consume
-    them unchanged.
+    A column typed image/pdf is an attachment (url-format only); anything else is text.
     """
-    submissions = batch_input.data
-    input_columns = input_columns or {}
-    columns = list(submissions[0].keys()) if submissions else []
-
     text_columns: list[str] = []
     attachments: list[AssessmentAttachment] = []
     for column in columns:
@@ -230,7 +224,24 @@ def build_rows(
             )
         else:
             text_columns.append(column)
+    return text_columns, attachments
+
 
+def build_rows(
+    batch_input: BatchInput,
+    input_columns: dict[str, Any] | None = None,
+) -> tuple[list[dict[str, str]], list[str], list[AssessmentAttachment]]:
+    """Normalise submissions to string cells over the union of row and schema columns.
+
+    Submit-time only; the batch task streams the stored rows instead. A column a row omits
+    (non-strict) is filled with "".
+    """
+    submissions = batch_input.data or []
+    input_columns = input_columns or {}
+    columns = list(
+        dict.fromkeys([*(key for sub in submissions for key in sub), *input_columns])
+    )
+    text_columns, attachments = column_kinds(columns, input_columns)
     rows = [{col: str(sub.get(col, "")) for col in columns} for sub in submissions]
     return rows, text_columns, attachments
 
@@ -274,6 +285,8 @@ def _stage_params(blob: AssessmentConfigBlob, stage: str) -> dict[str, Any]:
         params.pop("submission", None)
         if json_schema is not None:
             params["output_schema"] = json_schema  # provider param name
+        # Normalised here, not in the mapper, so only this path's prompts are rewritten.
+        params["instructions"] = normalize_llm_text(params.get("instructions") or "")
         return params
 
     flt = _prefilter_for_stage(blob, stage)
@@ -282,7 +295,7 @@ def _stage_params(blob: AssessmentConfigBlob, stage: str) -> dict[str, Any]:
     params["output_schema"] = PREFILTER_VERDICT_SCHEMA
     # The config's criteria (mandatory params.instructions) is the system prompt;
     # append the gate directive so the model returns the verdict+reasoning contract.
-    criteria = params.get("instructions") or ""
+    criteria = normalize_llm_text(params.get("instructions") or "")
     params["instructions"] = f"{criteria}\n\n{_PREFILTER_INSTRUCTION}"
     return params
 
@@ -598,21 +611,45 @@ def _submit_stage(
     *,
     session: Session,
     execution: AssessmentRun,
+    assessment: Assessment,
     blob: AssessmentConfigBlob,
-    batch_input: BatchInput,
     bag: BatchRunState,
     stage: str,
     organization_id: int,
     project_id: int,
 ) -> bool:
-    """Build + submit the current stage's batch on its row subset. Returns success."""
+    """Build + submit the current stage's batch on its row subset. Returns success.
+
+    A stage already in flight is reported as submitted (no second provider batch): the
+    in-memory bag can predate a concurrent task's write, so the row is re-read here.
+    Rows are streamed from storage once per stage submit; only this stage's subset is held.
+    """
+    session.refresh(execution)
+    persisted = cast(BatchRunState, execution.execution or {})
+    in_flight_batch_id = (persisted.get("stage_batches") or {}).get(stage)
+    if (
+        in_flight_batch_id is not None
+        and persisted.get("stage_status") == StageStatus.PROCESSING.value
+    ):
+        # Deliberately leaves `bag` unpersisted: the stored state is the fresher one.
+        logger.warning(
+            "[_submit_stage] Stage already submitted, skipping duplicate | "
+            "execution_id=%s | stage=%s | batch_job=%s",
+            execution.id,
+            stage,
+            in_flight_batch_id,
+        )
+        return True
+
+    from app.services.assessment.api.submission_store import open_submission_rows
+
     kind = _stage_kind(bag["pipeline"], stage)
     input_columns = {
         name: col.model_dump(exclude_none=True)
         for name, col in blob.input_schema.items()
     }
-    rows, text_columns, attachments = build_rows(batch_input, input_columns)
-    subset = _row_subset(bag, stage, kind, len(rows))
+    text_columns, attachments = column_kinds(list(input_columns), input_columns)
+    subset = _row_subset(bag, stage, kind, execution.total_items)
 
     if not subset:
         # No rows left for this stage (everything gated out upstream). Persist the
@@ -627,12 +664,16 @@ def _submit_stage(
         api.save_execution_state(session=session, execution=execution, state=bag)
         return False
 
+    wanted = set(subset)
+    with open_submission_rows(session=session, assessment=assessment) as stream:
+        rows = [row for idx, row in enumerate(stream) if idx in wanted]
+
     provider_name, model = _stage_provider_model(blob, stage)
     batch_job = _submit_provider_batch(
         session=session,
         provider_name=provider_name,
         model=model,
-        rows=[rows[i] for i in subset],
+        rows=rows,
         text_columns=text_columns,
         attachments=attachments,
         prompt=_stage_prompt(blob, stage),
@@ -660,8 +701,26 @@ def _submit_stage(
     return True
 
 
+def error_file_entries(provider: BatchProvider, file_id: str) -> list[dict[str, Any]]:
+    """Parsed lines of a provider error file (OpenAI only); an unparseable line is skipped."""
+    entries: list[dict[str, Any]] = []
+    for line in provider.download_file(file_id).splitlines():
+        if not line.strip():
+            continue
+        try:
+            entries.append(json.loads(line))
+        except json.JSONDecodeError:
+            logger.warning(
+                "[error_file_entries] Unparseable line skipped | file_id=%s", file_id
+            )
+    return entries
+
+
 def _poll_outcome(
-    session: Session, provider: BatchProvider, batch_job: BatchJob
+    session: Session,
+    provider: BatchProvider,
+    batch_job: BatchJob,
+    assessment_id: UUID,
 ) -> tuple[str, list[dict[str, Any]] | None]:
     """Poll a stage batch. Returns ('processing'|'completed'|'failed', results)."""
     status_result = poll_batch_status(
@@ -680,8 +739,25 @@ def _poll_outcome(
             return "failed", None
         if batch_job.provider_output_file_id:
             results, _ = process_completed_batch(
-                session=session, provider=provider, batch_job=batch_job
+                session=session,
+                provider=provider,
+                batch_job=batch_job,
+                subdirectory=stage_batch_prefix(assessment_id, batch_job.id),
             )
+            # Rows OpenAI rejected live only in the error file; without them they would
+            # read as "no output, no error" and the stage could finish COMPLETED.
+            if batch_job.provider_error_file_id:
+                try:
+                    results = [
+                        *results,
+                        *error_file_entries(provider, batch_job.provider_error_file_id),
+                    ]
+                except Exception:
+                    logger.warning(
+                        "[_poll_outcome] Provider error file unreadable | batch_job_id=%s",
+                        batch_job.id,
+                        exc_info=True,
+                    )
             return "completed", results
         return "processing", None  # output not ready yet
     if status in _FAILED_STATUSES:
@@ -696,6 +772,7 @@ def _finalize(
     bag: BatchRunState,
 ) -> None:
     from app.services.assessment.api.callbacks import deliver
+    from app.services.assessment.api.result_files import finalize_result_files
     from app.services.assessment.api.results import build_result
 
     bag["stage"] = ApiStage.ASSESSMENT.value
@@ -721,13 +798,20 @@ def _finalize(
         errors,
     )
 
+    # Before the callback check: durability must not depend on a callback existing.
+    finalize_result_files(
+        session=session, execution=execution, assessment=assessment, bag=bag
+    )
+
     callback_url = bag.get("callback_url")
     if callback_url:
         deliver(
+            session=session,
             assessment=assessment,
             result=result,
             callback_url=callback_url,
             request_metadata=bag.get("request_metadata"),
+            failure_message=None,
         )
 
 
@@ -739,6 +823,7 @@ def _fail(
     message: str,
 ) -> None:
     from app.services.assessment.api.callbacks import deliver
+    from app.services.assessment.api.result_files import finalize_result_files
     from app.services.assessment.api.results import build_result
 
     bag["stage_status"] = StageStatus.FAILED.value
@@ -751,14 +836,25 @@ def _fail(
         "[_fail] Execution failed | execution_id=%s | message=%s", execution.id, message
     )
 
+    # Before the callback check: durability must not depend on a callback existing.
+    finalize_result_files(
+        session=session,
+        execution=execution,
+        assessment=assessment,
+        bag=bag,
+        failure_message=message,
+    )
+
     callback_url = bag.get("callback_url")
     if callback_url:
         result = build_result(session=session, assessment=assessment)
         deliver(
+            session=session,
             assessment=assessment,
             result=result,
             callback_url=callback_url,
             request_metadata=bag.get("request_metadata"),
+            failure_message=message,
         )
 
 
@@ -768,7 +864,6 @@ def _advance_or_finalize(
     execution: AssessmentRun,
     assessment: Assessment,
     blob: AssessmentConfigBlob,
-    batch_input: BatchInput,
     bag: BatchRunState,
     stage: str,
     organization_id: int,
@@ -780,6 +875,8 @@ def _advance_or_finalize(
     (``_submit_stage`` returns False); it is treated as completed and skipped, recursing
     so a chain of empty stages still terminates at ``_finalize``.
     """
+    from app.services.assessment.api.submission_store import SubmissionUnavailableError
+
     nxt = next_stage(bag["pipeline"], stage)
     if nxt is None:
         _finalize(session, execution, assessment, bag)
@@ -790,13 +887,23 @@ def _advance_or_finalize(
         submitted = _submit_stage(
             session=session,
             execution=execution,
+            assessment=assessment,
             blob=blob,
-            batch_input=batch_input,
             bag=bag,
             stage=nxt,
             organization_id=organization_id,
             project_id=project_id,
         )
+    except SubmissionUnavailableError as exc:
+        # Storage blip, not a bad run: the stage is still PENDING, so retry the task.
+        logger.warning(
+            "[_advance_or_finalize] Submission unreadable, will retry | "
+            "execution_id=%s | stage=%s | %s",
+            execution.id,
+            nxt,
+            exc,
+        )
+        return {"requeue": True}
     except Exception as exc:
         _fail(session, execution, assessment, bag, str(exc))
         return {"requeue": False}
@@ -808,7 +915,6 @@ def _advance_or_finalize(
             execution=execution,
             assessment=assessment,
             blob=blob,
-            batch_input=batch_input,
             bag=bag,
             stage=nxt,
             organization_id=organization_id,
@@ -820,15 +926,26 @@ def _advance_or_finalize(
 def run_batch_stage(
     *, execution_id: int, organization_id: int, project_id: int
 ) -> dict[str, bool]:
-    """Drive one tick of the staged pipeline. Returns ``{"requeue": bool}``.
+    """Run one step of the staged pipeline. Returns ``{"requeue": bool}``.
 
     Idempotent: keyed off ``stage_status`` in the bag — a redelivery either re-polls
     the in-flight batch or re-submits a stage that was never dispatched.
     """
+    # Lazy (like callbacks/results below): result_files imports ApiStage from this module.
+    from app.services.assessment.api.result_files import record_stage_dump
+    from app.services.assessment.api.submission_store import SubmissionUnavailableError
+
     with Session(engine) as session:
-        execution = session.get(AssessmentRun, execution_id)
+        execution = session.exec(
+            select(AssessmentRun)
+            .where(col(AssessmentRun.id) == execution_id)
+            .with_for_update(skip_locked=True)
+        ).first()
         if execution is None:
-            logger.error("[run_batch_stage] execution_id=%s not found", execution_id)
+            logger.warning(
+                "[run_batch_stage] execution_id=%s missing or held by another task",
+                execution_id,
+            )
             return {"requeue": False}
         assessment = session.get(Assessment, execution.assessment_id)
         if assessment is None:
@@ -853,11 +970,18 @@ def run_batch_stage(
             )
             return {"requeue": False}
 
+        # Entry log: distinguishes "the task never ran" from "it ran and did nothing".
+        logger.info(
+            "[run_batch_stage] Step | execution_id=%s | stage=%s | stage_status=%s",
+            execution_id,
+            stage,
+            stage_status,
+        )
+
         # Resolving the stored blob can raise (deleted config version -> 404, or an
         # invalid/old-shape blob). Route these to _fail so the client gets a terminal
         # callback instead of the run stranding in PROCESSING.
         try:
-            batch_input = BatchInput.model_validate(assessment.input)
             blob = AssessmentConfigBlob.model_validate(
                 _resolve_blob(session, execution, project_id)
             )
@@ -870,13 +994,23 @@ def run_batch_stage(
                 submitted = _submit_stage(
                     session=session,
                     execution=execution,
+                    assessment=assessment,
                     blob=blob,
-                    batch_input=batch_input,
                     bag=bag,
                     stage=stage,
                     organization_id=organization_id,
                     project_id=project_id,
                 )
+            except SubmissionUnavailableError as exc:
+                # Storage blip, not a bad run: the stage stays PENDING, retry the task.
+                logger.warning(
+                    "[run_batch_stage] Submission unreadable, will retry | "
+                    "execution_id=%s | stage=%s | %s",
+                    execution_id,
+                    stage,
+                    exc,
+                )
+                return {"requeue": True}
             except Exception as exc:
                 # Credential/provider/network errors from _submit_provider_batch, not
                 # just ValueError — all are terminal for this run.
@@ -894,7 +1028,6 @@ def run_batch_stage(
                     execution=execution,
                     assessment=assessment,
                     blob=blob,
-                    batch_input=batch_input,
                     bag=bag,
                     stage=stage,
                     organization_id=organization_id,
@@ -918,7 +1051,9 @@ def run_batch_stage(
                 organization_id=organization_id,
                 project_id=project_id,
             )
-            outcome, results = _poll_outcome(session, provider, batch_job)
+            outcome, results = _poll_outcome(
+                session, provider, batch_job, assessment.id
+            )
         except Exception as exc:
             # Transient (network/provider hiccup) — the batch is still running; retry.
             logger.warning(
@@ -946,7 +1081,22 @@ def run_batch_stage(
         parsed = parse_batch_results(results or [], bag["provider"])
         _record_stage(bag, stage, kind, parsed)
         bag["stage_status"] = StageStatus.COMPLETED.value
+
+        stage_errors: dict[str, str] = {}
+        for idx, out in parsed.items():
+            error = out.get("error")
+            if error:
+                stage_errors[str(idx)] = error
+        bag.setdefault("stage_errors", {})[stage] = stage_errors
+
         bag.setdefault("stage_output_urls", {})[stage] = batch_job.raw_output_url
+        # Per stage, not only at terminal time: a run that never terminates still has dumps.
+        record_stage_dump(
+            session=session,
+            assessment=assessment,
+            stage=stage,
+            url=batch_job.raw_output_url,
+        )
         api.save_execution_state(session=session, execution=execution, state=bag)
 
         return _advance_or_finalize(
@@ -954,7 +1104,6 @@ def run_batch_stage(
             execution=execution,
             assessment=assessment,
             blob=blob,
-            batch_input=batch_input,
             bag=bag,
             stage=stage,
             organization_id=organization_id,
diff --git a/backend/app/services/assessment/api/callbacks.py b/backend/app/services/assessment/api/callbacks.py
index 169397575..dbea7341c 100644
--- a/backend/app/services/assessment/api/callbacks.py
+++ b/backend/app/services/assessment/api/callbacks.py
@@ -2,18 +2,21 @@
 
 POSTs the ``AssessmentCallback`` envelope to the client's callback_url on completion via
 the shared SSRF-guarded ``send_callback`` (HMAC-signed with the project webhook secret) —
-the same transport the response path uses.
+the same transport the response path uses. One inline attempt, no retry.
 """
 
 import logging
 from typing import Any
 
+from sqlmodel import Session
+
 from app.models.assessment import (
     Assessment,
     AssessmentBatchResult,
     AssessmentCallback,
     AssessmentStatus,
 )
+from app.services.assessment.api.result_files import build_callback_metadata
 from app.utils import get_webhook_secret, send_callback
 
 logger = logging.getLogger(__name__)
@@ -21,14 +24,17 @@
 
 def deliver(
     *,
+    session: Session,
     assessment: Assessment,
     result: AssessmentBatchResult,
     callback_url: str,
     request_metadata: dict[str, Any] | None,
+    failure_message: str | None,
 ) -> bool:
     """POST the assessment result to ``callback_url`` (HMAC-signed). Returns whether it was sent.
 
-    ``request_metadata`` is echoed back unchanged for client-side correlation.
+    ``request_metadata`` is the client's own echo; the envelope ``metadata`` carries the
+    presigned result-file urls, and ``failure_message`` becomes the envelope ``error``.
     """
     callback = AssessmentCallback(
         assessment_id=assessment.id,
@@ -39,20 +45,33 @@ def deliver(
     webhook_secret = get_webhook_secret(
         assessment.project_id, assessment.organization_id
     )
+
+    try:
+        metadata = build_callback_metadata(session=session, assessment=assessment)
+    except Exception:
+        # A metadata bug must never cost the client its result.
+        logger.error(
+            "[deliver] Callback metadata failed, delivering without it | assessment_id=%s",
+            assessment.id,
+            exc_info=True,
+        )
+        metadata = None
+
     sent = send_callback(
         callback_url,
         {
             "success": assessment.status != AssessmentStatus.FAILED,
             "data": callback.model_dump(mode="json"),
-            "error": None,
-            "metadata": None,
+            "error": failure_message,
+            "metadata": metadata,
         },
         webhook_secret=webhook_secret,
     )
     logger.info(
-        "[deliver] Callback %s | assessment_id=%s | status=%s",
+        "[deliver] Callback %s | assessment_id=%s | status=%s | result_files=%s",
         "sent" if sent else "failed",
         assessment.id,
         assessment.status,
+        sorted((metadata or {}).get("result_files", {})),
     )
     return sent
diff --git a/backend/app/services/assessment/api/result_files.py b/backend/app/services/assessment/api/result_files.py
new file mode 100644
index 000000000..582ded0e1
--- /dev/null
+++ b/backend/app/services/assessment/api/result_files.py
@@ -0,0 +1,308 @@
+"""Durable result dumps for the BATCH API-client path.
+
+Records every provider dump on ``assessment.result_files`` as ``{kind: {object_store_url}}``,
+builds ``errors.jsonl`` at terminal time, and presigns both into the callback envelope.
+Nothing here raises into the terminal path: a missing dump degrades to a missing key.
+"""
+
+import logging
+from datetime import timedelta
+from enum import StrEnum
+from typing import Any
+
+from sqlmodel import Session
+
+from app.core.cloud import get_cloud_storage
+from app.core.config import settings
+from app.core.storage_utils import upload_jsonl_to_object_store
+from app.core.util import now
+from app.crud.assessment import api
+from app.crud.job import get_batch_job
+from app.models.assessment import (
+    Assessment,
+    AssessmentRun,
+    BatchRunState,
+)
+from app.models.batch_job import BatchJob
+from app.services.assessment.api.batch import (
+    ApiStage,
+    _build_batch_provider,
+    error_file_entries,
+)
+from app.services.assessment.validators import (
+    ERRORS_FILENAME,
+    assessment_prefix,
+)
+
+logger = logging.getLogger(__name__)
+
+RESULTS_FILE_KIND = "results"
+ERRORS_FILE_KIND = "errors"
+
+# 86400 is the storage layer's own ceiling, so the presigned urls live exactly one day.
+SIGNED_URL_EXPIRY_SECONDS = settings.MAX_SIGNED_URL_EXPIRY_SECONDS
+
+
+class ErrorRecordEnum(StrEnum):
+    """``type`` tag on each errors.jsonl row, so the file is self-describing."""
+
+    EXECUTION_ERROR = "execution_error"
+    ROW_ERROR = "row_error"
+    PROVIDER_ERROR_FILE = "provider_error_file"
+    PROVIDER_ERROR_FILE_UNAVAILABLE = "provider_error_file_unavailable"
+
+
+def stage_file_kind(stage: str) -> str:
+    """Result-file kind for a stage's dump; the assessment dump is the run's ``results``."""
+    if stage == ApiStage.ASSESSMENT.value:
+        return RESULTS_FILE_KIND
+    return f"{stage}_results"
+
+
+def record_stage_dump(
+    *,
+    session: Session,
+    assessment: Assessment,
+    stage: str,
+    url: str | None,
+) -> None:
+    """Record one stage's dump on the parent row as soon as the stage completes.
+
+    No-op on a falsy url: ``process_completed_batch`` swallows a failed upload.
+    """
+    if not url:
+        logger.warning(
+            "[record_stage_dump] No dump url to record | assessment_id=%s | stage=%s",
+            assessment.id,
+            stage,
+        )
+        return
+
+    api.set_result_files(
+        session=session,
+        assessment=assessment,
+        files={stage_file_kind(stage): {"object_store_url": url}},
+    )
+
+
+def _row_error_rows(stage_errors: dict[str, dict[str, str]]) -> list[dict[str, Any]]:
+    """Per-row errors captured at parse time, flattened across stages."""
+    rows: list[dict[str, Any]] = []
+    for stage, errors in stage_errors.items():
+        for row_index, error in errors.items():
+            rows.append(
+                {
+                    "type": ErrorRecordEnum.ROW_ERROR.value,
+                    "stage": stage,
+                    "row_index": int(row_index) if row_index.isdigit() else row_index,
+                    "error": error,
+                }
+            )
+    return rows
+
+
+def _error_file_rows(
+    *, session: Session, assessment: Assessment, stage: str, batch_job: BatchJob
+) -> list[dict[str, Any]]:
+    """Parsed lines of one stage batch's provider error file (OpenAI only).
+
+    Degrades to a single ``provider_error_file_unavailable`` row: the client still learns
+    the file existed and could not be read.
+    """
+    file_id = batch_job.provider_error_file_id
+    if not file_id:
+        return []
+
+    try:
+        provider = _build_batch_provider(
+            session=session,
+            provider_name=batch_job.provider,
+            organization_id=assessment.organization_id,
+            project_id=assessment.project_id,
+        )
+        entries = error_file_entries(provider, file_id)
+    except Exception as exc:
+        # Provider SDKs raise heterogeneous types here and the dump is best-effort.
+        message = (
+            f"[KAAPI] Could not download the provider error file "
+            f"(code: {type(exc).__name__}): {exc}"
+        )
+        logger.error(
+            "[_error_file_rows] %s | batch_job_id=%s | stage=%s",
+            message,
+            batch_job.id,
+            stage,
+            exc_info=True,
+        )
+        return [
+            {
+                "type": ErrorRecordEnum.PROVIDER_ERROR_FILE_UNAVAILABLE.value,
+                "stage": stage,
+                "provider_error_file_id": file_id,
+                "error": message,
+            }
+        ]
+
+    return [
+        {
+            "type": ErrorRecordEnum.PROVIDER_ERROR_FILE.value,
+            "stage": stage,
+            "provider_error_file_id": file_id,
+            "entry": entry,
+        }
+        for entry in entries
+    ]
+
+
+def build_and_upload_errors(
+    *,
+    session: Session,
+    execution: AssessmentRun,
+    assessment: Assessment,
+    bag: BatchRunState,
+    failure_message: str | None,
+) -> str | None:
+    """Assemble and upload the run's ``errors.jsonl``. Returns its object-store url.
+
+    Uploaded even when there are no rows, so the "both a results and an errors url"
+    promise holds on the clean-success path too.
+    """
+    rows: list[dict[str, Any]] = []
+    if failure_message:
+        rows.append(
+            {
+                "type": ErrorRecordEnum.EXECUTION_ERROR.value,
+                "stage": bag.get("stage"),
+                "error": failure_message,
+            }
+        )
+    rows.extend(_row_error_rows(bag.get("stage_errors") or {}))
+    for stage, batch_job_id in (bag.get("stage_batches") or {}).items():
+        batch_job = (
+            get_batch_job(session=session, batch_job_id=batch_job_id)
+            if batch_job_id
+            else None
+        )
+        if batch_job is not None:
+            rows.extend(
+                _error_file_rows(
+                    session=session,
+                    assessment=assessment,
+                    stage=stage,
+                    batch_job=batch_job,
+                )
+            )
+
+    try:
+        storage = get_cloud_storage(session=session, project_id=assessment.project_id)
+    except Exception:
+        logger.error(
+            "[build_and_upload_errors] Storage unavailable, no errors dump | "
+            "execution_id=%s | rows=%s",
+            execution.id,
+            len(rows),
+            exc_info=True,
+        )
+        return None
+
+    url = upload_jsonl_to_object_store(
+        storage=storage,
+        results=rows,
+        filename=ERRORS_FILENAME,
+        subdirectory=assessment_prefix(assessment.id),
+    )
+    logger.info(
+        "[build_and_upload_errors] Errors dump %s | execution_id=%s | rows=%s | url=%s",
+        "uploaded" if url else "upload failed",
+        execution.id,
+        len(rows),
+        url,
+    )
+    return url
+
+
+def finalize_result_files(
+    *,
+    session: Session,
+    execution: AssessmentRun,
+    assessment: Assessment,
+    bag: BatchRunState,
+    failure_message: str | None = None,
+) -> None:
+    """Persist every stage dump plus the run's errors.jsonl at terminal time.
+
+    Idempotent (a re-merge replaces only its own kind), so a redelivered tick is
+    harmless. Never raises: durability is best-effort, terminating the run is not.
+    """
+    try:
+        files: dict[str, dict[str, Any]] = {}
+        for stage, url in (bag.get("stage_output_urls") or {}).items():
+            if not url:
+                continue
+            files[stage_file_kind(stage)] = {"object_store_url": url}
+
+        errors_url = build_and_upload_errors(
+            session=session,
+            execution=execution,
+            assessment=assessment,
+            bag=bag,
+            failure_message=failure_message,
+        )
+        if errors_url:
+            files[ERRORS_FILE_KIND] = {"object_store_url": errors_url}
+
+        if files:
+            api.set_result_files(session=session, assessment=assessment, files=files)
+    except Exception:
+        logger.error(
+            "[finalize_result_files] Could not persist result files | "
+            "assessment_id=%s | execution_id=%s",
+            assessment.id,
+            execution.id,
+            exc_info=True,
+        )
+
+
+def build_callback_metadata(
+    *, session: Session, assessment: Assessment
+) -> dict[str, Any]:
+    """Presign every recorded result file for the callback envelope's ``metadata``.
+
+    Always returns ``{"result_files": ..., "expires_at": ...}``; a per-key presign
+    failure drops that entry rather than the whole envelope key.
+    """
+    expires_at = (now() + timedelta(seconds=SIGNED_URL_EXPIRY_SECONDS)).isoformat()
+    signed: dict[str, dict[str, Any]] = {}
+
+    try:
+        storage = get_cloud_storage(session=session, project_id=assessment.project_id)
+    except Exception:
+        logger.error(
+            "[build_callback_metadata] Storage unavailable, sending empty result_files | "
+            "assessment_id=%s",
+            assessment.id,
+            exc_info=True,
+        )
+        return {"result_files": signed, "expires_at": expires_at}
+
+    for kind, record in assessment.result_files.items():
+        entry: dict[str, Any] = record or {}
+        object_store_url = entry.get("object_store_url")
+        if not object_store_url:
+            continue
+        try:
+            signed_url = storage.get_signed_url(
+                object_store_url, expires_in=SIGNED_URL_EXPIRY_SECONDS
+            )
+        except Exception:
+            logger.error(
+                "[build_callback_metadata] Presign failed, dropping kind | "
+                "assessment_id=%s | kind=%s",
+                assessment.id,
+                kind,
+                exc_info=True,
+            )
+            continue
+        signed[kind] = {"signed_url": signed_url}
+
+    return {"result_files": signed, "expires_at": expires_at}
diff --git a/backend/app/services/assessment/api/results.py b/backend/app/services/assessment/api/results.py
index b61973a6d..32463b238 100644
--- a/backend/app/services/assessment/api/results.py
+++ b/backend/app/services/assessment/api/results.py
@@ -1,4 +1,4 @@
-"""Assemble an AssessmentBatchResult for the BATCH API-client path.
+"""Assemble the BATCH API-client result, for the webhook and the poll endpoint.
 
 One result unit per input row. Gate-failed rows carry ``assessment=null`` plus
 their pre-filter verdicts; gate-passed rows carry the assessment call's parsed
@@ -17,21 +17,23 @@
 from app.models.assessment import (
     Assessment,
     AssessmentBatchResult,
+    AssessmentConfigRef,
     AssessmentCounts,
+    AssessmentDetailResponse,
     AssessmentOutput,
     AssessmentResult,
-    BatchInput,
+    AssessmentResultRow,
+    AssessmentRun,
+    AssessmentSubmission,
+    AssessmentSummary,
     BatchRunState,
     ParsedResult,
     PreFilter,
     PreFilterVerdict,
+    Submission,
     Verdict,
 )
-from app.services.assessment.api.batch import (
-    ApiStage,
-    build_rows,
-    parse_batch_results,
-)
+from app.services.assessment.api.batch import ApiStage, parse_batch_results
 from app.services.assessment.utils.parsing import parse_stored_results
 
 logger = logging.getLogger(__name__)
@@ -86,25 +88,31 @@ def _load_assessment_outputs(
         return {}, "Assessment output could not be read from storage."
 
 
-def build_result(*, session: Session, assessment: Assessment) -> AssessmentBatchResult:
+def build_result(
+    *,
+    session: Session,
+    assessment: Assessment,
+    execution: AssessmentRun | None = None,
+) -> AssessmentBatchResult:
     """Build the per-row result from stored verdicts (bag) + assessment output (store).
 
     Status lives on the response envelope (sourced from the parent assessment), so this
-    result body carries only the rows and their tallies.
+    result body carries only the rows and their tallies. Pass ``execution`` when the
+    caller already holds it, so a poll does not re-query it.
     """
-    executions = api.list_executions(session=session, assessment_id=assessment.id)
-    bag = cast(BatchRunState, (executions[0].execution or {}) if executions else {})
+    if execution is None:
+        executions = api.list_executions(session=session, assessment_id=assessment.id)
+        execution = executions[0] if executions else None
+    bag = cast(BatchRunState, (execution.execution or {}) if execution else {})
 
-    batch_input = (
-        BatchInput.model_validate(assessment.input) if assessment.input else None
-    )
-    input_columns = bag.get("input_schema") or {}
-    rows, _, _ = build_rows(batch_input, input_columns) if batch_input else ([], [], [])
-    total_items = len(rows)
+    # Off the execution, not re-derived: the terminal path must not fetch rows to count them.
+    total_items = execution.total_items if execution else 0
 
     gate_passed = bag.get("gate_passed") or [True] * total_items
     verdicts = bag.get("verdicts") or {}
     outputs, load_error = _load_assessment_outputs(session, bag, assessment.project_id)
+    # Rows the provider rejected are absent from the output dump; the bag kept their error.
+    row_errors = (bag.get("stage_errors") or {}).get(ApiStage.ASSESSMENT.value, {})
 
     tr_verdicts = verdicts.get(ApiStage.TOPIC_RELEVANCE.value, {})
 
@@ -120,6 +128,8 @@ def build_result(*, session: Session, assessment: Assessment) -> AssessmentBatch
                 out = outputs[idx]
                 assessment_output = _parse_assessment(out)
                 error = out.get("error")
+            elif str(idx) in row_errors:
+                error = row_errors[str(idx)]
             elif load_error:
                 error = load_error
 
@@ -149,3 +159,96 @@ def build_result(*, session: Session, assessment: Assessment) -> AssessmentBatch
         counts=counts,
         items=items,
     )
+
+
+def _submission_rows(session: Session, assessment: Assessment) -> list[Submission]:
+    """The rows the run was submitted with; empty when they cannot be read.
+
+    A storage blip must degrade the poll to rows without input columns, never fail it.
+    """
+    from app.services.assessment.api.submission_store import (
+        SubmissionUnavailableError,
+        open_submission_rows,
+    )
+
+    try:
+        with open_submission_rows(session=session, assessment=assessment) as stream:
+            return list(stream)
+    except (SubmissionUnavailableError, ValueError) as exc:
+        logger.warning(
+            "[_submission_rows] Submission rows unavailable | assessment_id=%s | %s",
+            assessment.id,
+            exc,
+        )
+        return []
+
+
+def build_summary(
+    assessment: Assessment,
+    execution: AssessmentRun | None,
+    submission_name: str | None = None,
+) -> AssessmentSummary:
+    """List row for one assessment. Reads only columns and the exec bag, never storage."""
+    bag = cast(BatchRunState, (execution.execution or {}) if execution else {})
+    config = (
+        AssessmentConfigRef(id=execution.config_id, version=execution.config_version)
+        if execution
+        else None
+    )
+    return AssessmentSummary(
+        assessment_id=assessment.id,
+        method=assessment.method,
+        status=assessment.status,
+        experiment_name=assessment.experiment_name,
+        submission_id=assessment.submission_id,
+        submission_name=submission_name,
+        config=config,
+        total_items=execution.total_items if execution else 0,
+        stages=[
+            str(step["stage"]) for step in bag.get("pipeline", []) if step.get("stage")
+        ],
+        stage=bag.get("stage"),
+        stage_status=bag.get("stage_status"),
+        error=execution.error_message if execution else None,
+        inserted_at=assessment.inserted_at,
+        updated_at=assessment.updated_at,
+    )
+
+
+def build_detail(
+    *, session: Session, assessment: Assessment, include_input: bool = False
+) -> AssessmentDetailResponse:
+    """Poll payload: run status plus every row produced so far.
+
+    ``include_input`` echoes the submitted columns; it costs a storage read, so a tight
+    poll loop leaves it off.
+    """
+    executions = api.list_executions(session=session, assessment_id=assessment.id)
+    execution = executions[0] if executions else None
+    submission = (
+        session.get(AssessmentSubmission, assessment.submission_id)
+        if assessment.submission_id
+        else None
+    )
+
+    result = build_result(session=session, assessment=assessment, execution=execution)
+    rows = _submission_rows(session, assessment) if include_input else []
+
+    items = [
+        AssessmentResultRow(
+            row_index=idx,
+            input=rows[idx] if idx < len(rows) else None,
+            output=item.output,
+            error=item.error,
+        )
+        for idx, item in enumerate(result.items)
+    ]
+
+    summary = build_summary(
+        assessment, execution, submission.name if submission else None
+    )
+    return AssessmentDetailResponse(
+        **summary.model_dump(),
+        counts=result.counts,
+        items=items,
+    )
diff --git a/backend/app/services/assessment/api/submission.py b/backend/app/services/assessment/api/submission.py
index 6ea711feb..848466fae 100644
--- a/backend/app/services/assessment/api/submission.py
+++ b/backend/app/services/assessment/api/submission.py
@@ -6,6 +6,8 @@
 """
 
 import logging
+from urllib.parse import urlparse
+from uuid import UUID, uuid4
 
 from asgi_correlation_id import correlation_id
 from fastapi import HTTPException
@@ -13,6 +15,7 @@
 from sqlmodel import Session
 
 from app.crud.assessment import api
+from app.crud.assessment.submission import get_submission_by_id
 from app.crud.config import ConfigCrud, ConfigVersionCrud
 from app.models.assessment import (
     AssessmentCreate,
@@ -26,6 +29,10 @@
 from app.models.config.assessment_blob import AssessmentConfigBlob
 from app.models.config.config import ConfigTag
 from app.services.assessment.api import batch as batch_service
+from app.services.assessment.api.submission_store import (
+    open_uploaded_rows,
+    upload_submission_rows,
+)
 from app.utils import validate_callback_url
 
 logger = logging.getLogger(__name__)
@@ -33,6 +40,25 @@
 # Attachment cell values are provided as URLs (base64 is unsupported for batch).
 _URL_PREFIXES = ("http://", "https://", "gs://")
 _ATTACHMENT_TYPES = ("image", "pdf")
+_EXTENSION_TYPES = {
+    ".pdf": "pdf",
+    ".png": "image",
+    ".jpg": "image",
+    ".jpeg": "image",
+    ".gif": "image",
+    ".webp": "image",
+}
+
+
+def _url_attachment_type(url: str) -> str | None:
+    """The kind a URL's own extension implies, or None when it names no extension.
+
+    Presigned URLs carry a query string, so only the path is read.
+    """
+    path = urlparse(url).path.lower()
+    return next(
+        (kind for ext, kind in _EXTENSION_TYPES.items() if path.endswith(ext)), None
+    )
 
 
 def _validate_rows_against_schema(
@@ -40,20 +66,22 @@ def _validate_rows_against_schema(
 ) -> None:
     """Validate every BATCH row against the config's input_schema.
 
-    Raises 422 on the first offending row: a missing declared column, an
-    unexpected column not in the schema, or an attachment column whose value is
-    not a URL. The row index is named so the client can locate the bad row.
+    Raises 422 on the first offending row: a strict column absent or blank, a column
+    not in the schema, or an attachment value that is not a URL. A non-strict column
+    may be omitted or blank. The row index is named so the client can locate the row.
     """
     declared = set(input_schema)
+    strict_columns = [
+        column for column, spec in input_schema.items() if (spec or {}).get("strict")
+    ]
     for idx, row in enumerate(rows):
-        row_columns = set(row)
-        missing = declared - row_columns
+        missing = [c for c in strict_columns if not (row.get(c) or "").strip()]
         if missing:
             raise HTTPException(
                 status_code=422,
-                detail=f"input.data[{idx}] is missing required column(s): {sorted(missing)}",
+                detail=f"input.data[{idx}] is missing required column(s): {missing}",
             )
-        unexpected = row_columns - declared
+        unexpected = set(row) - declared
         if unexpected:
             raise HTTPException(
                 status_code=422,
@@ -63,18 +91,66 @@ def _validate_rows_against_schema(
                 ),
             )
         for column, spec in input_schema.items():
-            if (spec or {}).get("type") in _ATTACHMENT_TYPES:
-                value = row.get(column, "")
+            column_type = (spec or {}).get("type")
+            value = (row.get(column) or "").strip()
+            if value and column_type in _ATTACHMENT_TYPES:
                 if not value.startswith(_URL_PREFIXES):
                     raise HTTPException(
                         status_code=422,
                         detail=(
                             f"input.data[{idx}] column '{column}' must be a URL for a "
-                            f"'{spec.get('type')}' column."
+                            f"'{column_type}' column."
+                        ),
+                    )
+                # The provider only reports a mistyped column later, as an opaque format error.
+                actual = _url_attachment_type(value)
+                if actual is not None and actual != column_type:
+                    raise HTTPException(
+                        status_code=422,
+                        detail=(
+                            f"input.data[{idx}] column '{column}' is declared "
+                            f"'{column_type}' but its URL points to a '{actual}' file. "
+                            f"Change the column type to '{actual}'."
                         ),
                     )
 
 
+def _rows_from_submission(
+    *,
+    session: Session,
+    submission_doc_id: UUID,
+    organization_id: int,
+    project_id: int,
+) -> BatchInput:
+    """Stream an uploaded submission's rows so they can be validated before dispatch."""
+    submission = get_submission_by_id(
+        session=session,
+        submission_id=submission_doc_id,
+        organization_id=organization_id,
+        project_id=project_id,
+    )
+    try:
+        with open_uploaded_rows(session=session, submission=submission) as stream:
+            rows = list(stream)
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    except Exception as exc:
+        logger.error(
+            "[_rows_from_submission] Could not read submission | submission_id=%s",
+            submission_doc_id,
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=502, detail="Failed to read the submission file from storage."
+        ) from exc
+
+    if not rows:
+        raise HTTPException(
+            status_code=422, detail=f"Submission {submission_doc_id} has no rows."
+        )
+    return BatchInput(data=rows)
+
+
 def _resolve_config(
     *, session: Session, request: AssessmentCreate, project_id: int
 ) -> tuple[AssessmentConfigBlob, str, str]:
@@ -132,32 +208,47 @@ def submit(
     """Submit a BATCH assessment: persist state, seed the pipeline, dispatch the task."""
     from app.celery.tasks.job_execution import run_assessment_api_batch
 
-    method = derive_method(request.input, dataset_id=None)
+    method = derive_method(request.input, submission_id=None)
     if method != AssessmentMethod.BATCH:
         # RESPONSE is handled (stubbed) at the route; submit is BATCH-only for now.
         raise HTTPException(
             status_code=501, detail="Only BATCH input is wired in the assessment API."
         )
 
-    # Delivery is webhook-only, so reject an unusable callback_url up front (HTTPS +
-    # SSRF/private-IP guard) instead of after a full batch run is already paid for.
-    try:
-        validate_callback_url(str(request.callback_url))
-    except ValueError as exc:
-        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    # Reject an unusable callback_url up front (HTTPS + SSRF/private-IP guard) instead
+    # of after a full batch run is already paid for. Absent means the client polls.
+    if request.callback_url is not None:
+        try:
+            validate_callback_url(str(request.callback_url))
+        except ValueError as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
 
     batch_input: BatchInput = request.input
+    submission_id = batch_input.submission_doc_id
+    if submission_id is not None:
+        batch_input = _rows_from_submission(
+            session=session,
+            submission_doc_id=submission_id,
+            organization_id=organization_id,
+            project_id=project_id,
+        )
+
     blob, provider, model = _resolve_config(
         session=session, request=request, project_id=project_id
     )
 
-    # input_schema is mandatory (enforced on the config), so every row must match it:
-    # all declared columns present, no undeclared columns, attachments url-valued.
     input_columns = {
         name: col.model_dump(exclude_none=True)
         for name, col in blob.input_schema.items()
     }
-    _validate_rows_against_schema(batch_input.data, input_columns)
+    if submission_id is not None:
+        batch_input = BatchInput(
+            data=[
+                {key: value for key, value in row.items() if key in input_columns}
+                for row in batch_input.data or []
+            ]
+        )
+    _validate_rows_against_schema(batch_input.data or [], input_columns)
 
     # Validate transposition up front so bad attachment shapes fail as 422, not async.
     try:
@@ -166,13 +257,34 @@ def submit(
         raise HTTPException(status_code=422, detail=str(exc)) from exc
     total_items = len(rows)
 
+    assessment_id = uuid4()
+    # Only inline rows need storing; an uploaded submission is already immutable in
+    # storage, so the run reads it through `submission_id` instead of copying it.
+    submission_url = None
+    if submission_id is None:
+        submission_url = upload_submission_rows(
+            session=session,
+            assessment_id=assessment_id,
+            project_id=project_id,
+            batch_input=batch_input,
+        )
+        if not submission_url:
+            raise HTTPException(
+                status_code=503,
+                detail="Failed to store the assessment submission. Please retry.",
+            )
     assessment = api.create_assessment(
         session=session,
+        assessment_id=assessment_id,
         method=AssessmentMethod.BATCH,
-        input=batch_input.model_dump(mode="json"),
+        input=None,
+        submission_id=submission_id,
+        submission_input=submission_url,
+        experiment_name=request.experiment_name,
         organization_id=organization_id,
         project_id=project_id,
     )
+
     execution = api.create_execution(
         session=session,
         assessment_id=assessment.id,
@@ -194,7 +306,7 @@ def submit(
         "provider": provider,
         "model": model,
         "input_schema": input_columns or None,
-        "callback_url": str(request.callback_url),
+        "callback_url": str(request.callback_url) if request.callback_url else None,
         "request_metadata": request.request_metadata,
     }
     api.save_execution_state(session=session, execution=execution, state=bag)
@@ -204,7 +316,7 @@ def submit(
 
     trace_id = correlation_id.get() or ""
     try:
-        run_assessment_api_batch.delay(
+        dispatched = run_assessment_api_batch.delay(
             execution_id=execution.id,
             organization_id=organization_id,
             project_id=project_id,
@@ -228,9 +340,10 @@ def submit(
         ) from exc
     logger.info(
         "[submit] Dispatched BATCH assessment | assessment_id=%s | execution_id=%s | "
-        "provider=%s | stages=%s | rows=%s",
+        "task_id=%s | provider=%s | stages=%s | rows=%s",
         assessment.id,
         execution.id,
+        dispatched.id,
         provider,
         [s["stage"] for s in pipeline],
         total_items,
diff --git a/backend/app/services/assessment/api/submission_store.py b/backend/app/services/assessment/api/submission_store.py
new file mode 100644
index 000000000..ee651b201
--- /dev/null
+++ b/backend/app/services/assessment/api/submission_store.py
@@ -0,0 +1,143 @@
+"""Object-store round trip for the rows a BATCH assessment runs against."""
+
+import json
+import logging
+from collections.abc import Generator, Iterator
+from contextlib import contextmanager
+from uuid import UUID
+
+from botocore.response import StreamingBody
+from sqlmodel import Session
+
+from app.core.cloud import get_cloud_storage
+from app.core.storage_utils import upload_jsonl_to_object_store
+from app.models.assessment import (
+    Assessment,
+    AssessmentSubmission,
+    BatchInput,
+    Submission,
+)
+from app.services.assessment.validators import (
+    SUBMISSION_FILENAME,
+    assessment_prefix,
+    submission_rows_url,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class SubmissionUnavailableError(Exception):
+    """The stored submission rows could not be read; the caller should retry the task."""
+
+
+def upload_submission_rows(
+    *, session: Session, assessment_id: UUID, project_id: int, batch_input: BatchInput
+) -> str | None:
+    """Store inline submission rows as JSONL. Returns the object-store url, None on failure."""
+    rows = batch_input.data or []
+    url = upload_jsonl_to_object_store(
+        storage=get_cloud_storage(session=session, project_id=project_id),
+        results=rows,
+        filename=SUBMISSION_FILENAME,
+        subdirectory=assessment_prefix(assessment_id),
+    )
+    logger.info(
+        "[upload_submission_rows] Submission %s | assessment_id=%s | rows=%s | url=%s",
+        "stored" if url else "upload failed",
+        assessment_id,
+        len(rows),
+        url,
+    )
+    return url
+
+
+def _rows(body: StreamingBody, url: str) -> Iterator[Submission]:
+    try:
+        for line in body.iter_lines():
+            if line.strip():
+                yield json.loads(line)
+    except json.JSONDecodeError:
+        raise
+    except Exception as exc:
+        raise SubmissionUnavailableError(f"Read of {url} failed: {exc}") from exc
+
+
+@contextmanager
+def _stream(
+    *, session: Session, project_id: int, url: str
+) -> Generator[Iterator[Submission], None, None]:
+    """Stream a JSONL of rows; the storage body closes on exit."""
+    try:
+        storage = get_cloud_storage(session=session, project_id=project_id)
+        body = storage.stream(url)
+    except Exception as exc:
+        raise SubmissionUnavailableError(f"Could not open {url}: {exc}") from exc
+
+    try:
+        yield _rows(body, url)
+    finally:
+        body.close()
+
+
+@contextmanager
+def open_uploaded_rows(
+    *, session: Session, submission: AssessmentSubmission
+) -> Generator[Iterator[Submission], None, None]:
+    """Stream an uploaded submission's rows, parsed once at upload.
+
+    Falls back to parsing the original file for submissions stored before the
+    upload started writing them, so old records keep working.
+    """
+    if not submission.object_store_url:
+        raise ValueError(f"Submission {submission.id} has no object_store_url")
+
+    url = submission_rows_url(submission.object_store_url)
+    # Opened here, not via `_stream`: only a failure to open may fall back, never a
+    # failure mid-iteration, which must surface as the retryable error it is.
+    try:
+        storage = get_cloud_storage(session=session, project_id=submission.project_id)
+        body = storage.stream(url)
+    except Exception:
+        logger.info(
+            "[open_uploaded_rows] No stored rows, parsing the original | submission_id=%s",
+            submission.id,
+        )
+        from app.crud.assessment.batch import load_submission_file_rows
+
+        yield iter(load_submission_file_rows(session=session, submission=submission))
+        return
+
+    try:
+        yield _rows(body, url)
+    finally:
+        body.close()
+
+
+@contextmanager
+def open_submission_rows(
+    *, session: Session, assessment: Assessment
+) -> Generator[Iterator[Submission], None, None]:
+    """Stream the rows an assessment runs against.
+
+    An inline BATCH holds its own copy at ``submission_input``; one submitted by
+    reference reads the uploaded submission directly, since that file never changes.
+    """
+    if assessment.submission_input:
+        with _stream(
+            session=session,
+            project_id=assessment.project_id,
+            url=assessment.submission_input,
+        ) as stream:
+            yield stream
+        return
+
+    submission = (
+        session.get(AssessmentSubmission, assessment.submission_id)
+        if assessment.submission_id
+        else None
+    )
+    if submission is None:
+        raise ValueError(f"Assessment {assessment.id} has no rows to read")
+
+    with open_uploaded_rows(session=session, submission=submission) as stream:
+        yield stream
diff --git a/backend/app/services/assessment/dataset.py b/backend/app/services/assessment/dataset.py
deleted file mode 100644
index 22ebaae70..000000000
--- a/backend/app/services/assessment/dataset.py
+++ /dev/null
@@ -1,319 +0,0 @@
-"""Dataset management service for assessments (CSV + XLSX).
-
-Upload stores files directly to object store as-is (no column validation,
-no format conversion). Row count is computed for metadata.
-"""
-
-import csv
-import io
-import logging
-
-from fastapi import HTTPException
-from sqlmodel import Session
-
-from app.core.cloud import get_cloud_storage
-from app.core.storage_utils import generate_timestamped_filename, upload_to_object_store
-from app.crud.assessment.dataset import create_assessment_dataset
-from app.models.evaluation import EvaluationDataset
-from app.services.evaluations.validators import sanitize_dataset_name
-
-logger = logging.getLogger(__name__)
-
-try:
-    from openpyxl.utils.exceptions import InvalidFileException
-except Exception:  # pragma: no cover - openpyxl is expected in runtime deps
-
-    class InvalidFileException(Exception):
-        pass
-
-
-_MIME_TYPES = {
-    ".csv": "text/csv",
-    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-}
-
-
-def _upload_file_to_object_store(
-    session: Session,
-    project_id: int,
-    file_content: bytes,
-    file_ext: str,
-    dataset_name: str,
-) -> str | None:
-    """Upload the raw file to object store, preserving original format."""
-    extension = file_ext.lstrip(".")
-    filename = generate_timestamped_filename(dataset_name, extension=extension)
-    content_type = _MIME_TYPES.get(file_ext, "application/octet-stream")
-
-    try:
-        storage = get_cloud_storage(session=session, project_id=project_id)
-        return upload_to_object_store(
-            storage=storage,
-            content=file_content,
-            filename=filename,
-            subdirectory="datasets",
-            content_type=content_type,
-        )
-    except Exception as e:
-        logger.warning(
-            f"[_upload_file_to_object_store] Failed to upload | {e}",
-            exc_info=True,
-        )
-        return None
-
-
-def _count_csv_rows(content: bytes) -> int:
-    """Count data rows in a CSV file (excluding header)."""
-    try:
-        for encoding in ("utf-8-sig", "utf-8", "latin-1"):
-            try:
-                text = content.decode(encoding)
-                break
-            except (UnicodeDecodeError, ValueError):
-                continue
-        else:
-            text = content.decode("utf-8", errors="replace")
-
-        reader = csv.reader(io.StringIO(text))
-        next(reader, None)
-        return sum(1 for row in reader if any(cell.strip() for cell in row))
-    except Exception as e:
-        logger.warning(f"[_count_csv_rows] Failed to count rows | {e}")
-        return 0
-
-
-def _count_excel_rows(content: bytes) -> int:
-    """Count data rows in an Excel file (excluding header)."""
-    wb = None
-    try:
-        import openpyxl
-
-        wb = openpyxl.load_workbook(io.BytesIO(content), read_only=True, data_only=True)
-        ws = wb.active
-        if ws is None:
-            return 0
-
-        rows_iter = ws.iter_rows(values_only=True)
-        header = next(rows_iter, None)
-        if header is None:
-            return 0
-
-        return sum(
-            1 for row in rows_iter if row and any(cell is not None for cell in row)
-        )
-    except InvalidFileException as e:
-        logger.warning("[_count_excel_rows] Invalid XLSX file content: %s", e)
-        raise
-    except Exception as e:
-        logger.warning(
-            "[_count_excel_rows] Failed to count rows | %s", e, exc_info=True
-        )
-        raise ValueError("Failed to parse XLSX file") from e
-    finally:
-        if wb is not None:
-            wb.close()
-
-
-def _count_rows(content: bytes, file_ext: str) -> int:
-    """Count data rows in a file (CSV or XLSX), excluding the header."""
-    if file_ext == ".xls":
-        raise ValueError(
-            "Legacy Excel format (.xls) is not supported. Please upload .xlsx or .csv."
-        )
-    if file_ext == ".xlsx":
-        return _count_excel_rows(content)
-    return _count_csv_rows(content)
-
-
-def _stringify(value: object) -> str:
-    if value is None:
-        return ""
-    return str(value)
-
-
-def _preview_csv(content: bytes, limit: int) -> tuple[list[str], list[list[str]]]:
-    for encoding in ("utf-8-sig", "utf-8", "latin-1"):
-        try:
-            text = content.decode(encoding)
-            break
-        except (UnicodeDecodeError, ValueError):
-            continue
-    else:
-        text = content.decode("utf-8", errors="replace")
-
-    reader = csv.reader(io.StringIO(text))
-    header = next(reader, None) or []
-    headers = [_stringify(cell) for cell in header]
-
-    rows: list[list[str]] = []
-    for row in reader:
-        if not any(cell.strip() for cell in row):
-            continue
-        rows.append([_stringify(cell) for cell in row])
-        if len(rows) >= limit:
-            break
-    return headers, rows
-
-
-def _preview_excel(content: bytes, limit: int) -> tuple[list[str], list[list[str]]]:
-    import openpyxl
-
-    wb = None
-    try:
-        wb = openpyxl.load_workbook(io.BytesIO(content), read_only=True, data_only=True)
-        ws = wb.active
-        if ws is None:
-            return [], []
-
-        rows_iter = ws.iter_rows(values_only=True)
-        header = next(rows_iter, None) or ()
-        headers = [_stringify(cell) for cell in header]
-
-        rows: list[list[str]] = []
-        for row in rows_iter:
-            if not row or not any(cell is not None for cell in row):
-                continue
-            rows.append([_stringify(cell) for cell in row])
-            if len(rows) >= limit:
-                break
-        return headers, rows
-    finally:
-        if wb is not None:
-            wb.close()
-
-
-def preview_dataset(
-    session: Session,
-    dataset: EvaluationDataset,
-    project_id: int,
-    limit: int,
-) -> tuple[list[str], list[list[str]]]:
-    """Return the first `limit` data rows (plus header) of a dataset file."""
-    if not dataset.object_store_url:
-        raise HTTPException(
-            status_code=404, detail="Dataset has no underlying file to preview."
-        )
-
-    raw_ext = (dataset.dataset_metadata or {}).get("file_extension")
-    file_ext = raw_ext.strip().lower() if isinstance(raw_ext, str) else None
-    if file_ext == ".xls":
-        raise HTTPException(
-            status_code=422,
-            detail="Legacy Excel format (.xls) is not supported.",
-        )
-    if file_ext not in {".csv", ".xlsx"}:
-        raise HTTPException(
-            status_code=422,
-            detail="Unsupported or missing file extension.",
-        )
-
-    storage = get_cloud_storage(session=session, project_id=project_id)
-    try:
-        content = storage.get(dataset.object_store_url)
-    except Exception as e:
-        logger.warning(
-            f"[preview_dataset] Failed to fetch file | dataset_id={dataset.id} | {e}",
-            exc_info=True,
-        )
-        raise HTTPException(
-            status_code=502, detail="Failed to fetch dataset file from storage."
-        ) from e
-
-    try:
-        if file_ext == ".xlsx":
-            return _preview_excel(content, limit)
-        return _preview_csv(content, limit)
-    except InvalidFileException as e:
-        raise HTTPException(status_code=422, detail="Invalid XLSX file content.") from e
-    except Exception as e:
-        logger.warning(
-            f"[preview_dataset] Failed to parse file | dataset_id={dataset.id} | {e}",
-            exc_info=True,
-        )
-        raise HTTPException(
-            status_code=422, detail="Unable to parse dataset file for preview."
-        ) from e
-
-
-def upload_dataset(
-    session: Session,
-    file_content: bytes,
-    file_ext: str,
-    dataset_name: str,
-    description: str | None,
-    organization_id: int,
-    project_id: int,
-) -> EvaluationDataset:
-    """Upload a dataset file directly to object store and record metadata."""
-    original_name = dataset_name
-    try:
-        dataset_name = sanitize_dataset_name(dataset_name)
-    except ValueError as e:
-        raise HTTPException(status_code=422, detail=f"Invalid dataset name: {str(e)}")
-
-    if original_name != dataset_name:
-        logger.info(
-            f"[upload_dataset] Dataset name sanitized | '{original_name}' -> '{dataset_name}'"
-        )
-
-    try:
-        row_count = _count_rows(file_content, file_ext)
-    except InvalidFileException as e:
-        raise HTTPException(
-            status_code=422,
-            detail="Invalid XLSX file content. Please upload a valid .xlsx file.",
-        ) from e
-    except ValueError as e:
-        raise HTTPException(status_code=422, detail=str(e)) from e
-    except Exception as e:
-        raise HTTPException(
-            status_code=422,
-            detail="Unable to parse dataset file. Please upload a valid CSV or XLSX file.",
-        ) from e
-
-    logger.info(
-        f"[upload_dataset] Uploading dataset | dataset={dataset_name} | "
-        f"file_type={file_ext} | rows={row_count} | "
-        f"org_id={organization_id} | project_id={project_id}"
-    )
-
-    object_store_url = _upload_file_to_object_store(
-        session=session,
-        project_id=project_id,
-        file_content=file_content,
-        file_ext=file_ext,
-        dataset_name=dataset_name,
-    )
-    if not object_store_url:
-        logger.error(
-            f"[upload_dataset] Object store upload failed | dataset={dataset_name} | "
-            f"org_id={organization_id} | project_id={project_id}"
-        )
-        raise HTTPException(
-            status_code=500,
-            detail="Failed to upload dataset file. Please try again.",
-        )
-
-    metadata = {
-        "file_extension": file_ext,
-        "file_size_bytes": len(file_content),
-        "total_items_count": row_count,
-    }
-
-    dataset = create_assessment_dataset(
-        session=session,
-        name=dataset_name,
-        description=description,
-        dataset_metadata=metadata,
-        object_store_url=object_store_url,
-        langfuse_dataset_id=None,
-        organization_id=organization_id,
-        project_id=project_id,
-    )
-
-    logger.info(
-        f"[upload_dataset] Created dataset record | "
-        f"id={dataset.id} | name={dataset_name} | rows={row_count}"
-    )
-
-    return dataset
diff --git a/backend/app/services/assessment/mappers.py b/backend/app/services/assessment/mappers.py
deleted file mode 100644
index 5623222de..000000000
--- a/backend/app/services/assessment/mappers.py
+++ /dev/null
@@ -1,296 +0,0 @@
-import logging
-import unicodedata
-
-from google.genai import _transformers as genai_transformers
-from sqlmodel import Session
-
-from app.crud.model_config import is_reasoning_model
-
-logger = logging.getLogger(__name__)
-
-
-def normalize_llm_text(text: str) -> str:
-    if not isinstance(text, str) or not text:
-        return text
-
-    text = text.replace("\\n", "\n")
-    text = text.replace("\\t", "\t")
-    text = text.replace("\\r", "\r")
-    text = text.replace('\\"', '"')
-    text = text.replace("\\\\", "\\")
-
-    text = unicodedata.normalize("NFC", text)
-
-    return text
-
-
-def _ensure_openai_strict_schema(schema: dict) -> dict:
-    """Recursively add additionalProperties: false for OpenAI strict JSON schema validation."""
-    normalized = dict(schema)
-
-    if normalized.get("type") == "object":
-        normalized["additionalProperties"] = False
-
-    if "properties" in normalized:
-        normalized["properties"] = {
-            key: _ensure_openai_strict_schema(value)
-            if isinstance(value, dict)
-            else value
-            for key, value in normalized["properties"].items()
-        }
-
-    items = normalized.get("items")
-    if isinstance(items, dict):
-        normalized["items"] = _ensure_openai_strict_schema(items)
-
-    return normalized
-
-
-def _strip_additional_properties(schema: dict) -> dict:
-    """Recursively strip additionalProperties — unsupported by Google GenAI."""
-    normalized_schema = dict(schema)
-    normalized_schema.pop("additionalProperties", None)
-
-    if "properties" in normalized_schema:
-        normalized_schema["properties"] = {
-            property_name: _strip_additional_properties(property_schema)
-            if isinstance(property_schema, dict)
-            else property_schema
-            for property_name, property_schema in normalized_schema[
-                "properties"
-            ].items()
-        }
-
-    if "items" in normalized_schema and isinstance(normalized_schema["items"], dict):
-        normalized_schema["items"] = _strip_additional_properties(
-            normalized_schema["items"]
-        )
-
-    return normalized_schema
-
-
-def _convert_json_schema_to_google(schema: dict) -> dict:
-    """Convert a JSON Schema dict to Google GenAI's OpenAPI-style schema.
-
-    Strips unsupported fields, then normalizes the schema through the Gemini SDK
-    so enum/type values match Gemini's expected OpenAPI-flavored shape.
-    """
-    normalized_schema = _strip_additional_properties(schema)
-    converted = genai_transformers.t_schema(None, normalized_schema)
-    google_schema = (
-        converted.model_dump(mode="json", exclude_none=True)
-        if converted is not None
-        else normalized_schema
-    )
-
-    if "properties" in google_schema and "propertyOrdering" not in google_schema:
-        google_schema["propertyOrdering"] = list(
-            normalized_schema.get("required", [])
-        ) or list(google_schema["properties"].keys())
-
-    return google_schema
-
-
-def map_kaapi_to_openai_params(
-    session: Session, kaapi_params: dict
-) -> tuple[dict, list[str]]:
-    """Map Kaapi-abstracted parameters to OpenAI batch assessment API parameters.
-
-    Extends the base LLM mapper with structured output schema support via
-    ``output_schema`` → ``text.format.json_schema`` (strict mode).
-
-    Returns:
-        Tuple of (OpenAI API params dict, list of warning strings)
-    """
-    openai_params: dict = {}
-    warnings: list[str] = []
-
-    model = kaapi_params.get("model")
-    reasoning = kaapi_params.get("reasoning")
-    effort = kaapi_params.get("effort") or reasoning
-    summary = kaapi_params.get("summary")
-    temperature = kaapi_params.get("temperature")
-    top_p = kaapi_params.get("top_p")
-
-    instructions = normalize_llm_text(kaapi_params.get("instructions"))
-    knowledge_base_ids = kaapi_params.get("knowledge_base_ids")
-    max_num_results = kaapi_params.get("max_num_results")
-    response_format = kaapi_params.get("response_format")
-    output_schema = kaapi_params.get("output_schema")
-
-    support_reasoning = bool(model) and is_reasoning_model(
-        session=session,
-        provider="openai",
-        model_name=model,
-    )
-
-    # max_output_tokens is intentionally omitted for batch assessment —
-    # Indic feedback responses can be long and a stored token limit would truncate them.
-
-    if support_reasoning:
-        reasoning_payload: dict[str, object] = {}
-        if effort is not None:
-            reasoning_payload["effort"] = effort
-        if summary is not None:
-            reasoning_payload["summary"] = None if summary == "null" else summary
-        if reasoning_payload:
-            openai_params["reasoning"] = reasoning_payload
-        if temperature is not None:
-            warnings.append(
-                "Parameter 'temperature' was suppressed because the selected model "
-                "supports reasoning, and temperature is ignored when reasoning is enabled."
-            )
-        if top_p is not None:
-            warnings.append(
-                "Parameter 'top_p' was suppressed because the selected model "
-                "supports reasoning, and top_p is ignored when reasoning is enabled."
-            )
-    else:
-        if effort is not None or summary is not None:
-            warnings.append(
-                "Parameters 'effort'/'summary' were suppressed because the selected model "
-                "does not support reasoning."
-            )
-        if temperature is not None:
-            openai_params["temperature"] = temperature
-        if top_p is not None:
-            openai_params["top_p"] = top_p
-
-    if model:
-        openai_params["model"] = model
-
-    if instructions:
-        openai_params["instructions"] = instructions
-
-    if output_schema is not None:
-        openai_params["text"] = {
-            "format": {
-                "type": "json_schema",
-                "name": "output",
-                "strict": True,
-                "schema": _ensure_openai_strict_schema(output_schema),
-            }
-        }
-    elif response_format and response_format != "text":
-        openai_params["text"] = {"format": {"type": response_format}}
-
-    if knowledge_base_ids:
-        openai_params["tools"] = [
-            {
-                "type": "file_search",
-                "vector_store_ids": knowledge_base_ids,
-                "max_num_results": max_num_results or 20,
-            }
-        ]
-
-    return openai_params, warnings
-
-
-def map_kaapi_to_anthropic_params(kaapi_params: dict) -> tuple[dict, list[str]]:
-    """Map Kaapi-abstracted parameters to Anthropic Messages API parameters.
-
-    Returns:
-        Tuple of (Anthropic API params dict, list of warning strings)
-    """
-    anthropic_params: dict = {}
-    warnings: list[str] = []
-
-    model = kaapi_params.get("model")
-    if not model:
-        return {}, ["Missing required 'model' parameter"]
-
-    anthropic_params["model"] = model
-
-    instructions = normalize_llm_text(kaapi_params.get("instructions"))
-    if instructions:
-        anthropic_params["system"] = instructions
-
-    temperature = kaapi_params.get("temperature")
-    top_p = kaapi_params.get("top_p")
-    if temperature is not None and top_p is not None:
-        warnings.append(
-            "Parameter 'top_p' was suppressed because Anthropic does not accept "
-            "both 'temperature' and 'top_p' on the same request."
-        )
-        top_p = None
-    if temperature is not None:
-        anthropic_params["temperature"] = temperature
-    if top_p is not None:
-        anthropic_params["top_p"] = top_p
-
-    max_output_tokens = kaapi_params.get("max_output_tokens")
-    if max_output_tokens is not None:
-        anthropic_params["max_tokens"] = max_output_tokens
-
-    output_schema = kaapi_params.get("output_schema")
-    if output_schema is not None:
-        anthropic_params["output_config"] = {
-            "format": {
-                "type": "json_schema",
-                "schema": _ensure_openai_strict_schema(output_schema),
-            }
-        }
-
-    if kaapi_params.get("effort") or kaapi_params.get("reasoning"):
-        warnings.append(
-            "Parameters 'effort'/'reasoning' are not mapped for Anthropic "
-            "batch assessment and were ignored."
-        )
-
-    if kaapi_params.get("knowledge_base_ids"):
-        warnings.append(
-            "Parameter 'knowledge_base_ids' is not supported by Anthropic and was ignored."
-        )
-
-    return anthropic_params, warnings
-
-
-def map_kaapi_to_google_params(kaapi_params: dict) -> tuple[dict, list[str]]:
-    """Map Kaapi-abstracted parameters to Google AI (Gemini) API parameters.
-
-    Returns:
-        Tuple of (Google AI params dict, list of warning strings)
-    """
-    google_params: dict = {}
-    warnings: list[str] = []
-
-    model = kaapi_params.get("model")
-    if not model:
-        return {}, ["Missing required 'model' parameter"]
-
-    google_params["model"] = model
-
-    instructions = normalize_llm_text(kaapi_params.get("instructions"))
-    if instructions:
-        google_params["instructions"] = instructions
-
-    temperature = kaapi_params.get("temperature")
-    if temperature is not None:
-        google_params["temperature"] = temperature
-
-    top_p = kaapi_params.get("top_p")
-    if top_p is not None:
-        google_params["top_p"] = top_p
-
-    max_output_tokens = kaapi_params.get("max_output_tokens")
-    if max_output_tokens is not None:
-        google_params["max_output_tokens"] = max_output_tokens
-
-    thinking_level = kaapi_params.get("thinking_level")
-    if thinking_level:
-        google_params["thinking_config"] = {"thinking_level": thinking_level}
-
-    reasoning = kaapi_params.get("reasoning")
-    if reasoning:
-        google_params["reasoning"] = reasoning
-
-    output_schema = kaapi_params.get("output_schema")
-    if output_schema is not None:
-        google_params["output_schema"] = _convert_json_schema_to_google(output_schema)
-
-    if kaapi_params.get("knowledge_base_ids"):
-        warnings.append(
-            "Parameter 'knowledge_base_ids' is not supported by Google AI and was ignored."
-        )
-
-    return google_params, warnings
diff --git a/backend/app/services/assessment/prefilter/request_builder.py b/backend/app/services/assessment/prefilter/request_builder.py
index 3e438ffed..1b7078c9b 100644
--- a/backend/app/services/assessment/prefilter/request_builder.py
+++ b/backend/app/services/assessment/prefilter/request_builder.py
@@ -2,7 +2,7 @@
 
 from typing import Any
 
-from app.services.assessment.mappers import _ensure_openai_strict_schema
+from app.services.llm.mappers import _ensure_openai_strict_schema
 from app.services.assessment.prefilter import constants
 
 
diff --git a/backend/app/services/assessment/service.py b/backend/app/services/assessment/service.py
index 888a949bb..6a7724d82 100644
--- a/backend/app/services/assessment/service.py
+++ b/backend/app/services/assessment/service.py
@@ -2,6 +2,7 @@
 
 import logging
 from typing import Any
+from uuid import UUID
 
 from asgi_correlation_id import correlation_id
 from fastapi import HTTPException
@@ -10,7 +11,7 @@
 from app.crud.assessment import (
     create_assessment,
     create_assessment_run,
-    get_assessment_dataset_by_id,
+    get_submission_by_id,
     get_assessment_runs_for_assessment,
     recompute_assessment_status,
 )
@@ -51,7 +52,7 @@
 def _build_retry_request(
     *,
     experiment_name: str,
-    dataset_id: int,
+    submission_id: UUID,
     input_binding: dict[str, Any] | None,
     runs: list[AssessmentRun],
 ) -> AssessmentRunCreate:
@@ -87,7 +88,7 @@ def _build_retry_request(
 
     return AssessmentRunCreate(
         experiment_name=experiment_name,
-        dataset_id=dataset_id,
+        submission_id=submission_id,
         input_binding=binding,
         configs=configs,
         post_processing_config=input_binding.get("post_processing_config"),
@@ -108,16 +109,16 @@ def start_assessment(
     from app.celery.tasks.job_execution import run_assessment_pipeline
 
     logger.info(
-        "[start_assessment] Starting | experiment=%s | dataset_id=%s | configs=%s | org_id=%s",
+        "[start_assessment] Starting | experiment=%s | submission_id=%s | configs=%s | org_id=%s",
         request.experiment_name,
-        request.dataset_id,
+        request.submission_id,
         len(request.configs),
         organization_id,
     )
 
-    dataset = get_assessment_dataset_by_id(
+    submission = get_submission_by_id(
         session=session,
-        dataset_id=request.dataset_id,
+        submission_id=request.submission_id,
         organization_id=organization_id,
         project_id=project_id,
     )
@@ -177,7 +178,7 @@ def start_assessment(
     assessment = create_assessment(
         session=session,
         experiment_name=request.experiment_name,
-        dataset_id=request.dataset_id,
+        submission_id=request.submission_id,
         organization_id=organization_id,
         project_id=project_id,
         input_binding=assessment_input,
@@ -220,8 +221,8 @@ def start_assessment(
     return AssessmentRunResponse(
         assessment_id=assessment.id,
         experiment_name=request.experiment_name,
-        dataset_id=request.dataset_id,
-        dataset_name=dataset.name,
+        submission_id=request.submission_id,
+        submission_name=submission.name,
         num_configs=len(runs),
         runs=[
             AssessmentRunSummary(
@@ -248,7 +249,7 @@ def retry_assessment(
     )
     request = _build_retry_request(
         experiment_name=assessment.experiment_name,
-        dataset_id=assessment.dataset_id,
+        submission_id=assessment.submission_id,
         input_binding=assessment.input,
         runs=runs,
     )
@@ -277,7 +278,7 @@ def retry_assessment_run(
         )
     request = _build_retry_request(
         experiment_name=parent.experiment_name,
-        dataset_id=parent.dataset_id,
+        submission_id=parent.submission_id,
         input_binding=parent.input,
         runs=[run],
     )
@@ -319,9 +320,9 @@ def resume_assessment_run(
             status_code=404,
             detail=f"Parent assessment {run.assessment_id} not found",
         )
-    dataset = get_assessment_dataset_by_id(
+    submission = get_submission_by_id(
         session=session,
-        dataset_id=parent.dataset_id,
+        submission_id=parent.submission_id,
         organization_id=organization_id,
         project_id=project_id,
     )
@@ -349,8 +350,8 @@ def resume_assessment_run(
     return AssessmentRunResponse(
         assessment_id=parent.id,
         experiment_name=parent.experiment_name,
-        dataset_id=parent.dataset_id,
-        dataset_name=dataset.name if dataset else None,
+        submission_id=parent.submission_id,
+        submission_name=submission.name if submission else None,
         num_configs=1,
         runs=[
             AssessmentRunSummary(
diff --git a/backend/app/services/assessment/stages.py b/backend/app/services/assessment/stages.py
index 0676ce05e..5b7ac9fe4 100644
--- a/backend/app/services/assessment/stages.py
+++ b/backend/app/services/assessment/stages.py
@@ -63,13 +63,24 @@ def build_pipeline(assessment_input: dict[str, Any]) -> dict[str, Any]:
     return {"stages": stages}
 
 
-def ordered_stages(pipeline: dict[str, Any] | None) -> list[str]:
-    """The stage names in execution order."""
-    return [s["stage"] for s in (pipeline or {}).get("stages", [])]
+def ordered_stages(pipeline: dict[str, Any] | list[dict[str, str]] | None) -> list[str]:
+    """The stage names in execution order, for the legacy RUN pipeline shape only.
+
+    The BATCH API path writes a bare list into the same JSONB column, so name the bad
+    shape here instead of failing with an AttributeError inside the caller.
+    """
+    if pipeline is None:
+        return []
+    if not isinstance(pipeline, dict):
+        raise ValueError(
+            f"[ordered_stages] Expected the RUN pipeline mapping "
+            f"{{'stages': [...]}}, got {type(pipeline).__name__}"
+        )
+    return [s["stage"] for s in pipeline.get("stages", [])]
 
 
 def next_stage(
-    pipeline: dict[str, Any] | None, current: str | None = None
+    pipeline: dict[str, Any] | list[dict[str, str]] | None, current: str | None = None
 ) -> str | None:
     """First stage when ``current`` is None, else the stage after it (None if last)."""
     stages = ordered_stages(pipeline)
diff --git a/backend/app/services/assessment/submission.py b/backend/app/services/assessment/submission.py
new file mode 100644
index 000000000..bbc03b9aa
--- /dev/null
+++ b/backend/app/services/assessment/submission.py
@@ -0,0 +1,303 @@
+"""Uploaded submission files for assessments (CSV + XLSX).
+
+Stored as-is: no column validation, no format conversion. The row count is computed at
+upload so nothing has to re-read the file to learn how many rows it holds.
+"""
+
+import csv
+import io
+import logging
+from uuid import UUID, uuid4
+
+from fastapi import HTTPException
+from sqlmodel import Session
+
+from app.core.cloud import get_cloud_storage
+from app.core.storage_utils import upload_jsonl_to_object_store, upload_to_object_store
+from app.crud.assessment.submission import create_submission, get_submission_by_name
+from app.models.assessment import AssessmentSubmission
+from app.services.assessment.validators import (
+    SUBMISSION_FILENAME,
+    clean_sheet,
+    file_extension_of,
+    parse_rows,
+    submission_prefix,
+)
+from app.services.evaluations.validators import sanitize_dataset_name
+
+logger = logging.getLogger(__name__)
+
+try:
+    from openpyxl.utils.exceptions import InvalidFileException
+except Exception:  # pragma: no cover - openpyxl is expected in runtime deps
+
+    class InvalidFileException(Exception):
+        pass
+
+
+_MIME_TYPES = {
+    ".csv": "text/csv",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+}
+
+
+def _upload_file_to_object_store(
+    session: Session,
+    project_id: int,
+    file_content: bytes,
+    file_ext: str,
+    submission_name: str,
+    submission_id: UUID,
+) -> str | None:
+    """Upload the raw file as-is under a key no other submission can share."""
+    filename = f"{submission_name}.{file_ext.lstrip('.')}"
+    content_type = _MIME_TYPES.get(file_ext, "application/octet-stream")
+
+    try:
+        storage = get_cloud_storage(session=session, project_id=project_id)
+        return upload_to_object_store(
+            storage=storage,
+            content=file_content,
+            filename=filename,
+            subdirectory=submission_prefix(submission_id),
+            content_type=content_type,
+        )
+    except Exception as e:
+        logger.warning(
+            f"[_upload_file_to_object_store] Failed to upload | {e}",
+            exc_info=True,
+        )
+        return None
+
+
+def _store_parsed_rows(
+    session: Session,
+    project_id: int,
+    submission_id: UUID,
+    rows: list[dict[str, str]],
+) -> None:
+    """Keep the parsed rows beside the file so no run has to parse it again.
+
+    Best effort: a failure here only costs a later reader one re-parse.
+    """
+    try:
+        url = upload_jsonl_to_object_store(
+            storage=get_cloud_storage(session=session, project_id=project_id),
+            results=rows,
+            filename=SUBMISSION_FILENAME,
+            subdirectory=submission_prefix(submission_id),
+        )
+    except Exception as exc:
+        logger.warning(
+            "[_store_parsed_rows] Rows not stored, runs will parse the file | "
+            "submission_id=%s | error=%s",
+            submission_id,
+            exc,
+        )
+        return
+
+    if not url:
+        logger.warning(
+            "[_store_parsed_rows] Rows not stored, runs will parse the file | "
+            "submission_id=%s",
+            submission_id,
+        )
+
+
+def _stringify(value: object) -> str:
+    if value is None:
+        return ""
+    return str(value)
+
+
+def _preview_csv(content: bytes, limit: int) -> tuple[list[str], list[list[str]]]:
+    for encoding in ("utf-8-sig", "utf-8", "latin-1"):
+        try:
+            text = content.decode(encoding)
+            break
+        except (UnicodeDecodeError, ValueError):
+            continue
+    else:
+        text = content.decode("utf-8", errors="replace")
+
+    reader = csv.reader(io.StringIO(text))
+    header = next(reader, None) or []
+    headers = [_stringify(cell) for cell in header]
+
+    rows: list[list[str]] = []
+    for row in reader:
+        if not any(cell.strip() for cell in row):
+            continue
+        rows.append([_stringify(cell) for cell in row])
+        if len(rows) >= limit:
+            break
+    return headers, rows
+
+
+def _preview_excel(content: bytes, limit: int) -> tuple[list[str], list[list[str]]]:
+    import openpyxl
+
+    wb = None
+    try:
+        wb = openpyxl.load_workbook(io.BytesIO(content), read_only=True, data_only=True)
+        ws = wb.active
+        if ws is None:
+            return [], []
+
+        rows_iter = ws.iter_rows(values_only=True)
+        headers, rows = clean_sheet(next(rows_iter, None) or (), rows_iter)
+        return headers, rows[:limit]
+    finally:
+        if wb is not None:
+            wb.close()
+
+
+def preview_submission(
+    session: Session,
+    submission: AssessmentSubmission,
+    project_id: int,
+    limit: int,
+) -> tuple[list[str], list[list[str]]]:
+    """Return the first `limit` data rows (plus header) of a submission file."""
+    if not submission.object_store_url:
+        raise HTTPException(
+            status_code=404, detail="Submission has no underlying file to preview."
+        )
+
+    file_ext = file_extension_of(submission.object_store_url)
+    if file_ext == ".xls":
+        raise HTTPException(
+            status_code=422,
+            detail="Legacy Excel format (.xls) is not supported.",
+        )
+    if file_ext not in {".csv", ".xlsx"}:
+        raise HTTPException(
+            status_code=422,
+            detail="Unsupported or missing file extension.",
+        )
+
+    storage = get_cloud_storage(session=session, project_id=project_id)
+    try:
+        content = storage.get(submission.object_store_url)
+    except Exception as e:
+        logger.warning(
+            f"[preview_submission] Failed to fetch file | submission_id={submission.id} | {e}",
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=502, detail="Failed to fetch the submission file from storage."
+        ) from e
+
+    try:
+        if file_ext == ".xlsx":
+            return _preview_excel(content, limit)
+        return _preview_csv(content, limit)
+    except InvalidFileException as e:
+        raise HTTPException(status_code=422, detail="Invalid XLSX file content.") from e
+    except Exception as e:
+        logger.warning(
+            f"[preview_submission] Failed to parse file | submission_id={submission.id} | {e}",
+            exc_info=True,
+        )
+        raise HTTPException(
+            status_code=422, detail="Unable to parse the submission file for preview."
+        ) from e
+
+
+def upload_submission(
+    session: Session,
+    file_content: bytes,
+    file_ext: str,
+    submission_name: str,
+    description: str | None,
+    organization_id: int,
+    project_id: int,
+) -> AssessmentSubmission:
+    """Store an uploaded submission file and record it."""
+    original_name = submission_name
+    try:
+        submission_name = sanitize_dataset_name(submission_name)
+    except ValueError as e:
+        raise HTTPException(
+            status_code=422, detail=f"Invalid submission name: {str(e)}"
+        )
+
+    if original_name != submission_name:
+        logger.info(
+            f"[upload_submission] Name sanitized | '{original_name}' -> '{submission_name}'"
+        )
+
+    if get_submission_by_name(
+        session=session,
+        name=submission_name,
+        organization_id=organization_id,
+        project_id=project_id,
+    ):
+        raise HTTPException(
+            status_code=409,
+            detail=(
+                f"Submission with name '{submission_name}' already exists in this "
+                "organization and project."
+            ),
+        )
+
+    try:
+        rows = parse_rows(file_content, file_ext)
+    except InvalidFileException as e:
+        raise HTTPException(
+            status_code=422,
+            detail="Invalid XLSX file content. Please upload a valid .xlsx file.",
+        ) from e
+    except ValueError as e:
+        raise HTTPException(status_code=422, detail=str(e)) from e
+    except Exception as e:
+        raise HTTPException(
+            status_code=422,
+            detail="Unable to parse the file. Please upload a valid CSV or XLSX file.",
+        ) from e
+
+    row_count = len(rows)
+    logger.info(
+        f"[upload_submission] Uploading | name={submission_name} | "
+        f"file_type={file_ext} | rows={row_count} | "
+        f"org_id={organization_id} | project_id={project_id}"
+    )
+
+    submission_id = uuid4()
+    object_store_url = _upload_file_to_object_store(
+        session=session,
+        project_id=project_id,
+        file_content=file_content,
+        file_ext=file_ext,
+        submission_name=submission_name,
+        submission_id=submission_id,
+    )
+    if not object_store_url:
+        logger.error(
+            f"[upload_submission] Object store upload failed | name={submission_name} | "
+            f"org_id={organization_id} | project_id={project_id}"
+        )
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to upload the submission file. Please try again.",
+        )
+
+    _store_parsed_rows(session, project_id, submission_id, rows)
+
+    submission = create_submission(
+        session=session,
+        submission_id=submission_id,
+        name=submission_name,
+        description=description,
+        object_store_url=object_store_url,
+        total_items=row_count,
+        organization_id=organization_id,
+        project_id=project_id,
+    )
+
+    logger.info(
+        f"[upload_submission] Created record | "
+        f"id={submission.id} | name={submission_name} | rows={row_count}"
+    )
+
+    return submission
diff --git a/backend/app/services/assessment/tasks.py b/backend/app/services/assessment/tasks.py
index 33e066385..732046a65 100644
--- a/backend/app/services/assessment/tasks.py
+++ b/backend/app/services/assessment/tasks.py
@@ -9,11 +9,11 @@
 from app.celery.tasks.job_execution import run_assessment_pipeline
 from app.core.db import engine
 from app.crud.assessment import (
-    get_assessment_dataset_by_id,
+    get_submission_by_id,
     recompute_assessment_status,
     update_assessment_run_status,
 )
-from app.crud.assessment.batch import _load_dataset_rows, submit_assessment_batch
+from app.crud.assessment.batch import load_submission_file_rows, submit_assessment_batch
 from app.crud.assessment.core import _read_exec, _write_exec
 from app.crud.assessment.processing import parse_assessment_output
 from app.crud.evaluations.core import resolve_evaluation_config
@@ -108,13 +108,13 @@ def _dispatch(run_id: int, organization_id: int, project_id: int) -> None:
 def _resolve_run_context(
     session: Session, run: AssessmentRun, organization_id: int, project_id: int
 ):
-    """Load the assessment, dataset, and resolved config; ``error`` set on failure."""
+    """Load the assessment, submission, and resolved config; ``error`` set on failure."""
     assessment = session.get(Assessment, run.assessment_id)
     if assessment is None:
         return None, None, None, "Parent assessment not found."
-    dataset = get_assessment_dataset_by_id(
+    submission = get_submission_by_id(
         session=session,
-        dataset_id=assessment.dataset_id,
+        submission_id=assessment.submission_id,
         organization_id=organization_id,
         project_id=project_id,
     )
@@ -126,8 +126,8 @@ def _resolve_run_context(
         tag=ConfigTag.ASSESSMENT,
     )
     if error or config_blob is None:
-        return assessment, dataset, None, f"Config resolution failed: {error}"
-    return assessment, dataset, config_blob, None
+        return assessment, submission, None, f"Config resolution failed: {error}"
+    return assessment, submission, config_blob, None
 
 
 def _accepted_indices(
@@ -201,7 +201,7 @@ def _orchestrate(run_id: int, organization_id: int, project_id: int) -> None:
 def _submit_stage(
     session: Session, run: AssessmentRun, organization_id: int, project_id: int
 ) -> None:
-    assessment, dataset, config_blob, error = _resolve_run_context(
+    assessment, submission, config_blob, error = _resolve_run_context(
         session, run, organization_id, project_id
     )
     if error:
@@ -212,7 +212,7 @@ def _submit_stage(
         recompute_assessment_status(session=session, assessment_id=run.assessment_id)
         return
 
-    all_rows = _load_dataset_rows(session, dataset)
+    all_rows = load_submission_file_rows(session=session, submission=submission)
     if not all_rows:
         _write_exec(run, stage_status=StageStatus.FAILED)
         update_assessment_run_status(
@@ -269,7 +269,7 @@ def _submit_stage(
             session=session,
             run=run,
             assessment=assessment,
-            dataset=dataset,
+            submission=submission,
             config_blob=config_blob,
             assessment_input=assessment_input,
             organization_id=organization_id,
diff --git a/backend/app/services/assessment/utils/export.py b/backend/app/services/assessment/utils/export.py
index 64110380c..7302e4785 100644
--- a/backend/app/services/assessment/utils/export.py
+++ b/backend/app/services/assessment/utils/export.py
@@ -22,10 +22,10 @@
     AssessmentExportRow,
     AssessmentRun,
     AssessmentStatus,
+    AssessmentSubmission,
     Stage,
 )
 from app.models.batch_job import BatchJob
-from app.models.evaluation import EvaluationDataset
 from app.services.assessment.prefilter.duplicate_detection import (
     parse_duplicate_detection_results,
 )
@@ -43,15 +43,15 @@
 logger = logging.getLogger(__name__)
 
 
-def _load_dataset_rows(
+def _load_submission_rows(
     session: Session,
-    dataset: EvaluationDataset,
+    submission: AssessmentSubmission,
 ) -> list[dict[str, str]]:
     # Imported lazily: app.crud.assessment.batch pulls this module via
     # app.services.assessment.utils, so a top-level import would be circular.
-    from app.crud.assessment.batch import _load_dataset_rows as load_dataset_rows
+    from app.crud.assessment.batch import load_submission_file_rows
 
-    return load_dataset_rows(session, dataset)
+    return load_submission_file_rows(session=session, submission=submission)
 
 
 def _stage_batch_job(
@@ -113,7 +113,7 @@ def _expand_input_columns(
 ) -> tuple[list[dict[str, Any]], list[str]]:
     """Expand ``input_data`` dict into separate input columns.
 
-    Uses the original column names from the dataset (no prefix).
+    Uses the original column names from the submission (no prefix).
 
     Returns:
         (expanded_rows with input_data replaced by individual columns,
@@ -144,7 +144,7 @@ def _expand_input_columns(
     collisions = {key: value for key, value in key_map.items() if key != value}
     if collisions:
         logger.warning(
-            "[_expand_input_columns] Input dataset columns conflict with reserved "
+            "[_expand_input_columns] Input submission columns conflict with reserved "
             "export fields and were namespaced: %s",
             collisions,
         )
@@ -450,27 +450,27 @@ def _load_parsed_results_for_run(
     return None
 
 
-def _load_dataset_rows_for_run(
+def _load_submission_rows_for_run(
     session: Session,
     run: AssessmentRun,
     assessment: Assessment,
 ) -> list[dict[str, str]]:
-    """Load original dataset rows for input-output correlation.
+    """Load the original submission rows for input-output correlation.
 
-    Returns an empty list if the dataset is not available.
+    Returns an empty list if the submission is not available.
     """
     try:
-        dataset = session.get(EvaluationDataset, assessment.dataset_id)
-        if not dataset or not dataset.object_store_url:
+        submission = session.get(AssessmentSubmission, assessment.submission_id)
+        if not submission or not submission.object_store_url:
             logger.warning(
-                "[_load_dataset_rows_for_run] Dataset not available for run id=%s",
+                "[_load_submission_rows_for_run] Submission not available for run id=%s",
                 run.id,
             )
             return []
-        return _load_dataset_rows(session, dataset)
+        return _load_submission_rows(session, submission)
     except Exception as exc:
         logger.warning(
-            "[_load_dataset_rows_for_run] Failed to load dataset for run id=%s: %s",
+            "[_load_submission_rows_for_run] Failed to load submission for run id=%s: %s",
             run.id,
             exc,
         )
@@ -594,13 +594,13 @@ def load_export_rows_for_run(
         )
         return []
 
-    dataset_rows = _load_dataset_rows_for_run(session, run, assessment)
+    submission_rows = _load_submission_rows_for_run(session, run, assessment)
 
     prefilter_by_row_id = _load_prefilter_results(session, run, assessment)
     l2_by_row_id = _load_l2_results_for_run(session, run, assessment)
     has_prefilter = bool(prefilter_by_row_id)
 
-    if dataset_rows:
+    if submission_rows:
         rows = [
             _build_export_row(
                 run=run,
@@ -611,7 +611,7 @@ def load_export_rows_for_run(
                 l2_item=l2_by_row_id.get(f"row_{row_idx}"),
                 has_prefilter=has_prefilter,
             )
-            for row_idx, input_data in enumerate(dataset_rows)
+            for row_idx, input_data in enumerate(submission_rows)
         ]
         return rows
 
diff --git a/backend/app/services/assessment/validators.py b/backend/app/services/assessment/validators.py
index 3d3f992f2..e546f4d2a 100644
--- a/backend/app/services/assessment/validators.py
+++ b/backend/app/services/assessment/validators.py
@@ -1,15 +1,27 @@
-"""Validation utilities for assessment dataset file uploads (CSV + XLSX).
+"""Uploaded submission files: upload validation, object-store keys, parsing to rows,
+and prompt-text normalisation.
 
-Only validates file type and size — no column requirements.
+Every layer imports this, so it stays dependency-free: no DB, no object store, no
+other app module.
 """
 
+import csv
+import io
 import logging
+import unicodedata
+from collections.abc import Iterable
 from pathlib import Path
+from uuid import UUID
 
+import openpyxl
 from fastapi import HTTPException, UploadFile
+from openpyxl.utils.exceptions import InvalidFileException
 
 logger = logging.getLogger(__name__)
 
+
+# ─── UPLOAD VALIDATION ───────────────────────────────────────────────────────
+
 MAX_FILE_SIZE = 10 * 1024 * 1024  # 10 MB
 
 ALLOWED_EXTENSIONS = {".csv", ".xlsx"}
@@ -69,3 +81,163 @@ async def validate_dataset_file(file: UploadFile) -> tuple[bytes, str]:
 
     content = await file.read()
     return content, file_ext
+
+
+# ─── STORAGE KEY CONSTANTS ───────────────────────────────────────────────────
+
+SUBMISSION_FILENAME = "submission.jsonl"
+ERRORS_FILENAME = "errors.jsonl"
+
+ASSESSMENTS_PREFIX = "assessment"
+SUBMISSIONS_PREFIX = "assessment/submissions"
+
+
+def file_extension_of(object_store_url: str) -> str:
+    """Format of a stored submission, read off its key (no column holds it)."""
+    return Path(object_store_url).suffix.lower()
+
+
+def assessment_prefix(assessment_id: UUID) -> str:
+    """Holds every file one assessment produces."""
+    return f"{ASSESSMENTS_PREFIX}/{assessment_id}"
+
+
+def stage_batch_prefix(assessment_id: UUID, batch_job_id: int) -> str:
+    """Holds one stage's provider dump."""
+    return f"{assessment_prefix(assessment_id)}/batch-{batch_job_id}"
+
+
+def submission_prefix(submission_id: UUID) -> str:
+    """Holds an uploaded file and the rows parsed from it."""
+    return f"{SUBMISSIONS_PREFIX}/{submission_id}"
+
+
+def submission_rows_url(object_store_url: str) -> str:
+    """The parsed rows sitting beside an uploaded file.
+
+    String surgery, not ``Path``: a posix path collapses the ``s3://`` double slash.
+    """
+    return f"{object_store_url.rsplit('/', 1)[0]}/{SUBMISSION_FILENAME}"
+
+
+# ─── PROMPT TEXT ─────────────────────────────────────────────────────────────
+
+
+def normalize_llm_text(text: str) -> str:
+    """Unescape a prompt stored with literal ``\\n``/``\\t`` and NFC-normalise it.
+
+    Applies to stored templates and instructions only. Submission-row values are
+    passed through verbatim, so a cell like ``C:\\new`` is not rewritten.
+    """
+    if not isinstance(text, str) or not text:
+        return text
+
+    text = text.replace("\\n", "\n")
+    text = text.replace("\\t", "\t")
+    text = text.replace("\\r", "\r")
+    text = text.replace('\\"', '"')
+    text = text.replace("\\\\", "\\")
+
+    return unicodedata.normalize("NFC", text)
+
+
+# ─── SHEET PARSING ───────────────────────────────────────────────────────────
+
+
+def _cell(value: object) -> str:
+    return "" if value is None else str(value).strip()
+
+
+def clean_sheet(
+    header: Iterable[object], rows: Iterable[Iterable[object]]
+) -> tuple[list[str], list[list[str]]]:
+    """Drop blank rows, then columns with no header or no values; cells come back stripped.
+
+    Sheets pad with formatted-but-empty cells, so 1000 rows x 17 columns with 100 x 10
+    filled comes back as exactly 100 x 10. A row left empty by the column drop goes too.
+    """
+    headers = [_cell(name) for name in header]
+    width = len(headers)
+
+    filled: list[list[str]] = []
+    for row in rows:
+        cells = [_cell(value) for value in row][:width]
+        cells += [""] * (width - len(cells))
+        if any(cells):
+            filled.append(cells)
+
+    keep = [
+        idx
+        for idx, name in enumerate(headers)
+        if name and any(row[idx] for row in filled)
+    ]
+    rows = [[row[idx] for idx in keep] for row in filled]
+    return [headers[idx] for idx in keep], [row for row in rows if any(row)]
+
+
+def _named_cells(row: dict[str | None, str | None]) -> dict[str, str]:
+    """Keep only columns the sheet actually names.
+
+    A spreadsheet's trailing blank columns are padding, not data — naming them
+    ``col_<n>`` would surface them as undeclared columns and 422 the run.
+    """
+    return {
+        str(key).strip(): value or ""
+        for key, value in row.items()
+        if key is not None and str(key).strip()
+    }
+
+
+def parse_csv_rows(content: bytes) -> list[dict[str, str]]:
+    """Parse CSV content into list of row dicts."""
+    for encoding in ("utf-8-sig", "utf-8", "latin-1"):
+        try:
+            text = content.decode(encoding)
+            break
+        except (UnicodeDecodeError, ValueError):
+            continue
+    else:
+        text = content.decode("utf-8", errors="replace")
+
+    rows = (_named_cells(row) for row in csv.DictReader(io.StringIO(text)))
+    return [row for row in rows if any(value.strip() for value in row.values())]
+
+
+def parse_excel_rows(content: bytes) -> list[dict[str, str]]:
+    """Parse Excel content into row dicts; blank rows and empty columns are dropped."""
+    wb = None
+    try:
+        wb = openpyxl.load_workbook(io.BytesIO(content), read_only=True, data_only=True)
+        ws = wb.active
+        if ws is None:
+            return []
+
+        rows_iter = ws.iter_rows(values_only=True)
+        header = next(rows_iter, None)
+        if header is None:
+            return []
+
+        headers, rows = clean_sheet(header, rows_iter)
+        return [dict(zip(headers, row, strict=True)) for row in rows]
+    except InvalidFileException as e:
+        logger.warning("[parse_excel_rows] Invalid XLSX file content: %s", e)
+        raise
+    except Exception as e:
+        logger.warning(
+            "[parse_excel_rows] Failed to parse XLSX rows | %s", e, exc_info=True
+        )
+        raise ValueError("Failed to parse XLSX submission rows") from e
+    finally:
+        if wb is not None:
+            wb.close()
+
+
+def parse_rows(content: bytes, file_ext: str) -> list[dict[str, str]]:
+    """Parse an uploaded submission file's bytes by the format its key names."""
+    if file_ext == ".xls":
+        raise ValueError(
+            "Legacy Excel format (.xls) is not supported. Please upload .xlsx or .csv."
+        )
+    if file_ext == ".xlsx":
+        return parse_excel_rows(content)
+    return parse_csv_rows(content)
diff --git a/backend/app/services/llm/mappers.py b/backend/app/services/llm/mappers.py
index f2e3d7d05..88c26cade 100644
--- a/backend/app/services/llm/mappers.py
+++ b/backend/app/services/llm/mappers.py
@@ -27,6 +27,8 @@
 # stays for native/stored configs whose params are persisted as plain JSON.
 KaapiParamsInput = TextLLMParams | STTLLMParams | TTSLLMParams | dict[str, Any]
 
+ANTHROPIC_DEFAULT_TEMPERATURE = 1.0
+
 SARVAM_DEFAULTS_BY_TYPE = {
     "stt": DEFAULT_SARVAM_STT_MODEL,
     "tts": DEFAULT_SARVAM_TTS_MODEL,
@@ -127,6 +129,8 @@ def _convert_json_schema_to_google(schema: dict[str, Any]) -> dict[str, Any]:
         else normalized_schema
     )
 
+    # Vertex rejects a payload carrying both spellings (the SDK dump emits snake_case).
+    google_schema.pop("property_ordering", None)
     if "properties" in google_schema and "propertyOrdering" not in google_schema:
         google_schema["propertyOrdering"] = list(
             normalized_schema.get("required", [])
@@ -156,6 +160,8 @@ def map_kaapi_to_openai_params(
         - reasoning → legacy alias for effort, used only when effort is absent
         - summary → reasoning.summary (if reasoning supported by model else suppressed)
         - temperature → temperature (if reasoning not supported by model else suppressed)
+        - top_p → top_p (if reasoning not supported by model else suppressed)
+        - output_schema → text.format.json_schema in strict mode
 
     Returns:
         Tuple of:
@@ -171,11 +177,11 @@ def map_kaapi_to_openai_params(
     effort = params.get("effort")
     summary = params.get("summary")
     temperature = params.get("temperature")
+    top_p = params.get("top_p")
     instructions = params.get("instructions")
     knowledge_base_ids = params.get("knowledge_base_ids")
     max_num_results = params.get("max_num_results")
-    # NOTE: Json Schema can only be used for the assessment pipeline
-    json_schema = params.get("json_schema")
+    output_schema = params.get("output_schema")
 
     support_reasoning = bool(model) and is_reasoning_model(
         session=session, provider="openai", model_name=model
@@ -200,6 +206,12 @@ def map_kaapi_to_openai_params(
                 "Parameter 'temperature' was suppressed because the selected model "
                 "supports reasoning, and temperature is ignored when reasoning is enabled."
             )
+
+        if top_p is not None:
+            warnings.append(
+                "Parameter 'top_p' was suppressed because the selected model "
+                "supports reasoning, and top_p is ignored when reasoning is enabled."
+            )
     else:
         if effort_value is not None:
             warnings.append(
@@ -210,6 +222,9 @@ def map_kaapi_to_openai_params(
         if temperature is not None:
             openai_params["temperature"] = temperature
 
+        if top_p is not None:
+            openai_params["top_p"] = top_p
+
     openai_params["model"] = model or DEFAULT_TEXT_MODELS["openai"]
 
     if instructions:
@@ -224,13 +239,13 @@ def map_kaapi_to_openai_params(
             }
         ]
 
-    if json_schema:
+    if output_schema:
         openai_params["text"] = {
             "format": {
                 "type": "json_schema",
                 "name": "output",
                 "strict": True,
-                "schema": _ensure_openai_strict_schema(json_schema),
+                "schema": _ensure_openai_strict_schema(output_schema),
             }
         }
 
@@ -238,7 +253,7 @@ def map_kaapi_to_openai_params(
 
 
 def map_kaapi_to_google_params(
-    kaapi_params: KaapiParamsInput, completion_type: str
+    kaapi_params: KaapiParamsInput, completion_type: str = CompletionType.TEXT
 ) -> tuple[dict[str, Any], list[str]]:
     """Map Kaapi-abstracted parameters to Google AI (Gemini) API parameters.
 
@@ -253,6 +268,9 @@ def map_kaapi_to_google_params(
         - model → model
         - instructions → instructions (for STT prompts, if available)
         - temperature -> temperature parameter (0-2)
+        - top_p / max_output_tokens → same name (text only)
+        - thinking_level → thinking_config.thinking_level (text only)
+        - output_schema → output_schema, converted to Gemini's shape (text only)
         - knowledge_base_ids → FileSearch tool store names (text only)
 
     Returns:
@@ -284,6 +302,18 @@ def map_kaapi_to_google_params(
         if temperature is not None:
             google_params["temperature"] = temperature
 
+        top_p = params.get("top_p")
+        if top_p is not None:
+            google_params["top_p"] = top_p
+
+        max_output_tokens = params.get("max_output_tokens")
+        if max_output_tokens is not None:
+            google_params["max_output_tokens"] = max_output_tokens
+
+        thinking_level = params.get("thinking_level")
+        if thinking_level:
+            google_params["thinking_config"] = {"thinking_level": thinking_level}
+
         reasoning = params.get("reasoning")
         if reasoning:
             google_params["reasoning"] = reasoning
@@ -298,10 +328,11 @@ def map_kaapi_to_google_params(
                 "FileSearch tool and was ignored."
             )
 
-        # NOTE: Json Schema can only be used for the assessment pipeline
-        json_schema = params.get("json_schema")
-        if json_schema:
-            google_params["json_schema"] = _convert_json_schema_to_google(json_schema)
+        output_schema = params.get("output_schema")
+        if output_schema:
+            google_params["output_schema"] = _convert_json_schema_to_google(
+                output_schema
+            )
 
     elif completion_type == CompletionType.TTS:
         # TTS mode - voice, language, response_format
@@ -572,57 +603,90 @@ def map_kaapi_to_anthropic_params(
     """Map Kaapi-abstracted parameters to Anthropic Messages API parameters.
 
     Supported Mapping:
-        - model → model
+        - model → model (falls back to DEFAULT_TEXT_MODELS)
         - instructions → system
-        - temperature → temperature
-        - top_p → top_p
+        - temperature / top_p → always dropped; a non-default value also warns
         - max_output_tokens → max_tokens (Anthropic requires this;
           provider defaults if absent)
+        - output_schema → output_config.format, effort → output_config.effort
+        - thinking → thinking, forwarded as-is
 
     Unsupported Kaapi params:
         - knowledge_base_ids / max_num_results: Anthropic has no native
           vector-store / file_search tool, dropped with warning.
-        - reasoning / effort / summary: Messages API does not expose a
-          reasoning-effort knob, dropped with warning.
+        - thinking_level: Google-only, dropped with warning.
+        - summary: no reasoning summaries on the Messages API, dropped with warning.
     """
+    # Anthropic's output_config.effort ladder; Kaapi's "none"/"minimal" have no equivalent.
+    effort_levels = ("low", "medium", "high", "xhigh", "max")
     params = kaapi_params_as_dict(kaapi_params)
     anthropic_params: dict[str, Any] = {}
     warnings: list[str] = []
 
-    model = params.get("model")
+    model = params.get("model") or DEFAULT_TEXT_MODELS["anthropic"]
+    anthropic_params["model"] = model
+
     instructions = params.get("instructions")
+    if instructions:
+        anthropic_params["system"] = instructions
+
+    # The Messages API returns 400 for a non-default temperature/top_p on every
+    # model Kaapi serves, so sampling never reaches the provider.
     temperature = params.get("temperature")
     top_p = params.get("top_p")
+    if top_p is not None or (
+        temperature is not None and temperature != ANTHROPIC_DEFAULT_TEMPERATURE
+    ):
+        warnings.append(
+            "Parameters 'temperature'/'top_p' were suppressed because the Anthropic "
+            "Messages API rejects non-default sampling values."
+        )
+
     max_output_tokens = params.get("max_output_tokens")
-    knowledge_base_ids = params.get("knowledge_base_ids")
-    reasoning = params.get("reasoning")
-    effort = params.get("effort")
-    summary = params.get("summary")
+    if max_output_tokens is not None:
+        anthropic_params["max_tokens"] = max_output_tokens
 
-    anthropic_params["model"] = model or DEFAULT_TEXT_MODELS["anthropic"]
+    # Structured output and reasoning effort share one container on the Messages API.
+    output_config: dict[str, Any] = {}
+    output_schema = params.get("output_schema")
+    if output_schema:
+        output_config["format"] = {
+            "type": "json_schema",
+            "schema": _ensure_openai_strict_schema(output_schema),
+        }
 
-    if instructions:
-        anthropic_params["system"] = instructions
+    effort = params.get("effort") or params.get("reasoning")
+    if effort in effort_levels:
+        output_config["effort"] = effort
+    elif effort is not None:
+        warnings.append(
+            f"Parameter 'effort' value '{effort}' is not an Anthropic effort level "
+            f"({', '.join(effort_levels)}) and was ignored."
+        )
 
-    if temperature is not None:
-        anthropic_params["temperature"] = temperature
+    if output_config:
+        anthropic_params["output_config"] = output_config
 
-    if top_p is not None:
-        anthropic_params["top_p"] = top_p
+    if params.get("summary") is not None:
+        warnings.append(
+            "Parameter 'summary' was ignored because the Anthropic Messages API "
+            "does not return reasoning summaries."
+        )
 
-    if max_output_tokens is not None:
-        anthropic_params["max_tokens"] = max_output_tokens
+    thinking = params.get("thinking")
+    if thinking is not None:
+        anthropic_params["thinking"] = thinking
 
-    if knowledge_base_ids:
+    if params.get("thinking_level") is not None:
         warnings.append(
-            "Parameter 'knowledge_base_ids' was ignored because Anthropic has no "
-            "native vector-store/file_search tool. Inline document content blocks instead."
+            "Parameter 'thinking_level' is Google-only; Anthropic reads the 'thinking' "
+            "container instead, so it was ignored."
         )
 
-    if reasoning is not None or effort is not None or summary is not None:
+    if params.get("knowledge_base_ids"):
         warnings.append(
-            "Parameters 'reasoning'/'effort'/'summary' were ignored because the "
-            "Anthropic Messages API does not expose a reasoning-effort knob."
+            "Parameter 'knowledge_base_ids' was ignored because Anthropic has no "
+            "native vector-store/file_search tool. Inline document content blocks instead."
         )
 
     return anthropic_params, warnings
diff --git a/backend/app/tests/assessment/test_api_batch.py b/backend/app/tests/assessment/test_api_batch.py
index 208077b92..1b65eb9be 100644
--- a/backend/app/tests/assessment/test_api_batch.py
+++ b/backend/app/tests/assessment/test_api_batch.py
@@ -6,6 +6,8 @@
 """
 
 import json
+from contextlib import contextmanager
+from uuid import uuid4
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -68,6 +70,27 @@
 TOPIC_CRITERIA = "Is this on topic?"
 
 
+_SEEDED_ROWS: dict = {}
+
+
+@pytest.fixture(autouse=True)
+def _serve_seeded_submission_rows():
+    """Submission rows live in object storage; serve the seeded ones instead."""
+
+    @contextmanager
+    def _open(*, assessment, **_):
+        yield iter(_SEEDED_ROWS[assessment.id])
+
+    with patch(
+        "app.services.assessment.api.submission_store.open_submission_rows", _open
+    ):
+        yield
+
+
+def _register_rows(assessment, data) -> None:
+    _SEEDED_ROWS[assessment.id] = data
+
+
 def _blob_dict(
     *,
     topic_relevance: bool | None = None,
@@ -524,14 +547,14 @@ def _make_batch_job(db, *, org_id, project_id, **kwargs) -> BatchJob:
 
 
 def _seed_assessment(db, *, org_id, project_id, config_id, bag, data, status=None):
-    batch_input = BatchInput(data=data)
     assessment = api.create_assessment(
         session=db,
         method=AssessmentMethod.BATCH,
-        input=batch_input.model_dump(mode="json"),
+        input=None,
         organization_id=org_id,
         project_id=project_id,
     )
+    _register_rows(assessment, data)
     execution = api.create_execution(
         session=db,
         assessment_id=assessment.id,
@@ -813,7 +836,7 @@ def test_processing_when_status_pending(self, db) -> None:
             "app.services.assessment.api.batch.poll_batch_status",
             return_value={},
         ):
-            outcome, results = _poll_outcome(db, self._provider(), job)
+            outcome, results = _poll_outcome(db, self._provider(), job, uuid4())
         assert outcome == "processing"
         assert results is None
 
@@ -829,7 +852,7 @@ def test_failed_status(self, db) -> None:
             "app.services.assessment.api.batch.poll_batch_status",
             return_value={},
         ):
-            outcome, _ = _poll_outcome(db, self._provider(), job)
+            outcome, _ = _poll_outcome(db, self._provider(), job, uuid4())
         assert outcome == "failed"
 
     def test_success_but_all_failed_counts(self, db) -> None:
@@ -845,7 +868,7 @@ def test_success_but_all_failed_counts(self, db) -> None:
             "app.services.assessment.api.batch.poll_batch_status",
             return_value={"request_counts": {"completed": 0, "failed": 3}},
         ):
-            outcome, _ = _poll_outcome(db, self._provider(), job)
+            outcome, _ = _poll_outcome(db, self._provider(), job, uuid4())
         assert outcome == "failed"
 
     def test_success_output_not_ready(self, db) -> None:
@@ -860,7 +883,7 @@ def test_success_output_not_ready(self, db) -> None:
             "app.services.assessment.api.batch.poll_batch_status",
             return_value={"request_counts": {"completed": 1}},
         ):
-            outcome, _ = _poll_outcome(db, self._provider(), job)
+            outcome, _ = _poll_outcome(db, self._provider(), job, uuid4())
         assert outcome == "processing"
 
 
@@ -1073,10 +1096,11 @@ def test_all_gated_out_skips_submit(self, db) -> None:
         assessment = api.create_assessment(
             session=db,
             method=AssessmentMethod.BATCH,
-            input=batch_input.model_dump(mode="json"),
+            input=None,
             organization_id=auth.organization_id,
             project_id=auth.project_id,
         )
+        _register_rows(assessment, batch_input.data)
         execution = api.create_execution(
             session=db,
             assessment_id=assessment.id,
@@ -1087,8 +1111,8 @@ def test_all_gated_out_skips_submit(self, db) -> None:
         ok = _submit_stage(
             session=db,
             execution=execution,
+            assessment=assessment,
             blob=blob,
-            batch_input=batch_input,
             bag=bag,
             stage=ApiStage.ASSESSMENT.value,
             organization_id=auth.organization_id,
@@ -1752,10 +1776,11 @@ def _seed(self, db, auth, *, data, bag):
         assessment = api.create_assessment(
             session=db,
             method=AssessmentMethod.BATCH,
-            input=batch_input.model_dump(mode="json"),
+            input=None,
             organization_id=auth.organization_id,
             project_id=auth.project_id,
         )
+        _register_rows(assessment, batch_input.data)
         execution = api.create_execution(
             session=db,
             assessment_id=assessment.id,
diff --git a/backend/app/tests/assessment/test_api_crud.py b/backend/app/tests/assessment/test_api_crud.py
index e41e76eee..1ad7502e9 100644
--- a/backend/app/tests/assessment/test_api_crud.py
+++ b/backend/app/tests/assessment/test_api_crud.py
@@ -162,6 +162,63 @@ def test_list_executions_orders_by_id(self, db) -> None:
         assert [e.id for e in listed] == [first.id, second.id]
 
 
+class TestSetResultFiles:
+    def _assessment(self, db, auth):
+        return api.create_assessment(
+            session=db,
+            method=AssessmentMethod.BATCH,
+            input={"data": [{"a": "1"}]},
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+
+    def test_second_kind_does_not_evict_the_first(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment = self._assessment(db, auth)
+
+        api.set_result_files(
+            session=db,
+            assessment=assessment,
+            files={"results": {"url": "s3://b/out.jsonl", "count": 998}},
+        )
+        api.set_result_files(
+            session=db,
+            assessment=assessment,
+            files={"errors": {"url": "s3://b/errors.jsonl", "count": 389}},
+        )
+
+        db.refresh(assessment)
+        assert assessment.result_files == {
+            "results": {"url": "s3://b/out.jsonl", "count": 998},
+            "errors": {"url": "s3://b/errors.jsonl", "count": 389},
+        }
+
+    def test_rerecording_a_kind_replaces_only_that_kind(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment = self._assessment(db, auth)
+
+        api.set_result_files(
+            session=db,
+            assessment=assessment,
+            files={
+                "results": {"url": "s3://b/stale.jsonl", "count": 1},
+                "errors": {"url": "s3://b/errors.jsonl", "count": 389},
+            },
+        )
+        api.set_result_files(
+            session=db,
+            assessment=assessment,
+            files={"results": {"url": "s3://b/fresh.jsonl", "count": 998}},
+        )
+
+        db.refresh(assessment)
+        assert assessment.result_files["results"] == {
+            "url": "s3://b/fresh.jsonl",
+            "count": 998,
+        }
+        assert assessment.result_files["errors"]["count"] == 389
+
+
 class TestDeriveMethod:
     def test_response_input(self) -> None:
         assert derive_method(ResponseInput(), None) == AssessmentMethod.RESPONSE
@@ -257,6 +314,16 @@ def test_user_set_temperature_kept(self) -> None:
         blob = AssessmentConfigBlob.model_validate(_assessment_params(temperature=0.4))
         assert blob.assessment.params["temperature"] == 0.4
 
+    def test_thinking_params_reach_the_stored_params(self) -> None:
+        # validate_params replaces params with the model dump, so a param the model
+        # does not declare is silently dropped before any mapper can see it.
+        thinking = {"type": "enabled", "budget_tokens": 4096}
+        blob = AssessmentConfigBlob.model_validate(
+            _assessment_params(thinking=thinking, thinking_level="high")
+        )
+        assert blob.assessment.params["thinking"] == thinking
+        assert blob.assessment.params["thinking_level"] == "high"
+
 
 class TestInputSchemaValidators:
     def test_missing_input_schema_rejected(self) -> None:
diff --git a/backend/app/tests/assessment/test_api_read.py b/backend/app/tests/assessment/test_api_read.py
new file mode 100644
index 000000000..079126277
--- /dev/null
+++ b/backend/app/tests/assessment/test_api_read.py
@@ -0,0 +1,282 @@
+"""Tests for the API-client read endpoints: the assessment list and the poll detail."""
+
+from contextlib import contextmanager
+from types import SimpleNamespace
+from unittest.mock import patch
+from uuid import uuid4
+
+import pytest
+from fastapi import HTTPException
+
+from app.crud.assessment import api
+from app.models.assessment import (
+    AssessmentMethod,
+    AssessmentStatus,
+    BatchRunState,
+)
+from app.models.config.assessment_blob import AssessmentConfigBlob
+from app.models.config.config import ConfigTag
+from app.services.assessment.api.results import build_detail, build_summary
+from app.tests.utils.auth import get_user_test_auth_context
+from app.tests.utils.test_data import create_test_config
+from app.tests.utils.utils import random_lower_string
+
+_STORE = "app.services.assessment.api.results.get_cloud_storage"
+_ROWS = "app.services.assessment.api.submission_store.open_submission_rows"
+
+
+def _serving(rows):
+    """Stand-in for open_submission_rows that streams the given rows."""
+
+    @contextmanager
+    def _open(**_):
+        yield iter(rows)
+
+    return _open
+
+
+def _config(db, project_id):
+    blob = AssessmentConfigBlob.model_validate(
+        {
+            "input_schema": {"a": {"type": "text"}},
+            "assessment": {
+                "provider": "openai",
+                "type": "text",
+                "params": {"model": "gpt-4o", "submission": "Assess {a}"},
+            },
+        }
+    )
+    return create_test_config(
+        db,
+        project_id=project_id,
+        name=f"assess-{random_lower_string()}",
+        config_blob=blob,
+        tag=ConfigTag.ASSESSMENT,
+    )
+
+
+def _bag(total: int, **overrides) -> BatchRunState:
+    bag: BatchRunState = {
+        "pipeline": [{"stage": "assessment", "kind": "ASSESSMENT"}],
+        "stage": "assessment",
+        "stage_status": "PROCESSING",
+        "stage_batches": {},
+        "stage_output_urls": {},
+        "verdicts": {},
+        "counters": {},
+        "gate_passed": [True] * total,
+        "provider": "openai",
+        "model": "gpt-4o",
+        "input_schema": {"a": {"type": "text"}},
+        "callback_url": None,
+        "request_metadata": None,
+    }
+    bag.update(overrides)  # type: ignore[typeddict-item]
+    return bag
+
+
+def _seed(db, auth, *, total=2, config=None, name="run", bag=None):
+    assessment = api.create_assessment(
+        session=db,
+        method=AssessmentMethod.BATCH,
+        input=None,
+        experiment_name=name,
+        organization_id=auth.organization_id,
+        project_id=auth.project_id,
+    )
+    execution = api.create_execution(
+        session=db,
+        assessment_id=assessment.id,
+        config_id=(config or _config(db, auth.project_id)).id,
+        config_version=1,
+        total_items=total,
+    )
+    api.save_execution_state(session=db, execution=execution, state=bag or _bag(total))
+    return assessment, execution
+
+
+class TestListFilters:
+    def test_lists_newest_first(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        _seed(db, auth, name="older")
+        _seed(db, auth, name="newer")
+
+        rows = api.list_assessments_with_execution(
+            session=db,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+        names = [a.experiment_name for a, _, _ in rows]
+        assert names.index("newer") < names.index("older")
+
+    def test_config_and_version_narrow_the_list(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        config = _config(db, auth.project_id)
+        other = _config(db, auth.project_id)
+        _seed(db, auth, config=config, name="wanted")
+        _seed(db, auth, config=other, name="other-config")
+
+        rows = api.list_assessments_with_execution(
+            session=db,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+            config_id=config.id,
+            config_version=1,
+        )
+        assert [a.experiment_name for a, _, _ in rows] == ["wanted"]
+
+        missed = api.list_assessments_with_execution(
+            session=db,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+            config_id=config.id,
+            config_version=2,
+        )
+        assert missed == []
+
+    def test_scoped_to_the_project(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        _seed(db, auth)
+
+        assert (
+            api.list_assessments_with_execution(
+                session=db,
+                organization_id=auth.organization_id,
+                project_id=auth.project_id + 1,
+            )
+            == []
+        )
+
+
+class TestSummary:
+    def test_reads_stage_off_the_bag_without_touching_storage(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth, total=3)
+
+        with patch(_STORE) as storage:
+            summary = build_summary(assessment, execution)
+
+        storage.assert_not_called()
+        assert summary.total_items == 3
+        assert summary.stage == "assessment"
+        assert summary.stage_status == "PROCESSING"
+        assert summary.config is not None
+
+    def test_survives_a_missing_execution(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment = api.create_assessment(
+            session=db,
+            method=AssessmentMethod.BATCH,
+            input=None,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+        summary = build_summary(assessment, None)
+        assert summary.total_items == 0
+        assert summary.config is None
+
+
+class TestDetail:
+    def test_mid_run_returns_placeholders_with_input_attached(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, _ = _seed(db, auth, total=2)
+
+        with patch(_ROWS, _serving([{"a": "one"}, {"a": "two"}])):
+            detail = build_detail(session=db, assessment=assessment, include_input=True)
+
+        assert detail.status == AssessmentStatus.PENDING
+        assert detail.total_items == 2
+        assert [row.row_index for row in detail.items] == [0, 1]
+        assert detail.items[0].input == {"a": "one"}
+        assert detail.items[0].output.assessment is None
+
+    def test_unreadable_submission_degrades_to_null_input(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, _ = _seed(db, auth, total=1)
+
+        from app.services.assessment.api.submission_store import (
+            SubmissionUnavailableError,
+        )
+
+        with patch(_ROWS, side_effect=SubmissionUnavailableError("s3 down")):
+            detail = build_detail(session=db, assessment=assessment, include_input=True)
+
+        assert detail.items[0].input is None
+        assert detail.total_items == 1
+
+    def test_gated_rows_carry_their_verdict(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        bag = _bag(
+            2,
+            gate_passed=[False, True],
+            verdicts={
+                "topic_relevance": {
+                    "0": {"verdict": False, "reasoning": "off topic"},
+                    "1": {"verdict": True, "reasoning": "on topic"},
+                }
+            },
+        )
+        assessment, _ = _seed(db, auth, total=2, bag=bag)
+
+        with patch(_ROWS, _serving([{"a": "1"}, {"a": "2"}])):
+            detail = build_detail(session=db, assessment=assessment)
+
+        gated = detail.items[0]
+        assert gated.output.assessment is None
+        assert gated.output.pre_filter is not None
+        assert gated.output.pre_filter.topic_relevance.verdict is False
+        assert detail.counts.filtered == 1
+
+    def test_input_shorter_than_total_items(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, _ = _seed(db, auth, total=3)
+
+        with patch(_ROWS, _serving([{"a": "only one"}])):
+            detail = build_detail(session=db, assessment=assessment, include_input=True)
+
+        assert detail.items[0].input == {"a": "only one"}
+        assert detail.items[1].input is None
+        assert detail.items[2].input is None
+
+
+class TestDetailRouteGuards:
+    """The route wraps `auth_context.organization_` / `.project_`, unlike the crud."""
+
+    @staticmethod
+    def _route_context(auth):
+        return SimpleNamespace(
+            organization_=SimpleNamespace(id=auth.organization_id),
+            project_=SimpleNamespace(id=auth.project_id),
+        )
+
+    def test_run_assessment_is_rejected(self, db) -> None:
+        from app.api.routes.assessment.api import get_assessment_detail
+
+        auth = get_user_test_auth_context(db)
+        assessment = api.create_assessment(
+            session=db,
+            method=AssessmentMethod.RUN,
+            input={"prompt": "p"},
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+
+        with pytest.raises(HTTPException) as exc:
+            get_assessment_detail(
+                assessment_id=assessment.id,
+                session=db,
+                auth_context=self._route_context(auth),
+            )
+        assert exc.value.status_code == 422
+
+    def test_unknown_assessment_is_404(self, db) -> None:
+        from app.api.routes.assessment.api import get_assessment_detail
+
+        auth = get_user_test_auth_context(db)
+        with pytest.raises(HTTPException) as exc:
+            get_assessment_detail(
+                assessment_id=uuid4(),
+                session=db,
+                auth_context=self._route_context(auth),
+            )
+        assert exc.value.status_code == 404
diff --git a/backend/app/tests/assessment/test_api_submission.py b/backend/app/tests/assessment/test_api_submission.py
index 2ddbb5854..f35c496f5 100644
--- a/backend/app/tests/assessment/test_api_submission.py
+++ b/backend/app/tests/assessment/test_api_submission.py
@@ -1,5 +1,6 @@
 """Tests for the BATCH API-client submit entrypoint (app/services/assessment/api/submission.py)."""
 
+from contextlib import contextmanager
 from unittest.mock import patch
 from uuid import uuid4
 
@@ -10,6 +11,7 @@
 
 from app.core.config import settings
 from app.crud.assessment import api
+from app.crud.assessment.submission import create_submission
 from app.models.assessment import (
     Assessment,
     AssessmentCreate,
@@ -22,6 +24,18 @@
 from app.tests.utils.test_data import create_test_config
 from app.tests.utils.utils import random_lower_string
 
+_OPEN_ROWS = "app.services.assessment.api.submission.open_uploaded_rows"
+
+
+def _serving(rows):
+    """Stand-in for open_uploaded_rows that streams the given rows."""
+
+    @contextmanager
+    def _open(**_):
+        yield iter(rows)
+
+    return _open
+
 
 def _assessment_config(
     db, project_id, *, provider="openai", model="gpt-4o", input_schema=None
@@ -71,6 +85,15 @@ def _bypass_callback_check(self):
         with patch("app.services.assessment.api.submission.validate_callback_url"):
             yield
 
+    @pytest.fixture(autouse=True)
+    def _stub_submission_upload(self):
+        # Submit stores the rows in object storage; these cases are not about that.
+        with patch(
+            "app.services.assessment.api.submission.upload_submission_rows",
+            return_value="s3://bucket/submission.jsonl",
+        ):
+            yield
+
     def test_creates_assessment_run_and_dispatches(self, db) -> None:
         auth = get_user_test_auth_context(db)
         config = _assessment_config(db, auth.project_id)
@@ -104,12 +127,12 @@ def test_creates_assessment_run_and_dispatches(self, db) -> None:
         assert bag["stage_status"] == AssessmentStatus.PENDING.value
         assert bag["callback_url"].startswith("https://hook.example")
 
-    def test_row_missing_declared_column_is_422(self, db) -> None:
+    def test_row_missing_strict_column_is_422(self, db) -> None:
         auth = get_user_test_auth_context(db)
         config = _assessment_config(
             db,
             auth.project_id,
-            input_schema={"a": {"type": "text"}, "b": {"type": "text"}},
+            input_schema={"a": {"type": "text"}, "b": {"type": "text", "strict": True}},
         )
         request = _request(config, [{"a": "present"}, {"a": "present", "b": "here"}])
 
@@ -269,6 +292,99 @@ def test_dispatch_failure_marks_failed_and_503(self, db) -> None:
         assert latest.status == AssessmentStatus.FAILED
 
 
+class TestSubmissionDocId:
+    """The `submission_doc_id` branch: rows come from a stored submission file."""
+
+    @pytest.fixture(autouse=True)
+    def _bypass_callback_check(self):
+        with (
+            patch("app.services.assessment.api.submission.validate_callback_url"),
+            patch(
+                "app.services.assessment.api.submission.upload_submission_rows",
+                return_value="s3://bucket/submission.jsonl",
+            ),
+        ):
+            yield
+
+    def _request(self, config, submission_doc_id):
+        return AssessmentCreate.model_validate(
+            {
+                "config": {"id": str(config.id), "version": 1},
+                "input": {"submission_doc_id": str(submission_doc_id)},
+                "callback_url": "https://hook.example/cb",
+            }
+        )
+
+    def _submit(self, db, auth, config, submission_doc_id):
+        return submission.submit(
+            session=db,
+            request=self._request(config, submission_doc_id),
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+
+    def test_rows_are_read_from_the_submission(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        config = _assessment_config(db, auth.project_id)
+        stored = create_submission(
+            session=db,
+            name="rows",
+            object_store_url="s3://bucket/rows.csv",
+            total_items=2,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+
+        with (
+            patch(_OPEN_ROWS, _serving([{"a": "one"}, {"a": "two"}])),
+            patch("app.celery.tasks.job_execution.run_assessment_api_batch"),
+        ):
+            response = self._submit(db, auth, config, stored.id)
+
+        assert response.status == AssessmentStatus.PROCESSING
+
+    def test_unknown_submission_is_404(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        config = _assessment_config(db, auth.project_id)
+        with pytest.raises(HTTPException) as exc:
+            self._submit(db, auth, config, uuid4())
+        assert exc.value.status_code == 404
+
+    def test_unreadable_submission_is_502(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        config = _assessment_config(db, auth.project_id)
+        stored = create_submission(
+            session=db,
+            name="unreadable",
+            object_store_url="s3://bucket/rows.csv",
+            total_items=1,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+
+        with patch(_OPEN_ROWS, side_effect=RuntimeError("s3 down")):
+            with pytest.raises(HTTPException) as exc:
+                self._submit(db, auth, config, stored.id)
+        assert exc.value.status_code == 502
+
+    def test_empty_submission_is_422(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        config = _assessment_config(db, auth.project_id)
+        stored = create_submission(
+            session=db,
+            name="empty",
+            object_store_url="s3://bucket/rows.csv",
+            total_items=0,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+
+        with patch(_OPEN_ROWS, _serving([])):
+            with pytest.raises(HTTPException) as exc:
+                self._submit(db, auth, config, stored.id)
+        assert exc.value.status_code == 422
+
+
 class TestCallbackUrlValidation:
     """BUG 3 regression: submission.submit validates callback_url up front (HTTPS +
     SSRF/private-IP guard) and maps failure to 422, instead of only at delivery time."""
@@ -319,6 +435,10 @@ def test_valid_public_https_callback_succeeds(self, db) -> None:
                 "app.services.assessment.api.submission.validate_callback_url"
             ) as validate,
             patch("app.celery.tasks.job_execution.run_assessment_api_batch") as task,
+            patch(
+                "app.services.assessment.api.submission.upload_submission_rows",
+                return_value="s3://bucket/submission.jsonl",
+            ),
         ):
             response = self._submit(db, auth, config, "https://example.com/hook")
         validate.assert_called_once_with("https://example.com/hook")
@@ -329,7 +449,13 @@ def test_valid_public_https_callback_succeeds(self, db) -> None:
 class TestCreateAssessmentRoute:
     @pytest.fixture(autouse=True)
     def _bypass_callback_check(self):
-        with patch("app.services.assessment.api.submission.validate_callback_url"):
+        with (
+            patch("app.services.assessment.api.submission.validate_callback_url"),
+            patch(
+                "app.services.assessment.api.submission.upload_submission_rows",
+                return_value="s3://bucket/submission.jsonl",
+            ),
+        ):
             yield
 
     def test_batch_input_dispatches_and_returns_202_body(
diff --git a/backend/app/tests/assessment/test_batch.py b/backend/app/tests/assessment/test_batch.py
index d00ba8af5..2662050d2 100644
--- a/backend/app/tests/assessment/test_batch.py
+++ b/backend/app/tests/assessment/test_batch.py
@@ -10,11 +10,10 @@
 
 from app.crud.assessment.batch import (
     _build_text_prompt,
-    _load_dataset_rows,
-    _parse_excel_rows,
     build_anthropic_jsonl,
     build_google_jsonl,
     build_openai_jsonl,
+    load_submission_file_rows,
     submit_assessment_batch,
 )
 from app.models.assessment import AssessmentAttachment
@@ -30,6 +29,7 @@
     split_attachment_urls,
     to_direct_attachment_url,
 )
+from app.services.assessment.validators import parse_excel_rows
 
 _REWRITE_RESOLVER = "app.services.assessment.utils.attachments.resolve_attachments"
 
@@ -103,17 +103,17 @@ def _make_assessment() -> MagicMock:
     return assessment
 
 
-def _make_dataset() -> MagicMock:
-    dataset = MagicMock()
-    dataset.id = 8
-    return dataset
+def _make_submission() -> MagicMock:
+    submission = MagicMock()
+    submission.id = 8
+    return submission
 
 
 class TestSubmitAssessmentBatchProviderRouting:
     def test_openai_native_routes_to_openai_batch(self) -> None:
         session = MagicMock()
         run = _make_run()
-        dataset = _make_dataset()
+        submission = _make_submission()
         config_blob = SimpleNamespace(
             completion=SimpleNamespace(
                 provider="openai-native",
@@ -126,7 +126,7 @@ def test_openai_native_routes_to_openai_batch(self) -> None:
 
         with (
             patch(
-                "app.crud.assessment.batch._load_dataset_rows",
+                "app.crud.assessment.batch.load_submission_file_rows",
                 return_value=[{"question": "q1"}],
             ),
             patch(
@@ -154,7 +154,7 @@ def test_openai_native_routes_to_openai_batch(self) -> None:
                 session=session,
                 run=run,
                 assessment=_make_assessment(),
-                dataset=dataset,
+                submission=submission,
                 config_blob=config_blob,
                 assessment_input={
                     "text_columns": ["question"],
@@ -177,7 +177,7 @@ def test_openai_native_routes_to_openai_batch(self) -> None:
     def test_config_instruction_is_used(self) -> None:
         session = MagicMock()
         run = _make_run()
-        dataset = _make_dataset()
+        submission = _make_submission()
         config_blob = SimpleNamespace(
             completion=SimpleNamespace(
                 provider="openai",
@@ -190,7 +190,7 @@ def test_config_instruction_is_used(self) -> None:
 
         with (
             patch(
-                "app.crud.assessment.batch._load_dataset_rows",
+                "app.crud.assessment.batch.load_submission_file_rows",
                 return_value=[{"question": "q1"}],
             ),
             patch(
@@ -218,7 +218,7 @@ def test_config_instruction_is_used(self) -> None:
                 session=session,
                 run=run,
                 assessment=_make_assessment(),
-                dataset=dataset,
+                submission=submission,
                 config_blob=config_blob,
                 assessment_input={"text_columns": ["question"], "attachments": []},
                 organization_id=1,
@@ -234,7 +234,7 @@ def test_config_instruction_is_used(self) -> None:
     def test_google_native_routes_to_google_batch(self) -> None:
         session = MagicMock()
         run = _make_run()
-        dataset = _make_dataset()
+        submission = _make_submission()
         config_blob = SimpleNamespace(
             completion=SimpleNamespace(
                 provider="google-native",
@@ -249,7 +249,7 @@ def test_google_native_routes_to_google_batch(self) -> None:
 
         with (
             patch(
-                "app.crud.assessment.batch._load_dataset_rows",
+                "app.crud.assessment.batch.load_submission_file_rows",
                 return_value=[{"question": "q1"}],
             ),
             patch(
@@ -275,7 +275,7 @@ def test_google_native_routes_to_google_batch(self) -> None:
                 session=session,
                 run=run,
                 assessment=_make_assessment(),
-                dataset=dataset,
+                submission=submission,
                 config_blob=config_blob,
                 assessment_input={
                     "text_columns": ["question"],
@@ -293,7 +293,7 @@ def test_google_native_routes_to_google_batch(self) -> None:
     def test_anthropic_native_routes_to_anthropic_batch(self) -> None:
         session = MagicMock()
         run = _make_run()
-        dataset = _make_dataset()
+        submission = _make_submission()
         config_blob = SimpleNamespace(
             completion=SimpleNamespace(
                 provider="anthropic-native",
@@ -306,7 +306,7 @@ def test_anthropic_native_routes_to_anthropic_batch(self) -> None:
 
         with (
             patch(
-                "app.crud.assessment.batch._load_dataset_rows",
+                "app.crud.assessment.batch.load_submission_file_rows",
                 return_value=[{"question": "q1"}],
             ),
             patch(
@@ -334,7 +334,7 @@ def test_anthropic_native_routes_to_anthropic_batch(self) -> None:
                 session=session,
                 run=run,
                 assessment=_make_assessment(),
-                dataset=dataset,
+                submission=submission,
                 config_blob=config_blob,
                 assessment_input={
                     "text_columns": ["question"],
@@ -355,13 +355,12 @@ def test_anthropic_native_routes_to_anthropic_batch(self) -> None:
 
 
 class TestBatchDatasetParsing:
-    def test_load_dataset_rows_routes_xlsx_to_excel_parser(self) -> None:
+    def test_load_submission_rows_routes_xlsx_to_excel_parser(self) -> None:
         session = MagicMock()
-        dataset = MagicMock()
-        dataset.id = 8
-        dataset.project_id = 1
-        dataset.object_store_url = "s3://bucket/key"
-        dataset.dataset_metadata = {"file_extension": ".xlsx"}
+        submission = MagicMock()
+        submission.id = 8
+        submission.project_id = 1
+        submission.object_store_url = "s3://bucket/key.xlsx"
 
         storage = MagicMock()
         stream_body = MagicMock()
@@ -372,22 +371,21 @@ def test_load_dataset_rows_routes_xlsx_to_excel_parser(self) -> None:
         with (
             patch("app.crud.assessment.batch.get_cloud_storage", return_value=storage),
             patch(
-                "app.crud.assessment.batch._parse_excel_rows",
+                "app.crud.assessment.batch.parse_rows",
                 return_value=expected,
-            ) as parse_excel,
+            ) as parse,
         ):
-            result = _load_dataset_rows(session=session, dataset=dataset)
+            result = load_submission_file_rows(session=session, submission=submission)
 
         assert result == expected
-        parse_excel.assert_called_once_with(b"xlsx-content")
+        parse.assert_called_once_with(b"xlsx-content", ".xlsx")
 
-    def test_load_dataset_rows_rejects_legacy_xls(self) -> None:
+    def test_load_submission_rows_rejects_legacy_xls(self) -> None:
         session = MagicMock()
-        dataset = MagicMock()
-        dataset.id = 8
-        dataset.project_id = 1
-        dataset.object_store_url = "s3://bucket/key"
-        dataset.dataset_metadata = {"file_extension": ".xls"}
+        submission = MagicMock()
+        submission.id = 8
+        submission.project_id = 1
+        submission.object_store_url = "s3://bucket/key.xls"
 
         storage = MagicMock()
         stream_body = MagicMock()
@@ -396,11 +394,11 @@ def test_load_dataset_rows_rejects_legacy_xls(self) -> None:
 
         with patch("app.crud.assessment.batch.get_cloud_storage", return_value=storage):
             with pytest.raises(ValueError, match="Legacy Excel format"):
-                _load_dataset_rows(session=session, dataset=dataset)
+                load_submission_file_rows(session=session, submission=submission)
 
     def test_parse_excel_rows_invalid_payload_raises(self) -> None:
         with pytest.raises((ValueError, InvalidFileException)):
-            _parse_excel_rows(b"not-a-valid-xlsx")
+            parse_excel_rows(b"not-a-valid-xlsx")
 
     def test_parse_excel_rows_success(self) -> None:
         wb = Workbook()
@@ -413,16 +411,17 @@ def test_parse_excel_rows_success(self) -> None:
         wb.save(buf)
         wb.close()
 
-        rows = _parse_excel_rows(buf.getvalue())
+        rows = parse_excel_rows(buf.getvalue())
         assert rows == [{"question": "What is 2+2?", "answer": "4"}]
 
     def test_parse_excel_rows_returns_empty_when_sheet_missing(self) -> None:
         fake_wb = MagicMock()
         fake_wb.active = None
         with patch(
-            "app.crud.assessment.batch.openpyxl.load_workbook", return_value=fake_wb
+            "app.services.assessment.validators.openpyxl.load_workbook",
+            return_value=fake_wb,
         ):
-            assert _parse_excel_rows(b"irrelevant") == []
+            assert parse_excel_rows(b"irrelevant") == []
         fake_wb.close.assert_called_once()
 
     def test_parse_excel_rows_returns_empty_when_header_missing(self) -> None:
@@ -431,26 +430,29 @@ def test_parse_excel_rows_returns_empty_when_header_missing(self) -> None:
         fake_wb = MagicMock()
         fake_wb.active = fake_ws
         with patch(
-            "app.crud.assessment.batch.openpyxl.load_workbook", return_value=fake_wb
+            "app.services.assessment.validators.openpyxl.load_workbook",
+            return_value=fake_wb,
         ):
-            assert _parse_excel_rows(b"irrelevant") == []
+            assert parse_excel_rows(b"irrelevant") == []
         fake_wb.close.assert_called_once()
 
     def test_parse_excel_rows_invalid_file_exception_re_raises(self) -> None:
         with patch(
-            "app.crud.assessment.batch.openpyxl.load_workbook",
+            "app.services.assessment.validators.openpyxl.load_workbook",
             side_effect=InvalidFileException("bad xlsx"),
         ):
             with pytest.raises(InvalidFileException):
-                _parse_excel_rows(b"bad")
+                parse_excel_rows(b"bad")
 
     def test_parse_excel_rows_unexpected_exception_raises_value_error(self) -> None:
         with patch(
-            "app.crud.assessment.batch.openpyxl.load_workbook",
+            "app.services.assessment.validators.openpyxl.load_workbook",
             side_effect=RuntimeError("boom"),
         ):
-            with pytest.raises(ValueError, match="Failed to parse XLSX dataset rows"):
-                _parse_excel_rows(b"bad")
+            with pytest.raises(
+                ValueError, match="Failed to parse XLSX submission rows"
+            ):
+                parse_excel_rows(b"bad")
 
 
 class TestBatchHelpers:
diff --git a/backend/app/tests/assessment/test_cron.py b/backend/app/tests/assessment/test_cron.py
index e2fb211b4..6eab9496c 100644
--- a/backend/app/tests/assessment/test_cron.py
+++ b/backend/app/tests/assessment/test_cron.py
@@ -1,15 +1,42 @@
 """Tests for assessment/cron.py helper functions."""
 
 from datetime import datetime
+from uuid import uuid4
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
+from app.crud.assessment import api as assessment_api
+from app.crud.assessment import core as assessment_core
 from app.crud.assessment.cron import (
     _log_config_progress,
     poll_all_pending_assessment_evaluations,
 )
-from app.models.assessment import StageStatus
+from app.models.assessment import (
+    AssessmentMethod,
+    AssessmentStatus,
+    AssessmentSubmission,
+    StageStatus,
+)
+from app.models.config.assessment_blob import AssessmentConfigBlob
+from app.models.config.config import ConfigTag
+from app.tests.utils.auth import get_user_test_auth_context
+from app.tests.utils.test_data import (
+    create_test_config,
+    create_test_evaluation_dataset,
+)
+from app.tests.utils.utils import random_lower_string
+
+_ASSESSMENT_BLOB = AssessmentConfigBlob.model_validate(
+    {
+        "input_schema": {"a": {"type": "text"}},
+        "assessment": {
+            "provider": "openai",
+            "type": "text",
+            "params": {"model": "gpt-4o", "submission": "assess {a}"},
+        },
+    }
+)
 
 
 @pytest.fixture(autouse=True)
@@ -166,6 +193,35 @@ async def test_transient_poll_exception_does_not_fail_run(self) -> None:
         assert result["failed"] == 0
         assert result["still_processing"] == 1
 
+    @pytest.mark.asyncio
+    async def test_attribute_error_marks_run_failed(self) -> None:
+        """The I-2 shape bug surfaced as an AttributeError and looped forever on retry.
+
+        Session is a mock because the failure branch calls ``session.rollback()``, which
+        unwinds the ``db`` fixture's outer transaction along with the seeded rows.
+        """
+        session = MagicMock()
+        assessment = _make_assessment(id=1, status="processing")
+        run = _make_run(id=11, execution={"stage_status": StageStatus.PROCESSING})
+        session.exec.return_value.all.return_value = [assessment]
+
+        with patch(
+            "app.crud.assessment.cron.get_assessment_runs_for_assessment",
+            return_value=[run],
+        ), patch(
+            "app.crud.assessment.cron.process_run_batches",
+            new=AsyncMock(
+                side_effect=AttributeError("'list' object has no attribute 'get'")
+            ),
+        ), patch(
+            "app.crud.assessment.cron.update_assessment_run_status"
+        ) as mark_failed:
+            result = await poll_all_pending_assessment_evaluations(session=session)
+
+        assert result["failed"] == 1
+        assert result["still_processing"] == 0
+        assert mark_failed.call_args.kwargs["status"] == "FAILED"
+
     @pytest.mark.asyncio
     async def test_deterministic_error_marks_run_failed(self) -> None:
         """A deterministic ValueError fails the run instead of retrying forever."""
@@ -188,3 +244,91 @@ async def test_deterministic_error_marks_run_failed(self) -> None:
         assert result["failed"] == 1
         assert result["still_processing"] == 0
         assert mark_failed.call_args.kwargs["status"] == "FAILED"
+
+
+class TestPollerAgainstRealRows:
+    """The poller's method boundary and its failure classification, on real rows."""
+
+    def _run_assessment(self, db, auth):
+        submission = AssessmentSubmission(
+            name=f"sub-{uuid4().hex[:8]}",
+            object_store_url="s3://bucket/sub.csv",
+            total_items=1,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+        db.add(submission)
+        db.commit()
+        db.refresh(submission)
+        return assessment_core.create_assessment(
+            session=db,
+            experiment_name="exp",
+            submission_id=submission.id,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+
+    def _batch_assessment(self, db, auth):
+        return assessment_api.create_assessment(
+            session=db,
+            method=AssessmentMethod.BATCH,
+            input={"data": [{"a": "1"}]},
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+
+    @pytest.mark.asyncio
+    async def test_batch_assessments_are_not_polled_but_run_ones_are(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        run_assessment = self._run_assessment(db, auth)
+        batch_assessment = self._batch_assessment(db, auth)
+
+        polled: list = []
+
+        def record(*, session, assessment_id):
+            polled.append(assessment_id)
+            return []
+
+        with patch(
+            "app.crud.assessment.cron.get_assessment_runs_for_assessment",
+            side_effect=record,
+        ):
+            await poll_all_pending_assessment_evaluations(session=db)
+
+        assert run_assessment.id in polled
+        assert batch_assessment.id not in polled
+
+    @pytest.mark.asyncio
+    async def test_a_run_assessments_active_run_is_polled(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment = self._run_assessment(db, auth)
+        config = create_test_config(
+            db,
+            project_id=auth.project_id,
+            name=f"assess-{random_lower_string()}",
+            config_blob=_ASSESSMENT_BLOB,
+            tag=ConfigTag.ASSESSMENT,
+        )
+        run = assessment_core.create_assessment_run(
+            session=db,
+            assessment_id=assessment.id,
+            config_id=config.id,
+            config_version=1,
+        )
+        assessment_core.update_assessment_run_status(
+            session=db, run=run, status=AssessmentStatus.PROCESSING
+        )
+        assessment_core._write_exec(run, stage_status=StageStatus.PROCESSING)
+        db.add(run)
+        db.commit()
+
+        polled_run_ids: list[int] = []
+
+        async def record(*, run, session):
+            polled_run_ids.append(run.id)
+            return {"action": "still_processing"}
+
+        with patch("app.crud.assessment.cron.process_run_batches", new=record):
+            await poll_all_pending_assessment_evaluations(session=db)
+
+        assert run.id in polled_run_ids
diff --git a/backend/app/tests/assessment/test_crud.py b/backend/app/tests/assessment/test_crud.py
index 961fc37b3..91d5b69af 100644
--- a/backend/app/tests/assessment/test_crud.py
+++ b/backend/app/tests/assessment/test_crud.py
@@ -13,12 +13,12 @@
     build_run_stats,
     compute_run_counts,
     create_assessment,
-    create_assessment_dataset,
+    create_submission,
     create_assessment_run,
     derive_aggregate_error,
     derive_assessment_status,
     get_assessment_by_id,
-    get_assessment_dataset_by_id,
+    get_submission_by_id,
     get_assessment_run_by_id,
     get_assessment_runs_for_assessment,
     list_assessment_runs,
@@ -28,7 +28,6 @@
     update_run_post_processing_config,
 )
 from app.crud.assessment.core import update_assessment_run_prefilter_stats
-from app.models.stt_evaluation import EvaluationType
 
 
 def _counts(total=0, pending=0, processing=0, completed=0, failed=0):
@@ -84,18 +83,17 @@ def test_get_assessment_run_by_id_not_found(self) -> None:
         assert exc_info.value.status_code == 404
         assert "99" in exc_info.value.detail
 
-    def test_get_assessment_dataset_by_id_not_found(self) -> None:
+    def test_get_submission_by_id_not_found(self) -> None:
         session = MagicMock()
         session.exec.return_value.first.return_value = None
         with pytest.raises(HTTPException) as exc_info:
-            get_assessment_dataset_by_id(
+            get_submission_by_id(
                 session=session,
-                dataset_id=99,
+                submission_id=UUID("00000000-0000-0000-0000-000000000099"),
                 organization_id=1,
                 project_id=1,
             )
         assert exc_info.value.status_code == 404
-        assert "99" in exc_info.value.detail
 
     def test_get_assessment_runs_for_assessment(self) -> None:
         session = MagicMock()
@@ -104,21 +102,20 @@ def test_get_assessment_runs_for_assessment(self) -> None:
 
 
 class TestCrudWrites:
-    def test_create_assessment_dataset_uses_assessment_type(self) -> None:
+    def test_create_submission_persists_row(self) -> None:
         session = MagicMock()
-        result = create_assessment_dataset(
+        result = create_submission(
             session=session,
-            name="dataset",
+            name="submission",
             description="desc",
-            dataset_metadata={"total_items_count": 2},
-            object_store_url="s3://datasets/file.csv",
-            langfuse_dataset_id="langfuse-dataset",
+            object_store_url="s3://submissions/file.csv",
+            total_items=2,
             organization_id=1,
             project_id=1,
         )
 
-        assert result.type == EvaluationType.ASSESSMENT.value
-        assert result.langfuse_dataset_id == "langfuse-dataset"
+        assert result.name == "submission"
+        assert result.total_items == 2
         session.add.assert_called_once()
         session.commit.assert_called_once()
         session.refresh.assert_called_once()
@@ -128,7 +125,7 @@ def test_create_assessment_success(self) -> None:
         result = create_assessment(
             session=session,
             experiment_name="exp",
-            dataset_id=1,
+            submission_id=UUID(int=1),
             organization_id=1,
             project_id=1,
         )
diff --git a/backend/app/tests/assessment/test_dataset.py b/backend/app/tests/assessment/test_dataset.py
deleted file mode 100644
index 2535c2acd..000000000
--- a/backend/app/tests/assessment/test_dataset.py
+++ /dev/null
@@ -1,304 +0,0 @@
-"""Tests for assessment/dataset.py upload and row counting behavior."""
-
-from unittest.mock import MagicMock, patch
-
-import pytest
-from fastapi import HTTPException
-from openpyxl.utils.exceptions import InvalidFileException
-
-from app.services.assessment.dataset import (
-    _count_csv_rows,
-    _count_excel_rows,
-    _count_rows,
-    _preview_csv,
-    _preview_excel,
-    preview_dataset,
-    upload_dataset,
-)
-
-
-class TestCountRows:
-    def test_legacy_xls_rejected(self) -> None:
-        with pytest.raises(ValueError, match="Legacy Excel format"):
-            _count_rows(b"legacy-xls-content", ".xls")
-
-    def test_count_excel_rows_invalid_file_re_raises(self) -> None:
-        with patch(
-            "openpyxl.load_workbook",
-            side_effect=InvalidFileException("bad xlsx"),
-        ):
-            with pytest.raises(InvalidFileException):
-                _count_excel_rows(b"bad")
-
-    def test_count_excel_rows_unexpected_error_raises_value_error(self) -> None:
-        with patch("openpyxl.load_workbook", side_effect=RuntimeError("boom")):
-            with pytest.raises(ValueError, match="Failed to parse XLSX file"):
-                _count_excel_rows(b"bad")
-
-    def test_count_csv_rows(self) -> None:
-        assert _count_csv_rows(b"a,b\n1,2\n\n3,4\n") == 2
-
-    def test_count_rows_csv_and_xlsx(self) -> None:
-        with patch("app.services.assessment.dataset._count_excel_rows", return_value=5):
-            assert _count_rows(b"x", ".xlsx") == 5
-        assert _count_rows(b"a,b\n1,2\n", ".csv") == 1
-
-
-class TestUploadDataset:
-    def test_invalid_xlsx_returns_422(self) -> None:
-        session = MagicMock()
-        with patch(
-            "app.services.assessment.dataset.sanitize_dataset_name", return_value="ds-1"
-        ), patch(
-            "app.services.assessment.dataset._count_rows",
-            side_effect=InvalidFileException("bad xlsx"),
-        ):
-            with pytest.raises(HTTPException) as exc_info:
-                upload_dataset(
-                    session=session,
-                    file_content=b"invalid-xlsx",
-                    file_ext=".xlsx",
-                    dataset_name="ds-1",
-                    description=None,
-                    organization_id=1,
-                    project_id=1,
-                )
-        assert exc_info.value.status_code == 422
-        assert "Invalid XLSX file content" in exc_info.value.detail
-
-    def test_count_rows_value_error_returns_422(self) -> None:
-        session = MagicMock()
-        with patch(
-            "app.services.assessment.dataset.sanitize_dataset_name", return_value="ds-1"
-        ), patch(
-            "app.services.assessment.dataset._count_rows",
-            side_effect=ValueError("Legacy Excel format (.xls) is not supported."),
-        ):
-            with pytest.raises(HTTPException) as exc_info:
-                upload_dataset(
-                    session=session,
-                    file_content=b"bad",
-                    file_ext=".xls",
-                    dataset_name="ds-1",
-                    description=None,
-                    organization_id=1,
-                    project_id=1,
-                )
-        assert exc_info.value.status_code == 422
-        assert "Legacy Excel format" in exc_info.value.detail
-
-    def test_count_rows_unexpected_error_returns_generic_422(self) -> None:
-        session = MagicMock()
-        with patch(
-            "app.services.assessment.dataset.sanitize_dataset_name", return_value="ds-1"
-        ), patch(
-            "app.services.assessment.dataset._count_rows",
-            side_effect=RuntimeError("unexpected"),
-        ):
-            with pytest.raises(HTTPException) as exc_info:
-                upload_dataset(
-                    session=session,
-                    file_content=b"bad",
-                    file_ext=".xlsx",
-                    dataset_name="ds-1",
-                    description=None,
-                    organization_id=1,
-                    project_id=1,
-                )
-        assert exc_info.value.status_code == 422
-        assert "Unable to parse dataset file" in exc_info.value.detail
-
-    def test_upload_dataset_success(self) -> None:
-        session = MagicMock()
-        created = MagicMock()
-        created.id = 9
-        with patch(
-            "app.services.assessment.dataset.sanitize_dataset_name", return_value="ds-1"
-        ), patch("app.services.assessment.dataset._count_rows", return_value=2), patch(
-            "app.services.assessment.dataset._upload_file_to_object_store",
-            return_value="s3://datasets/file.csv",
-        ), patch(
-            "app.services.assessment.dataset.create_assessment_dataset",
-            return_value=created,
-        ) as create_ds:
-            result = upload_dataset(
-                session=session,
-                file_content=b"a,b\n1,2\n",
-                file_ext=".csv",
-                dataset_name="ds-1",
-                description="desc",
-                organization_id=1,
-                project_id=1,
-            )
-        assert result.id == 9
-        create_ds.assert_called_once()
-        assert create_ds.call_args.kwargs["dataset_metadata"]["total_items_count"] == 2
-
-    def test_preview_csv_returns_headers_and_rows(self) -> None:
-        headers, rows = _preview_csv(b"a,b\n1,2\n\n3,4\n5,6\n", limit=2)
-        assert headers == ["a", "b"]
-        assert rows == [["1", "2"], ["3", "4"]]
-
-    def test_preview_csv_handles_latin1_fallback(self) -> None:
-        # \xff is invalid utf-8 -> falls back to latin-1
-        headers, rows = _preview_csv(b"name\nca\xfffe\n", limit=5)
-        assert headers == ["name"]
-        assert rows and rows[0][0].startswith("ca")
-
-    def test_preview_excel_returns_headers_and_rows(self) -> None:
-        import io
-
-        import openpyxl
-
-        wb = openpyxl.Workbook()
-        ws = wb.active
-        ws.append(["x", "y"])
-        ws.append([1, 2])
-        ws.append([None, None])
-        ws.append([3, 4])
-        buf = io.BytesIO()
-        wb.save(buf)
-        headers, rows = _preview_excel(buf.getvalue(), limit=10)
-        assert headers == ["x", "y"]
-        assert rows == [["1", "2"], ["3", "4"]]
-
-    def test_preview_excel_empty_workbook(self) -> None:
-        import io
-
-        import openpyxl
-
-        wb = openpyxl.Workbook()
-        buf = io.BytesIO()
-        wb.save(buf)
-        headers, rows = _preview_excel(buf.getvalue(), limit=10)
-        assert headers == [""] or headers == []
-        assert rows == []
-
-    def test_preview_dataset_missing_url_returns_404(self) -> None:
-        ds = MagicMock()
-        ds.object_store_url = None
-        with pytest.raises(HTTPException) as exc_info:
-            preview_dataset(session=MagicMock(), dataset=ds, project_id=1, limit=10)
-        assert exc_info.value.status_code == 404
-
-    def test_preview_dataset_missing_extension_returns_422(self) -> None:
-        ds = MagicMock()
-        ds.object_store_url = "s3://x"
-        ds.dataset_metadata = {}
-        with pytest.raises(HTTPException) as exc_info:
-            preview_dataset(session=MagicMock(), dataset=ds, project_id=1, limit=10)
-        assert exc_info.value.status_code == 422
-        assert "Unsupported or missing" in exc_info.value.detail
-
-    def test_preview_dataset_unknown_extension_returns_422(self) -> None:
-        ds = MagicMock()
-        ds.object_store_url = "s3://x"
-        ds.dataset_metadata = {"file_extension": ".json"}
-        with pytest.raises(HTTPException) as exc_info:
-            preview_dataset(session=MagicMock(), dataset=ds, project_id=1, limit=10)
-        assert exc_info.value.status_code == 422
-
-    def test_preview_dataset_normalizes_extension_case(self) -> None:
-        ds = MagicMock()
-        ds.object_store_url = "s3://x"
-        ds.dataset_metadata = {"file_extension": " .CSV "}
-        storage = MagicMock()
-        storage.get.return_value = b"a,b\n1,2\n"
-        with patch(
-            "app.services.assessment.dataset.get_cloud_storage", return_value=storage
-        ):
-            headers, rows = preview_dataset(
-                session=MagicMock(), dataset=ds, project_id=1, limit=10
-            )
-        assert headers == ["a", "b"]
-        assert rows == [["1", "2"]]
-
-    def test_preview_dataset_legacy_xls_returns_422(self) -> None:
-        ds = MagicMock()
-        ds.object_store_url = "s3://x"
-        ds.dataset_metadata = {"file_extension": ".xls"}
-        with pytest.raises(HTTPException) as exc_info:
-            preview_dataset(session=MagicMock(), dataset=ds, project_id=1, limit=10)
-        assert exc_info.value.status_code == 422
-
-    def test_preview_dataset_storage_failure_returns_502(self) -> None:
-        ds = MagicMock()
-        ds.object_store_url = "s3://x"
-        ds.dataset_metadata = {"file_extension": ".csv"}
-        storage = MagicMock()
-        storage.get.side_effect = RuntimeError("boom")
-        with patch(
-            "app.services.assessment.dataset.get_cloud_storage", return_value=storage
-        ):
-            with pytest.raises(HTTPException) as exc_info:
-                preview_dataset(session=MagicMock(), dataset=ds, project_id=1, limit=10)
-        assert exc_info.value.status_code == 502
-
-    def test_preview_dataset_invalid_xlsx_returns_422(self) -> None:
-        ds = MagicMock()
-        ds.object_store_url = "s3://x"
-        ds.dataset_metadata = {"file_extension": ".xlsx"}
-        storage = MagicMock()
-        storage.get.return_value = b"not-a-real-xlsx"
-        with patch(
-            "app.services.assessment.dataset.get_cloud_storage", return_value=storage
-        ), patch(
-            "app.services.assessment.dataset._preview_excel",
-            side_effect=InvalidFileException("bad"),
-        ):
-            with pytest.raises(HTTPException) as exc_info:
-                preview_dataset(session=MagicMock(), dataset=ds, project_id=1, limit=10)
-        assert exc_info.value.status_code == 422
-        assert "Invalid XLSX" in exc_info.value.detail
-
-    def test_preview_dataset_parse_error_returns_422(self) -> None:
-        ds = MagicMock()
-        ds.object_store_url = "s3://x"
-        ds.dataset_metadata = {"file_extension": ".csv"}
-        storage = MagicMock()
-        storage.get.return_value = b"a,b\n1,2\n"
-        with patch(
-            "app.services.assessment.dataset.get_cloud_storage", return_value=storage
-        ), patch(
-            "app.services.assessment.dataset._preview_csv",
-            side_effect=RuntimeError("boom"),
-        ):
-            with pytest.raises(HTTPException) as exc_info:
-                preview_dataset(session=MagicMock(), dataset=ds, project_id=1, limit=10)
-        assert exc_info.value.status_code == 422
-        assert "Unable to parse" in exc_info.value.detail
-
-    def test_preview_dataset_csv_success(self) -> None:
-        ds = MagicMock()
-        ds.object_store_url = "s3://x"
-        ds.dataset_metadata = {"file_extension": ".csv"}
-        storage = MagicMock()
-        storage.get.return_value = b"a,b\n1,2\n3,4\n"
-        with patch(
-            "app.services.assessment.dataset.get_cloud_storage", return_value=storage
-        ):
-            headers, rows = preview_dataset(
-                session=MagicMock(), dataset=ds, project_id=1, limit=10
-            )
-        assert headers == ["a", "b"]
-        assert rows == [["1", "2"], ["3", "4"]]
-
-    def test_upload_dataset_object_store_failure_returns_500(self) -> None:
-        session = MagicMock()
-        with patch(
-            "app.services.assessment.dataset.sanitize_dataset_name", return_value="ds-1"
-        ), patch("app.services.assessment.dataset._count_rows", return_value=1), patch(
-            "app.services.assessment.dataset._upload_file_to_object_store",
-            return_value=None,
-        ):
-            with pytest.raises(HTTPException) as exc_info:
-                upload_dataset(
-                    session=session,
-                    file_content=b"a,b\n1,2\n",
-                    file_ext=".csv",
-                    dataset_name="ds-1",
-                    description=None,
-                    organization_id=1,
-                    project_id=1,
-                )
-        assert exc_info.value.status_code == 500
diff --git a/backend/app/tests/assessment/test_export.py b/backend/app/tests/assessment/test_export.py
index 9ac64116c..4e443d95a 100644
--- a/backend/app/tests/assessment/test_export.py
+++ b/backend/app/tests/assessment/test_export.py
@@ -13,7 +13,7 @@
     _drop_empty_columns,
     _expand_input_columns,
     _expand_output_columns,
-    _load_dataset_rows_for_run,
+    _load_submission_rows_for_run,
     _load_l2_results_for_run,
     _load_parsed_results_for_batch_job,
     _load_parsed_results_for_run,
@@ -567,7 +567,7 @@ def _make_assessment(self, dataset_id: int = 1) -> MagicMock:
     def test_dataset_not_found_returns_empty(self) -> None:
         session = MagicMock()
         session.get.return_value = None
-        result = _load_dataset_rows_for_run(
+        result = _load_submission_rows_for_run(
             session=session, run=self._make_run(), assessment=self._make_assessment()
         )
         assert result == []
@@ -577,7 +577,7 @@ def test_dataset_no_url_returns_empty(self) -> None:
         dataset = MagicMock()
         dataset.object_store_url = None
         session.get.return_value = dataset
-        result = _load_dataset_rows_for_run(
+        result = _load_submission_rows_for_run(
             session=session, run=self._make_run(), assessment=self._make_assessment()
         )
         assert result == []
@@ -585,7 +585,7 @@ def test_dataset_no_url_returns_empty(self) -> None:
     def test_exception_returns_empty(self) -> None:
         session = MagicMock()
         session.get.side_effect = Exception("DB error")
-        result = _load_dataset_rows_for_run(
+        result = _load_submission_rows_for_run(
             session=session, run=self._make_run(), assessment=self._make_assessment()
         )
         assert result == []
@@ -596,10 +596,10 @@ def test_valid_dataset_returns_rows(self) -> None:
         dataset.object_store_url = "s3://bucket/ds.csv"
         session.get.return_value = dataset
         with patch(
-            "app.services.assessment.utils.export._load_dataset_rows",
+            "app.services.assessment.utils.export._load_submission_rows",
             return_value=[{"q": "hi"}],
         ):
-            result = _load_dataset_rows_for_run(
+            result = _load_submission_rows_for_run(
                 session=session,
                 run=self._make_run(),
                 assessment=self._make_assessment(),
@@ -637,7 +637,7 @@ def _patches(self, *, l2, prefilter=None, dataset_rows=None):
                 return_value=prefilter or {},
             ),
             patch(
-                "app.services.assessment.utils.export._load_dataset_rows_for_run",
+                "app.services.assessment.utils.export._load_submission_rows_for_run",
                 return_value=dataset_rows if dataset_rows is not None else [],
             ),
         ]
diff --git a/backend/app/tests/assessment/test_mappers.py b/backend/app/tests/assessment/test_mappers.py
deleted file mode 100644
index 4ebb636a2..000000000
--- a/backend/app/tests/assessment/test_mappers.py
+++ /dev/null
@@ -1,331 +0,0 @@
-"""Tests for assessment/mappers.py."""
-
-from unittest.mock import MagicMock, patch
-
-from app.services.assessment.mappers import (
-    _ensure_openai_strict_schema,
-    _strip_additional_properties,
-    map_kaapi_to_google_params,
-    map_kaapi_to_openai_params,
-    normalize_llm_text,
-)
-
-
-class TestNormalizeLlmText:
-    def test_non_string_returns_as_is(self) -> None:
-        assert normalize_llm_text(None) is None  # type: ignore[arg-type]
-        assert normalize_llm_text(42) == 42  # type: ignore[arg-type]
-
-    def test_empty_string_returns_as_is(self) -> None:
-        assert normalize_llm_text("") == ""
-
-    def test_escaped_newline_replaced(self) -> None:
-        assert normalize_llm_text("line1\\nline2") == "line1\nline2"
-
-    def test_escaped_tab_replaced(self) -> None:
-        assert normalize_llm_text("col1\\tcol2") == "col1\tcol2"
-
-    def test_escaped_quote_replaced(self) -> None:
-        assert normalize_llm_text('\\"quoted\\"') == '"quoted"'
-
-    def test_double_backslash_collapsed(self) -> None:
-        assert normalize_llm_text("a\\\\b") == "a\\b"
-
-    def test_nfc_normalization_applied(self) -> None:
-        # Combining character sequence → precomposed form
-        import unicodedata
-
-        text = "é"  # e + combining acute accent
-        result = normalize_llm_text(text)
-        assert result == unicodedata.normalize("NFC", text)
-
-
-class TestEnsureOpenAIStrictSchema:
-    def test_object_type_gets_additional_properties_false(self) -> None:
-        schema = {"type": "object", "properties": {"name": {"type": "string"}}}
-        result = _ensure_openai_strict_schema(schema)
-        assert result["additionalProperties"] is False
-
-    def test_nested_object_also_gets_flag(self) -> None:
-        schema = {
-            "type": "object",
-            "properties": {
-                "address": {
-                    "type": "object",
-                    "properties": {"city": {"type": "string"}},
-                }
-            },
-        }
-        result = _ensure_openai_strict_schema(schema)
-        assert result["properties"]["address"]["additionalProperties"] is False
-
-    def test_array_items_processed_recursively(self) -> None:
-        schema = {
-            "type": "array",
-            "items": {"type": "object", "properties": {"x": {"type": "number"}}},
-        }
-        result = _ensure_openai_strict_schema(schema)
-        assert result["items"]["additionalProperties"] is False
-
-    def test_non_object_type_not_modified(self) -> None:
-        schema = {"type": "string"}
-        result = _ensure_openai_strict_schema(schema)
-        assert "additionalProperties" not in result
-
-
-class TestStripAdditionalProperties:
-    def test_removes_additional_properties(self) -> None:
-        schema = {"type": "object", "additionalProperties": False, "properties": {}}
-        result = _strip_additional_properties(schema)
-        assert "additionalProperties" not in result
-
-    def test_nested_removal(self) -> None:
-        schema = {
-            "type": "object",
-            "additionalProperties": False,
-            "properties": {"child": {"type": "object", "additionalProperties": False}},
-        }
-        result = _strip_additional_properties(schema)
-        assert "additionalProperties" not in result["properties"]["child"]
-
-    def test_array_items_processed(self) -> None:
-        schema = {
-            "type": "array",
-            "items": {"type": "object", "additionalProperties": False},
-        }
-        result = _strip_additional_properties(schema)
-        assert "additionalProperties" not in result["items"]
-
-
-class TestMapKaapiToOpenAIParams:
-    def _call(self, params: dict, supports_reasoning: bool = False):
-        with patch(
-            "app.services.assessment.mappers.is_reasoning_model",
-            return_value=supports_reasoning,
-        ):
-            return map_kaapi_to_openai_params(session=MagicMock(), kaapi_params=params)
-
-    def test_basic_model_passed_through(self) -> None:
-        result, warnings = self._call({"model": "gpt-4o"})
-        assert result["model"] == "gpt-4o"
-        assert warnings == []
-
-    def test_instructions_normalized_and_set(self) -> None:
-        result, _ = self._call({"model": "gpt-4o", "instructions": "Be helpful\\n"})
-        assert result["instructions"] == "Be helpful\n"
-
-    def test_temperature_set_for_non_reasoning_model(self) -> None:
-        result, _ = self._call({"model": "gpt-4o", "temperature": 0.7})
-        assert result["temperature"] == 0.7
-
-    def test_temperature_suppressed_for_reasoning_model(self) -> None:
-        result, warnings = self._call(
-            {"model": "o1", "temperature": 0.5}, supports_reasoning=True
-        )
-        assert "temperature" not in result
-        assert any("temperature" in w for w in warnings)
-
-    def test_top_p_suppressed_for_reasoning_model(self) -> None:
-        result, warnings = self._call(
-            {"model": "o1", "top_p": 0.9}, supports_reasoning=True
-        )
-        assert "top_p" not in result
-        assert any("top_p" in w for w in warnings)
-
-    def test_effort_set_for_reasoning_model(self) -> None:
-        result, _ = self._call(
-            {"model": "o1", "effort": "high"}, supports_reasoning=True
-        )
-        assert result["reasoning"]["effort"] == "high"
-
-    def test_effort_suppressed_for_non_reasoning_model(self) -> None:
-        result, warnings = self._call({"model": "gpt-4o", "effort": "high"})
-        assert "reasoning" not in result
-        assert any("effort" in w for w in warnings)
-
-    def test_output_schema_sets_text_format(self) -> None:
-        schema = {"type": "object", "properties": {"score": {"type": "integer"}}}
-        result, _ = self._call({"model": "gpt-4o", "output_schema": schema})
-        assert result["text"]["format"]["type"] == "json_schema"
-        assert result["text"]["format"]["strict"] is True
-
-    def test_response_format_text_not_set(self) -> None:
-        result, _ = self._call({"model": "gpt-4o", "response_format": "text"})
-        assert "text" not in result
-
-    def test_knowledge_base_ids_sets_tools(self) -> None:
-        result, _ = self._call(
-            {"model": "gpt-4o", "knowledge_base_ids": ["vs_123"], "max_num_results": 10}
-        )
-        assert result["tools"][0]["type"] == "file_search"
-        assert result["tools"][0]["max_num_results"] == 10
-
-    def test_summary_null_string_sets_none(self) -> None:
-        result, _ = self._call(
-            {"model": "o1", "summary": "null"}, supports_reasoning=True
-        )
-        assert result["reasoning"]["summary"] is None
-
-    def test_top_p_set_for_non_reasoning_model(self) -> None:
-        result, _ = self._call({"model": "gpt-4o", "top_p": 0.85})
-        assert result["top_p"] == 0.85
-
-
-class TestMapKaapiToGoogleParams:
-    def _call(self, params: dict):
-        mock_schema = MagicMock()
-        mock_schema.model_dump.return_value = {}
-        with patch(
-            "app.services.assessment.mappers.genai_transformers.t_schema",
-            return_value=mock_schema,
-        ):
-            return map_kaapi_to_google_params(params)
-
-    def test_missing_model_returns_warning(self) -> None:
-        result, warnings = map_kaapi_to_google_params({})
-        assert result == {}
-        assert any("model" in w for w in warnings)
-
-    def test_basic_model_set(self) -> None:
-        result, _ = self._call({"model": "gemini-1.5-pro"})
-        assert result["model"] == "gemini-1.5-pro"
-
-    def test_temperature_set(self) -> None:
-        result, _ = self._call({"model": "gemini-1.5-pro", "temperature": 0.3})
-        assert result["temperature"] == 0.3
-
-    def test_top_p_set(self) -> None:
-        result, _ = self._call({"model": "gemini-1.5-pro", "top_p": 0.8})
-        assert result["top_p"] == 0.8
-
-    def test_thinking_level_set(self) -> None:
-        result, _ = self._call(
-            {"model": "gemini-2.0-flash-thinking", "thinking_level": "high"}
-        )
-        assert result["thinking_config"] == {"thinking_level": "high"}
-
-    def test_knowledge_base_ids_warns(self) -> None:
-        result, warnings = self._call(
-            {"model": "gemini-1.5-pro", "knowledge_base_ids": ["kb_1"]}
-        )
-        assert any("knowledge_base_ids" in w for w in warnings)
-
-    def test_output_schema_set(self) -> None:
-        schema = {"type": "object", "properties": {"score": {"type": "integer"}}}
-        result, _ = self._call({"model": "gemini-1.5-pro", "output_schema": schema})
-        assert "output_schema" in result
-
-    def test_instructions_normalized(self) -> None:
-        result, _ = self._call(
-            {"model": "gemini-1.5-pro", "instructions": "Be kind\\n"}
-        )
-        assert result["instructions"] == "Be kind\n"
-
-    def test_max_output_tokens_set(self) -> None:
-        result, _ = self._call({"model": "gemini-1.5-pro", "max_output_tokens": 512})
-        assert result["max_output_tokens"] == 512
-
-    def test_reasoning_set(self) -> None:
-        result, _ = self._call(
-            {"model": "gemini-2.0-flash-thinking", "reasoning": "high"}
-        )
-        assert result["reasoning"] == "high"
-
-
-class TestConvertJsonSchemaToGoogle:
-    def _call(self, schema: dict) -> dict:
-        mock_result = MagicMock()
-        mock_result.model_dump.return_value = {"properties": {"score": {}}}
-        with patch(
-            "app.services.assessment.mappers.genai_transformers.t_schema",
-            return_value=mock_result,
-        ):
-            from app.services.assessment.mappers import _convert_json_schema_to_google
-
-            return _convert_json_schema_to_google(schema)
-
-    def test_property_ordering_added_from_required(self) -> None:
-        schema = {
-            "type": "object",
-            "required": ["score", "reason"],
-            "properties": {"score": {}, "reason": {}},
-        }
-        result = self._call(schema)
-        assert result["propertyOrdering"] == ["score", "reason"]
-
-    def test_property_ordering_falls_back_to_keys(self) -> None:
-        schema = {"type": "object", "properties": {"a": {}, "b": {}}}
-        result = self._call(schema)
-        assert "propertyOrdering" in result
-
-
-class TestOpenAIResponseFormat:
-    def _call(self, params: dict):
-        with patch(
-            "app.services.assessment.mappers.is_reasoning_model",
-            return_value=False,
-        ):
-            return map_kaapi_to_openai_params(session=MagicMock(), kaapi_params=params)
-
-    def test_non_text_response_format_sets_text_field(self) -> None:
-        result, _ = self._call({"model": "gpt-4o", "response_format": "json_object"})
-        assert result["text"]["format"]["type"] == "json_object"
-
-
-class TestMapKaapiToAnthropicParams:
-    def _call(self, params: dict):
-        from app.services.assessment.mappers import map_kaapi_to_anthropic_params
-
-        return map_kaapi_to_anthropic_params(params)
-
-    def test_missing_model_returns_warning(self) -> None:
-        result, warnings = self._call({})
-        assert result == {}
-        assert any("model" in w for w in warnings)
-
-    def test_basic_params_mapped(self) -> None:
-        result, warnings = self._call(
-            {
-                "model": "claude-sonnet-4-6",
-                "instructions": "be brief",
-                "temperature": 0.3,
-                "max_output_tokens": 2048,
-            }
-        )
-        assert result["model"] == "claude-sonnet-4-6"
-        assert result["system"] == "be brief"
-        assert result["temperature"] == 0.3
-        assert result["max_tokens"] == 2048
-        assert warnings == []
-
-    def test_top_p_suppressed_when_temperature_present(self) -> None:
-        result, warnings = self._call(
-            {"model": "claude-sonnet-4-6", "temperature": 0.3, "top_p": 0.9}
-        )
-        assert result["temperature"] == 0.3
-        assert "top_p" not in result
-        assert any("top_p" in w for w in warnings)
-
-    def test_top_p_alone_passes_through(self) -> None:
-        result, warnings = self._call({"model": "claude-sonnet-4-6", "top_p": 0.9})
-        assert result["top_p"] == 0.9
-        assert warnings == []
-
-    def test_output_schema_maps_to_output_config(self) -> None:
-        schema = {"type": "object", "properties": {"score": {"type": "integer"}}}
-        result, _ = self._call({"model": "claude-sonnet-4-6", "output_schema": schema})
-        fmt = result["output_config"]["format"]
-        assert fmt["type"] == "json_schema"
-        assert fmt["schema"]["additionalProperties"] is False
-
-    def test_unsupported_params_warned(self) -> None:
-        result, warnings = self._call(
-            {
-                "model": "claude-sonnet-4-6",
-                "effort": "high",
-                "knowledge_base_ids": ["kb1"],
-            }
-        )
-        assert "effort" not in result
-        assert any("effort" in w for w in warnings)
-        assert any("knowledge_base_ids" in w for w in warnings)
diff --git a/backend/app/tests/assessment/test_pipeline.py b/backend/app/tests/assessment/test_pipeline.py
index fbdeb7950..a41b5095d 100644
--- a/backend/app/tests/assessment/test_pipeline.py
+++ b/backend/app/tests/assessment/test_pipeline.py
@@ -76,6 +76,16 @@ def test_next_stage(self) -> None:
         )
         assert next_stage(pipeline, Stage.L2_ASSESSMENT) is None
 
+    def test_no_pipeline_is_no_stages(self) -> None:
+        assert ordered_stages(None) == []
+
+    def test_batch_api_list_pipeline_names_the_bad_shape(self) -> None:
+        # The BATCH API path writes a bare list into the same JSONB column; the legacy
+        # poller used to hit `AttributeError: 'list' object has no attribute 'get'` here.
+        batch_pipeline = [{"stage": "assessment", "kind": "ASSESSMENT"}]
+        with pytest.raises(ValueError, match="got list"):
+            ordered_stages(batch_pipeline)
+
 
 class TestAdvanceOrFinalize:
     def test_advances_to_next_pending_stage(self) -> None:
diff --git a/backend/app/tests/assessment/test_prefilter_batching.py b/backend/app/tests/assessment/test_prefilter_batching.py
index a8081491c..367f5f7b4 100644
--- a/backend/app/tests/assessment/test_prefilter_batching.py
+++ b/backend/app/tests/assessment/test_prefilter_batching.py
@@ -2,6 +2,7 @@
 
 from contextlib import contextmanager
 from types import SimpleNamespace
+from uuid import UUID
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -101,7 +102,9 @@ def _ctx(self, accepted):
                 "_resolve_run_context",
                 return_value=(assessment, MagicMock(), SimpleNamespace(), None),
             ),
-            patch.object(tasks, "_load_dataset_rows", return_value=[{"a": "1"}] * 3),
+            patch.object(
+                tasks, "load_submission_file_rows", return_value=[{"a": "1"}] * 3
+            ),
             patch.object(tasks, "_accepted_indices", return_value=accepted),
             patch.object(tasks, "recompute_assessment_status"),
         ]
@@ -160,7 +163,9 @@ def test_prefilter_rewrites_gcs_attachments_before_submit(self) -> None:
                 "_resolve_run_context",
                 return_value=(assessment, MagicMock(), SimpleNamespace(), None),
             ),
-            patch.object(tasks, "_load_dataset_rows", return_value=[{"a": "1"}] * 3),
+            patch.object(
+                tasks, "load_submission_file_rows", return_value=[{"a": "1"}] * 3
+            ),
             patch.object(tasks, "_accepted_indices", return_value=[0, 1, 2]),
             patch.object(tasks, "recompute_assessment_status"),
             patch.object(assessment_core, "flag_modified"),
@@ -279,9 +284,9 @@ class TestResolveRunContext:
     def test_success(self) -> None:
         session = MagicMock()
         run = _run()
-        session.get.return_value = SimpleNamespace(dataset_id=3)
+        session.get.return_value = SimpleNamespace(submission_id=UUID(int=3))
         with patch.object(
-            tasks, "get_assessment_dataset_by_id", return_value=MagicMock()
+            tasks, "get_submission_by_id", return_value=MagicMock()
         ), patch.object(
             tasks, "resolve_evaluation_config", return_value=({"x": 1}, None)
         ):
@@ -298,9 +303,9 @@ def test_missing_parent(self) -> None:
 
     def test_config_error(self) -> None:
         session = MagicMock()
-        session.get.return_value = SimpleNamespace(dataset_id=3)
+        session.get.return_value = SimpleNamespace(submission_id=UUID(int=3))
         with patch.object(
-            tasks, "get_assessment_dataset_by_id", return_value=MagicMock()
+            tasks, "get_submission_by_id", return_value=MagicMock()
         ), patch.object(
             tasks, "resolve_evaluation_config", return_value=(None, "bad config")
         ):
@@ -361,7 +366,9 @@ def test_empty_dataset_fails_run(self) -> None:
             tasks,
             "_resolve_run_context",
             return_value=(SimpleNamespace(), MagicMock(), SimpleNamespace(), None),
-        ), patch.object(tasks, "_load_dataset_rows", return_value=[]), patch.object(
+        ), patch.object(
+            tasks, "load_submission_file_rows", return_value=[]
+        ), patch.object(
             assessment_core, "flag_modified"
         ), patch.object(
             tasks, "update_assessment_run_status"
@@ -389,7 +396,7 @@ def test_submits_l2_batch(self) -> None:
                 None,
             ),
         ), patch.object(
-            tasks, "_load_dataset_rows", return_value=[{"a": "1"}] * 3
+            tasks, "load_submission_file_rows", return_value=[{"a": "1"}] * 3
         ), patch.object(
             tasks, "_accepted_indices", return_value=[0, 1]
         ), patch.object(
@@ -415,7 +422,7 @@ def test_unknown_stage_raises(self) -> None:
                 None,
             ),
         ), patch.object(
-            tasks, "_load_dataset_rows", return_value=[{"a": "1"}]
+            tasks, "load_submission_file_rows", return_value=[{"a": "1"}]
         ), patch.object(
             tasks, "_accepted_indices", return_value=[0]
         ):
diff --git a/backend/app/tests/assessment/test_result_files.py b/backend/app/tests/assessment/test_result_files.py
new file mode 100644
index 000000000..3a9629a1e
--- /dev/null
+++ b/backend/app/tests/assessment/test_result_files.py
@@ -0,0 +1,546 @@
+"""Tests for the durable result-file dumps (app/services/assessment/api/result_files.py).
+
+Real assessment/execution/batch_job rows on the transactional session; object storage
+and the provider client are the only seams stubbed.
+"""
+
+import json
+from datetime import datetime, timedelta
+from unittest.mock import MagicMock, patch
+
+from app.core.util import now
+from app.crud.assessment import api
+from app.models.assessment import AssessmentMethod, BatchRunState
+from app.models.batch_job import BatchJob, BatchJobType
+from app.models.config.assessment_blob import AssessmentConfigBlob
+from app.models.config.config import ConfigTag
+from app.services.assessment.api.batch import ApiStage
+from app.services.assessment.api.result_files import (
+    build_and_upload_errors,
+    build_callback_metadata,
+    finalize_result_files,
+    record_stage_dump,
+    stage_file_kind,
+)
+from app.tests.utils.auth import get_user_test_auth_context
+from app.tests.utils.test_data import create_test_config
+from app.tests.utils.utils import random_lower_string
+
+ONE_DAY_SECONDS = 86400
+
+_BLOB = AssessmentConfigBlob.model_validate(
+    {
+        "input_schema": {"a": {"type": "text"}},
+        "assessment": {
+            "provider": "openai",
+            "type": "text",
+            "params": {"model": "gpt-4o", "submission": "assess {a}"},
+        },
+    }
+)
+
+
+def _bag(**overrides) -> BatchRunState:
+    bag: dict = {
+        "pipeline": [{"stage": ApiStage.ASSESSMENT.value, "kind": "ASSESSMENT"}],
+        "stage": ApiStage.ASSESSMENT.value,
+        "stage_status": "COMPLETED",
+        "stage_batches": {},
+        "stage_output_urls": {},
+        "verdicts": {},
+        "counters": {},
+        "gate_passed": [True],
+        "provider": "openai",
+        "model": "gpt-4o",
+        "input_schema": None,
+        "callback_url": "",
+        "request_metadata": None,
+    }
+    bag.update(overrides)
+    return bag  # type: ignore[return-value]
+
+
+def _seed(db, auth, *, rows: int = 1):
+    assessment = api.create_assessment(
+        session=db,
+        method=AssessmentMethod.BATCH,
+        input={"data": [{"a": str(i)} for i in range(rows)]},
+        organization_id=auth.organization_id,
+        project_id=auth.project_id,
+    )
+    config = create_test_config(
+        db,
+        project_id=auth.project_id,
+        name=f"assess-{random_lower_string()}",
+        config_blob=_BLOB,
+        tag=ConfigTag.ASSESSMENT,
+    )
+    execution = api.create_execution(
+        session=db,
+        assessment_id=assessment.id,
+        config_id=config.id,
+        config_version=1,
+        total_items=rows,
+    )
+    return assessment, execution
+
+
+def _batch_job(db, auth, **kwargs) -> BatchJob:
+    job = BatchJob(
+        provider="openai",
+        job_type=BatchJobType.ASSESSMENT.value,
+        organization_id=auth.organization_id,
+        project_id=auth.project_id,
+        total_items=1,
+        **kwargs,
+    )
+    db.add(job)
+    db.commit()
+    db.refresh(job)
+    return job
+
+
+class _Uploads:
+    """Records every errors.jsonl upload instead of writing to object storage."""
+
+    def __init__(self, url: str | None = "s3://bucket/errors.jsonl") -> None:
+        self.url = url
+        self.calls: list[dict] = []
+
+    def __call__(self, *, storage, results, filename, subdirectory) -> str | None:
+        self.calls.append(
+            {
+                "rows": list(results),
+                "filename": filename,
+                "subdirectory": subdirectory,
+            }
+        )
+        return self.url
+
+    @property
+    def rows(self) -> list[dict]:
+        return self.calls[-1]["rows"]
+
+
+def _storage_patch(storage: MagicMock | None = None):
+    return patch(
+        "app.services.assessment.api.result_files.get_cloud_storage",
+        return_value=storage or MagicMock(),
+    )
+
+
+def _upload_patch(uploads: _Uploads):
+    return patch(
+        "app.services.assessment.api.result_files.upload_jsonl_to_object_store",
+        new=uploads,
+    )
+
+
+class TestStageFileKind:
+    def test_assessment_stage_is_the_runs_results(self) -> None:
+        assert stage_file_kind(ApiStage.ASSESSMENT.value) == "results"
+
+    def test_prefilter_stage_is_suffixed(self) -> None:
+        assert stage_file_kind(ApiStage.TOPIC_RELEVANCE.value) == (
+            "topic_relevance_results"
+        )
+
+
+class TestRecordStageDump:
+    def test_dump_is_on_the_parent_row_before_any_terminal_state(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, _ = _seed(db, auth)
+
+        record_stage_dump(
+            session=db,
+            assessment=assessment,
+            stage=ApiStage.TOPIC_RELEVANCE.value,
+            url="s3://bucket/batch-1170/output.jsonl",
+        )
+
+        db.refresh(assessment)
+        assert assessment.result_files == {
+            "topic_relevance_results": {
+                "object_store_url": "s3://bucket/batch-1170/output.jsonl",
+            }
+        }
+
+    def test_missing_url_records_nothing(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, _ = _seed(db, auth)
+
+        record_stage_dump(
+            session=db,
+            assessment=assessment,
+            stage=ApiStage.ASSESSMENT.value,
+            url=None,
+        )
+
+        db.refresh(assessment)
+        assert assessment.result_files == {}
+
+
+class TestBuildAndUploadErrors:
+    def test_clean_success_still_uploads_an_empty_file(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth)
+        uploads = _Uploads()
+
+        with _storage_patch(), _upload_patch(uploads):
+            url = build_and_upload_errors(
+                session=db,
+                execution=execution,
+                assessment=assessment,
+                bag=_bag(),
+                failure_message=None,
+            )
+
+        assert url == "s3://bucket/errors.jsonl"
+        assert uploads.rows == []
+        assert uploads.calls[0]["filename"] == "errors.jsonl"
+        assert uploads.calls[0]["subdirectory"] == f"assessment/{assessment.id}"
+
+    def test_row_errors_are_flattened_per_stage(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth, rows=2)
+        uploads = _Uploads()
+        bag = _bag(
+            stage_errors={ApiStage.ASSESSMENT.value: {"1": "rate limit exceeded"}}
+        )
+
+        with _storage_patch(), _upload_patch(uploads):
+            build_and_upload_errors(
+                session=db,
+                execution=execution,
+                assessment=assessment,
+                bag=bag,
+                failure_message=None,
+            )
+        assert uploads.rows == [
+            {
+                "type": "row_error",
+                "stage": ApiStage.ASSESSMENT.value,
+                "row_index": 1,
+                "error": "rate limit exceeded",
+            }
+        ]
+
+    def test_openai_error_file_lines_become_rows(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth)
+        job = _batch_job(db, auth, provider_error_file_id="file-err-1")
+        uploads = _Uploads()
+        error_file = (
+            json.dumps({"custom_id": "row_0", "error": {"message": "bad request"}})
+            + "\n"
+            + json.dumps({"custom_id": "row_3", "error": {"message": "too long"}})
+            + "\n"
+        )
+        provider = MagicMock()
+        provider.download_file.return_value = error_file
+
+        with (
+            _storage_patch(),
+            _upload_patch(uploads),
+            patch(
+                "app.services.assessment.api.result_files._build_batch_provider",
+                return_value=provider,
+            ),
+        ):
+            build_and_upload_errors(
+                session=db,
+                execution=execution,
+                assessment=assessment,
+                bag=_bag(stage_batches={ApiStage.ASSESSMENT.value: job.id}),
+                failure_message=None,
+            )
+        assert [row["type"] for row in uploads.rows] == [
+            "provider_error_file",
+            "provider_error_file",
+        ]
+        assert [row["entry"]["custom_id"] for row in uploads.rows] == [
+            "row_0",
+            "row_3",
+        ]
+        assert uploads.rows[0]["provider_error_file_id"] == "file-err-1"
+        provider.download_file.assert_called_once_with("file-err-1")
+
+    def test_unreadable_error_file_degrades_to_one_row(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth)
+        job = _batch_job(db, auth, provider_error_file_id="file-err-2")
+        uploads = _Uploads()
+        provider = MagicMock()
+        provider.download_file.side_effect = RuntimeError("404 file expired")
+
+        with (
+            _storage_patch(),
+            _upload_patch(uploads),
+            patch(
+                "app.services.assessment.api.result_files._build_batch_provider",
+                return_value=provider,
+            ),
+        ):
+            build_and_upload_errors(
+                session=db,
+                execution=execution,
+                assessment=assessment,
+                bag=_bag(stage_batches={ApiStage.ASSESSMENT.value: job.id}),
+                failure_message=None,
+            )
+        row = uploads.rows[0]
+        assert row["type"] == "provider_error_file_unavailable"
+        assert row["provider_error_file_id"] == "file-err-2"
+        assert "404 file expired" in row["error"]
+
+    def test_batch_without_an_error_file_contributes_nothing(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth)
+        job = _batch_job(db, auth)  # Anthropic/Gemini report errors inline, no file id
+        uploads = _Uploads()
+
+        with _storage_patch(), _upload_patch(uploads):
+            build_and_upload_errors(
+                session=db,
+                execution=execution,
+                assessment=assessment,
+                bag=_bag(stage_batches={ApiStage.ASSESSMENT.value: job.id}),
+                failure_message=None,
+            )
+
+    def test_storage_outage_yields_no_url(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth)
+
+        with patch(
+            "app.services.assessment.api.result_files.get_cloud_storage",
+            side_effect=RuntimeError("s3 unreachable"),
+        ):
+            url = build_and_upload_errors(
+                session=db,
+                execution=execution,
+                assessment=assessment,
+                bag=_bag(),
+                failure_message="kaboom",
+            )
+
+        assert url is None
+
+
+class TestFinalizeResultFiles:
+    def test_pre_provider_failure_records_only_a_synthetic_execution_error(
+        self, db
+    ) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth)
+        uploads = _Uploads()
+
+        with _storage_patch(), _upload_patch(uploads):
+            finalize_result_files(
+                session=db,
+                execution=execution,
+                assessment=assessment,
+                bag=_bag(),
+                failure_message="Vertex model gemini-2.5-pro not found",
+            )
+
+        db.refresh(assessment)
+        assert set(assessment.result_files) == {"errors"}
+        assert assessment.result_files["errors"] == {
+            "object_store_url": "s3://bucket/errors.jsonl",
+        }
+        assert uploads.rows == [
+            {
+                "type": "execution_error",
+                "stage": ApiStage.ASSESSMENT.value,
+                "error": "Vertex model gemini-2.5-pro not found",
+            }
+        ]
+
+    def test_completed_run_carries_both_a_results_and_an_errors_record(
+        self, db
+    ) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth, rows=2)
+        record_stage_dump(
+            session=db,
+            assessment=assessment,
+            stage=ApiStage.ASSESSMENT.value,
+            url="s3://bucket/batch-1173/output.jsonl",
+        )
+        uploads = _Uploads()
+
+        with _storage_patch(), _upload_patch(uploads):
+            finalize_result_files(
+                session=db,
+                execution=execution,
+                assessment=assessment,
+                bag=_bag(
+                    stage_output_urls={
+                        ApiStage.ASSESSMENT.value: "s3://bucket/batch-1173/output.jsonl"
+                    }
+                ),
+            )
+
+        db.refresh(assessment)
+        assert assessment.result_files == {
+            "results": {"object_store_url": "s3://bucket/batch-1173/output.jsonl"},
+            "errors": {"object_store_url": "s3://bucket/errors.jsonl"},
+        }
+
+    def test_prefilter_and_assessment_dumps_coexist(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth, rows=2)
+        uploads = _Uploads()
+        bag = _bag(
+            stage_output_urls={
+                ApiStage.TOPIC_RELEVANCE.value: "s3://bucket/batch-1170/output.jsonl",
+                ApiStage.ASSESSMENT.value: "s3://bucket/batch-1173/output.jsonl",
+            },
+            counters={
+                ApiStage.TOPIC_RELEVANCE.value: {
+                    "total": 2,
+                    "passed": 1,
+                    "rejected": 1,
+                },
+                ApiStage.ASSESSMENT.value: {"total": 1, "passed": 1, "rejected": 0},
+            },
+        )
+
+        with _storage_patch(), _upload_patch(uploads):
+            finalize_result_files(
+                session=db, execution=execution, assessment=assessment, bag=bag
+            )
+
+        db.refresh(assessment)
+        assert set(assessment.result_files) == {
+            "topic_relevance_results",
+            "results",
+            "errors",
+        }
+        assert "topic_relevance_results" in assessment.result_files
+
+    def test_a_second_tick_does_not_duplicate_or_lose_records(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth)
+        uploads = _Uploads()
+        bag = _bag(
+            stage_output_urls={
+                ApiStage.ASSESSMENT.value: "s3://bucket/batch-1173/output.jsonl"
+            }
+        )
+
+        with _storage_patch(), _upload_patch(uploads):
+            finalize_result_files(
+                session=db, execution=execution, assessment=assessment, bag=bag
+            )
+            finalize_result_files(
+                session=db, execution=execution, assessment=assessment, bag=bag
+            )
+
+        db.refresh(assessment)
+        assert set(assessment.result_files) == {"results", "errors"}
+
+    def test_upload_failure_does_not_raise_into_the_terminal_path(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, execution = _seed(db, auth)
+
+        with (
+            _storage_patch(),
+            patch(
+                "app.services.assessment.api.result_files."
+                "upload_jsonl_to_object_store",
+                side_effect=RuntimeError("bucket write denied"),
+            ),
+        ):
+            finalize_result_files(
+                session=db,
+                execution=execution,
+                assessment=assessment,
+                bag=_bag(
+                    stage_output_urls={
+                        ApiStage.ASSESSMENT.value: "s3://bucket/out.jsonl"
+                    }
+                ),
+            )
+
+        db.refresh(assessment)
+        assert assessment.result_files == {}
+
+
+class TestBuildCallbackMetadata:
+    def _signing_storage(self, failing_url: str | None = None) -> MagicMock:
+        storage = MagicMock()
+
+        def sign(url, expires_in):
+            if url == failing_url:
+                raise RuntimeError("presign refused")
+            return f"https://signed.example/{url}?exp={expires_in}"
+
+        storage.get_signed_url.side_effect = sign
+        return storage
+
+    def test_every_kind_is_signed(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, _ = _seed(db, auth)
+        api.set_result_files(
+            session=db,
+            assessment=assessment,
+            files={
+                "results": {"object_store_url": "s3://bucket/out.jsonl"},
+                "errors": {"object_store_url": "s3://bucket/errors.jsonl"},
+            },
+        )
+
+        with _storage_patch(self._signing_storage()):
+            metadata = build_callback_metadata(session=db, assessment=assessment)
+
+        assert metadata["result_files"]["results"] == {
+            "signed_url": f"https://signed.example/s3://bucket/out.jsonl?exp={ONE_DAY_SECONDS}",
+        }
+
+    def test_expires_at_is_one_day_out(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, _ = _seed(db, auth)
+
+        with _storage_patch(self._signing_storage()):
+            metadata = build_callback_metadata(session=db, assessment=assessment)
+
+        expires_at = datetime.fromisoformat(metadata["expires_at"])
+        assert timedelta(hours=23, minutes=59) < expires_at - now() <= timedelta(days=1)
+
+    def test_a_failing_presign_drops_only_its_own_kind(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, _ = _seed(db, auth)
+        api.set_result_files(
+            session=db,
+            assessment=assessment,
+            files={
+                "results": {"object_store_url": "s3://bucket/out.jsonl"},
+                "errors": {"object_store_url": "s3://bucket/errors.jsonl"},
+            },
+        )
+
+        with _storage_patch(self._signing_storage(failing_url="s3://bucket/out.jsonl")):
+            metadata = build_callback_metadata(session=db, assessment=assessment)
+
+        assert set(metadata["result_files"]) == {"errors"}
+        assert metadata["expires_at"]
+
+    def test_storage_outage_still_returns_the_envelope_keys(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assessment, _ = _seed(db, auth)
+        api.set_result_files(
+            session=db,
+            assessment=assessment,
+            files={"results": {"object_store_url": "s3://bucket/out.jsonl"}},
+        )
+
+        with patch(
+            "app.services.assessment.api.result_files.get_cloud_storage",
+            side_effect=RuntimeError("s3 unreachable"),
+        ):
+            metadata = build_callback_metadata(session=db, assessment=assessment)
+
+        assert metadata["result_files"] == {}
+        assert metadata["expires_at"]
diff --git a/backend/app/tests/assessment/test_routes.py b/backend/app/tests/assessment/test_routes.py
index a2fdf9a65..92d7fe497 100644
--- a/backend/app/tests/assessment/test_routes.py
+++ b/backend/app/tests/assessment/test_routes.py
@@ -3,7 +3,7 @@
 from datetime import datetime
 from types import SimpleNamespace
 from unittest.mock import MagicMock, patch
-from uuid import UUID
+from uuid import UUID, uuid4
 
 import pytest
 from fastapi import HTTPException
@@ -16,7 +16,7 @@
     retry_assessment,
 )
 from app.api.routes.assessment.datasets import (
-    _dataset_to_response,
+    _submission_to_response,
     delete_dataset,
     get_dataset,
     list_datasets,
@@ -47,13 +47,13 @@ def _auth_context() -> SimpleNamespace:
     )
 
 
-def _dataset() -> SimpleNamespace:
+def _submission() -> SimpleNamespace:
     return SimpleNamespace(
-        id=7,
+        id=UUID(int=7),
         name="ds",
         description="d",
-        dataset_metadata={"total_items_count": 2, "file_extension": ".csv"},
-        object_store_url="s3://x",
+        total_items=2,
+        object_store_url="s3://x/ds.csv",
     )
 
 
@@ -61,7 +61,8 @@ def _assessment() -> SimpleNamespace:
     return SimpleNamespace(
         id=10,
         experiment_name="exp",
-        dataset_id=7,
+        method="RUN",
+        submission_id=UUID(int=7),
         status="processing",
         organization_id=1,
         project_id=1,
@@ -111,9 +112,9 @@ def _row(execution_id: int = 22) -> AssessmentExportRow:
 
 
 class TestRouteHelpers:
-    def test_dataset_to_response(self) -> None:
-        resp = _dataset_to_response(_dataset(), signed_url="signed")
-        assert resp.dataset_id == 7
+    def test_submission_to_response(self) -> None:
+        resp = _submission_to_response(_submission(), signed_url="signed")
+        assert resp.submission_id == UUID(int=7)
         assert resp.signed_url == "signed"
 
 
@@ -123,8 +124,8 @@ def test_dataset_to_response(self) -> None:
 class TestDatasetRoutes:
     def test_list_datasets(self) -> None:
         with patch(
-            "app.api.routes.assessment.datasets.list_assessment_datasets",
-            return_value=[_dataset()],
+            "app.api.routes.assessment.datasets.list_submissions",
+            return_value=[_submission()],
         ):
             resp = list_datasets(session=MagicMock(), auth_context=_auth_context())
         assert resp.success is True
@@ -132,26 +133,30 @@ def test_list_datasets(self) -> None:
 
     def test_get_dataset_not_found(self) -> None:
         with patch(
-            "app.api.routes.assessment.datasets.get_assessment_dataset_by_id",
+            "app.api.routes.assessment.datasets.get_submission_by_id",
             side_effect=HTTPException(
                 status_code=404,
                 detail="Dataset 1 not found or not accessible",
             ),
         ):
             with pytest.raises(HTTPException, match="not found"):
-                get_dataset(1, session=MagicMock(), auth_context=_auth_context())
+                get_dataset(uuid4(), session=MagicMock(), auth_context=_auth_context())
 
     def test_get_dataset_with_signed_url(self) -> None:
         storage = MagicMock()
         storage.get_signed_url.return_value = "signed-url"
-        with patch(
-            "app.api.routes.assessment.datasets.get_assessment_dataset_by_id",
-            return_value=_dataset(),
-        ), patch(
-            "app.api.routes.assessment.datasets.get_cloud_storage", return_value=storage
+        with (
+            patch(
+                "app.api.routes.assessment.datasets.get_submission_by_id",
+                return_value=_submission(),
+            ),
+            patch(
+                "app.api.routes.assessment.datasets.get_cloud_storage",
+                return_value=storage,
+            ),
         ):
             resp = get_dataset(
-                7,
+                uuid4(),
                 session=MagicMock(),
                 auth_context=_auth_context(),
                 include_signed_url=True,
@@ -161,15 +166,18 @@ def test_get_dataset_with_signed_url(self) -> None:
         assert resp.data.signed_url == "signed-url"
 
     def test_get_dataset_with_limit_rows_includes_preview(self) -> None:
-        with patch(
-            "app.api.routes.assessment.datasets.get_assessment_dataset_by_id",
-            return_value=_dataset(),
-        ), patch(
-            "app.api.routes.assessment.datasets.preview_assessment_dataset",
-            return_value=(["a", "b"], [["1", "2"], ["3", "4"]]),
-        ) as preview_mock:
+        with (
+            patch(
+                "app.api.routes.assessment.datasets.get_submission_by_id",
+                return_value=_submission(),
+            ),
+            patch(
+                "app.api.routes.assessment.datasets.preview_submission",
+                return_value=(["a", "b"], [["1", "2"], ["3", "4"]]),
+            ) as preview_mock,
+        ):
             resp = get_dataset(
-                7,
+                uuid4(),
                 session=MagicMock(),
                 auth_context=_auth_context(),
                 limit_rows=2,
@@ -182,37 +190,52 @@ def test_get_dataset_with_limit_rows_includes_preview(self) -> None:
         assert resp.data.preview.truncated is True
 
     def test_get_dataset_without_limit_rows_skips_preview(self) -> None:
-        with patch(
-            "app.api.routes.assessment.datasets.get_assessment_dataset_by_id",
-            return_value=_dataset(),
-        ), patch(
-            "app.api.routes.assessment.datasets.preview_assessment_dataset"
-        ) as preview_mock:
-            resp = get_dataset(7, session=MagicMock(), auth_context=_auth_context())
+        with (
+            patch(
+                "app.api.routes.assessment.datasets.get_submission_by_id",
+                return_value=_submission(),
+            ),
+            patch(
+                "app.api.routes.assessment.datasets.preview_submission"
+            ) as preview_mock,
+        ):
+            resp = get_dataset(
+                uuid4(), session=MagicMock(), auth_context=_auth_context()
+            )
         preview_mock.assert_not_called()
         assert resp.data is not None
         assert resp.data.preview is None
 
     def test_delete_dataset_success_and_error(self) -> None:
-        with patch(
-            "app.api.routes.assessment.datasets.get_assessment_dataset_by_id",
-            return_value=_dataset(),
-        ), patch(
-            "app.api.routes.assessment.datasets.delete_assessment_dataset",
-            return_value=None,
+        with (
+            patch(
+                "app.api.routes.assessment.datasets.get_submission_by_id",
+                return_value=_submission(),
+            ),
+            patch(
+                "app.api.routes.assessment.datasets.delete_submission",
+                return_value=None,
+            ),
         ):
-            resp = delete_dataset(7, session=MagicMock(), auth_context=_auth_context())
+            resp = delete_dataset(
+                uuid4(), session=MagicMock(), auth_context=_auth_context()
+            )
         assert resp.success is True
 
-        with patch(
-            "app.api.routes.assessment.datasets.get_assessment_dataset_by_id",
-            return_value=_dataset(),
-        ), patch(
-            "app.api.routes.assessment.datasets.delete_assessment_dataset",
-            return_value="cannot delete",
+        with (
+            patch(
+                "app.api.routes.assessment.datasets.get_submission_by_id",
+                return_value=_submission(),
+            ),
+            patch(
+                "app.api.routes.assessment.datasets.delete_submission",
+                return_value="cannot delete",
+            ),
         ):
             with pytest.raises(HTTPException, match="cannot delete"):
-                delete_dataset(7, session=MagicMock(), auth_context=_auth_context())
+                delete_dataset(
+                    uuid4(), session=MagicMock(), auth_context=_auth_context()
+                )
 
 
 # ─── Runs — POST + retry ─────────────────────────────────────────────────────
@@ -222,7 +245,7 @@ class TestRunRoutes:
     def test_create_assessment_runs(self) -> None:
         request = AssessmentRunCreate(
             experiment_name="exp",
-            dataset_id=7,
+            submission_id=UUID(int=7),
             input_binding=InputBinding(prompt="p", text_columns=[], attachments=[]),
             configs=[
                 AssessmentConfigRef(
@@ -233,8 +256,8 @@ def test_create_assessment_runs(self) -> None:
         result = SimpleNamespace(
             assessment_id=10,
             experiment_name="exp",
-            dataset_id=7,
-            dataset_name="ds",
+            submission_id=UUID(int=7),
+            submission_name="ds",
             num_configs=1,
             runs=[],
         )
@@ -250,29 +273,35 @@ def test_retry_endpoints(self) -> None:
         result = SimpleNamespace(
             assessment_id=10,
             experiment_name="exp",
-            dataset_id=7,
-            dataset_name="ds",
+            submission_id=UUID(int=7),
+            submission_name="ds",
             num_configs=1,
             runs=[],
         )
-        with patch(
-            "app.api.routes.assessment.assessments.get_assessment_by_id",
-            return_value=_assessment(),
-        ), patch(
-            "app.api.routes.assessment.assessments.retry_assessment_service",
-            return_value=result,
+        with (
+            patch(
+                "app.api.routes.assessment.assessments.get_assessment_by_id",
+                return_value=_assessment(),
+            ),
+            patch(
+                "app.api.routes.assessment.assessments.retry_assessment_service",
+                return_value=result,
+            ),
         ):
             resp = retry_assessment(
                 10, session=MagicMock(), auth_context=_auth_context()
             )
         assert resp.success is True
 
-        with patch(
-            "app.api.routes.assessment.runs.get_run_by_id",
-            return_value=_run(),
-        ), patch(
-            "app.api.routes.assessment.runs.retry_run",
-            return_value=result,
+        with (
+            patch(
+                "app.api.routes.assessment.runs.get_run_by_id",
+                return_value=_run(),
+            ),
+            patch(
+                "app.api.routes.assessment.runs.retry_run",
+                return_value=result,
+            ),
         ):
             resp = retry_assessment_run(
                 22, session=MagicMock(), auth_context=_auth_context()
@@ -286,12 +315,15 @@ def test_retry_endpoints(self) -> None:
 class TestAssessmentAndRunRoutes:
     def test_list_and_get_assessments(self) -> None:
         public_stub = MagicMock()
-        with patch(
-            "app.api.routes.assessment.assessments.list_assessments_crud",
-            return_value=[_assessment()],
-        ), patch(
-            "app.api.routes.assessment.assessments._build_assessment_public",
-            return_value=public_stub,
+        with (
+            patch(
+                "app.api.routes.assessment.assessments.list_assessments_crud",
+                return_value=[_assessment()],
+            ),
+            patch(
+                "app.api.routes.assessment.assessments._build_assessment_public",
+                return_value=public_stub,
+            ),
         ):
             resp = list_assessments(
                 session=MagicMock(),
@@ -300,12 +332,15 @@ def test_list_and_get_assessments(self) -> None:
         assert resp.success is True
         assert len(resp.data or []) == 1
 
-        with patch(
-            "app.api.routes.assessment.assessments.get_assessment_by_id",
-            return_value=_assessment(),
-        ), patch(
-            "app.api.routes.assessment.assessments._build_assessment_public",
-            return_value=public_stub,
+        with (
+            patch(
+                "app.api.routes.assessment.assessments.get_assessment_by_id",
+                return_value=_assessment(),
+            ),
+            patch(
+                "app.api.routes.assessment.assessments._build_assessment_public",
+                return_value=public_stub,
+            ),
         ):
             resp = get_assessment(
                 10,
@@ -325,24 +360,30 @@ def test_list_and_get_assessments(self) -> None:
 
     def test_list_and_get_runs(self) -> None:
         public_stub = MagicMock()
-        with patch(
-            "app.api.routes.assessment.runs.list_runs",
-            return_value=[_run()],
-        ), patch(
-            "app.api.routes.assessment.runs._build_run_public",
-            return_value=public_stub,
+        with (
+            patch(
+                "app.api.routes.assessment.runs.list_runs",
+                return_value=[_run()],
+            ),
+            patch(
+                "app.api.routes.assessment.runs._build_run_public",
+                return_value=public_stub,
+            ),
         ):
             resp = list_assessment_runs(
                 session=MagicMock(), auth_context=_auth_context()
             )
         assert resp.success is True
 
-        with patch(
-            "app.api.routes.assessment.runs.get_run_by_id",
-            return_value=_run(),
-        ), patch(
-            "app.api.routes.assessment.runs._build_run_public",
-            return_value=public_stub,
+        with (
+            patch(
+                "app.api.routes.assessment.runs.get_run_by_id",
+                return_value=_run(),
+            ),
+            patch(
+                "app.api.routes.assessment.runs._build_run_public",
+                return_value=public_stub,
+            ),
         ):
             resp = get_assessment_run(
                 22, session=MagicMock(), auth_context=_auth_context()
@@ -367,16 +408,20 @@ def test_list_and_get_runs(self) -> None:
 class TestExportRoutes:
     def test_export_assessment_results_delegates_to_util(self) -> None:
         """Parent export route delegates JSON/single-file/ZIP packaging to utils."""
-        with patch(
-            "app.api.routes.assessment.assessments.get_assessment_by_id",
-            return_value=_assessment(),
-        ), patch(
-            "app.api.routes.assessment.assessments.get_assessment_runs_for_assessment",
-            return_value=[_run()],
-        ), patch(
-            "app.api.routes.assessment.assessments.build_assessment_results_response",
-            return_value="stub-response",
-        ) as build:
+        with (
+            patch(
+                "app.api.routes.assessment.assessments.get_assessment_by_id",
+                return_value=_assessment(),
+            ),
+            patch(
+                "app.api.routes.assessment.assessments.get_assessment_runs_for_assessment",
+                return_value=[_run()],
+            ),
+            patch(
+                "app.api.routes.assessment.assessments.build_assessment_results_response",
+                return_value="stub-response",
+            ) as build,
+        ):
             result = export_assessment_results(
                 10,
                 session=MagicMock(),
@@ -388,21 +433,27 @@ def test_export_assessment_results_delegates_to_util(self) -> None:
 
     def test_export_assessment_run_results_json_and_file(self) -> None:
         run = _run()
-        with patch(
-            "app.api.routes.assessment.runs.get_run_by_id",
-            return_value=run,
-        ), patch(
-            "app.api.routes.assessment.runs.get_assessment_by_id",
-            return_value=_assessment(),
-        ), patch(
-            "app.api.routes.assessment.runs.load_export_rows_for_run",
-            return_value=[_row()],
-        ), patch(
-            "app.api.routes.assessment.runs.sort_export_rows",
-            side_effect=lambda rows: rows,
-        ), patch(
-            "app.api.routes.assessment.runs.build_json_export_rows",
-            return_value=[{"x": 1}],
+        with (
+            patch(
+                "app.api.routes.assessment.runs.get_run_by_id",
+                return_value=run,
+            ),
+            patch(
+                "app.api.routes.assessment.runs.get_assessment_by_id",
+                return_value=_assessment(),
+            ),
+            patch(
+                "app.api.routes.assessment.runs.load_export_rows_for_run",
+                return_value=[_row()],
+            ),
+            patch(
+                "app.api.routes.assessment.runs.sort_export_rows",
+                side_effect=lambda rows: rows,
+            ),
+            patch(
+                "app.api.routes.assessment.runs.build_json_export_rows",
+                return_value=[{"x": 1}],
+            ),
         ):
             json_resp = export_assessment_run_results(
                 22,
@@ -412,21 +463,27 @@ def test_export_assessment_run_results_json_and_file(self) -> None:
             )
         assert json_resp.success is True
 
-        with patch(
-            "app.api.routes.assessment.runs.get_run_by_id",
-            return_value=run,
-        ), patch(
-            "app.api.routes.assessment.runs.get_assessment_by_id",
-            return_value=_assessment(),
-        ), patch(
-            "app.api.routes.assessment.runs.load_export_rows_for_run",
-            return_value=[_row()],
-        ), patch(
-            "app.api.routes.assessment.runs.sort_export_rows",
-            side_effect=lambda rows: rows,
-        ), patch(
-            "app.api.routes.assessment.runs.build_export_response",
-            return_value=StreamingResponse(iter([b"x"])),
+        with (
+            patch(
+                "app.api.routes.assessment.runs.get_run_by_id",
+                return_value=run,
+            ),
+            patch(
+                "app.api.routes.assessment.runs.get_assessment_by_id",
+                return_value=_assessment(),
+            ),
+            patch(
+                "app.api.routes.assessment.runs.load_export_rows_for_run",
+                return_value=[_row()],
+            ),
+            patch(
+                "app.api.routes.assessment.runs.sort_export_rows",
+                side_effect=lambda rows: rows,
+            ),
+            patch(
+                "app.api.routes.assessment.runs.build_export_response",
+                return_value=StreamingResponse(iter([b"x"])),
+            ),
         ):
             file_resp = export_assessment_run_results(
                 22,
@@ -474,15 +531,19 @@ def test_json_returns_apiresponse(self) -> None:
             build_assessment_results_response,
         )
 
-        with patch(
-            "app.services.assessment.utils.export.load_export_rows_for_run",
-            return_value=[_row()],
-        ), patch(
-            "app.services.assessment.utils.export.sort_export_rows",
-            side_effect=lambda rows: rows,
-        ), patch(
-            "app.services.assessment.utils.export.build_json_export_rows",
-            return_value=[{"x": 1}],
+        with (
+            patch(
+                "app.services.assessment.utils.export.load_export_rows_for_run",
+                return_value=[_row()],
+            ),
+            patch(
+                "app.services.assessment.utils.export.sort_export_rows",
+                side_effect=lambda rows: rows,
+            ),
+            patch(
+                "app.services.assessment.utils.export.build_json_export_rows",
+                return_value=[{"x": 1}],
+            ),
         ):
             resp = build_assessment_results_response(
                 session=MagicMock(),
@@ -502,18 +563,23 @@ def test_csv_multi_run_returns_zip(self) -> None:
         run2.id = 23
         run2.config_version = 2
 
-        with patch(
-            "app.services.assessment.utils.export.load_export_rows_for_run",
-            side_effect=[[_row(execution_id=22)], [_row(execution_id=23)]],
-        ), patch(
-            "app.services.assessment.utils.export.sort_export_rows",
-            side_effect=lambda rows: rows,
-        ), patch(
-            "app.services.assessment.utils.export.serialize_export_rows",
-            return_value=(b"csv", "text/csv"),
-        ), patch(
-            "app.services.assessment.utils.export.generate_timestamped_filename",
-            return_value="out.zip",
+        with (
+            patch(
+                "app.services.assessment.utils.export.load_export_rows_for_run",
+                side_effect=[[_row(execution_id=22)], [_row(execution_id=23)]],
+            ),
+            patch(
+                "app.services.assessment.utils.export.sort_export_rows",
+                side_effect=lambda rows: rows,
+            ),
+            patch(
+                "app.services.assessment.utils.export.serialize_export_rows",
+                return_value=(b"csv", "text/csv"),
+            ),
+            patch(
+                "app.services.assessment.utils.export.generate_timestamped_filename",
+                return_value="out.zip",
+            ),
         ):
             resp = build_assessment_results_response(
                 session=MagicMock(),
diff --git a/backend/app/tests/assessment/test_service.py b/backend/app/tests/assessment/test_service.py
index 7460676e9..6b0508cd6 100644
--- a/backend/app/tests/assessment/test_service.py
+++ b/backend/app/tests/assessment/test_service.py
@@ -33,7 +33,7 @@
 def _make_request(provider_config_id: UUID) -> AssessmentRunCreate:
     return AssessmentRunCreate(
         experiment_name="exp-1",
-        dataset_id=7,
+        submission_id=UUID(int=7),
         input_binding=InputBinding(
             prompt="Answer: {question}",
             text_columns=["question"],
@@ -80,7 +80,7 @@ def test_dataset_not_found(self) -> None:
         session = MagicMock()
         request = _make_request(UUID("00000000-0000-0000-0000-000000000001"))
         with patch(
-            "app.services.assessment.service.get_assessment_dataset_by_id",
+            "app.services.assessment.service.get_submission_by_id",
             side_effect=HTTPException(
                 status_code=404,
                 detail="Dataset 7 not found or not accessible",
@@ -99,7 +99,7 @@ def test_config_resolution_failure(self) -> None:
         request = _make_request(UUID("00000000-0000-0000-0000-000000000001"))
         with (
             patch(
-                "app.services.assessment.service.get_assessment_dataset_by_id",
+                "app.services.assessment.service.get_submission_by_id",
                 return_value=_make_dataset(),
             ),
             patch(
@@ -123,7 +123,7 @@ def test_rejects_unsupported_provider(self) -> None:
 
         with (
             patch(
-                "app.services.assessment.service.get_assessment_dataset_by_id",
+                "app.services.assessment.service.get_submission_by_id",
                 return_value=_make_dataset(),
             ),
             patch(
@@ -159,7 +159,7 @@ def test_google_provider_is_supported(self) -> None:
 
         with (
             patch(
-                "app.services.assessment.service.get_assessment_dataset_by_id",
+                "app.services.assessment.service.get_submission_by_id",
                 return_value=dataset,
             ),
             patch(
@@ -215,7 +215,7 @@ def test_supported_batch_providers_are_accepted(self, provider: str) -> None:
 
         with (
             patch(
-                "app.services.assessment.service.get_assessment_dataset_by_id",
+                "app.services.assessment.service.get_submission_by_id",
                 return_value=dataset,
             ),
             patch(
@@ -259,7 +259,7 @@ def test_anthropic_provider_is_supported(self) -> None:
 
         with (
             patch(
-                "app.services.assessment.service.get_assessment_dataset_by_id",
+                "app.services.assessment.service.get_submission_by_id",
                 return_value=dataset,
             ),
             patch(
@@ -303,7 +303,7 @@ def test_defaults_missing_provider_to_openai(self) -> None:
 
         with (
             patch(
-                "app.services.assessment.service.get_assessment_dataset_by_id",
+                "app.services.assessment.service.get_submission_by_id",
                 return_value=dataset,
             ),
             patch(
@@ -350,7 +350,7 @@ def test_rejects_default_tagged_config(self) -> None:
 
         with (
             patch(
-                "app.services.assessment.service.get_assessment_dataset_by_id",
+                "app.services.assessment.service.get_submission_by_id",
                 return_value=_make_dataset(),
             ),
             patch("app.services.assessment.service.ConfigCrud", return_value=crud),
@@ -388,7 +388,7 @@ def test_dispatches_one_celery_task_per_config(self) -> None:
 
         with (
             patch(
-                "app.services.assessment.service.get_assessment_dataset_by_id",
+                "app.services.assessment.service.get_submission_by_id",
                 return_value=dataset,
             ),
             patch(
@@ -428,13 +428,19 @@ def test_build_retry_request_errors_and_success(self) -> None:
 
         with pytest.raises(HTTPException, match="No assessment runs"):
             _build_retry_request(
-                experiment_name="exp", dataset_id=1, input_binding=binding, runs=[]
+                experiment_name="exp",
+                submission_id=UUID(int=1),
+                input_binding=binding,
+                runs=[],
             )
 
         run = MagicMock()
         with pytest.raises(HTTPException, match="missing for retry"):
             _build_retry_request(
-                experiment_name="exp", dataset_id=1, input_binding=None, runs=[run]
+                experiment_name="exp",
+                submission_id=UUID(int=1),
+                input_binding=None,
+                runs=[run],
             )
 
         run2 = MagicMock()
@@ -443,7 +449,10 @@ def test_build_retry_request_errors_and_success(self) -> None:
         run2.config_version = None
         with pytest.raises(HTTPException, match="Config reference is missing"):
             _build_retry_request(
-                experiment_name="exp", dataset_id=1, input_binding=binding, runs=[run2]
+                experiment_name="exp",
+                submission_id=UUID(int=1),
+                input_binding=binding,
+                runs=[run2],
             )
 
         run3 = MagicMock()
@@ -451,7 +460,10 @@ def test_build_retry_request_errors_and_success(self) -> None:
         run3.config_id = CONFIG_ID
         run3.config_version = 1
         req = _build_retry_request(
-            experiment_name="exp", dataset_id=1, input_binding=binding, runs=[run3]
+            experiment_name="exp",
+            submission_id=UUID(int=1),
+            input_binding=binding,
+            runs=[run3],
         )
         assert req.experiment_name == "exp"
         assert req.input_binding.prompt == "p"
@@ -462,7 +474,7 @@ def test_retry_assessment_wrappers(self) -> None:
         assessment = MagicMock()
         assessment.id = ASSESSMENT_ID
         assessment.experiment_name = "exp"
-        assessment.dataset_id = 7
+        assessment.submission_id = UUID(int=7)
         assessment.input = {"prompt": "p", "text_columns": [], "attachments": []}
         run = MagicMock()
         run.assessment_id = ASSESSMENT_ID
@@ -473,8 +485,8 @@ def test_retry_assessment_wrappers(self) -> None:
         result = SimpleNamespace(
             assessment_id=1,
             experiment_name="exp",
-            dataset_id=7,
-            dataset_name="ds",
+            submission_id=UUID(int=7),
+            submission_name="ds",
             num_configs=1,
             runs=[],
         )
@@ -518,7 +530,7 @@ def _failed_run(self, stage: str) -> MagicMock:
             },
         }
         run.assessment = SimpleNamespace(
-            id=ASSESSMENT_ID, experiment_name="exp", dataset_id=7
+            id=ASSESSMENT_ID, experiment_name="exp", submission_id=UUID(int=7)
         )
         return run
 
@@ -541,7 +553,7 @@ def test_resumes_in_place_from_failed_stage(self) -> None:
 
         with (
             patch(
-                "app.services.assessment.service.get_assessment_dataset_by_id",
+                "app.services.assessment.service.get_submission_by_id",
                 return_value=_make_dataset(),
             ),
             patch("app.services.assessment.service.recompute_assessment_status"),
diff --git a/backend/app/tests/assessment/test_submission.py b/backend/app/tests/assessment/test_submission.py
new file mode 100644
index 000000000..b4f9d844f
--- /dev/null
+++ b/backend/app/tests/assessment/test_submission.py
@@ -0,0 +1,392 @@
+"""Tests for assessment/submission.py upload and preview behaviour."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from fastapi import HTTPException
+from openpyxl.utils.exceptions import InvalidFileException
+
+from app.services.assessment.submission import (
+    _preview_csv,
+    _preview_excel,
+    preview_submission,
+    upload_submission,
+)
+
+
+class TestUploadSubmission:
+    def test_invalid_xlsx_returns_422(self) -> None:
+        session = MagicMock()
+        with (
+            patch(
+                "app.services.assessment.submission.sanitize_dataset_name",
+                return_value="ds-1",
+            ),
+            patch(
+                "app.services.assessment.submission.get_submission_by_name",
+                return_value=None,
+            ),
+            patch(
+                "app.services.assessment.submission.parse_rows",
+                side_effect=InvalidFileException("bad xlsx"),
+            ),
+        ):
+            with pytest.raises(HTTPException) as exc_info:
+                upload_submission(
+                    session=session,
+                    file_content=b"invalid-xlsx",
+                    file_ext=".xlsx",
+                    submission_name="ds-1",
+                    description=None,
+                    organization_id=1,
+                    project_id=1,
+                )
+        assert exc_info.value.status_code == 422
+        assert "Invalid XLSX file content" in exc_info.value.detail
+
+    def test_count_rows_value_error_returns_422(self) -> None:
+        session = MagicMock()
+        with (
+            patch(
+                "app.services.assessment.submission.sanitize_dataset_name",
+                return_value="ds-1",
+            ),
+            patch(
+                "app.services.assessment.submission.get_submission_by_name",
+                return_value=None,
+            ),
+            patch(
+                "app.services.assessment.submission.parse_rows",
+                side_effect=ValueError("Legacy Excel format (.xls) is not supported."),
+            ),
+        ):
+            with pytest.raises(HTTPException) as exc_info:
+                upload_submission(
+                    session=session,
+                    file_content=b"bad",
+                    file_ext=".xls",
+                    submission_name="ds-1",
+                    description=None,
+                    organization_id=1,
+                    project_id=1,
+                )
+        assert exc_info.value.status_code == 422
+        assert "Legacy Excel format" in exc_info.value.detail
+
+    def test_count_rows_unexpected_error_returns_generic_422(self) -> None:
+        session = MagicMock()
+        with (
+            patch(
+                "app.services.assessment.submission.sanitize_dataset_name",
+                return_value="ds-1",
+            ),
+            patch(
+                "app.services.assessment.submission.get_submission_by_name",
+                return_value=None,
+            ),
+            patch(
+                "app.services.assessment.submission.parse_rows",
+                side_effect=RuntimeError("unexpected"),
+            ),
+        ):
+            with pytest.raises(HTTPException) as exc_info:
+                upload_submission(
+                    session=session,
+                    file_content=b"bad",
+                    file_ext=".xlsx",
+                    submission_name="ds-1",
+                    description=None,
+                    organization_id=1,
+                    project_id=1,
+                )
+        assert exc_info.value.status_code == 422
+        assert "Unable to parse the file" in exc_info.value.detail
+
+    def test_upload_submission_success(self) -> None:
+        session = MagicMock()
+        created = MagicMock()
+        created.id = 9
+        with (
+            patch(
+                "app.services.assessment.submission.sanitize_dataset_name",
+                return_value="ds-1",
+            ),
+            patch(
+                "app.services.assessment.submission.get_submission_by_name",
+                return_value=None,
+            ),
+            patch(
+                "app.services.assessment.submission.get_submission_by_name",
+                return_value=None,
+            ),
+            patch(
+                "app.services.assessment.submission.parse_rows",
+                return_value=[{"a": "1"}, {"a": "2"}],
+            ),
+            patch(
+                "app.services.assessment.submission._upload_file_to_object_store",
+                return_value="s3://datasets/file.csv",
+            ),
+            patch(
+                "app.services.assessment.submission.create_submission",
+                return_value=created,
+            ) as create_ds,
+        ):
+            result = upload_submission(
+                session=session,
+                file_content=b"a,b\n1,2\n",
+                file_ext=".csv",
+                submission_name="ds-1",
+                description="desc",
+                organization_id=1,
+                project_id=1,
+            )
+        assert result.id == 9
+        create_ds.assert_called_once()
+        assert create_ds.call_args.kwargs["total_items"] == 2
+
+    def test_upload_survives_a_failed_parsed_row_store(self) -> None:
+        """Storing the parsed rows is best effort; the upload still succeeds."""
+        session = MagicMock()
+        created = MagicMock()
+        created.id = 11
+        with (
+            patch(
+                "app.services.assessment.submission.sanitize_dataset_name",
+                return_value="ds-2",
+            ),
+            patch(
+                "app.services.assessment.submission.get_submission_by_name",
+                return_value=None,
+            ),
+            patch(
+                "app.services.assessment.submission.parse_rows",
+                return_value=[{"a": "1"}],
+            ),
+            patch(
+                "app.services.assessment.submission._upload_file_to_object_store",
+                return_value="s3://datasets/file.csv",
+            ),
+            patch(
+                "app.services.assessment.submission.get_cloud_storage",
+                side_effect=RuntimeError("storage down"),
+            ),
+            patch(
+                "app.services.assessment.submission.create_submission",
+                return_value=created,
+            ) as create_ds,
+        ):
+            result = upload_submission(
+                session=session,
+                file_content=b"a\n1\n",
+                file_ext=".csv",
+                submission_name="ds-2",
+                description=None,
+                organization_id=1,
+                project_id=1,
+            )
+        assert result.id == 11
+        create_ds.assert_called_once()
+
+    def test_preview_csv_returns_headers_and_rows(self) -> None:
+        headers, rows = _preview_csv(b"a,b\n1,2\n\n3,4\n5,6\n", limit=2)
+        assert headers == ["a", "b"]
+        assert rows == [["1", "2"], ["3", "4"]]
+
+    def test_preview_csv_handles_latin1_fallback(self) -> None:
+        # \xff is invalid utf-8 -> falls back to latin-1
+        headers, rows = _preview_csv(b"name\nca\xfffe\n", limit=5)
+        assert headers == ["name"]
+        assert rows and rows[0][0].startswith("ca")
+
+    def test_preview_excel_returns_headers_and_rows(self) -> None:
+        import io
+
+        import openpyxl
+
+        wb = openpyxl.Workbook()
+        ws = wb.active
+        ws.append(["x", "y"])
+        ws.append([1, 2])
+        ws.append([None, None])
+        ws.append([3, 4])
+        buf = io.BytesIO()
+        wb.save(buf)
+        headers, rows = _preview_excel(buf.getvalue(), limit=10)
+        assert headers == ["x", "y"]
+        assert rows == [["1", "2"], ["3", "4"]]
+
+    def test_preview_excel_empty_workbook(self) -> None:
+        import io
+
+        import openpyxl
+
+        wb = openpyxl.Workbook()
+        buf = io.BytesIO()
+        wb.save(buf)
+        headers, rows = _preview_excel(buf.getvalue(), limit=10)
+        assert headers == [""] or headers == []
+        assert rows == []
+
+    def test_preview_submission_missing_url_returns_404(self) -> None:
+        ds = MagicMock()
+        ds.object_store_url = None
+        with pytest.raises(HTTPException) as exc_info:
+            preview_submission(
+                session=MagicMock(), submission=ds, project_id=1, limit=10
+            )
+        assert exc_info.value.status_code == 404
+
+    def test_preview_submission_missing_extension_returns_422(self) -> None:
+        ds = MagicMock()
+        ds.object_store_url = "s3://x"
+        ds.object_store_url = "s3://bucket/key"
+        with pytest.raises(HTTPException) as exc_info:
+            preview_submission(
+                session=MagicMock(), submission=ds, project_id=1, limit=10
+            )
+        assert exc_info.value.status_code == 422
+        assert "Unsupported or missing" in exc_info.value.detail
+
+    def test_preview_submission_unknown_extension_returns_422(self) -> None:
+        ds = MagicMock()
+        ds.object_store_url = "s3://x"
+        ds.object_store_url = "s3://bucket/key.json"
+        with pytest.raises(HTTPException) as exc_info:
+            preview_submission(
+                session=MagicMock(), submission=ds, project_id=1, limit=10
+            )
+        assert exc_info.value.status_code == 422
+
+    def test_preview_submission_normalizes_extension_case(self) -> None:
+        ds = MagicMock()
+        ds.object_store_url = "s3://x"
+        ds.object_store_url = "s3://bucket/key.CSV"
+        storage = MagicMock()
+        storage.get.return_value = b"a,b\n1,2\n"
+        with patch(
+            "app.services.assessment.submission.get_cloud_storage", return_value=storage
+        ):
+            headers, rows = preview_submission(
+                session=MagicMock(), submission=ds, project_id=1, limit=10
+            )
+        assert headers == ["a", "b"]
+        assert rows == [["1", "2"]]
+
+    def test_preview_submission_legacy_xls_returns_422(self) -> None:
+        ds = MagicMock()
+        ds.object_store_url = "s3://x"
+        ds.object_store_url = "s3://bucket/key.xls"
+        with pytest.raises(HTTPException) as exc_info:
+            preview_submission(
+                session=MagicMock(), submission=ds, project_id=1, limit=10
+            )
+        assert exc_info.value.status_code == 422
+
+    def test_preview_submission_storage_failure_returns_502(self) -> None:
+        ds = MagicMock()
+        ds.object_store_url = "s3://x"
+        ds.object_store_url = "s3://bucket/key.csv"
+        storage = MagicMock()
+        storage.get.side_effect = RuntimeError("boom")
+        with patch(
+            "app.services.assessment.submission.get_cloud_storage", return_value=storage
+        ):
+            with pytest.raises(HTTPException) as exc_info:
+                preview_submission(
+                    session=MagicMock(), submission=ds, project_id=1, limit=10
+                )
+        assert exc_info.value.status_code == 502
+
+    def test_preview_submission_invalid_xlsx_returns_422(self) -> None:
+        ds = MagicMock()
+        ds.object_store_url = "s3://x"
+        ds.object_store_url = "s3://bucket/key.xlsx"
+        storage = MagicMock()
+        storage.get.return_value = b"not-a-real-xlsx"
+        with (
+            patch(
+                "app.services.assessment.submission.get_cloud_storage",
+                return_value=storage,
+            ),
+            patch(
+                "app.services.assessment.submission._preview_excel",
+                side_effect=InvalidFileException("bad"),
+            ),
+        ):
+            with pytest.raises(HTTPException) as exc_info:
+                preview_submission(
+                    session=MagicMock(), submission=ds, project_id=1, limit=10
+                )
+        assert exc_info.value.status_code == 422
+        assert "Invalid XLSX" in exc_info.value.detail
+
+    def test_preview_submission_parse_error_returns_422(self) -> None:
+        ds = MagicMock()
+        ds.object_store_url = "s3://x"
+        ds.object_store_url = "s3://bucket/key.csv"
+        storage = MagicMock()
+        storage.get.return_value = b"a,b\n1,2\n"
+        with (
+            patch(
+                "app.services.assessment.submission.get_cloud_storage",
+                return_value=storage,
+            ),
+            patch(
+                "app.services.assessment.submission._preview_csv",
+                side_effect=RuntimeError("boom"),
+            ),
+        ):
+            with pytest.raises(HTTPException) as exc_info:
+                preview_submission(
+                    session=MagicMock(), submission=ds, project_id=1, limit=10
+                )
+        assert exc_info.value.status_code == 422
+        assert "Unable to parse" in exc_info.value.detail
+
+    def test_preview_submission_csv_success(self) -> None:
+        ds = MagicMock()
+        ds.object_store_url = "s3://x"
+        ds.object_store_url = "s3://bucket/key.csv"
+        storage = MagicMock()
+        storage.get.return_value = b"a,b\n1,2\n3,4\n"
+        with patch(
+            "app.services.assessment.submission.get_cloud_storage", return_value=storage
+        ):
+            headers, rows = preview_submission(
+                session=MagicMock(), submission=ds, project_id=1, limit=10
+            )
+        assert headers == ["a", "b"]
+        assert rows == [["1", "2"], ["3", "4"]]
+
+    def test_upload_submission_object_store_failure_returns_500(self) -> None:
+        session = MagicMock()
+        with (
+            patch(
+                "app.services.assessment.submission.sanitize_dataset_name",
+                return_value="ds-1",
+            ),
+            patch(
+                "app.services.assessment.submission.get_submission_by_name",
+                return_value=None,
+            ),
+            patch(
+                "app.services.assessment.submission.parse_rows",
+                return_value=[{"a": "1"}],
+            ),
+            patch(
+                "app.services.assessment.submission._upload_file_to_object_store",
+                return_value=None,
+            ),
+        ):
+            with pytest.raises(HTTPException) as exc_info:
+                upload_submission(
+                    session=session,
+                    file_content=b"a,b\n1,2\n",
+                    file_ext=".csv",
+                    submission_name="ds-1",
+                    description=None,
+                    organization_id=1,
+                    project_id=1,
+                )
+        assert exc_info.value.status_code == 500
diff --git a/backend/app/tests/assessment/test_submission_crud.py b/backend/app/tests/assessment/test_submission_crud.py
new file mode 100644
index 000000000..9e0162eda
--- /dev/null
+++ b/backend/app/tests/assessment/test_submission_crud.py
@@ -0,0 +1,137 @@
+"""Tests for assessment submission CRUD (app/crud/assessment/submission.py)."""
+
+from uuid import uuid4
+
+import pytest
+from fastapi import HTTPException
+
+from app.crud.assessment import api
+from app.crud.assessment.submission import (
+    create_submission,
+    delete_submission,
+    get_submission_by_id,
+    get_submission_by_name,
+    list_submissions,
+)
+from app.models.assessment import AssessmentMethod
+from app.tests.utils.auth import get_user_test_auth_context
+from app.tests.utils.utils import random_lower_string
+
+
+def _create(db, auth, **kwargs):
+    return create_submission(
+        session=db,
+        name=kwargs.pop("name", random_lower_string()),
+        object_store_url="s3://bucket/sub.csv",
+        total_items=kwargs.pop("total_items", 3),
+        organization_id=auth.organization_id,
+        project_id=auth.project_id,
+        **kwargs,
+    )
+
+
+class TestCreate:
+    def test_persists_the_row(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        submission = _create(db, auth, description="desc")
+
+        assert submission.id is not None
+        assert submission.total_items == 3
+        assert submission.description == "desc"
+
+    def test_duplicate_name_is_409(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        name = random_lower_string()
+        _create(db, auth, name=name)
+
+        with pytest.raises(HTTPException) as exc:
+            _create(db, auth, name=name)
+        assert exc.value.status_code == 409
+
+
+class TestReads:
+    def test_get_by_id_scoped_to_project(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        submission = _create(db, auth)
+
+        found = get_submission_by_id(
+            session=db,
+            submission_id=submission.id,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+        assert found.id == submission.id
+
+        with pytest.raises(HTTPException) as exc:
+            get_submission_by_id(
+                session=db,
+                submission_id=submission.id,
+                organization_id=auth.organization_id,
+                project_id=auth.project_id + 1,
+            )
+        assert exc.value.status_code == 404
+
+    def test_get_by_id_unknown_is_404(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        with pytest.raises(HTTPException) as exc:
+            get_submission_by_id(
+                session=db,
+                submission_id=uuid4(),
+                organization_id=auth.organization_id,
+                project_id=auth.project_id,
+            )
+        assert exc.value.status_code == 404
+
+    def test_get_by_name_returns_none_when_absent(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        assert (
+            get_submission_by_name(
+                session=db,
+                name=random_lower_string(),
+                organization_id=auth.organization_id,
+                project_id=auth.project_id,
+            )
+            is None
+        )
+
+    def test_list_returns_the_project_rows(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        created = _create(db, auth)
+
+        rows = list_submissions(
+            session=db,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+        assert created.id in {row.id for row in rows}
+
+
+class TestDelete:
+    def test_deletes_an_unreferenced_submission(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        submission = _create(db, auth)
+
+        assert delete_submission(session=db, submission=submission) is None
+        with pytest.raises(HTTPException):
+            get_submission_by_id(
+                session=db,
+                submission_id=submission.id,
+                organization_id=auth.organization_id,
+                project_id=auth.project_id,
+            )
+
+    def test_refuses_while_an_assessment_references_it(self, db) -> None:
+        auth = get_user_test_auth_context(db)
+        submission = _create(db, auth)
+        api.create_assessment(
+            session=db,
+            method=AssessmentMethod.BATCH,
+            input=None,
+            submission_id=submission.id,
+            organization_id=auth.organization_id,
+            project_id=auth.project_id,
+        )
+
+        error = delete_submission(session=db, submission=submission)
+        assert error is not None
+        assert "being used by" in error
diff --git a/backend/app/tests/assessment/test_submission_store.py b/backend/app/tests/assessment/test_submission_store.py
new file mode 100644
index 000000000..6113b0b0a
--- /dev/null
+++ b/backend/app/tests/assessment/test_submission_store.py
@@ -0,0 +1,146 @@
+"""Tests for the submission-rows round trip (api/submission_store.py)."""
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+from uuid import uuid4
+
+import pytest
+
+from app.models.assessment import Assessment, AssessmentMethod, BatchInput
+from app.services.assessment.api.submission_store import (
+    SubmissionUnavailableError,
+    open_submission_rows,
+    upload_submission_rows,
+)
+
+_STORAGE = "app.services.assessment.api.submission_store.get_cloud_storage"
+_UPLOAD = "app.services.assessment.api.submission_store.upload_jsonl_to_object_store"
+
+
+def _assessment(url: str | None) -> Assessment:
+    return Assessment(
+        id=uuid4(),
+        method=AssessmentMethod.BATCH,
+        submission_input=url,
+        organization_id=1,
+        project_id=1,
+    )
+
+
+class _Body:
+    """The slice of botocore's StreamingBody the loader touches."""
+
+    def __init__(self, payload: bytes, fail_after: int | None = None) -> None:
+        self._lines = payload.splitlines()
+        self._fail_after = fail_after
+        self.closed = False
+
+    def iter_lines(self):
+        for index, line in enumerate(self._lines):
+            if self._fail_after is not None and index >= self._fail_after:
+                raise OSError("connection reset")
+            yield line
+
+    def close(self) -> None:
+        self.closed = True
+
+
+def _storage_with(body: _Body) -> MagicMock:
+    storage = MagicMock()
+    storage.stream.return_value = body
+    return storage
+
+
+class TestUpload:
+    def test_writes_rows_under_the_assessment_prefix(self) -> None:
+        assessment_id = uuid4()
+        with patch(_STORAGE), patch(_UPLOAD, return_value="s3://b/sub.jsonl") as upload:
+            url = upload_submission_rows(
+                session=MagicMock(),
+                assessment_id=assessment_id,
+                project_id=1,
+                batch_input=BatchInput(data=[{"a": "1"}]),
+            )
+
+        assert url == "s3://b/sub.jsonl"
+        assert upload.call_args.kwargs["filename"] == "submission.jsonl"
+        assert upload.call_args.kwargs["subdirectory"] == f"assessment/{assessment_id}"
+
+    def test_returns_none_when_the_upload_fails(self) -> None:
+        with patch(_STORAGE), patch(_UPLOAD, return_value=None):
+            assert (
+                upload_submission_rows(
+                    session=MagicMock(),
+                    assessment_id=uuid4(),
+                    project_id=1,
+                    batch_input=BatchInput(data=[{"a": "1"}]),
+                )
+                is None
+            )
+
+
+class TestOpen:
+    def test_streams_the_stored_jsonl_and_closes_the_body(self) -> None:
+        body = _Body(b'{"a": "1"}\n\n{"a": "2"}\n')
+        with patch(_STORAGE, return_value=_storage_with(body)):
+            with open_submission_rows(
+                session=MagicMock(), assessment=_assessment("s3://b/sub.jsonl")
+            ) as stream:
+                assert list(stream) == [{"a": "1"}, {"a": "2"}]
+
+        assert body.closed
+
+    def test_no_rows_anywhere_is_a_value_error(self) -> None:
+        session = MagicMock()
+        session.get.return_value = None
+        with pytest.raises(ValueError, match="no rows to read"):
+            with open_submission_rows(session=session, assessment=_assessment(None)):
+                pass
+
+    def test_falls_back_to_the_uploaded_submission(self) -> None:
+        body = _Body(b'{"a": "1"}\n')
+        assessment = _assessment(None)
+        assessment.submission_id = uuid4()
+        submission = SimpleNamespace(
+            id=assessment.submission_id,
+            project_id=1,
+            object_store_url="s3://b/subs/x/file.csv",
+        )
+        session = MagicMock()
+        session.get.return_value = submission
+
+        with patch(_STORAGE, return_value=_storage_with(body)):
+            with open_submission_rows(session=session, assessment=assessment) as stream:
+                assert list(stream) == [{"a": "1"}]
+
+        assert body.closed
+
+    def test_open_failure_is_retryable(self) -> None:
+        storage = MagicMock()
+        storage.stream.side_effect = RuntimeError("s3 down")
+        with patch(_STORAGE, return_value=storage):
+            with pytest.raises(SubmissionUnavailableError):
+                with open_submission_rows(
+                    session=MagicMock(), assessment=_assessment("s3://b/sub.jsonl")
+                ):
+                    pass
+
+    def test_read_failure_mid_stream_is_retryable_and_still_closes(self) -> None:
+        body = _Body(b'{"a": "1"}\n{"a": "2"}\n', fail_after=1)
+        with patch(_STORAGE, return_value=_storage_with(body)):
+            with pytest.raises(SubmissionUnavailableError):
+                with open_submission_rows(
+                    session=MagicMock(), assessment=_assessment("s3://b/sub.jsonl")
+                ) as stream:
+                    list(stream)
+
+        assert body.closed
+
+    def test_corrupt_line_is_terminal(self) -> None:
+        body = _Body(b'{"a": "1"}\nnot json\n')
+        with patch(_STORAGE, return_value=_storage_with(body)):
+            with pytest.raises(ValueError):
+                with open_submission_rows(
+                    session=MagicMock(), assessment=_assessment("s3://b/sub.jsonl")
+                ) as stream:
+                    list(stream)
diff --git a/backend/app/tests/assessment/test_validators.py b/backend/app/tests/assessment/test_validators.py
index 87b2b2a2e..1d65e8da6 100644
--- a/backend/app/tests/assessment/test_validators.py
+++ b/backend/app/tests/assessment/test_validators.py
@@ -5,7 +5,11 @@
 import pytest
 from fastapi import UploadFile
 
-from app.services.assessment.validators import MAX_FILE_SIZE, validate_dataset_file
+from app.services.assessment.validators import (
+    MAX_FILE_SIZE,
+    normalize_llm_text,
+    validate_dataset_file,
+)
 
 
 def _make_upload(
@@ -101,3 +105,28 @@ async def test_unexpected_content_type_still_accepted_by_extension(self) -> None
         )
         content, ext = await validate_dataset_file(file)
         assert ext == ".csv"
+
+
+class TestNormalizeLlmText:
+    """Stored templates and instructions only; row values are never normalised."""
+
+    def test_non_string_returns_as_is(self):
+        assert normalize_llm_text(None) is None  # type: ignore[arg-type]
+        assert normalize_llm_text(42) == 42  # type: ignore[arg-type]
+
+    def test_empty_string_returns_as_is(self):
+        assert normalize_llm_text("") == ""
+
+    def test_escaped_whitespace_and_quotes_unescaped(self):
+        assert normalize_llm_text("line1\\nline2") == "line1\nline2"
+        assert normalize_llm_text("col1\\tcol2") == "col1\tcol2"
+        assert normalize_llm_text('\\"quoted\\"') == '"quoted"'
+
+    def test_double_backslash_collapsed(self):
+        assert normalize_llm_text("a\\\\b") == "a\\b"
+
+    def test_nfc_normalization_applied(self):
+        import unicodedata
+
+        text = "é"  # e + combining acute accent
+        assert normalize_llm_text(text) == unicodedata.normalize("NFC", text)
diff --git a/backend/app/tests/core/batch/test_polling.py b/backend/app/tests/core/batch/test_polling.py
new file mode 100644
index 000000000..4b40916be
--- /dev/null
+++ b/backend/app/tests/core/batch/test_polling.py
@@ -0,0 +1,128 @@
+"""Tests for poll_batch_status (app/core/batch/polling.py).
+
+Real batch_job rows on the transactional session; only the provider client is stubbed.
+"""
+
+from unittest.mock import MagicMock
+
+from sqlmodel import Session
+
+from app.core.batch.polling import poll_batch_status
+from app.models.batch_job import BatchJob, BatchJobType
+from app.tests.utils.auth import get_user_test_auth_context
+
+
+def _batch_job(db: Session, **kwargs) -> BatchJob:
+    auth = get_user_test_auth_context(db)
+    job = BatchJob(
+        provider="openai",
+        job_type=BatchJobType.ASSESSMENT.value,
+        organization_id=auth.organization_id,
+        project_id=auth.project_id,
+        provider_batch_id="batch_abc",
+        total_items=1,
+        **kwargs,
+    )
+    db.add(job)
+    db.commit()
+    db.refresh(job)
+    return job
+
+
+def _provider(status_result: dict) -> MagicMock:
+    provider = MagicMock()
+    provider.get_batch_status.return_value = status_result
+    return provider
+
+
+class TestPollBatchStatus:
+    def test_error_file_id_persists_when_the_status_did_not_change(
+        self, db: Session
+    ) -> None:
+        job = _batch_job(db, provider_status="in_progress")
+
+        poll_batch_status(
+            session=db,
+            provider=_provider(
+                {"provider_status": "in_progress", "error_file_id": "file-err-1"}
+            ),
+            batch_job=job,
+        )
+
+        db.refresh(job)
+        assert job.provider_error_file_id == "file-err-1"
+        assert job.provider_status == "in_progress"
+
+    def test_unchanged_fields_are_not_written(self, db: Session) -> None:
+        job = _batch_job(
+            db,
+            provider_status="completed",
+            provider_output_file_id="file-out",
+            provider_error_file_id="file-err",
+        )
+        before = job.updated_at
+
+        poll_batch_status(
+            session=db,
+            provider=_provider(
+                {
+                    "provider_status": "completed",
+                    "provider_output_file_id": "file-out",
+                    "error_file_id": "file-err",
+                }
+            ),
+            batch_job=job,
+        )
+
+        db.refresh(job)
+        assert job.updated_at == before
+
+    def test_omitted_field_does_not_null_the_stored_value(self, db: Session) -> None:
+        job = _batch_job(
+            db, provider_status="in_progress", provider_output_file_id="file-out"
+        )
+
+        poll_batch_status(
+            session=db,
+            provider=_provider({"provider_status": "completed"}),
+            batch_job=job,
+        )
+
+        db.refresh(job)
+        assert job.provider_status == "completed"
+        assert job.provider_output_file_id == "file-out"
+
+    def test_status_flip_persists_the_terminal_fields(self, db: Session) -> None:
+        job = _batch_job(db, provider_status="in_progress")
+
+        poll_batch_status(
+            session=db,
+            provider=_provider(
+                {
+                    "provider_status": "failed",
+                    "provider_output_file_id": "file-out",
+                    "error_message": "provider rejected the batch",
+                }
+            ),
+            batch_job=job,
+        )
+
+        db.refresh(job)
+        assert job.provider_status == "failed"
+        assert job.provider_output_file_id == "file-out"
+        assert job.error_message == "provider rejected the batch"
+
+    def test_status_result_is_returned_verbatim(self, db: Session) -> None:
+        # _poll_outcome reads error_file_id off the return value, not off the row.
+        job = _batch_job(db, provider_status="in_progress")
+        status_result = {
+            "provider_status": "completed",
+            "error_file_id": "file-err-2",
+            "request_counts": {"completed": 3, "failed": 1},
+        }
+
+        returned = poll_batch_status(
+            session=db, provider=_provider(status_result), batch_job=job
+        )
+
+        assert returned == status_result
diff --git a/backend/app/tests/services/llm/test_mappers.py b/backend/app/tests/services/llm/test_mappers.py
index 77a862788..c69832c35 100644
--- a/backend/app/tests/services/llm/test_mappers.py
+++ b/backend/app/tests/services/llm/test_mappers.py
@@ -15,6 +15,9 @@
     build_kaapi_completion_config,
 )
 from app.services.llm.mappers import (
+    _convert_json_schema_to_google,
+    _ensure_openai_strict_schema,
+    _strip_additional_properties,
     bcp47_to_elevenlabs_lang,
     map_kaapi_to_anthropic_params,
     map_kaapi_to_elevenlabs_params,
@@ -143,6 +146,45 @@ def test_summary_mapping_for_reasoning_models(self, db: Session):
         assert result["model"] == "gpt-5"
         assert result["reasoning"] == {"effort": "high", "summary": "detailed"}
 
+    def test_top_p_forwarded_for_non_reasoning_models(self, db: Session):
+        kaapi_params = TextLLMParams(model="gpt-4o", top_p=0.85)
+
+        result, warnings = map_kaapi_to_openai_params(
+            session=db, kaapi_params=kaapi_params.model_dump(exclude_none=True)
+        )
+
+        assert result["top_p"] == 0.85
+        assert warnings == []
+
+    def test_top_p_suppressed_for_reasoning_models(self, db: Session):
+        kaapi_params = TextLLMParams(model="gpt-5", top_p=0.9, temperature=None)
+
+        result, warnings = map_kaapi_to_openai_params(
+            session=db, kaapi_params=kaapi_params.model_dump(exclude_none=True)
+        )
+
+        assert "top_p" not in result
+        assert len(warnings) == 1
+        assert "top_p" in warnings[0]
+
+    def test_output_schema_sets_strict_text_format(self, db: Session):
+        result, _ = map_kaapi_to_openai_params(
+            session=db,
+            kaapi_params={
+                "model": "gpt-4o",
+                "output_schema": {
+                    "type": "object",
+                    "properties": {"score": {"type": "integer"}},
+                },
+            },
+        )
+
+        text_format = result["text"]["format"]
+        assert text_format["type"] == "json_schema"
+        assert text_format["strict"] is True
+        assert text_format["schema"]["additionalProperties"] is False
+        assert text_format["schema"]["required"] == ["score"]
+
 
 class TestMapKaapiToGoogleParams:
     """Test cases for map_kaapi_to_google_params function with completion_type."""
@@ -204,6 +246,51 @@ def test_text_completion_max_num_results_unsupported(self):
         assert len(warnings) == 1
         assert "max_num_results" in warnings[0]
 
+    def test_text_completion_top_p_and_max_output_tokens(self):
+        kaapi_params = TextLLMParams(
+            model="gemini-2.5-pro", top_p=0.8, max_output_tokens=512
+        )
+
+        result, warnings = map_kaapi_to_google_params(
+            kaapi_params.model_dump(exclude_none=True), completion_type="text"
+        )
+
+        assert result["top_p"] == 0.8
+        assert result["max_output_tokens"] == 512
+        assert warnings == []
+
+    def test_text_completion_thinking_level_maps_to_thinking_config(self):
+        kaapi_params = TextLLMParams(model="gemini-2.5-pro", thinking_level="high")
+
+        result, warnings = map_kaapi_to_google_params(
+            kaapi_params.model_dump(exclude_none=True), completion_type="text"
+        )
+
+        assert result["thinking_config"] == {"thinking_level": "high"}
+        assert warnings == []
+
+    def test_enum_output_schema_carries_only_the_camel_case_ordering_key(self):
+        """Vertex rejects a payload carrying both ordering spellings; the SDK dump
+        only emits the snake_case one for some schemas, and an enum triggers it."""
+        result, _ = map_kaapi_to_google_params(
+            {
+                "model": "gemini-2.5-pro",
+                "output_schema": {
+                    "type": "object",
+                    "properties": {
+                        "band": {"type": "string", "enum": ["low", "high"]},
+                        "score": {"type": "integer"},
+                    },
+                    "required": ["band", "score"],
+                },
+            },
+            completion_type="text",
+        )
+
+        google_schema = result["output_schema"]
+        assert "property_ordering" not in google_schema
+        assert google_schema["propertyOrdering"] == ["band", "score"]
+
     def test_stt_completion_with_instructions(self):
         """Test STT completion with instructions parameter."""
         kaapi_params = STTLLMParams(
@@ -822,8 +909,6 @@ def test_full_text_completion_params_mapped(self):
         kaapi_params = {
             "model": "claude-sonnet-4-6",
             "instructions": "You are a helpful assistant.",
-            "temperature": 0.4,
-            "top_p": 0.9,
             "max_output_tokens": 1024,
         }
 
@@ -832,12 +917,39 @@ def test_full_text_completion_params_mapped(self):
         assert result == {
             "model": "claude-sonnet-4-6",
             "system": "You are a helpful assistant.",
-            "temperature": 0.4,
-            "top_p": 0.9,
             "max_tokens": 1024,
         }
         assert warnings == []
 
+    def test_sampling_is_always_dropped_with_a_warning(self):
+        """The Messages API returns 400 for a non-default temperature or any top_p."""
+        result, warnings = map_kaapi_to_anthropic_params(
+            {"model": "claude-sonnet-4-6", "temperature": 0.3, "top_p": 0.9}
+        )
+
+        assert "temperature" not in result
+        assert "top_p" not in result
+        assert len(warnings) == 1
+        assert "temperature" in warnings[0]
+
+    def test_default_temperature_dropped_without_a_warning(self):
+        """1.0 is Anthropic's own default, so dropping it changes nothing."""
+        result, warnings = map_kaapi_to_anthropic_params(
+            {"model": "claude-sonnet-4-6", "temperature": 1.0}
+        )
+
+        assert "temperature" not in result
+        assert warnings == []
+
+    def test_effort_is_unaffected_by_dropped_sampling(self):
+        result, warnings = map_kaapi_to_anthropic_params(
+            {"model": "claude-opus-4-8", "effort": "high", "temperature": 0.3}
+        )
+
+        assert result["output_config"] == {"effort": "high"}
+        assert "temperature" not in result
+        assert len(warnings) == 1
+
     def test_missing_model_falls_back_to_default(self):
         """Anthropic requires model — provider falls back to the centralised
         default when caller omits it."""
@@ -870,9 +982,9 @@ def test_unsupported_knowledge_base_emits_warning_and_drops_field(self):
         assert len(warnings) == 1
         assert "knowledge_base_ids" in warnings[0]
 
-    def test_reasoning_effort_summary_collapsed_into_single_warning(self):
-        """Any of reasoning/effort/summary triggers the same advisory; only
-        one warning is emitted regardless of how many are supplied."""
+    def test_effort_wins_over_the_reasoning_alias(self):
+        """effort is canonical; reasoning is only read when effort is absent.
+        summary has no Anthropic equivalent and is dropped."""
         result, warnings = map_kaapi_to_anthropic_params(
             {
                 "model": "claude-sonnet-4-6",
@@ -882,19 +994,160 @@ def test_reasoning_effort_summary_collapsed_into_single_warning(self):
             }
         )
 
+        assert result["output_config"] == {"effort": "medium"}
         assert "reasoning" not in result
-        assert "effort" not in result
         assert "summary" not in result
         assert len(warnings) == 1
-        assert "reasoning" in warnings[0].lower()
+        assert "summary" in warnings[0]
 
-    def test_temperature_zero_is_preserved(self):
-        """0.0 is a valid temperature — guard against truthy-check bugs that
-        would drop it as if it were None."""
+    def test_reasoning_alias_is_read_as_effort(self):
         result, _ = map_kaapi_to_anthropic_params(
+            {"model": "claude-sonnet-4-6", "reasoning": "medium"}
+        )
+        assert result["output_config"]["effort"] == "medium"
+
+    def test_minimal_effort_is_warned_and_omitted(self):
+        """Kaapi/OpenAI expose a "minimal" rung with no Anthropic equivalent."""
+        result, warnings = map_kaapi_to_anthropic_params(
+            {"model": "claude-sonnet-4-6", "effort": "minimal"}
+        )
+
+        assert "output_config" not in result
+        assert any("minimal" in warning for warning in warnings)
+
+    def test_output_schema_maps_to_output_config_format(self):
+        result, _ = map_kaapi_to_anthropic_params(
+            {
+                "model": "claude-sonnet-4-6",
+                "output_schema": {
+                    "type": "object",
+                    "properties": {"score": {"type": "integer"}},
+                },
+            }
+        )
+
+        output_format = result["output_config"]["format"]
+        assert output_format["type"] == "json_schema"
+        assert output_format["schema"]["additionalProperties"] is False
+
+    def test_effort_shares_the_output_config_with_the_schema(self):
+        """Structured output and reasoning effort share one container."""
+        result, _ = map_kaapi_to_anthropic_params(
+            {
+                "model": "claude-sonnet-4-6",
+                "effort": "high",
+                "output_schema": {
+                    "type": "object",
+                    "properties": {"score": {"type": "integer"}},
+                },
+            }
+        )
+
+        assert result["output_config"]["effort"] == "high"
+        assert result["output_config"]["format"]["type"] == "json_schema"
+
+    def test_thinking_container_passes_through(self):
+        thinking = {"type": "enabled", "budget_tokens": 4096}
+
+        result, warnings = map_kaapi_to_anthropic_params(
+            {"model": "claude-sonnet-4-6", "thinking": thinking}
+        )
+
+        assert result["thinking"] == thinking
+        assert warnings == []
+
+    def test_thinking_level_is_warned_and_dropped(self):
+        """thinking_level is Google-only; Anthropic reads the thinking container."""
+        result, warnings = map_kaapi_to_anthropic_params(
+            {"model": "claude-sonnet-4-6", "thinking_level": "high"}
+        )
+
+        assert "thinking_level" not in result
+        assert any("thinking_level" in warning for warning in warnings)
+
+    def test_zero_temperature_is_dropped_not_ignored(self):
+        """0.0 is falsy but still a non-default value the API would reject."""
+        _, warnings = map_kaapi_to_anthropic_params(
             {"model": "claude-sonnet-4-6", "temperature": 0.0}
         )
-        assert result["temperature"] == 0.0
+        assert len(warnings) == 1
+
+
+class TestSchemaHelpers:
+    """Schema shaping shared by the OpenAI, Anthropic and Gemini mappers."""
+
+    def test_strict_schema_forbids_extras_and_requires_every_property(self):
+        result = _ensure_openai_strict_schema(
+            {"type": "object", "properties": {"name": {"type": "string"}}}
+        )
+
+        assert result["additionalProperties"] is False
+        assert result["required"] == ["name"]
+
+    def test_strict_schema_recurses_into_nested_objects_and_arrays(self):
+        result = _ensure_openai_strict_schema(
+            {
+                "type": "object",
+                "properties": {
+                    "address": {
+                        "type": "object",
+                        "properties": {"city": {"type": "string"}},
+                    },
+                    "tags": {
+                        "type": "array",
+                        "items": {"type": "object", "properties": {"x": {}}},
+                    },
+                },
+            }
+        )
+
+        assert result["properties"]["address"]["additionalProperties"] is False
+        assert result["properties"]["tags"]["items"]["additionalProperties"] is False
+
+    def test_strict_schema_leaves_non_objects_alone(self):
+        assert "additionalProperties" not in _ensure_openai_strict_schema(
+            {"type": "string"}
+        )
+
+    def test_additional_properties_stripped_recursively(self):
+        result = _strip_additional_properties(
+            {
+                "type": "object",
+                "additionalProperties": False,
+                "properties": {
+                    "child": {"type": "object", "additionalProperties": False},
+                    "list": {
+                        "type": "array",
+                        "items": {"type": "object", "additionalProperties": False},
+                    },
+                },
+            }
+        )
+
+        assert "additionalProperties" not in result
+        assert "additionalProperties" not in result["properties"]["child"]
+        assert "additionalProperties" not in result["properties"]["list"]["items"]
+
+    def test_google_schema_orders_properties_by_required(self):
+        result = _convert_json_schema_to_google(
+            {
+                "type": "object",
+                "required": ["score", "reason"],
+                "properties": {"score": {"type": "integer"}, "reason": {}},
+            }
+        )
+
+        assert result["propertyOrdering"] == ["score", "reason"]
+
+    def test_google_schema_ordering_falls_back_to_property_keys(self):
+        result = _convert_json_schema_to_google(
+            {
+                "type": "object",
+                "properties": {"a": {"type": "string"}, "b": {"type": "string"}},
+            }
+        )
+
+        assert result["propertyOrdering"] == ["a", "b"]
 
 
 class TestTransformGoogleVertexRouting:
diff --git a/docs/wiki/domain-map.md b/docs/wiki/domain-map.md
index 7187f0129..073d65540 100644
--- a/docs/wiki/domain-map.md
+++ b/docs/wiki/domain-map.md
@@ -29,12 +29,13 @@ APIKey → Organization, Project, User  # programmatic access
 | LlmChain | llm/request.py | Org, Project | LlmCall |
 | Job | job.py | Project | LlmCall; Assessment (RESPONSE method); Celery job execution (logical); evaluation prompt improvement (`JobType.PROMPT_IMPROVEMENT`, logical) |
 | BatchJob | batch_job.py | Org, Project | EvaluationRun, Assessment; batch polling cron (logical) |
-| EvaluationDataset | evaluation.py | Org, Project, Language | EvaluationRun, STTSample (via stt_evaluation), Assessment |
+| EvaluationDataset | evaluation.py | Org, Project, Language | EvaluationRun, STTSample (via stt_evaluation) |
+| AssessmentSubmission | assessment/submission.py | Org, Project | Assessment (`submission_id`); assessment BATCH `submission_doc_id` requests (logical) |
 | EvaluationRun | evaluation.py | Dataset, Config, BatchJob, Org, Project, Language | STTResult, TTSResult; Langfuse scores (logical); console UI (logical) |
 | EvaluationIterationRun | evaluation_iteration.py | Dataset, Config, Org, Project | EvaluationRun, Job (referenced only inside the LangGraph checkpoint state, not FK columns on this table, logical); callback_url caller (logical) |
 | STTSample / STTResult | stt_evaluation.py | Dataset, Run, File, Language | human annotation UI (logical) |
 | TTSResult | tts_evaluation.py | Run, Org, Project | human annotation UI (logical) |
-| Assessment / AssessmentRun | assessment.py | Config, Dataset, BatchJob, Job, Org, Project | console UI (logical) |
+| Assessment / AssessmentRun | assessment.py | Config, AssessmentSubmission, BatchJob, Job, Org, Project | console UI (logical); webhook consumers (logical) |
 | Document | document.py | Project, Document (parent) | DocumentCollection, DocTransformationJob, FineTuning, ModelEvaluation |
 | Collection | collection.py | Project | DocumentCollection, CollectionJob; provider vector stores (logical) |
 | DocumentCollection | document_collection.py | Document, Collection | RAG lookups (logical) |
diff --git a/docs/wiki/modules/assessment.md b/docs/wiki/modules/assessment.md
index 4314faade..bb09c0e47 100644
--- a/docs/wiki/modules/assessment.md
+++ b/docs/wiki/modules/assessment.md
@@ -5,31 +5,44 @@ Assessments of datasets/inputs against ASSESSMENT-tagged configs. Three methods,
 All paths relative to `backend/app/`.
 
 ## Routes
-- `api/routes/assessment/` — legacy UI (assessments, runs, datasets)
-- `api/routes/assessment/api.py` — API-client route, mounted top-level at `/assessments` (**`POST /assessments` only** — no status/result poll endpoint; the result is delivered by webhook to the request's required `callback_url`); method inferred from input shape. BATCH wired; RESPONSE returns 501 (deferred)
+- `api/routes/assessment/` — legacy UI (assessments, runs, datasets); RUN only, and the results export 422s a BATCH assessment (its rows come from `GET /assessments/{id}`)
+- `api/routes/assessment/api.py` — API-client routes, mounted top-level at `/assessments`: `POST` (submit; method inferred from input shape, BATCH wired, RESPONSE returns 501), `GET` (list, **BATCH only** so the execution join yields one row per assessment; `config_id` + optional `version` filters), `GET /{assessment_id}` (detail/poll; `include_input=true` echoes the submitted rows at the cost of a storage read, off by default). `callback_url` is optional and adds a webhook push on top of polling.
 
 ## Tables (SQLModel)
-`models/assessment/` is a package, split by surface: `assessment.py` holds the shared DB tables + `AssessmentStatus`/`AssessmentMethod` enums + `AssessmentConfigRef` + the legacy RUN (UI) models; `assessment_api.py` holds the API-client request/response models. Both are re-exported from the package `__init__`, so `from app.models.assessment import X` resolves either.
+`models/assessment/` is a package, split by surface: `assessment.py` holds the shared DB tables + `AssessmentStatus`/`AssessmentMethod` enums + `AssessmentConfigRef` + the legacy RUN (UI) models; `assessment_api.py` holds the API-client request/response models; `submission.py` holds the uploaded-submission table and its response models. All are re-exported from the package `__init__`, so `from app.models.assessment import X` resolves either.
 
 | Table | Model |
 |---|---|
-| `assessment` (Assessment; parent — `method`, data source; FK → job (RESPONSE), evaluation_dataset, org, project) | `models/assessment/assessment.py` |
+| `assessment` (Assessment; parent — `method`, data source, `submission_input`, `result_files`; FK → job (RESPONSE), assessment_submission (RUN), org, project) | `models/assessment/assessment.py` |
 | `assessment_run` (AssessmentRun; child — one config execution, BATCH/RUN; FK → assessment, config, batch_job) | `models/assessment/assessment.py` |
+| `assessment_submission` (AssessmentSubmission; an uploaded CSV/XLSX a run can read its rows from; FK → org, project) | `models/assessment/submission.py` |
 
-Config version (tag=ASSESSMENT, `models/config/assessment_blob.py`) owns system / pre-filters / params / schemas: `input_schema` is a **top-level** field on the blob (sibling of `pre_filters`/`assessment`, **mandatory, non-empty** per-column spec `{type, format}` for the BATCH `data` rows — `type` is required per column; every declared column must be present in every submission row; attachment columns are url-format only) — it describes the shared input rows once, so both the pre-filter and assessment consumers read the same schema. `submission` (the per-row prompt template with `{column}` placeholders — **mandatory** on `assessment.params`, optional on each pre-filter's `params`; every `{placeholder}` is validated at config save against the top-level `input_schema` keys, and an unknown placeholder rejects the save). `json_output_schema` stays in `assessment.params` (assessment-specific, object-typed structured-output schema, omit for free text). The only API-client pre-filter is `topic_relevance` (duplicate_detection was removed from the API-client pipeline; it survives only in the legacy RUN pipeline); it carries its own `provider` (default `openai`) + `params` (TextLLMParams: model, temperature, ...) and runs its own llm call; its criteria live in `params.instructions` (a **mandatory** field, same shape as the assessment call — pre-filters no longer have a top-level `prompt`/`content`) and it may carry its own `params.submission` template. The prompt template lives on the config, not the request. Strict input types `ResponseInput` (RESPONSE, `{attachments}`) / `BatchInput` (BATCH, `{data}` where `data` is a **list of submission rows** — each a flat column→string map, an attachment column's value being a url string) no longer carry `query`; they discriminate structurally on the `data` key (`data` ⇒ BATCH, else RESPONSE) with `extra=forbid` keeping them disjoint and rejecting a stray `query` — no `mode` tag (`models/assessment/assessment_api.py`). Legacy RUN runtime lives in `assessment_run.execution` (`RunExecution`).
+Config version (tag=ASSESSMENT, `models/config/assessment_blob.py`) owns system / pre-filters / params / schemas: `input_schema` is a **top-level** field on the blob (sibling of `pre_filters`/`assessment`, **mandatory, non-empty** per-column spec `{type, format}` for the BATCH `data` rows — `type` is required per column; `strict: true` means the column must be present and non-blank in every submission row; it is **off by default** because the console declares every sheet column (the backend rejects undeclared ones) and real sheets have blanks — a blank on a non-strict column passes and `build_rows` fills omitted keys with `""` so the placeholder still resolves; note the config store persists the validated blob *with defaults*, so a saved version pins the default in force at save time; `InputColumn` is `extra=forbid`, so a misspelt flag fails at config save; attachment columns are url-format only) — it describes the shared input rows once, so both the pre-filter and assessment consumers read the same schema. `submission` (the per-row prompt template with `{column}` placeholders — **mandatory** on `assessment.params`, optional on each pre-filter's `params`; every `{placeholder}` is validated at config save against the top-level `input_schema` keys, and an unknown placeholder rejects the save). `json_output_schema` stays in `assessment.params` (assessment-specific, object-typed structured-output schema, omit for free text). The only API-client pre-filter is `topic_relevance` (duplicate_detection was removed from the API-client pipeline; it survives only in the legacy RUN pipeline); it carries its own `provider` (default `openai`) + `params` (TextLLMParams: model, temperature, ...) and runs its own llm call; its criteria live in `params.instructions` (a **mandatory** field, same shape as the assessment call — pre-filters no longer have a top-level `prompt`/`content`) and it may carry its own `params.submission` template. The prompt template lives on the config, not the request. Strict input types `ResponseInput` (RESPONSE, `{attachments}`) / `BatchInput` (BATCH) no longer carry `query`; they discriminate structurally (a `data` or `submission_doc_id` key ⇒ BATCH, else RESPONSE) with `extra=forbid` keeping them disjoint and rejecting a stray `query` — no `mode` tag (`models/assessment/assessment_api.py`). `BatchInput` takes the rows **either** inline as `data` (a list of submission rows, each a flat column→string map, an attachment column's value being a url string) **or** by reference as `submission_doc_id` (an `assessment_submission` id); a `model_validator` requires exactly one, so both-or-neither is a 422. A `submission_doc_id` is resolved at submit: its rows are read, projected onto the schema's columns (a sheet column `input_schema` does not name is dropped, so the schema is the selection and the console need only declare the `@`-referenced columns), validated against `input_schema` like inline ones, and copied into that run's own `submission.jsonl`, so downstream stays one code path and the run keeps an immutable snapshot if the submission file is later replaced. `assessment.submission_id` records which submission it came from, so the provenance survives the copy and `delete_submission` refuses while a BATCH run still points at it. That column is set by RUN and by a `submission_doc_id` BATCH alike; it stays NULL only when BATCH sent rows inline. Legacy RUN runtime lives in `assessment_run.execution` (`RunExecution`).
 
-`assessment.id` is a **UUID** (like config/job/llm_call). Per-item result = `AssessmentResult {output: {assessment, pre_filter}, error}` (no `metadata` — the provider/model/usage block was removed from the API-client output) where `output.assessment` = the LLM output parsed to an object when the config has a `json_output_schema`, else string (null for gated/failed rows), and `output.pre_filter` holds the `{topic_relevance}` verdict (`{verdict, reasoning}` or null) and is itself null when no pre-filter ran. Delivery is **webhook-only**: the `POST /assessments` ack is the flat `AssessmentSubmitResponse {assessment_id, status, message, inserted_at, updated_at}`, and the result is delivered solely by POSTing the `AssessmentCallback {assessment_id, status, data, request_metadata}` to the request's required `callback_url` on completion — where `data` is a single `AssessmentResult` (RESPONSE) or an `AssessmentBatchResult {total_items, counts, items}` (BATCH); `status` lives on the envelope only. Pre-filter `stop_on_fail` flag (`config/assessment_blob.py`) drives which filters hard-stop the chain on a failing verdict vs pass-through (record only).
+`assessment.id` is a **UUID** (like config/job/llm_call). Per-item result = `AssessmentResult {output: {assessment, pre_filter}, error}` (no `metadata` — the provider/model/usage block was removed from the API-client output) where `output.assessment` = the LLM output parsed to an object when the config has a `json_output_schema`, else string (null for gated/failed rows), and `output.pre_filter` holds the `{topic_relevance}` verdict (`{verdict, reasoning}` or null) and is itself null when no pre-filter ran. The API-client BATCH rows do **not** live in `assessment.input` (that column is now RESPONSE/RUN only, NULL for BATCH). They are uploaded to `submission.jsonl` at submit and `assessment.submission_input` holds its `s3://` url: 3-6MB of JSONB was dragged along by every full-row `SELECT` of the assessment. `services/assessment/api/submission_store.py` owns the round trip: `upload_submission_rows` at submit, and the `open_submission_rows` context manager on read, which streams the JSONL line by line and closes the body on exit. Rows are read only inside `_submit_stage`, never on a poll, and only the rows the stage's subset needs are held (the count comes from `execution.total_items`, so an empty subset never opens the file). A storage read failure raises `SubmissionUnavailableError`, which requeues the task instead of failing the execution; a corrupt line is a `ValueError` and terminal. An upload failure at submit is a 503 (an assessment without its rows is unrunnable). `build_result` reads `execution.total_items` rather than re-deriving the count from the rows, so the terminal path never fetches them.
+
+`assessment.result_files` is the durable record of every provider batch dump held: JSONB, **NOT NULL default `{}`**, CHECK-constrained to a JSON object (`ck_assessment_result_files_is_object`), keyed by file kind (`results` / `errors` / `<stage>_results`, derived by `stage_file_kind`) with `{object_store_url}` per kind. It stores the raw `s3://` url (presigning is per-delivery, so the column never holds an expiring link); writes go through `crud/assessment/api.py::set_result_files`, which merges **server-side** (`result_files || :files::jsonb`) rather than read-modify-write, because two drivers can touch the row in the same second. `batch_job.provider_error_file_id` persists OpenAI's `error_file_id` (OpenAI only; Anthropic and Gemini report per-item errors inline) so the error dump is still fetchable at terminal time, in a later task than the poll that surfaced it.
+
+Delivery is poll-or-push: the `POST /assessments` ack is the flat `AssessmentSubmitResponse {assessment_id, status, message, inserted_at, updated_at}`, the result is always readable from `GET /assessments/{assessment_id}`, and when the request carried a `callback_url` the `AssessmentCallback {assessment_id, status, data, request_metadata}` is also POSTed there on completion — where `data` is a single `AssessmentResult` (RESPONSE) or an `AssessmentBatchResult {total_items, counts, items}` (BATCH); `status` lives on the envelope only. The outer `send_callback` envelope carries `{success, data, error, metadata}`: `error` is `_fail`'s failure message (null on a success path) and `metadata` is `{result_files: {kind: {signed_url}}, expires_at}` — the column's `object_store_url` presigned for 1 day at delivery time, never stored, so a client whose receiver rejects the (large, item-inlining) body can still fetch the dumps. Both were hardcoded `None` before. Delivery is one inline attempt with no retry, so a rejected callback is still lost. Pre-filter `stop_on_fail` flag (`config/assessment_blob.py`) drives which filters hard-stop the chain on a failing verdict vs pass-through (record only).
 
 ## Services / CRUD
 - `services/assessment/utils/attachments.py` — cell→provider attachment conversion (Drive URL normalization; OpenAI/Anthropic/Gemini part builders). `rewrite_gcs_attachment_urls` bulk-resolves `gs://` cells to provider-reachable URLs via `services/buckets/` (Path A native passthrough for google-gcp / Path B signed HTTPS otherwise) **before** JSONL build. Called in: `services/assessment/api/batch.py::_submit_provider_batch` (API pipeline, all stages), `crud/assessment/batch.py::submit_assessment_batch` (legacy L2), `services/assessment/tasks.py` (legacy prefilter). Submit-time validation (`services/assessment/api/submission.py`) allows `gs://` alongside `http(s)://`.
 - `services/assessment/` — legacy RUN pipeline (service, stages, processing, batch, cron, tasks)
-- `services/assessment/api/` — API-client pipeline: `submission.py` (submit), `batch.py` (staged provider batches — gate pre-filters → pass-through → assessment, over `core/batch`; `PREFILTER_VERDICT_SCHEMA`), `results.py` (builds `AssessmentBatchResult`), `callbacks.py` (webhook)
-- `crud/assessment/api.py` — new API-client crud (method-based Assessment/AssessmentRun writes): `create_assessment`, `set_assessment_job`, `create_execution`, `set_execution_batch_job`, `update_status`, `list_executions` (no `get_assessment` — delivery is webhook-only, so there is no request-time fetch). Namespaced under `api` (`from app.crud.assessment import api`) to avoid colliding with the legacy `create_assessment`.
+- `services/assessment/submission.py` — submission-file upload + preview (`upload_submission`, `preview_submission`, `file_extension_of`). The name is sanitized then checked via `crud/assessment/submission.py::get_submission_by_name` **before** the object-store write (early 409 on a duplicate); the id is pre-generated and the key is `assessment/submissions/<submission_id>/<name>.<ext>` (`SUBMISSIONS_SUBDIRECTORY`), so two concurrent same-name uploads never share a key and the unique constraint is the only arbiter. No `file_extension` column exists; the format is read off the key's suffix. Upload parses the sheet once and writes the rows beside the file as `submission.jsonl` (`_store_parsed_rows`, best effort — a failure only costs a later reader one re-parse); `services/assessment/api/submission_store.py::open_uploaded_rows` streams that copy and falls back to `crud/assessment/batch.py::load_submission_file_rows` only when the copy cannot be opened, never mid-stream. XLSX goes through `clean_sheet` in all three readers (upload count, preview, run loader): blank rows drop first, then columns with no header or no values, and cells come back stripped — so a 1000×17 sheet with 100×10 filled is 100×10 everywhere. CSV keeps only the blank-row / blank-header filter.
+- `services/assessment/validators.py` — the module's one leaf of shared helpers, in three sections: upload validation (`MAX_FILE_SIZE`, `ALLOWED_EXTENSIONS`, `ALLOWED_MIME_TYPES`, `validate_dataset_file`), storage-key constants and builders (`SUBMISSION_FILENAME`, `ERRORS_FILENAME`, `assessment_prefix`, `stage_batch_prefix`, `submission_prefix`, `submission_rows_url`, `file_extension_of`), and sheet parsing (`clean_sheet`, `parse_csv_rows`, `parse_excel_rows`, `parse_rows`). Keep new shared helpers here rather than adding another utils module.
+- **Provider param mapping lives in `services/llm/mappers.py`, not in the assessment tree.** The assessment fork (`services/assessment/mappers.py`) is deleted; `crud/assessment/batch.py`, `services/assessment/api/batch.py` and `prefilter/request_builder.py` all import the shared mappers. The structured-output key is `output_schema` on every provider (the wire name stays `json_output_schema` on `AssessmentTextParams`; `api/batch.py::_stage_params` renames it). `normalize_llm_text` is exported from the same module but no mapper calls it — assessment normalises `instructions` at its own call sites, so prod LLM prompts are untouched.
+- **`evaluation_dataset` is no longer used anywhere in the assessment domain.** Assessment rows used to be `type='assessment'` entries in that shared table, which multiplexes four surfaces behind a discriminator, carries eval-only columns (`language_id`, `langfuse_dataset_id`), and whose name uniqueness ignores `type`, so an eval dataset name blocked an assessment one. `assessment.dataset_id` became `assessment.submission_id` (UUID FK) in migration 084.
+- `services/assessment/api/` — API-client pipeline: `submission.py` (submit), `submission_store.py` (submission rows in object storage), `batch.py` (staged provider batches — gate pre-filters → pass-through → assessment, over `core/batch`; `PREFILTER_VERDICT_SCHEMA`), `results.py` (builds `AssessmentBatchResult`), `result_files.py` (dump bookkeeping + `errors.jsonl` + presigned callback `metadata`), `callbacks.py` (webhook)
+- `result_files.py` — `stage_file_kind` / `record_stage_dump` (called per completed stage from `batch.py`), `build_and_upload_errors` (one self-describing JSONL of `execution_error` / `row_error` / `provider_error_file` records, uploaded **even when empty** so both urls always exist; per-row errors come from the exec bag's `stage_errors`; OpenAI's error-file rows are merged into the stage's parsed results at poll time via `batch.error_file_entries`, so they land in `stage_errors` and `build_result` reports them per row instead of as silent "no output, no error" gaps; the same helper feeds the errors.jsonl dump), `finalize_result_files` (called from `_finalize`/`_fail` *before* the callback_url check, so durability never depends on a callback), `build_callback_metadata` (presigns each kind at `expires_in=86400`; never raises). Storage keys land under one per-assessment prefix, `<project.storage_path uuid>/assessment/<assessment_id>/` (`assessment_subdirectory`), holding `errors.jsonl` plus `batch-<batch_job_id>/results.jsonl` per stage; the API path passes that prefix into `process_completed_batch`'s optional `subdirectory` (legacy RUN and evaluations keep the default `<job_type>/batch-<id>`). Uploaded submission files sit at `assessment/submissions/<submission_id>/<name>.<ext>` beside their parsed `submission.jsonl`. Only an **inline** BATCH gets a per-assessment copy at `<assessment_id>/submission.jsonl` (`assessment.submission_input`); a run submitted by `submission_doc_id` streams the uploaded submission's own rows, because a submission is immutable (create/read/delete only, no update crud) and the copy would never diverge.
+- `crud/assessment/submission.py` — `create_submission`, `get_submission_by_name`, `get_submission_by_id`, `list_submissions`, `delete_submission` (refuses while an assessment still references it)
+- `crud/assessment/api.py` — new API-client crud (method-based Assessment/AssessmentRun writes): `create_assessment` (takes a pre-generated `assessment_id` + `submission_input`, so submit uploads `submission.jsonl` first and then does one insert — no FAILED orphan when the upload fails), `set_assessment_job`, `create_execution`, `set_execution_batch_job`, `save_execution_state`, `set_result_files`, `update_status`, `list_executions`, `list_assessments_with_execution` (BATCH only; the detail route reads through the legacy `core.get_assessment_by_id`). Namespaced under `api` (`from app.crud.assessment import api`) to avoid colliding with the legacy `create_assessment`.
 - `crud/assessment/{core,cron,processing,batch}.py` — legacy RUN pipeline crud. RUN runtime for the dropped columns (`stage`/`stage_status`/`pipeline`/`stage_batches`/`prefilter_total_*`/`object_store_url`) now lives in the `assessment_run.execution` bag via `core._read_exec`/`_write_exec`; `status` is the `AssessmentStatus` enum; the RUN input binding lives on the parent `assessment.input`. `batch.py` builds per-row prompts (`{column}` substitution from the parent `InputBinding.prompt`).
 
 ## Async
 - Rides shared `core/batch/` provider batch infra + cron polling (same as evaluations).
-- API-client BATCH: `celery/tasks/job_execution.py::run_assessment_api_batch` drives the staged pipeline (poll → parse verdict/gate → advance/finalize → callback), self-re-enqueuing between stages. Staged state + `callback_url`/`request_metadata` live in the `assessment_run.execution` bag.
+- **Two drivers, strictly separated:** the cron poller (`crud/assessment/cron.py::poll_all_pending_assessment_evaluations`) selects `method == RUN` only and owns the legacy pipeline; the API-client BATCH path is driven solely by the Celery self-re-enqueue. The poller used to pick up BATCH runs too and crash on their list-shaped `pipeline`, leaving the run un-finalised and the callback unfired. Its deterministic-error branch (`DETERMINISTIC_ERRORS`) marks a run FAILED on a programming error instead of logging "will retry" forever; bare `Exception` stays the transient path.
+- API-client BATCH: `celery/tasks/job_execution.py::run_assessment_api_batch` drives the staged pipeline (poll → parse verdict/gate → advance/finalize → callback), self-re-enqueuing between stages. The task carries `autoretry_for=(Exception, Timeout)` with backoff (app-default `max_retries`), so a task that raises is re-run instead of silently ending the chain, and `run_batch_stage` takes its execution row `FOR UPDATE SKIP LOCKED`, so an overlapping task no-ops and a duplicate chain collapses. It also sets `reject_on_worker_lost=False` (per task; the global flag stays `True` for every other task), so a task whose worker is lost is acked instead of re-queued in a loop. Known gap: the execution then stays PROCESSING (no callback) until retriggered; marking it FAILED is a follow-up. Staged state + `callback_url`/`request_metadata` live in the `assessment_run.execution` bag (`BatchRunState`), which also holds `stage_errors` (`stage -> {row_index -> error}`, captured at parse time; the raw dumps go to object storage, not the bag).
+- `core/batch/polling.py::poll_batch_status` diffs **per field**, not only on a `provider_status` flip, so `error_file_id` and `provider_output_file_id` persist even when the status is unchanged. Shared with the evaluations path; return value unchanged.
 
 ## External
 - Provider Batch APIs, object storage for attachments (incl. `gs://` attachments resolved via `services/buckets/`).
diff --git a/docs/wiki/modules/llm-call.md b/docs/wiki/modules/llm-call.md
index 4e22cbd91..de5749b90 100644
--- a/docs/wiki/modules/llm-call.md
+++ b/docs/wiki/modules/llm-call.md
@@ -28,11 +28,13 @@ All paths relative to `backend/app/`.
 - `LLMCallConfig` — one-of: saved reference (`id` + `version`) XOR ad-hoc `blob` (validator-enforced)
 - `ConfigBlob` — `completion` + optional `prompt_template` (`PromptTemplate.template`, plain string; `{{input}}` interpolation is llm-chain-only) + `input_guardrails`/`output_guardrails`
 - `CompletionConfig` — discriminated union on `provider`: `KaapiCompletionConfig` (standardized params: `TextLLMParams`/`STTLLMParams`/`TTSLLMParams`), `NativeCompletionConfig` (pass-through), `ProxyCompletionConfig` (client's own endpoint)
+- `TextLLMParams` reasoning knobs: `reasoning` + `effort` (OpenAI-style), `thinking` (Anthropic adaptive-thinking container, forwarded as-is) and `thinking_level` (Gemini). A knob must be **declared here** to survive config save — pydantic's default extra policy is ignore, so an undeclared key is dropped silently at validation with no error.
 - `QueryParams` — per-call input + `ConversationConfig`
 - `models/guardrails/` — validator config shapes
 
 ## Services / CRUD
 - `services/llm/` — `mappers.py` (Kaapi params → provider API), `providers/`, `chain/`, `guardrails.py`, `jobs.py`
+- `mappers.py` is the **only** param mapper in the codebase; the assessment fork was merged back into it. Callers: `crud/evaluations/{batch,fast,judge}.py`, `crud/assessment/batch.py`, `services/assessment/api/batch.py`, `services/assessment/prefilter/request_builder.py`. Structured output is keyed `output_schema` for every provider (OpenAI `text.format`, Anthropic `output_config.format`, Gemini `output_schema`), and Anthropic reads `effort` into `output_config.effort`. Every param that only assessment set (`top_p`, `max_output_tokens`, `thinking_level`, `thinking`, `output_schema`) defaults to `None` on `TextLLMParams` and is dropped by `ParamSerialization._dump_compact`, so a config that does not set it maps exactly as before. Anthropic never receives `temperature`/`top_p`: the Messages API returns 400 for a non-default sampling value on every Claude model Kaapi serves, so the mapper drops both, warning only when the value was not Anthropic's own default of 1.0. `normalize_llm_text` no longer lives here; it moved to `services/assessment/validators.py`, the only place that calls it.
 - `services/guardrails/` — validator execution
 - `crud/llm.py`, `crud/llm_chain.py`, `crud/config/` — persistence
 
diff --git a/docs/wiki/modules/platform.md b/docs/wiki/modules/platform.md
index a41197c24..19d4923b4 100644
--- a/docs/wiki/modules/platform.md
+++ b/docs/wiki/modules/platform.md
@@ -13,7 +13,7 @@ All paths relative to `backend/app/`.
 | Credentials | `api/routes/credentials.py` | `credential` (`models/credentials.py`) | `crud/credentials.py`; provider keys per org/project; envelope encryption (KMS-wrapped data key + AES-GCM), prefix-versioned ciphertexts |
 | Model config | `api/routes/model_config.py` | `model_config` (`models/model_config.py`) | `crud/model_config.py` |
 | Bucket providers | — | reuses `credential` (`google-gcp`) | `services/buckets/` — global registry + resolver (`providers/`), GCS V4 signed + bulk-signed URLs with a 24h expiry cap (`providers/gcs.py`, cap in `providers/base.py`), attachment path selection + URL resolution (`attachments.py`) |
-| Cron | `api/routes/cron.py` | — | triggers batch polling (`crud/evaluations/cron.py`) |
+| Cron | `api/routes/cron.py` | — | triggers batch polling (`crud/evaluations/cron.py`, `crud/assessment/cron.py` — the latter polls `method == RUN` assessments only; API-client BATCH runs are driven by their own Celery self-re-enqueue) |
 | Jobs | — | `job` (`models/job.py`), `batch_job` (`models/batch_job.py`) | `crud/jobs.py`, `crud/job/`, `services/job_monitoring.py` |
 
 ## Credential contracts