diff --git a/.changeset/prerun-feedback-and-run-gate.md b/.changeset/prerun-feedback-and-run-gate.md
new file mode 100644
index 0000000..b88624d
--- /dev/null
+++ b/.changeset/prerun-feedback-and-run-gate.md
@@ -0,0 +1,92 @@
+---
+'@platforma-open/milaboratories.import-vdj.workflow': patch
+'@platforma-open/milaboratories.import-vdj.model': patch
+'@platforma-open/milaboratories.import-vdj.ui': patch
+'@platforma-open/milaboratories.import-vdj': patch
+---
+
+Say what the block is checking, and refuse to run until it has
+
+Loading a file left the panel silent while every column of it was profiled — a whole-file pass,
+minutes on remote storage — and the profile outputs are retentive, so the dropdowns went on
+answering with the *previous* file's headers as though nothing had happened. A mapping that had
+passed every check against that previous file also still counted as valid, so Run stayed live over
+a file nobody had read yet, against headers it might not even contain.
+
+- **The wait is announced, on both doors.** Prerun now states which file a profile was taken from,
+  and which dataset and format an inference was run for; the model pairs each with its result so the
+  two cannot get out of step. The panel announces the wait and withholds the mapping until the
+  columns on offer really belong to what is selected. Keyed to the input rather than to "prerun is
+  busy", because prerun also re-runs on every mapping edit to re-check the id column. The import
+  itself now shows the block's loader, which it never did. The verdict about the selected columns
+  now sits below the controls it is about, rather than between them.
+- **The column list waits until it has something to list.** "The following columns will be
+  imported:" appeared with nothing under it as soon as a dataset was picked, before any format was,
+  which read as an import that would emit nothing. It also outlived a dataset switch, listing the
+  previous dataset's columns.
+- **Loading a second file disables Run.** Picking a different file drops the parts of the mapping
+  that name columns, keeping the receptor declaration and the numbering scheme, which describe the
+  data rather than one file. Re-picking the same file is not a swap and keeps the mapping.
+- **A repeated id column now stops the run.** The record key is the identity's hash, so a value
+  repeated on rows that are not identical merges two records into one. Prerun always found these
+  and the panel always warned, but the warning was only a warning, and a run driven through the API
+  imported the merged set without complaint. Run is now refused both while the verdict is
+  outstanding and when it reports a repeat, and the platform enforces it as well as the interface.
+- **The warning names the mapping it is about.** It used to compare against the freshly picked
+  column while the verdict was still the previous mapping's, so changing an offending column flashed
+  the old accusation under the new selection. What a verdict covers is the id column *and* the
+  sequence columns, since a collision is a repeated id whose other mapped cells differ — keyed on
+  the id alone, a clean verdict outlived a remapped chain and the run gate accepted it. It also listed up to ten repeated values; it now lists three and a count,
+  printed whole, since the id column can hold sequences and trimming those hides what tells them
+  apart.
+- **Run waits for the dataset to be judged.** For the seven non-custom formats Run was gated on
+  booleans the UI mirrored back from `validationResult`, keyed on the *format* alone and never on
+  the dataset. Switching between two datasets of the same format left the previous one's verdict
+  standing, so Run armed at once while the panel was still scanning. The five `*ColumnsPresent`
+  fields and their watcher are gone, replaced by a second case of `prerunCheck` — the same shape the
+  collision check already uses: the verdict carries the dataset *and format* it was reached for,
+  and one left over from an earlier selection reads as "not judged yet" rather than being applied.
+  Run is refused both while a verdict is outstanding and when it reports missing columns.
+
+  `validationResult` now takes the format from prerun's stamp rather than from live block data, so
+  both halves of the question come from one staging context and a verdict can no longer judge one
+  dataset's headers under another's format. It states the dataset it judged, which is what lets the
+  UI mirror it in by copying rather than by matching the two outputs against the selection — there
+  is no comparison left in the hairpin to get wrong.
+- **One provenance stamp, not two, and it names a dataset.** The file door emitted
+  `profiledSampleId` and the dataset door `inferredFor`; both answered the same question — what the
+  prerun results on screen were computed for — and only one door is ever live. They are now a
+  single `prerunDatasetValidationInfo`, tagged by door: `{ door: "file", datasetId }` or
+  `{ door: "dataset", datasetRef, format }`. Tagged rather than flattened because the two answers
+  are not interchangeable — the file door names a dataset that *is* the file, the dataset door
+  names one already in the pool — and side by side they otherwise read as one id in two formats. `FileSource.sampleId` is renamed `datasetId` to match: one file is
+  one dataset, and it is only *today* that the dataset is also one sample, which is why that value
+  also mints the `pl7.app/sampleId` key. A file carrying several samples would name those from its
+  own contents while this stayed the identity of the file they came from. The value mints an axis
+  key and v1 shipped in block 1.8.1, so the rename carries a `v1 -> v2` data migration rather than
+  relying on the old key being absent — without it a saved project would key its records on
+  `undefined` and lose every join a downstream block had made.
+
+- **Re-reading a file no longer changes its identity.** The id was minted on every pick, so
+  re-selecting the same file — which is also how a file gets re-read — handed it a new one. Since
+  that value mints the `pl7.app/sampleId` key, the re-read silently orphaned every join a
+  downstream block had made against the old key, with nothing on screen to say so. It is now minted
+  only when the handle changes, which is the same test that decides whether the mapping is dropped,
+  and which the field's own contract had claimed all along. Two different files that share a name
+  are still a swap: their handles differ. They do share a label, since that is the filename stem.
+- **Alert headings appear.** Four alerts passed their heading to a slot `PlAlert` does not have, so
+  the headings had never rendered — a warning about a non-unique id column read as an unlabelled
+  wall of values.
+- **The id column can be cleared.** Clearing it left the field reading "Value not available" in
+  red: "nothing chosen" is stored as an empty string, and a dropdown counts any value that is not
+  `undefined` as chosen. Relatedly, two places named the IG chain pair where they meant every
+  mapped chain, so a TCR mapping could never clear itself and was offered its own sequence columns
+  as record properties.
+
+Refusing the run on a prerun verdict needs that verdict inside the args projection, which sees only
+the block's own data, so the UI mirrors it in. That is a hairpin, and deliberate: unlike a column
+mapping there is no gesture at which the fact could be captured, because the scientist picks a
+column and only then does the check discover whether it is sound. The two rules that keep it safe —
+a verdict carries what it is about, and is dropped when the source changes — are stated on
+`BlockData.prerunChecks`, and the checks still to come should follow them. It can all go once
+`argsValid` can read prerun directly.
diff --git a/model/src/data-model.ts b/model/src/data-model.ts
index ab96a0e..879ebf5 100644
--- a/model/src/data-model.ts
+++ b/model/src/data-model.ts
@@ -4,37 +4,12 @@ import type { BlockData, LegacyBlockArgs, LegacyUiState } from "./types";
 /** The six chains a fresh block offers. Unchanged from V1's `withArgs` default. */
 const DEFAULT_CHAINS = ["IGHeavy", "IGLight", "TCRAlpha", "TCRBeta", "TCRDelta", "TCRGamma"];
 
-/**
- * View-state defaults, shared by the fresh-project initialiser and the legacy upgrade.
- *
- * The upgrade needs them because V1's `uiState` fields are all optional on disk: a project
- * saved before a flag was introduced simply has no value for it, and an undefined boolean
- * reaching `argsValid` used to read as false by accident. Making the defaults explicit here
- * means the V3 data is complete whatever shape the project was saved in.
- */
+/** View-state defaults, shared by the fresh-project initialiser and the legacy upgrade. */
 const viewStateDefaults = () => ({
   tableState: createPlDataTableStateV2(),
   settingsOpen: true,
-  qiagenColumnsPresent: false,
-  immunoSeqColumnsPresent: false,
-  mixcrColumnsPresent: false,
-  crColumnsPresent: false,
-  airrColumnsPresent: false,
 });
 
-/**
- * V1 kept the scientist's edits in two buckets — `args` and `uiState`. V3 keeps them in one,
- * and derives what the workflow sees. This upgrade runs once per project, the first time a
- * project saved under V1 is opened.
- *
- * The mapping is field-for-field: nothing is reshaped, because nothing in V1's shape was bent
- * to dodge the stale gate. What changes is where the fields *go afterwards* — the labels and
- * the secondary count type stop being projected into args, which is the whole point of the
- * migration for this block. See `index.ts`.
- *
- * V1's `loadFromFile` is dropped rather than carried: the panel now derives which door it is
- * showing from whether a file is loaded, so a stored flag could only disagree with the data.
- */
 export function upgradeLegacyData({
   args,
   uiState,
@@ -59,9 +34,23 @@ export function upgradeLegacyData({
   };
 }
 
+/** `FileSource.sampleId` became `datasetId`. The value mints an axis key, so it must carry over. */
+type FileSourceV1 = { sampleId?: string; datasetId?: string } & Record<string, unknown>;
+
+function renameSampleIdToDatasetId(data: BlockData): BlockData {
+  const fileSource = data.fileSource as FileSourceV1 | undefined;
+  if (fileSource === undefined) return data;
+  const { sampleId, ...rest } = fileSource;
+  return {
+    ...data,
+    fileSource: { ...rest, datasetId: fileSource.datasetId ?? sampleId } as BlockData["fileSource"],
+  };
+}
+
 export const blockDataModel = new DataModelBuilder()
   .from<BlockData>("v1")
   .upgradeLegacy<LegacyBlockArgs, LegacyUiState>(upgradeLegacyData)
+  .migrate<BlockData>("v2", renameSampleIdToDatasetId)
   .init(() => ({
     ...viewStateDefaults(),
     defaultBlockLabel: "",
diff --git a/model/src/index.ts b/model/src/index.ts
index 1d1479a..ea8c583 100644
--- a/model/src/index.ts
+++ b/model/src/index.ts
@@ -1,4 +1,4 @@
-import type { InferOutputsType, PColumnKey, PColumnValue } from "@platforma-sdk/model";
+import type { InferOutputsType, PColumnKey, PColumnValue, PlRef } from "@platforma-sdk/model";
 import {
   BlockModelV3,
   DataColumn,
@@ -6,8 +6,15 @@ import {
   TreeNodeAccessor,
 } from "@platforma-sdk/model";
 import { blockDataModel } from "./data-model";
-import type { BlockArgs, BlockData, ColumnDescription, ColumnProfile } from "./types";
-import { bareSetValid } from "./types";
+import type {
+  BareSetMapping,
+  BlockArgs,
+  BlockData,
+  ColumnDescription,
+  ColumnProfile,
+  ImportFormat,
+} from "./types";
+import { bareSetValid, collisionCheckKey, datasetCheckKey } from "./types";
 
 export * from "./types";
 export { upgradeLegacyData } from "./data-model";
@@ -39,14 +46,42 @@ function withoutDatasetDoorMapping(args: BlockArgs): BlockArgs {
 }
 
 /**
- * The workflow's view of the block, and the only place validation lives.
+ * Refuse a bare set whose mapped columns prerun has not cleared — including when there is no
+ * verdict yet. The record key is the identity's hash, so running before the answer is in is how two
+ * different records silently become one.
+ */
+function requireCheckedColumns(data: BlockData): void {
+  const columns = collisionCheckKey(data.bareSet);
+  if (columns === undefined) return; // bareSetValid has already refused
+  const check = data.prerunCheck;
+  if (check?.check !== "columns" || check.subject !== columns) {
+    throw new Error("Validating the selected columns");
+  }
+  if (check.identityCollides) {
+    throw new Error(`"${data.bareSet?.identity}" repeats on rows that are not identical`);
+  }
+}
+
+/**
+ * Refuse the run until prerun has judged the dataset and format actually selected.
  *
- * Three jobs, in order: refuse what cannot run (by throwing), drop the door that is not in
- * use, and drop the fields the chosen path never reads. What it deliberately does NOT do is
- * reorder `chains`: canonicalising a set the user picked in their own order would change the
- * args of every project already on disk, and buys only the rare case of someone re-picking the
- * same chains in a different order.
+ * The verdict carries the dataset it was reached for, so one left over from a previous selection
+ * reads as "not judged yet" rather than being applied to this one. That is the whole of the rule
+ * the old per-format flags broke: they were keyed on the format alone, so switching between two
+ * datasets of the same format left the previous verdict standing and Run armed on it.
  */
+function requireCheckedDataset(data: BlockData): void {
+  const dataset = datasetCheckKey(data);
+  if (dataset === undefined) return; // the file door, or nothing picked yet
+  const check = data.prerunCheck;
+  if (check?.check !== "dataset" || check.subject !== dataset) {
+    throw new Error("Validating the selected columns");
+  }
+  if (!check.columnsPresent) {
+    throw new Error(`The dataset does not carry the columns a ${data.format} dataset needs`);
+  }
+}
+
 function projectArgs(data: BlockData): BlockArgs {
   const { datasetRef, format, chains, customMapping, primaryCountType, fileSource } = data;
 
@@ -60,6 +95,8 @@ function projectArgs(data: BlockData): BlockArgs {
     datasetRef,
     fileSource,
     format,
+    // Not sorted: canonicalising an order the user chose would change the args of every project
+    // already on disk, to buy the rare re-pick of the same chains in a different order.
     chains,
     customMapping,
     primaryCountType,
@@ -72,6 +109,7 @@ function projectArgs(data: BlockData): BlockArgs {
   // mapping unfurled under a format nobody had chosen.
   if (fileSource !== undefined) {
     if (!bareSetValid(data.bareSet)) throw new Error("Finish mapping the file's columns");
+    requireCheckedColumns(data);
     return withoutDatasetDoorMapping(args);
   }
 
@@ -85,6 +123,7 @@ function projectArgs(data: BlockData): BlockArgs {
     // identity column, because the key is the identity's hash and the label is its value.
     if (data.bareSet !== undefined) {
       if (!bareSetValid(data.bareSet)) throw new Error("Finish mapping the record's columns");
+      requireCheckedColumns(data);
       return withoutDatasetDoorMapping(args);
     }
 
@@ -100,21 +139,10 @@ function projectArgs(data: BlockData): BlockArgs {
     return args;
   }
 
-  // The per-format flags are written by the UI from the `validationResult` output. They are a
-  // mirror of a derivation, which is a hairpin, but replacing them is a separate change: the
-  // check they stand for needs the file's headers, and the args lambda cannot reach prerun.
-  const presentByFormat: Record<string, boolean> = {
-    qiagen: data.qiagenColumnsPresent === true,
-    immunoSeq: data.immunoSeqColumnsPresent === true,
-    mixcr: data.mixcrColumnsPresent === true,
-    "mixcr-sc": data.mixcrColumnsPresent === true,
-    cellranger: data.crColumnsPresent === true,
-    airr: data.airrColumnsPresent === true,
-    "airr-sc": data.airrColumnsPresent === true,
-  };
-  if (format in presentByFormat && !presentByFormat[format]) {
-    throw new Error(`The file does not carry the columns a ${format} dataset needs`);
-  }
+  // The check needs the dataset's headers, which live in prerun, and a V3 args lambda receives
+  // `data` only. So the verdict is mirrored in — the same hairpin the collision check uses, under
+  // the same contract, which is what keeps it from repeating the per-format flags' mistake.
+  requireCheckedDataset(data);
 
   return args;
 }
@@ -143,15 +171,6 @@ export const platforma = BlockModelV3.create(blockDataModel)
     bareSet: data.bareSet,
   }))
 
-  /**
-   * Identity values that appear on rows which are not identical to each other.
-   *
-   * Not `retentive`: this gates the run, so a stale value is worse than a briefly absent one.
-   *
-   * Read straight from prerun here, and *not* mirrored into `uiState` from a UI watcher. That
-   * mirror is what the format-validity flags do, and it is a hairpin — an output written back
-   * into state that a derivation then reads. It survives on one client and races on two.
-   */
   /**
    * Drives the upload for a directly-loaded file.
    *
@@ -177,7 +196,19 @@ export const platforma = BlockModelV3.create(blockDataModel)
     { isActive: true },
   )
 
+  /**
+   * Identity values repeated on rows that are not identical, with the mapping they were found
+   * under. One value, so the two can never be read from different runs.
+   *
+   * Not `retentive`: this reports a defect, so a briefly absent verdict beats a stale one.
+   */
   .output("identityCollisions", (ctx) => {
+    const mapping = ctx.prerun
+      ?.resolve({ field: "collisionsFor", allowPermanentAbsence: true })
+      ?.getDataAsJsonOrUndefined<Pick<BareSetMapping, "identity" | "sequences">>();
+    const key = collisionCheckKey(mapping);
+    if (key === undefined) return undefined;
+
     const raw = ctx.prerun
       ?.resolve({ field: "identityCollisions", allowPermanentAbsence: true })
       ?.getDataAsString();
@@ -188,7 +219,7 @@ export const platforma = BlockModelV3.create(blockDataModel)
       .split("\n")
       .map((l) => l.trim())
       .filter((l) => l.length > 0);
-    return lines.slice(1);
+    return { key, values: lines.slice(1) };
   })
 
   .retentiveOutput("datasetOptions", (ctx) => {
@@ -264,6 +295,40 @@ export const platforma = BlockModelV3.create(blockDataModel)
     }
   })
 
+  /**
+   * What the prerun results on screen were computed for. A mismatch with what is selected now
+   * means the panel is still showing the previous one's columns.
+   *
+   * Tagged by door because the two answers are not interchangeable: the file door names a dataset
+   * that IS the file, by a minted id; the dataset door names one already in the result pool, by a
+   * ref. Exactly one door is ever live — `projectArgs` refuses both at once.
+   *
+   * Keyed to the input rather than to "prerun is busy": prerun also re-runs on every mapping edit,
+   * to re-check the identity column.
+   */
+  .retentiveOutput("prerunDatasetValidationInfo", (ctx) => {
+    // Gate on the result the stamp describes, whichever door produced it. The read is marked
+    // unstable, so `retentive` keeps reporting the previous input until the new result lands and
+    // the two can never disagree.
+    const backing =
+      ctx.prerun?.resolve({ field: "columnProfile", allowPermanentAbsence: true }) ??
+      ctx.prerun?.resolve({ field: "headerColumns", allowPermanentAbsence: true });
+    if (backing === undefined) return undefined;
+    if (!backing.getIsReadyOrError()) return undefined;
+    return ctx.prerun
+      ?.resolve({ field: "prerunDatasetValidationInfo", allowPermanentAbsence: true })
+      ?.getDataAsJsonOrUndefined<
+        | { door: "file"; datasetId: string }
+        | { door: "dataset"; datasetRef?: PlRef; format?: ImportFormat }
+      >();
+  })
+
+  /**
+   * Drives the block's loader (`ui/src/app.ts`). Excludes prerun: the loader covers the whole
+   * block, and prerun re-runs while the settings panel is being edited.
+   */
+  .output("isRunning", (ctx) => ctx.outputs?.getIsReadyOrError() === false)
+
   /** Headers of the dataset selected from the pool. Absent on the file door. */
   .retentiveOutput("datasetColumns", (ctx) => {
     const headers = ctx.prerun
@@ -286,143 +351,156 @@ export const platforma = BlockModelV3.create(blockDataModel)
       })
       ?.getDataAsJson<string[]>();
 
-    if (!headerColumns || !ctx.data.format) {
+    // The format comes from prerun's own stamp, not from `ctx.data`. Both halves of the question
+    // then come from the same staging context, so a verdict cannot pair one dataset's headers with
+    // another's format while a switch is in flight — which it could when the format was read live.
+    const stamp = ctx.prerun
+      ?.resolve({ field: "prerunDatasetValidationInfo", allowPermanentAbsence: true })
+      ?.getDataAsJsonOrUndefined<{ door?: string; datasetRef?: PlRef; format?: ImportFormat }>();
+
+    if (!headerColumns || stamp?.door !== "dataset" || !stamp.format || !stamp.datasetRef) {
       return undefined;
     }
 
-    const format = ctx.data.format;
+    const format = stamp.format;
     const headers = headerColumns;
+    // The verdict carries what it is about, so the UI mirrors it in without matching anything.
+    const dataset = datasetCheckKey({ datasetRef: stamp.datasetRef, format });
+
+    const verdict = ((): { isValid: boolean; missingColumns: string[]; format: string } => {
+      if (format === "qiagen") {
+        const qiagenColumns = [
+          "read set",
+          "chain",
+          "V-region",
+          "J-region",
+          "CDR3 nucleotide seq",
+          "CDR3 amino acid seq",
+          "frequency",
+          "rank",
+          "UMIs with analytical threshold",
+          "nucleotide length",
+          "amino acid length",
+        ];
+
+        const missingColumns = qiagenColumns.filter((col) => !headers.includes(col));
+
+        return {
+          isValid: missingColumns.length === 0,
+          missingColumns,
+          format: "qiagen",
+        };
+      }
 
-    if (format === "qiagen") {
-      const qiagenColumns = [
-        "read set",
-        "chain",
-        "V-region",
-        "J-region",
-        "CDR3 nucleotide seq",
-        "CDR3 amino acid seq",
-        "frequency",
-        "rank",
-        "UMIs with analytical threshold",
-        "nucleotide length",
-        "amino acid length",
-      ];
-
-      const missingColumns = qiagenColumns.filter((col) => !headers.includes(col));
-
-      return {
-        isValid: missingColumns.length === 0,
-        missingColumns,
-        format: "qiagen",
-      };
-    }
+      if (format === "immunoSeq") {
+        const hasAny = (aliases: string[]) => aliases.some((alias) => headers.includes(alias));
+        const missingColumns: string[] = [];
+        if (!hasAny(["rearrangement", "nucleotide"])) missingColumns.push("sequence");
+        if (!hasAny(["amino_acid_sequence", "amino_acid", "aminoAcid"]))
+          missingColumns.push("cdr3-aa");
+        if (!hasAny(["v_gene", "v-gene", "vGene", "vGeneName"])) missingColumns.push("v-gene");
+        if (!hasAny(["d_gene", "d-gene", "dGene", "dGeneName"])) missingColumns.push("d-gene");
+        if (!hasAny(["j_gene", "j-gene", "jGene", "jGeneName"])) missingColumns.push("j-gene");
+        if (!hasAny(["v-index", "v_index", "vIndex"])) missingColumns.push("v-begin");
+        if (!hasAny(["count (templates/reads)", "count (reads)", "seq_reads", "reads", "count"])) {
+          missingColumns.push("read-count");
+        }
 
-    if (format === "immunoSeq") {
-      const hasAny = (aliases: string[]) => aliases.some((alias) => headers.includes(alias));
-      const missingColumns: string[] = [];
-      if (!hasAny(["rearrangement", "nucleotide"])) missingColumns.push("sequence");
-      if (!hasAny(["amino_acid_sequence", "amino_acid", "aminoAcid"]))
-        missingColumns.push("cdr3-aa");
-      if (!hasAny(["v_gene", "v-gene", "vGene", "vGeneName"])) missingColumns.push("v-gene");
-      if (!hasAny(["d_gene", "d-gene", "dGene", "dGeneName"])) missingColumns.push("d-gene");
-      if (!hasAny(["j_gene", "j-gene", "jGene", "jGeneName"])) missingColumns.push("j-gene");
-      if (!hasAny(["v-index", "v_index", "vIndex"])) missingColumns.push("v-begin");
-      if (!hasAny(["count (templates/reads)", "count (reads)", "seq_reads", "reads", "count"])) {
-        missingColumns.push("read-count");
+        return {
+          isValid: missingColumns.length === 0,
+          missingColumns,
+          format: "immunoSeq",
+        };
       }
 
-      return {
-        isValid: missingColumns.length === 0,
-        missingColumns,
-        format: "immunoSeq",
-      };
-    }
-
-    if (format === "mixcr") {
-      // MiXCR minimal requirements aligned with infer-columns-mixcr.lib.tengo
-      const mixcrRequiredHeaders = ["readCount", "nSeqCDR3", "aaSeqCDR3"];
+      if (format === "mixcr") {
+        // MiXCR minimal requirements aligned with infer-columns-mixcr.lib.tengo
+        const mixcrRequiredHeaders = ["readCount", "nSeqCDR3", "aaSeqCDR3"];
 
-      const missingColumns = mixcrRequiredHeaders.filter((col) => !headers.includes(col));
+        const missingColumns = mixcrRequiredHeaders.filter((col) => !headers.includes(col));
 
-      return {
-        isValid: missingColumns.length === 0,
-        missingColumns,
-        format: "mixcr",
-      };
-    }
+        return {
+          isValid: missingColumns.length === 0,
+          missingColumns,
+          format: "mixcr",
+        };
+      }
 
-    if (format === "mixcr-sc") {
-      // Same as MiXCR plus at least one tagValueCELL* column
-      const mixcrRequiredHeaders = ["readCount", "nSeqCDR3", "aaSeqCDR3"];
-      const missingBase = mixcrRequiredHeaders.filter((col) => !headers.includes(col));
-      const hasTagValueCell = headers.some((h) => h.startsWith("tagValueCELL"));
-      const missingColumns = [
-        ...missingBase,
-        ...(hasTagValueCell ? ([] as string[]) : ["tagValueCELL*"]),
-      ];
-      return {
-        isValid: missingColumns.length === 0,
-        missingColumns,
-        format: "mixcr-sc",
-      };
-    }
+      if (format === "mixcr-sc") {
+        // Same as MiXCR plus at least one tagValueCELL* column
+        const mixcrRequiredHeaders = ["readCount", "nSeqCDR3", "aaSeqCDR3"];
+        const missingBase = mixcrRequiredHeaders.filter((col) => !headers.includes(col));
+        const hasTagValueCell = headers.some((h) => h.startsWith("tagValueCELL"));
+        const missingColumns = [
+          ...missingBase,
+          ...(hasTagValueCell ? ([] as string[]) : ["tagValueCELL*"]),
+        ];
+        return {
+          isValid: missingColumns.length === 0,
+          missingColumns,
+          format: "mixcr-sc",
+        };
+      }
 
-    if (format === "cellranger") {
-      // Cell Ranger VDJ clones per-chain table minimal required headers
-      const cellrangerRequired = ["cdr3_nt", "cdr3", "v_gene", "j_gene", "barcode"];
-      const missingColumns = cellrangerRequired.filter((col) => !headers.includes(col));
-      return {
-        isValid: missingColumns.length === 0,
-        missingColumns,
-        format: "cellranger",
-      };
-    }
+      if (format === "cellranger") {
+        // Cell Ranger VDJ clones per-chain table minimal required headers
+        const cellrangerRequired = ["cdr3_nt", "cdr3", "v_gene", "j_gene", "barcode"];
+        const missingColumns = cellrangerRequired.filter((col) => !headers.includes(col));
+        return {
+          isValid: missingColumns.length === 0,
+          missingColumns,
+          format: "cellranger",
+        };
+      }
 
-    if (format === "airr" || format === "airr-sc") {
-      // AIRR format uses case-insensitive column names
-      // Required: duplicate_count, junction (CDR3 nt), v_call, j_call
-      // For single-cell: also requires cell_id
-      // Handle case where headerColumns might be a single comma-separated string or array of strings
-      const flattenedHeaders: string[] = [];
-      for (const h of headers) {
-        const str = String(h).trim();
-        // If the string contains commas, split it
-        if (str.includes(",")) {
-          flattenedHeaders.push(
-            ...str
-              .split(",")
-              .map((s) => s.trim())
-              .filter((s) => s.length > 0),
-          );
-        } else {
-          flattenedHeaders.push(str);
+      if (format === "airr" || format === "airr-sc") {
+        // AIRR format uses case-insensitive column names
+        // Required: duplicate_count, junction (CDR3 nt), v_call, j_call
+        // For single-cell: also requires cell_id
+        // Handle case where headerColumns might be a single comma-separated string or array of strings
+        const flattenedHeaders: string[] = [];
+        for (const h of headers) {
+          const str = String(h).trim();
+          // If the string contains commas, split it
+          if (str.includes(",")) {
+            flattenedHeaders.push(
+              ...str
+                .split(",")
+                .map((s) => s.trim())
+                .filter((s) => s.length > 0),
+            );
+          } else {
+            flattenedHeaders.push(str);
+          }
         }
-      }
-      const headersLower = flattenedHeaders.map((h) => h.toLowerCase());
-      const airrRequired = ["duplicate_count", "junction", "v_call", "j_call"];
-      const missingColumns = airrRequired.filter((req) => !headersLower.includes(req));
-
-      // For single-cell AIRR, also require cell_id
-      if (format === "airr-sc") {
-        const hasCellId = headersLower.includes("cell_id");
-        if (!hasCellId) {
-          missingColumns.push("cell_id");
+        const headersLower = flattenedHeaders.map((h) => h.toLowerCase());
+        const airrRequired = ["duplicate_count", "junction", "v_call", "j_call"];
+        const missingColumns = airrRequired.filter((req) => !headersLower.includes(req));
+
+        // For single-cell AIRR, also require cell_id
+        if (format === "airr-sc") {
+          const hasCellId = headersLower.includes("cell_id");
+          if (!hasCellId) {
+            missingColumns.push("cell_id");
+          }
         }
+
+        return {
+          isValid: missingColumns.length === 0,
+          missingColumns,
+          format: format,
+        };
       }
 
+      // For other formats, validation is handled elsewhere or not needed
       return {
-        isValid: missingColumns.length === 0,
-        missingColumns,
+        isValid: true,
+        missingColumns: [],
         format: format,
       };
-    }
+    })();
 
-    // For other formats, validation is handled elsewhere or not needed
-    return {
-      isValid: true,
-      missingColumns: [],
-      format: format,
-    };
+    return { ...verdict, dataset };
   })
 
   /**
diff --git a/model/src/types.ts b/model/src/types.ts
index 6ef71ee..06757f6 100644
--- a/model/src/types.ts
+++ b/model/src/types.ts
@@ -14,11 +14,8 @@ export type CountType = "read" | "umi";
 
 export type FileSource = {
   handle: ImportFileHandle;
-  /**
-   * Minted in the UI at the moment the file is picked, not derived from the handle, so the
-   * sample keeps its identity across runs even if the same file is re-selected.
-   */
-  sampleId: string;
+  /** Unique id for the dataset this file holds. Minted when the file is picked. */
+  datasetId: string;
   /** The filename stem — exactly what samples-and-data would have labelled the sample. */
   label: string;
   /**
@@ -79,7 +76,7 @@ export const CHAIN_SLOTS: Record<ChainSelection, BareSetChain[]> = {
  * IMGT is position-unified and chain-agnostic — ANARCI's `number_imgt` takes no chain type at
  * all. Kabat, Chothia, Martin and Wolfguy were defined on antibody structures and ANARCI
  * implements them for `H`/`K`/`L` only, raising "Unimplemented numbering scheme" for a TCR chain
- * (anarci.py:558-592). So a TCR selection can only be numbered under IMGT, and offering the
+ * (anarci.py). So a TCR selection can only be numbered under IMGT, and offering the
  * others would hand the scientist a choice that fails the run.
  */
 export const SCHEMES_FOR_SELECTION: Record<ChainSelection, BareSetScheme[]> = {
@@ -110,6 +107,13 @@ export const CHAIN_SLOT_LABELS: Record<BareSetChain, string> = {
   TCRGamma: "TCR-ɣ",
 };
 
+/** What to call each numbering scheme in front of the scientist. */
+export const SCHEME_LABELS: Record<BareSetScheme, string> = {
+  imgt: "IMGT",
+  kabat: "Kabat",
+  chothia: "Chothia",
+};
+
 /** What a column can hold, decided by profiling every row of the file. */
 export type ColumnValueType = "Long" | "Double" | "String";
 
@@ -222,14 +226,33 @@ export type BlockData = {
   // --- bare set. Its presence is what selects the bare path in the workflow.
   bareSet?: BareSetMapping;
 
+  /**
+   * What prerun found, kept here so the args projection — which sees only `data` — can gate the run
+   * on it. Written by the UI (`ui/src/app.ts`).
+   *
+   * The verdict carries what it is *about*, so one reached for something no longer selected is
+   * ignored rather than applied. Tagged by which check it is: the two paths through `projectArgs`
+   * that consult a verdict return before reaching each other, so only ever one is live.
+   */
+  prerunCheck?:
+    | {
+        check: "columns";
+        /** The mapping the verdict was reached for — see {@link collisionCheckKey}. */
+        subject: string;
+        /** The id column repeats on rows whose other mapped cells differ, so two records merge. */
+        identityCollides: boolean;
+      }
+    | {
+        check: "dataset";
+        /** The dataset and format the verdict was reached for — see {@link datasetCheckKey}. */
+        subject: string;
+        /** The dataset carries the columns its declared format needs. */
+        columnsPresent: boolean;
+      };
+
   // --- view state. None of this is projected anywhere.
   tableState: PlDataTableStateV2;
   settingsOpen: boolean;
-  qiagenColumnsPresent: boolean;
-  immunoSeqColumnsPresent: boolean;
-  mixcrColumnsPresent: boolean;
-  crColumnsPresent: boolean;
-  airrColumnsPresent: boolean;
 };
 
 /** The V1 `args` bucket, as it sits in projects saved before the V3 migration. */
@@ -250,17 +273,12 @@ export type LegacyBlockArgs = {
 export type LegacyUiState = {
   tableState?: PlDataTableStateV2;
   settingsOpen?: boolean;
-  qiagenColumnsPresent?: boolean;
-  immunoSeqColumnsPresent?: boolean;
-  mixcrColumnsPresent?: boolean;
-  crColumnsPresent?: boolean;
-  airrColumnsPresent?: boolean;
 };
 
 /**
  * The SDK's `substituteSpecialCharacters` class, mirrored so the model can refuse a collision
  * without a round trip to the workflow. Kept in step with
- * `sdk/workflow-tengo/src/strings.lib.tengo:4`.
+ * the SDK's `strings.lib.tengo`.
  */
 const SPECIAL_CHARACTERS = /[-_,.:; +()!<>[\]}{"\\/:$%^#@*&]+/g;
 
@@ -278,6 +296,51 @@ export function propertyCollisions(properties: ImportedProperty[]): Record<strin
   return Object.fromEntries(Object.entries(byToken).filter(([, hs]) => hs.length > 1));
 }
 
+/**
+ * What a collision verdict is about. A collision is an identity repeated on rows whose *other
+ * mapped cells* differ, so the sequence columns are part of the question and remapping a chain
+ * invalidates the answer. Sorted, so the key does not depend on the order columns were picked in.
+ */
+export function collisionCheckKey(
+  mapping: Pick<BareSetMapping, "identity" | "sequences"> | undefined,
+): string | undefined {
+  if (mapping === undefined || !mapping.identity) return undefined;
+  const mapped = Object.entries(mapping.sequences ?? {})
+    .filter(([, column]) => Boolean(column))
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([slot, column]) => `${slot}=${column}`);
+  return [mapping.identity, ...mapped].join("\u0000");
+}
+
+/**
+ * What a dataset-door verdict is about: the dataset picked and the format it was declared to be.
+ * Both, because the same dataset answers differently under a different format.
+ *
+ * `undefined` when there is nothing to check yet — no dataset, or no format — which is also how
+ * the caller tells the dataset door from the file door.
+ */
+export function datasetCheckKey(
+  data: Pick<BlockData, "datasetRef" | "format">,
+): string | undefined {
+  const ref = data.datasetRef;
+  if (ref === undefined || data.format === undefined) return undefined;
+  return [ref.blockId, ref.name, data.format].join("\u0000");
+}
+
+/**
+ * The mapping with everything that names a column dropped. The receptor declaration and the
+ * numbering scheme describe the biology and outlive any one file; the column names do not.
+ */
+export function forgetMappedColumns(bare: BareSetMapping | undefined): BareSetMapping | undefined {
+  if (bare === undefined) return undefined;
+  return {
+    identity: "",
+    chainSelection: bare.chainSelection,
+    sequences: {},
+    scheme: bare.scheme,
+  };
+}
+
 /**
  * Whether a bare-set mapping is complete enough to run.
  *
diff --git a/test/src/messages.test.ts b/test/src/messages.test.ts
new file mode 100644
index 0000000..f2f7401
--- /dev/null
+++ b/test/src/messages.test.ts
@@ -0,0 +1,76 @@
+import { collisionCheckKey } from "@platforma-open/milaboratories.import-vdj.model";
+import { describe, expect, test } from "vitest";
+import {
+  emptySamplesMessage,
+  formatLabel,
+  identityCollisionMessage,
+  missingColumnsMessage,
+  propertyCollisionMessage,
+} from "../../ui/src/pages/messages";
+
+describe("ui messages", () => {
+  test("empty samples: under the cap", () => {
+    expect(emptySamplesMessage({ emptySamples: ["S1", "S2"] })).toBe(
+      "After receptor chain filtering, no clonotypes found in sample(s) S1, S2",
+    );
+  });
+  test("empty samples: over the cap truncates at 5", () => {
+    expect(emptySamplesMessage({ emptySamples: ["a", "b", "c", "d", "e", "f", "g"] })).toBe(
+      "After receptor chain filtering, no clonotypes found in sample(s) a, b, c, d, e and 2 more",
+    );
+  });
+  test("empty samples: none is undefined, not an empty string", () => {
+    expect(emptySamplesMessage({ emptySamples: [] })).toBeUndefined();
+    expect(emptySamplesMessage(undefined)).toBeUndefined();
+  });
+  test("format label falls back to the raw id", () => {
+    expect(formatLabel("mixcr")).toBe("MiXCR bulk");
+    expect(formatLabel("MIXCR-SC")).toBe("MiXCR single cell");
+    expect(formatLabel("nope")).toBe("nope");
+    expect(formatLabel(undefined)).toBe("");
+  });
+  test("missing columns", () => {
+    expect(
+      missingColumnsMessage({
+        isValid: false,
+        missingColumns: ["v_call", "j_call"],
+        format: "airr",
+      }),
+    ).toBe(
+      "The selected dataset is missing required AIRR bulk columns: v_call, j_call. Please verify the format selection or choose a different dataset.",
+    );
+    expect(missingColumnsMessage({ isValid: true, missingColumns: [], format: "airr" })).toBe("");
+    expect(missingColumnsMessage(undefined)).toBe("");
+  });
+  const mapping = { identity: "id", sequences: { IGHeavy: "VH" } } as never;
+  const keyFor = (m: never) => collisionCheckKey(m)!;
+
+  test("identity collisions truncate at 3", () => {
+    expect(
+      identityCollisionMessage(
+        { key: keyFor(mapping), values: ["x", "y", "z", "w", "v"] },
+        mapping,
+      ),
+    ).toBe(
+      "Repeated on rows that are not identical: x, y, z and 2 more. Two rows sharing an id become one record — pick a different column, or fix the file.",
+    );
+    expect(identityCollisionMessage({ key: keyFor(mapping), values: [] }, mapping)).toBe("");
+    expect(identityCollisionMessage(undefined, mapping)).toBe("");
+  });
+
+  test("a verdict for a different mapping says nothing", () => {
+    const other = { identity: "other", sequences: { IGHeavy: "VH" } } as never;
+    expect(identityCollisionMessage({ key: keyFor(other), values: ["x"] }, mapping)).toBe("");
+  });
+  test("property collisions", () => {
+    const props = [
+      { header: "A b", valueType: "String" },
+      { header: "A/b", valueType: "String" },
+    ] as never;
+    expect(propertyCollisionMessage(props)).toBe(
+      "These headers would become the same column: A b / A/b. Rename one in the file — importing both is not possible, and dropping one silently would lose a column you asked for.",
+    );
+    expect(propertyCollisionMessage([])).toBe("");
+    expect(propertyCollisionMessage(undefined)).toBe("");
+  });
+});
diff --git a/test/src/model.test.ts b/test/src/model.test.ts
index 8511cae..8d7957c 100644
--- a/test/src/model.test.ts
+++ b/test/src/model.test.ts
@@ -35,7 +35,7 @@ describe("upgradeLegacyData", () => {
           scheme: "kabat",
         },
       },
-      uiState: { settingsOpen: false, mixcrColumnsPresent: true },
+      uiState: { settingsOpen: false },
     });
 
     expect(data.defaultBlockLabel).toBe("my import");
@@ -48,22 +48,15 @@ describe("upgradeLegacyData", () => {
     expect(data.secondaryCountType).toBe("read");
     expect(data.bareSet?.scheme).toBe("kabat");
 
-    // uiState survives too, including a flag the defaults set the other way.
+    // uiState survives too, set the other way from the defaults.
     expect(data.settingsOpen).toBe(false);
-    expect(data.mixcrColumnsPresent).toBe(true);
   });
 
-  test("fills view state a project saved before a flag existed has no value for", () => {
+  test("fills view state and chains a project saved without them has no value for", () => {
     const data = upgradeLegacyData({ args: { format: "qiagen" }, uiState: {} });
 
-    // Every flag present and false rather than undefined: an undefined boolean reaching the
-    // args projection would read as "columns not present" by accident rather than by rule.
-    expect(data.qiagenColumnsPresent).toBe(false);
-    expect(data.immunoSeqColumnsPresent).toBe(false);
-    expect(data.mixcrColumnsPresent).toBe(false);
-    expect(data.crColumnsPresent).toBe(false);
-    expect(data.airrColumnsPresent).toBe(false);
     expect(data.tableState).toBeDefined();
+    expect(data.settingsOpen).toBe(true);
     expect(data.chains.length).toBe(6);
   });
 
@@ -74,7 +67,7 @@ describe("upgradeLegacyData", () => {
       args: {
         fileSource: {
           handle: "index://x" as never,
-          sampleId: "S1",
+          datasetId: "S1",
           label: "panel",
           extension: "tsv",
         },
diff --git a/test/src/wf.test.ts b/test/src/wf.test.ts
index 61fa2b2..167cd63 100644
--- a/test/src/wf.test.ts
+++ b/test/src/wf.test.ts
@@ -14,6 +14,7 @@
   real panel a sequence-derived key merges 119 of 1,243 antibodies.
 */
 
+import { collisionCheckKey } from "@platforma-open/milaboratories.import-vdj.model";
 import { SamplesAndDataBlockPointer } from "@platforma-open/milaboratories.samples-and-data";
 import { blockSpec as sequencePropertiesSpec } from "@platforma-open/milaboratories.sequence-properties";
 import type { PTableHandle } from "@platforma-sdk/model";
@@ -29,17 +30,28 @@ import { ImportVdjBlockPointer } from "this-block";
  * visibly `tableState`, which the stats table is built from.
  */
 function blockData(fields: Record<string, unknown>): Record<string, unknown> {
+  const bareSet = fields.bareSet as
+    | { identity: string; sequences: Record<string, string> }
+    | undefined;
   return {
     defaultBlockLabel: "",
     customBlockLabel: "",
     chains: [],
     tableState: createPlDataTableStateV2(),
     settingsOpen: true,
-    qiagenColumnsPresent: false,
-    immunoSeqColumnsPresent: false,
-    mixcrColumnsPresent: false,
-    crColumnsPresent: false,
-    airrColumnsPresent: false,
+    // `args` refuses a bare set whose columns prerun has not cleared, and the verdict reaches data
+    // through a UI watcher these tests never run. So stand in for it — clean unless the test passes
+    // its own `prerunCheck`, which `...fields` below lets it do. Keyed with the block's own rule,
+    // so a change to what a verdict covers fails here rather than silently passing.
+    ...(collisionCheckKey(bareSet) !== undefined
+      ? {
+          prerunCheck: {
+            check: "columns" as const,
+            subject: collisionCheckKey(bareSet)!,
+            identityCollides: false,
+          },
+        }
+      : {}),
     ...fields,
   };
 }
@@ -307,33 +319,57 @@ blockTest(
           sequences: { IGHeavy: "VH", IGLight: "VL" },
           scheme: SCHEME,
         },
+        // What the UI mirrors in once prerun answers. Stated here because the mirror is a UI
+        // watcher and these tests drive the block directly.
+        prerunCheck: {
+          check: "columns" as const,
+          subject: collisionCheckKey({
+            identity: "mAb ID",
+            sequences: { IGHeavy: "VH", IGLight: "VL" },
+          })!,
+          identityCollides: true,
+        },
       }),
     });
 
     const state = (await awaitStableState(project.getBlockState(blockId), 300000)) as {
       outputs?: Record<string, unknown>;
-      inputsValid?: boolean;
-      canRun?: boolean;
     };
 
-    const wrapped = state.outputs?.identityCollisions as
-      | { value?: string[] }
-      | string[]
-      | undefined;
-    const collisions = (Array.isArray(wrapped) ? wrapped : (wrapped?.value ?? [])) as string[];
+    // The refusal the block's name promises: a colliding id column makes args invalid, so the
+    // interface offers no Run. Read from the overview, not the block state — the block state
+    // carries outputs, and runnability lives on the overview.
+    const overview = (await project.overview.getValue())!;
+    const blockOverview = overview.blocks.find((b) => b.id === blockId)!;
+    expect(blockOverview.inputsValid).toBe(false);
+    expect(blockOverview.canRun).toBe(false);
+
+    type Verdict = { key: string; values: string[] };
+    const wrapped = state.outputs?.identityCollisions as { value?: Verdict } | Verdict | undefined;
+    const found = (wrapped && "key" in wrapped ? wrapped : wrapped?.value) as Verdict | undefined;
+
+    // The verdict names the mapping it is about — the id column AND the sequence columns, since a
+    // collision is a repeated id whose other mapped cells differ. Keyed on the id alone, a clean
+    // verdict outlived a remapped chain and the run gate accepted it, merging records.
+    expect(found?.key).toBe(
+      collisionCheckKey({ identity: "mAb ID", sequences: { IGHeavy: "VH", IGLight: "VL" } }),
+    );
+    // Remapping a chain is a different question, so the old verdict must not answer it.
+    expect(found?.key).not.toBe(
+      collisionCheckKey({ identity: "mAb ID", sequences: { IGHeavy: "VH", IGLight: "VL2" } }),
+    );
+    const collisions = found?.values ?? [];
 
     // The differing pair is reported, so the scientist is told which value to fix.
     expect(collisions).toContain("AB-001");
     // The identical pair is not: repeating a record verbatim discards nothing.
     expect(collisions).not.toContain("AB-002");
 
-    // GAP, verified here rather than assumed: `argsValid` disables Run in the interface, but
-    // the platform does not enforce it — `project.runBlock` resolves happily on an invalid
-    // block. So "the run does not start" holds for a scientist clicking Run and not for an API
-    // caller, and a colliding set driven through the API would still import and merge records.
-    // Closing that needs a workflow-side refusal, which is data-dependent and therefore a
-    // separate awaiting template.
-    await expect(project.runBlock(blockId)).resolves.toBeUndefined();
+    // Enforced by the platform, not only by the interface: invalid args means no args to render a
+    // production from, so an API caller cannot drive a colliding set through either. This was a
+    // documented gap while the collision verdict sat outside the gate — args stayed valid, and
+    // `runBlock` imported a set that merged records without complaint.
+    await expect(project.runBlock(blockId)).rejects.toThrow(/currentArgs not set/);
   },
 );
 
@@ -458,7 +494,7 @@ blockTest(
         chains: ["IGHeavy", "IGLight"],
         fileSource: {
           handle,
-          sampleId: "SDIRECT000000000000000001",
+          datasetId: "SDIRECT000000000000000001",
           label: "bare-paired-set",
           extension: "tsv",
         },
@@ -511,6 +547,16 @@ blockTest(
       "Affinity (nM)": "Double",
     });
 
+    // The profile names the dataset it came from. The panel reads this to tell this file's columns
+    // from the previous file's, still retained while the new one is scanned.
+    expect(
+      (
+        state.outputs?.prerunDatasetValidationInfo as
+          | { value?: { door?: string; datasetId?: string } }
+          | undefined
+      )?.value,
+    ).toEqual({ door: "file", datasetId: "SDIRECT000000000000000001" });
+
     // Indistinguishable from the pool door: same axes, same key, same columns — abundance
     // alone on [sampleId, variantKey], every property of the record on the record axis.
     for (const c of columns) {
@@ -559,7 +605,7 @@ blockTest(
         },
         fileSource: {
           handle,
-          sampleId: "SDIRECT000000000000000001",
+          datasetId: "SDIRECT000000000000000001",
           label: "bare-paired-set",
           extension: "tsv",
         },
@@ -614,7 +660,7 @@ blockTest(
         chains: ["IGHeavy", "IGLight"],
         fileSource: {
           handle,
-          sampleId: "SCHAIN0000000000000000001",
+          datasetId: "SCHAIN0000000000000000001",
           label: "bare-paired-set",
           extension: "tsv",
         },
@@ -677,7 +723,7 @@ blockTest(
         format: "custom",
         fileSource: {
           handle,
-          sampleId: "STCR00000000000000000001",
+          datasetId: "STCR00000000000000000001",
           label: "bare-tcrab-set",
           extension: "tsv",
         },
@@ -761,7 +807,7 @@ blockTest(
         chains: ["IGHeavy", "IGLight"],
         fileSource: {
           handle,
-          sampleId: "SXLSX00000000000000000001",
+          datasetId: "SXLSX00000000000000000001",
           label: "bare-paired-set",
           extension: "xlsx",
         },
diff --git a/ui/src/app.ts b/ui/src/app.ts
index 064ee1d..ce4f56d 100644
--- a/ui/src/app.ts
+++ b/ui/src/app.ts
@@ -1,10 +1,15 @@
 import { platforma } from "@platforma-open/milaboratories.import-vdj.model";
 import { defineAppV3 } from "@platforma-sdk/ui-vue";
 import MainPage from "./pages/MainPage.vue";
-import { watch } from "vue";
+import { watch, watchEffect } from "vue";
+
+export const sdkPlugin = defineAppV3(platforma, (app) => {
+  syncPrerunChecks(app.model);
 
-export const sdkPlugin = defineAppV3(platforma, () => {
   return {
+    // Main run only: the loader covers the whole block, and prerun re-runs while the settings
+    // panel is being edited. Prerun waits are announced inside the panel instead.
+    progress: () => app.model.outputs.isRunning,
     routes: {
       "/": () => MainPage,
     },
@@ -13,6 +18,54 @@ export const sdkPlugin = defineAppV3(platforma, () => {
 
 export const useApp = sdkPlugin.useApp;
 
+type AppModel = ReturnType<typeof useApp>["model"];
+
+/**
+ * Carry prerun's verdicts into `data` so the args projection can refuse the run on them. An output
+ * written back into state a derivation reads — the hairpin — kept safe by the contract on
+ * `BlockData.prerunCheck`: the verdict carries what it is about, so a stale one is ignored rather
+ * than applied.
+ */
+function syncPrerunChecks(model: AppModel) {
+  // Both writes are idempotent: every client derives the same verdict from the same output, and
+  // the guard means agreeing clients do not write at all.
+  const put = (next: NonNullable<AppModel["data"]["prerunCheck"]>) => {
+    const current = model.data.prerunCheck;
+    if (JSON.stringify(current) === JSON.stringify(next)) return;
+    model.data.prerunCheck = next;
+  };
+
+  watchEffect(() => {
+    const found = model.outputs.identityCollisions;
+    if (found === undefined) return;
+    put({ check: "columns", subject: found.key, identityCollides: found.values.length > 0 });
+  });
+
+  // A copy, not a comparison: `validationResult` states which dataset and format it judged, so
+  // there is nothing here to match up and so nothing to get wrong. The args projection does the
+  // comparing, against whatever is selected when it runs.
+  watchEffect(() => {
+    const result = model.outputs.validationResult;
+    if (result?.dataset === undefined) return;
+    put({ check: "dataset", subject: result.dataset, columnsPresent: result.isValid });
+  });
+
+  // A verdict cannot outlive the file or dataset it was reached for. Watching primitives, not the
+  // refs, so a server patch swapping the data object does not clear it spuriously. Format is in
+  // here because the same dataset answers differently under a different format.
+  watch(
+    () => [
+      model.data.fileSource?.datasetId,
+      model.data.datasetRef?.blockId,
+      model.data.datasetRef?.name,
+      model.data.format,
+    ],
+    () => {
+      model.data.prerunCheck = undefined;
+    },
+  );
+}
+
 // Make sure labels are initialized
 const unwatch = watch(sdkPlugin, ({ loaded }) => {
   if (!loaded) return;
diff --git a/ui/src/pages/MainPage.vue b/ui/src/pages/MainPage.vue
index 401fd9c..fc18f8c 100644
--- a/ui/src/pages/MainPage.vue
+++ b/ui/src/pages/MainPage.vue
@@ -1,17 +1,9 @@
 <script setup lang="ts">
-import type {
-  BareSetChain,
-  BareSetScheme,
-  BlockData,
-  ChainSelection,
-  ImportedProperty,
-} from "@platforma-open/milaboratories.import-vdj.model";
+import type { BareSetScheme } from "@platforma-open/milaboratories.import-vdj.model";
 import {
-  CHAIN_SLOT_LABELS,
-  CHAIN_SLOTS,
-  SCHEMES_FOR_SELECTION,
+  forgetMappedColumns,
+  SCHEME_LABELS,
 } from "@platforma-open/milaboratories.import-vdj.model";
-import { propertyCollisions } from "@platforma-open/milaboratories.import-vdj.model";
 import type { ImportFileHandle, PlRef } from "@platforma-sdk/model";
 import { getFileNameFromHandle, uniquePlId } from "@platforma-sdk/model";
 import canonicalize from "canonicalize";
@@ -35,67 +27,29 @@ import {
 import type { ImportedFiles } from "@platforma-sdk/ui-vue";
 import { computed, ref, watch, watchEffect } from "vue";
 import { useApp } from "../app";
+import {
+  chainsOptions,
+  countTypeOptions,
+  formatOptions,
+  LOAD_FROM_FILE,
+  optionalCanonical,
+  optionalMutations,
+  optionalSequence,
+  receptorOptions,
+  requiredCanonicalBase,
+} from "./constants";
+import {
+  emptySamplesMessage as buildEmptySamplesMessage,
+  formatLabel,
+  missingColumnsMessage,
+} from "./messages";
+import BareSetForm from "./components/BareSetForm.vue";
 
 const app = useApp();
 
-const formatOptions = [
-  { label: "ImmunoSeq", value: "immunoSeq" },
-  { label: "QIAseq Immune Repertoire Analysis", value: "qiagen" },
-  { label: "MiXCR bulk", value: "mixcr" },
-  { label: "MiXCR single cell", value: "mixcr-sc" },
-  { label: "Cell Ranger VDJ", value: "cellranger" },
-  { label: "AIRR bulk", value: "airr" },
-  { label: "AIRR single cell", value: "airr-sc" },
-  { label: "Custom", value: "custom" },
-];
-
-const chainsOptions = [
-  { label: "IG Heavy", value: "IGHeavy" },
-  { label: "IG Light", value: "IGLight" },
-  { label: "TRA", value: "TCRAlpha" },
-  { label: "TRB", value: "TCRBeta" },
-  { label: "TRD", value: "TCRDelta" },
-  { label: "TRG", value: "TCRGamma" },
-];
-
-const receptorOptions = [
-  { value: "IG", label: "IG" },
-  { value: "TCRAB", label: "TCR-αβ" },
-  { value: "TCRGD", label: "TCR-ɣδ" },
-];
-
-// Warn when chain filtering left a sample with no clonotypes; cap the names so a big dataset can't flood the banner.
-const EMPTY_SAMPLES_SHOWN = 5;
-
-const emptySamplesMessage = computed(() => {
-  const empty = app.model.outputs.emptyChainSamples?.emptySamples ?? [];
-  if (empty.length === 0) return undefined;
-
-  const shown = empty.slice(0, EMPTY_SAMPLES_SHOWN).join(", ");
-  const overflow = empty.length - EMPTY_SAMPLES_SHOWN;
-  const samples = overflow > 0 ? `${shown} and ${overflow} more` : shown;
-
-  return `After receptor chain filtering, no clonotypes found in sample(s) ${samples}`;
-});
-
-const SCHEME_LABELS: Record<BareSetScheme, string> = {
-  imgt: "IMGT",
-  kabat: "Kabat",
-  chothia: "Chothia",
-};
-
-/**
- * Only the schemes the declared chains can actually be numbered under. Kabat and Chothia are
- * antibody schemes — ANARCI implements them for heavy and light only and raises for a TCR chain
- * — so a TCR selection narrows this to IMGT rather than offering a choice that fails the run.
- */
-const schemeOptions = computed(() => {
-  const selection = app.model.data.bareSet?.chainSelection;
-  const allowed = selection
-    ? (SCHEMES_FOR_SELECTION[selection] ?? (["imgt"] as BareSetScheme[]))
-    : (["imgt", "kabat", "chothia"] as BareSetScheme[]);
-  return allowed.map((s) => ({ label: SCHEME_LABELS[s], value: s }));
-});
+const emptySamplesMessage = computed(() =>
+  buildEmptySamplesMessage(app.model.outputs.emptyChainSamples),
+);
 
 // updating defaultBlockLabel
 watchEffect(() => {
@@ -133,173 +87,6 @@ watchEffect(() => {
   args.defaultBlockLabel = parts.filter(Boolean).join(" - ");
 });
 
-// A bare set is not a mode the scientist declares up front — whether a set is bare is
-// something the block works out from what they mapped. So there is no toggle: the slots are
-// always offered, and filling the identity slot plus at least one chain is what makes it one.
-type BareSetArgs = NonNullable<BlockData["bareSet"]>;
-
-function getBare(): BareSetArgs | undefined {
-  return app.model.data.bareSet;
-}
-
-/**
- * What is being imported. Receptors expand to both their chains; a single chain is its own
- * entry, which is how a heavy-only panel is declared rather than inferred from an unfilled slot.
- *
- * The more diverse chain — the one recombining a D segment — comes first in every pair, which is
- * MiXCR's rule and the order its receptorInfos uses. TCR is numbered under IMGT only; the scheme
- * dropdown narrows itself from the selection.
- */
-const chainSelectionOptions = [
-  // Receptors then chains, with the labels mixcr-clonotyping's combined receptor-or-chain list
-  // uses (SettingsPanel.vue:288-301) — the same control, so the same words.
-  { label: "IG", value: "IG" },
-  { label: "TCR-αβ", value: "TCRAB" },
-  { label: "TCR-ɣδ", value: "TCRGD" },
-  { label: "IG Heavy", value: "IGHeavy" },
-  { label: "IG Light", value: "IGLight" },
-  { label: "TCR-α", value: "TCRAlpha" },
-  { label: "TCR-β", value: "TCRBeta" },
-  { label: "TCR-ɣ", value: "TCRGamma" },
-  { label: "TCR-δ", value: "TCRDelta" },
-];
-
-/** The slots the current declaration asks for, in emission order. */
-const chainSlots = computed<BareSetChain[]>(() => {
-  const selection = app.model.data.bareSet?.chainSelection;
-  return selection ? (CHAIN_SLOTS[selection] ?? []) : [];
-});
-
-function slotLabel(slot: BareSetChain): string {
-  return CHAIN_SLOT_LABELS[slot];
-}
-
-function setChainSelection(value: string | undefined) {
-  const a = app.model.data;
-  const current: BareSetArgs = a.bareSet ?? {
-    identity: "",
-    chainSelection: "IG",
-    sequences: {},
-    scheme: "imgt",
-  };
-  if (!value) return;
-
-  const selection = value as ChainSelection;
-  // Columns mapped to a slot the new declaration does not ask for are dropped. Keeping them
-  // would leave the block emitting a chain the scientist just said they were not importing.
-  const kept: Partial<Record<BareSetChain, string>> = {};
-  for (const slot of CHAIN_SLOTS[selection] ?? []) {
-    const existing = current.sequences?.[slot];
-    if (existing) kept[slot] = existing;
-  }
-
-  // A scheme the new chains cannot be numbered under would fail the run rather than the
-  // mapping, so it is reset here rather than left for ANARCI to reject.
-  const allowed = SCHEMES_FOR_SELECTION[selection] ?? (["imgt"] as BareSetScheme[]);
-  const scheme = allowed.includes(current.scheme) ? current.scheme : allowed[0];
-
-  a.bareSet = { ...current, chainSelection: selection, sequences: kept, scheme };
-}
-
-function bareField(field: "identity" | BareSetChain): string | undefined {
-  const bare = getBare();
-  if (!bare) return undefined;
-  return field === "identity" ? bare.identity : bare.sequences?.[field];
-}
-
-/** Written on user gesture only, never from a watcher on an output. */
-function setBareField(field: "identity" | BareSetChain, value: string | undefined) {
-  const a = app.model.data;
-  const current: BareSetArgs = a.bareSet ?? {
-    identity: "",
-    chainSelection: "IG",
-    sequences: {},
-    scheme: "imgt",
-  };
-  const next: BareSetArgs = {
-    identity: field === "identity" ? (value ?? "") : current.identity,
-    chainSelection: current.chainSelection,
-    sequences: { ...current.sequences },
-    scheme: current.scheme,
-  };
-  if (field !== "identity") {
-    if (value) next.sequences[field] = value;
-    else delete next.sequences[field];
-  }
-
-  // Cleared right back out when nothing is mapped, so its mere presence stays a reliable
-  // signal that this is a bare set.
-  const empty = !next.identity && !next.sequences.IGHeavy && !next.sequences.IGLight;
-  a.bareSet = empty ? undefined : next;
-}
-
-function setBareScheme(value: string | undefined) {
-  const a = app.model.data;
-  if (!a.bareSet || !value) return;
-  a.bareSet = { ...a.bareSet, scheme: value as BareSetArgs["scheme"] };
-}
-
-const isBareSet = computed(() => app.model.data.bareSet !== undefined);
-
-/** Identity values the file repeats on rows that are not identical. The run cannot start
- *  while any exist: the record key is the identity's hash, so a repeat would merge two
- *  different records into one. */
-const identityCollisions = computed<string[]>(
-  () => (app.model.outputs.identityCollisions as string[] | undefined) ?? [],
-);
-
-/** Headers not taken by a sequence or the identity — offered as record properties rather than
- *  dropped, which is what the block used to do with them. */
-const propertyCandidates = computed(() => {
-  const bare = app.model.data.bareSet;
-  const taken = new Set(
-    [bare?.identity, bare?.sequences?.IGHeavy, bare?.sequences?.IGLight].filter(
-      Boolean,
-    ) as string[],
-  );
-  // File door only — record properties exist only for a bare set.
-  return (app.model.outputs.fileColumns ?? []).filter((h) => !taken.has(h));
-});
-
-const acceptedProperties = computed<string[]>({
-  get: () => (app.model.data.bareSet?.properties ?? []).map((p) => p.header),
-  set: (headers) => {
-    const a = app.model.data;
-    if (!a.bareSet) return;
-    // The type is written here, on the accept gesture, from the profile prerun produced by
-    // reading every row. The panel asks no type question — see ColumnProfile — and taking a
-    // snapshot at the gesture keeps the args projection a pure function of `data`.
-    const types = app.model.outputs.columnProfile?.types ?? {};
-    a.bareSet = {
-      ...a.bareSet,
-      properties: headers.map(
-        (h): ImportedProperty => ({ header: h, valueType: types[h] ?? "String" }),
-      ),
-    };
-  },
-});
-
-const propertyCollisionMessage = computed(() => {
-  const collisions = propertyCollisions(app.model.data.bareSet?.properties ?? []);
-  const groups = Object.values(collisions);
-  if (groups.length === 0) return "";
-  const pairs = groups.map((hs) => hs.join(" / ")).join("; ");
-  return `These headers would become the same column: ${pairs}. Rename one in the file — importing both is not possible, and dropping one silently would lose a column you asked for.`;
-});
-
-const identityCollisionMessage = computed(() => {
-  const values = identityCollisions.value;
-  if (values.length === 0) return "";
-  const shown = values.slice(0, 10).join(", ");
-  const rest = values.length > 10 ? ` and ${values.length - 10} more` : "";
-  return `These values of "${app.model.data.bareSet?.identity}" appear on rows that are not identical: ${shown}${rest}. Each record needs its own identifier — two rows sharing one would become a single record. Fix them in the file, or choose a different identity column.`;
-});
-
-const countTypeOptions = [
-  { label: "Reads", value: "read" },
-  { label: "UMIs", value: "umi" },
-];
-
 const secondaryTypeOptions = computed(() => {
   const p = app.model.data.primaryCountType;
   if (p === "read") return [{ label: "UMIs", value: "umi" }];
@@ -329,17 +116,7 @@ const fileSourceError = ref("");
 
 /**
  * What the block is reading: a dataset from the pool, or a file this block loads itself.
- *
- * One dropdown rather than a checkbox plus a dropdown. The two doors are alternatives, and a
- * checkbox made that a second question — the scientist had to know they were on the right door
- * before the dropdown in front of them meant anything.
- *
- * Values are strings because the list mixes two kinds of entry: a canonicalised PlRef per pool
- * dataset, and one sentinel that opens a file dialog instead of selecting anything. `PlDropdownRef`
- * cannot express the sentinel — its value is a PlRef — so this is a plain dropdown that maps back.
  */
-const LOAD_FROM_FILE = "__load_from_file__";
-
 const datasetOptions = computed(() => app.model.outputs.datasetOptions ?? []);
 
 const sourceOptions = computed(() => {
@@ -362,13 +139,6 @@ const selectedSource = computed<string | undefined>(() => {
   return ref ? (canonicalize(ref) as string) : undefined;
 });
 
-/**
- * The platform's own file browser, not the OS one — the same dialog PlFileInput opens.
- *
- * It lists every storage the scientist has, remote ones included, so a file on S3 can be loaded
- * the same way as one on the desktop. `lsDriver.showOpenSingleFileDialog` opens the operating
- * system's picker instead, which can only see the local disk.
- */
 const fileDialogOpen = ref(false);
 
 function onFilesImported(imported: ImportedFiles) {
@@ -407,6 +177,45 @@ function setSource(value: string | undefined) {
 /** The file door is showing exactly when a file is loaded. No stored flag decides it. */
 const loadFromFile = computed(() => app.model.data.fileSource !== undefined);
 
+/**
+ * The loaded file is still being profiled — the columns on offer are the previous file's, since
+ * the profile outputs are retentive. True between picking a file and its scan finishing.
+ */
+const fileScanning = computed(() => {
+  const file = app.model.data.fileSource;
+  if (file === undefined) return false;
+  const stamp = app.model.outputs.prerunDatasetValidationInfo;
+  return !(stamp?.door === "file" && stamp.datasetId === file.datasetId);
+});
+
+/**
+ * The selected dataset's columns are still being inferred — {@link fileScanning} for the other
+ * door. `datasetColumns` and `validationResult` are retentive, so until then the panel would offer
+ * the previous dataset's headers and verdict.
+ *
+ * Needs a format, which is what the inference is asked about. Not raised on the bare-set path,
+ * where prerun answers with collisions and never produces columns.
+ */
+const datasetScanning = computed(() => {
+  if (loadFromFile.value) return false;
+  const ref = app.model.data.datasetRef;
+  if (ref === undefined || app.model.data.format === undefined) return false;
+  if (app.model.data.bareSet !== undefined) return false;
+  const stamp = app.model.outputs.prerunDatasetValidationInfo;
+  if (stamp?.door !== "dataset" || stamp.datasetRef === undefined) return true;
+  return !plRefsEqual(stamp.datasetRef, ref) || stamp.format !== app.model.data.format;
+});
+
+/**
+ * The columns the import will emit, once known for what is selected now. Only the dataset door
+ * produces them, only under a chosen format, and the output is retentive — drop any guard and the
+ * list shows the previous dataset's columns, or a heading with nothing under it.
+ */
+const columnDescriptions = computed(() => {
+  if (loadFromFile.value || app.model.data.format === undefined || datasetScanning.value) return [];
+  return app.model.outputs.columnDescriptions ?? [];
+});
+
 async function setFile(handle: ImportFileHandle | undefined) {
   fileSourceError.value = "";
   const a = app.model.data;
@@ -415,6 +224,7 @@ async function setFile(handle: ImportFileHandle | undefined) {
     return;
   }
 
+  const previous = a.fileSource;
   const name = getFileNameFromHandle(handle);
   // A workbook is identified by its name — there is no first line to read, and the workflow
   // converts it to csv before anything else looks at it. For text files the delimiter is
@@ -425,16 +235,21 @@ async function setFile(handle: ImportFileHandle | undefined) {
       ? "csv"
       : "tsv";
 
-  // The id is minted here, at the user's gesture, rather than derived from the handle, so the
-  // sample keeps its identity across runs. The label is the filename stem, which is exactly
-  // what samples-and-data would have produced.
+  // Re-picking the same file is not a swap: the dialog is also how a file gets re-read, and the
+  // handle is derived from the path, so an unchanged handle means the same file.
+  const isSwap = previous?.handle !== handle;
+
   a.fileSource = {
     handle,
-    sampleId: uniquePlId(),
+    datasetId: isSwap ? uniquePlId() : previous.datasetId,
     label: name.replace(/\.[^.]+$/, ""),
     extension,
   };
   a.datasetRef = undefined;
+
+  // This is what disables Run: a mapping that passed against the last file still satisfies
+  // `bareSetValid`.
+  if (isSwap) a.bareSet = forgetMappedColumns(a.bareSet);
 }
 
 function setReceptors(selected: string[]) {
@@ -463,61 +278,6 @@ const selectedReceptors = computed<string[]>({
   set: (val) => setReceptors(val),
 });
 
-const requiredCanonicalBase = [
-  { key: "cdr3-aa", label: "CDR3 aa" },
-  { key: "cdr3-nt", label: "CDR3 nt" },
-  { key: "v-gene", label: "V gene" },
-  { key: "j-gene", label: "J gene" },
-];
-
-const optionalSequence = [
-  { key: "fr1-aa", label: "FR1 aa" },
-  { key: "fr2-aa", label: "FR2 aa" },
-  { key: "fr3-aa", label: "FR3 aa" },
-  { key: "fr4-aa", label: "FR4 aa" },
-  { key: "cdr1-aa", label: "CDR1 aa" },
-  { key: "cdr2-aa", label: "CDR2 aa" },
-  { key: "vdj-aa", label: "Full VDJ region aa" },
-  { key: "fr1-nt", label: "FR1 nt" },
-  { key: "fr2-nt", label: "FR2 nt" },
-  { key: "fr3-nt", label: "FR3 nt" },
-  { key: "fr4-nt", label: "FR4 nt" },
-  { key: "cdr1-nt", label: "CDR1 nt" },
-  { key: "cdr2-nt", label: "CDR2 nt" },
-  { key: "vdj-nt", label: "Full VDJ region nt" },
-];
-
-const optionalCanonical = [
-  { key: "top-chains", label: "Top chains" },
-  { key: "v-allele", label: "V allele" },
-  { key: "j-allele", label: "J allele" },
-  { key: "d-gene", label: "D gene" },
-  { key: "d-allele", label: "D allele" },
-  { key: "c-gene", label: "C gene" },
-  { key: "c-allele", label: "C allele" },
-  { key: "is-productive", label: "Productive" },
-  // This is calculated by the workflow
-  // { key: 'cdr3-aa-length', label: 'CDR3 length (aa)' },
-  // { key: 'cdr3-nt-length', label: 'CDR3 length (nt)' },
-  // Newly added optional fields
-  { key: "isotype", label: "Isotype" },
-  { key: "n-length-vj-junction", label: "VJ junction length (nt)" },
-  { key: "n-length-vd-junction", label: "VD junction length (nt)" },
-  { key: "n-length-dj-junction", label: "DJ junction length (nt)" },
-  { key: "n-length-total-added", label: "Total added nt" },
-];
-
-const optionalMutations = [
-  { key: "aa-mutations-count-v", label: "AA mutations count (V)" },
-  { key: "aa-mutations-rate-v", label: "AA mutations rate (V)" },
-  { key: "nt-mutations-count-v", label: "NT mutations count (V)" },
-  { key: "nt-mutations-rate-v", label: "NT mutations rate (V)" },
-  { key: "aa-mutations-count-j", label: "AA mutations count (J)" },
-  { key: "aa-mutations-rate-j", label: "AA mutations rate (J)" },
-  { key: "nt-mutations-count-j", label: "NT mutations count (J)" },
-  { key: "nt-mutations-rate-j", label: "NT mutations rate (J)" },
-];
-
 /**
  * The columns of whatever this block is reading. Each door has its own output — the file door
  * profiles a file we hold, the dataset door takes the pool's inference — so a door never offers
@@ -530,20 +290,6 @@ const headerOptions = computed(() => {
   return (columns ?? []).map((h) => ({ label: h, value: h }));
 });
 
-/** Headers whose sampled values actually read as amino-acid variable domains. The workflow
- *  works this out at prerun by reading a few rows — a header cannot say it, and offering every
- *  column here lets an antibody's *name* be mapped into a sequence slot, which imports cleanly
- *  and leaves every record Failed after ANARCI declines to number it.
- *
- *  Falls back to every header when the classification is empty, which happens before the file
- *  is read and on a file whose rows could not be sampled. An empty dropdown would be a worse
- *  failure than an unfiltered one: the scientist could not proceed at all. */
-const sequenceOptions = computed(() => {
-  const aminoAcid = app.model.outputs.aminoAcidColumns ?? [];
-  if (aminoAcid.length === 0) return headerOptions.value;
-  return aminoAcid.map((h) => ({ label: h, value: h }));
-});
-
 function getMapping(key: string): string | undefined {
   const a = app.model.data as unknown as { customMapping?: Record<string, string | undefined> };
   return a.customMapping?.[key];
@@ -555,31 +301,9 @@ function setMapping(key: string, value: string | undefined) {
   else a.customMapping[key] = value;
 }
 
-const validationResult = computed(() => {
-  // Access format to create dependency and ensure reactivity when format changes
-  const format = app.model.data.format;
-  // Access outputs - Vue should track this if outputs is reactive
-  const outputs = app.model.outputs;
-  const result = (
-    outputs as { validationResult?: { isValid: boolean; missingColumns: string[]; format: string } }
-  )?.validationResult;
-  // Return result - format dependency ensures recomputation when format changes
-  return format ? result : result;
-});
-
-/** The display name for a format id, from the same list the dropdown is built from. */
-function formatLabel(format: string | undefined): string {
-  if (!format) return "";
-  const key = format.toLowerCase();
-  return formatOptions.find((o) => o.value.toLowerCase() === key)?.label ?? format;
-}
-
-const validationMessage = computed(() => {
-  const result = validationResult.value;
-  if (!result || result.isValid) return "";
+const validationResult = computed(() => app.model.outputs.validationResult);
 
-  return `The selected dataset is missing required ${formatLabel(result.format)} columns: ${result.missingColumns.join(", ")}. Please verify the format selection or choose a different dataset.`;
-});
+const validationMessage = computed(() => missingColumnsMessage(validationResult.value));
 
 watch(
   () => app.model.data,
@@ -616,39 +340,6 @@ watch(
   },
   { immediate: true },
 );
-
-const formatFlags = {
-  qiagen: "qiagenColumnsPresent",
-  immunoSeq: "immunoSeqColumnsPresent",
-  immunoseq: "immunoSeqColumnsPresent",
-  mixcr: "mixcrColumnsPresent",
-  "mixcr-sc": "mixcrColumnsPresent",
-  cellranger: "crColumnsPresent",
-  airr: "airrColumnsPresent",
-  "airr-sc": "airrColumnsPresent",
-} as const;
-
-watch(
-  [() => app.model.data.format, validationResult],
-  ([format, result]) => {
-    Object.values(formatFlags).forEach((flag) => (app.model.data[flag] = false));
-
-    if (!result) return;
-
-    if (result.format === format) {
-      const flag = formatFlags[result.format as keyof typeof formatFlags];
-      if (flag) {
-        app.model.data[flag] = result.isValid;
-      }
-    }
-  },
-  { immediate: true, deep: true },
-);
-
-// The panel closes whenever the scientist closes it, finished or not. It used to refuse while
-// the mapping was incomplete, which left no way to look at the table, re-read the file or check
-// an upstream block without finishing first. Nothing needs the refusal: the args projection
-// already keeps Run disabled until the mapping is valid, and Settings reopens the panel.
 </script>
 
 <template>
@@ -686,67 +377,14 @@ watch(
           {{ fileSourceError }}
         </PlAlert>
 
-        <template v-if="headerOptions.length > 0">
-          <PlSectionSeparator>Columns to import</PlSectionSeparator>
-          <PlAlert v-if="identityCollisionMessage" type="warn" :style="{ width: '100%' }">
-            <template #title>Id column is not unique</template>
-            {{ identityCollisionMessage }}
-          </PlAlert>
-          <div class="field-col">
-            <PlDropdown
-              :model-value="bareField('identity')"
-              :options="headerOptions"
-              label="Select id column"
-              clearable
-              required
-              @update:model-value="(v: string | undefined) => setBareField('identity', v)"
-            />
-            <PlDropdown
-              :model-value="app.model.data.bareSet?.chainSelection"
-              :options="chainSelectionOptions"
-              label="Receptors"
-              required
-              @update:model-value="(v: string | undefined) => setChainSelection(v)"
-            />
-            <PlDropdown
-              v-for="slot in chainSlots"
-              :key="slot"
-              :model-value="bareField(slot)"
-              :options="sequenceOptions"
-              :label="slotLabel(slot)"
-              clearable
-              required
-              @update:model-value="(v: string | undefined) => setBareField(slot, v)"
-            />
-            <template v-if="isBareSet">
-              <PlDropdownMulti
-                v-model="acceptedProperties"
-                :options="propertyCandidates.map((h) => ({ label: h, value: h }))"
-                label="Import as record properties"
-              />
-            </template>
-          </div>
-          <PlAlert v-if="propertyCollisionMessage" type="warn" :style="{ width: '100%' }">
-            <template #title>Two headers would become one column</template>
-            {{ propertyCollisionMessage }}
-          </PlAlert>
-        </template>
+        <PlAlert v-if="fileScanning" type="info" :style="{ width: '100%' }">
+          Checking the file's columns. This can take a moment, please wait...
+        </PlAlert>
 
-        <!-- Not a column mapping: it chooses how the mapped sequences are numbered, and the
-             region boundaries every downstream block reads follow from it. Kept apart from the
-             mapping so it does not read as one more column to assign. -->
-        <template v-if="isBareSet">
-          <PlSectionSeparator>Region annotation</PlSectionSeparator>
-          <div class="field-col">
-            <PlDropdown
-              :model-value="app.model.data.bareSet?.scheme"
-              :options="schemeOptions"
-              label="Numbering scheme"
-              required
-              @update:model-value="(v: string | undefined) => setBareScheme(v)"
-            />
-          </div>
-        </template>
+        <BareSetForm
+          v-if="!fileScanning && headerOptions.length > 0"
+          :header-options="headerOptions"
+        />
       </template>
 
       <template v-else>
@@ -757,11 +395,6 @@ watch(
           required
         />
 
-        <PlAlert v-if="validationMessage" type="warn" :style="{ width: '100%' }">
-          <template #title>Invalid {{ formatLabel(validationResult?.format) }} dataset</template>
-          {{ validationMessage }}
-        </PlAlert>
-
         <PlDropdownMulti
           v-if="!isSingleCell"
           v-model="app.model.data.chains"
@@ -777,7 +410,20 @@ watch(
           required
         />
 
-        <template v-if="app.model.data.format === 'custom'">
+        <PlAlert v-if="datasetScanning" type="info" :style="{ width: '100%' }">
+          Validating the selected columns. This can take a moment, please wait...
+        </PlAlert>
+
+        <PlAlert
+          v-if="!datasetScanning && validationMessage"
+          type="warn"
+          :label="`Invalid ${formatLabel(validationResult?.format)} dataset`"
+          :style="{ width: '100%' }"
+        >
+          {{ validationMessage }}
+        </PlAlert>
+
+        <template v-if="app.model.data.format === 'custom' && !datasetScanning">
           <PlSectionSeparator>Required columns</PlSectionSeparator>
           <div class="field-col">
             <PlDropdown
@@ -899,11 +545,11 @@ watch(
         </template>
       </template>
 
-      <template v-if="app.model.outputs.columnDescriptions">
+      <template v-if="columnDescriptions.length > 0">
         <PlSectionSeparator>Columns</PlSectionSeparator>
         The following columns will be imported:
         <PlElementList
-          v-model:items="app.model.outputs.columnDescriptions"
+          :items="columnDescriptions"
           disable-removing
           disable-dragging
           disable-pinning
@@ -921,8 +567,12 @@ watch(
       </template>
     </PlSlideModal>
 
-    <PlAlert v-if="emptySamplesMessage" type="warn" :style="{ width: '100%' }">
-      <template #title>No clonotypes imported</template>
+    <PlAlert
+      v-if="emptySamplesMessage"
+      type="warn"
+      label="No clonotypes imported"
+      :style="{ width: '100%' }"
+    >
       {{ emptySamplesMessage }}
     </PlAlert>
 
diff --git a/ui/src/pages/components/BareSetForm.vue b/ui/src/pages/components/BareSetForm.vue
new file mode 100644
index 0000000..8cb11d0
--- /dev/null
+++ b/ui/src/pages/components/BareSetForm.vue
@@ -0,0 +1,286 @@
+<script setup lang="ts">
+import type {
+  BareSetChain,
+  BareSetMapping,
+  BareSetScheme,
+  ChainSelection,
+  ImportedProperty,
+} from "@platforma-open/milaboratories.import-vdj.model";
+import {
+  bareSetValid,
+  CHAIN_SLOT_LABELS,
+  collisionCheckKey,
+  CHAIN_SLOTS,
+  SCHEME_LABELS,
+  SCHEMES_FOR_SELECTION,
+} from "@platforma-open/milaboratories.import-vdj.model";
+import { PlAlert, PlDropdown, PlDropdownMulti, PlSectionSeparator } from "@platforma-sdk/ui-vue";
+import { computed } from "vue";
+import { useApp } from "../../app";
+import { chainsOptions, receptorOptions } from "../constants";
+import {
+  identityCollisionMessage as buildIdentityCollisionMessage,
+  propertyCollisionMessage as buildPropertyCollisionMessage,
+} from "../messages";
+
+const { headerOptions } = defineProps<{
+  /** Every column of the loaded file. Computed by the parent, which needs it for the other door. */
+  headerOptions: { label: string; value: string }[];
+}>();
+
+const app = useApp();
+
+/**
+ * Only the schemes the declared chains can actually be numbered under. Kabat and Chothia are
+ * antibody schemes — ANARCI implements them for heavy and light only and raises for a TCR chain
+ * — so a TCR selection narrows this to IMGT rather than offering a choice that fails the run.
+ */
+const schemeOptions = computed(() => {
+  const selection = app.model.data.bareSet?.chainSelection;
+  const allowed = selection
+    ? (SCHEMES_FOR_SELECTION[selection] ?? (["imgt"] as BareSetScheme[]))
+    : (["imgt", "kabat", "chothia"] as BareSetScheme[]);
+  return allowed.map((s) => ({ label: SCHEME_LABELS[s], value: s }));
+});
+
+const chainSelectionOptions = [...receptorOptions, ...chainsOptions];
+
+/** The slots the current declaration asks for, in emission order. */
+const chainSlots = computed<BareSetChain[]>(() => {
+  const selection = app.model.data.bareSet?.chainSelection;
+  return selection ? (CHAIN_SLOTS[selection] ?? []) : [];
+});
+
+function slotLabel(slot: BareSetChain): string {
+  return CHAIN_SLOT_LABELS[slot];
+}
+
+function setChainSelection(value: string | undefined) {
+  const a = app.model.data;
+  const current: BareSetMapping = a.bareSet ?? {
+    identity: "",
+    chainSelection: "IG",
+    sequences: {},
+    scheme: "imgt",
+  };
+  if (!value) return;
+
+  const selection = value as ChainSelection;
+  // Columns mapped to a slot the new declaration does not ask for are dropped. Keeping them would
+  // leave the block emitting a chain the scientist just said they were not importing.
+  const kept: Partial<Record<BareSetChain, string>> = {};
+  for (const slot of CHAIN_SLOTS[selection] ?? []) {
+    const existing = current.sequences?.[slot];
+    if (existing) kept[slot] = existing;
+  }
+
+  // A scheme the new chains cannot be numbered under would fail the run rather than the mapping,
+  // so it is reset here rather than left for ANARCI to reject.
+  const allowed = SCHEMES_FOR_SELECTION[selection] ?? (["imgt"] as BareSetScheme[]);
+  const scheme = allowed.includes(current.scheme) ? current.scheme : allowed[0];
+
+  a.bareSet = { ...current, chainSelection: selection, sequences: kept, scheme };
+}
+
+function bareField(field: "identity" | BareSetChain): string | undefined {
+  const bare = app.model.data.bareSet;
+  if (!bare) return undefined;
+  if (field !== "identity") return bare.sequences?.[field];
+  // `identity` is a required string, so "nothing chosen" is stored as "". A dropdown counts any
+  // non-undefined value as chosen, so handing it "" showed an italic red "Value not available"
+  // instead of an empty field, and clearing the id column looked like it had broken it.
+  return bare.identity === "" ? undefined : bare.identity;
+}
+
+/** Written on user gesture only, never from a watcher on an output. */
+function setBareField(field: "identity" | BareSetChain, value: string | undefined) {
+  const a = app.model.data;
+  const current: BareSetMapping = a.bareSet ?? {
+    identity: "",
+    chainSelection: "IG",
+    sequences: {},
+    scheme: "imgt",
+  };
+  const next: BareSetMapping = {
+    identity: field === "identity" ? (value ?? "") : current.identity,
+    chainSelection: current.chainSelection,
+    sequences: { ...current.sequences },
+    scheme: current.scheme,
+  };
+  if (field !== "identity") {
+    if (value) next.sequences[field] = value;
+    else delete next.sequences[field];
+  }
+
+  // Cleared right back out when nothing is mapped, so its mere presence stays a reliable signal
+  // that this is a bare set. Every slot, not just the two IG ones — naming those two left a TCR
+  // mapping unable to clear itself.
+  const empty = !next.identity && !Object.values(next.sequences).some(Boolean);
+  a.bareSet = empty ? undefined : next;
+}
+
+function setBareScheme(value: string | undefined) {
+  const a = app.model.data;
+  if (!a.bareSet || !value) return;
+  a.bareSet = { ...a.bareSet, scheme: value as BareSetScheme };
+}
+
+/** A column has been assigned. Not `bareSet !== undefined` — that outlives the mapping it held. */
+const isBareSet = computed(() => {
+  const bare = app.model.data.bareSet;
+  if (bare === undefined) return false;
+  return !!bare.identity || Object.values(bare.sequences ?? {}).some(Boolean);
+});
+
+/**
+ * Headers whose sampled values actually read as amino-acid variable domains. The workflow works
+ * this out at prerun by reading the file — a header cannot say it, and offering every column here
+ * lets an antibody's *name* be mapped into a sequence slot, which imports cleanly and leaves every
+ * record Failed after ANARCI declines to number it.
+ *
+ * Falls back to every header when the classification is empty, which happens before the file is
+ * read and on a file whose rows could not be sampled. An empty dropdown would be a worse failure
+ * than an unfiltered one: the scientist could not proceed at all.
+ */
+const sequenceOptions = computed(() => {
+  const aminoAcid = app.model.outputs.aminoAcidColumns ?? [];
+  if (aminoAcid.length === 0) return headerOptions;
+  return aminoAcid.map((h) => ({ label: h, value: h }));
+});
+
+/**
+ * Identity values repeated on rows that are not identical — the record key is the identity's hash,
+ * so a repeat merges two records into one. Empty unless the verdict is about the mapping now
+ * selected; anything else is about one the scientist has moved on from.
+ */
+/**
+ * The mapping is finished but prerun has not yet cleared the columns it names. Run is disabled
+ * meanwhile and this layout does not surface the args error, so the reason is said here.
+ */
+const columnChecksPending = computed(() => {
+  const bare = app.model.data.bareSet;
+  if (bare === undefined || !bareSetValid(bare)) return false;
+  const check = app.model.data.prerunCheck;
+  return check?.check !== "columns" || check.subject !== collisionCheckKey(bare);
+});
+
+/**
+ * Headers not taken by a sequence or the identity — offered as record properties rather than
+ * dropped, which is what the block used to do with them.
+ */
+const propertyCandidates = computed(() => {
+  const bare = app.model.data.bareSet;
+  const taken = new Set(
+    [bare?.identity, ...Object.values(bare?.sequences ?? {})].filter(Boolean) as string[],
+  );
+  return (app.model.outputs.fileColumns ?? []).filter((h) => !taken.has(h));
+});
+
+const acceptedProperties = computed<string[]>({
+  get: () => (app.model.data.bareSet?.properties ?? []).map((p) => p.header),
+  set: (headers) => {
+    const a = app.model.data;
+    if (!a.bareSet) return;
+    // The type is written here, on the accept gesture, from the profile prerun produced by reading
+    // every row. The panel asks no type question — see ColumnProfile — and taking a snapshot at the
+    // gesture keeps the args projection a pure function of `data`.
+    const types = app.model.outputs.columnProfile?.types ?? {};
+    a.bareSet = {
+      ...a.bareSet,
+      properties: headers.map(
+        (h): ImportedProperty => ({ header: h, valueType: types[h] ?? "String" }),
+      ),
+    };
+  },
+});
+
+const identityCollisionMessage = computed(() =>
+  buildIdentityCollisionMessage(app.model.outputs.identityCollisions, app.model.data.bareSet),
+);
+const propertyCollisionMessage = computed(() =>
+  buildPropertyCollisionMessage(app.model.data.bareSet?.properties),
+);
+</script>
+
+<template>
+  <PlSectionSeparator>Columns to import</PlSectionSeparator>
+
+  <PlAlert
+    v-if="identityCollisionMessage"
+    type="warn"
+    label="Id column is not unique"
+    :style="{ width: '100%' }"
+  >
+    {{ identityCollisionMessage }}
+  </PlAlert>
+  <PlAlert v-else-if="columnChecksPending" type="info" :style="{ width: '100%' }">
+    Validating the selected columns. This can take a moment, please wait...
+  </PlAlert>
+
+  <div class="field-col">
+    <PlDropdown
+      :model-value="bareField('identity')"
+      :options="headerOptions"
+      label="Select id column"
+      clearable
+      required
+      @update:model-value="(v: string | undefined) => setBareField('identity', v)"
+    />
+    <PlDropdown
+      :model-value="app.model.data.bareSet?.chainSelection"
+      :options="chainSelectionOptions"
+      label="Receptors"
+      required
+      @update:model-value="(v: string | undefined) => setChainSelection(v)"
+    />
+    <PlDropdown
+      v-for="slot in chainSlots"
+      :key="slot"
+      :model-value="bareField(slot)"
+      :options="sequenceOptions"
+      :label="slotLabel(slot)"
+      clearable
+      required
+      @update:model-value="(v: string | undefined) => setBareField(slot, v)"
+    />
+    <PlDropdownMulti
+      v-if="isBareSet"
+      v-model="acceptedProperties"
+      :options="propertyCandidates.map((h) => ({ label: h, value: h }))"
+      label="Import as record properties"
+    />
+  </div>
+
+  <PlAlert
+    v-if="propertyCollisionMessage"
+    type="warn"
+    label="Two headers would become one column"
+    :style="{ width: '100%' }"
+  >
+    {{ propertyCollisionMessage }}
+  </PlAlert>
+
+  <!-- Not a column mapping: it chooses how the mapped sequences are numbered, and the region
+       boundaries every downstream block reads follow from it. Kept apart from the mapping so it
+       does not read as one more column to assign. -->
+  <template v-if="isBareSet">
+    <PlSectionSeparator>Region annotation</PlSectionSeparator>
+    <div class="field-col">
+      <PlDropdown
+        :model-value="app.model.data.bareSet?.scheme"
+        :options="schemeOptions"
+        label="Numbering scheme"
+        required
+        @update:model-value="(v: string | undefined) => setBareScheme(v)"
+      />
+    </div>
+  </template>
+</template>
+
+<style scoped>
+.field-col {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 12px;
+}
+</style>
diff --git a/ui/src/pages/constants.ts b/ui/src/pages/constants.ts
new file mode 100644
index 0000000..14a0662
--- /dev/null
+++ b/ui/src/pages/constants.ts
@@ -0,0 +1,102 @@
+import type {
+  ChainSelection,
+  CountType,
+  ImportFormat,
+} from "@platforma-open/milaboratories.import-vdj.model";
+import type { ListOptionBase } from "@platforma-sdk/ui-vue";
+
+/** The formats the dataset door can read. `custom` is the mapping-by-hand path. */
+export const formatOptions: ListOptionBase<ImportFormat>[] = [
+  { label: "ImmunoSeq", value: "immunoSeq" },
+  { label: "QIAseq Immune Repertoire Analysis", value: "qiagen" },
+  { label: "MiXCR bulk", value: "mixcr" },
+  { label: "MiXCR single cell", value: "mixcr-sc" },
+  { label: "Cell Ranger VDJ", value: "cellranger" },
+  { label: "AIRR bulk", value: "airr" },
+  { label: "AIRR single cell", value: "airr-sc" },
+  { label: "Custom", value: "custom" },
+];
+
+/** Chains to import from the selected dataset. Values are the `pl7.app/vdj/chain` vocabulary. */
+export const chainsOptions: ListOptionBase<ChainSelection>[] = [
+  { label: "IG Heavy", value: "IGHeavy" },
+  { label: "IG Light", value: "IGLight" },
+  { label: "TCR-α", value: "TCRAlpha" },
+  { label: "TCR-β", value: "TCRBeta" },
+  { label: "TCR-δ", value: "TCRDelta" },
+  { label: "TCR-ɣ", value: "TCRGamma" },
+];
+
+/** Receptors offered on the direct-file door, where the scientist declares what they are importing. */
+export const receptorOptions: ListOptionBase<ChainSelection>[] = [
+  { value: "IG", label: "IG" },
+  { value: "TCRAB", label: "TCR-αβ" },
+  { value: "TCRGD", label: "TCR-ɣδ" },
+];
+
+export const countTypeOptions: ListOptionBase<CountType>[] = [
+  { label: "Reads", value: "read" },
+  { label: "UMIs", value: "umi" },
+];
+
+/**
+ * Sentinel for the "load from file" entry in the dataset dropdown. `PlDropdownRef` cannot express
+ * it — its values are `PlRef`s — so the source picker is a plain dropdown that maps back.
+ */
+export const LOAD_FROM_FILE = "__load_from_file__";
+
+/** A column the custom mapping can name. */
+type MappableColumn = { key: string; label: string };
+
+/** Always asked for on the custom format, whichever chains are picked. */
+export const requiredCanonicalBase: MappableColumn[] = [
+  { key: "cdr3-aa", label: "CDR3 aa" },
+  { key: "cdr3-nt", label: "CDR3 nt" },
+  { key: "v-gene", label: "V gene" },
+  { key: "j-gene", label: "J gene" },
+];
+
+export const optionalSequence: MappableColumn[] = [
+  { key: "fr1-aa", label: "FR1 aa" },
+  { key: "fr2-aa", label: "FR2 aa" },
+  { key: "fr3-aa", label: "FR3 aa" },
+  { key: "fr4-aa", label: "FR4 aa" },
+  { key: "cdr1-aa", label: "CDR1 aa" },
+  { key: "cdr2-aa", label: "CDR2 aa" },
+  { key: "vdj-aa", label: "Full VDJ region aa" },
+  { key: "fr1-nt", label: "FR1 nt" },
+  { key: "fr2-nt", label: "FR2 nt" },
+  { key: "fr3-nt", label: "FR3 nt" },
+  { key: "fr4-nt", label: "FR4 nt" },
+  { key: "cdr1-nt", label: "CDR1 nt" },
+  { key: "cdr2-nt", label: "CDR2 nt" },
+  { key: "vdj-nt", label: "Full VDJ region nt" },
+];
+
+export const optionalCanonical: MappableColumn[] = [
+  { key: "top-chains", label: "Top chains" },
+  { key: "v-allele", label: "V allele" },
+  { key: "j-allele", label: "J allele" },
+  { key: "d-gene", label: "D gene" },
+  { key: "d-allele", label: "D allele" },
+  { key: "c-gene", label: "C gene" },
+  { key: "c-allele", label: "C allele" },
+  { key: "is-productive", label: "Productive" },
+  // CDR3 lengths are calculated by the workflow, so they are not offered here.
+  { key: "isotype", label: "Isotype" },
+  { key: "n-length-vj-junction", label: "VJ junction length (nt)" },
+  { key: "n-length-vd-junction", label: "VD junction length (nt)" },
+  { key: "n-length-dj-junction", label: "DJ junction length (nt)" },
+  { key: "n-length-total-added", label: "Total added nt" },
+];
+
+export const optionalMutations: MappableColumn[] = [
+  { key: "aa-mutations-count-v", label: "AA mutations count (V)" },
+  { key: "aa-mutations-rate-v", label: "AA mutations rate (V)" },
+  { key: "nt-mutations-count-v", label: "NT mutations count (V)" },
+  { key: "nt-mutations-rate-v", label: "NT mutations rate (V)" },
+  { key: "aa-mutations-count-j", label: "AA mutations count (J)" },
+  { key: "aa-mutations-rate-j", label: "AA mutations rate (J)" },
+  { key: "nt-mutations-count-j", label: "NT mutations count (J)" },
+  { key: "nt-mutations-rate-j", label: "NT mutations rate (J)" },
+];
diff --git a/ui/src/pages/messages.ts b/ui/src/pages/messages.ts
new file mode 100644
index 0000000..9e95526
--- /dev/null
+++ b/ui/src/pages/messages.ts
@@ -0,0 +1,96 @@
+import type {
+  BareSetMapping,
+  ImportedProperty,
+} from "@platforma-open/milaboratories.import-vdj.model";
+import {
+  collisionCheckKey,
+  propertyCollisions,
+} from "@platforma-open/milaboratories.import-vdj.model";
+import { formatOptions } from "./constants";
+
+/**
+ * How many sample names the empty-samples banner lists before summarising the rest, so a large
+ * dataset cannot flood it.
+ */
+const EMPTY_SAMPLES_SHOWN = 5;
+
+/**
+ * How many repeated identity values the non-unique-id warning lists. Printed whole rather than
+ * trimmed: the id column can hold sequences, and cutting those hides what tells them apart.
+ */
+const COLLISIONS_SHOWN = 3;
+
+/**
+ * `a, b, c and 4 more`. Long lists are truncated rather than scrolled: the values can be
+ * sequences or sample names, and a banner that fills the panel hides the controls under it.
+ */
+function andMore(values: string[], shown: number): string {
+  const head = values.slice(0, shown).join(", ");
+  const rest = values.length - shown;
+  return rest > 0 ? `${head} and ${rest} more` : head;
+}
+
+/** The display name for a format id, from the same list the dropdown is built from. */
+export function formatLabel(format: string | undefined): string {
+  if (!format) return "";
+  const key = format.toLowerCase();
+  return formatOptions.find((o) => o.value.toLowerCase() === key)?.label ?? format;
+}
+
+/**
+ * Samples left with no clonotypes once the chosen chains were filtered for. `undefined` when
+ * every sample kept something, which is the caller's signal not to raise a banner at all.
+ */
+export function emptySamplesMessage(
+  found: { emptySamples?: string[] } | undefined,
+): string | undefined {
+  const empty = found?.emptySamples ?? [];
+  if (empty.length === 0) return undefined;
+  return `After receptor chain filtering, no clonotypes found in sample(s) ${andMore(empty, EMPTY_SAMPLES_SHOWN)}`;
+}
+
+/** The dataset does not carry the columns its declared format needs. Empty when it does. */
+export function missingColumnsMessage(
+  result: { isValid: boolean; missingColumns: string[]; format: string } | undefined,
+): string {
+  if (!result || result.isValid) return "";
+  return (
+    `The selected dataset is missing required ${formatLabel(result.format)} columns: ` +
+    `${result.missingColumns.join(", ")}. ` +
+    `Please verify the format selection or choose a different dataset.`
+  );
+}
+
+/**
+ * The identity column repeats on rows that are not identical, so two rows would merge into one
+ * record. Empty when it does not.
+ */
+export function identityCollisionMessage(
+  found: { key: string; values: string[] } | undefined,
+  mapping: BareSetMapping | undefined,
+): string {
+  // A verdict reached for a different mapping is not this mapping's answer, so it says nothing
+  // rather than accusing the column now selected.
+  if (found === undefined || found.key !== collisionCheckKey(mapping)) return "";
+  const values = found.values;
+  if (values.length === 0) return "";
+  return (
+    `Repeated on rows that are not identical: ${andMore(values, COLLISIONS_SHOWN)}. ` +
+    `Two rows sharing an id become one record — pick a different column, or fix the file.`
+  );
+}
+
+/**
+ * Two accepted property headers that sanitize to the same column name. Refused rather than
+ * disambiguated: a generated suffix would name nothing in the scientist's file.
+ */
+export function propertyCollisionMessage(properties: ImportedProperty[] | undefined): string {
+  const groups = Object.values(propertyCollisions(properties ?? []));
+  if (groups.length === 0) return "";
+  const pairs = groups.map((headers) => headers.join(" / ")).join("; ");
+  return (
+    `These headers would become the same column: ${pairs}. ` +
+    `Rename one in the file — importing both is not possible, and dropping one silently would ` +
+    `lose a column you asked for.`
+  );
+}
diff --git a/workflow/src/aggregate-by-record.tpl.tengo b/workflow/src/aggregate-by-record.tpl.tengo
index 07b3e5a..ce8bf69 100644
--- a/workflow/src/aggregate-by-record.tpl.tengo
+++ b/workflow/src/aggregate-by-record.tpl.tengo
@@ -9,7 +9,7 @@
 //
 // That split is not cosmetic. Every consumer's sequence selector matches axes *positionally*:
 // a query naming one axis is compared against the candidate column's axis 0
-// (BQueryAxesKeys.Accept, core/pl controllers/shared/resources/block_resolver_request.go:244).
+// (BQueryAxesKeys.Accept, core/pl's block_resolver_request.go).
 // Leave the sample axis on a property column and axis 0 is `pl7.app/sampleId`, so the query
 // matches nothing and the consumer reports a missing column rather than a mismatched one.
 // Collapsing here is what makes a bare set readable by `sequence-properties`,
diff --git a/workflow/src/annotate-regions.tpl.tengo b/workflow/src/annotate-regions.tpl.tengo
index 31e5767..e3d45d4 100644
--- a/workflow/src/annotate-regions.tpl.tengo
+++ b/workflow/src/annotate-regions.tpl.tengo
@@ -43,7 +43,7 @@ regionsSw := assets.importSoftware("@platforma-open/milaboratories.import-vdj.re
 // deterministic, so the result is worth holding on to.
 CACHE_MILLIS := 24 * 60 * 60 * 1000
 
-// ANARCI writes one CSV per chain type it found, over exactly this list (anarci.py:263). Kappa
+// ANARCI writes one CSV per chain type it found, over exactly this list (anarci.py). Kappa
 // and lambda share KL. Every bucket is pre-created and saved whichever chains the set declares:
 // the step must name its saves before ANARCI has run.
 BUCKETS := ["H", "KL", "A", "B", "G", "D"]
@@ -96,7 +96,7 @@ self.body(func(inputs) {
 	// `writable: true` is the whole trick. Workdir inputs land 0o400 by default so the backend
 	// can hardlink them from the archive cache; without it ANARCI dies on
 	// "Permission denied: anarci.csv_H.csv". Same pattern as
-	// peptide-extraction/workflow/src/parse.tpl.tengo:28.
+	// peptide-extraction's parse.tpl.tengo.
 	//
 	// Both buckets are always read, whichever chains were mapped: the chain a column was
 	// assigned to is *declared*, ANARCI's bucket is *inferred*, and the two can disagree.
diff --git a/workflow/src/bare-set-specs.lib.tengo b/workflow/src/bare-set-specs.lib.tengo
index a71d468..6e8c366 100644
--- a/workflow/src/bare-set-specs.lib.tengo
+++ b/workflow/src/bare-set-specs.lib.tengo
@@ -26,11 +26,10 @@ strings := import("@platforma-sdk/workflow-tengo:strings")
 // `pl7.app/vdj/scClonotypeChain`, which `sequence-properties` already reads.
 CHAINS := ["IGHeavy", "IGLight", "TCRBeta", "TCRAlpha", "TCRDelta", "TCRGamma"]
 
-// Labels use Heavy/Light while domains use A/B. The atoms write `<chain>` in both
-// positions, but the workspace's one shipped paired producer renders labels as
-// "Heavy CDR3 aa" and keeps A/B for the domain
-// (blocks/mixcr-scfv-clonotyping/workflow/src/mixcr-exports.lib.tengo:173-178,271).
-// Following it: a literal reading would put "A CDR3 aa" in front of the scientist.
+// Labels use Heavy/Light while domains use A/B. The atoms write `<chain>` in both positions, but
+// the workspace's one shipped paired producer — mixcr-scfv-clonotyping — renders labels as
+// "Heavy CDR3 aa" and keeps A/B for the domain. Following it: a literal reading would put
+// "A CDR3 aa" in front of the scientist.
 // What the mapping panel calls each locus, mirrored from the UI's receptor/chain list so the
 // statistics table and the dropdown that produced it use one vocabulary.
 CHAIN_DISPLAY := {
@@ -58,7 +57,7 @@ CHAIN_LABELS := {
 // `scClonotypeChain` is the separate, positional vocabulary for chains sharing one frame, and
 // A/B is what every producer puts in it — so the slot name does not belong there.
 // A is the more diverse chain — the one that recombines a D segment. That is MiXCR's rule,
-// stated at mixcr-clonotyping process.tpl.tengo:695 ("A" chain is always the one that is more
+// stated at mixcr-clonotyping's process.tpl.tengo ("A" chain is always the one that is more
 // diverse) and encoded in its receptorInfos chain order: IGHeavy/IGLight, TCRBeta/TCRAlpha,
 // TCRDelta/TCRGamma. This block's own single-cell path already follows it.
 PAIRED_CHAIN_DOMAIN := {
@@ -176,9 +175,8 @@ validateScheme := func(scheme) {
  * No `…/structure` domain key: that belongs to the `scClonotypeKey` vocabulary this axis no
  * longer uses, and no `variantKey` producer in the workspace emits one.
  *
- * The annotation set mirrors peptide-extraction's `variantKey` axis
- * (blocks/peptide-extraction/workflow/src/column-specs.lib.tengo:15-35) with the peptide run
- * id exchanged for the VDJ one.
+ * The annotation set mirrors peptide-extraction's `variantKey` axis, with the peptide run id
+ * exchanged for the VDJ one.
  */
 keyAxis := func(blockId, chains) {
 	ll.assert(len(chains) > 0, "bare-set-specs: at least one chain must be mapped")
@@ -744,8 +742,20 @@ columnsBySource := func(chains, scheme, properties) {
 	}
 }
 
+// The mapped sequence columns, keyed by slot — the other half of what the collision check reads.
+// Emitted alongside a verdict so the panel and the run gate can tell a verdict about the current
+// mapping from one reached before a chain was remapped.
+mappedSequences := func(bare, mappedChains) {
+	mapped := {}
+	for chain in mappedChains {
+		mapped[chain] = bare.sequences[chain]
+	}
+	return mapped
+}
+
 export {
 	CHAINS: CHAINS,
+	mappedSequences: mappedSequences,
 	CHAIN_LABELS: CHAIN_LABELS,
 	REGIONS: REGIONS,
 	SCHEMES: SCHEMES,
diff --git a/workflow/src/bare-set-specs.test.tengo b/workflow/src/bare-set-specs.test.tengo
index 5cd2ffb..3c19374 100644
--- a/workflow/src/bare-set-specs.test.tengo
+++ b/workflow/src/bare-set-specs.test.tengo
@@ -534,7 +534,7 @@ Test_keyAxis_derivesTheReceptorFromTheChains := func() {
 
 
 // A is the more diverse chain — the one recombining a D segment. MiXCR states the rule
-// (process.tpl.tengo:695) and encodes it in receptorInfos: IGHeavy/IGLight, TCRBeta/TCRAlpha,
+// (process.tpl.tengo) and encodes it in receptorInfos: IGHeavy/IGLight, TCRBeta/TCRAlpha,
 // TCRDelta/TCRGamma. This block's single-cell path already follows it, and a bare set must agree
 // or the same dataset would mean different things depending on which door it came through.
 Test_pairedChainDomain_putsTheDiverseChainInSlotA := func() {
diff --git a/workflow/src/main.tpl.tengo b/workflow/src/main.tpl.tengo
index 6e1cc4a..05d29c2 100644
--- a/workflow/src/main.tpl.tengo
+++ b/workflow/src/main.tpl.tengo
@@ -80,7 +80,7 @@ wf.body(func(args) {
 			readable := workbook.toXsv(imported.file, fileSource.extension)
 
 			builder := pColumn.resourceMapBuilder(1)
-			builder.add([fileSource.sampleId], readable.file)
+			builder.add([fileSource.datasetId], readable.file)
 			datasetData = builder.build()
 
 			datasetSpec = {
@@ -134,7 +134,7 @@ wf.body(func(args) {
 			// the pool door samples-and-data emits this column, and on the direct door nobody
 			// else will.
 			labelData := {}
-			labelData[string(json.encode([fileSource.sampleId]))] = fileSource.label
+			labelData[string(json.encode([fileSource.datasetId]))] = fileSource.label
 			bareExports["sampleLabel"] = {
 				spec: {
 					kind: "PColumn",
diff --git a/workflow/src/prerun.tpl.tengo b/workflow/src/prerun.tpl.tengo
index 11b9cbf..999db86 100644
--- a/workflow/src/prerun.tpl.tengo
+++ b/workflow/src/prerun.tpl.tengo
@@ -24,7 +24,7 @@ wf.body(func(args) {
 		readable := workbook.toXsv(imported.file, args.fileSource.extension)
 
 		builder := pColumn.resourceMapBuilder(1)
-		builder.add([args.fileSource.sampleId], readable.file)
+		builder.add([args.fileSource.datasetId], readable.file)
 
 		// The mapping dropdowns need the file's headers, and on this door nothing upstream
 		// supplies them. The separator comes from what the UI read out of the file's own first
@@ -46,7 +46,13 @@ wf.body(func(args) {
 		outputs := {
 			// getImportProgress on this is what starts the upload.
 			fileImports: imported.handle,
-			columnProfile: profile.output("profile")
+			columnProfile: profile.output("profile"),
+			// Which dataset the profile above describes. Stated here because nothing exposes the
+			// args a staging context was built with, so the model cannot work it out.
+			prerunDatasetValidationInfo: smart.createJsonResource({
+				door: "file",
+				datasetId: args.fileSource.datasetId
+			})
 		}
 
 		if args.bareSet != undefined {
@@ -60,6 +66,13 @@ wf.body(func(args) {
 			}
 
 			if bare.identity != "" && len(mappedChains) > 0 {
+				// What the collisions below are about: the identity AND the sequence columns, because a
+				// collision is a repeated identity whose other mapped cells differ. Naming only the
+				// identity let a verdict outlive the mapping it was reached for.
+				outputs.collisionsFor = smart.createJsonResource({
+					identity: bare.identity,
+					sequences: specs.mappedSequences(bare, mappedChains)
+				})
 				outputs.identityCollisions = render.create(collisionsTpl, {
 					dataset: {
 						spec: {
@@ -114,7 +127,11 @@ wf.body(func(args) {
 
 			return {
 				outputs: {
-					identityCollisions: collisions
+					identityCollisions: collisions,
+					collisionsFor: smart.createJsonResource({
+						identity: bare.identity,
+						sequences: specs.mappedSequences(bare, mappedChains)
+					})
 				},
 				exports: {}
 			}
@@ -136,7 +153,16 @@ wf.body(func(args) {
 		outputs: {
 			columnsInfo: columnsInfo,
 			columnDescriptions: columnDescriptions,
-			headerColumns: headerColumns
+			headerColumns: headerColumns,
+			// What the inference above was about — the same stamp the file door emits, under the
+			// same name, because it answers the same question: the model cannot ask which args a
+			// staging context was built with, so without it the panel cannot tell this dataset's
+			// columns from the last one's, still on screen. Exactly one door is ever live.
+			prerunDatasetValidationInfo: smart.createJsonResource({
+				door: "dataset",
+				datasetRef: args.datasetRef,
+				format: args.format
+			})
 		},
 		exports: {}
 	}
diff --git a/workflow/src/workbook.lib.tengo b/workflow/src/workbook.lib.tengo
index 6840b37..9ae1305 100644
--- a/workflow/src/workbook.lib.tengo
+++ b/workflow/src/workbook.lib.tengo
@@ -6,7 +6,7 @@
 // The conversion happens here, in the workflow, rather than in the browser. The atom describes
 // it as a UI-boundary conversion and cites `immune-assay-data`, but that block converts in a
 // workflow software package too (`software/xlsx-to-csv`, invoked at
-// `workflow/src/analysis.tpl.tengo:28-38`); its UI-side xlsx reader only builds a column list
+// its `analysis.tpl.tengo`); its UI-side xlsx reader only builds a column list
 // for the mapping panel. Converting workflow-side buys two things: no vendored JavaScript xlsx
 // dependency, and one converted file that the header list, the identity check and the import
 // all read — rather than the browser parsing the original and the pipeline parsing it again.