diff --git a/docs/specifications/collection-views.md b/docs/specifications/collection-views.md
index 035c858..4c5d527 100644
--- a/docs/specifications/collection-views.md
+++ b/docs/specifications/collection-views.md
@@ -52,7 +52,7 @@ Each is a standalone component (`src/lib/components/*CollectionView.svelte`) tak
 
 **Board swimlanes** (`config.swimlaneBy`, issue #67/#165) — an optional second grouping dimension, rows crossing the existing columns, GitLab/Jira-style. A "Swimlane by" dropdown next to "Group by" offers every `select` property in the schema except whichever one is already `groupBy` (Board never lets one property drive both dimensions); it's hidden entirely when no other `select` property exists, rather than prompting to create one the way the initial "Group by" empty state does — the swimlane dimension is optional, not required to use Board at all. When set, `groupBySwimlaneAndColumn` (§3) replaces the flat column render with one row per swimlane (plus a trailing "No `<property>`" catch-all), each rendering the same full column set — every column still appears inside every swimlane, including an otherwise-empty one, matching `groupBySelectProperty`'s own "preserve empty groups" rule at the second dimension. Both the "Move to column" `<select>` and a parallel "Move to swimlane" `<select>` are per-card, keyboard/screen-reader-accessible alternatives to drag-and-drop; dragging a card into a different swimlane's column cell (or dropping it via native drag-and-drop) sets both the column and swimlane grouping properties in one `setCollectionCell` call, and the swimlane-only move sets just the swimlane property, leaving the record's column untouched. Manual per-cell card order (§8) is scoped by swimlane too, keyed by `` `${groupBy}:${swimlaneBy}:${swimlaneOptionId}:${columnOptionId}` `` — switching either grouping property, or moving a card across swimlanes, never resurrects a stale order saved under a different cell. Retargeting "Group by" onto the property currently driving swimlanes clears `swimlaneBy` (rather than leaving it pointing at what's now the column property too — a duplicate-dimension state `swimlaneCandidates` can never resolve back to) as part of that same `onConfigChange` call; a different retarget leaves `swimlaneBy` untouched. If `swimlaneBy` ever names a property that's been deleted out from under it instead, the swimlane row disappears and Board falls back to its flat single-dimension column view — the same graceful-degradation `groupProperty` itself already has when `groupBy` names a missing field.
 
-**Calendar** (`CalendarCollectionView.svelte`) — `config.groupBy` names the `date` property driving placement, same add-one-if-missing prompt as Board. A fixed 6-row/42-cell month grid (leading/trailing days from adjacent months included, so the grid's shape doesn't jump between 5- and 6-row months) places each record on the day matching `dateKeyForRecord`; a record with no value for the date property renders in an "Unscheduled" section below rather than being hidden. Every entry (scheduled or unscheduled) shows the Collection's resolved primary field (§7) as its title — normally a directly-editable `PropertyValueCell`, matching Board, rendered `compact` given Calendar's denser rows — plus its date property (also inline via `PropertyValueCell`, so rescheduling, including giving an unscheduled record its first date, is a direct edit) and whatever other schema properties are in `visibleProperties` (issue #105: this predates #96 as a plain-text-only title and was made editable to match Board once "primary field" became a named concept applied identically everywhere else — Calendar's entries already supported inline editing for the date field, so this isn't a new interaction pattern for the view, just extending it to one more field). A day cell's "+" button creates a record with that day pre-filled (`createCollectionRow`).
+**Calendar** (`CalendarCollectionView.svelte`) — `config.groupBy` names the `date` property driving placement, same add-one-if-missing prompt as Board. A fixed 6-row/42-cell month grid (leading/trailing days from adjacent months included, so the grid's shape doesn't jump between 5- and 6-row months) places each record on the day matching `dateKeyForRecord`; a record with no value for the date property renders in an "Unscheduled" section below rather than being hidden. Every entry (scheduled or unscheduled) renders its date property inline via `PropertyValueCell`, so rescheduling — including giving an unscheduled record its first date — is a direct edit. A day cell's "+" button creates a record with that day pre-filled (`createCollectionRow`).
 
 ## 5. Permission scoping and `get_document`
 
@@ -64,6 +64,8 @@ Each is a standalone component (`src/lib/components/*CollectionView.svelte`) tak
 
 Both new components call `src/lib/data/records.ts` directly against the browser's own `Y.Doc`, the same direct-UI-mutation pattern every other schema edit in this codebase uses (`updateCollectionSchema` from `+page.svelte` predates this feature) — not routed through the service layer, and picked up generically by `attachDocAuditObserver` (`audit-coverage.md`) like any other direct UI write.
 
+**Field-label contract.** Every field label is trimmed before storage, must be non-blank, and must be unique case-insensitively within its Collection schema. The Add field form, Board's initial select-property prompt, Calendar's initial date-property prompt, and FieldMenu rename all surface a rejected label as an inline `ValidationError`; no schema or view configuration is written on rejection. FieldMenu's generated actions choose an available label (`New field`, then `New field 2`, and `<label> copy`, then `<label> copy 2`) so repeated insertions and duplications remain usable without weakening that invariant.
+
 - **`FieldMenu.svelte`** — a per-field dropdown (the header's "⋯" button in Table, or a row's own menu inside `FieldManagerDialog`) offering: **Edit field** (one popover form covering both rename and change-type — Airtable folds these together rather than exposing them as two separate top-level actions), **Insert left/right** (a plain `text` field titled "New field", inserted immediately adjacent — no auto-opened rename prompt, kept deliberately simple), **Duplicate** (`duplicateCollectionProperty` — fresh key, "`<label>` copy", every record's existing value copied under the new key), **Hide in this view** (only rendered when the caller passes `onToggleVisible` — i.e. only from an embedded view's own header, never from `FieldManagerDialog`, which has no single view's `visibleProperties` to toggle), and **Delete field** (a `ConfirmDialog` naming how many records currently hold a value, via `countRecordsWithProperty`, before `deleteCollectionProperty` runs).
 - **Change-type migration.** `coercePropertyValue` defines the only lossless-enough conversions: number/date/checkbox → text, and a parseable text → number/checkbox. Everything else (anything into/out of `date`/`select`/`relation`) has no generic safe conversion and clears the value. `previewCollectionPropertyTypeChange` counts how many filled records would lose their value under a given target type, shown in the edit form before the user confirms by saving — there's no separate confirmation step beyond that inline warning, since (unlike delete) a retype's data loss is scoped to one field's values, not the field's existence.
 - **Delete repair.** `deleteCollectionProperty` does three things in one transaction: drops the field from schema, strips its value off every record that had one, and walks every `collection_view` block referencing that Collection to strip the deleted key out of `filters`/`visibleProperties`/`groupBy`/`sort.propertyKey` — an embed left pointing at a schema key that no longer exists would otherwise silently mis-filter, mis-group, or mis-sort the next time it renders. Manual per-column Board order is untouched (it isn't part of `viewConfig` in the first place — see §7).
@@ -85,8 +87,8 @@ Board and Calendar cards used to title themselves off "the first `text`-type fie
 - **Storage.** `Collection.primaryFieldKey?: string` (`data-model.md` §1) — a schema key, stored the same whole-value way as `schema` itself (`readCollectionMeta`/`ymeta.set('primaryFieldKey', ...)` in `src/lib/data/records.ts`). Absent on every Collection created before this feature, and on any Collection where no field has been explicitly chosen since — no migration script runs; resolution (next bullet) is what makes an unset Collection keep behaving exactly as it did before.
 - **Resolution: `resolvePrimaryField(schema, primaryFieldKey)`.** Returns the schema field named by `primaryFieldKey` when it exists and is an eligible type; otherwise falls back to the first `text` field in schema order — the exact pre-#96 implicit rule — so a Collection created before this feature, or one whose chosen primary field was since deleted or retyped away, keeps showing the same title without a migration step. The fallback only ever considers `text` fields, not every eligible type, so this returns `undefined` both when the schema has no eligible field at all and when it has eligible fields (e.g. a lone `number` or `select` field) but none of type `text` (Board/Calendar's card/entry title then reads "Untitled", same as before). Board and Calendar both call this in place of their old `schema.find(p => p.type === 'text')` line; `FieldMenu`'s primary-field indicator (next bullet) calls it too, so the star always matches what's actually titling a card.
 - **Eligible types: everything except `relation`.** A `relation` value is a list of record IDs with no display string of its own (data-model.md's `PropertyValue`) — every other type (`text`, `number`, `date`, `select`, `checkbox`) already renders as one displayable value via `PropertyValueCell`, so `setPrimaryField` rejects choosing a `relation` field (`ValidationError`), and a retype that turns the current primary field _into_ `relation` clears `primaryFieldKey` in the same transaction rather than leaving it pointing at a now-invalid field. Deleting the current primary field clears it the same way. Both repairs mirror the existing `deleteCollectionProperty`/`updateCollectionProperty` pattern of fixing up stale schema references in one transaction rather than leaving a dangling key for a reader to notice later.
-- **Display value: `primaryFieldDisplayValue(value, property)`** (`src/lib/data/views.ts`) — a plain-text rendering of any eligible type's value (a `select` value resolves through `property.options` to its label; `checkbox` renders "Checked"/"Unchecked"), used for Board's card-title `aria-label`s and other plain-text title fallbacks. Board's card and Calendar's entry normally render their primary field as a full `PropertyValueCell` (so whichever type is chosen — not just `text` — stays directly editable inline); this function is only for places a plain string is needed instead of an editable cell.
-- **Colliding with `groupBy` or `swimlaneBy` (issue #104, #105).** `primaryFieldKey` and Board/Calendar's `groupBy` (§3), or Board's `swimlaneBy`, are independent choices — nothing stops a user from pointing any of them at the same `select`/`date` field. Both Board's card title and Calendar's entry title normally render the primary field as a directly-editable `PropertyValueCell` (§4), which — when `titleProperty.key` matches `groupProperty.key` (Board or Calendar) or Board's `swimlaneProperty.key` — would otherwise sit right next to another editable control for the identical value: Board's matching "Move to column"/"Move to swimlane" `<select>` (§3), or Calendar's own date `PropertyValueCell` rendered lower in the same entry (§4). Both views resolve this identically, by falling back to the same plain non-editable label used when there's no primary field at all (`titleEditableViaCell` in `BoardCollectionView.svelte`, checked against both properties; the same-named derived value in `CalendarCollectionView.svelte`, checked against `groupBy` only, since Calendar has no swimlane dimension): the other control stays the one editable path to that value, and the title cell for every other field keeps behaving exactly as described above. Nothing prevents choosing the same field for more than one of these roles — there's no correctness reason to forbid it — this only changes which control is editable when a choice collides.
+- **Display value: `primaryFieldDisplayValue(value, property)`** (`src/lib/data/views.ts`) — a plain-text rendering of any eligible type's value (a `select` value resolves through `property.options` to its label; `checkbox` renders "Checked"/empty), used for Board/Calendar's card-title `aria-label`s and Calendar's static entry-title text. Board's own card _editor_ still renders the primary field as a full `PropertyValueCell` (so whichever type is chosen — not just `text` — stays directly editable inline); this function is only for the places a plain string is needed instead of an editable cell.
+- **Colliding with `groupBy` or `swimlaneBy` (issue #104).** `primaryFieldKey` and Board/Calendar's `groupBy` (§3), or Board's `swimlaneBy`, are independent choices — nothing stops a user from pointing any of them at the same `select`/`date` field. Calendar's entry title is _always_ the plain, non-editable `primaryFieldDisplayValue` text described above (it never renders the title as a `PropertyValueCell` at all), so this collision doesn't create a duplicate control there. Board's card title normally _is_ a directly-editable `PropertyValueCell` (previous bullet), which — when `titleProperty.key` matches either `groupProperty.key` or `swimlaneProperty.key` — would otherwise sit right above the matching "Move to column"/"Move to swimlane" `<select>` (§3) as a second, redundant editable control for the identical value. Board resolves this by falling back to the same plain non-editable label it already uses when there's no primary field at all (`titleEditableViaCell` in `BoardCollectionView.svelte`, checked against both properties): the relevant "Move to…" select stays the one editable control for that value, and the title cell for every other field keeps behaving exactly as described above. Nothing prevents choosing the same field for more than one of these roles — there's no correctness reason to forbid it — this only changes which control is editable when a choice collides.
 - **Control and indicator: `FieldMenu`.** A "Set as primary field" / "Unset primary field" menu item (disabled, with an explanatory `title`, for a `relation` field) calls `setPrimaryField`/`setPrimaryField(..., null)` directly — the same direct-Yjs-mutation pattern every other `FieldMenu` action already uses. The toggle's own `isPrimary` state compares the Collection's raw `primaryFieldKey` prop against `property.key` directly — deliberately **not** through `resolvePrimaryField` — because a resolved comparison would make the auto-fallback field's own toggle a permanent no-op: with `primaryFieldKey` unset, the fallback field already resolves as primary, so a resolved `isPrimary` would read `true` and the menu would only ever offer "Unset," writing `null` onto an already-`null` key with no way to actually promote that field to an explicit choice. The small star indicator next to a field's label (rendered by each of `FieldMenu`'s call sites — `TableCollectionView` and `FieldManagerDialog`; `/table/[id]` inherits it by composing `TableCollectionView` (§4) rather than rendering its own `FieldMenu` any more; Board/Calendar show no column headers, so neither renders `FieldMenu` at all) is unaffected by this distinction: those call `resolvePrimaryField` themselves for display, so the star still reflects the _resolved_ primary field, including the auto-fallback case, even while the field's own toggle correctly reads as "not yet explicitly set."
 - **MCP-visible schema.** `collections.listCollections` and `collections.queryCollection` (`mcp-tools.md`) both include a `primaryFieldKey` alongside `schema` in their response — the _resolved_ key (`resolvePrimaryField`'s result), not the raw possibly-unset stored value, so an agent always sees which field is actually titling a record right now rather than having to reimplement the fallback rule itself.
 - **Deliberately not built.** A per-view override (a Board embed titling its cards differently than a Table view of the same Collection) — data-model.md §2's "a view never introduces view-specific row fields" argues directly against it, and no user story in this repo has asked for cards and rows to disagree about a record's name. Record templates, formula/computed primary fields, and multi-field display identities (e.g. "first + last name") are out of scope for the same reason #96 itself lists them as non-goals — they're a different, larger feature than "pick which existing field is the title."
diff --git a/src/lib/client/collection-editor.ts b/src/lib/client/collection-editor.ts
index fd75e8f..64527c4 100644
--- a/src/lib/client/collection-editor.ts
+++ b/src/lib/client/collection-editor.ts
@@ -11,7 +11,7 @@ import type { PropertyDefinition, PropertyValue, WorkspaceRecord } from '$lib/da
 /**
  * Shared row/cell/select-option/field mutation helpers used by every
  * Collection renderer — the embedded Table/Board/Calendar views and the
- * full-page Table route (issue #189). Each wraps a `$lib/data/records.ts`
+ * full-page Table route (issue #189). Each wraps a `$lib/data/collection-ops.ts`
  * primitive with the "no doc yet" guard every renderer previously
  * reimplemented individually; renderer-specific behavior (Board's
  * pre-seeded column value, Calendar's pre-seeded date) stays in the
@@ -48,9 +48,11 @@ export type SelectOptionResult =
 	| { ok: true; option: { id: string; label: string; color?: string } }
 	| { ok: false; error: string };
 
+export type CollectionFieldResult = { ok: true } | { ok: false; error: string };
+
 /**
  * The one path every renderer must use to add a select option — validated,
- * deduped, and palette-colored by `records.ts`'s `addSelectOption`. Before
+ * deduped, and palette-colored by `collection-ops.ts`'s `addSelectOption`. Before
  * issue #189, Calendar and the full-page Table route each rebuilt the
  * schema by hand instead, silently allowing duplicate, uncolored options.
  */
@@ -76,19 +78,28 @@ export function addCollectionSelectOption(
 /**
  * Appends one field to a Collection's schema — the shared path for Board's
  * "add a select property" and Calendar's "add a date property" first-run
- * prompts, and FieldManagerDialog's "Add field" form. Reads the current
- * schema from Yjs itself (`records.ts`'s `appendCollectionField`), not from
+ * prompts, and FieldManagerDialog's "Add field" form. Validates field labels
+ * while reading the current schema from Yjs itself (`collection-ops.ts`'s
+ * `appendCollectionField`), not from
  * a caller-supplied snapshot, so two rapid appends never race. Returns
- * whether the field was actually written — `false` when `doc` isn't
- * connected yet — so a caller doesn't persist a config referencing a field
+ * the validation error when it cannot write, so callers can render it inline;
+ * this also prevents callers from persisting a config referencing a field
  * (e.g. `groupBy`) that was never added.
  */
 export function appendCollectionField(
 	doc: Y.Doc | undefined,
 	collectionId: string,
 	field: PropertyDefinition
-): boolean {
-	if (!doc) return false;
-	appendCollectionFieldToSchema(doc, collectionId, field);
-	return true;
+): CollectionFieldResult {
+	if (!doc) return { ok: false, error: 'Not connected yet. Please try again.' };
+	try {
+		appendCollectionFieldToSchema(doc, collectionId, field);
+		return { ok: true };
+	} catch (err) {
+		return {
+			ok: false,
+			error:
+				err instanceof ValidationError ? err.message : 'Could not add the field. Please try again.'
+		};
+	}
 }
diff --git a/src/lib/components/BoardCollectionView.svelte b/src/lib/components/BoardCollectionView.svelte
index 832d635..8d39926 100644
--- a/src/lib/components/BoardCollectionView.svelte
+++ b/src/lib/components/BoardCollectionView.svelte
@@ -52,6 +52,7 @@
 	let manualOrder: Record<string, string[]> = $state({});
 	let draggedRecordId: string | null = $state(null);
 	let newGroupingPropertyLabel = $state('Status');
+	let newGroupingPropertyError = $state('');
 	let optionDialogPropertyKey: string | null = $state(null);
 	let optionDialogError = $state('');
 	// The side-pane surface for a card's full schema/backlinks/attribution
@@ -185,11 +186,18 @@
 	);
 
 	function addGroupingProperty(): void {
-		const label = newGroupingPropertyLabel.trim();
-		if (!label) return;
-		const property: PropertyDefinition = { key: nanoid(8), label, type: 'select', options: [] };
-		if (appendCollectionField(ydoc, collectionId, property)) {
+		const property: PropertyDefinition = {
+			key: nanoid(8),
+			label: newGroupingPropertyLabel,
+			type: 'select',
+			options: []
+		};
+		const result = appendCollectionField(ydoc, collectionId, property);
+		if (result.ok) {
+			newGroupingPropertyError = '';
 			onConfigChange({ ...config, groupBy: property.key });
+		} else {
+			newGroupingPropertyError = result.error;
 		}
 	}
 
@@ -377,6 +385,9 @@
 				<span>Add a select property</span>
 			</button>
 		</form>
+		{#if newGroupingPropertyError}
+			<p class="mt-2 text-sm text-red-600" role="alert">{newGroupingPropertyError}</p>
+		{/if}
 	</div>
 {:else}
 	<div class="mb-4 flex flex-wrap items-center gap-4">
diff --git a/src/lib/components/CalendarCollectionView.svelte b/src/lib/components/CalendarCollectionView.svelte
index dfbc0a7..9ab5a73 100644
--- a/src/lib/components/CalendarCollectionView.svelte
+++ b/src/lib/components/CalendarCollectionView.svelte
@@ -52,6 +52,7 @@
 	let viewYear = $state(today.getFullYear());
 	let viewMonth = $state(today.getMonth()); // 0-11
 	let newDatePropertyLabel = $state('Date');
+	let newDatePropertyError = $state('');
 	let optionDialogPropertyKey: string | null = $state(null);
 	let optionDialogError = $state('');
 	// The side-pane surface for an entry's full schema/backlinks/attribution
@@ -205,11 +206,17 @@
 	});
 
 	function addDateProperty(): void {
-		const label = newDatePropertyLabel.trim();
-		if (!label) return;
-		const property: PropertyDefinition = { key: nanoid(8), label, type: 'date' };
-		if (appendCollectionField(ydoc, collectionId, property)) {
+		const property: PropertyDefinition = {
+			key: nanoid(8),
+			label: newDatePropertyLabel,
+			type: 'date'
+		};
+		const result = appendCollectionField(ydoc, collectionId, property);
+		if (result.ok) {
+			newDatePropertyError = '';
 			onConfigChange({ ...config, groupBy: property.key });
+		} else {
+			newDatePropertyError = result.error;
 		}
 	}
 
@@ -302,6 +309,9 @@
 				<span>Add a date property</span>
 			</button>
 		</form>
+		{#if newDatePropertyError}
+			<p class="mt-2 text-sm text-red-600" role="alert">{newDatePropertyError}</p>
+		{/if}
 	</div>
 {:else}
 	<div class="mb-4 flex flex-wrap items-center gap-3">
diff --git a/src/lib/components/FieldManagerDialog.svelte b/src/lib/components/FieldManagerDialog.svelte
index 55a3059..e59bb6c 100644
--- a/src/lib/components/FieldManagerDialog.svelte
+++ b/src/lib/components/FieldManagerDialog.svelte
@@ -93,24 +93,22 @@
 
 	function addField(event: SubmitEvent): void {
 		event.preventDefault();
-		const label = newFieldLabel.trim();
-		if (!label) return;
 		const field: PropertyDefinition = {
 			key: nanoid(8),
-			label,
+			label: newFieldLabel,
 			type: newFieldType,
 			options: newFieldType === 'select' ? [] : undefined,
 			targetCollectionId:
 				newFieldType === 'relation' ? newFieldTargetCollectionId || undefined : undefined
 		};
-		try {
-			appendCollectionField(getShardDoc(shardId), collectionId, field);
+		const result = appendCollectionField(getShardDoc(shardId), collectionId, field);
+		if (result.ok) {
 			newFieldLabel = '';
 			newFieldType = 'text';
 			newFieldTargetCollectionId = '';
 			errorMessage = '';
-		} catch {
-			errorMessage = 'Could not add the field. Please try again.';
+		} else {
+			errorMessage = result.error;
 		}
 	}
 
diff --git a/src/lib/components/FieldManagerDialog.svelte.test.ts b/src/lib/components/FieldManagerDialog.svelte.test.ts
index d8268b9..4908c03 100644
--- a/src/lib/components/FieldManagerDialog.svelte.test.ts
+++ b/src/lib/components/FieldManagerDialog.svelte.test.ts
@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { render, screen, within } from '@testing-library/svelte';
+import { fireEvent, render, screen, within } from '@testing-library/svelte';
 import userEvent from '@testing-library/user-event';
 import * as Y from 'yjs';
 import { createCollection, deleteCollection, getCollection } from '$lib/data/collection-ops';
@@ -120,6 +120,42 @@ describe('FieldManagerDialog', () => {
 		]);
 	});
 
+	it('rejects a case-insensitively duplicate field label with an inline error', async () => {
+		const collection = createCollection(ydoc, {
+			title: 'T',
+			schema: [{ key: 'status', label: 'Status', type: 'select' }]
+		});
+		const user = userEvent.setup();
+		render(FieldManagerDialog, {
+			open: true,
+			collectionId: collection.id,
+			shardId: 'test-shard',
+			onClose: vi.fn()
+		});
+
+		await user.type(screen.getByPlaceholderText('Field name…'), ' status ');
+		await user.click(screen.getByRole('button', { name: 'Add field' }));
+
+		expect(screen.getByRole('alert')).toHaveTextContent('A field named "status" already exists');
+		expect(getCollection(ydoc, collection.id)?.schema).toHaveLength(1);
+	});
+
+	it('shows an inline error for a blank field label', async () => {
+		const collection = createCollection(ydoc, { title: 'T', schema: [] });
+		const user = userEvent.setup();
+		render(FieldManagerDialog, {
+			open: true,
+			collectionId: collection.id,
+			shardId: 'test-shard',
+			onClose: vi.fn()
+		});
+
+		await user.type(screen.getByPlaceholderText('Field name…'), '   ');
+		await fireEvent.submit(screen.getByRole('button', { name: 'Add field' }).closest('form')!);
+
+		expect(screen.getByRole('alert')).toHaveTextContent('Field label cannot be blank');
+	});
+
 	it("adds a relation field with a target collection, and doesn't offer the picker for other types (issue #15)", async () => {
 		const people = createCollection(ydoc, { title: 'People', schema: [] });
 		const collection = createCollection(ydoc, { title: 'T', schema: [] });
diff --git a/src/lib/components/FieldMenu.svelte b/src/lib/components/FieldMenu.svelte
index abffa2b..7ae9aa1 100644
--- a/src/lib/components/FieldMenu.svelte
+++ b/src/lib/components/FieldMenu.svelte
@@ -182,8 +182,7 @@
 
 	function saveEdit(event: SubmitEvent): void {
 		event.preventDefault();
-		const label = editLabel.trim();
-		if (!label) return;
+		const label = editLabel;
 		try {
 			updateCollectionProperty(getShardDoc(shardId), collectionId, property.key, {
 				label: label !== property.label ? label : undefined,
@@ -195,18 +194,26 @@
 			});
 			errorMessage = '';
 			closeMenu();
-		} catch {
-			errorMessage = 'Could not update the field. Please try again.';
+		} catch (err) {
+			errorMessage =
+				err instanceof ValidationError
+					? err.message
+					: 'Could not update the field. Please try again.';
 		}
 	}
 
 	function insertField(direction: 'left' | 'right'): void {
 		const field: PropertyDefinition = { key: nanoid(8), label: 'New field', type: 'text' };
 		try {
-			insertCollectionField(getShardDoc(shardId), collectionId, property.key, direction, field);
+			insertCollectionField(getShardDoc(shardId), collectionId, property.key, direction, field, {
+				generateUniqueLabel: true
+			});
 			closeMenu();
-		} catch {
-			errorMessage = 'Could not insert a field. Please try again.';
+		} catch (err) {
+			errorMessage =
+				err instanceof ValidationError
+					? err.message
+					: 'Could not insert a field. Please try again.';
 		}
 	}
 
@@ -214,8 +221,11 @@
 		try {
 			duplicateCollectionProperty(getShardDoc(shardId), collectionId, property.key);
 			closeMenu();
-		} catch {
-			errorMessage = 'Could not duplicate the field. Please try again.';
+		} catch (err) {
+			errorMessage =
+				err instanceof ValidationError
+					? err.message
+					: 'Could not duplicate the field. Please try again.';
 		}
 	}
 
diff --git a/src/lib/components/FieldMenu.svelte.test.ts b/src/lib/components/FieldMenu.svelte.test.ts
index 15201c1..4657cad 100644
--- a/src/lib/components/FieldMenu.svelte.test.ts
+++ b/src/lib/components/FieldMenu.svelte.test.ts
@@ -42,6 +42,31 @@ describe('FieldMenu', () => {
 		expect(getCollection(ydoc, collection.id)?.schema[0].label).toBe('Full name');
 	});
 
+	it('rejects a duplicate label from the edit form with an inline error', async () => {
+		const collection = createCollection(ydoc, {
+			title: 'T',
+			schema: [
+				{ key: 'name', label: 'Name', type: 'text' },
+				{ key: 'status', label: 'Status', type: 'select' }
+			]
+		});
+		const user = userEvent.setup();
+		render(FieldMenu, {
+			shardId: 'test-shard',
+			collectionId: collection.id,
+			property: collection.schema[0]
+		});
+
+		await user.click(screen.getByRole('button', { name: 'Field options for Name' }));
+		await user.click(screen.getByRole('menuitem', { name: 'Edit field' }));
+		await user.clear(screen.getByLabelText('Label'));
+		await user.type(screen.getByLabelText('Label'), 'status');
+		await user.click(screen.getByRole('button', { name: 'Save' }));
+
+		expect(screen.getByRole('alert')).toHaveTextContent('A field named "status" already exists');
+		expect(getCollection(ydoc, collection.id)?.schema[0].label).toBe('Name');
+	});
+
 	it('warns before a retype that would clear values, and applies the migration on save', async () => {
 		const collection = createCollection(ydoc, {
 			title: 'T',
@@ -90,6 +115,30 @@ describe('FieldMenu', () => {
 		expect(schema.map((p) => p.label)).toEqual(['New field', 'Name']);
 	});
 
+	it('generates an available label for repeated insertions', async () => {
+		const collection = createCollection(ydoc, {
+			title: 'T',
+			schema: [{ key: 'name', label: 'Name', type: 'text' }]
+		});
+		const user = userEvent.setup();
+		render(FieldMenu, {
+			shardId: 'test-shard',
+			collectionId: collection.id,
+			property: collection.schema[0]
+		});
+
+		await user.click(screen.getByRole('button', { name: 'Field options for Name' }));
+		await user.click(screen.getByRole('menuitem', { name: 'Insert left' }));
+		await user.click(screen.getByRole('button', { name: 'Field options for Name' }));
+		await user.click(screen.getByRole('menuitem', { name: 'Insert left' }));
+
+		expect(getCollection(ydoc, collection.id)?.schema.map((p) => p.label)).toEqual([
+			'New field',
+			'New field 2',
+			'Name'
+		]);
+	});
+
 	it('duplicates a field, copying its value', async () => {
 		const collection = createCollection(ydoc, {
 			title: 'T',
@@ -118,6 +167,30 @@ describe('FieldMenu', () => {
 		});
 	});
 
+	it('generates an available label for repeated duplicates', async () => {
+		const collection = createCollection(ydoc, {
+			title: 'T',
+			schema: [{ key: 'name', label: 'Name', type: 'text' }]
+		});
+		const user = userEvent.setup();
+		render(FieldMenu, {
+			shardId: 'test-shard',
+			collectionId: collection.id,
+			property: collection.schema[0]
+		});
+
+		await user.click(screen.getByRole('button', { name: 'Field options for Name' }));
+		await user.click(screen.getByRole('menuitem', { name: 'Duplicate' }));
+		await user.click(screen.getByRole('button', { name: 'Field options for Name' }));
+		await user.click(screen.getByRole('menuitem', { name: 'Duplicate' }));
+
+		expect(getCollection(ydoc, collection.id)?.schema.map((p) => p.label)).toEqual([
+			'Name',
+			'Name copy 2',
+			'Name copy'
+		]);
+	});
+
 	it('offers "Hide in this view" only when onToggleVisible is passed, and calls it', async () => {
 		const collection = createCollection(ydoc, {
 			title: 'T',
diff --git a/src/lib/components/collection-editing-contract.svelte.test.ts b/src/lib/components/collection-editing-contract.svelte.test.ts
index e66357e..8efad41 100644
--- a/src/lib/components/collection-editing-contract.svelte.test.ts
+++ b/src/lib/components/collection-editing-contract.svelte.test.ts
@@ -7,7 +7,7 @@
 // and the full-page route silently create duplicate, uncolored options
 // before this fix.
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { render, screen, within } from '@testing-library/svelte';
+import { fireEvent, render, screen, within } from '@testing-library/svelte';
 import userEvent from '@testing-library/user-event';
 import * as Y from 'yjs';
 import { createCollection, getCollection } from '$lib/data/collection-ops';
@@ -16,6 +16,7 @@ import { SELECT_OPTION_COLORS } from '$lib/data/select-colors';
 import TableCollectionViewHarness from './TableCollectionViewHarness.svelte';
 import BoardCollectionViewHarness from './BoardCollectionViewHarness.svelte';
 import CalendarCollectionViewHarness from './CalendarCollectionViewHarness.svelte';
+import FieldManagerDialog from './FieldManagerDialog.svelte';
 import FullPageTable from '../../routes/space/[spaceId]/table/[id]/+page.svelte';
 
 const actor = { kind: 'human' as const, userId: 'local' };
@@ -206,6 +207,94 @@ describe('cross-surface select-option contract (issue #189)', () => {
 	});
 });
 
+describe('cross-surface field-label validation (issue #205)', () => {
+	beforeEach(() => {
+		ydoc = new Y.Doc();
+		vi.stubGlobal(
+			'fetch',
+			vi.fn(async () => ({ ok: true, json: async () => ({ shardId: 'test-shard' }) }))
+		);
+	});
+
+	afterEach(() => {
+		ydoc.destroy();
+		vi.unstubAllGlobals();
+	});
+
+	it('Board and Calendar reject a field label that duplicates another field', async () => {
+		createCollection(ydoc, {
+			id: 'board-collection',
+			title: 'Board',
+			schema: [{ key: 'existing', label: 'Status', type: 'text' }]
+		});
+		const user = userEvent.setup();
+		const { unmount } = render(BoardCollectionViewHarness, { collectionId: 'board-collection' });
+
+		await user.click(await screen.findByRole('button', { name: 'Add a select property' }));
+		expect(screen.getByRole('alert')).toHaveTextContent('A field named "Status" already exists');
+		expect(getCollection(ydoc, 'board-collection')?.schema).toHaveLength(1);
+		unmount();
+
+		createCollection(ydoc, {
+			id: 'calendar-collection',
+			title: 'Calendar',
+			schema: [{ key: 'existing', label: 'Date', type: 'text' }]
+		});
+		render(CalendarCollectionViewHarness, { collectionId: 'calendar-collection' });
+
+		await user.click(await screen.findByRole('button', { name: 'Add a date property' }));
+		expect(screen.getByRole('alert')).toHaveTextContent('A field named "Date" already exists');
+		expect(getCollection(ydoc, 'calendar-collection')?.schema).toHaveLength(1);
+	});
+
+	it('Board and Calendar show an inline error for a blank initial field label', async () => {
+		createCollection(ydoc, { id: 'blank-board', title: 'Board', schema: [] });
+		const user = userEvent.setup();
+		const { unmount } = render(BoardCollectionViewHarness, { collectionId: 'blank-board' });
+
+		const boardInput = await screen.findByLabelText('Select property name');
+		await user.clear(boardInput);
+		await user.type(boardInput, '   ');
+		await fireEvent.submit(
+			screen.getByRole('button', { name: 'Add a select property' }).closest('form')!
+		);
+		expect(screen.getByRole('alert')).toHaveTextContent('Field label cannot be blank');
+		unmount();
+
+		createCollection(ydoc, { id: 'blank-calendar', title: 'Calendar', schema: [] });
+		render(CalendarCollectionViewHarness, { collectionId: 'blank-calendar' });
+
+		const calendarInput = await screen.findByLabelText('Date property name');
+		await user.clear(calendarInput);
+		await user.type(calendarInput, '   ');
+		await fireEvent.submit(
+			screen.getByRole('button', { name: 'Add a date property' }).closest('form')!
+		);
+		expect(screen.getByRole('alert')).toHaveTextContent('Field label cannot be blank');
+	});
+
+	it('FieldManagerDialog rejects a duplicate label from its Add field form', async () => {
+		createCollection(ydoc, {
+			id: 'manager-collection',
+			title: 'Manager',
+			schema: [{ key: 'existing', label: 'Status', type: 'text' }]
+		});
+		const user = userEvent.setup();
+		render(FieldManagerDialog, {
+			open: true,
+			collectionId: 'manager-collection',
+			shardId: 'test-shard',
+			onClose: vi.fn()
+		});
+
+		await user.type(screen.getByPlaceholderText('Field name…'), 'status');
+		await user.click(screen.getByRole('button', { name: 'Add field' }));
+
+		expect(screen.getByRole('alert')).toHaveTextContent('A field named "status" already exists');
+		expect(getCollection(ydoc, 'manager-collection')?.schema).toHaveLength(1);
+	});
+});
+
 describe('cross-surface row attribution contract (issue #189)', () => {
 	beforeEach(() => {
 		ydoc = new Y.Doc();
diff --git a/src/lib/data/collection-ops.test.ts b/src/lib/data/collection-ops.test.ts
index 07027cf..57eedb6 100644
--- a/src/lib/data/collection-ops.test.ts
+++ b/src/lib/data/collection-ops.test.ts
@@ -148,6 +148,26 @@ describe('appendCollectionField: reads the current Yjs schema atomically (issue
 			'due'
 		]);
 	});
+
+	it('rejects blank and case-insensitively duplicate field labels', () => {
+		const doc = new Y.Doc();
+		const collection = createCollection(doc, {
+			title: 'Tasks',
+			schema: [{ key: 'status', label: 'Status', type: 'select' }]
+		});
+
+		expect(() =>
+			appendCollectionField(doc, collection.id, { key: 'blank', label: '   ', type: 'text' })
+		).toThrow('Field label cannot be blank');
+		expect(() =>
+			appendCollectionField(doc, collection.id, {
+				key: 'duplicate',
+				label: ' status ',
+				type: 'text'
+			})
+		).toThrow('A field named "status" already exists');
+		expect(getCollection(doc, collection.id)?.schema).toHaveLength(1);
+	});
 });
 
 describe('insertCollectionField: reads the current Yjs schema atomically (issue #203)', () => {
@@ -191,6 +211,53 @@ describe('insertCollectionField: reads the current Yjs schema atomically (issue
 			})
 		).toThrow(NotFoundError);
 	});
+
+	it('rejects a duplicate field label', () => {
+		const doc = new Y.Doc();
+		const collection = createCollection(doc, {
+			title: 'Tasks',
+			schema: [{ key: 'name', label: 'Name', type: 'text' }]
+		});
+
+		expect(() =>
+			insertCollectionField(doc, collection.id, 'name', 'right', {
+				key: 'duplicate',
+				label: 'name',
+				type: 'text'
+			})
+		).toThrow('A field named "name" already exists');
+	});
+
+	it('generates an available label when requested for a default insertion', () => {
+		const doc = new Y.Doc();
+		const collection = createCollection(doc, {
+			title: 'Tasks',
+			schema: [{ key: 'name', label: 'Name', type: 'text' }]
+		});
+
+		insertCollectionField(
+			doc,
+			collection.id,
+			'name',
+			'right',
+			{ key: 'new-1', label: 'New field', type: 'text' },
+			{ generateUniqueLabel: true }
+		);
+		insertCollectionField(
+			doc,
+			collection.id,
+			'name',
+			'right',
+			{ key: 'new-2', label: 'New field', type: 'text' },
+			{ generateUniqueLabel: true }
+		);
+
+		expect(getCollection(doc, collection.id)?.schema.map((p) => p.label)).toEqual([
+			'Name',
+			'New field 2',
+			'New field'
+		]);
+	});
 });
 
 describe('moveCollectionField: reads the current Yjs schema atomically (issue #203)', () => {
@@ -274,6 +341,26 @@ describe('collection field lifecycle: rename, retype, duplicate, delete', () =>
 		});
 	});
 
+	it('updateCollectionProperty trims labels and rejects blank or duplicate labels', () => {
+		const doc = new Y.Doc();
+		const collection = createCollection(doc, {
+			title: 'Tasks',
+			schema: [
+				{ key: 'name', label: 'Name', type: 'text' },
+				{ key: 'status', label: 'Status', type: 'select' }
+			]
+		});
+
+		updateCollectionProperty(doc, collection.id, 'name', { label: ' Full name ' });
+		expect(getCollection(doc, collection.id)?.schema[0].label).toBe('Full name');
+		expect(() => updateCollectionProperty(doc, collection.id, 'name', { label: '   ' })).toThrow(
+			'Field label cannot be blank'
+		);
+		expect(() => updateCollectionProperty(doc, collection.id, 'name', { label: 'status' })).toThrow(
+			'A field named "status" already exists'
+		);
+	});
+
 	it('updateCollectionProperty retypes a field and migrates coercible values, clearing the rest', () => {
 		const doc = new Y.Doc();
 		const collection = createCollection(doc, {
@@ -411,6 +498,21 @@ describe('collection field lifecycle: rename, retype, duplicate, delete', () =>
 		expect(getRecord(doc, withoutValue.id)?.properties?.[copy.key]).toBeUndefined();
 	});
 
+	it('duplicateCollectionProperty generates an available copy label for repeated duplicates', () => {
+		const doc = new Y.Doc();
+		const { collection } = setupCollection(doc);
+
+		duplicateCollectionProperty(doc, collection.id, 'name');
+		const secondCopy = duplicateCollectionProperty(doc, collection.id, 'name');
+
+		expect(secondCopy.label).toBe('Name copy 2');
+		expect(getCollection(doc, collection.id)?.schema.map((p) => p.label)).toEqual([
+			'Name',
+			'Name copy 2',
+			'Name copy'
+		]);
+	});
+
 	it("duplicateCollectionProperty carries a relation field's targetCollectionId over to the copy", () => {
 		const doc = new Y.Doc();
 		const people = createCollection(doc, { title: 'People', schema: [] });
diff --git a/src/lib/data/collection-ops.ts b/src/lib/data/collection-ops.ts
index 773890f..fae54ff 100644
--- a/src/lib/data/collection-ops.ts
+++ b/src/lib/data/collection-ops.ts
@@ -70,13 +70,47 @@ export function updateCollectionSchema(doc: Y.Doc, id: string, schema: PropertyD
 	ymeta.set('schema', schema);
 }
 
-/** Appends one field to a Collection's schema, reading the current schema from Yjs inside the same transaction rather than trusting a caller-supplied snapshot — two rapid appends from the same reactive snapshot would otherwise race, with the second silently dropping the first. */
+function fieldLabelCollides(
+	schema: PropertyDefinition[],
+	label: string,
+	excludePropertyKey?: string
+): boolean {
+	return schema.some(
+		(property) =>
+			property.key !== excludePropertyKey &&
+			property.label.trim().toLowerCase() === label.toLowerCase()
+	);
+}
+
+function assertUniqueFieldLabel(
+	schema: PropertyDefinition[],
+	label: string,
+	excludePropertyKey?: string
+): string {
+	const trimmed = label.trim();
+	if (!trimmed) throw new ValidationError('Field label cannot be blank');
+	if (fieldLabelCollides(schema, trimmed, excludePropertyKey)) {
+		throw new ValidationError(`A field named "${trimmed}" already exists`);
+	}
+	return trimmed;
+}
+
+function nextAvailableFieldLabel(schema: PropertyDefinition[], baseLabel: string): string {
+	const base = baseLabel.trim();
+	let candidate = base;
+	let suffix = 2;
+	while (fieldLabelCollides(schema, candidate)) candidate = `${base} ${suffix++}`;
+	return candidate;
+}
+
+/** Appends one field to a Collection's schema, rejecting a blank or already-used (case-insensitive) label. Reads the current schema from Yjs inside the same transaction rather than trusting a caller-supplied snapshot — two rapid appends from the same reactive snapshot would otherwise race, with the second silently dropping the first. */
 export function appendCollectionField(doc: Y.Doc, id: string, field: PropertyDefinition): void {
 	const ymeta = collectionsMap(doc).get(id);
 	if (!ymeta) throw new NotFoundError(`Collection ${id} not found`);
 	doc.transact(() => {
 		const schema = ymeta.get('schema') ?? [];
-		ymeta.set('schema', [...schema, field]);
+		const label = assertUniqueFieldLabel(schema, field.label);
+		ymeta.set('schema', [...schema, { ...field, label }]);
 	});
 }
 
@@ -91,7 +125,8 @@ export function insertCollectionField(
 	collectionId: string,
 	referenceKey: string,
 	direction: 'left' | 'right',
-	field: PropertyDefinition
+	field: PropertyDefinition,
+	options?: { generateUniqueLabel?: boolean }
 ): void {
 	const ymeta = collectionsMap(doc).get(collectionId);
 	if (!ymeta) throw new NotFoundError(`Collection ${collectionId} not found`);
@@ -99,8 +134,15 @@ export function insertCollectionField(
 		const schema = ymeta.get('schema') ?? [];
 		const index = schema.findIndex((p) => p.key === referenceKey);
 		if (index === -1) throw new NotFoundError(`Property ${referenceKey} not found`);
+		const label = options?.generateUniqueLabel
+			? nextAvailableFieldLabel(schema, field.label)
+			: assertUniqueFieldLabel(schema, field.label);
 		const insertAt = direction === 'left' ? index : index + 1;
-		ymeta.set('schema', [...schema.slice(0, insertAt), field, ...schema.slice(insertAt)]);
+		ymeta.set('schema', [
+			...schema.slice(0, insertAt),
+			{ ...field, label },
+			...schema.slice(insertAt)
+		]);
 	});
 }
 
@@ -325,9 +367,13 @@ export function updateCollectionProperty(
 		} else {
 			nextTargetCollectionId = current.targetCollectionId;
 		}
+		const nextLabel =
+			patch.label !== undefined
+				? assertUniqueFieldLabel(schema, patch.label, propertyKey)
+				: current.label;
 		const next: PropertyDefinition = {
 			...current,
-			label: patch.label ?? current.label,
+			label: nextLabel,
 			type: nextType,
 			options: nextOptions,
 			defaultOptionId: nextDefaultOptionId,
@@ -356,10 +402,11 @@ export function duplicateCollectionProperty(
 		const index = schema.findIndex((p) => p.key === propertyKey);
 		if (index === -1) throw new NotFoundError(`Property ${propertyKey} not found`);
 		const source = schema[index];
+		const label = nextAvailableFieldLabel(schema, `${source.label} copy`);
 		const copy: PropertyDefinition = {
 			...source,
 			key: nanoid(8),
-			label: `${source.label} copy`,
+			label,
 			options: source.options?.map((o) => ({ ...o }))
 		};
 		const nextSchema = [...schema.slice(0, index + 1), copy, ...schema.slice(index + 1)];