From 9504905c8f1d7b34dce2e70fc19a90955f502e4f Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 23 Aug 2026 18:05:50 +0200
Subject: [PATCH 01/60] Upgrade project to Node 24

Node 22 leaves active LTS at the end of October. Move the Docker base
image and the documented local requirement to Node 24.

Pull @types/node from ^25 down to ^24 so the type definitions no longer
describe a newer runtime than the one in use. Types ahead of the runtime
let TypeScript accept APIs that are not there at execution time; the
opposite direction is harmless.

Add an engines field to record the supported version. No .nvmrc, since
the project is not used with a Node version manager.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 Dockerfile        |  2 +-
 README.md         |  2 +-
 package-lock.json | 23 ++++++++++++++---------
 package.json      |  5 ++++-
 4 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/Dockerfile b/Dockerfile
index 41a08fd..5484443 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,4 +1,4 @@
-FROM node:22
+FROM node:24
 WORKDIR /app
 
 COPY package*.json ./
diff --git a/README.md b/README.md
index c333917..d7a7b09 100644
--- a/README.md
+++ b/README.md
@@ -70,7 +70,7 @@ Produktionsdeployment. Details stehen in
 
 Voraussetzungen:
 
-- Node.js 22
+- Node.js 24
 - npm
 
 ```powershell
diff --git a/package-lock.json b/package-lock.json
index b0abb41..417421b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -22,12 +22,15 @@
       "devDependencies": {
         "@types/better-sqlite3": "^7.6.13",
         "@types/express": "^5.0.6",
-        "@types/node": "^25.6.0",
+        "@types/node": "^24.10.1",
         "@types/react": "^19.2.14",
         "@types/react-dom": "^19.2.3",
         "drizzle-kit": "^0.31.10",
         "tsx": "^4.21.0",
         "typescript": "^6.0.3"
+      },
+      "engines": {
+        "node": "24.x"
       }
     },
     "node_modules/@drizzle-team/brocli": {
@@ -1514,12 +1517,13 @@
       "dev": true
     },
     "node_modules/@types/node": {
-      "version": "25.6.0",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.6.0.tgz",
-      "integrity": "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==",
+      "version": "24.13.3",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.13.3.tgz",
+      "integrity": "sha512-Dh8vAsV36ig5wa9OX4pXvMc9D3Veibfw2wix0CUwYODLD8nkj9UsLjASr49nPg+2eKzxhBV+v7L8pXvT4e639Q==",
       "devOptional": true,
+      "license": "MIT",
       "dependencies": {
-        "undici-types": "~7.19.0"
+        "undici-types": "~7.18.0"
       }
     },
     "node_modules/@types/qs": {
@@ -3688,10 +3692,11 @@
       }
     },
     "node_modules/undici-types": {
-      "version": "7.19.2",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.19.2.tgz",
-      "integrity": "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==",
-      "devOptional": true
+      "version": "7.18.2",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+      "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
+      "devOptional": true,
+      "license": "MIT"
     },
     "node_modules/unpipe": {
       "version": "1.0.0",
diff --git a/package.json b/package.json
index 9bc5ae3..d5ebe82 100644
--- a/package.json
+++ b/package.json
@@ -3,6 +3,9 @@
   "version": "1.0.0",
   "description": "Spreadsheet-style circuit list editor for electrical distribution planning",
   "main": "dist/server/index.js",
+  "engines": {
+    "node": "24.x"
+  },
   "scripts": {
     "dev": "npm run dev:api",
     "dev:api": "tsx watch src/server/index.ts",
@@ -40,7 +43,7 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.6",
-    "@types/node": "^25.6.0",
+    "@types/node": "^24.10.1",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "drizzle-kit": "^0.31.10",

From c6cdfc42d5c347a529dff46ab173baa3e07daa07 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 23 Aug 2026 18:05:50 +0200
Subject: [PATCH 02/60] Keep manual quantity consistent when synchronizing
 device rows

Synchronizing a project device pushes its quantity onto every linked
device row, but manualQuantity is not part of the sync snapshot and was
left untouched. A device whose quantity is lower than the row's left the
row at manualQuantity > quantity, violating the snapshot invariant.

The violation surfaced far from its cause: the invariant is only checked
when a full state snapshot is read, and the automatic snapshot runs every
25 revisions. A project could therefore accumulate the broken row
silently and then reject every subsequent command, because the failing
validation rolls back the whole transaction including the revision bump.

Recompute manualQuantity as the synchronized quantity minus the total of
the linked external objects, matching the invariant that
assertCircuitDeviceRowQuantity enforces elsewhere, and reject a
synchronized quantity that falls below that total.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 ...ice-row-sync-project-command.repository.ts |  26 ++-
 ...ow-sync-project-command.repository.test.ts | 183 ++++++++++++++++++
 2 files changed, 208 insertions(+), 1 deletion(-)

diff --git a/src/db/repositories/project-device-row-sync-project-command.repository.ts b/src/db/repositories/project-device-row-sync-project-command.repository.ts
index da17458..eb722d7 100644
--- a/src/db/repositories/project-device-row-sync-project-command.repository.ts
+++ b/src/db/repositories/project-device-row-sync-project-command.repository.ts
@@ -14,6 +14,7 @@ import type { AppDatabase } from "../database-context.js";
 import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
 import { circuitLists } from "../schema/circuit-lists.js";
 import { circuits } from "../schema/circuits.js";
+import { externalModelObjects } from "../schema/external-model-objects.js";
 import { projectDevices } from "../schema/project-devices.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
 import { updateDerivedCircuitVoltage } from "./project-voltage.persistence.js";
@@ -119,9 +120,32 @@ export class ProjectDeviceRowSyncProjectCommandRepository
     );
 
     for (const assignment of input.command.payload.rows) {
+      const values: typeof assignment.target & {
+        manualQuantity?: number;
+      } = { ...assignment.target };
+      if (assignment.target.quantity !== assignment.expected.quantity) {
+        const externalTotal = tx
+          .select({ planningValues: externalModelObjects.planningValues })
+          .from(externalModelObjects)
+          .where(
+            eq(externalModelObjects.circuitDeviceRowId, assignment.rowId)
+          )
+          .all()
+          .reduce(
+            (sum, object) => sum + object.planningValues.effectiveQuantity,
+            0
+          );
+        const manualQuantity = assignment.target.quantity - externalTotal;
+        if (manualQuantity < 0) {
+          throw new Error(
+            "Synchronized quantity is below the total quantity of linked external objects."
+          );
+        }
+        values.manualQuantity = manualQuantity;
+      }
       const updated = tx
         .update(circuitDeviceRows)
-        .set(assignment.target)
+        .set(values)
         .where(eq(circuitDeviceRows.id, assignment.rowId))
         .run();
       if (updated.changes !== 1) {
diff --git a/tests/project-device-row-sync-project-command.repository.test.ts b/tests/project-device-row-sync-project-command.repository.test.ts
index 75d56a8..593a7f6 100644
--- a/tests/project-device-row-sync-project-command.repository.test.ts
+++ b/tests/project-device-row-sync-project-command.repository.test.ts
@@ -13,9 +13,13 @@ import { ProjectHistoryRepository } from "../src/db/repositories/project-history
 import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
 import { circuitSections } from "../src/db/schema/circuit-sections.js";
 import { circuits } from "../src/db/schema/circuits.js";
+import { externalImportBatches } from "../src/db/schema/external-import-batches.js";
+import { externalModelObjects } from "../src/db/schema/external-model-objects.js";
+import { externalModelSources } from "../src/db/schema/external-model-sources.js";
 import { projectDevices } from "../src/db/schema/project-devices.js";
 import { projectRevisions } from "../src/db/schema/project-revisions.js";
 import { projects } from "../src/db/schema/projects.js";
+import { externalCsvTestConfiguration } from "./fixtures/revit-csv-fixtures.js";
 import {
   createProjectDeviceRowSyncProjectCommand,
   type ProjectDeviceSyncRowSnapshot,
@@ -163,6 +167,79 @@ function getRow(context: DatabaseContext, rowId: string) {
   return row;
 }
 
+function linkExternalObject(
+  context: DatabaseContext,
+  rowId: string,
+  effectiveQuantity: number
+) {
+  context.db
+    .insert(externalModelSources)
+    .values({
+      id: "source-1",
+      projectId: "project-1",
+      name: "Revit",
+      sourceType: "revit_csv",
+    })
+    .run();
+  context.db
+    .insert(externalImportBatches)
+    .values({
+      id: "batch-1",
+      projectId: "project-1",
+      sourceId: "source-1",
+      importKind: "initial",
+      importedAtIso: "2026-08-02T16:00:00.000Z",
+      fileName: "revit.csv",
+      sha256: "a".repeat(64),
+      appliedProjectRevision: 0,
+      configurationVersion: 1,
+      configurationSnapshot: externalCsvTestConfiguration,
+      originalBytes: Buffer.from("test"),
+      document: { delimiter: ";", encoding: "utf-8", headers: [], rows: [] },
+    })
+    .run();
+  context.db
+    .insert(externalModelObjects)
+    .values({
+      id: "object-1",
+      projectId: "project-1",
+      sourceId: "source-1",
+      ifcGuid: "ifc-1",
+      lastSeenImportBatchId: "batch-1",
+      lastAcceptedImportBatchId: "batch-1",
+      acceptedSourceValues: {
+        rowNumber: 2,
+        roomNumber: "101",
+        roomName: "Büro",
+        familyAndType: "Leuchte: Standard",
+        selectionMarker: "Leuchte",
+        circuitIdentifier: "-1F1",
+        power: "30",
+        quantity: String(effectiveQuantity),
+        additionalSourceValues: {},
+      },
+      planningValues: {
+        displayName: "Leuchte",
+        internalDeviceType: "luminaire",
+        category: "single_phase",
+        connectionKind: "fixed",
+        effectiveQuantity,
+        powerPerUnitW: 30,
+        simultaneityFactor: 1,
+        cosPhi: null,
+        costGroup: null,
+        remark: null,
+      },
+      overriddenFields: [],
+      externalRoomMappingId: null,
+      distributionBoardId: null,
+      linkedProjectDeviceId: null,
+      circuitDeviceRowId: rowId,
+      presenceStatus: "present",
+    })
+    .run();
+}
+
 function snapshot(
   context: DatabaseContext,
   rowId: string
@@ -474,6 +551,112 @@ describe("project-device row sync project-command repository", () => {
     }
   });
 
+  it("keeps manualQuantity from exceeding quantity when a synced quantity shrinks", () => {
+    const fixture = createTestDatabase();
+    try {
+      fixture.context.db
+        .update(circuitDeviceRows)
+        .set({ quantity: 5, manualQuantity: 5 })
+        .where(eq(circuitDeviceRows.id, "row-1"))
+        .run();
+      const store = new ProjectDeviceRowSyncProjectCommandRepository(
+        fixture.context.db
+      );
+      const expected = snapshot(fixture.context, "row-1");
+      store.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createProjectDeviceRowSyncProjectCommand(
+          "project-device-1",
+          "synchronize",
+          [
+            {
+              rowId: "row-1",
+              expected,
+              target: { ...expected, quantity: 2 },
+            },
+          ]
+        ),
+      });
+      const row = getRow(fixture.context, "row-1");
+      assert.equal(row.quantity, 2);
+      assert.equal(row.manualQuantity, 2);
+    } finally {
+      fixture.context.close();
+    }
+  });
+
+  it("subtracts linked external objects when a synced quantity shrinks", () => {
+    const fixture = createTestDatabase();
+    try {
+      fixture.context.db
+        .update(circuitDeviceRows)
+        .set({ quantity: 5, manualQuantity: 2 })
+        .where(eq(circuitDeviceRows.id, "row-1"))
+        .run();
+      linkExternalObject(fixture.context, "row-1", 3);
+      const store = new ProjectDeviceRowSyncProjectCommandRepository(
+        fixture.context.db
+      );
+      const expected = snapshot(fixture.context, "row-1");
+      store.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createProjectDeviceRowSyncProjectCommand(
+          "project-device-1",
+          "synchronize",
+          [{ rowId: "row-1", expected, target: { ...expected, quantity: 4 } }]
+        ),
+      });
+      const row = getRow(fixture.context, "row-1");
+      assert.equal(row.quantity, 4);
+      assert.equal(row.manualQuantity, 1);
+    } finally {
+      fixture.context.close();
+    }
+  });
+
+  it("rejects a synced quantity below the linked external total", () => {
+    const fixture = createTestDatabase();
+    try {
+      fixture.context.db
+        .update(circuitDeviceRows)
+        .set({ quantity: 5, manualQuantity: 2 })
+        .where(eq(circuitDeviceRows.id, "row-1"))
+        .run();
+      linkExternalObject(fixture.context, "row-1", 3);
+      const store = new ProjectDeviceRowSyncProjectCommandRepository(
+        fixture.context.db
+      );
+      const expected = snapshot(fixture.context, "row-1");
+      assert.throws(
+        () =>
+          store.execute({
+            projectId: "project-1",
+            expectedRevision: 0,
+            source: "user",
+            command: createProjectDeviceRowSyncProjectCommand(
+              "project-device-1",
+              "synchronize",
+              [{ rowId: "row-1", expected, target: { ...expected, quantity: 2 } }]
+            ),
+          }),
+        /below the total quantity of linked external objects/
+      );
+      const row = getRow(fixture.context, "row-1");
+      assert.equal(row.quantity, 5);
+      assert.equal(row.manualQuantity, 2);
+      assert.equal(
+        fixture.context.db.select().from(projectRevisions).all().length,
+        0
+      );
+    } finally {
+      fixture.context.close();
+    }
+  });
+
   it("rolls back synchronized rows for a stale project revision", () => {
     const fixture = createTestDatabase();
     try {

From 906aa751c716a93b317a374456586079fd5ae9b0 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 23 Aug 2026 18:25:06 +0200
Subject: [PATCH 03/60] Run the Docker stack on built output instead of dev
 servers

compose.yaml overrode the image's own entrypoint to start "tsx watch" and
"next dev" with CHOKIDAR_USEPOLLING and WATCHPACK_POLLING enabled. The
built dist/ and .next from the image were never used, and the polling
watchers kept both containers busy around the clock whether or not
anyone used the application.

Split the two use cases: compose.yaml now runs node dist/server/index.js
and next start with no source mounts and no watchers, and the watching
setup moves to compose.dev.yaml.

next build writes the rewrite destinations from next.config.mjs into
.next/routes-manifest.json, so next start cannot pick up API_INTERNAL_URL
at runtime the way next dev does. Pass it as a build argument.

Give the web container its own probe. The healthcheck hit "/", which
redirects to "/projects", and fetch follows redirects, so every probe
rendered two pages every five seconds. "/health" could not serve as the
probe because next.config.mjs rewrites it to the API. Add "/web-health"
as a route handler, exclude it from the proxy matcher, and relax both
intervals to 30s.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 Dockerfile                  |  7 +++
 README.md                   | 18 +++++++-
 compose.dev.yaml            | 87 +++++++++++++++++++++++++++++++++++++
 compose.yaml                | 65 ++++++++++++---------------
 docs/deployment.md          | 39 ++++++++++++-----
 package.json                |  3 ++
 src/app/web-health/route.ts | 10 +++++
 src/proxy.ts                |  9 ++--
 8 files changed, 184 insertions(+), 54 deletions(-)
 create mode 100644 compose.dev.yaml
 create mode 100644 src/app/web-health/route.ts

diff --git a/Dockerfile b/Dockerfile
index 5484443..31d28c4 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -5,6 +5,13 @@ COPY package*.json ./
 RUN npm ci
 
 COPY . .
+
+# next build writes the rewrite destinations from next.config.mjs into
+# .next/routes-manifest.json, so "next start" cannot pick up a different
+# API URL later. The value has to be known here, not just at runtime.
+ARG API_INTERNAL_URL=http://localhost:3000
+ENV API_INTERNAL_URL=$API_INTERNAL_URL
+
 RUN npm run build:api && npm run build:web
 
 RUN mkdir -p data && chmod +x scripts/docker-start.sh
diff --git a/README.md b/README.md
index d7a7b09..fc82fca 100644
--- a/README.md
+++ b/README.md
@@ -62,10 +62,24 @@ docker compose logs --follow
 docker compose down
 ```
 
-Der Compose-Stack startet Entwicklungsserver mit Quellcode-Mounts. Er ist kein
-Produktionsdeployment. Details stehen in
+`compose.yaml` startet den Produktionsstand: gebautes `dist/` und `next start`,
+ohne Quellcode-Mounts und ohne Datei-Watcher. Details stehen in
 [Deployment und Betrieb](docs/deployment.md).
 
+Für die Entwicklung mit Hot Reload gibt es einen eigenen Stack mit
+Quellcode-Mounts und Watchern:
+
+```powershell
+docker compose -f compose.dev.yaml up --build --detach
+docker compose -f compose.dev.yaml logs --follow
+docker compose -f compose.dev.yaml down
+```
+
+Die Watcher darin laufen im Polling-Modus, weil Bind-Mounts unter Windows und
+macOS keine inotify-Events durchreichen. Das kostet dauerhaft CPU, auch wenn
+niemand die Anwendung benutzt — deshalb gehört dieser Stack nicht auf einen
+Server.
+
 ## Direkte lokale Entwicklung
 
 Voraussetzungen:
diff --git a/compose.dev.yaml b/compose.dev.yaml
new file mode 100644
index 0000000..86e42e2
--- /dev/null
+++ b/compose.dev.yaml
@@ -0,0 +1,87 @@
+# Development stack: source mounts, watching dev servers, hot reload.
+#   docker compose -f compose.dev.yaml up --build
+#
+# The polling watchers below are needed for bind mounts on Windows and
+# macOS, where inotify events do not cross the VM boundary. They cost
+# continuous CPU, which is why the production stack in compose.yaml does
+# not run watchers at all.
+name: leistungsbilanz-dev
+
+x-logging: &logging
+  driver: json-file
+  options:
+    max-size: "20m"
+    max-file: "10"
+
+services:
+  api:
+    build:
+      context: .
+    command:
+      - sh
+      - -c
+      - npm run db:migrate && npm run db:verify:circuit-schema && npm run dev:api
+    environment:
+      PORT: "3000"
+      CHOKIDAR_USEPOLLING: "true"
+      LOG_LEVEL: "${LOG_LEVEL:-debug}"
+    init: true
+    restart: unless-stopped
+    logging: *logging
+    ports:
+      - "3000:3000"
+    volumes:
+      - ./src:/app/src
+      - ./scripts:/app/scripts
+      - ./data:/app/data
+      - ./drizzle.config.ts:/app/drizzle.config.ts:ro
+      - ./tsconfig.json:/app/tsconfig.json:ro
+    healthcheck:
+      test:
+        - CMD
+        - node
+        - -e
+        - fetch('http://localhost:3000/health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
+      interval: 30s
+      timeout: 3s
+      retries: 5
+      start_period: 20s
+
+  web:
+    build:
+      context: .
+    command:
+      - npm
+      - run
+      - dev:web
+      - --
+      - --hostname
+      - 0.0.0.0
+    environment:
+      API_INTERNAL_URL: http://api:3000
+      WATCHPACK_POLLING: "true"
+      NEXT_TELEMETRY_DISABLED: "1"
+      LOG_LEVEL: "${LOG_LEVEL:-debug}"
+    init: true
+    restart: unless-stopped
+    logging: *logging
+    depends_on:
+      api:
+        condition: service_healthy
+    ports:
+      - "3001:3001"
+    volumes:
+      - ./src:/app/src
+      - ./next.config.mjs:/app/next.config.mjs:ro
+      - ./tsconfig.json:/app/tsconfig.json:ro
+      - ./tsconfig.next.json:/app/tsconfig.next.json:ro
+    healthcheck:
+      test:
+        - CMD
+        - node
+        - -e
+        - fetch('http://localhost:3001/web-health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
+      interval: 30s
+      timeout: 3s
+      retries: 5
+      start_period: 20s
diff --git a/compose.yaml b/compose.yaml
index 6a5ec7c..503a4b2 100644
--- a/compose.yaml
+++ b/compose.yaml
@@ -1,82 +1,73 @@
 name: leistungsbilanz
 
+x-build: &build
+  context: .
+  args:
+    # Baked into .next/routes-manifest.json by next build; see Dockerfile.
+    API_INTERNAL_URL: http://api:3000
+
+x-logging: &logging
+  driver: json-file
+  options:
+    max-size: "20m"
+    max-file: "10"
+
 services:
   api:
-    build:
-      context: .
+    build: *build
     command:
       - sh
       - -c
-      - npm run db:migrate && npm run db:verify:circuit-schema && npm run dev:api
+      - node scripts/run-migrations.js && node scripts/db-verify-circuit-schema.js && node dist/server/index.js
     environment:
+      NODE_ENV: production
       PORT: "3000"
-      CHOKIDAR_USEPOLLING: "true"
       LOG_LEVEL: "${LOG_LEVEL:-info}"
     init: true
     restart: unless-stopped
-    logging:
-      driver: json-file
-      options:
-        max-size: "20m"
-        max-file: "10"
+    logging: *logging
     ports:
       - "3000:3000"
     volumes:
-      - ./src:/app/src
-      - ./scripts:/app/scripts
       - ./data:/app/data
-      - ./drizzle.config.ts:/app/drizzle.config.ts:ro
-      - ./tsconfig.json:/app/tsconfig.json:ro
     healthcheck:
       test:
         - CMD
         - node
         - -e
         - fetch('http://localhost:3000/health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
-      interval: 5s
+      interval: 30s
       timeout: 3s
-      retries: 12
+      retries: 5
       start_period: 20s
 
   web:
-    build:
-      context: .
+    build: *build
     command:
-      - npm
-      - run
-      - dev:web
-      - --
-      - --hostname
-      - 0.0.0.0
+      - node_modules/.bin/next
+      - start
+      - -p
+      - "3001"
     environment:
+      NODE_ENV: production
       API_INTERNAL_URL: http://api:3000
-      WATCHPACK_POLLING: "true"
       NEXT_TELEMETRY_DISABLED: "1"
       LOG_LEVEL: "${LOG_LEVEL:-info}"
     init: true
     restart: unless-stopped
-    logging:
-      driver: json-file
-      options:
-        max-size: "20m"
-        max-file: "10"
+    logging: *logging
     depends_on:
       api:
         condition: service_healthy
     ports:
       - "3001:3001"
-    volumes:
-      - ./src:/app/src
-      - ./next.config.mjs:/app/next.config.mjs:ro
-      - ./tsconfig.json:/app/tsconfig.json:ro
-      - ./tsconfig.next.json:/app/tsconfig.next.json:ro
     healthcheck:
       test:
         - CMD
         - node
         - -e
-        - fetch('http://localhost:3001/').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
-      interval: 5s
+        - fetch('http://localhost:3001/web-health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
+      interval: 30s
       timeout: 3s
-      retries: 12
+      retries: 5
       start_period: 20s
diff --git a/docs/deployment.md b/docs/deployment.md
index dfbb3f1..06289a7 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -2,19 +2,27 @@
 
 ## Aktueller Status
 
-Es gibt derzeit kein unterstütztes Produktionsdeployment.
+Es gibt zwei Compose-Stacks.
 
-`compose.yaml` ist ausschließlich für lokale Entwicklung vorgesehen. Es startet
-`tsx watch` und `next dev`, bindet Quellcode vom Host ein und enthält weder TLS,
-Authentifizierung, Reverse Proxy, Prozesshärtung noch ein zentral betriebenes
-Datenbanksystem. Der Stack darf deshalb nicht als produktionsreif bezeichnet oder
-öffentlich erreichbar gemacht werden.
+`compose.yaml` startet den gebauten Stand: `node dist/server/index.js` und
+`next start`, ohne Quellcode-Mounts und ohne Datei-Watcher. Das ist der Stack
+für einen Server.
 
-## Entwicklungs-Topologie
+`compose.dev.yaml` startet `tsx watch` und `next dev` und bindet Quellcode vom
+Host ein. Die Watcher laufen im Polling-Modus, weil Bind-Mounts unter Windows
+und macOS keine inotify-Events durchreichen; das kostet dauerhaft CPU, auch
+ohne Benutzeraktivität. Dieser Stack gehört deshalb nur auf einen
+Entwicklungsrechner.
+
+Beides enthält weder TLS, Authentifizierung, Reverse Proxy, Prozesshärtung noch
+ein zentral betriebenes Datenbanksystem. Der Stack darf deshalb nicht öffentlich
+erreichbar gemacht werden.
+
+## Topologie
 
 | Komponente | Port | Healthcheck | Persistenz |
 | --- | ---: | --- | --- |
-| Next.js Web | 3001 | `GET /` | keine |
+| Next.js Web | 3001 | `GET /web-health` | keine |
 | Express API | 3000 | `GET /health` | `./data:/app/data` |
 | SQLite | Datei | Integritäts-/FK-Prüfung via Backup und Skript | `data/leistungsbilanz.db` |
 
@@ -24,15 +32,22 @@ Verwendete Umgebungsvariablen:
 - `API_INTERNAL_URL` – internes API-Ziel des Next.js-Rewrites, im Compose-Netz
   `http://api:3000`
 - `NEXT_TELEMETRY_DISABLED=1`
-- `CHOKIDAR_USEPOLLING=true` und `WATCHPACK_POLLING=true` für lokale
-  Dateibeobachtung in Docker
+- `CHOKIDAR_USEPOLLING=true` und `WATCHPACK_POLLING=true` – nur in
+  `compose.dev.yaml`, für Dateibeobachtung über Bind-Mounts hinweg
 - `LOG_LEVEL` – steuert für beide Dienste die Ausgabestufe des strukturierten
   JSON-Loggers (`error`, `warn`, `info`, `verbose`, `debug`), Standard `info`.
   Setzbar über eine `.env`-Datei neben `compose.yaml` oder
   `LOG_LEVEL=verbose docker compose up`.
 
-Beim API-Start laufen zuerst `npm run db:migrate` und
-`npm run db:verify:circuit-schema`.
+Beim API-Start laufen zuerst die Migrationen und die Schemaprüfung
+(`scripts/run-migrations.js` und `scripts/db-verify-circuit-schema.js`, im
+Entwicklungsstack über `npm run db:migrate` und
+`npm run db:verify:circuit-schema`).
+
+`API_INTERNAL_URL` wirkt für `next start` zur **Build-Zeit**: `next build`
+schreibt die Rewrite-Ziele aus `next.config.mjs` fest in
+`.next/routes-manifest.json`. `compose.yaml` reicht den Wert deshalb als
+Build-Argument an das Image durch, nicht nur als Laufzeit-Variable.
 
 ## Logging
 
diff --git a/package.json b/package.json
index d5ebe82..414eb53 100644
--- a/package.json
+++ b/package.json
@@ -13,6 +13,9 @@
     "docker:up": "docker compose up --build --detach",
     "docker:down": "docker compose down",
     "docker:logs": "docker compose logs --follow",
+    "docker:dev:up": "docker compose -f compose.dev.yaml up --build --detach",
+    "docker:dev:down": "docker compose -f compose.dev.yaml down",
+    "docker:dev:logs": "docker compose -f compose.dev.yaml logs --follow",
     "build": "npm run build:api",
     "build:api": "tsc -p tsconfig.json",
     "build:web": "next build",
diff --git a/src/app/web-health/route.ts b/src/app/web-health/route.ts
new file mode 100644
index 0000000..ce6f2c4
--- /dev/null
+++ b/src/app/web-health/route.ts
@@ -0,0 +1,10 @@
+import { NextResponse } from "next/server";
+
+// Liveness probe for the web container itself. The "/health" path is
+// rewritten to the API in next.config.mjs, so it cannot answer for this
+// process. Kept as a route handler so a probe does not render a page.
+export const dynamic = "force-dynamic";
+
+export function GET() {
+  return NextResponse.json({ ok: true });
+}
diff --git a/src/proxy.ts b/src/proxy.ts
index 4607ec0..3f4b83a 100644
--- a/src/proxy.ts
+++ b/src/proxy.ts
@@ -5,8 +5,9 @@ import { createLogger } from "./shared/logging/logger";
 const logger = createLogger("web:navigation");
 
 export function proxy(request: NextRequest) {
-  // The Docker healthcheck hits "/" every few seconds with no User-Agent
-  // header; skip it so real navigation isn't drowned out in the logs.
+  // Probes hit "/web-health" and are excluded by the matcher below. The
+  // User-Agent guard stays as a fallback for anything else that polls
+  // without one, so real navigation isn't drowned out in the logs.
   if (request.headers.get("user-agent")) {
     logger.info("page request", {
       method: request.method,
@@ -17,5 +18,7 @@ export function proxy(request: NextRequest) {
 }
 
 export const config = {
-  matcher: ["/((?!_next/static|_next/image|favicon.ico|api).*)"],
+  matcher: [
+    "/((?!_next/static|_next/image|favicon.ico|api|web-health).*)",
+  ],
 };

From 204499d7e4010533b4edae304863a738e1d4e953 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 23 Aug 2026 23:13:35 +0200
Subject: [PATCH 04/60] Add Revit Dynamo diagnostic scripts

---
 .gitignore                                    |   1 +
 dynamo/01_check_model_identity.py             | 385 +++++++++++++
 ..._electrical_fixture_parameter_inventory.py | 517 ++++++++++++++++++
 dynamo/README.md                              |  69 +++
 4 files changed, 972 insertions(+)
 create mode 100644 dynamo/01_check_model_identity.py
 create mode 100644 dynamo/02_export_electrical_fixture_parameter_inventory.py
 create mode 100644 dynamo/README.md

diff --git a/.gitignore b/.gitignore
index 8d44fb4..ed5ffe6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@ dist/
 data/*.db
 data/backups/*.db
 .codex/*.log
+dynamo/output/
diff --git a/dynamo/01_check_model_identity.py b/dynamo/01_check_model_identity.py
new file mode 100644
index 0000000..a3fe009
--- /dev/null
+++ b/dynamo/01_check_model_identity.py
@@ -0,0 +1,385 @@
+"""Read-only Revit 2026 model-identity diagnostics for a Dynamo Python node.
+
+Optional Dynamo input:
+    IN[0]: output directory or complete .json file path
+
+The script intentionally performs no Revit transaction and changes no model
+data. OUT contains a compact summary plus the complete report.
+"""
+
+import datetime
+import json
+import os
+import platform
+import sys
+import tempfile
+import traceback
+
+import clr
+
+clr.AddReference("RevitAPI")
+clr.AddReference("RevitServices")
+
+from Autodesk.Revit.DB import ModelPathUtils, StorageType  # noqa: E402
+from RevitServices.Persistence import DocumentManager  # noqa: E402
+
+
+CHECKED_PARAMETER_NAMES = ("LB_ModelId", "LB_ProjectId")
+
+
+def safe_text(value):
+    if value is None:
+        return None
+    try:
+        return str(value)
+    except Exception:
+        return None
+
+
+def element_id_text(element_id):
+    if element_id is None:
+        return None
+    try:
+        return str(element_id.Value)
+    except Exception:
+        try:
+            return str(element_id.IntegerValue)
+        except Exception:
+            return safe_text(element_id)
+
+
+def forge_type_id_text(value):
+    if value is None:
+        return None
+    try:
+        return value.TypeId
+    except Exception:
+        return safe_text(value)
+
+
+def parameter_value(parameter):
+    result = {
+        "hasValue": False,
+        "raw": None,
+        "display": None,
+    }
+    try:
+        result["hasValue"] = bool(parameter.HasValue)
+    except Exception:
+        pass
+
+    try:
+        storage_type = parameter.StorageType
+        if storage_type == StorageType.String:
+            result["raw"] = parameter.AsString()
+        elif storage_type == StorageType.Integer:
+            result["raw"] = int(parameter.AsInteger())
+        elif storage_type == StorageType.Double:
+            result["raw"] = float(parameter.AsDouble())
+        elif storage_type == StorageType.ElementId:
+            result["raw"] = element_id_text(parameter.AsElementId())
+    except Exception as error:
+        result["readError"] = safe_text(error)
+
+    try:
+        result["display"] = parameter.AsValueString()
+    except Exception:
+        pass
+    return result
+
+
+def describe_parameter(parameter):
+    definition = None
+    try:
+        definition = parameter.Definition
+    except Exception:
+        pass
+
+    name = None
+    if definition is not None:
+        try:
+            name = definition.Name
+        except Exception:
+            pass
+
+    is_shared = False
+    try:
+        is_shared = bool(parameter.IsShared)
+    except Exception:
+        pass
+
+    shared_guid = None
+    if is_shared:
+        try:
+            shared_guid = str(parameter.GUID)
+        except Exception:
+            pass
+
+    data_type = None
+    group_type = None
+    if definition is not None:
+        try:
+            data_type = forge_type_id_text(definition.GetDataType())
+        except Exception:
+            pass
+        try:
+            group_type = forge_type_id_text(definition.GetGroupTypeId())
+        except Exception:
+            pass
+
+    unit_type = None
+    try:
+        unit_type = forge_type_id_text(parameter.GetUnitTypeId())
+    except Exception:
+        pass
+
+    try:
+        storage_type = str(parameter.StorageType)
+    except Exception:
+        storage_type = None
+
+    try:
+        is_read_only = bool(parameter.IsReadOnly)
+    except Exception:
+        is_read_only = None
+
+    try:
+        user_modifiable = bool(parameter.UserModifiable)
+    except Exception:
+        user_modifiable = None
+
+    return {
+        "name": name,
+        "parameterId": element_id_text(getattr(parameter, "Id", None)),
+        "isShared": is_shared,
+        "sharedGuid": shared_guid,
+        "storageType": storage_type,
+        "dataTypeId": data_type,
+        "groupTypeId": group_type,
+        "unitTypeId": unit_type,
+        "isReadOnly": is_read_only,
+        "userModifiable": user_modifiable,
+        "value": parameter_value(parameter),
+    }
+
+
+def sorted_parameters(element):
+    parameters = []
+    try:
+        parameters = [describe_parameter(parameter) for parameter in element.Parameters]
+    except Exception:
+        return []
+    return sorted(
+        parameters,
+        key=lambda parameter: (
+            (parameter.get("name") or "").casefold(),
+            parameter.get("parameterId") or "",
+        ),
+    )
+
+
+def named_parameter_occurrences(element, parameter_name):
+    result = []
+    try:
+        parameters = element.GetParameters(parameter_name)
+        if parameters is not None:
+            result = [describe_parameter(parameter) for parameter in parameters]
+    except Exception:
+        parameter = None
+        try:
+            parameter = element.LookupParameter(parameter_name)
+        except Exception:
+            pass
+        if parameter is not None:
+            result = [describe_parameter(parameter)]
+    return result
+
+
+def loaded_assembly_versions():
+    result = {}
+    try:
+        from System import AppDomain
+
+        for assembly in AppDomain.CurrentDomain.GetAssemblies():
+            try:
+                name = assembly.GetName()
+                simple_name = str(name.Name)
+                if simple_name in (
+                    "DynamoCore",
+                    "DynamoCoreWpf",
+                    "DynamoRevitDS",
+                    "RevitAPI",
+                    "RevitServices",
+                ):
+                    result[simple_name] = str(name.Version)
+            except Exception:
+                continue
+    except Exception:
+        pass
+    return dict(sorted(result.items()))
+
+
+def get_cloud_identity(document):
+    result = {"isModelInCloud": False}
+    try:
+        result["isModelInCloud"] = bool(document.IsModelInCloud)
+    except Exception:
+        return result
+    if not result["isModelInCloud"]:
+        return result
+
+    try:
+        model_path = document.GetCloudModelPath()
+        result["userVisiblePath"] = ModelPathUtils.ConvertModelPathToUserVisiblePath(
+            model_path
+        )
+        for property_name, output_name in (
+            ("GetProjectGUID", "projectGuid"),
+            ("GetModelGUID", "modelGuid"),
+        ):
+            try:
+                result[output_name] = str(getattr(model_path, property_name)())
+            except Exception:
+                pass
+    except Exception as error:
+        result["readError"] = safe_text(error)
+    return result
+
+
+def get_worksharing_identity(document):
+    result = {"isWorkshared": False}
+    try:
+        result["isWorkshared"] = bool(document.IsWorkshared)
+    except Exception:
+        return result
+    if not result["isWorkshared"]:
+        return result
+
+    try:
+        model_path = document.GetWorksharingCentralModelPath()
+        result["centralModelPath"] = ModelPathUtils.ConvertModelPathToUserVisiblePath(
+            model_path
+        )
+    except Exception as error:
+        result["readError"] = safe_text(error)
+    return result
+
+
+def resolve_output_path(configured_path, report_name):
+    timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+    default_directory = os.path.join(tempfile.gettempdir(), "leistungsbilanz-dynamo")
+    raw_path = safe_text(configured_path)
+    if raw_path is None or not raw_path.strip():
+        directory = default_directory
+        file_path = os.path.join(directory, report_name + "-" + timestamp + ".json")
+    else:
+        expanded = os.path.abspath(os.path.expandvars(os.path.expanduser(raw_path.strip())))
+        if expanded.lower().endswith(".json"):
+            file_path = expanded
+            directory = os.path.dirname(file_path)
+        else:
+            directory = expanded
+            file_path = os.path.join(directory, report_name + "-" + timestamp + ".json")
+    if not directory:
+        directory = os.getcwd()
+    if not os.path.isdir(directory):
+        os.makedirs(directory)
+    return file_path
+
+
+def write_json(file_path, payload):
+    temporary_path = file_path + ".tmp"
+    with open(temporary_path, "w", encoding="utf-8", newline="\n") as output:
+        json.dump(payload, output, ensure_ascii=False, indent=2, sort_keys=True)
+        output.write("\n")
+    os.replace(temporary_path, file_path)
+
+
+def get_input(index, default=None):
+    values = globals().get("IN", [])
+    try:
+        value = values[index]
+        return default if value is None else value
+    except Exception:
+        return default
+
+
+def build_report():
+    document = DocumentManager.Instance.CurrentDBDocument
+    if document is None:
+        raise RuntimeError("No active Revit document is available.")
+
+    project_information = document.ProjectInformation
+    if project_information is None:
+        raise RuntimeError("The active document has no Project Information element.")
+
+    application = document.Application
+    checked_parameters = {
+        name: named_parameter_occurrences(project_information, name)
+        for name in CHECKED_PARAMETER_NAMES
+    }
+    warnings = []
+    for name in CHECKED_PARAMETER_NAMES:
+        occurrences = checked_parameters[name]
+        populated = [
+            parameter
+            for parameter in occurrences
+            if parameter.get("value", {}).get("raw") not in (None, "")
+        ]
+        if not occurrences:
+            warnings.append(name + " is not bound to Project Information.")
+        elif not populated:
+            warnings.append(name + " exists but has no value on Project Information.")
+        elif len(occurrences) > 1:
+            warnings.append(name + " occurs more than once; use a shared-parameter GUID later.")
+
+    return {
+        "reportSchemaVersion": 1,
+        "generatedAt": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+        "readOnly": True,
+        "environment": {
+            "revitVersionNumber": safe_text(getattr(application, "VersionNumber", None)),
+            "revitVersionName": safe_text(getattr(application, "VersionName", None)),
+            "revitSubVersionNumber": safe_text(
+                getattr(application, "SubVersionNumber", None)
+            ),
+            "pythonImplementation": safe_text(getattr(sys.implementation, "name", None)),
+            "pythonVersion": platform.python_version(),
+            "assemblies": loaded_assembly_versions(),
+        },
+        "document": {
+            "title": safe_text(document.Title),
+            "pathName": safe_text(document.PathName),
+            "isFamilyDocument": bool(document.IsFamilyDocument),
+            "cloud": get_cloud_identity(document),
+            "worksharing": get_worksharing_identity(document),
+        },
+        "modelIdentityCandidates": {
+            "projectInformationUniqueId": safe_text(project_information.UniqueId),
+            "projectInformationElementId": element_id_text(project_information.Id),
+            "checkedProjectParameters": checked_parameters,
+        },
+        "projectInformationParameters": sorted_parameters(project_information),
+        "warnings": warnings,
+    }
+
+
+try:
+    report = build_report()
+    output_path = resolve_output_path(get_input(0), "model-identity")
+    write_json(output_path, report)
+    OUT = {
+        "ok": True,
+        "filePath": output_path,
+        "projectInformationUniqueId": report["modelIdentityCandidates"][
+            "projectInformationUniqueId"
+        ],
+        "warnings": report["warnings"],
+        "report": report,
+    }
+except Exception as error:
+    OUT = {
+        "ok": False,
+        "error": safe_text(error),
+        "traceback": traceback.format_exc(),
+    }
diff --git a/dynamo/02_export_electrical_fixture_parameter_inventory.py b/dynamo/02_export_electrical_fixture_parameter_inventory.py
new file mode 100644
index 0000000..440a222
--- /dev/null
+++ b/dynamo/02_export_electrical_fixture_parameter_inventory.py
@@ -0,0 +1,517 @@
+"""Export all Electrical Fixtures instance/type parameters from Revit 2026.
+
+Optional Dynamo inputs:
+    IN[0]: output directory or complete .json file path
+    IN[1]: include empty parameters (default True)
+    IN[2]: maximum aggregated sample values (default 5)
+
+The script is read-only and performs no Revit transaction.
+"""
+
+import datetime
+import json
+import os
+import platform
+import sys
+import tempfile
+import traceback
+
+import clr
+
+clr.AddReference("RevitAPI")
+clr.AddReference("RevitServices")
+
+from Autodesk.Revit.DB import (  # noqa: E402
+    BuiltInCategory,
+    FilteredElementCollector,
+    ModelPathUtils,
+    StorageType,
+)
+from RevitServices.Persistence import DocumentManager  # noqa: E402
+
+
+def safe_text(value):
+    if value is None:
+        return None
+    try:
+        return str(value)
+    except Exception:
+        return None
+
+
+def element_id_text(element_id):
+    if element_id is None:
+        return None
+    try:
+        return str(element_id.Value)
+    except Exception:
+        try:
+            return str(element_id.IntegerValue)
+        except Exception:
+            return safe_text(element_id)
+
+
+def forge_type_id_text(value):
+    if value is None:
+        return None
+    try:
+        return value.TypeId
+    except Exception:
+        return safe_text(value)
+
+
+def parameter_value(parameter):
+    result = {"hasValue": False, "raw": None, "display": None}
+    try:
+        result["hasValue"] = bool(parameter.HasValue)
+    except Exception:
+        pass
+
+    try:
+        storage_type = parameter.StorageType
+        if storage_type == StorageType.String:
+            result["raw"] = parameter.AsString()
+        elif storage_type == StorageType.Integer:
+            result["raw"] = int(parameter.AsInteger())
+        elif storage_type == StorageType.Double:
+            result["raw"] = float(parameter.AsDouble())
+        elif storage_type == StorageType.ElementId:
+            result["raw"] = element_id_text(parameter.AsElementId())
+    except Exception as error:
+        result["readError"] = safe_text(error)
+
+    try:
+        result["display"] = parameter.AsValueString()
+    except Exception:
+        pass
+    return result
+
+
+def describe_parameter(parameter, scope):
+    definition = None
+    try:
+        definition = parameter.Definition
+    except Exception:
+        pass
+
+    name = None
+    data_type = None
+    group_type = None
+    if definition is not None:
+        try:
+            name = definition.Name
+        except Exception:
+            pass
+        try:
+            data_type = forge_type_id_text(definition.GetDataType())
+        except Exception:
+            pass
+        try:
+            group_type = forge_type_id_text(definition.GetGroupTypeId())
+        except Exception:
+            pass
+
+    is_shared = False
+    try:
+        is_shared = bool(parameter.IsShared)
+    except Exception:
+        pass
+
+    shared_guid = None
+    if is_shared:
+        try:
+            shared_guid = str(parameter.GUID)
+        except Exception:
+            pass
+
+    unit_type = None
+    try:
+        unit_type = forge_type_id_text(parameter.GetUnitTypeId())
+    except Exception:
+        pass
+
+    try:
+        storage_type = str(parameter.StorageType)
+    except Exception:
+        storage_type = None
+
+    try:
+        is_read_only = bool(parameter.IsReadOnly)
+    except Exception:
+        is_read_only = None
+
+    try:
+        user_modifiable = bool(parameter.UserModifiable)
+    except Exception:
+        user_modifiable = None
+
+    return {
+        "scope": scope,
+        "name": name,
+        "parameterId": element_id_text(getattr(parameter, "Id", None)),
+        "isShared": is_shared,
+        "sharedGuid": shared_guid,
+        "storageType": storage_type,
+        "dataTypeId": data_type,
+        "groupTypeId": group_type,
+        "unitTypeId": unit_type,
+        "isReadOnly": is_read_only,
+        "userModifiable": user_modifiable,
+        "value": parameter_value(parameter),
+    }
+
+
+def has_meaningful_value(parameter_description):
+    value = parameter_description.get("value", {})
+    return bool(value.get("hasValue")) or value.get("raw") not in (None, "") or value.get(
+        "display"
+    ) not in (None, "")
+
+
+def read_parameters(element, scope, include_empty):
+    result = []
+    try:
+        for parameter in element.Parameters:
+            description = describe_parameter(parameter, scope)
+            if include_empty or has_meaningful_value(description):
+                result.append(description)
+    except Exception as error:
+        return [], [safe_text(error)]
+    result.sort(
+        key=lambda parameter: (
+            (parameter.get("name") or "").casefold(),
+            parameter.get("parameterId") or "",
+        )
+    )
+    return result, []
+
+
+def read_space(element, document):
+    try:
+        space = element.Space
+    except Exception as error:
+        return None, safe_text(error)
+    if space is None:
+        return None, None
+
+    level_name = None
+    try:
+        level = document.GetElement(space.LevelId)
+        level_name = None if level is None else safe_text(level.Name)
+    except Exception:
+        pass
+
+    return {
+        "uniqueId": safe_text(space.UniqueId),
+        "elementId": element_id_text(space.Id),
+        "number": safe_text(getattr(space, "Number", None)),
+        "name": safe_text(getattr(space, "Name", None)),
+        "levelName": level_name,
+    }, None
+
+
+def read_family_identity(element, document):
+    symbol = None
+    try:
+        symbol = element.Symbol
+    except Exception:
+        try:
+            symbol = document.GetElement(element.GetTypeId())
+        except Exception:
+            pass
+
+    family_name = None
+    type_name = None
+    type_unique_id = None
+    type_element_id = None
+    if symbol is not None:
+        try:
+            family_name = safe_text(symbol.Family.Name)
+        except Exception:
+            family_name = safe_text(getattr(symbol, "FamilyName", None))
+        type_name = safe_text(getattr(symbol, "Name", None))
+        type_unique_id = safe_text(getattr(symbol, "UniqueId", None))
+        type_element_id = element_id_text(getattr(symbol, "Id", None))
+
+    return {
+        "familyName": family_name,
+        "typeName": type_name,
+        "typeUniqueId": type_unique_id,
+        "typeElementId": type_element_id,
+    }, symbol
+
+
+def parameter_inventory_key(parameter):
+    stable_id = parameter.get("sharedGuid") or parameter.get("parameterId") or ""
+    return "|".join(
+        (
+            parameter.get("scope") or "",
+            stable_id,
+            parameter.get("name") or "",
+            parameter.get("dataTypeId") or "",
+        )
+    )
+
+
+def sample_value_key(value):
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def add_to_inventory(inventory, parameter, max_samples):
+    key = parameter_inventory_key(parameter)
+    entry = inventory.get(key)
+    if entry is None:
+        entry = {
+            "scope": parameter.get("scope"),
+            "name": parameter.get("name"),
+            "parameterId": parameter.get("parameterId"),
+            "isShared": parameter.get("isShared"),
+            "sharedGuid": parameter.get("sharedGuid"),
+            "storageType": parameter.get("storageType"),
+            "dataTypeId": parameter.get("dataTypeId"),
+            "groupTypeId": parameter.get("groupTypeId"),
+            "unitTypeId": parameter.get("unitTypeId"),
+            "occurrenceCount": 0,
+            "populatedCount": 0,
+            "sampleValues": [],
+            "_sampleKeys": set(),
+        }
+        inventory[key] = entry
+    entry["occurrenceCount"] += 1
+    if has_meaningful_value(parameter):
+        entry["populatedCount"] += 1
+    value = parameter.get("value")
+    value_key = sample_value_key(value)
+    if len(entry["sampleValues"]) < max_samples and value_key not in entry["_sampleKeys"]:
+        entry["_sampleKeys"].add(value_key)
+        entry["sampleValues"].append(value)
+
+
+def finalize_inventory(inventory):
+    result = []
+    for entry in inventory.values():
+        clean_entry = dict(entry)
+        clean_entry.pop("_sampleKeys", None)
+        result.append(clean_entry)
+    return sorted(
+        result,
+        key=lambda entry: (
+            entry.get("scope") or "",
+            (entry.get("name") or "").casefold(),
+            entry.get("sharedGuid") or entry.get("parameterId") or "",
+        ),
+    )
+
+
+def loaded_assembly_versions():
+    result = {}
+    try:
+        from System import AppDomain
+
+        for assembly in AppDomain.CurrentDomain.GetAssemblies():
+            try:
+                name = assembly.GetName()
+                simple_name = str(name.Name)
+                if simple_name in (
+                    "DynamoCore",
+                    "DynamoCoreWpf",
+                    "DynamoRevitDS",
+                    "RevitAPI",
+                    "RevitServices",
+                ):
+                    result[simple_name] = str(name.Version)
+            except Exception:
+                continue
+    except Exception:
+        pass
+    return dict(sorted(result.items()))
+
+
+def resolve_output_path(configured_path):
+    timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+    default_directory = os.path.join(tempfile.gettempdir(), "leistungsbilanz-dynamo")
+    raw_path = safe_text(configured_path)
+    if raw_path is None or not raw_path.strip():
+        directory = default_directory
+        file_path = os.path.join(
+            directory, "electrical-fixture-parameters-" + timestamp + ".json"
+        )
+    else:
+        expanded = os.path.abspath(os.path.expandvars(os.path.expanduser(raw_path.strip())))
+        if expanded.lower().endswith(".json"):
+            file_path = expanded
+            directory = os.path.dirname(file_path)
+        else:
+            directory = expanded
+            file_path = os.path.join(
+                directory, "electrical-fixture-parameters-" + timestamp + ".json"
+            )
+    if not directory:
+        directory = os.getcwd()
+    if not os.path.isdir(directory):
+        os.makedirs(directory)
+    return file_path
+
+
+def write_json(file_path, payload):
+    temporary_path = file_path + ".tmp"
+    with open(temporary_path, "w", encoding="utf-8", newline="\n") as output:
+        json.dump(payload, output, ensure_ascii=False, indent=2, sort_keys=True)
+        output.write("\n")
+    os.replace(temporary_path, file_path)
+
+
+def get_input(index, default=None):
+    values = globals().get("IN", [])
+    try:
+        value = values[index]
+        return default if value is None else value
+    except Exception:
+        return default
+
+
+def build_report(include_empty, max_samples):
+    document = DocumentManager.Instance.CurrentDBDocument
+    if document is None:
+        raise RuntimeError("No active Revit document is available.")
+    if document.IsFamilyDocument:
+        raise RuntimeError("Open a Revit project document, not a family document.")
+
+    application = document.Application
+    collector = (
+        FilteredElementCollector(document)
+        .OfCategory(BuiltInCategory.OST_ElectricalFixtures)
+        .WhereElementIsNotElementType()
+    )
+    source_elements = list(collector)
+    source_elements.sort(key=lambda element: safe_text(element.UniqueId) or "")
+
+    elements = []
+    types_by_unique_id = {}
+    inventory = {}
+    errors = []
+    elements_without_space = 0
+
+    for element in source_elements:
+        element_errors = []
+        try:
+            family_identity, symbol = read_family_identity(element, document)
+            instance_parameters, parameter_errors = read_parameters(
+                element, "instance", include_empty
+            )
+            element_errors.extend(parameter_errors)
+            for parameter in instance_parameters:
+                add_to_inventory(inventory, parameter, max_samples)
+
+            type_unique_id = family_identity.get("typeUniqueId")
+            if symbol is not None and type_unique_id and type_unique_id not in types_by_unique_id:
+                type_parameters, type_errors = read_parameters(symbol, "type", include_empty)
+                element_errors.extend(type_errors)
+                for parameter in type_parameters:
+                    add_to_inventory(inventory, parameter, max_samples)
+                types_by_unique_id[type_unique_id] = {
+                    **family_identity,
+                    "parameters": type_parameters,
+                }
+
+            space, space_error = read_space(element, document)
+            if space_error:
+                element_errors.append("MEP Space: " + space_error)
+            if space is None:
+                elements_without_space += 1
+
+            elements.append(
+                {
+                    "uniqueId": safe_text(element.UniqueId),
+                    "elementId": element_id_text(element.Id),
+                    "categoryName": safe_text(
+                        None if element.Category is None else element.Category.Name
+                    ),
+                    "family": family_identity,
+                    "space": space,
+                    "instanceParameters": instance_parameters,
+                    "warnings": element_errors,
+                }
+            )
+        except Exception as error:
+            errors.append(
+                {
+                    "uniqueId": safe_text(getattr(element, "UniqueId", None)),
+                    "elementId": element_id_text(getattr(element, "Id", None)),
+                    "error": safe_text(error),
+                }
+            )
+
+    return {
+        "reportSchemaVersion": 1,
+        "generatedAt": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+        "readOnly": True,
+        "complete": len(errors) == 0,
+        "scope": {
+            "builtInCategory": "OST_ElectricalFixtures",
+            "wholeDocument": True,
+            "elementTypesExcluded": True,
+            "includeEmptyParameters": include_empty,
+        },
+        "environment": {
+            "revitVersionNumber": safe_text(getattr(application, "VersionNumber", None)),
+            "revitVersionName": safe_text(getattr(application, "VersionName", None)),
+            "revitSubVersionNumber": safe_text(
+                getattr(application, "SubVersionNumber", None)
+            ),
+            "pythonImplementation": safe_text(getattr(sys.implementation, "name", None)),
+            "pythonVersion": platform.python_version(),
+            "assemblies": loaded_assembly_versions(),
+        },
+        "document": {
+            "title": safe_text(document.Title),
+            "pathName": safe_text(document.PathName),
+            "projectInformationUniqueId": safe_text(document.ProjectInformation.UniqueId),
+        },
+        "summary": {
+            "elementCount": len(source_elements),
+            "exportedElementCount": len(elements),
+            "typeCount": len(types_by_unique_id),
+            "parameterDefinitionCount": len(inventory),
+            "elementsWithoutMepSpace": elements_without_space,
+            "elementErrorCount": len(errors),
+        },
+        "parameterInventory": finalize_inventory(inventory),
+        "types": sorted(
+            types_by_unique_id.values(),
+            key=lambda entry: (
+                (entry.get("familyName") or "").casefold(),
+                (entry.get("typeName") or "").casefold(),
+                entry.get("typeUniqueId") or "",
+            ),
+        ),
+        "elements": elements,
+        "errors": errors,
+    }
+
+
+try:
+    include_empty_input = get_input(1, True)
+    include_empty = bool(include_empty_input)
+    try:
+        max_samples = int(get_input(2, 5))
+    except Exception:
+        max_samples = 5
+    max_samples = max(0, min(max_samples, 50))
+
+    report = build_report(include_empty, max_samples)
+    output_path = resolve_output_path(get_input(0))
+    write_json(output_path, report)
+    OUT = {
+        "ok": True,
+        "filePath": output_path,
+        "complete": report["complete"],
+        "summary": report["summary"],
+        "errors": report["errors"],
+    }
+except Exception as error:
+    OUT = {
+        "ok": False,
+        "error": safe_text(error),
+        "traceback": traceback.format_exc(),
+    }
diff --git a/dynamo/README.md b/dynamo/README.md
new file mode 100644
index 0000000..800eded
--- /dev/null
+++ b/dynamo/README.md
@@ -0,0 +1,69 @@
+# Revit 2026 / Dynamo diagnostics
+
+This directory contains self-contained Python scripts for a Dynamo **Python
+Script** node. They use only Dynamo's built-in Revit integration, the Revit API
+and the Python standard library. No Dynamo package is required.
+
+The scripts are read-only. They do not start a Revit transaction and do not
+change the open model.
+
+## Python engine
+
+Use the built-in `CPython3` engine in Revit 2026. Autodesk ships Dynamo with
+Revit; optional PythonNet3 packages are not required by these diagnostics.
+
+## 01 - Check model identity
+
+File: `01_check_model_identity.py`
+
+The script reports:
+
+- Revit, Dynamo and Python versions;
+- `ProjectInformation.UniqueId` as a native model-identity candidate;
+- all occurrences and values of `LB_ModelId` and `LB_ProjectId` on Project
+  Information;
+- all Project Information parameters;
+- optional cloud/worksharing identity information when the API exposes it.
+
+Input `IN[0]` is optional. It may be either an output directory or a complete
+`.json` file path. With no input, the report is written below the current
+Windows temporary directory in `leistungsbilanz-dynamo`.
+
+## 02 - Inventory Electrical Fixtures parameters
+
+File: `02_export_electrical_fixture_parameter_inventory.py`
+
+The script reads every instance of
+`BuiltInCategory.OST_ElectricalFixtures` in the complete current document. It
+exports:
+
+- element, family, type and MEP Space identities;
+- every instance parameter and value;
+- every unique family-type parameter and value;
+- an aggregated parameter inventory with occurrence counts and sample values;
+- per-element warnings instead of aborting at the first unreadable element.
+
+Inputs:
+
+- `IN[0]` (optional): output directory or complete `.json` path;
+- `IN[1]` (optional): include empty parameters, default `true`;
+- `IN[2]` (optional): maximum sample values per aggregated parameter, default
+  `5`.
+
+The default output location is again the Windows temporary directory. The
+generated report can contain model paths and project-specific parameter values;
+review it before sharing or committing it.
+
+## Running a script
+
+1. Open the target model in Revit 2026.
+2. Open Dynamo from **Manage > Visual Programming > Dynamo**.
+3. Create a graph and add a **Python Script** node.
+4. Select the `CPython3` engine for the node.
+5. Copy the complete content of the desired `.py` file into the node.
+6. Optionally connect a String node containing the output path to `IN[0]`.
+7. Run the graph and inspect `OUT` for status, counts and the generated path.
+
+For the first test, run `01_check_model_identity.py` in the Revit main model.
+Then run the parameter inventory. Keep both generated JSON files so their
+structure can be checked before the production snapshot DTO is finalized.

From 2e3e85a8e52cfd1bd3434b9cc03af22bf164119d Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 16 Sep 2026 11:04:34 +0200
Subject: [PATCH 05/60] Harden the container runtime and shut down cleanly

Running the stack on built output stopped the idle CPU load, but the
remaining findings from the deployment report were still open.

The Dockerfile is now multi-stage. The prod target runs on node:24-slim as
the "node" user instead of root and carries only its runtime dependencies;
"npm prune --omit=dev" drops tsx, drizzle-kit and typescript. The migration
scripts need drizzle-orm and better-sqlite3, both regular dependencies, so
they keep working. The dev target keeps devDependencies for compose.dev.yaml.

Both compose files get a mem_limit. The server stack also sets memswap_limit
to the same value, so a leak lets the OOM killer replace the container
instead of pushing the host into swap. The Express API is no longer
published on the host: it has no authentication and is reached through the
Next.js rewrite. Development ports are bound to the loopback interface.
Services drop all capabilities and run with no-new-privileges.

SIGTERM and SIGINT now close the HTTP server and the SQLite handle and exit,
instead of only logging the signal and waiting for the container's SIGKILL
ten seconds later. server.closeIdleConnections() releases the keep-alive
sockets the Next.js server holds, which would otherwise keep server.close()
pending for the whole grace period. The compose start commands exec into
node, because otherwise sh stays the foreground process and the signal never
reaches it.

Delete scripts/docker-start.sh rather than fixing its unsupervised
background API: both compose stacks set their own command, so the
single-container entrypoint has no caller left. Also remove drizzle.config.js
(a stray tsc artifact drizzle-kit never reads) and the pre-Next index.html
and styles.css.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 .dockerignore           |  3 ++
 .gitignore              |  2 ++
 Dockerfile              | 57 +++++++++++++++++++++++++++++-------
 README.md               | 13 +++++++--
 compose.dev.yaml        | 56 ++++++++++++++++++++++-------------
 compose.yaml            | 65 ++++++++++++++++++++++++++++++-----------
 docs/deployment.md      | 56 ++++++++++++++++++++++++++++++-----
 drizzle.config.js       | 11 -------
 index.html              | 17 -----------
 scripts/docker-start.sh | 16 ----------
 src/db/client.ts        |  7 +++++
 src/server/index.ts     | 41 +++++++++++++++++++++++---
 styles.css              | 15 ----------
 13 files changed, 238 insertions(+), 121 deletions(-)
 delete mode 100644 drizzle.config.js
 delete mode 100644 index.html
 delete mode 100644 scripts/docker-start.sh
 delete mode 100644 styles.css

diff --git a/.dockerignore b/.dockerignore
index 80054d0..abd6bc2 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -6,3 +6,6 @@ data
 *.db
 .env
 .env.*
+# Lokale Werkzeug- und Agenten-Artefakte gehoeren nicht ins Image.
+.codex
+.agents
diff --git a/.gitignore b/.gitignore
index ed5ffe6..e0ef1d2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,8 @@
 node_modules/
 dist/
 .next/
+# Streuprodukt von tsc; drizzle-kit liest drizzle.config.ts.
+/drizzle.config.js
 data/*.db
 data/backups/*.db
 .codex/*.log
diff --git a/Dockerfile b/Dockerfile
index 31d28c4..66147e7 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,21 +1,56 @@
-FROM node:24
-WORKDIR /app
+# syntax=docker/dockerfile:1
 
+# ---------------------------------------------------------------------------
+# deps: vollstaendiger Abhaengigkeitsbaum, gemeinsam genutzt von "dev" und
+# "build". Bleibt auf dem vollen node-Image, weil better-sqlite3 beim
+# Installieren eine Toolchain braucht.
+# ---------------------------------------------------------------------------
+FROM node:24 AS deps
+WORKDIR /app
 COPY package*.json ./
 RUN npm ci
 
+# ---------------------------------------------------------------------------
+# dev: Ziel fuer compose.dev.yaml. Behaelt devDependencies, damit tsx,
+# drizzle-kit und "next dev" verfuegbar sind. Die Quellen kommen zur Laufzeit
+# ueber Bind-Mounts, das COPY hier ist nur der Ausgangsstand.
+# ---------------------------------------------------------------------------
+FROM deps AS dev
+ENV NODE_ENV=development
 COPY . .
+RUN mkdir -p data
+EXPOSE 3000 3001
+CMD ["npm", "run", "dev:api"]
 
-# next build writes the rewrite destinations from next.config.mjs into
-# .next/routes-manifest.json, so "next start" cannot pick up a different
-# API URL later. The value has to be known here, not just at runtime.
+# ---------------------------------------------------------------------------
+# build: API nach dist/ und Frontend nach .next/ uebersetzen, danach die
+# devDependencies entfernen, damit das Laufzeit-Image nur noch traegt, was es
+# auch ausfuehrt. Die Migrationsskripte kommen mit drizzle-orm und
+# better-sqlite3 aus, beides sind regulaere dependencies.
+# ---------------------------------------------------------------------------
+FROM deps AS build
+ENV NEXT_TELEMETRY_DISABLED=1
+# next build schreibt die Rewrite-Ziele aus next.config.mjs fest in
+# .next/routes-manifest.json, "next start" kann eine andere API-Adresse
+# spaeter nicht mehr uebernehmen. Der Wert muss hier bekannt sein, nicht erst
+# zur Laufzeit. Server-Komponenten lesen die Variable zur Laufzeit.
 ARG API_INTERNAL_URL=http://localhost:3000
 ENV API_INTERNAL_URL=$API_INTERNAL_URL
-
+COPY . .
 RUN npm run build:api && npm run build:web
+RUN npm prune --omit=dev
 
-RUN mkdir -p data && chmod +x scripts/docker-start.sh
-
-EXPOSE 3001
-
-CMD ["sh", "scripts/docker-start.sh"]
+# ---------------------------------------------------------------------------
+# prod: Laufzeit-Image. node:24-slim teilt sich das Debian-Release mit der
+# build-Stufe, damit das kompilierte better-sqlite3-Binding ladbar bleibt.
+# Laeuft als "node" (UID 1000) statt als root.
+# ---------------------------------------------------------------------------
+FROM node:24-slim AS prod
+ENV NODE_ENV=production
+ENV NEXT_TELEMETRY_DISABLED=1
+WORKDIR /app
+COPY --from=build --chown=node:node /app ./
+RUN mkdir -p data && chown node:node data
+USER node
+EXPOSE 3000 3001
+CMD ["node", "dist/server/index.js"]
diff --git a/README.md b/README.md
index fc82fca..58f1832 100644
--- a/README.md
+++ b/README.md
@@ -50,12 +50,20 @@ docker compose up --build --detach
 Danach:
 
 - Frontend: <http://localhost:3001>
-- API-Healthcheck: <http://localhost:3000/health>
+- API-Healthcheck: <http://localhost:3001/health> (über den Next.js-Rewrite)
+
+Die Express-API ist nicht mehr auf dem Host veröffentlicht. Sie hat keine
+Authentifizierung und ist nur innerhalb des Compose-Netzes erreichbar; der
+Zugriff läuft über den Rewrite im Web-Dienst.
 
 Der API-Container führt ausstehende Migrationen und die Schemaprüfung beim Start
 automatisch aus. Die SQLite-Datei liegt auf dem Host unter
 `data/leistungsbilanz.db` und bleibt beim Stoppen erhalten.
 
+Das Laufzeit-Image läuft als Benutzer `node` (UID 1000), nicht als root. Ein
+`data/`-Verzeichnis, das ein früherer root-Container angelegt hat, braucht
+deshalb einmalig `sudo chown -R 1000:1000 data` auf dem Host.
+
 ```powershell
 docker compose ps
 docker compose logs --follow
@@ -63,7 +71,8 @@ docker compose down
 ```
 
 `compose.yaml` startet den Produktionsstand: gebautes `dist/` und `next start`,
-ohne Quellcode-Mounts und ohne Datei-Watcher. Details stehen in
+ohne Quellcode-Mounts und ohne Datei-Watcher, mit Speichergrenzen und ohne
+root-Rechte im Container. Details stehen in
 [Deployment und Betrieb](docs/deployment.md).
 
 Für die Entwicklung mit Hot Reload gibt es einen eigenen Stack mit
diff --git a/compose.dev.yaml b/compose.dev.yaml
index 86e42e2..b9c64b4 100644
--- a/compose.dev.yaml
+++ b/compose.dev.yaml
@@ -1,35 +1,47 @@
-# Development stack: source mounts, watching dev servers, hot reload.
+# Entwicklungs-Stack: Quellcode-Mounts, laufende Dev-Server, Hot Reload.
 #   docker compose -f compose.dev.yaml up --build
 #
-# The polling watchers below are needed for bind mounts on Windows and
-# macOS, where inotify events do not cross the VM boundary. They cost
-# continuous CPU, which is why the production stack in compose.yaml does
-# not run watchers at all.
+# Die Polling-Watcher unten sind fuer Bind-Mounts unter Windows und macOS
+# noetig, weil inotify-Events die VM-Grenze nicht passieren. Sie kosten
+# dauerhaft CPU; genau deshalb laufen im Server-Stack (compose.yaml) gar
+# keine Watcher.
+#
+# Der Projektname muss sich von dem des Server-Stacks unterscheiden, damit
+# "docker compose down" in diesem Verzeichnis niemals einen laufenden
+# Server-Stack abraeumen kann.
 name: leistungsbilanz-dev
 
-x-logging: &logging
-  driver: json-file
-  options:
-    max-size: "20m"
-    max-file: "10"
+x-service-defaults: &service-defaults
+  init: true
+  restart: unless-stopped
+  stop_grace_period: 20s
+  logging:
+    driver: json-file
+    options:
+      max-size: "20m"
+      max-file: "10"
 
 services:
   api:
+    <<: *service-defaults
     build:
       context: .
+      target: dev
     command:
       - sh
       - -c
-      - npm run db:migrate && npm run db:verify:circuit-schema && npm run dev:api
+      - npm run db:migrate && npm run db:verify:circuit-schema && exec npm run dev:api
     environment:
       PORT: "3000"
       CHOKIDAR_USEPOLLING: "true"
       LOG_LEVEL: "${LOG_LEVEL:-debug}"
-    init: true
-    restart: unless-stopped
-    logging: *logging
+    # Nur auf dem Loopback: nichts davon ist authentifiziert, die API darf
+    # nicht aus dem LAN erreichbar sein.
     ports:
-      - "3000:3000"
+      - "127.0.0.1:3000:3000"
+    # Kein memswap_limit wie im Server-Stack: beim Entwickeln ist Swap als
+    # Puffer erwuenscht, die Grenze soll nur den Host vor Dauerlast schuetzen.
+    mem_limit: 1g
     volumes:
       - ./src:/app/src
       - ./scripts:/app/scripts
@@ -41,15 +53,17 @@ services:
         - CMD
         - node
         - -e
-        - fetch('http://localhost:3000/health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
+        - fetch('http://127.0.0.1:3000/health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
       interval: 30s
       timeout: 3s
       retries: 5
       start_period: 20s
 
   web:
+    <<: *service-defaults
     build:
       context: .
+      target: dev
     command:
       - npm
       - run
@@ -62,14 +76,14 @@ services:
       WATCHPACK_POLLING: "true"
       NEXT_TELEMETRY_DISABLED: "1"
       LOG_LEVEL: "${LOG_LEVEL:-debug}"
-    init: true
-    restart: unless-stopped
-    logging: *logging
     depends_on:
       api:
         condition: service_healthy
     ports:
-      - "3001:3001"
+      - "127.0.0.1:3001:3001"
+    # "next dev" haelt Kompilierzustand und waechst im Dauerbetrieb stetig;
+    # die Grenze macht daraus einen Container-Neustart statt Host-Swapping.
+    mem_limit: 2g
     volumes:
       - ./src:/app/src
       - ./next.config.mjs:/app/next.config.mjs:ro
@@ -80,7 +94,7 @@ services:
         - CMD
         - node
         - -e
-        - fetch('http://localhost:3001/web-health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
+        - fetch('http://127.0.0.1:3001/web-health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
       interval: 30s
       timeout: 3s
       retries: 5
diff --git a/compose.yaml b/compose.yaml
index 503a4b2..3438f90 100644
--- a/compose.yaml
+++ b/compose.yaml
@@ -1,33 +1,59 @@
+# Server-Stack: gebauter Stand, keine Quellcode-Mounts, keine Datei-Watcher.
+#   docker compose up --build --detach
+#
+# Fuer die Entwicklung mit Hot Reload compose.dev.yaml verwenden.
 name: leistungsbilanz
 
 x-build: &build
   context: .
+  target: prod
   args:
-    # Baked into .next/routes-manifest.json by next build; see Dockerfile.
+    # Wird von next build in .next/routes-manifest.json eingebacken, siehe
+    # Dockerfile. Muss der API-Adresse in diesem Netz entsprechen.
     API_INTERNAL_URL: http://api:3000
 
-x-logging: &logging
-  driver: json-file
-  options:
-    max-size: "20m"
-    max-file: "10"
+x-service-defaults: &service-defaults
+  init: true
+  restart: unless-stopped
+  # Der API-Prozess beendet HTTP-Server und SQLite-Handle auf SIGTERM; die
+  # Frist gibt laufenden Requests Zeit, statt sie nach 10s in ein SIGKILL
+  # laufen zu lassen.
+  stop_grace_period: 20s
+  # Das Image laeuft als "node" (UID 1000); zusaetzliche Rechte braucht
+  # weder der API- noch der Web-Prozess.
+  security_opt:
+    - no-new-privileges:true
+  cap_drop:
+    - ALL
+  logging:
+    driver: json-file
+    options:
+      max-size: "20m"
+      max-file: "10"
 
 services:
   api:
+    <<: *service-defaults
     build: *build
+    # "exec" beim letzten Schritt: sonst bleibt sh der Vordergrundprozess und
+    # SIGTERM erreicht node nie.
     command:
       - sh
       - -c
-      - node scripts/run-migrations.js && node scripts/db-verify-circuit-schema.js && node dist/server/index.js
+      - node scripts/run-migrations.js && node scripts/db-verify-circuit-schema.js && exec node dist/server/index.js
     environment:
       NODE_ENV: production
       PORT: "3000"
       LOG_LEVEL: "${LOG_LEVEL:-info}"
-    init: true
-    restart: unless-stopped
-    logging: *logging
-    ports:
-      - "3000:3000"
+    # Nicht auf dem Host veroeffentlicht: die API hat keine Authentifizierung
+    # und wird ueber den Next.js-Rewrite im Web-Dienst erreicht.
+    expose:
+      - "3000"
+    # Harte Obergrenze statt unbegrenztem Wachstum. memswap_limit == mem_limit
+    # schaltet Swap fuer den Container ab, damit ein Leck den Container trifft
+    # und nicht den Host.
+    mem_limit: 512m
+    memswap_limit: 512m
     volumes:
       - ./data:/app/data
     healthcheck:
@@ -35,38 +61,43 @@ services:
         - CMD
         - node
         - -e
-        - fetch('http://localhost:3000/health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
+        - fetch('http://127.0.0.1:3000/health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
       interval: 30s
       timeout: 3s
       retries: 5
       start_period: 20s
 
   web:
+    <<: *service-defaults
     build: *build
     command:
       - node_modules/.bin/next
       - start
       - -p
       - "3001"
+      - --hostname
+      - 0.0.0.0
     environment:
       NODE_ENV: production
       API_INTERNAL_URL: http://api:3000
       NEXT_TELEMETRY_DISABLED: "1"
       LOG_LEVEL: "${LOG_LEVEL:-info}"
-    init: true
-    restart: unless-stopped
-    logging: *logging
     depends_on:
       api:
         condition: service_healthy
     ports:
       - "3001:3001"
+    mem_limit: 1g
+    memswap_limit: 1g
     healthcheck:
+      # /web-health statt /health: next.config.mjs leitet /health an die API
+      # weiter, und "/" wuerde wegen des Redirects auf /projects bei jeder
+      # Probe zwei Seiten rendern.
       test:
         - CMD
         - node
         - -e
-        - fetch('http://localhost:3001/web-health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
+        - fetch('http://127.0.0.1:3001/web-health').then(response=>{if(!response.ok)process.exit(1)}).catch(()=>process.exit(1))
       interval: 30s
       timeout: 3s
       retries: 5
diff --git a/docs/deployment.md b/docs/deployment.md
index 06289a7..909c2c0 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -6,7 +6,9 @@ Es gibt zwei Compose-Stacks.
 
 `compose.yaml` startet den gebauten Stand: `node dist/server/index.js` und
 `next start`, ohne Quellcode-Mounts und ohne Datei-Watcher. Das ist der Stack
-für einen Server.
+für einen Server. Beide Dienste laufen aus der `prod`-Stufe des Dockerfiles,
+also als Benutzer `node` statt als root, ohne devDependencies, mit
+`cap_drop: ALL`, `no-new-privileges` und harten Speichergrenzen.
 
 `compose.dev.yaml` startet `tsx watch` und `next dev` und bindet Quellcode vom
 Host ein. Die Watcher laufen im Polling-Modus, weil Bind-Mounts unter Windows
@@ -20,11 +22,37 @@ erreichbar gemacht werden.
 
 ## Topologie
 
-| Komponente | Port | Healthcheck | Persistenz |
-| --- | ---: | --- | --- |
-| Next.js Web | 3001 | `GET /web-health` | keine |
-| Express API | 3000 | `GET /health` | `./data:/app/data` |
-| SQLite | Datei | Integritäts-/FK-Prüfung via Backup und Skript | `data/leistungsbilanz.db` |
+| Komponente | Port | Auf dem Host | Healthcheck | Persistenz |
+| --- | ---: | --- | --- | --- |
+| Next.js Web | 3001 | `3001` (Server) / `127.0.0.1:3001` (Dev) | `GET /web-health` | keine |
+| Express API | 3000 | nicht veröffentlicht (Server) / `127.0.0.1:3000` (Dev) | `GET /health` | `./data:/app/data` |
+| SQLite | Datei | – | Integritäts-/FK-Prüfung via Backup und Skript | `data/leistungsbilanz.db` |
+
+Die Express-API wird im Server-Stack nicht mehr auf dem Host veröffentlicht
+(`expose` statt `ports`). Sie hat keine Authentifizierung; jeder, der sie
+erreicht, kann jedes Projekt lesen und ändern. Erreichbar ist sie nur aus dem
+Compose-Netz, praktisch also über den Next.js-Rewrite. Im Entwicklungs-Stack
+hängen beide Ports am Loopback und sind nicht aus dem LAN erreichbar.
+
+### Speichergrenzen
+
+Jeder Dienst hat ein `mem_limit`. Im Server-Stack ist zusätzlich
+`memswap_limit` auf denselben Wert gesetzt, womit Swap für den Container
+abgeschaltet ist: ein Speicherleck lässt dann den Container am OOM-Killer
+sterben und `restart: unless-stopped` greift, statt dass der Host in den Swap
+läuft. Aktuell 512 MB für die API und 1 GB für das Frontend. Der
+Entwicklungs-Stack bekommt 1 GB bzw. 2 GB und behält Swap, weil `next dev`
+Kompilierzustand hält und im Dauerbetrieb stetig wächst.
+
+### Rechte im Container
+
+Das Laufzeit-Image läuft als `node` (UID 1000). Ein `data/`-Verzeichnis, das
+ein früherer root-Container angelegt hat, ist dann nicht beschreibbar und
+braucht einmalig auf dem Host:
+
+```bash
+sudo chown -R 1000:1000 data
+```
 
 Verwendete Umgebungsvariablen:
 
@@ -83,11 +111,25 @@ einem unbekannten Zustand weiterzulaufen. Beide Dienste laufen deshalb mit
 `restart: unless-stopped`, damit Docker sie danach automatisch neu startet;
 ohne diese Policy würde ein Crash den Dienst dauerhaft unerreichbar lassen.
 
+## Herunterfahren
+
+`SIGTERM` und `SIGINT` schließen in der API den HTTP-Server und anschließend
+das SQLite-Handle und beenden den Prozess. Offene Keep-Alive-Verbindungen –
+vor allem die des Next.js-Servers – werden dabei über
+`server.closeIdleConnections()` freigegeben, laufende Requests dürfen zu Ende
+laufen. Vorher wurde das Signal nur geloggt, der Prozess lief weiter und
+Docker beendete ihn nach zehn Sekunden mit `SIGKILL`, mitten in einem
+möglichen Schreibvorgang. Greift der Abbau nicht innerhalb von 15 Sekunden,
+beendet sich der Prozess selbst mit Exit-Code 1; `stop_grace_period: 20s` in
+beiden Compose-Dateien liegt bewusst darüber.
+
+Die Startbefehle in `compose.yaml` enden mit `exec node …`. Ohne das `exec`
+bleibt `sh` der Vordergrundprozess, und `SIGTERM` erreicht Node nie.
+
 ## Voraussetzungen für ein späteres Produktionssetup
 
 Vor einer produktiven Installation werden mindestens benötigt:
 
-- reproduzierbare Produktionsimages und ein Next.js-Produktionsstartskript
 - TLS-Termination und Reverse Proxy
 - Authentifizierung, Autorisierung und Benutzer-/Rollenmodell
 - definierte Secrets- und Konfigurationsverwaltung
diff --git a/drizzle.config.js b/drizzle.config.js
deleted file mode 100644
index 004045a..0000000
--- a/drizzle.config.js
+++ /dev/null
@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const drizzle_kit_1 = require("drizzle-kit");
-exports.default = (0, drizzle_kit_1.defineConfig)({
-    dialect: "sqlite",
-    schema: "./src/db/schema/*.ts",
-    out: "./src/db/migrations",
-    dbCredentials: {
-        url: "./data/leistungsbilanz.db",
-    },
-});
diff --git a/index.html b/index.html
deleted file mode 100644
index dcb632f..0000000
--- a/index.html
+++ /dev/null
@@ -1,17 +0,0 @@
-<!doctype html>
-<html lang="de">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Leistungsbilanz API</title>
-    <link rel="stylesheet" href="./styles.css" />
-  </head>
-  <body>
-    <main class="info">
-      <h1>Leistungsbilanz Backend</h1>
-      <p>Der aktuelle Stand laeuft als TypeScript Node/SQLite API.</p>
-      <p>Serverstart: <code>npm run dev</code></p>
-      <p>Healthcheck: <code>GET /health</code></p>
-    </main>
-  </body>
-</html>
diff --git a/scripts/docker-start.sh b/scripts/docker-start.sh
deleted file mode 100644
index bf0d856..0000000
--- a/scripts/docker-start.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/sh
-set -e
-
-echo "Running migrations..."
-node scripts/run-migrations.js
-
-echo "Starting API server on :3000..."
-node dist/server/index.js &
-
-echo "Waiting for API..."
-until node -e "require('http').get('http://localhost:3000/health', r => process.exit(r.statusCode===200?0:1)).on('error',()=>process.exit(1))" 2>/dev/null; do
-  sleep 1
-done
-
-echo "Starting Next.js on :3001..."
-exec node_modules/.bin/next start -p 3001
diff --git a/src/db/client.ts b/src/db/client.ts
index 02cfc7e..4d0c97b 100644
--- a/src/db/client.ts
+++ b/src/db/client.ts
@@ -7,3 +7,10 @@ const defaultDatabaseContext = createDatabaseContext(
 
 export const db = defaultDatabaseContext.db;
 
+/**
+ * Schliesst das SQLite-Handle des Prozesses. Nur beim Herunterfahren
+ * aufrufen: danach schlaegt jede Abfrage ueber {@link db} fehl.
+ */
+export function closeDefaultDatabase(): void {
+  defaultDatabaseContext.close();
+}
diff --git a/src/server/index.ts b/src/server/index.ts
index 2f6ac5e..1f5c9b2 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -4,11 +4,13 @@ import { projectDeviceRouter } from "./routes/project-device.routes.js";
 import { projectRouter } from "./routes/project.routes.js";
 import { errorMiddleware } from "./middleware/error.middleware.js";
 import { createLogger, toErrorMeta } from "../shared/logging/logger.js";
+import { closeDefaultDatabase } from "../db/client.js";
 
 const logger = createLogger("api");
 const app = express();
 const port = Number(process.env.PORT || 3000);
 const heartbeatIntervalMs = 5 * 60 * 1000;
+const shutdownTimeoutMs = 15 * 1000;
 
 app.use(express.json({ limit: "25mb" }));
 
@@ -62,9 +64,6 @@ process.on("unhandledRejection", (reason) => {
   process.exit(1);
 });
 
-process.on("SIGTERM", () => logger.info("received SIGTERM"));
-process.on("SIGINT", () => logger.info("received SIGINT"));
-
 setInterval(() => {
   const memory = process.memoryUsage();
   logger.verbose("heartbeat", {
@@ -74,6 +73,40 @@ setInterval(() => {
   });
 }, heartbeatIntervalMs).unref();
 
-app.listen(port, () => {
+const server = app.listen(port, () => {
   logger.info("server started", { port });
 });
+
+let shuttingDown = false;
+
+function shutdown(signal: NodeJS.Signals): void {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  logger.info("shutting down", { signal });
+
+  // Falls ein Request haengt oder ein Socket nicht freigegeben wird, soll der
+  // Prozess trotzdem enden, statt auf das SIGKILL des Containers zu warten.
+  const forceExit = setTimeout(() => {
+    logger.error("shutdown timed out, forcing exit");
+    process.exit(1);
+  }, shutdownTimeoutMs);
+  forceExit.unref();
+
+  server.close((error) => {
+    if (error) logger.error("http server close failed", toErrorMeta(error));
+    try {
+      closeDefaultDatabase();
+    } catch (closeError) {
+      logger.error("database close failed", toErrorMeta(closeError));
+    }
+    logger.info("shutdown complete");
+    process.exit(error ? 1 : 0);
+  });
+
+  // Ohne das warten offene Keep-Alive-Verbindungen (z. B. die des
+  // Next.js-Servers) den Timeout oben aus; laufende Requests laufen weiter.
+  server.closeIdleConnections();
+}
+
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
diff --git a/styles.css b/styles.css
deleted file mode 100644
index 58c8f79..0000000
--- a/styles.css
+++ /dev/null
@@ -1,15 +0,0 @@
-body {
-  margin: 0;
-  font-family: Arial, sans-serif;
-  background: #f5f6f8;
-  color: #1f2937;
-}
-
-.info {
-  max-width: 760px;
-  margin: 40px auto;
-  background: #ffffff;
-  border: 1px solid #d1d5db;
-  border-radius: 8px;
-  padding: 24px;
-}

From e394ff93f4dae27dbadd939cb032659e244af9d7 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 10:12:03 +0200
Subject: [PATCH 06/60] Use icon buttons in the circuit list editor

- New IconButton/IconButtonSeparator component based on lucide-react.
- Toolbar: icon plus text, grouped into history, view and insert blocks.
- Group headers: compact icons for add circuit, upstream fuse (VS), group
  RCD (FI), edit, move up/down, renumber and delete; the header no longer
  overflows the grid.
- Rows: add device, delete circuit (trash) and delete device (ListX).
- The previous German labels remain accessible names and tooltips;
  destructive actions highlight in the danger color.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |   7 +
 src/app/globals.css                           |  65 ++-
 .../components/circuit-tree-editor.tsx        | 448 ++++++++++--------
 src/frontend/components/icon-button.tsx       |  59 +++
 4 files changed, 374 insertions(+), 205 deletions(-)
 create mode 100644 src/frontend/components/icon-button.tsx

diff --git a/AGENTS.md b/AGENTS.md
index f1a509d..0ec3242 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -167,6 +167,13 @@ Keyboard behavior:
 
 Support Ctrl+Plus and Ctrl+Shift+Plus for insertion.
 
+Editor actions use `IconButton` (`src/frontend/components/icon-button.tsx`,
+`lucide-react` icons). The German action text is always the accessible name and
+tooltip; the toolbar shows icon plus text, group headers and rows show icons
+only, separated into logical blocks with `IconButtonSeparator`. Destructive
+actions use `variant="danger"` (trash icon for circuits and groups, `ListX` for
+removing a device row).
+
 ## Bootstrap / Styling Rule
 
 Bootstrap may be used for the general application UI, such as navigation, page layout, buttons, forms, cards, alerts and modals.
diff --git a/src/app/globals.css b/src/app/globals.css
index 22da5df..ec92d91 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -487,6 +487,54 @@ a.kpi:hover {
   opacity: 0.45;
 }
 
+/* Icon buttons (circuit list editor toolbar, group and row actions) */
+.icon-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.35rem;
+  line-height: 1.2;
+  cursor: pointer;
+  transition: color 0.12s ease, border-color 0.12s ease, background-color 0.12s ease;
+}
+
+.icon-button svg {
+  flex: none;
+}
+
+.icon-button:disabled {
+  cursor: not-allowed;
+}
+
+.icon-button:not(:disabled):hover {
+  border-color: var(--accent-blue);
+  color: var(--accent-blue);
+}
+
+.icon-button-danger:not(:disabled):hover {
+  border-color: var(--color-danger);
+  background: var(--color-danger-bg);
+  color: var(--color-danger);
+}
+
+.editor-toolbar .project-device-drawer-toggle:not(:disabled):hover {
+  color: #fff;
+  filter: brightness(1.08);
+}
+
+.icon-button-text {
+  font-size: 0.7rem;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+}
+
+.icon-button-separator {
+  align-self: stretch;
+  width: 1px;
+  margin: 0.1rem 0.15rem;
+  background: var(--panel-border-strong);
+}
+
 .editor-toolbar .project-device-drawer-toggle {
   border-color: var(--accent-blue);
   background: var(--accent-blue);
@@ -1153,7 +1201,20 @@ a.kpi:hover {
 
 .tree-grid .section-actions {
   display: flex;
-  gap: 0.35rem;
+  align-items: center;
+  gap: 0.25rem;
+}
+
+.tree-grid .section-actions .icon-button,
+.tree-grid .action-cell .icon-button {
+  min-width: 1.75rem;
+  min-height: 1.6rem;
+  padding: 0.15rem 0.3rem;
+}
+
+.tree-grid .section-actions .icon-button:disabled,
+.tree-grid .action-cell .icon-button:disabled {
+  opacity: 0.35;
 }
 
 .tree-grid .section-actions button {
@@ -1265,7 +1326,7 @@ a.kpi:hover {
 
 .tree-grid .action-cell {
   display: flex;
-  gap: 0.3rem;
+  gap: 0.25rem;
 }
 
 .tree-grid .action-cell button {
diff --git a/src/frontend/components/circuit-tree-editor.tsx b/src/frontend/components/circuit-tree-editor.tsx
index 03aa38d..cc3d522 100644
--- a/src/frontend/components/circuit-tree-editor.tsx
+++ b/src/frontend/components/circuit-tree-editor.tsx
@@ -1,6 +1,28 @@
 "use client";
 
 import { DragEvent, KeyboardEvent, useEffect, useMemo, useRef, useState } from "react";
+import {
+  ArrowDown,
+  ArrowDown01,
+  ArrowUp,
+  Check,
+  Columns3,
+  FilterX,
+  FolderPlus,
+  ListOrdered,
+  ListPlus,
+  ListX,
+  PackagePlus,
+  PanelRightClose,
+  PanelRightOpen,
+  Pencil,
+  Plus,
+  Redo2,
+  ShieldPlus,
+  Trash2,
+  Undo2,
+} from "lucide-react";
+import { IconButton, IconButtonSeparator } from "./icon-button";
 import {
   inferProjectDeviceSectionKey,
   isProjectDevicePlacementValid,
@@ -2995,32 +3017,37 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     return (
       <div className="tree-editor-shell">
         <div className="editor-toolbar">
-          <button
-            type="button"
-            onClick={() => void handleUndo()}
+          <IconButton
             disabled={!historyState || historyState.undoDepth === 0 || historyBusy || isSaving}
-          >
-            Rückgängig
-          </button>
-          <button
-            type="button"
-            onClick={() => void handleRedo()}
+            icon={Undo2}
+            label="Rückgängig"
+            onClick={() => void handleUndo()}
+            showLabel
+          />
+          <IconButton
             disabled={!historyState || historyState.redoDepth === 0 || historyBusy || isSaving}
-          >
-            Wiederholen
-          </button>
-        <button
-          type="button"
-          onClick={clearSortAndFilters}
-          disabled={!Boolean(sortState) && !hasActiveFilters}
-        >
-          Sortierung/Filter zurücksetzen
-        </button>
-        <button type="button" onClick={toggleColumnSettingsMenu} aria-expanded={isColumnMenuOpen}>
-          Spalten
-        </button>
-        {renderColumnSettingsMenu("col-empty")}
-      </div>
+            icon={Redo2}
+            label="Wiederholen"
+            onClick={() => void handleRedo()}
+            showLabel
+          />
+          <IconButtonSeparator />
+          <IconButton
+            ariaExpanded={isColumnMenuOpen}
+            icon={Columns3}
+            label="Spalten"
+            onClick={toggleColumnSettingsMenu}
+            showLabel
+          />
+          <IconButton
+            disabled={!Boolean(sortState) && !hasActiveFilters}
+            icon={FilterX}
+            label="Sortierung/Filter zurücksetzen"
+            onClick={clearSortAndFilters}
+            showLabel
+          />
+          {renderColumnSettingsMenu("col-empty")}
+        </div>
         {renderActiveViewSummary()}
         {renderDistributionPowerSummary()}
         {error ? (
@@ -3140,82 +3167,90 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
         />
       ) : null}
       <div className="editor-toolbar">
-        <button
-          type="button"
-          onClick={() => void handleUndo()}
+        <IconButton
           disabled={!historyState || historyState.undoDepth === 0 || historyBusy || isSaving}
+          icon={Undo2}
+          label="Rückgängig"
+          onClick={() => void handleUndo()}
+          showLabel
           title={
             historyState?.undoDepth
               ? `${historyState.undoDepth} Änderung(en) können rückgängig gemacht werden.`
               : undefined
           }
-        >
-          Rückgängig
-        </button>
-        <button
-          type="button"
-          onClick={() => void handleRedo()}
+        />
+        <IconButton
           disabled={!historyState || historyState.redoDepth === 0 || historyBusy || isSaving}
+          icon={Redo2}
+          label="Wiederholen"
+          onClick={() => void handleRedo()}
+          showLabel
           title={
             historyState?.redoDepth
               ? `${historyState.redoDepth} Änderung(en) können wiederholt werden.`
               : undefined
           }
-        >
-          Wiederholen
-        </button>
+        />
+        <IconButtonSeparator />
         {isSortedView ? (
-          <button
-            type="button"
-            onClick={() => void handleApplySortedOrder()}
+          <IconButton
             disabled={hasActiveFilters || isSaving || historyBusy}
+            icon={Check}
+            label="Sortierung übernehmen"
+            onClick={() => void handleApplySortedOrder()}
+            showLabel
             title={hasActiveFilters ? "Vor dem Übernehmen der Sortierung zuerst die Filter zurücksetzen." : undefined}
-          >
-            Sortierung übernehmen
-          </button>
+          />
         ) : null}
-        <button type="button" onClick={toggleColumnSettingsMenu} aria-expanded={isColumnMenuOpen}>
-          Spalten
-        </button>
-        <button
-          aria-controls="project-device-drawer"
-          aria-expanded={isProjectDeviceDrawerOpen}
-          className="project-device-drawer-toggle"
-          type="button"
-          onClick={() =>
-            setIsProjectDeviceDrawerOpen((current) => !current)
-          }
-        >
-          {isProjectDeviceDrawerOpen
-            ? "Projektgeräte schließen"
-            : `Projektgeräte öffnen (${projectDevices.length})`}
-        </button>
-        <button
-          type="button"
+        <IconButton
+          ariaExpanded={isColumnMenuOpen}
+          icon={Columns3}
+          label="Spalten"
+          onClick={toggleColumnSettingsMenu}
+          showLabel
+        />
+        <IconButton
+          disabled={!isSortedView && !hasActiveFilters}
+          icon={FilterX}
+          label="Sortierung/Filter zurücksetzen"
+          onClick={clearSortAndFilters}
+          showLabel
+        />
+        <IconButtonSeparator />
+        <IconButton
           disabled={isSaving || historyBusy}
+          icon={FolderPlus}
+          label="Stromkreisgruppe hinzufügen"
+          onClick={() => setCircuitGroupEditorIntent({ kind: "create" })}
+          showLabel
+        />
+        <IconButton
+          disabled={isSaving || historyBusy}
+          icon={PackagePlus}
+          label="Verteilergerät hinzufügen"
           onClick={() =>
             setComponentEditorIntent({
               kind: "create",
               role: "auxiliary",
             })
           }
-        >
-          Verteilergerät hinzufügen
-        </button>
-        <button
-          type="button"
-          disabled={isSaving || historyBusy}
-          onClick={() => setCircuitGroupEditorIntent({ kind: "create" })}
-        >
-          Stromkreisgruppe hinzufügen
-        </button>
-        <button
-          type="button"
-          onClick={clearSortAndFilters}
-          disabled={!isSortedView && !hasActiveFilters}
-        >
-          Sortierung/Filter zurücksetzen
-        </button>
+          showLabel
+        />
+        <IconButton
+          ariaControls="project-device-drawer"
+          ariaExpanded={isProjectDeviceDrawerOpen}
+          className="project-device-drawer-toggle"
+          icon={isProjectDeviceDrawerOpen ? PanelRightClose : PanelRightOpen}
+          label={
+            isProjectDeviceDrawerOpen
+              ? "Projektgeräte schließen"
+              : `Projektgeräte öffnen (${projectDevices.length})`
+          }
+          onClick={() =>
+            setIsProjectDeviceDrawerOpen((current) => !current)
+          }
+          showLabel
+        />
         {renderColumnSettingsMenu("col")}
       </div>
       {renderActiveViewSummary()}
@@ -3717,105 +3752,21 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                           </span>
                         </div>
                         <div className="section-actions">
-                          <button
-                            type="button"
-                            tabIndex={-1}
-                            disabled={!section.category || !section.groupNumber}
-                            onClick={() =>
-                              setCircuitGroupEditorIntent({
-                                kind: "edit",
-                                section,
-                              })
-                            }
-                          >
-                            Gruppe bearbeiten
-                          </button>
-                          <button
-                            type="button"
-                            tabIndex={-1}
-                            disabled={
-                              isSaving ||
-                              !buildCircuitGroupReorderAssignments(
-                                data.sections,
-                                section.id,
-                                -1
-                              )
-                            }
-                            onClick={() =>
-                              void handleMoveCircuitGroup(section.id, -1)
-                            }
-                            title="Innerhalb derselben Kategorie nach oben verschieben"
-                          >
-                            Gruppe nach oben
-                          </button>
-                          <button
-                            type="button"
-                            tabIndex={-1}
-                            disabled={
-                              isSaving ||
-                              !buildCircuitGroupReorderAssignments(
-                                data.sections,
-                                section.id,
-                                1
-                              )
-                            }
-                            onClick={() =>
-                              void handleMoveCircuitGroup(section.id, 1)
-                            }
-                            title="Innerhalb derselben Kategorie nach unten verschieben"
-                          >
-                            Gruppe nach unten
-                          </button>
-                          <button
-                            type="button"
-                            tabIndex={-1}
-                            disabled={
-                              isSaving ||
-                              hasActiveSortOrFilter ||
-                              !section.category ||
-                              !canRenumberCircuitGroups(
-                                data.sections,
-                                section.category
-                              )
-                            }
-                            onClick={() =>
-                              section.category
-                                ? void handleRenumberCircuitGroups(
-                                    section.category
-                                  )
-                                : undefined
-                            }
-                            title={
-                              hasActiveSortOrFilter
-                                ? "Vor der Gruppenneunummerierung Sortierung und Filter zurücksetzen."
-                                : "Alle Gruppen dieser Kategorie gemäß ihrer Reihenfolge neu nummerieren"
-                            }
-                          >
-                            Gruppen-BMK neu nummerieren
-                          </button>
-                          <button
-                            type="button"
-                            tabIndex={-1}
+                          <IconButton
                             disabled={isSaving}
-                            title={
-                              canDeleteCircuitGroup(section)
-                                ? "Leere Stromkreisgruppe entfernen"
-                                : "Befüllte Stromkreisgruppe mit vollständiger Warnung entfernen"
-                            }
-                            onClick={() =>
-                              void handleDeleteCircuitGroup(section)
-                            }
-                          >
-                            Gruppe entfernen
-                          </button>
-                          <button
-                            type="button"
+                            icon={Plus}
+                            label="Stromkreis hinzufügen"
+                            onClick={() => void handleAddReserveCircuit(section.id)}
                             tabIndex={-1}
+                          />
+                          <IconButton
                             disabled={
                               hasUpstreamProtection ||
                               !section.category ||
                               !section.groupNumber
                             }
+                            icon={ShieldPlus}
+                            label="Vorsicherung hinzufügen"
                             onClick={() =>
                               setComponentEditorIntent({
                                 kind: "create",
@@ -3828,17 +3779,18 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                                   ),
                               })
                             }
-                          >
-                            Vorsicherung hinzufügen
-                          </button>
-                          <button
-                            type="button"
                             tabIndex={-1}
+                          >
+                            <span className="icon-button-text">VS</span>
+                          </IconButton>
+                          <IconButton
                             disabled={
                               hasGroupRcd ||
                               !section.category ||
                               !section.groupNumber
                             }
+                            icon={ShieldPlus}
+                            label="Gruppen-FI hinzufügen"
                             onClick={() =>
                               setComponentEditorIntent({
                                 kind: "create",
@@ -3851,26 +3803,112 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                                   ),
                               })
                             }
-                          >
-                            Gruppen-FI hinzufügen
-                          </button>
-                          <button
-                            type="button"
                             tabIndex={-1}
-                            disabled={isSaving}
-                            onClick={() => void handleAddReserveCircuit(section.id)}
                           >
-                            Stromkreis hinzufügen
-                          </button>
-                          <button
-                            type="button"
+                            <span className="icon-button-text">FI</span>
+                          </IconButton>
+                          <IconButtonSeparator />
+                          <IconButton
+                            disabled={!section.category || !section.groupNumber}
+                            icon={Pencil}
+                            label="Gruppe bearbeiten"
+                            onClick={() =>
+                              setCircuitGroupEditorIntent({
+                                kind: "edit",
+                                section,
+                              })
+                            }
                             tabIndex={-1}
+                          />
+                          <IconButton
+                            disabled={
+                              isSaving ||
+                              !buildCircuitGroupReorderAssignments(
+                                data.sections,
+                                section.id,
+                                -1
+                              )
+                            }
+                            icon={ArrowUp}
+                            label="Gruppe nach oben"
+                            onClick={() =>
+                              void handleMoveCircuitGroup(section.id, -1)
+                            }
+                            tabIndex={-1}
+                            title="Gruppe nach oben (innerhalb derselben Kategorie)"
+                          />
+                          <IconButton
+                            disabled={
+                              isSaving ||
+                              !buildCircuitGroupReorderAssignments(
+                                data.sections,
+                                section.id,
+                                1
+                              )
+                            }
+                            icon={ArrowDown}
+                            label="Gruppe nach unten"
+                            onClick={() =>
+                              void handleMoveCircuitGroup(section.id, 1)
+                            }
+                            tabIndex={-1}
+                            title="Gruppe nach unten (innerhalb derselben Kategorie)"
+                          />
+                          <IconButtonSeparator />
+                          <IconButton
                             disabled={hasActiveSortOrFilter || isSaving}
+                            icon={ArrowDown01}
+                            label="Bereich neu nummerieren"
                             onClick={() => void handleRenumberSection(section.id)}
-                            title={hasActiveSortOrFilter ? "Vor der Neunummerierung Sortierung und Filter zurücksetzen." : undefined}
-                          >
-                            Bereich neu nummerieren
-                          </button>
+                            tabIndex={-1}
+                            title={
+                              hasActiveSortOrFilter
+                                ? "Vor der Neunummerierung Sortierung und Filter zurücksetzen."
+                                : "Stromkreise dieser Gruppe neu nummerieren"
+                            }
+                          />
+                          <IconButton
+                            disabled={
+                              isSaving ||
+                              hasActiveSortOrFilter ||
+                              !section.category ||
+                              !canRenumberCircuitGroups(
+                                data.sections,
+                                section.category
+                              )
+                            }
+                            icon={ListOrdered}
+                            label="Gruppen-BMK neu nummerieren"
+                            onClick={() =>
+                              section.category
+                                ? void handleRenumberCircuitGroups(
+                                    section.category
+                                  )
+                                : undefined
+                            }
+                            tabIndex={-1}
+                            title={
+                              hasActiveSortOrFilter
+                                ? "Vor der Gruppenneunummerierung Sortierung und Filter zurücksetzen."
+                                : "Gruppen-BMK: alle Gruppen dieser Kategorie gemäß ihrer Reihenfolge neu nummerieren"
+                            }
+                          />
+                          <IconButtonSeparator />
+                          <IconButton
+                            disabled={isSaving}
+                            icon={Trash2}
+                            label="Gruppe entfernen"
+                            onClick={() =>
+                              void handleDeleteCircuitGroup(section)
+                            }
+                            tabIndex={-1}
+                            title={
+                              canDeleteCircuitGroup(section)
+                                ? "Leere Stromkreisgruppe entfernen"
+                                : "Befüllte Stromkreisgruppe entfernen (mit Warnung)"
+                            }
+                            variant="danger"
+                          />
                         </div>
                       </div>
                       {dropIntent?.kind === "new-circuit" && dropIntent.sectionId === section.id ? (
@@ -4467,28 +4505,32 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                   >
                     {row.circuit && row.rowType !== "deviceRow" ? (
                       <>
-                        <button
-                          type="button"
-                          tabIndex={-1}
+                        <IconButton
                           disabled={isSaving}
+                          icon={ListPlus}
+                          label="Manuelles Gerät hinzufügen"
                           onClick={() => void handleAddManualDevice(row.circuit!, row.sectionId)}
-                        >
-                          Manuelles Gerät hinzufügen
-                        </button>
-                        <button
-                          type="button"
                           tabIndex={-1}
+                        />
+                        <IconButton
                           disabled={isSaving}
+                          icon={Trash2}
+                          label="Stromkreis löschen"
                           onClick={() => void handleDeleteCircuit(row.circuit!.id)}
-                        >
-                          Stromkreis löschen
-                        </button>
+                          tabIndex={-1}
+                          variant="danger"
+                        />
                       </>
                     ) : null}
                     {row.device ? (
-                      <button type="button" tabIndex={-1} disabled={isSaving} onClick={() => void handleDeleteDevice(row.device!.id)}>
-                        Gerät löschen
-                      </button>
+                      <IconButton
+                        disabled={isSaving}
+                        icon={ListX}
+                        label="Gerät löschen"
+                        onClick={() => void handleDeleteDevice(row.device!.id)}
+                        tabIndex={-1}
+                        variant="danger"
+                      />
                     ) : null}
                     {dropIntent?.kind === "new-circuit" && row.rowType === "placeholder" && dropIntent.sectionId === row.sectionId ? (
                       <span className="drop-hint">
diff --git a/src/frontend/components/icon-button.tsx b/src/frontend/components/icon-button.tsx
new file mode 100644
index 0000000..605036d
--- /dev/null
+++ b/src/frontend/components/icon-button.tsx
@@ -0,0 +1,59 @@
+"use client";
+
+import type { LucideIcon } from "lucide-react";
+import type { ReactNode } from "react";
+
+/**
+ * Compact editor button with a lucide icon. `label` is always the accessible
+ * name; it is also the tooltip unless a more specific `title` is given.
+ * With `showLabel` the label (or `children`) is rendered next to the icon.
+ */
+export function IconButton({
+  icon: Icon,
+  label,
+  title,
+  onClick,
+  disabled,
+  variant = "default",
+  showLabel = false,
+  children,
+  className,
+  tabIndex,
+  ariaExpanded,
+  ariaControls,
+}: {
+  icon: LucideIcon;
+  label: string;
+  title?: string;
+  onClick: () => void;
+  disabled?: boolean;
+  variant?: "default" | "danger" | "primary";
+  showLabel?: boolean;
+  children?: ReactNode;
+  className?: string;
+  tabIndex?: number;
+  ariaExpanded?: boolean;
+  ariaControls?: string;
+}) {
+  return (
+    <button
+      aria-controls={ariaControls}
+      aria-expanded={ariaExpanded}
+      aria-label={showLabel ? undefined : label}
+      className={`icon-button icon-button-${variant}${className ? ` ${className}` : ""}`}
+      disabled={disabled}
+      onClick={onClick}
+      tabIndex={tabIndex}
+      title={title ?? label}
+      type="button"
+    >
+      <Icon aria-hidden="true" size={15} strokeWidth={2} />
+      {showLabel ? <span>{children ?? label}</span> : children}
+    </button>
+  );
+}
+
+/** Thin vertical divider between groups of icon buttons. */
+export function IconButtonSeparator() {
+  return <span aria-hidden="true" className="icon-button-separator" />;
+}

From d95f0bf5c0f05cb396f31f346760f80114b44c7d Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 10:30:15 +0200
Subject: [PATCH 07/60] Compact circuit list column headers with filter icons

- Replace the "Filtern" text buttons with a funnel icon next to the column
  label; an active filter is highlighted and shows its value count.
- Header labels no longer break inside words (e.g. "Bemerkung"); hyphens
  are non-breaking and a trailing unit moves to its own line, so all
  headers share one height.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |  4 ++
 src/app/globals.css                           | 53 +++++++++++++++----
 .../components/circuit-tree-editor.tsx        | 29 +++++++++-
 3 files changed, 74 insertions(+), 12 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 0ec3242..ab8393e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -173,6 +173,10 @@ tooltip; the toolbar shows icon plus text, group headers and rows show icons
 only, separated into logical blocks with `IconButtonSeparator`. Destructive
 actions use `variant="danger"` (trash icon for circuits and groups, `ListX` for
 removing a device row).
+Column headers show the label (click to sort) with a funnel icon for the
+value filter; an active filter is highlighted and shows its value count.
+Header labels break only between words and put a trailing unit such as
+`[kW]` on a second line.
 
 ## Bootstrap / Styling Rule
 
diff --git a/src/app/globals.css b/src/app/globals.css
index ec92d91..fe81d07 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -892,24 +892,37 @@ a.kpi:hover {
   white-space: nowrap;
 }
 
+/* One header row: label (sort) on the left, filter icon on the right. */
 .tree-grid .header-cell {
   display: flex;
-  flex-direction: column;
-  align-items: stretch;
+  flex-direction: row;
+  align-items: flex-start;
+  justify-content: space-between;
   gap: 0.2rem;
   min-width: 0;
 }
 
 .tree-grid .header-filter-btn {
-  display: block;
-  width: 100%;
-  border: 1px solid var(--panel-border-strong);
-  background: var(--panel-bg);
-  color: var(--text-strong);
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  gap: 0.15rem;
+  border: 1px solid transparent;
+  background: transparent;
+  color: var(--text-faint);
   border-radius: 3px;
-  font-size: 0.75rem;
-  padding: 0.15rem 0.35rem;
+  font-size: 0.7rem;
+  font-weight: 700;
+  line-height: 1;
+  padding: 0.15rem 0.2rem;
   white-space: nowrap;
+  cursor: pointer;
+}
+
+.tree-grid .header-filter-btn:hover,
+.tree-grid .header-filter-btn:focus-visible {
+  border-color: var(--panel-border-strong);
+  color: var(--text-strong);
 }
 
 .tree-grid .header-sort-btn {
@@ -927,7 +940,10 @@ a.kpi:hover {
   font-size: 0.78rem;
   font-weight: 600;
   line-height: 1.15;
-  overflow-wrap: anywhere;
+  /* Break only between words; never inside a word such as "Bemerkung". */
+  overflow-wrap: normal;
+  word-break: normal;
+  hyphens: manual;
   white-space: normal;
   text-align: left;
   cursor: pointer;
@@ -967,6 +983,18 @@ a.kpi:hover {
   font-size: 0.78rem;
 }
 
+.tree-grid .header-cell .header-sort-btn {
+  flex: 1 1 auto;
+  width: auto;
+  align-items: flex-start;
+}
+
+.tree-grid .header-unit {
+  display: block;
+  font-weight: 500;
+  color: var(--text-faint);
+}
+
 .tree-grid .header-sort-btn:hover span:first-child,
 .tree-grid .header-sort-btn:focus-visible span:first-child {
   text-decoration: underline;
@@ -983,6 +1011,11 @@ a.kpi:hover {
   background: var(--accent-blue-soft-bg);
 }
 
+.tree-grid .header-filter-count {
+  min-width: 0.7rem;
+  text-align: center;
+}
+
 .tree-grid .header-filter-menu {
   position: absolute;
   z-index: 7;
diff --git a/src/frontend/components/circuit-tree-editor.tsx b/src/frontend/components/circuit-tree-editor.tsx
index cc3d522..e559303 100644
--- a/src/frontend/components/circuit-tree-editor.tsx
+++ b/src/frontend/components/circuit-tree-editor.tsx
@@ -9,6 +9,7 @@ import {
   Columns3,
   FilterX,
   FolderPlus,
+  Funnel,
   ListOrdered,
   ListPlus,
   ListX,
@@ -268,6 +269,24 @@ function createValuesFromEditPatch(
   );
 }
 
+/**
+ * Header labels break only between words: hyphens become non-breaking and a
+ * trailing unit such as "[kW]" is always shown on its own second line, so
+ * header heights stay uniform.
+ */
+function renderColumnHeaderLabel(label: string) {
+  const match = /^(.*?)s*([[^]]+])$/.exec(label);
+  const name = (match ? match[1] : label).replace(/-/g, "‑");
+  return match ? (
+    <>
+      {name}
+      <span className="header-unit">{match[2]}</span>
+    </>
+  ) : (
+    name
+  );
+}
+
 export function CircuitTreeEditor(props: { projectId: string; circuitListId: string }) {
   /*
     Circuit-tree editor invariant overview:
@@ -3440,7 +3459,9 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                         });
                       }}
                     >
-                      <span>{column.label}</span>
+                      <span className="header-label">
+                        {renderColumnHeaderLabel(column.label)}
+                      </span>
                       {sortState?.key === column.key ? (
                         <span className="sort-indicator" aria-label={sortState.direction === "asc" ? "aufsteigend" : "absteigend"}>
                           {sortState.direction === "asc" ? "↑" : "↓"}
@@ -3451,6 +3472,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                       type="button"
                       className={`header-filter-btn ${(columnFilters[column.key]?.length ?? 0) > 0 ? "active" : ""}`}
                       onClick={() => toggleColumnFilterMenu(column.key)}
+                      aria-label={`${getFullColumnLabel(column)} filtern`}
                       aria-pressed={(columnFilters[column.key]?.length ?? 0) > 0}
                       title={
                         (columnFilters[column.key]?.length ?? 0) > 0
@@ -3458,7 +3480,10 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                           : `${getFullColumnLabel(column)} filtern`
                       }
                     >
-                      Filtern{(columnFilters[column.key]?.length ?? 0) > 0 ? ` (${columnFilters[column.key]?.length})` : ""}
+                      <Funnel aria-hidden="true" size={13} strokeWidth={2.2} />
+                      {(columnFilters[column.key]?.length ?? 0) > 0 ? (
+                        <span className="header-filter-count">{columnFilters[column.key]?.length}</span>
+                      ) : null}
                     </button>
                   </div>
                   {openFilterColumn === column.key ? (

From 4779e4a1a7aa6e326e288defb603559a9914c9ad Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Fri, 25 Sep 2026 19:31:04 +0200
Subject: [PATCH 08/60] Add print view, board info card and document logo
 upload

- Seitenansicht (/projects/:projectId/print): tabular cover page, board
  overview with supply structure and power sums, one plan per board with a
  repeating title block; PDF via the browser print dialog with named @page
  rules (A4 portrait cover, A4/A3 landscape plans, page x of y).
- Distribution-board info card (board number, location, fed-from, remark)
  in the board edit dialog, persisted through the additively extended
  distribution-board.update command (migration 0008, snapshot schema 6,
  legacy subtree commands normalized).
- Global document logo upload (PNG/JPEG/SVG, max 2 MB) outside project
  revisions and snapshots.
- fed-from stays free text; the overview hierarchy and cumulated sums are
  preliminary until the feed link is modeled.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |   55 +-
 docs/README.md                                |    2 +
 docs/circuit-list-editor-api.md               |   30 +-
 docs/circuit-list-editor-known-limitations.md |    8 +
 docs/current-architecture.md                  |    8 +-
 docs/print-view.md                            |   80 +
 scripts/db-verify-circuit-schema.js           |    5 +
 src/app/projects/[projectId]/page.tsx         |   38 +-
 src/app/projects/[projectId]/print/page.tsx   |  261 ++
 .../0007_board_info_and_document_logo.sql     |   12 +
 src/db/migrations/meta/0007_snapshot.json     | 2493 +++++++++++++++++
 src/db/migrations/meta/_journal.json          |    7 +
 ...rd-structure-project-command.repository.ts |    5 +
 ...oard-subtree-project-command.repository.ts |   18 +-
 .../document-branding.repository.ts           |   52 +
 .../project-snapshot.repository.ts            |    3 +-
 src/db/schema/distribution-boards.ts          |    4 +
 src/db/schema/document-branding-assets.ts     |   18 +
 ...istribution-board-project-command.model.ts |   40 +-
 ...stribution-board-subtree-snapshot.model.ts |   25 +-
 .../models/project-state-snapshot.model.ts    |   97 +-
 .../distribution-board-info-card.tsx          |  110 +
 src/frontend/print/print-document-model.ts    |  180 ++
 src/frontend/print/print-document.css         |  473 ++++
 src/frontend/print/print-document.tsx         |  612 ++++
 src/frontend/types.ts                         |   16 +-
 src/frontend/utils/api.ts                     |   32 +-
 .../composition/application-repositories.ts   |    2 +
 .../distribution-board.controller.ts          |   13 +
 .../document-branding.controller.ts           |   84 +
 src/server/index.ts                           |    2 +
 src/server/routes/document-branding.routes.ts |    9 +
 src/shared/constants/distribution-board.ts    |   41 +
 .../validation/document-branding.schemas.ts   |   25 +
 .../validation/project-structure.schemas.ts   |   21 +-
 ...ructure-project-command.repository.test.ts |  104 +
 ...subtree-project-command.repository.test.ts |   61 +
 tests/print-document-model.test.ts            |  176 ++
 tests/project-snapshot.repository.test.ts     |   61 +
 tests/project-state-snapshot.test.ts          |   47 +
 40 files changed, 5297 insertions(+), 33 deletions(-)
 create mode 100644 docs/print-view.md
 create mode 100644 src/app/projects/[projectId]/print/page.tsx
 create mode 100644 src/db/migrations/0007_board_info_and_document_logo.sql
 create mode 100644 src/db/migrations/meta/0007_snapshot.json
 create mode 100644 src/db/repositories/document-branding.repository.ts
 create mode 100644 src/db/schema/document-branding-assets.ts
 create mode 100644 src/frontend/components/distribution-board-info-card.tsx
 create mode 100644 src/frontend/print/print-document-model.ts
 create mode 100644 src/frontend/print/print-document.css
 create mode 100644 src/frontend/print/print-document.tsx
 create mode 100644 src/server/controllers/document-branding.controller.ts
 create mode 100644 src/server/routes/document-branding.routes.ts
 create mode 100644 src/shared/validation/document-branding.schemas.ts
 create mode 100644 tests/print-document-model.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index f1a509d..98c6a28 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -250,8 +250,12 @@ not change the project revision or undo/redo stacks. Restoring a server-stored
 snapshot verifies its checksum and the current-state hash, replaces supported
 project data atomically and records a new `restore` revision with a complete
 inverse command. Restore can therefore be undone and redone after a restart.
-Current snapshot schema version 5 additionally stores the manual quantity share
-of every CircuitDeviceRow. Version 4 snapshots are upgraded with
+Current snapshot schema version 6 additionally stores the distribution-board
+info fields `boardNumber`, `location`, `fedFrom` and `remark`; all older
+supported versions are upgraded with `null` for these fields. Stored named and
+automatic snapshots of every supported version (1 to 6) remain restorable;
+they are upgraded while parsing. Version 5 stores
+the manual quantity share of every CircuitDeviceRow. Version 4 snapshots are upgraded with
 `manualQuantity = quantity`; they already contain the complete confirmed
 external-model source, import batches, room mappings and objects. Version 3
 snapshots are upgraded with an empty external-model state; version 2 snapshots
@@ -265,7 +269,7 @@ project graph.
 Project-wide Revit CSV configuration uses
 `external-csv-configuration.update`. Its complete expected/target snapshot is
 persisted through the shared project-command transaction, so create, update,
-delete, Undo and Redo are revision-safe. Snapshot schema 5, restore and portable
+delete, Undo and Redo are revision-safe. Snapshot schema 5/6, restore and portable
 project duplication preserve the configuration; duplication remaps its internal
 id and project link.
 The project page exposes the Revit CSV modal. It edits the complete
@@ -279,7 +283,7 @@ immutable import batches with original bytes plus the classified cell matrix,
 normalized source-room mappings and external objects unique by
 `(sourceId, ifcGuid)`. Source values, planning values and overrides are separate.
 The general external-model repository is read-only; runtime writes belong only
-to typed command adapters. Snapshot/restore and portable project transfer schema version 5
+to typed command adapters. Snapshot/restore and portable project transfer schema version 5/6
 capture the complete external state and remap every internal UUID and link while
 preserving IFCGUIDs, source values, original bytes and the classified matrix.
 Import batches additionally store the monotonic project CSV configuration
@@ -422,6 +426,18 @@ the only supported circuit-protection source; no flat compatibility fields remai
 Distribution-board floor assignment and a project-enabled supply type use
 `distribution-board.update`; both values are snapshot/export fields and one
 persistent undo step.
+The same command (still schema version 1, additively extended) carries the
+board info-card fields `boardNumber`, `location`, `fedFrom` and `remark`
+(migration `0007`). They are nullable, trimmed planner values; the PUT route
+only includes submitted info fields in the command and its inverse. An empty
+board with info values is no longer an unchanged setup, so history deletion of
+it is rejected like a changed simultaneity factor. Populated-subtree commands
+stored before these fields existed are normalized to `null` values
+(`normalizeDistributionBoardSubtreeSnapshot`). `fedFrom` is deliberately free
+text: the logical link to the feeding board/circuit is an open design decision.
+These fields are intended to be prefillable from Revit parameters later, but
+only through the Phase 14 rules (preview, explicit confirmation, no silent
+overwrite).
 Floor and room setup uses persistent insert, update and delete commands with
 complete stable snapshots. Their inverses remove or restore only unchanged records and
 reject floors with assigned rooms/distribution boards or rooms referenced by
@@ -443,6 +459,32 @@ Required operations:
 - synchronization changes
 
 
+## Print View (Seitenansicht)
+
+- Route `src/app/projects/[projectId]/print/page.tsx`, opened from the project
+  page button "Seitenansicht". Read-only: it only uses existing GET endpoints.
+- Pure read model `src/frontend/print/print-document-model.ts` (tested in
+  `tests/print-document-model.test.ts`); React sheets in
+  `src/frontend/print/print-document.tsx`; styles scoped to `.print-view` in
+  `src/frontend/print/print-document.css`.
+- Pages: cover (A4 portrait, tabular), board overview with structure and
+  power sums, one plan per board (A4/A3 landscape) whose title block sits in
+  `<thead>` so it repeats on printed pages. PDF export uses the browser print
+  dialog; page size, margins and "Seite x von y" come from injected named
+  `@page` rules (`lb-portrait`, `lb-landscape`).
+- The board hierarchy and "Σ inkl. unterlagert" in the overview are
+  PRELIMINARY (text match of `fedFrom` against board number/name, plain sum,
+  no upstream simultaneity factor). Replace this once the feed link is modeled.
+- Colors/fonts are the provisional kbp CD (`--pd-*` variables) until the
+  official CD specification exists. Cover fields shown as "[ergänzen]"
+  (address, Leistungsphase, office staff) have no data model yet.
+- The document logo is global office branding: table
+  `document_branding_assets` (migration `0007`), endpoints
+  `GET|PUT|DELETE /api/document-branding/logo` and `GET /api/document-branding`.
+  It is intentionally outside project revisions, snapshots and transfer.
+  Uploads are PNG/JPEG/SVG up to 2 MB with a content signature check; the logo
+  is served with `nosniff` and a restrictive CSP.
+
 ## Revit / CSV External Model Work
 
 When explicitly working on Phase 14, use
@@ -538,6 +580,11 @@ Users must be able to override sizing suggestions.
 - full electrical sizing
 - multi-user/PostgreSQL operation
 - supported production deployment
+- logical feed link between distribution boards (`fedFrom` stays free text
+  until the project owner decides whether it references a board, a feeding
+  circuit or both) and the resulting hierarchical power summation
+- data model for the remaining print cover fields (address, Leistungsphase,
+  project lead/editor) and the official kbp CD values
 
 Do not implement these while working on an unrelated phase.
 
diff --git a/docs/README.md b/docs/README.md
index 69a2115..395b1ac 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -12,6 +12,8 @@ ausdrücklich getrennt und dürfen nicht als bereits implementiert verstanden we
   fachliches Modell und Grid-Aufteilung
 - [Editor-Interaktionen](circuit-list-editor-interactions.md) – Tastatur,
   Drag-and-drop, Sortierung, Filterung und Undo/Redo
+- [Seitenansicht und PDF-Export](print-view.md) – Deckblatt,
+  Verteilerübersicht, Verteilerpläne, Büro-Logo
 - [Editor-API](circuit-list-editor-api.md) – unterstützte Circuit-First-Endpunkte
 - [Bekannte Einschränkungen](circuit-list-editor-known-limitations.md) –
   bewusst noch nicht implementierte oder begrenzte Funktionen
diff --git a/docs/circuit-list-editor-api.md b/docs/circuit-list-editor-api.md
index 9ed9e0a..762a279 100644
--- a/docs/circuit-list-editor-api.md
+++ b/docs/circuit-list-editor-api.md
@@ -230,9 +230,13 @@ returns HTTP `409` with `PROJECT_HISTORY_OPERATION_UNAVAILABLE`.
   - stale revisions return `409 PROJECT_REVISION_CONFLICT`
 - `PUT /projects/:projectId/distribution-boards/:distributionBoardId`
   - body:
-    `{ "floorId": null, "supplyType": "AV", "expectedRevision": 13 }`
-  - executes `distribution-board.update`; floor and supply type are restored
-    together by persistent Undo/Redo
+    `{ "floorId": null, "supplyType": "AV", "simultaneityFactor": 1, "expectedRevision": 13 }`
+  - optional info-card fields: `boardNumber` (max. 50), `location`,
+    `fedFrom` (max. 200 each) and `remark` (max. 2000); strings are trimmed
+    and an empty string is stored as `null`
+  - executes `distribution-board.update`; all submitted values, including the
+    submitted info fields, are restored together by persistent Undo/Redo
+  - `fedFrom` is free text until the logical feed link is modeled
 - `POST /projects/:projectId/distribution-boards/:distributionBoardId/copy`
   - body: `{ "name": "UV-02 Kopie", "expectedRevision": 14 }`
   - duplicates the complete distribution-board subtree with new owning UUIDs
@@ -425,3 +429,23 @@ project device never triggers synchronization implicitly.
 Parser errors expose stable codes such as `header-not-found`,
 `ambiguous-header`, `invalid-ifc-guid` and `duplicate-ifc-guid`. The confirmed
 import uploads and parses the file again and verifies its hash.
+
+## Document Branding (print view)
+
+Office-wide branding for the print view. These endpoints are mounted at
+`/api/document-branding`, outside `/api/projects`, because the data is global
+and intentionally not part of project revisions, snapshots or transfer.
+
+- `GET /document-branding`
+  - returns `{ "logo": { "mimeType", "fileName", "sizeBytes", "updatedAtIso" } | null }`
+- `GET /document-branding/logo`
+  - returns the stored image bytes with its media type, or `404` without logo
+  - responses carry `X-Content-Type-Options: nosniff` and a restrictive
+    Content-Security-Policy so an SVG logo cannot execute scripts
+- `PUT /document-branding/logo`
+  - request: `{ "fileName": "logo.png", "mimeType": "image/png", "contentBase64": "..." }`
+  - accepted types: `image/png`, `image/jpeg`, `image/svg+xml`; at most 2 MB
+    after decoding; the content signature must match the declared type
+  - replaces an existing logo; returns the logo metadata
+- `DELETE /document-branding/logo`
+  - removes the logo; returns `204`
diff --git a/docs/circuit-list-editor-known-limitations.md b/docs/circuit-list-editor-known-limitations.md
index 4f7f660..bea8b87 100644
--- a/docs/circuit-list-editor-known-limitations.md
+++ b/docs/circuit-list-editor-known-limitations.md
@@ -27,3 +27,11 @@
 - Protection and cable values are planner-owned manual selections. The later
   sizing/warning engine does not yet validate them against load, length or
   voltage-drop rules.
+- Distribution-board `fedFrom` is free text. The print overview derives its
+  supply structure and "Σ inkl. unterlagert" only from exact text matches with
+  board numbers/names and adds values without an upstream simultaneity factor
+  (see `docs/print-view.md`).
+- The print view cover page shows placeholders for address, Leistungsphase and
+  office staff, and uses a provisional kbp corporate design. On screen, long
+  board plans are not split into pages; pagination happens in the browser print
+  dialog.
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 92efc98..cbea92f 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -416,7 +416,13 @@ wieder her.
 verteilerweiten Gleichzeitigkeitsfaktor gemeinsam und stellt alle Werte über
 dauerhaftes Undo/Redo wieder her. Der Faktor liegt zwischen `0` und `1` und
 ist für bestehende sowie neu angelegte Verteilungen standardmäßig `1`.
-Snapshot-Schema 5 enthält zusätzlich den manuellen Mengenanteil jeder
+Derselbe Befehl versioniert die Felder der Verteiler-Infokarte
+(`boardNumber`, `location`, `fedFrom`, `remark`, Migration `0007`). Die
+Infokarte liegt im Bearbeiten-Dialog der Verteilung; die Werte sind lokale
+Planungswerte und sollen später über den Revit-Abgleich nur nach Vorschau und
+ausdrücklicher Bestätigung vorbelegt werden. `fedFrom` ist vorerst Freitext.
+Snapshot-Schema 6 enthält diese Felder; ältere Versionen werden mit `null`
+hochgestuft. Snapshot-Schema 5 enthält zusätzlich den manuellen Mengenanteil jeder
 Gerätezeile. Version 4 wird mit `manualQuantity = quantity` hochgestuft und
 enthält bereits den vollständigen externen Modellzustand
 aus Quelle, Batches, Raum-Mappings und Objekten. Es enthält außerdem die
diff --git a/docs/print-view.md b/docs/print-view.md
new file mode 100644
index 0000000..3de19a5
--- /dev/null
+++ b/docs/print-view.md
@@ -0,0 +1,80 @@
+# Seitenansicht und PDF-Export
+
+Stand: erste Ausbaustufe (Beispiel zur Abstimmung). Die Seitenansicht ist
+rein lesend und verändert keine Projektdaten.
+
+## Aufruf
+
+- Projektseite → Button **Seitenansicht** öffnet
+  `/projects/:projectId/print` in einem neuen Tab.
+- **Als PDF speichern / Drucken** nutzt den Druckdialog des Browsers
+  (Ziel „Als PDF speichern“). Der Dokumenttitel `Leistungsbilanz – <Projekt>`
+  wird als Dateiname vorgeschlagen.
+- **Planformat** schaltet die Verteilerpläne zwischen A4 quer und A3 quer um.
+  Deckblatt bleibt A4 hoch.
+- **Logo hinterlegen / ersetzen / entfernen** verwaltet das Büro-Logo.
+
+## Seiten
+
+1. **Deckblatt (A4 hoch)** – tabellarisch: Projekt, Planverfasser, Dokument,
+   Planstände (aus benannten Sicherungspunkten) und Inhalt. Angaben ohne
+   Datenmodell erscheinen als orangefarbenes „[ergänzen]“ (Anschrift,
+   Leistungsphase, Projektleitung, Bearbeitung).
+2. **Verteilerübersicht (quer)** – Versorgungsstruktur und Tabelle je
+   Verteiler mit Stromkreisanzahl, P<sub>inst</sub> (Anzahl × Leistung je
+   Stück), P<sub>Geräte</sub> (mit Geräte-GZF), Verteiler-GZF,
+   P<sub>gl</sub>, I<sub>B</sub> und „Σ inkl. unterlagert“.
+3. **Verteilerpläne (quer, je Verteiler)** – Titelleiste mit
+   Verteilernummer, Bezeichnung, Örtlichkeit, Netzart, „Gespeist von“ und
+   P<sub>gl</sub>; darunter Kopfkomponenten, Gruppen, Stromkreise
+   (mehrzeilige mit Sammelzeile und eingerückten Gerätezeilen),
+   Gruppensummen und Verteilersumme. Fehlende Kabelangaben sind als „offen“
+   markiert. Die Titelleiste steht im Tabellenkopf und wiederholt sich beim
+   Drucken auf Folgeseiten.
+
+Seitenformat, Ränder und „Seite x von y“ kommen beim Drucken aus benannten
+`@page`-Regeln (`lb-portrait`, `lb-landscape`), die die Seite zur Laufzeit
+einfügt. Die Bildschirmansicht zeigt Blätter in Papiergröße; die exakte
+Seitenaufteilung langer Verteilerpläne entsteht erst beim Drucken.
+
+## Vorläufige Punkte
+
+- **Einspeisung / Hierarchie:** `fedFrom` ist Freitext. Die Übersicht ordnet
+  einen Verteiler nur dann unter, wenn der Text genau der Nummer oder
+  Bezeichnung eines anderen Verteilers entspricht; „Σ inkl. unterlagert“ ist
+  eine einfache Summe ohne übergeordneten GZF. Die fachliche Verknüpfung
+  (Verteiler und/oder speisender Stromkreis) und die Summierungslogik sind
+  offen.
+- **I<sub>B</sub>** ist ein symmetrischer Drehstromwert
+  S / (√3 · U<sub>3~</sub>) mit S aus P / cos φ je Gerätezeile
+  (fehlendes cos φ = 1) und Verteiler-GZF.
+- **Corporate Design:** Farben (`--pd-*` in
+  `src/frontend/print/print-document.css`) und Schrift (Arial) sind aus Logo
+  und kbp-Präsentationsmaterial abgeleitet und werden durch die offizielle
+  CD-Vorgabe ersetzt. Der Büroname steht vorläufig als Konstante
+  `printOfficeName` in `src/frontend/print/print-document.tsx`.
+
+## Logo
+
+- Globale Büro-Einstellung, nicht Teil von Projekten, Revisionen, Snapshots
+  oder Projektexport.
+- Tabelle `document_branding_assets` (Migration `0007`).
+- `GET /api/document-branding` → `{ logo: { mimeType, fileName, sizeBytes, updatedAtIso } | null }`
+- `GET /api/document-branding/logo` → Bilddaten (`404` ohne Logo), mit
+  `X-Content-Type-Options: nosniff` und restriktiver CSP.
+- `PUT /api/document-branding/logo` mit
+  `{ "fileName", "mimeType": "image/png" | "image/jpeg" | "image/svg+xml", "contentBase64" }`,
+  maximal 2 MB; der Dateiinhalt wird gegen das Format geprüft.
+- `DELETE /api/document-branding/logo` → `204`.
+
+## Code
+
+- `src/app/projects/[projectId]/print/page.tsx` – Datenladen, Werkzeugleiste,
+  `@page`-Regeln
+- `src/frontend/print/print-document-model.ts` – reine Berechnungen und
+  Formatierung (Tests: `tests/print-document-model.test.ts`)
+- `src/frontend/print/print-document.tsx` – Blätter und Tabellen
+- `src/frontend/print/print-document.css` – Layout, auf `.print-view`
+  begrenzt
+- `src/frontend/components/distribution-board-info-card.tsx` – Infokarte im
+  Bearbeiten-Dialog der Verteilung
diff --git a/scripts/db-verify-circuit-schema.js b/scripts/db-verify-circuit-schema.js
index 8680f59..558178e 100644
--- a/scripts/db-verify-circuit-schema.js
+++ b/scripts/db-verify-circuit-schema.js
@@ -12,6 +12,7 @@ const requiredTables = [
   "circuit_protection_devices",
   "distribution_board_components",
   "distribution_board_component_protection_devices",
+  "document_branding_assets",
 ];
 
 const tablePlaceholders = requiredTables.map(() => "?").join(", ");
@@ -98,6 +99,10 @@ const requiredDistributionBoardColumns = [
   "floor_id",
   "supply_type",
   "simultaneity_factor",
+  "board_number",
+  "location",
+  "fed_from",
+  "remark",
 ];
 const distributionBoardColumns = new Set(
   db
diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index fa342ea..73f9460 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -54,6 +54,12 @@ import {
   type DistributionBoardSupplyType,
 } from "../../../shared/constants/distribution-board";
 import { ProjectVersionHistory } from "../../../frontend/components/project-version-history";
+import {
+  DistributionBoardInfoCard,
+  fromDistributionBoardInfoDraft,
+  toDistributionBoardInfoDraft,
+  type DistributionBoardInfoDraft,
+} from "../../../frontend/components/distribution-board-info-card";
 import {
   ProjectSettingsModal,
   type ProjectSettingsInput,
@@ -101,6 +107,15 @@ export default function ProjectDetailPage() {
     setEditingBoardSimultaneityFactor,
   ] = useState("1");
   const [editingBoardCopyName, setEditingBoardCopyName] = useState("");
+  const [editingBoardInfo, setEditingBoardInfo] =
+    useState<DistributionBoardInfoDraft>(
+      toDistributionBoardInfoDraft({
+        boardNumber: null,
+        location: null,
+        fedFrom: null,
+        remark: null,
+      })
+    );
   const [floorName, setFloorName] = useState("");
   const [editingFloor, setEditingFloor] = useState<FloorDto | null>(null);
   const [editingRoom, setEditingRoom] = useState<RoomDto | null>(null);
@@ -424,6 +439,7 @@ export default function ProjectDetailPage() {
       String(board.simultaneityFactor)
     );
     setEditingBoardCopyName(`${board.name} Kopie`);
+    setEditingBoardInfo(toDistributionBoardInfoDraft(board));
   }
 
   function openBoardCreator() {
@@ -459,6 +475,7 @@ export default function ProjectDetailPage() {
           floorId: editingBoardFloorId || null,
           supplyType: editingBoardSupplyType,
           simultaneityFactor,
+          ...fromDistributionBoardInfoDraft(editingBoardInfo),
         },
         project.currentRevision
       );
@@ -849,6 +866,13 @@ export default function ProjectDetailPage() {
           </p>
         </div>
         <div className="d-flex gap-2">
+          <Link
+            className="btn btn-primary"
+            href={`/projects/${projectId}/print`}
+            target="_blank"
+          >
+            Seitenansicht
+          </Link>
           <button
             className="btn btn-outline-primary"
             disabled={!project}
@@ -922,7 +946,9 @@ export default function ProjectDetailPage() {
               <table className="table table-hover align-middle mb-0">
                 <thead>
                   <tr>
+                    <th>Nr.</th>
                     <th>Verteilung</th>
+                    <th>Örtlichkeit</th>
                     <th>Etage</th>
                     <th>Netzart</th>
                     <th>GZF</th>
@@ -934,7 +960,11 @@ export default function ProjectDetailPage() {
                     const circuitList = circuitListByBoardId.get(board.id);
                     return (
                       <tr key={board.id}>
+                        <td className="fw-semibold">
+                          {board.boardNumber ?? "–"}
+                        </td>
                         <td>{board.name}</td>
+                        <td>{board.location ?? "–"}</td>
                         <td>
                           {board.floorId
                             ? floorById.get(board.floorId)?.name ?? "Unbekannt"
@@ -985,7 +1015,7 @@ export default function ProjectDetailPage() {
                   })}
                   {!boards.length ? (
                     <tr>
-                      <td colSpan={5} className="text-center text-secondary py-4">
+                      <td colSpan={7} className="text-center text-secondary py-4">
                         Noch keine Verteilungen vorhanden.
                       </td>
                     </tr>
@@ -1464,6 +1494,12 @@ export default function ProjectDetailPage() {
               </div>
             </div>
           </div>
+          <div className="mt-4">
+            <DistributionBoardInfoCard
+              draft={editingBoardInfo}
+              onChange={setEditingBoardInfo}
+            />
+          </div>
           <hr className="my-4" />
           <section aria-labelledby="copy-distribution-board-heading">
             <h3
diff --git a/src/app/projects/[projectId]/print/page.tsx b/src/app/projects/[projectId]/print/page.tsx
new file mode 100644
index 0000000..91eb433
--- /dev/null
+++ b/src/app/projects/[projectId]/print/page.tsx
@@ -0,0 +1,261 @@
+"use client";
+
+import Link from "next/link";
+import { useParams } from "next/navigation";
+import { ChangeEvent, useEffect, useMemo, useState } from "react";
+import "../../../../frontend/print/print-document.css";
+import {
+  deleteDocumentLogo,
+  documentLogoUrl,
+  getCircuitTree,
+  getDocumentBranding,
+  getProject,
+  listCircuitLists,
+  listDistributionBoards,
+  listFloors,
+  listProjectSnapshots,
+  uploadDocumentLogo,
+} from "../../../../frontend/utils/api";
+import type {
+  DocumentLogoMetadataDto,
+  ProjectDto,
+  ProjectSnapshotMetadataDto,
+} from "../../../../frontend/types";
+import { PrintDocument } from "../../../../frontend/print/print-document";
+import {
+  buildPreliminaryBoardHierarchy,
+  summarizePrintBoard,
+  type PrintBoardSummary,
+} from "../../../../frontend/print/print-document-model";
+import {
+  documentLogoMimeTypes,
+  maxDocumentLogoBytes,
+} from "../../../../shared/validation/document-branding.schemas";
+
+type PlanFormat = "a4" | "a3";
+
+interface PrintData {
+  project: ProjectDto;
+  summaries: PrintBoardSummary[];
+  namedSnapshots: ProjectSnapshotMetadataDto[];
+}
+
+const boardSortCollator = new Intl.Collator("de", { numeric: true });
+
+function cssString(value: string) {
+  return JSON.stringify(value.replace(/[<>\r\n]/g, " "));
+}
+
+function pageRules(project: ProjectDto, stand: string, format: PlanFormat) {
+  const marginBoxes = `
+    @bottom-left { content: ${cssString(`${project.name} · Leistungsbilanz`)}; font: 7.5pt Arial, sans-serif; color: #6b7280; }
+    @bottom-center { content: ${cssString(`Stand ${stand} · Datenstand Rev. ${project.currentRevision}`)}; font: 7.5pt Arial, sans-serif; color: #6b7280; }
+    @bottom-right { content: "Seite " counter(page) " von " counter(pages); font: 7.5pt Arial, sans-serif; color: #6b7280; }`;
+  return `
+    @page lb-portrait { size: A4 portrait; margin: 14mm 16mm 16mm; ${marginBoxes} }
+    @page lb-landscape { size: ${format === "a3" ? "A3" : "A4"} landscape; margin: 10mm 10mm 13mm; ${marginBoxes} }`;
+}
+
+export default function ProjectPrintPage() {
+  const params = useParams<{ projectId: string }>();
+  const projectId = params.projectId;
+  const [data, setData] = useState<PrintData | null>(null);
+  const [logo, setLogo] = useState<DocumentLogoMetadataDto | null>(null);
+  const [format, setFormat] = useState<PlanFormat>("a4");
+  const [error, setError] = useState<string | null>(null);
+  const [message, setMessage] = useState<string | null>(null);
+  const [isBusy, setIsBusy] = useState(false);
+  const [printedAt] = useState(() => new Date());
+
+  useEffect(() => {
+    if (!projectId) {
+      return;
+    }
+    let cancelled = false;
+    async function load() {
+      const [project, boards, circuitLists, floors, snapshots, branding] =
+        await Promise.all([
+          getProject(projectId),
+          listDistributionBoards(projectId),
+          listCircuitLists(projectId),
+          listFloors(projectId),
+          listProjectSnapshots(projectId),
+          getDocumentBranding(),
+        ]);
+      const floorNameById = new Map(floors.map((floor) => [floor.id, floor.name]));
+      const summaries = await Promise.all(
+        [...boards]
+          .sort(
+            (left, right) =>
+              boardSortCollator.compare(left.boardNumber ?? "", right.boardNumber ?? "") ||
+              boardSortCollator.compare(left.name, right.name)
+          )
+          .flatMap((board) => {
+            const circuitList = circuitLists.find(
+              (list) => list.distributionBoardId === board.id
+            );
+            return circuitList ? [{ board, circuitList }] : [];
+          })
+          .map(async ({ board, circuitList }) =>
+            summarizePrintBoard({
+              board,
+              circuitListId: circuitList.id,
+              tree: await getCircuitTree(projectId, circuitList.id),
+              floorName: board.floorId ? floorNameById.get(board.floorId) ?? null : null,
+            })
+          )
+      );
+      if (cancelled) {
+        return;
+      }
+      setData({
+        project,
+        summaries,
+        namedSnapshots: snapshots
+          .filter((snapshot) => snapshot.kind === "named")
+          .sort((left, right) => left.createdAtIso.localeCompare(right.createdAtIso)),
+      });
+      setLogo(branding.logo);
+      document.title = `Leistungsbilanz – ${project.name}`;
+    }
+    load().catch((err: unknown) => {
+      if (!cancelled) {
+        setError(err instanceof Error ? err.message : "Die Seitenansicht konnte nicht geladen werden.");
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [projectId]);
+
+  const entries = useMemo(
+    () => (data ? buildPreliminaryBoardHierarchy(data.summaries) : []),
+    [data]
+  );
+  const stand = useMemo(
+    () =>
+      new Intl.DateTimeFormat("de-DE", {
+        day: "2-digit",
+        month: "2-digit",
+        year: "numeric",
+      }).format(printedAt),
+    [printedAt]
+  );
+  const logoSrc = logo
+    ? `${documentLogoUrl}?v=${encodeURIComponent(logo.updatedAtIso)}`
+    : null;
+
+  async function handleLogoUpload(event: ChangeEvent<HTMLInputElement>) {
+    const file = event.target.files?.[0];
+    event.target.value = "";
+    if (!file) {
+      return;
+    }
+    if (!(documentLogoMimeTypes as readonly string[]).includes(file.type)) {
+      setError("Bitte ein PNG-, JPG- oder SVG-Bild wählen.");
+      return;
+    }
+    if (file.size > maxDocumentLogoBytes) {
+      setError("Das Logo darf höchstens 2 MB groß sein.");
+      return;
+    }
+    setIsBusy(true);
+    setError(null);
+    try {
+      const result = await uploadDocumentLogo(file);
+      setLogo(result.logo);
+      setMessage("Logo hinterlegt. Es gilt für alle Projekte.");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Das Logo konnte nicht gespeichert werden.");
+    } finally {
+      setIsBusy(false);
+    }
+  }
+
+  async function handleLogoDelete() {
+    if (!window.confirm("Hinterlegtes Logo für alle Projekte entfernen?")) {
+      return;
+    }
+    setIsBusy(true);
+    setError(null);
+    try {
+      await deleteDocumentLogo();
+      setLogo(null);
+      setMessage("Logo entfernt.");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Das Logo konnte nicht entfernt werden.");
+    } finally {
+      setIsBusy(false);
+    }
+  }
+
+  return (
+    // Paper output: always light, independent of the app's dark mode.
+    <div
+      className={format === "a3" ? "print-view pd-a3" : "print-view"}
+      data-bs-theme="light"
+    >
+      {data ? <style>{pageRules(data.project, stand, format)}</style> : null}
+      <div className="pd-toolbar">
+        <span className="pd-toolbar-title">
+          Seitenansicht{data ? ` · ${data.project.name}` : ""}
+        </span>
+        {message ? <span className="pd-toolbar-message">{message}</span> : null}
+        {error ? <span className="pd-toolbar-error">{error}</span> : null}
+        <label className="d-flex align-items-center gap-2">
+          Planformat
+          <select
+            className="form-select form-select-sm w-auto"
+            onChange={(event) => setFormat(event.target.value as PlanFormat)}
+            value={format}
+          >
+            <option value="a4">A4 quer</option>
+            <option value="a3">A3 quer</option>
+          </select>
+        </label>
+        <label className={`btn btn-sm btn-outline-primary mb-0${isBusy ? " disabled" : ""}`}>
+          {logo ? "Logo ersetzen" : "Logo hinterlegen"}
+          <input
+            accept={documentLogoMimeTypes.join(",")}
+            disabled={isBusy}
+            hidden
+            onChange={(event) => void handleLogoUpload(event)}
+            type="file"
+          />
+        </label>
+        {logo ? (
+          <button
+            className="btn btn-sm btn-outline-secondary"
+            disabled={isBusy}
+            onClick={() => void handleLogoDelete()}
+            type="button"
+          >
+            Logo entfernen
+          </button>
+        ) : null}
+        <button
+          className="btn btn-sm btn-primary"
+          disabled={!data}
+          onClick={() => window.print()}
+          type="button"
+        >
+          Als PDF speichern / Drucken
+        </button>
+        <Link className="btn btn-sm btn-outline-secondary" href={`/projects/${projectId}`}>
+          Zum Projekt
+        </Link>
+      </div>
+      {data ? (
+        <PrintDocument
+          entries={entries}
+          logoSrc={logoSrc}
+          namedSnapshots={data.namedSnapshots}
+          printedAt={printedAt}
+          project={data.project}
+        />
+      ) : error ? null : (
+        <p className="p-4 text-secondary">Seitenansicht wird geladen …</p>
+      )}
+    </div>
+  );
+}
diff --git a/src/db/migrations/0007_board_info_and_document_logo.sql b/src/db/migrations/0007_board_info_and_document_logo.sql
new file mode 100644
index 0000000..5f27040
--- /dev/null
+++ b/src/db/migrations/0007_board_info_and_document_logo.sql
@@ -0,0 +1,12 @@
+CREATE TABLE `document_branding_assets` (
+	`key` text PRIMARY KEY NOT NULL,
+	`mime_type` text NOT NULL,
+	`file_name` text,
+	`data` blob NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE `distribution_boards` ADD `board_number` text;--> statement-breakpoint
+ALTER TABLE `distribution_boards` ADD `location` text;--> statement-breakpoint
+ALTER TABLE `distribution_boards` ADD `fed_from` text;--> statement-breakpoint
+ALTER TABLE `distribution_boards` ADD `remark` text;
\ No newline at end of file
diff --git a/src/db/migrations/meta/0007_snapshot.json b/src/db/migrations/meta/0007_snapshot.json
new file mode 100644
index 0000000..d0c04de
--- /dev/null
+++ b/src/db/migrations/meta/0007_snapshot.json
@@ -0,0 +1,2493 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "4db6e93a-3070-459a-94ef-587fd4929411",
+  "prevId": "b25e1a40-c400-4848-bc24-a04bda7a8209",
+  "tables": {
+    "circuit_device_rows": {
+      "name": "circuit_device_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "level": {
+          "name": "level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number_snapshot": {
+          "name": "room_number_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_name_snapshot": {
+          "name": "room_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "manual_quantity": {
+          "name": "manual_quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_device_rows_circuit_id_idx": {
+          "name": "circuit_device_rows_circuit_id_idx",
+          "columns": [
+            "circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "circuit_device_rows_circuit_id_circuits_id_fk": {
+          "name": "circuit_device_rows_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_linked_project_device_id_project_devices_id_fk": {
+          "name": "circuit_device_rows_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_room_id_rooms_id_fk": {
+          "name": "circuit_device_rows_room_id_rooms_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_list_equipment_identifiers": {
+      "name": "circuit_list_equipment_identifiers",
+      "columns": {
+        "owner_type": {
+          "name": "owner_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_list_equipment_identifiers_owner_unique": {
+          "name": "circuit_list_equipment_identifiers_owner_unique",
+          "columns": [
+            "owner_type",
+            "owner_id"
+          ],
+          "isUnique": true
+        },
+        "circuit_list_equipment_identifiers_list_identifier_unique": {
+          "name": "circuit_list_equipment_identifiers_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_list_equipment_identifiers",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_lists": {
+      "name": "circuit_lists",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_lists_distribution_board_id_unique": {
+          "name": "circuit_lists_distribution_board_id_unique",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_lists_project_id_projects_id_fk": {
+          "name": "circuit_lists_project_id_projects_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_lists_distribution_board_id_distribution_boards_id_fk": {
+          "name": "circuit_lists_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_protection_devices": {
+      "name": "circuit_protection_devices",
+      "columns": {
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "circuit_protection_devices_circuit_id_circuits_id_fk": {
+          "name": "circuit_protection_devices_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_protection_devices",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_sections": {
+      "name": "circuit_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "group_number": {
+          "name": "group_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_sections_list_key_unique": {
+          "name": "circuit_sections_list_key_unique",
+          "columns": [
+            "circuit_list_id",
+            "key"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_prefix_unique": {
+          "name": "circuit_sections_list_prefix_unique",
+          "columns": [
+            "circuit_list_id",
+            "prefix"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_category_group_unique": {
+          "name": "circuit_sections_list_category_group_unique",
+          "columns": [
+            "circuit_list_id",
+            "category",
+            "group_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_sections_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_sections_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_sections",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuits": {
+      "name": "circuits",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "cable_type": {
+          "name": "cable_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_cross_section": {
+          "name": "cable_cross_section",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_length": {
+          "name": "cable_length",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_assignment": {
+          "name": "rcd_assignment",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_designation": {
+          "name": "terminal_designation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage": {
+          "name": "voltage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "control_requirement": {
+          "name": "control_requirement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_reserve": {
+          "name": "is_reserve",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuits_section_id_idx": {
+          "name": "circuits_section_id_idx",
+          "columns": [
+            "section_id"
+          ],
+          "isUnique": false
+        },
+        "circuits_list_equipment_identifier_unique": {
+          "name": "circuits_list_equipment_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuits_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuits_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuits_section_id_circuit_sections_id_fk": {
+          "name": "circuits_section_id_circuit_sections_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_component_protection_devices": {
+      "name": "distribution_board_component_protection_devices",
+      "columns": {
+        "component_id": {
+          "name": "component_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk": {
+          "name": "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk",
+          "tableFrom": "distribution_board_component_protection_devices",
+          "tableTo": "distribution_board_components",
+          "columnsFrom": [
+            "component_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_components": {
+      "name": "distribution_board_components",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "placement": {
+          "name": "placement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "distribution_board_components_list_identifier_unique": {
+          "name": "distribution_board_components_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        },
+        "distribution_board_components_section_role_unique": {
+          "name": "distribution_board_components_section_role_unique",
+          "columns": [
+            "section_id",
+            "role"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "distribution_board_components_circuit_list_id_circuit_lists_id_fk": {
+          "name": "distribution_board_components_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_board_components_section_id_circuit_sections_id_fk": {
+          "name": "distribution_board_components_section_id_circuit_sections_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_boards": {
+      "name": "distribution_boards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "supply_type": {
+          "name": "supply_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "board_number": {
+          "name": "board_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "location": {
+          "name": "location",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fed_from": {
+          "name": "fed_from",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_boards_project_id_projects_id_fk": {
+          "name": "distribution_boards_project_id_projects_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_floor_id_floors_id_fk": {
+          "name": "distribution_boards_floor_id_floors_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_assets": {
+      "name": "document_branding_assets",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_csv_configurations": {
+      "name": "external_csv_configurations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration": {
+          "name": "configuration",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_csv_configurations_project_id_unique": {
+          "name": "external_csv_configurations_project_id_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_csv_configurations_project_id_projects_id_fk": {
+          "name": "external_csv_configurations_project_id_projects_id_fk",
+          "tableFrom": "external_csv_configurations",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_import_batches": {
+      "name": "external_import_batches",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "import_kind": {
+          "name": "import_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "imported_at_iso": {
+          "name": "imported_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "applied_project_revision": {
+          "name": "applied_project_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_snapshot": {
+          "name": "configuration_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "original_bytes": {
+          "name": "original_bytes",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "document": {
+          "name": "document",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_import_batches_project_revision_idx": {
+          "name": "external_import_batches_project_revision_idx",
+          "columns": [
+            "project_id",
+            "applied_project_revision"
+          ],
+          "isUnique": false
+        },
+        "external_import_batches_source_imported_idx": {
+          "name": "external_import_batches_source_imported_idx",
+          "columns": [
+            "source_id",
+            "imported_at_iso"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_import_batches_project_id_projects_id_fk": {
+          "name": "external_import_batches_project_id_projects_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_import_batches_source_id_external_model_sources_id_fk": {
+          "name": "external_import_batches_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_objects": {
+      "name": "external_model_objects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ifc_guid": {
+          "name": "ifc_guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen_import_batch_id": {
+          "name": "last_seen_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_accepted_import_batch_id": {
+          "name": "last_accepted_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "accepted_source_values": {
+          "name": "accepted_source_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "planning_values": {
+          "name": "planning_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "external_room_mapping_id": {
+          "name": "external_room_mapping_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "circuit_device_row_id": {
+          "name": "circuit_device_row_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "presence_status": {
+          "name": "presence_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'present'"
+        }
+      },
+      "indexes": {
+        "external_model_objects_source_ifc_guid_unique": {
+          "name": "external_model_objects_source_ifc_guid_unique",
+          "columns": [
+            "source_id",
+            "ifc_guid"
+          ],
+          "isUnique": true
+        },
+        "external_model_objects_project_presence_idx": {
+          "name": "external_model_objects_project_presence_idx",
+          "columns": [
+            "project_id",
+            "presence_status"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_distribution_board_idx": {
+          "name": "external_model_objects_distribution_board_idx",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_circuit_device_row_idx": {
+          "name": "external_model_objects_circuit_device_row_idx",
+          "columns": [
+            "circuit_device_row_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_model_objects_project_id_projects_id_fk": {
+          "name": "external_model_objects_project_id_projects_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_source_id_external_model_sources_id_fk": {
+          "name": "external_model_objects_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_seen_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_accepted_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk": {
+          "name": "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_room_mappings",
+          "columnsFrom": [
+            "external_room_mapping_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_model_objects_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_linked_project_device_id_project_devices_id_fk": {
+          "name": "external_model_objects_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk": {
+          "name": "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "circuit_device_rows",
+          "columnsFrom": [
+            "circuit_device_row_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_sources": {
+      "name": "external_model_sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_type": {
+          "name": "source_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'revit_csv'"
+        }
+      },
+      "indexes": {
+        "external_model_sources_project_type_unique": {
+          "name": "external_model_sources_project_type_unique",
+          "columns": [
+            "project_id",
+            "source_type"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_sources_project_id_projects_id_fk": {
+          "name": "external_model_sources_project_id_projects_id_fk",
+          "tableFrom": "external_model_sources",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_room_mappings": {
+      "name": "external_room_mappings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "normalized_source_room_key": {
+          "name": "normalized_source_room_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_floor_name": {
+          "name": "source_floor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_room_number": {
+          "name": "source_room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_room_name": {
+          "name": "source_room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_distribution_board_id": {
+          "name": "default_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_room_mappings_source_key_unique": {
+          "name": "external_room_mappings_source_key_unique",
+          "columns": [
+            "source_id",
+            "normalized_source_room_key"
+          ],
+          "isUnique": true
+        },
+        "external_room_mappings_project_room_idx": {
+          "name": "external_room_mappings_project_room_idx",
+          "columns": [
+            "project_id",
+            "room_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_room_mappings_project_id_projects_id_fk": {
+          "name": "external_room_mappings_project_id_projects_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_source_id_external_model_sources_id_fk": {
+          "name": "external_room_mappings_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_room_id_rooms_id_fk": {
+          "name": "external_room_mappings_room_id_rooms_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "default_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "floors": {
+      "name": "floors",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "floors_project_id_projects_id_fk": {
+          "name": "floors_project_id_projects_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "global_devices": {
+      "name": "global_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "installed_power_per_unit_kw": {
+          "name": "installed_power_per_unit_kw",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "demand_factor": {
+          "name": "demand_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase_count": {
+          "name": "phase_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_factor": {
+          "name": "power_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_change_sets": {
+      "name": "project_change_sets",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_revision_id": {
+          "name": "project_revision_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "command_type": {
+          "name": "command_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_schema_version": {
+          "name": "payload_schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "forward_payload_json": {
+          "name": "forward_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "inverse_payload_json": {
+          "name": "inverse_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_change_sets_revision_unique": {
+          "name": "project_change_sets_revision_unique",
+          "columns": [
+            "project_revision_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_change_sets_project_revision_id_project_revisions_id_fk": {
+          "name": "project_change_sets_project_revision_id_project_revisions_id_fk",
+          "tableFrom": "project_change_sets",
+          "tableTo": "project_revisions",
+          "columnsFrom": [
+            "project_revision_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_devices": {
+      "name": "project_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'single_phase'"
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "project_devices_project_id_projects_id_fk": {
+          "name": "project_devices_project_id_projects_id_fk",
+          "tableFrom": "project_devices",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_history_stack_entries": {
+      "name": "project_history_stack_entries",
+      "columns": {
+        "change_set_id": {
+          "name": "change_set_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stack": {
+          "name": "stack",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_history_stack_entries_position_unique": {
+          "name": "project_history_stack_entries_position_unique",
+          "columns": [
+            "project_id",
+            "stack",
+            "position"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_history_stack_entries_change_set_id_project_change_sets_id_fk": {
+          "name": "project_history_stack_entries_change_set_id_project_change_sets_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "project_change_sets",
+          "columnsFrom": [
+            "change_set_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "project_history_stack_entries_project_id_projects_id_fk": {
+          "name": "project_history_stack_entries_project_id_projects_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "project_history_stack_entries_stack_check": {
+          "name": "project_history_stack_entries_stack_check",
+          "value": "\"project_history_stack_entries\".\"stack\" in ('undo', 'redo')"
+        }
+      }
+    },
+    "project_revisions": {
+      "name": "project_revisions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision_number": {
+          "name": "revision_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_revisions_project_number_unique": {
+          "name": "project_revisions_project_number_unique",
+          "columns": [
+            "project_id",
+            "revision_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_revisions_project_id_projects_id_fk": {
+          "name": "project_revisions_project_id_projects_id_fk",
+          "tableFrom": "project_revisions",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_snapshots": {
+      "name": "project_snapshots",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_revision": {
+          "name": "source_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_version": {
+          "name": "schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'named'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "payload_json": {
+          "name": "payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_sha256": {
+          "name": "payload_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_by_actor_id": {
+          "name": "created_by_actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_snapshots_project_created_idx": {
+          "name": "project_snapshots_project_created_idx",
+          "columns": [
+            "project_id",
+            "created_at_iso"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_kind_revision_idx": {
+          "name": "project_snapshots_project_kind_revision_idx",
+          "columns": [
+            "project_id",
+            "kind",
+            "source_revision"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_name_unique": {
+          "name": "project_snapshots_project_name_unique",
+          "columns": [
+            "project_id",
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_snapshots_project_id_projects_id_fk": {
+          "name": "project_snapshots_project_id_projects_id_fk",
+          "tableFrom": "project_snapshots",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "internal_project_number": {
+          "name": "internal_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_project_number": {
+          "name": "external_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "building_owner": {
+          "name": "building_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_public_building": {
+          "name": "is_public_building",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "single_phase_voltage_v": {
+          "name": "single_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 230
+        },
+        "three_phase_voltage_v": {
+          "name": "three_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 400
+        },
+        "enabled_distribution_board_supply_types": {
+          "name": "enabled_distribution_board_supply_types",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'[\"AV\",\"SV\",\"EV\",\"USV\",\"MSR\",\"SiBe\"]'"
+        },
+        "current_revision": {
+          "name": "current_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "rooms": {
+      "name": "rooms",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number": {
+          "name": "room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_name": {
+          "name": "room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rooms_project_id_projects_id_fk": {
+          "name": "rooms_project_id_projects_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rooms_floor_id_floors_id_fk": {
+          "name": "rooms_floor_id_floors_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index eedfc7a..2b5f1f5 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -50,6 +50,13 @@
       "when": 1786043080323,
       "tag": "0006_damp_skrulls",
       "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "6",
+      "when": 1790411540872,
+      "tag": "0007_board_info_and_document_logo",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/db/repositories/distribution-board-structure-project-command.repository.ts b/src/db/repositories/distribution-board-structure-project-command.repository.ts
index 29a8f21..db2cede 100644
--- a/src/db/repositories/distribution-board-structure-project-command.repository.ts
+++ b/src/db/repositories/distribution-board-structure-project-command.repository.ts
@@ -388,10 +388,15 @@ function structureMatches(
 ) {
   const {
     simultaneityFactor,
+    boardNumber,
+    location,
+    fedFrom,
+    remark,
     ...actualDistributionBoard
   } = actual.board;
   if (
     simultaneityFactor !== 1 ||
+    [boardNumber, location, fedFrom, remark].some((value) => value !== null) ||
     !sameRecord(
       expected.distributionBoard,
       actualDistributionBoard
diff --git a/src/db/repositories/distribution-board-subtree-project-command.repository.ts b/src/db/repositories/distribution-board-subtree-project-command.repository.ts
index 63038eb..6788dcc 100644
--- a/src/db/repositories/distribution-board-subtree-project-command.repository.ts
+++ b/src/db/repositories/distribution-board-subtree-project-command.repository.ts
@@ -10,6 +10,7 @@ import {
 } from "../../domain/models/distribution-board-subtree-project-command.model.js";
 import {
   assertDistributionBoardSubtreeSnapshot,
+  normalizeDistributionBoardSubtreeSnapshot,
   type DistributionBoardSubtreeSnapshot,
 } from "../../domain/models/distribution-board-subtree-snapshot.model.js";
 import type {
@@ -63,19 +64,20 @@ export class DistributionBoardSubtreeProjectCommandRepository
     projectId: string,
     command: DistributionBoardSubtreeProjectCommand
   ) {
+    const snapshot = normalizeDistributionBoardSubtreeSnapshot(
+      command.payload.snapshot
+    );
     if (command.type === distributionBoardInsertSubtreeCommandType) {
-      this.insert(database, projectId, command.payload.snapshot);
-      return createDistributionBoardDeleteSubtreeProjectCommand(
-        command.payload.snapshot
-      );
+      this.insert(database, projectId, snapshot);
+      return createDistributionBoardDeleteSubtreeProjectCommand(snapshot);
     }
     if (command.type === distributionBoardDeleteSubtreeCommandType) {
       const current = this.captureFrom(
         database,
         projectId,
-        command.payload.snapshot.distributionBoard.id
+        snapshot.distributionBoard.id
       );
-      if (!sameSnapshot(current, command.payload.snapshot)) {
+      if (!sameSnapshot(current, snapshot)) {
         throw new Error(
           "Distribution-board subtree changed before deletion."
         );
@@ -97,9 +99,7 @@ export class DistributionBoardSubtreeProjectCommandRepository
           "Distribution-board subtree could not be deleted."
         );
       }
-      return createDistributionBoardInsertSubtreeProjectCommand(
-        command.payload.snapshot
-      );
+      return createDistributionBoardInsertSubtreeProjectCommand(snapshot);
     }
     throw new Error("Unsupported distribution-board subtree command.");
   }
diff --git a/src/db/repositories/document-branding.repository.ts b/src/db/repositories/document-branding.repository.ts
new file mode 100644
index 0000000..450e8d2
--- /dev/null
+++ b/src/db/repositories/document-branding.repository.ts
@@ -0,0 +1,52 @@
+import { eq } from "drizzle-orm";
+import type { AppDatabase } from "../database-context.js";
+import {
+  documentBrandingAssets,
+  type DocumentBrandingAsset,
+} from "../schema/document-branding-assets.js";
+
+// Plain repository without revision semantics: branding is global office
+// configuration, not a project mutation.
+export class DocumentBrandingRepository {
+  constructor(private readonly db: AppDatabase) {}
+
+  get(key: string): DocumentBrandingAsset | undefined {
+    return this.db
+      .select()
+      .from(documentBrandingAssets)
+      .where(eq(documentBrandingAssets.key, key))
+      .get();
+  }
+
+  upsert(asset: {
+    key: string;
+    mimeType: string;
+    fileName: string | null;
+    data: Buffer;
+  }): DocumentBrandingAsset {
+    const updatedAt = new Date();
+    return this.db
+      .insert(documentBrandingAssets)
+      .values({ ...asset, updatedAt })
+      .onConflictDoUpdate({
+        target: documentBrandingAssets.key,
+        set: {
+          mimeType: asset.mimeType,
+          fileName: asset.fileName,
+          data: asset.data,
+          updatedAt,
+        },
+      })
+      .returning()
+      .get();
+  }
+
+  delete(key: string): boolean {
+    return (
+      this.db
+        .delete(documentBrandingAssets)
+        .where(eq(documentBrandingAssets.key, key))
+        .run().changes > 0
+    );
+  }
+}
diff --git a/src/db/repositories/project-snapshot.repository.ts b/src/db/repositories/project-snapshot.repository.ts
index 5274fee..7a7522a 100644
--- a/src/db/repositories/project-snapshot.repository.ts
+++ b/src/db/repositories/project-snapshot.repository.ts
@@ -5,6 +5,7 @@ import { ProjectSnapshotNameConflictError } from "../../domain/errors/project-sn
 import { createProjectStateRestoreCommand } from "../../domain/models/project-state-restore-command.model.js";
 import {
   deserializeProjectStateSnapshot,
+  isSupportedProjectStateSnapshotSchemaVersion,
   projectStateSnapshotSchemaVersion,
 } from "../../domain/models/project-state-snapshot.model.js";
 import type {
@@ -138,7 +139,7 @@ export class ProjectSnapshotRepository implements ProjectSnapshotStore {
     if (actualChecksum !== stored.payloadSha256) {
       throw new Error("Project snapshot checksum verification failed.");
     }
-    if (stored.schemaVersion !== projectStateSnapshotSchemaVersion) {
+    if (!isSupportedProjectStateSnapshotSchemaVersion(stored.schemaVersion)) {
       throw new Error("Project snapshot schema version is not supported.");
     }
     const targetState = deserializeProjectStateSnapshot(stored.payloadJson);
diff --git a/src/db/schema/distribution-boards.ts b/src/db/schema/distribution-boards.ts
index 06fdaf6..eb63486 100644
--- a/src/db/schema/distribution-boards.ts
+++ b/src/db/schema/distribution-boards.ts
@@ -16,5 +16,9 @@ export const distributionBoards = sqliteTable("distribution_boards", {
   simultaneityFactor: real("simultaneity_factor")
     .notNull()
     .default(1),
+  boardNumber: text("board_number"),
+  location: text("location"),
+  fedFrom: text("fed_from"),
+  remark: text("remark"),
 });
 
diff --git a/src/db/schema/document-branding-assets.ts b/src/db/schema/document-branding-assets.ts
new file mode 100644
index 0000000..8fb68f8
--- /dev/null
+++ b/src/db/schema/document-branding-assets.ts
@@ -0,0 +1,18 @@
+import { sql } from "drizzle-orm";
+import { blob, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+// Office-wide branding for printed documents (currently only the logo shown
+// on the cover page and plan title blocks). Global application data, not part
+// of any project: it is deliberately outside project revisions, logical
+// project snapshots and project transfer.
+export const documentBrandingAssets = sqliteTable("document_branding_assets", {
+  key: text("key").primaryKey(),
+  mimeType: text("mime_type").notNull(),
+  fileName: text("file_name"),
+  data: blob("data", { mode: "buffer" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
+
+export type DocumentBrandingAsset = typeof documentBrandingAssets.$inferSelect;
diff --git a/src/domain/models/distribution-board-project-command.model.ts b/src/domain/models/distribution-board-project-command.model.ts
index a41be72..2e917d0 100644
--- a/src/domain/models/distribution-board-project-command.model.ts
+++ b/src/domain/models/distribution-board-project-command.model.ts
@@ -1,14 +1,21 @@
 import {
+  distributionBoardInfoFieldMaxLengths,
+  distributionBoardInfoFields,
   distributionBoardSupplyTypes,
+  type DistributionBoardInfoField,
   type DistributionBoardSupplyType,
 } from "../../shared/constants/distribution-board.js";
 import type { SerializedProjectCommand } from "./project-command.model.js";
 
 export const distributionBoardUpdateCommandType =
   "distribution-board.update" as const;
+// The info-card fields were added additively to schema version 1: every
+// previously stored command remains valid, and the inverse is still derived
+// from the persisted row for exactly the changed fields.
 export const distributionBoardUpdateCommandSchemaVersion = 1 as const;
 
-export interface DistributionBoardUpdateValues {
+export interface DistributionBoardUpdateValues
+  extends Record<DistributionBoardInfoField, string | null> {
   floorId: string | null;
   supplyType: DistributionBoardSupplyType | null;
   simultaneityFactor: number;
@@ -82,16 +89,20 @@ export function assertDistributionBoardUpdateProjectCommand(
   for (const change of changes) {
     if (
       !isPlainObject(change) ||
+      typeof change.field !== "string" ||
       (change.field !== "floorId" &&
         change.field !== "supplyType" &&
-        change.field !== "simultaneityFactor") ||
+        change.field !== "simultaneityFactor" &&
+        !isInfoField(change.field)) ||
       seen.has(change.field)
     ) {
       throw new Error(
         "Distribution-board update contains an invalid or duplicate field."
       );
     }
-    if (change.field === "floorId") {
+    if (isInfoField(change.field)) {
+      assertInfoFieldValue(change.field, change.value);
+    } else if (change.field === "floorId") {
       if (
         change.value !== null &&
         (typeof change.value !== "string" || !change.value.trim())
@@ -121,6 +132,29 @@ export function assertDistributionBoardUpdateProjectCommand(
   }
 }
 
+function isInfoField(field: string): field is DistributionBoardInfoField {
+  return (distributionBoardInfoFields as readonly string[]).includes(field);
+}
+
+function assertInfoFieldValue(
+  field: DistributionBoardInfoField,
+  value: unknown
+) {
+  if (value === null) {
+    return;
+  }
+  if (
+    typeof value !== "string" ||
+    !value.trim() ||
+    value !== value.trim() ||
+    value.length > distributionBoardInfoFieldMaxLengths[field]
+  ) {
+    throw new Error(
+      `${field} must be a trimmed, non-empty string of at most ${distributionBoardInfoFieldMaxLengths[field]} characters or null.`
+    );
+  }
+}
+
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
diff --git a/src/domain/models/distribution-board-subtree-snapshot.model.ts b/src/domain/models/distribution-board-subtree-snapshot.model.ts
index be896a0..a0269fc 100644
--- a/src/domain/models/distribution-board-subtree-snapshot.model.ts
+++ b/src/domain/models/distribution-board-subtree-snapshot.model.ts
@@ -10,7 +10,9 @@ import {
   type DistributionBoardComponentRole,
 } from "../../shared/constants/distribution-board-component.js";
 import {
+  distributionBoardInfoFields,
   distributionBoardSupplyTypes,
+  type DistributionBoardInfoField,
   type DistributionBoardSupplyType,
 } from "../../shared/constants/distribution-board.js";
 import type {
@@ -72,7 +74,7 @@ export interface DistributionBoardSubtreeSnapshot {
     floorId: string | null;
     supplyType: DistributionBoardSupplyType | null;
     simultaneityFactor: number;
-  };
+  } & Record<DistributionBoardInfoField, string | null>;
   circuitList: {
     id: string;
     projectId: string;
@@ -169,6 +171,22 @@ export function cloneDistributionBoardSubtree(
   return clone;
 }
 
+/**
+ * Subtree commands stored before the board info fields existed carry no
+ * info values. They are equivalent to a board whose info fields are empty,
+ * so comparisons against a freshly captured subtree and re-inserts stay
+ * exact.
+ */
+export function normalizeDistributionBoardSubtreeSnapshot(
+  snapshot: DistributionBoardSubtreeSnapshot
+): DistributionBoardSubtreeSnapshot {
+  const board = { ...snapshot.distributionBoard };
+  for (const field of distributionBoardInfoFields) {
+    board[field] = board[field] ?? null;
+  }
+  return { ...snapshot, distributionBoard: board };
+}
+
 export function assertDistributionBoardSubtreeSnapshot(
   value: unknown
 ): asserts value is DistributionBoardSubtreeSnapshot {
@@ -204,6 +222,11 @@ export function assertDistributionBoardSubtreeSnapshot(
   if (board.simultaneityFactor < 0 || board.simultaneityFactor > 1) {
     throw new Error("Distribution-board simultaneity factor is invalid.");
   }
+  for (const field of distributionBoardInfoFields) {
+    if (board[field] !== undefined) {
+      assertNullableString(board[field], `distributionBoard.${field}`);
+    }
+  }
   for (const field of [
     "id",
     "projectId",
diff --git a/src/domain/models/project-state-snapshot.model.ts b/src/domain/models/project-state-snapshot.model.ts
index 7172cb7..57dafc5 100644
--- a/src/domain/models/project-state-snapshot.model.ts
+++ b/src/domain/models/project-state-snapshot.model.ts
@@ -1,5 +1,9 @@
 import { z } from "zod";
-import { distributionBoardSupplyTypes } from "../../shared/constants/distribution-board.js";
+import {
+  distributionBoardInfoFieldMaxLengths,
+  distributionBoardSupplyTypes,
+  type DistributionBoardInfoField,
+} from "../../shared/constants/distribution-board.js";
 import {
   circuitGroupCategories,
 } from "../../shared/constants/circuit-group.js";
@@ -27,7 +31,8 @@ import {
   type ExternalModelStateSnapshot,
 } from "../../external-model/domain/external-model-contracts.js";
 
-export const projectStateSnapshotSchemaVersion = 5 as const;
+export const projectStateSnapshotSchemaVersion = 6 as const;
+const boardInfoProjectStateSnapshotSchemaVersion = 5 as const;
 const previousProjectStateSnapshotSchemaVersion = 4 as const;
 const externalModelProjectStateSnapshotSchemaVersion = 3 as const;
 const legacyProjectStateSnapshotSchemaVersion = 2 as const;
@@ -62,7 +67,7 @@ const projectSchema = previousProjectSchema
   .extend({ isPublicBuilding: z.boolean() })
   .strict();
 
-const distributionBoardSchema = z
+const legacyDistributionBoardSchema = z
   .object({
     id: idSchema,
     projectId: idSchema,
@@ -73,6 +78,35 @@ const distributionBoardSchema = z
   })
   .strict();
 
+const distributionBoardInfoValueSchema = (field: DistributionBoardInfoField) =>
+  z
+    .string()
+    .trim()
+    .min(1)
+    .max(distributionBoardInfoFieldMaxLengths[field])
+    .nullable();
+
+const distributionBoardSchema = legacyDistributionBoardSchema
+  .extend({
+    boardNumber: distributionBoardInfoValueSchema("boardNumber"),
+    location: distributionBoardInfoValueSchema("location"),
+    fedFrom: distributionBoardInfoValueSchema("fedFrom"),
+    remark: distributionBoardInfoValueSchema("remark"),
+  })
+  .strict();
+
+function withEmptyDistributionBoardInfo(
+  boards: Array<z.infer<typeof legacyDistributionBoardSchema>>
+) {
+  return boards.map((board) => ({
+    ...board,
+    boardNumber: null,
+    location: null,
+    fedFrom: null,
+    remark: null,
+  }));
+}
+
 const circuitListSchema = z
   .object({
     id: idSchema,
@@ -457,11 +491,22 @@ export const projectStateSnapshotSchema = z
   })
   .strict();
 
+const boardInfoProjectStateSnapshotSchema = z
+  .object({
+    schemaVersion: z.literal(boardInfoProjectStateSnapshotSchemaVersion),
+    project: projectSchema,
+    distributionBoards: z.array(legacyDistributionBoardSchema),
+    externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
+    externalModel: externalModelStateSchema,
+    ...projectStateSnapshotContents,
+  })
+  .strict();
+
 const previousProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(previousProjectStateSnapshotSchemaVersion),
     project: projectSchema,
-    distributionBoards: z.array(distributionBoardSchema),
+    distributionBoards: z.array(legacyDistributionBoardSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
     externalModel: externalModelStateSchema,
     ...projectStateSnapshotContents,
@@ -472,7 +517,7 @@ const externalModelProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(externalModelProjectStateSnapshotSchemaVersion),
     project: projectSchema,
-    distributionBoards: z.array(distributionBoardSchema),
+    distributionBoards: z.array(legacyDistributionBoardSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
     ...projectStateSnapshotContents,
   })
@@ -482,7 +527,7 @@ const legacyProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(legacyProjectStateSnapshotSchemaVersion),
     project: projectSchema,
-    distributionBoards: z.array(distributionBoardSchema),
+    distributionBoards: z.array(legacyDistributionBoardSchema),
     ...projectStateSnapshotContents,
   })
   .strict();
@@ -491,7 +536,7 @@ const baselineProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(baselineProjectStateSnapshotSchemaVersion),
     project: previousProjectSchema,
-    distributionBoards: z.array(distributionBoardSchema),
+    distributionBoards: z.array(legacyDistributionBoardSchema),
     ...projectStateSnapshotContents,
   })
   .strict();
@@ -500,6 +545,20 @@ export type ProjectStateSnapshot = z.infer<
   typeof projectStateSnapshotSchema
 >;
 
+/**
+ * Stored snapshots of every supported version can be restored: they are
+ * upgraded to the current version while parsing.
+ */
+export function isSupportedProjectStateSnapshotSchemaVersion(
+  schemaVersion: number
+): boolean {
+  return (
+    Number.isInteger(schemaVersion) &&
+    schemaVersion >= baselineProjectStateSnapshotSchemaVersion &&
+    schemaVersion <= projectStateSnapshotSchemaVersion
+  );
+}
+
 export function parseProjectStateSnapshot(
   value: unknown
 ): ProjectStateSnapshot {
@@ -521,11 +580,26 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     return value;
   }
   const schemaVersion = (value as { schemaVersion: number }).schemaVersion;
+  // Every supported version before 6 lacks the distribution-board info
+  // fields; they are upgraded as empty (null) values.
+  if (schemaVersion === boardInfoProjectStateSnapshotSchemaVersion) {
+    const previous = boardInfoProjectStateSnapshotSchema.parse(value);
+    return {
+      ...previous,
+      schemaVersion: projectStateSnapshotSchemaVersion,
+      distributionBoards: withEmptyDistributionBoardInfo(
+        previous.distributionBoards
+      ),
+    };
+  }
   if (schemaVersion === previousProjectStateSnapshotSchemaVersion) {
     const previous = previousProjectStateSnapshotSchema.parse(value);
     return {
       ...previous,
       schemaVersion: projectStateSnapshotSchemaVersion,
+      distributionBoards: withEmptyDistributionBoardInfo(
+        previous.distributionBoards
+      ),
     };
   }
   if (schemaVersion === externalModelProjectStateSnapshotSchemaVersion) {
@@ -533,6 +607,9 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     return {
       ...previous,
       schemaVersion: projectStateSnapshotSchemaVersion,
+      distributionBoards: withEmptyDistributionBoardInfo(
+        previous.distributionBoards
+      ),
       externalModel: emptyExternalModelState(),
     };
   }
@@ -541,6 +618,9 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     return {
       ...legacy,
       schemaVersion: projectStateSnapshotSchemaVersion,
+      distributionBoards: withEmptyDistributionBoardInfo(
+        legacy.distributionBoards
+      ),
       externalCsvConfiguration: null,
       externalModel: emptyExternalModelState(),
     };
@@ -551,6 +631,9 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
       ...baseline,
       schemaVersion: projectStateSnapshotSchemaVersion,
       project: { ...baseline.project, isPublicBuilding: false },
+      distributionBoards: withEmptyDistributionBoardInfo(
+        baseline.distributionBoards
+      ),
       externalCsvConfiguration: null,
       externalModel: emptyExternalModelState(),
     };
diff --git a/src/frontend/components/distribution-board-info-card.tsx b/src/frontend/components/distribution-board-info-card.tsx
new file mode 100644
index 0000000..f2523f4
--- /dev/null
+++ b/src/frontend/components/distribution-board-info-card.tsx
@@ -0,0 +1,110 @@
+"use client";
+
+import {
+  distributionBoardInfoFieldLabels,
+  distributionBoardInfoFieldMaxLengths,
+  distributionBoardInfoFields,
+  type DistributionBoardInfoField,
+} from "../../shared/constants/distribution-board";
+import type { DistributionBoardInfoDto } from "../types";
+
+export type DistributionBoardInfoDraft = Record<DistributionBoardInfoField, string>;
+
+const placeholders: Record<DistributionBoardInfoField, string> = {
+  boardNumber: "z. B. UV 1.1",
+  location: "z. B. Raum 003 Technik",
+  fedFrom: "z. B. HV 0.1 oder HAK / Zähleranlage",
+  remark: "",
+};
+
+export function toDistributionBoardInfoDraft(
+  info: DistributionBoardInfoDto
+): DistributionBoardInfoDraft {
+  return {
+    boardNumber: info.boardNumber ?? "",
+    location: info.location ?? "",
+    fedFrom: info.fedFrom ?? "",
+    remark: info.remark ?? "",
+  };
+}
+
+export function fromDistributionBoardInfoDraft(
+  draft: DistributionBoardInfoDraft
+): DistributionBoardInfoDto {
+  const value = (field: DistributionBoardInfoField) =>
+    draft[field].trim() ? draft[field].trim() : null;
+  return {
+    boardNumber: value("boardNumber"),
+    location: value("location"),
+    fedFrom: value("fedFrom"),
+    remark: value("remark"),
+  };
+}
+
+/**
+ * Descriptive board data used by the print view title block. The values are
+ * local planning values; a later Revit import may prefill them only through
+ * an explicit, previewed decision.
+ */
+export function DistributionBoardInfoCard({
+  draft,
+  onChange,
+}: {
+  draft: DistributionBoardInfoDraft;
+  onChange: (draft: DistributionBoardInfoDraft) => void;
+}) {
+  return (
+    <section
+      aria-labelledby="distribution-board-info-heading"
+      className="card"
+    >
+      <div className="card-header" id="distribution-board-info-heading">
+        Infokarte
+      </div>
+      <div className="card-body row g-3">
+        {distributionBoardInfoFields.map((field) => (
+          <div
+            className={field === "remark" ? "col-12" : "col-12 col-md-6"}
+            key={field}
+          >
+            <label
+              className="form-label"
+              htmlFor={`distribution-board-info-${field}`}
+            >
+              {distributionBoardInfoFieldLabels[field]}
+            </label>
+            {field === "remark" ? (
+              <textarea
+                className="form-control"
+                id={`distribution-board-info-${field}`}
+                maxLength={distributionBoardInfoFieldMaxLengths[field]}
+                onChange={(event) =>
+                  onChange({ ...draft, [field]: event.target.value })
+                }
+                rows={2}
+                value={draft[field]}
+              />
+            ) : (
+              <input
+                className="form-control"
+                id={`distribution-board-info-${field}`}
+                maxLength={distributionBoardInfoFieldMaxLengths[field]}
+                onChange={(event) =>
+                  onChange({ ...draft, [field]: event.target.value })
+                }
+                placeholder={placeholders[field]}
+                value={draft[field]}
+              />
+            )}
+            {field === "fedFrom" ? (
+              <div className="form-text">
+                Vorerst Freitext. Die logische Verknüpfung mit dem
+                speisenden Verteiler folgt.
+              </div>
+            ) : null}
+          </div>
+        ))}
+      </div>
+    </section>
+  );
+}
diff --git a/src/frontend/print/print-document-model.ts b/src/frontend/print/print-document-model.ts
new file mode 100644
index 0000000..c0df6b7
--- /dev/null
+++ b/src/frontend/print/print-document-model.ts
@@ -0,0 +1,180 @@
+import { protectionDeviceTypeLabels } from "../../shared/constants/protection-device";
+import type {
+  CircuitTreeCircuitDto,
+  CircuitTreeProtectionDeviceDto,
+  CircuitTreeResponseDto,
+  DistributionBoardDto,
+} from "../types";
+
+/**
+ * Pure read model for the print view (cover page, board overview and board
+ * plans). It only derives display values from the existing circuit-tree
+ * responses and never changes project data.
+ */
+export interface PrintBoardSummary {
+  board: DistributionBoardDto;
+  circuitListId: string;
+  tree: CircuitTreeResponseDto;
+  floorName: string | null;
+  circuitCount: number;
+  /** Σ quantity × power per unit, without any simultaneity factor. */
+  installedPowerKw: number;
+  /** Σ row totals, i.e. with the device-row simultaneity factors. */
+  devicePowerKw: number;
+  simultaneityFactor: number;
+  /** Device power with the board simultaneity factor applied. */
+  demandPowerKw: number;
+  /**
+   * Symmetrical three-phase design current from the apparent power
+   * S = Σ(row total / cos φ) × board GZF. A missing cos φ counts as 1.
+   */
+  designCurrentA: number;
+}
+
+export function summarizePrintBoard(input: {
+  board: DistributionBoardDto;
+  circuitListId: string;
+  tree: CircuitTreeResponseDto;
+  floorName: string | null;
+}): PrintBoardSummary {
+  const { tree } = input;
+  let circuitCount = 0;
+  let installedPowerKw = 0;
+  let apparentPowerKva = 0;
+  for (const section of tree.sections) {
+    for (const circuit of section.circuits) {
+      circuitCount += 1;
+      for (const row of circuit.deviceRows) {
+        installedPowerKw += row.quantity * row.powerPerUnit;
+        apparentPowerKva += row.rowTotalPower / (row.cosPhi || 1);
+      }
+    }
+  }
+  const simultaneityFactor = tree.distributionBoardSimultaneityFactor;
+  return {
+    ...input,
+    circuitCount,
+    installedPowerKw,
+    devicePowerKw: tree.distributionBoardTotalPower,
+    simultaneityFactor,
+    demandPowerKw: tree.distributionBoardTotalPowerWithSimultaneityFactor,
+    designCurrentA:
+      (apparentPowerKva * simultaneityFactor * 1000) /
+      (Math.sqrt(3) * tree.threePhaseVoltageV),
+  };
+}
+
+export interface PrintBoardHierarchyEntry {
+  summary: PrintBoardSummary;
+  depth: number;
+  parentBoardId: string | null;
+  /** Own demand plus the plain sum of all resolved downstream boards. */
+  cumulatedDemandPowerKw: number;
+}
+
+/**
+ * PRELIMINARY: `fedFrom` is free text until the logical feed link is
+ * decided. A board is shown below another board only when its `fedFrom`
+ * text equals that board's number or name (case-insensitive). The
+ * cumulated value is a plain sum without an upstream simultaneity factor.
+ * Unresolved texts and cycles keep a board at the top level.
+ */
+export function buildPreliminaryBoardHierarchy(
+  summaries: PrintBoardSummary[]
+): PrintBoardHierarchyEntry[] {
+  const normalize = (value: string | null) =>
+    value?.trim().toLocaleLowerCase("de") || null;
+  const parentById = new Map<string, string | null>();
+  for (const summary of summaries) {
+    const fedFrom = normalize(summary.board.fedFrom);
+    const parent = fedFrom
+      ? summaries.find(
+          (candidate) =>
+            candidate !== summary &&
+            (normalize(candidate.board.boardNumber) === fedFrom ||
+              normalize(candidate.board.name) === fedFrom)
+        )
+      : undefined;
+    parentById.set(summary.board.id, parent?.board.id ?? null);
+  }
+  for (const summary of summaries) {
+    const visited = new Set<string>([summary.board.id]);
+    let current = parentById.get(summary.board.id) ?? null;
+    while (current !== null) {
+      if (visited.has(current)) {
+        parentById.set(summary.board.id, null);
+        break;
+      }
+      visited.add(current);
+      current = parentById.get(current) ?? null;
+    }
+  }
+
+  const childrenOf = (boardId: string | null) =>
+    summaries.filter(
+      (summary) => parentById.get(summary.board.id) === boardId
+    );
+  const cumulated = (summary: PrintBoardSummary): number =>
+    summary.demandPowerKw +
+    childrenOf(summary.board.id).reduce(
+      (sum, child) => sum + cumulated(child),
+      0
+    );
+
+  const entries: PrintBoardHierarchyEntry[] = [];
+  const walk = (summary: PrintBoardSummary, depth: number) => {
+    entries.push({
+      summary,
+      depth,
+      parentBoardId: parentById.get(summary.board.id) ?? null,
+      cumulatedDemandPowerKw: cumulated(summary),
+    });
+    childrenOf(summary.board.id).forEach((child) => walk(child, depth + 1));
+  };
+  childrenOf(null).forEach((root) => walk(root, 0));
+  return entries;
+}
+
+const kilowattFormat = new Intl.NumberFormat("de-DE", {
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2,
+});
+const unitPowerFormat = new Intl.NumberFormat("de-DE", {
+  minimumFractionDigits: 3,
+  maximumFractionDigits: 3,
+});
+const currentFormat = new Intl.NumberFormat("de-DE", {
+  minimumFractionDigits: 1,
+  maximumFractionDigits: 1,
+});
+
+export const formatKilowatt = (value: number) => kilowattFormat.format(value);
+export const formatUnitPower = (value: number) => unitPowerFormat.format(value);
+export const formatFactor = (value: number) => kilowattFormat.format(value);
+export const formatCurrent = (value: number) => currentFormat.format(value);
+
+export function formatProtectionDevice(
+  protection: CircuitTreeProtectionDeviceDto | undefined
+): string | null {
+  if (!protection) {
+    return null;
+  }
+  const parts = [
+    protectionDeviceTypeLabels[protection.type],
+    protection.tripCharacteristic,
+    `${protection.ratedCurrentA} A`,
+    protection.fuseUtilizationCategory,
+  ].filter(Boolean);
+  let text = parts.join(" ");
+  if (protection.ratedResidualCurrentMa !== undefined) {
+    text += `, ${protection.ratedResidualCurrentMa} mA`;
+    if (protection.rcdType) {
+      text += ` Typ ${protection.rcdType}`;
+    }
+  }
+  return text;
+}
+
+export function formatCircuitCable(circuit: CircuitTreeCircuitDto): string | null {
+  return circuit.cableType || circuit.cableCrossSection || null;
+}
diff --git a/src/frontend/print/print-document.css b/src/frontend/print/print-document.css
new file mode 100644
index 0000000..8a0784d
--- /dev/null
+++ b/src/frontend/print/print-document.css
@@ -0,0 +1,473 @@
+/* Print view (Seitenansicht) in the provisional kbp corporate design.
+   Colors are derived from the kbp logo and presentation material and will be
+   replaced by the official CD specification; change them only here.
+   All selectors are scoped to .print-view. The @page rules (format, margins,
+   page numbers) are injected by the print page because they need project
+   data. */
+.print-view {
+  --pd-blue: #476088;
+  --pd-lilac: #9198c4;
+  --pd-line: #d6dae5;
+  --pd-tint: #f5f6fa;
+  --pd-text: #2b2b2b;
+  --pd-muted: #6b7280;
+  --pd-accent: #c9782a;
+  --pd-font: Arial, "Helvetica Neue", Helvetica, sans-serif;
+  --pd-landscape-width: 297mm;
+  --pd-landscape-height: 210mm;
+  min-height: 100vh;
+  background: #e7e9ef;
+  color: var(--pd-text);
+  font-family: var(--pd-font);
+  color-scheme: light;
+}
+.print-view.pd-a3 {
+  --pd-landscape-width: 420mm;
+  --pd-landscape-height: 297mm;
+}
+
+.pd-toolbar {
+  position: sticky;
+  top: 0;
+  z-index: 5;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  align-items: center;
+  padding: 10px 16px;
+  background: #fff;
+  border-bottom: 1px solid var(--pd-line);
+  font-size: 14px;
+}
+.pd-toolbar-title {
+  margin-right: auto;
+  color: var(--pd-blue);
+  font-weight: bold;
+}
+.pd-toolbar .pd-toolbar-message {
+  color: var(--pd-muted);
+  font-size: 13px;
+}
+.pd-toolbar .pd-toolbar-error {
+  color: #b04035;
+  font-size: 13px;
+}
+
+.pd-pages {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 24px;
+  padding: 24px 16px 48px;
+  overflow-x: auto;
+}
+.pd-sheet {
+  position: relative;
+  flex: none;
+  background: #fff;
+  box-shadow: 0 2px 12px rgba(0, 0, 0, 0.18);
+  font-size: 9pt;
+  line-height: 1.3;
+}
+.pd-portrait {
+  width: 210mm;
+  min-height: 297mm;
+  padding: 18mm 18mm 22mm;
+  page: lb-portrait;
+}
+.pd-landscape {
+  width: var(--pd-landscape-width);
+  min-height: var(--pd-landscape-height);
+  padding: 12mm 12mm 18mm;
+  page: lb-landscape;
+}
+.pd-a3 .pd-landscape {
+  font-size: 10pt;
+}
+
+.print-view table {
+  border-collapse: collapse;
+  width: 100%;
+}
+.print-view caption {
+  caption-side: top;
+  padding: 0 0 1.5mm;
+  color: var(--pd-blue);
+  font-size: 10pt;
+  font-weight: bold;
+  letter-spacing: 0.04em;
+  text-align: left;
+  text-transform: uppercase;
+}
+.print-view sub {
+  font-size: 0.75em;
+}
+.pd-r {
+  text-align: right !important;
+}
+.pd-placeholder {
+  color: var(--pd-accent);
+  font-style: italic;
+}
+.pd-open {
+  color: var(--pd-accent);
+  font-weight: bold;
+}
+.pd-logo {
+  display: block;
+  max-width: 100%;
+  object-fit: contain;
+}
+.pd-logo-missing {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border: 1px dashed var(--pd-line);
+  color: var(--pd-muted);
+  font-size: 8pt;
+}
+
+/* Cover */
+.pd-cover-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  border-bottom: 2px solid var(--pd-blue);
+  padding-bottom: 6mm;
+}
+.pd-cover-kicker {
+  margin-top: 3mm;
+  color: var(--pd-muted);
+  font-size: 10pt;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+.pd-cover-logo {
+  height: 15mm;
+  width: auto;
+  max-width: 60mm;
+}
+span.pd-cover-logo {
+  width: 40mm;
+}
+.pd-cover-title {
+  margin: 14mm 0 10mm;
+}
+.pd-cover-title h1 {
+  margin: 0;
+  color: var(--pd-blue);
+  font-size: 30pt;
+  font-weight: bold;
+}
+.pd-cover-title p {
+  margin: 2mm 0 0;
+  color: var(--pd-muted);
+  font-size: 13pt;
+}
+.pd-kv {
+  margin-bottom: 7mm;
+}
+.pd-kv th,
+.pd-kv td {
+  border: 1px solid var(--pd-line);
+  padding: 2mm 3mm;
+  font-size: 9.5pt;
+  text-align: left;
+  vertical-align: top;
+}
+.pd-kv th {
+  width: 42mm;
+  background: var(--pd-tint);
+  color: var(--pd-muted);
+  font-weight: normal;
+}
+.pd-cover-cols {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 6mm;
+}
+.pd-cover-cols .pd-kv th {
+  width: 30mm;
+}
+.pd-block {
+  margin-bottom: 7mm;
+}
+.pd-col-index {
+  width: 14mm;
+}
+
+/* Generic grid tables */
+.pd-grid th,
+.pd-grid td {
+  border: 1px solid var(--pd-line);
+  padding: 1.3mm 2mm;
+  text-align: left;
+  vertical-align: top;
+}
+.pd-grid > thead > tr > th:not(.pd-tb-cell) {
+  background: var(--pd-blue);
+  border-color: var(--pd-blue);
+  color: #fff;
+  font-weight: bold;
+  vertical-align: bottom;
+}
+
+/* Footer (screen only; printed pages use @page margin boxes) */
+.pd-sheet-footer {
+  position: absolute;
+  left: 12mm;
+  right: 12mm;
+  bottom: 7mm;
+  display: flex;
+  justify-content: space-between;
+  border-top: 1px solid var(--pd-line);
+  padding-top: 2mm;
+  color: var(--pd-muted);
+  font-size: 7.5pt;
+}
+.pd-portrait .pd-sheet-footer {
+  left: 18mm;
+  right: 18mm;
+  bottom: 10mm;
+}
+
+/* Title block */
+.pd-grid th.pd-tb-cell {
+  border: none;
+  padding: 0 0 4mm;
+  background: none;
+  font-weight: normal;
+}
+.pd-titleblock {
+  display: grid;
+  grid-template-columns: 28mm 1fr auto auto;
+  border: 1.5px solid var(--pd-blue);
+  margin-bottom: 4mm;
+  background: #fff;
+  font-size: 9pt;
+}
+.pd-grid .pd-titleblock {
+  margin-bottom: 0;
+}
+.pd-titleblock > * {
+  padding: 2.5mm 3.5mm;
+  border-left: 1px solid var(--pd-line);
+}
+.pd-titleblock > :first-child {
+  border-left: none;
+}
+.pd-tb-logo {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 17mm;
+}
+.pd-tb-logo-image {
+  max-height: 10mm;
+}
+span.pd-tb-logo-image {
+  width: 100%;
+  height: 10mm;
+}
+.pd-tb-kicker {
+  color: var(--pd-muted);
+  font-size: 7.5pt;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+}
+.pd-tb-title {
+  display: flex;
+  align-items: baseline;
+  gap: 4mm;
+  margin-top: 1mm;
+}
+.pd-tb-number {
+  color: var(--pd-blue);
+  font-size: 18pt;
+  font-weight: bold;
+}
+.pd-tb-name {
+  font-size: 14pt;
+  font-weight: bold;
+}
+.pd-tb-grid {
+  display: grid;
+  grid-template-columns: auto auto;
+  gap: 0.8mm 4mm;
+  align-content: center;
+  margin: 0;
+  font-size: 8pt;
+}
+.pd-tb-grid div {
+  display: contents;
+}
+.pd-tb-grid dt {
+  color: var(--pd-muted);
+  font-weight: normal;
+}
+.pd-tb-grid dd {
+  margin: 0;
+  font-weight: bold;
+}
+.pd-tb-meta {
+  background: var(--pd-tint);
+}
+
+/* Board plan table */
+.pd-plan {
+  font-size: 7.6pt;
+  line-height: 1.2;
+}
+.pd-a3 .pd-plan {
+  font-size: 9pt;
+}
+.pd-plan th,
+.pd-plan td {
+  padding: 0.75mm 1.6mm;
+}
+.pd-plan td.pd-bmk {
+  color: var(--pd-blue);
+  font-weight: bold;
+  white-space: nowrap;
+}
+.pd-plan tr.pd-group td {
+  background: var(--pd-tint);
+  border-top: 1.5px solid var(--pd-lilac);
+  font-weight: bold;
+}
+.pd-plan tr.pd-component td,
+.pd-plan tr.pd-component td.pd-bmk,
+.pd-plan tr.pd-device td {
+  color: var(--pd-muted);
+}
+.pd-plan tr.pd-device td:nth-child(2) {
+  padding-left: 6mm;
+}
+.pd-plan tr.pd-reserve td {
+  color: var(--pd-muted);
+  font-style: italic;
+}
+.pd-plan tr.pd-subtotal td {
+  border-bottom: 1.5px solid var(--pd-line);
+  font-weight: bold;
+}
+.pd-plan .pd-sub {
+  color: var(--pd-muted);
+  font-size: 0.9em;
+}
+.pd-plan tfoot td {
+  background: var(--pd-tint);
+  font-weight: bold;
+}
+.pd-plan tfoot tr.pd-grand td {
+  background: var(--pd-blue);
+  border-color: var(--pd-blue);
+  color: #fff;
+}
+.pd-plan tr {
+  break-inside: avoid;
+}
+
+/* Overview */
+.pd-overview {
+  display: grid;
+  grid-template-columns: 62mm 1fr;
+  gap: 6mm;
+}
+.pd-a3 .pd-overview {
+  grid-template-columns: 90mm 1fr;
+}
+.pd-structure h2 {
+  margin: 0 0 3mm;
+  color: var(--pd-blue);
+  font-size: 10pt;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+.pd-tree,
+.pd-tree ul {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+.pd-tree ul {
+  margin-left: 5mm;
+  padding-left: 4mm;
+  border-left: 1.5px solid var(--pd-lilac);
+}
+.pd-tree li {
+  position: relative;
+  margin: 2.5mm 0;
+}
+.pd-tree ul > li::before {
+  content: "";
+  position: absolute;
+  left: -4mm;
+  top: 5mm;
+  width: 4mm;
+  border-top: 1.5px solid var(--pd-lilac);
+}
+.pd-node {
+  display: grid;
+  gap: 0.3mm;
+  padding: 1.5mm 2.5mm;
+  border: 1px solid var(--pd-line);
+  border-left: 3px solid var(--pd-blue);
+  background: #fff;
+}
+.pd-node.pd-feed {
+  border-left-color: var(--pd-accent);
+}
+.pd-node span {
+  color: var(--pd-muted);
+  font-size: 8pt;
+}
+.pd-node em {
+  color: var(--pd-blue);
+  font-size: 8.5pt;
+  font-style: normal;
+  font-weight: bold;
+}
+.pd-note {
+  margin: 4mm 0 1mm;
+  padding: 2.5mm 3mm;
+  border-left: 3px solid var(--pd-accent);
+  background: #fbf4ec;
+  font-size: 8pt;
+}
+.pd-legend {
+  margin: 1mm 0 0;
+  color: var(--pd-muted);
+  font-size: 7.5pt;
+}
+
+@media print {
+  html,
+  body,
+  .print-view {
+    background: #fff !important;
+  }
+  .pd-toolbar,
+  .pd-sheet-footer {
+    display: none !important;
+  }
+  .pd-pages {
+    display: block;
+    padding: 0;
+    overflow: visible;
+  }
+  .pd-sheet {
+    width: auto;
+    min-height: 0;
+    padding: 0;
+    box-shadow: none;
+    break-after: page;
+  }
+  .pd-sheet:last-child {
+    break-after: auto;
+  }
+  .print-view * {
+    -webkit-print-color-adjust: exact;
+    print-color-adjust: exact;
+  }
+}
diff --git a/src/frontend/print/print-document.tsx b/src/frontend/print/print-document.tsx
new file mode 100644
index 0000000..4270dbc
--- /dev/null
+++ b/src/frontend/print/print-document.tsx
@@ -0,0 +1,612 @@
+"use client";
+
+import type { ReactNode } from "react";
+import type {
+  CircuitTreeCircuitDto,
+  CircuitTreeComponentDto,
+  CircuitTreeDeviceRowDto,
+  ProjectDto,
+  ProjectSnapshotMetadataDto,
+} from "../types";
+import {
+  formatCircuitCable,
+  formatCurrent,
+  formatFactor,
+  formatKilowatt,
+  formatProtectionDevice,
+  formatUnitPower,
+  type PrintBoardHierarchyEntry,
+} from "./print-document-model";
+
+// Provisional office data until the project/cover fields are added.
+export const printOfficeName = "kbp köhler beraten + planen GmbH";
+
+export interface PrintDocumentProps {
+  project: ProjectDto;
+  entries: PrintBoardHierarchyEntry[];
+  namedSnapshots: ProjectSnapshotMetadataDto[];
+  logoSrc: string | null;
+  printedAt: Date;
+}
+
+const dateFormat = new Intl.DateTimeFormat("de-DE", {
+  day: "2-digit",
+  month: "2-digit",
+  year: "numeric",
+});
+
+function Placeholder({ label = "ergänzen" }: { label?: string }) {
+  return <span className="pd-placeholder">[{label}]</span>;
+}
+
+function Open() {
+  return <span className="pd-open">offen</span>;
+}
+
+function Logo({ src, className }: { src: string | null; className: string }) {
+  return src ? (
+    // eslint-disable-next-line @next/next/no-img-element
+    <img alt="Logo" className={`pd-logo ${className}`} src={src} />
+  ) : (
+    <span className={`pd-logo-missing ${className}`}>Logo</span>
+  );
+}
+
+function SheetFooter({ project, stand }: { project: ProjectDto; stand: string }) {
+  return (
+    <div className="pd-sheet-footer" aria-hidden="true">
+      <span>{project.name} · Leistungsbilanz</span>
+      <span>
+        Stand {stand} · Datenstand Rev. {project.currentRevision}
+      </span>
+    </div>
+  );
+}
+
+function TitleBlock({
+  kicker,
+  number,
+  name,
+  rows,
+  project,
+  stand,
+  logoSrc,
+}: {
+  kicker: string;
+  number?: string | null;
+  name: string;
+  rows: Array<[ReactNode, ReactNode]>;
+  project: ProjectDto;
+  stand: string;
+  logoSrc: string | null;
+}) {
+  return (
+    <div className="pd-titleblock">
+      <div className="pd-tb-logo">
+        <Logo className="pd-tb-logo-image" src={logoSrc} />
+      </div>
+      <div className="pd-tb-main">
+        <div className="pd-tb-kicker">{kicker}</div>
+        <div className="pd-tb-title">
+          {number ? <span className="pd-tb-number">{number}</span> : null}
+          <span className="pd-tb-name">{name}</span>
+        </div>
+      </div>
+      <dl className="pd-tb-grid">
+        {rows.map(([label, value], index) => (
+          <div key={index}>
+            <dt>{label}</dt>
+            <dd>{value}</dd>
+          </div>
+        ))}
+      </dl>
+      <dl className="pd-tb-grid pd-tb-meta">
+        <div>
+          <dt>Projekt</dt>
+          <dd>{project.name}</dd>
+        </div>
+        <div>
+          <dt>Projekt-Nr.</dt>
+          <dd>{project.internalProjectNumber ?? "–"}</dd>
+        </div>
+        <div>
+          <dt>Stand</dt>
+          <dd>{stand}</dd>
+        </div>
+        <div>
+          <dt>Datenstand</dt>
+          <dd>Rev. {project.currentRevision}</dd>
+        </div>
+      </dl>
+    </div>
+  );
+}
+
+function boardLabel(entry: PrintBoardHierarchyEntry) {
+  const { board } = entry.summary;
+  return board.boardNumber ? `${board.boardNumber} – ${board.name}` : board.name;
+}
+
+function CoverSheet({
+  project,
+  entries,
+  namedSnapshots,
+  logoSrc,
+  stand,
+}: Omit<PrintDocumentProps, "printedAt"> & { stand: string }) {
+  return (
+    <section className="pd-sheet pd-portrait pd-cover">
+      <div className="pd-cover-head">
+        <div className="pd-cover-kicker">Projektdokumentation Elektrotechnik</div>
+        <Logo className="pd-cover-logo" src={logoSrc} />
+      </div>
+      <div className="pd-cover-title">
+        <h1>Leistungsbilanz</h1>
+        <p>Verteilerübersicht und Verteilerpläne</p>
+      </div>
+
+      <table className="pd-kv">
+        <caption>Projekt</caption>
+        <tbody>
+          <tr><th>Bauvorhaben</th><td>{project.name}</td></tr>
+          <tr><th>Anschrift</th><td><Placeholder /></td></tr>
+          <tr><th>Bauherr</th><td>{project.buildingOwner ?? <Placeholder />}</td></tr>
+          <tr><th>Projektnummer intern</th><td>{project.internalProjectNumber ?? <Placeholder />}</td></tr>
+          <tr><th>Projektnummer extern</th><td>{project.externalProjectNumber ?? <Placeholder />}</td></tr>
+          <tr><th>Leistungsphase</th><td><Placeholder /></td></tr>
+          <tr><th>Gewerk</th><td>KG 440 – Starkstromanlagen</td></tr>
+          <tr><th>Beschreibung</th><td>{project.description ?? "–"}</td></tr>
+        </tbody>
+      </table>
+
+      <div className="pd-cover-cols">
+        <table className="pd-kv">
+          <caption>Planverfasser</caption>
+          <tbody>
+            <tr><th>Büro</th><td>{printOfficeName}</td></tr>
+            <tr><th>Anschrift</th><td><Placeholder /></td></tr>
+            <tr><th>Projektleitung</th><td><Placeholder /></td></tr>
+            <tr><th>Bearbeitung</th><td><Placeholder /></td></tr>
+          </tbody>
+        </table>
+        <table className="pd-kv">
+          <caption>Dokument</caption>
+          <tbody>
+            <tr><th>Dokumentart</th><td>Leistungsbilanz</td></tr>
+            <tr><th>Stand</th><td>{stand}</td></tr>
+            <tr><th>Datenstand</th><td>Revision {project.currentRevision}</td></tr>
+            <tr><th>Verteiler</th><td>{entries.length}</td></tr>
+          </tbody>
+        </table>
+      </div>
+
+      <table className="pd-grid pd-block">
+        <caption>Planstände</caption>
+        <thead>
+          <tr><th className="pd-col-index">Index</th><th>Datum</th><th>Änderung</th><th>Bearbeitung</th></tr>
+        </thead>
+        <tbody>
+          {namedSnapshots.length ? (
+            namedSnapshots.map((snapshot, index) => (
+              <tr key={snapshot.id}>
+                <td>{String.fromCharCode(97 + (index % 26))}</td>
+                <td>{dateFormat.format(new Date(snapshot.createdAtIso))}</td>
+                <td>{snapshot.name}</td>
+                <td><Placeholder /></td>
+              </tr>
+            ))
+          ) : (
+            <tr><td colSpan={4}>–</td></tr>
+          )}
+        </tbody>
+      </table>
+
+      <table className="pd-grid pd-block">
+        <caption>Inhalt</caption>
+        <tbody>
+          <tr><td className="pd-col-index">1</td><td>Verteilerübersicht und Leistungssummen</td></tr>
+          {entries.map((entry, index) => (
+            <tr key={entry.summary.board.id}>
+              <td className="pd-col-index">2.{index + 1}</td>
+              <td>Verteilerplan {boardLabel(entry)}</td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+      <SheetFooter project={project} stand={stand} />
+    </section>
+  );
+}
+
+function StructureNode({
+  entry,
+  entries,
+}: {
+  entry: PrintBoardHierarchyEntry;
+  entries: PrintBoardHierarchyEntry[];
+}) {
+  const children = entries.filter(
+    (candidate) => candidate.parentBoardId === entry.summary.board.id
+  );
+  const { board } = entry.summary;
+  return (
+    <li>
+      <div className="pd-node">
+        <strong>{board.boardNumber ?? board.name}</strong>
+        {board.boardNumber ? <span>{board.name}</span> : null}
+        <em>{formatKilowatt(entry.summary.demandPowerKw)} kW</em>
+      </div>
+      {children.length ? (
+        <ul>
+          {children.map((child) => (
+            <StructureNode entries={entries} entry={child} key={child.summary.board.id} />
+          ))}
+        </ul>
+      ) : null}
+    </li>
+  );
+}
+
+function OverviewSheet({
+  project,
+  entries,
+  logoSrc,
+  stand,
+}: {
+  project: ProjectDto;
+  entries: PrintBoardHierarchyEntry[];
+  logoSrc: string | null;
+  stand: string;
+}) {
+  const roots = entries.filter((entry) => entry.parentBoardId === null);
+  // Top-level boards whose "fed from" text names no other board are grouped
+  // below that text as an external feed (e.g. "HAK / Zähleranlage").
+  const feedGroups = new Map<string, PrintBoardHierarchyEntry[]>();
+  for (const root of roots) {
+    const feed = root.summary.board.fedFrom ?? "";
+    feedGroups.set(feed, [...(feedGroups.get(feed) ?? []), root]);
+  }
+  const sum =(pick: (entry: PrintBoardHierarchyEntry) => number) =>
+    entries.reduce((total, entry) => total + pick(entry), 0);
+  return (
+    <section className="pd-sheet pd-landscape">
+      <TitleBlock
+        kicker="Übersicht"
+        logoSrc={logoSrc}
+        name="Verteilerübersicht und Leistungssummen"
+        project={project}
+        rows={[
+          ["Verteiler", String(entries.length)],
+          ["Netz", `${project.threePhaseVoltageV} / ${project.singlePhaseVoltageV} V`],
+        ]}
+        stand={stand}
+      />
+      <div className="pd-overview">
+        <div className="pd-structure">
+          <h2>Versorgungsstruktur</h2>
+          <ul className="pd-tree">
+            {[...feedGroups].map(([feed, feedRoots]) => {
+              const nodes = feedRoots.map((root) => (
+                <StructureNode entries={entries} entry={root} key={root.summary.board.id} />
+              ));
+              return feed ? (
+                <li key={`feed:${feed}`}>
+                  <div className="pd-node pd-feed">
+                    <strong>Einspeisung</strong>
+                    <span>{feed}</span>
+                  </div>
+                  <ul>{nodes}</ul>
+                </li>
+              ) : (
+                nodes
+              );
+            })}
+          </ul>
+        </div>
+        <div>
+          <table className="pd-grid pd-plan">
+            <thead>
+              <tr>
+                <th>Nr.</th><th>Bezeichnung</th><th>Örtlichkeit</th><th>Etage</th><th>Netz</th><th>Gespeist von</th>
+                <th className="pd-r">SK</th>
+                <th className="pd-r">P<sub>inst</sub><br />[kW]</th>
+                <th className="pd-r">P<sub>Geräte</sub><br />[kW]</th>
+                <th className="pd-r">GZF<br />Vert.</th>
+                <th className="pd-r">P<sub>gl</sub><br />[kW]</th>
+                <th className="pd-r">I<sub>B</sub><br />[A]</th>
+                <th className="pd-r">Σ inkl.<br />unterlagert [kW]</th>
+              </tr>
+            </thead>
+            <tbody>
+              {entries.map((entry) => {
+                const { board } = entry.summary;
+                return (
+                  <tr key={board.id}>
+                    <td style={{ paddingLeft: `${1.6 + entry.depth * 3.5}mm` }}>
+                      {entry.depth ? "└ " : ""}
+                      <strong>{board.boardNumber ?? "–"}</strong>
+                    </td>
+                    <td>{board.name}</td>
+                    <td>{board.location ?? "–"}</td>
+                    <td>{entry.summary.floorName ?? "–"}</td>
+                    <td>{board.supplyType ?? "–"}</td>
+                    <td>{board.fedFrom ?? "–"}</td>
+                    <td className="pd-r">{entry.summary.circuitCount}</td>
+                    <td className="pd-r">{formatKilowatt(entry.summary.installedPowerKw)}</td>
+                    <td className="pd-r">{formatKilowatt(entry.summary.devicePowerKw)}</td>
+                    <td className="pd-r">{formatFactor(entry.summary.simultaneityFactor)}</td>
+                    <td className="pd-r"><strong>{formatKilowatt(entry.summary.demandPowerKw)}</strong></td>
+                    <td className="pd-r">{formatCurrent(entry.summary.designCurrentA)}</td>
+                    <td className="pd-r">{formatKilowatt(entry.cumulatedDemandPowerKw)}</td>
+                  </tr>
+                );
+              })}
+            </tbody>
+            <tfoot>
+              <tr>
+                <td colSpan={7}>Summe aller Verteiler (ohne übergeordneten GZF)</td>
+                <td className="pd-r">{formatKilowatt(sum((entry) => entry.summary.installedPowerKw))}</td>
+                <td className="pd-r">{formatKilowatt(sum((entry) => entry.summary.devicePowerKw))}</td>
+                <td />
+                <td className="pd-r">{formatKilowatt(sum((entry) => entry.summary.demandPowerKw))}</td>
+                <td />
+                <td />
+              </tr>
+            </tfoot>
+          </table>
+          <p className="pd-note">
+            <strong>Vorläufig:</strong> „Gespeist von“ ist noch ein Freitextfeld. Struktur und
+            „Σ inkl. unterlagert“ werden nur über gleichlautende Verteilernummern bzw.
+            -bezeichnungen zugeordnet und einfach addiert (kein übergeordneter GZF). Die fachliche
+            Verknüpfung und Summierung folgt.
+          </p>
+          <p className="pd-legend">
+            P<sub>inst</sub> = Anzahl × Leistung je Stück · P<sub>Geräte</sub> = mit Geräte-GZF ·
+            P<sub>gl</sub> = mit Verteiler-GZF · I<sub>B</sub> = S / (√3 · {project.threePhaseVoltageV} V),
+            S aus cos φ je Gerätezeile
+          </p>
+        </div>
+      </div>
+      <SheetFooter project={project} stand={stand} />
+    </section>
+  );
+}
+
+const planColumnCount = 11;
+
+function roomLabel(row: CircuitTreeDeviceRowDto) {
+  return row.roomNumberSnapshot
+    ? `${row.roomNumberSnapshot} ${row.roomNameSnapshot ?? ""}`.trim()
+    : "–";
+}
+
+function ComponentRow({ component }: { component: CircuitTreeComponentDto }) {
+  return (
+    <tr className="pd-component">
+      <td className="pd-bmk">{component.equipmentIdentifier}</td>
+      <td colSpan={6}>{component.name}</td>
+      <td>{formatProtectionDevice(component.protectionDevice) ?? "–"}</td>
+      <td colSpan={3} />
+    </tr>
+  );
+}
+
+function CircuitRows({ circuit }: { circuit: CircuitTreeCircuitDto }) {
+  const rows = circuit.deviceRows;
+  const circuitCells = (
+    <>
+      <td>{formatProtectionDevice(circuit.protectionDevice) ?? <Open />}</td>
+      <td>{formatCircuitCable(circuit) ?? (circuit.isReserve ? "–" : <Open />)}</td>
+      <td className="pd-r">
+        {circuit.cableLength ?? (circuit.isReserve ? "–" : <Open />)}
+      </td>
+      <td>{circuit.remark ?? ""}</td>
+    </>
+  );
+  if (rows.length === 0) {
+    return (
+      <tr className="pd-circuit pd-reserve">
+        <td className="pd-bmk">{circuit.equipmentIdentifier}</td>
+        <td>{circuit.displayName ?? "Reserve"}</td>
+        <td>–</td>
+        <td /><td /><td />
+        <td className="pd-r">–</td>
+        {circuitCells}
+      </tr>
+    );
+  }
+  if (rows.length === 1) {
+    const row = rows[0];
+    const title = circuit.displayName ?? row.displayName;
+    return (
+      <tr className="pd-circuit">
+        <td className="pd-bmk">{circuit.equipmentIdentifier}</td>
+        <td>
+          {title}
+          {title !== row.displayName ? (
+            <span className="pd-sub"> · {row.displayName}</span>
+          ) : null}
+        </td>
+        <td>{roomLabel(row)}</td>
+        <td className="pd-r">{row.quantity}</td>
+        <td className="pd-r">{formatUnitPower(row.powerPerUnit)}</td>
+        <td className="pd-r">{formatFactor(row.simultaneityFactor)}</td>
+        <td className="pd-r"><strong>{formatKilowatt(circuit.circuitTotalPower)}</strong></td>
+        {circuitCells}
+      </tr>
+    );
+  }
+  return (
+    <>
+      <tr className="pd-circuit">
+        <td className="pd-bmk">{circuit.equipmentIdentifier}</td>
+        <td>{circuit.displayName ?? ""}</td>
+        <td /><td /><td /><td />
+        <td className="pd-r"><strong>{formatKilowatt(circuit.circuitTotalPower)}</strong></td>
+        {circuitCells}
+      </tr>
+      {rows.map((row) => (
+        <tr className="pd-device" key={row.id}>
+          <td />
+          <td>{row.displayName}</td>
+          <td>{roomLabel(row)}</td>
+          <td className="pd-r">{row.quantity}</td>
+          <td className="pd-r">{formatUnitPower(row.powerPerUnit)}</td>
+          <td className="pd-r">{formatFactor(row.simultaneityFactor)}</td>
+          <td className="pd-r">{formatKilowatt(row.rowTotalPower)}</td>
+          <td colSpan={4} />
+        </tr>
+      ))}
+    </>
+  );
+}
+
+function BoardPlanSheet({
+  entry,
+  project,
+  logoSrc,
+  stand,
+}: {
+  entry: PrintBoardHierarchyEntry;
+  project: ProjectDto;
+  logoSrc: string | null;
+  stand: string;
+}) {
+  const { summary } = entry;
+  const { board, tree } = summary;
+  return (
+    <section className="pd-sheet pd-landscape">
+      <table className="pd-grid pd-plan">
+        {/* The title block lives in <thead> so it repeats on every printed page. */}
+        <thead>
+          <tr>
+            <th className="pd-tb-cell" colSpan={planColumnCount}>
+              <TitleBlock
+                kicker="Verteilerplan"
+                logoSrc={logoSrc}
+                name={board.name}
+                number={board.boardNumber}
+                project={project}
+                rows={[
+                  ["Örtlichkeit", [board.location, summary.floorName].filter(Boolean).join(" · ") || "–"],
+                  ["Netzart", board.supplyType ?? "–"],
+                  ["Gespeist von", board.fedFrom ?? "–"],
+                  [
+                    <>P<sub>gl</sub></>,
+                    <>
+                      {formatKilowatt(summary.demandPowerKw)} kW · I<sub>B</sub>{" "}
+                      {formatCurrent(summary.designCurrentA)} A
+                    </>,
+                  ],
+                ]}
+                stand={stand}
+              />
+            </th>
+          </tr>
+          <tr className="pd-head">
+            <th>SK-Nr.</th><th>Bezeichnung</th><th>Raum</th>
+            <th className="pd-r">Anz.</th>
+            <th className="pd-r">P/Stk.<br />[kW]</th>
+            <th className="pd-r">GZF</th>
+            <th className="pd-r">P<br />[kW]</th>
+            <th>Schutz</th><th>Kabel</th>
+            <th className="pd-r">Länge<br />[m]</th>
+            <th>Bemerkung</th>
+          </tr>
+        </thead>
+        <tbody>
+          {tree.headerComponents.map((component) => (
+            <ComponentRow component={component} key={component.id} />
+          ))}
+          {tree.sections.map((section) => (
+            <SectionRows key={section.id} section={section} />
+          ))}
+          {tree.footerComponents.map((component) => (
+            <ComponentRow component={component} key={component.id} />
+          ))}
+        </tbody>
+        <tfoot>
+          <tr>
+            <td />
+            <td colSpan={5}>
+              Summe Verteiler (P<sub>inst</sub> {formatKilowatt(summary.installedPowerKw)} kW)
+            </td>
+            <td className="pd-r">{formatKilowatt(summary.devicePowerKw)}</td>
+            <td colSpan={4} />
+          </tr>
+          <tr>
+            <td />
+            <td colSpan={5}>Gleichzeitigkeitsfaktor Verteiler</td>
+            <td className="pd-r">{formatFactor(summary.simultaneityFactor)}</td>
+            <td colSpan={4} />
+          </tr>
+          <tr className="pd-grand">
+            <td />
+            <td colSpan={5}>Gleichzeitige Leistung P<sub>gl</sub></td>
+            <td className="pd-r">{formatKilowatt(summary.demandPowerKw)}</td>
+            <td colSpan={4}>I<sub>B</sub> ≈ {formatCurrent(summary.designCurrentA)} A</td>
+          </tr>
+        </tfoot>
+      </table>
+      <SheetFooter project={project} stand={stand} />
+    </section>
+  );
+}
+
+function SectionRows({
+  section,
+}: {
+  section: PrintBoardHierarchyEntry["summary"]["tree"]["sections"][number];
+}) {
+  return (
+    <>
+      <tr className="pd-group">
+        <td className="pd-bmk">{section.prefix}</td>
+        <td colSpan={planColumnCount - 1}>{section.displayName}</td>
+      </tr>
+      {section.components.map((component) => (
+        <ComponentRow component={component} key={component.id} />
+      ))}
+      {section.circuits.map((circuit) => (
+        <CircuitRows circuit={circuit} key={circuit.id} />
+      ))}
+      <tr className="pd-subtotal">
+        <td />
+        <td colSpan={5}>Summe {section.displayName}</td>
+        <td className="pd-r">{formatKilowatt(section.sectionTotalPower)}</td>
+        <td colSpan={4} />
+      </tr>
+    </>
+  );
+}
+
+export function PrintDocument({
+  project,
+  entries,
+  namedSnapshots,
+  logoSrc,
+  printedAt,
+}: PrintDocumentProps) {
+  const stand = dateFormat.format(printedAt);
+  return (
+    <div className="pd-pages">
+      <CoverSheet
+        entries={entries}
+        logoSrc={logoSrc}
+        namedSnapshots={namedSnapshots}
+        project={project}
+        stand={stand}
+      />
+      <OverviewSheet entries={entries} logoSrc={logoSrc} project={project} stand={stand} />
+      {entries.map((entry) => (
+        <BoardPlanSheet
+          entry={entry}
+          key={entry.summary.board.id}
+          logoSrc={logoSrc}
+          project={project}
+          stand={stand}
+        />
+      ))}
+    </div>
+  );
+}
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 2bce5d9..a964b74 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -172,7 +172,14 @@ export interface ProjectCommandResultDto {
   history: ProjectHistoryStateDto;
 }
 
-export interface DistributionBoardDto {
+export interface DistributionBoardInfoDto {
+  boardNumber: string | null;
+  location: string | null;
+  fedFrom: string | null;
+  remark: string | null;
+}
+
+export interface DistributionBoardDto extends DistributionBoardInfoDto {
   id: string;
   projectId: string;
   name: string;
@@ -181,6 +188,13 @@ export interface DistributionBoardDto {
   simultaneityFactor: number;
 }
 
+export interface DocumentLogoMetadataDto {
+  mimeType: string;
+  fileName: string | null;
+  sizeBytes: number;
+  updatedAtIso: string;
+}
+
 export interface DistributionBoardCommandResultDto
   extends ProjectCommandResultDto {
   distributionBoard: DistributionBoardDto;
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index 5250922..e5be802 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -8,6 +8,8 @@ import type {
   DistributionBoardCommandResultDto,
   DistributionBoardCopyCommandResultDto,
   DistributionBoardDeleteCommandResultDto,
+  DistributionBoardInfoDto,
+  DocumentLogoMetadataDto,
   FloorDto,
   GlobalDeviceDto,
   ProjectCommandDto,
@@ -329,7 +331,7 @@ export function updateDistributionBoard(
     floorId: string | null;
     supplyType: NonNullable<DistributionBoardDto["supplyType"]>;
     simultaneityFactor: number;
-  },
+  } & Partial<DistributionBoardInfoDto>,
   expectedRevision: number
 ) {
   return request<DistributionBoardCommandResultDto>(
@@ -341,6 +343,34 @@ export function updateDistributionBoard(
   );
 }
 
+export const documentLogoUrl = "/api/document-branding/logo";
+
+export function getDocumentBranding() {
+  return request<{ logo: DocumentLogoMetadataDto | null }>(
+    "/api/document-branding"
+  );
+}
+
+export async function uploadDocumentLogo(file: File) {
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 0x8000) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + 0x8000));
+  }
+  return request<{ logo: DocumentLogoMetadataDto }>(documentLogoUrl, {
+    method: "PUT",
+    body: JSON.stringify({
+      fileName: file.name,
+      mimeType: file.type,
+      contentBase64: btoa(binary),
+    }),
+  });
+}
+
+export function deleteDocumentLogo() {
+  return request<void>(documentLogoUrl, { method: "DELETE" });
+}
+
 export function getExternalCsvConfiguration(projectId: string) {
   return request<{ configuration: ExternalCsvConfigurationSnapshotDto | null }>(
     `/api/projects/${projectId}/external-csv/configuration`
diff --git a/src/server/composition/application-repositories.ts b/src/server/composition/application-repositories.ts
index a3a9457..944c843 100644
--- a/src/server/composition/application-repositories.ts
+++ b/src/server/composition/application-repositories.ts
@@ -13,6 +13,7 @@ import { ProjectRepository } from "../../db/repositories/project.repository.js";
 import { RoomRepository } from "../../db/repositories/room.repository.js";
 import { ExternalCsvConfigurationRepository } from "../../db/repositories/external-csv-configuration.repository.js";
 import { ExternalModelStateRepository } from "../../db/repositories/external-model-state.repository.js";
+import { DocumentBrandingRepository } from "../../db/repositories/document-branding.repository.js";
 
 export const circuitDeviceRowRepository =
   new CircuitDeviceRowRepository(db);
@@ -33,3 +34,4 @@ export const roomRepository = new RoomRepository(db);
 export const externalCsvConfigurationRepository =
   new ExternalCsvConfigurationRepository(db);
 export const externalModelStateRepository = new ExternalModelStateRepository(db);
+export const documentBrandingRepository = new DocumentBrandingRepository(db);
diff --git a/src/server/controllers/distribution-board.controller.ts b/src/server/controllers/distribution-board.controller.ts
index 1ca8b1b..9ea713a 100644
--- a/src/server/controllers/distribution-board.controller.ts
+++ b/src/server/controllers/distribution-board.controller.ts
@@ -9,6 +9,7 @@ import {
   createDistributionBoardInsertSubtreeProjectCommand,
 } from "../../domain/models/distribution-board-subtree-project-command.model.js";
 import { cloneDistributionBoardSubtree } from "../../domain/models/distribution-board-subtree-snapshot.model.js";
+import { distributionBoardInfoFields } from "../../shared/constants/distribution-board.js";
 import {
   copyDistributionBoardSchema,
   createDistributionBoardSchema,
@@ -64,6 +65,10 @@ export async function createDistributionBoard(req: Request, res: Response) {
       distributionBoard: {
         ...structure.distributionBoard,
         simultaneityFactor: 1,
+        boardNumber: null,
+        location: null,
+        fedFrom: null,
+        remark: null,
       },
     });
   } catch (error) {
@@ -86,6 +91,13 @@ export async function updateDistributionBoard(
   if (!parsed.success) {
     return res.status(400).json({ error: parsed.error.flatten() });
   }
+  // Info fields are optional in the request; only submitted fields become
+  // part of the command and therefore of its inverse.
+  const infoPatch = Object.fromEntries(
+    distributionBoardInfoFields
+      .filter((field) => parsed.data[field] !== undefined)
+      .map((field) => [field, parsed.data[field]])
+  );
   try {
     const result = projectCommandService.executeUser({
       projectId,
@@ -97,6 +109,7 @@ export async function updateDistributionBoard(
           floorId: parsed.data.floorId,
           supplyType: parsed.data.supplyType,
           simultaneityFactor: parsed.data.simultaneityFactor,
+          ...infoPatch,
         }
       ),
     });
diff --git a/src/server/controllers/document-branding.controller.ts b/src/server/controllers/document-branding.controller.ts
new file mode 100644
index 0000000..eda6ce5
--- /dev/null
+++ b/src/server/controllers/document-branding.controller.ts
@@ -0,0 +1,84 @@
+import type { Request, Response } from "express";
+import type { DocumentBrandingAsset } from "../../db/schema/document-branding-assets.js";
+import {
+  maxDocumentLogoBytes,
+  uploadDocumentLogoSchema,
+  type DocumentLogoMimeType,
+} from "../../shared/validation/document-branding.schemas.js";
+import { documentBrandingRepository } from "../composition/application-repositories.js";
+
+const logoKey = "logo";
+
+export function getDocumentBrandingHandler(_req: Request, res: Response) {
+  const logo = documentBrandingRepository.get(logoKey);
+  return res.json({ logo: logo ? toLogoMetadata(logo) : null });
+}
+
+export function getDocumentLogoHandler(_req: Request, res: Response) {
+  const logo = documentBrandingRepository.get(logoKey);
+  if (!logo) {
+    return res.status(404).json({ error: "No logo uploaded" });
+  }
+  res.setHeader("Content-Type", logo.mimeType);
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("X-Content-Type-Options", "nosniff");
+  // SVG uploads are rendered through <img> only; forbid script execution if
+  // the file is ever opened directly.
+  res.setHeader(
+    "Content-Security-Policy",
+    "default-src 'none'; style-src 'unsafe-inline'; img-src data:"
+  );
+  return res.send(logo.data);
+}
+
+export function uploadDocumentLogoHandler(req: Request, res: Response) {
+  const parsed = uploadDocumentLogoSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+  const data = Buffer.from(parsed.data.contentBase64, "base64");
+  if (data.length === 0 || data.length > maxDocumentLogoBytes) {
+    return res
+      .status(400)
+      .json({ error: "Das Logo darf höchstens 2 MB groß sein." });
+  }
+  if (!matchesMimeType(data, parsed.data.mimeType)) {
+    return res.status(400).json({
+      error: "Der Dateiinhalt passt nicht zum angegebenen Bildformat.",
+    });
+  }
+  const logo = documentBrandingRepository.upsert({
+    key: logoKey,
+    mimeType: parsed.data.mimeType,
+    fileName: parsed.data.fileName,
+    data,
+  });
+  return res.json({ logo: toLogoMetadata(logo) });
+}
+
+export function deleteDocumentLogoHandler(_req: Request, res: Response) {
+  documentBrandingRepository.delete(logoKey);
+  return res.status(204).end();
+}
+
+function toLogoMetadata(logo: DocumentBrandingAsset) {
+  return {
+    mimeType: logo.mimeType,
+    fileName: logo.fileName,
+    sizeBytes: logo.data.length,
+    updatedAtIso: logo.updatedAt.toISOString(),
+  };
+}
+
+function matchesMimeType(data: Buffer, mimeType: DocumentLogoMimeType) {
+  if (mimeType === "image/png") {
+    return data
+      .subarray(0, 8)
+      .equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
+  }
+  if (mimeType === "image/jpeg") {
+    return data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff;
+  }
+  const head = data.subarray(0, 2048).toString("utf8").toLowerCase();
+  return head.includes("<svg");
+}
diff --git a/src/server/index.ts b/src/server/index.ts
index 1f5c9b2..7d4517d 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -1,6 +1,7 @@
 import express from "express";
 import { globalDeviceRouter } from "./routes/global-device.routes.js";
 import { projectDeviceRouter } from "./routes/project-device.routes.js";
+import { documentBrandingRouter } from "./routes/document-branding.routes.js";
 import { projectRouter } from "./routes/project.routes.js";
 import { errorMiddleware } from "./middleware/error.middleware.js";
 import { createLogger, toErrorMeta } from "../shared/logging/logger.js";
@@ -51,6 +52,7 @@ app.get("/health", (_req, res) => {
 app.use("/api/projects", projectRouter);
 app.use("/api/global-devices", globalDeviceRouter);
 app.use("/api/project-devices", projectDeviceRouter);
+app.use("/api/document-branding", documentBrandingRouter);
 
 app.use(errorMiddleware);
 
diff --git a/src/server/routes/document-branding.routes.ts b/src/server/routes/document-branding.routes.ts
new file mode 100644
index 0000000..b12581b
--- /dev/null
+++ b/src/server/routes/document-branding.routes.ts
@@ -0,0 +1,9 @@
+import express from "express";
+import * as documentBrandingController from "../controllers/document-branding.controller.js";
+
+export const documentBrandingRouter = express.Router();
+
+documentBrandingRouter.get("/", documentBrandingController.getDocumentBrandingHandler);
+documentBrandingRouter.get("/logo", documentBrandingController.getDocumentLogoHandler);
+documentBrandingRouter.put("/logo", documentBrandingController.uploadDocumentLogoHandler);
+documentBrandingRouter.delete("/logo", documentBrandingController.deleteDocumentLogoHandler);
diff --git a/src/shared/constants/distribution-board.ts b/src/shared/constants/distribution-board.ts
index c69ecc1..54ea475 100644
--- a/src/shared/constants/distribution-board.ts
+++ b/src/shared/constants/distribution-board.ts
@@ -24,3 +24,44 @@ export const distributionBoardSupplyTypeLabels: Record<
   MSR: "MSR – Mess-, Steuerungs- und Regelungstechnik",
   SiBe: "SiBe – Sicherheitsbeleuchtung",
 };
+
+/**
+ * Planner-owned descriptive distribution-board data shown on the board info
+ * card and in the print view. The values are local planning values. A later
+ * Revit/CSV round-trip may prefill them from mapped model parameters, but only
+ * through a previewed, explicitly confirmed project command (see
+ * docs/spec/revit-csv-integration-requirements.md); imports never overwrite
+ * them silently.
+ *
+ * `fedFrom` is intentionally free text for now. How a board is logically
+ * linked to its upstream board or feeding circuit is not decided yet.
+ */
+export const distributionBoardInfoFields = [
+  "boardNumber",
+  "location",
+  "fedFrom",
+  "remark",
+] as const;
+
+export type DistributionBoardInfoField =
+  (typeof distributionBoardInfoFields)[number];
+
+export const distributionBoardInfoFieldLabels: Record<
+  DistributionBoardInfoField,
+  string
+> = {
+  boardNumber: "Verteilernummer",
+  location: "Örtlichkeit",
+  fedFrom: "Gespeist von",
+  remark: "Bemerkung",
+};
+
+export const distributionBoardInfoFieldMaxLengths: Record<
+  DistributionBoardInfoField,
+  number
+> = {
+  boardNumber: 50,
+  location: 200,
+  fedFrom: 200,
+  remark: 2000,
+};
diff --git a/src/shared/validation/document-branding.schemas.ts b/src/shared/validation/document-branding.schemas.ts
new file mode 100644
index 0000000..3d40572
--- /dev/null
+++ b/src/shared/validation/document-branding.schemas.ts
@@ -0,0 +1,25 @@
+import { z } from "zod";
+
+export const documentLogoMimeTypes = [
+  "image/png",
+  "image/jpeg",
+  "image/svg+xml",
+] as const;
+
+export type DocumentLogoMimeType = (typeof documentLogoMimeTypes)[number];
+
+export const maxDocumentLogoBytes = 2 * 1024 * 1024;
+
+export const uploadDocumentLogoSchema = z
+  .object({
+    fileName: z.string().trim().min(1).max(200),
+    mimeType: z.enum(documentLogoMimeTypes),
+    contentBase64: z
+      .string()
+      .min(1)
+      // Base64 expands by 4/3; the decoded size is checked again server-side.
+      .max(Math.ceil((maxDocumentLogoBytes * 4) / 3) + 4),
+  })
+  .strict();
+
+export type UploadDocumentLogoInput = z.infer<typeof uploadDocumentLogoSchema>;
diff --git a/src/shared/validation/project-structure.schemas.ts b/src/shared/validation/project-structure.schemas.ts
index 2bb1c77..4dd4c3c 100644
--- a/src/shared/validation/project-structure.schemas.ts
+++ b/src/shared/validation/project-structure.schemas.ts
@@ -1,5 +1,9 @@
 import { z } from "zod";
-import { distributionBoardSupplyTypes } from "../constants/distribution-board.js";
+import {
+  distributionBoardInfoFieldMaxLengths,
+  distributionBoardSupplyTypes,
+  type DistributionBoardInfoField,
+} from "../constants/distribution-board.js";
 import { expectedProjectRevisionSchema } from "./project-command.schemas.js";
 
 export const createProjectSchema = z.object({
@@ -42,12 +46,27 @@ export const createDistributionBoardSchema = z
   })
   .strict();
 
+// Empty info text is stored as null so that "not entered" has one
+// representation in the database, snapshots and print view.
+const distributionBoardInfoValueSchema = (field: DistributionBoardInfoField) =>
+  z
+    .string()
+    .trim()
+    .max(distributionBoardInfoFieldMaxLengths[field])
+    .nullable()
+    .transform((value) => (value ? value : null))
+    .optional();
+
 export const updateDistributionBoardSchema = z
   .object({
     expectedRevision: expectedProjectRevisionSchema,
     floorId: z.string().trim().min(1).nullable(),
     supplyType: z.enum(distributionBoardSupplyTypes),
     simultaneityFactor: z.number().finite().min(0).max(1),
+    boardNumber: distributionBoardInfoValueSchema("boardNumber"),
+    location: distributionBoardInfoValueSchema("location"),
+    fedFrom: distributionBoardInfoValueSchema("fedFrom"),
+    remark: distributionBoardInfoValueSchema("remark"),
   })
   .strict();
 
diff --git a/tests/distribution-board-structure-project-command.repository.test.ts b/tests/distribution-board-structure-project-command.repository.test.ts
index 685ffe8..f829edf 100644
--- a/tests/distribution-board-structure-project-command.repository.test.ts
+++ b/tests/distribution-board-structure-project-command.repository.test.ts
@@ -387,6 +387,110 @@ describe("distribution-board structure project command", () => {
     }
   });
 
+  it("updates the info card fields with persisted undo", () => {
+    const context = createTestDatabase();
+    try {
+      const repository =
+        new DistributionBoardStructureProjectCommandRepository(
+          context.db
+        );
+      const structure = createDistributionBoardStructureSnapshot(
+        "project-1",
+        "UV-EG",
+        { floorId: null, supplyType: "AV" }
+      );
+      const insert = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createDistributionBoardInsertProjectCommand(structure),
+      });
+      const readInfo = () =>
+        context.db
+          .select({
+            boardNumber: distributionBoards.boardNumber,
+            location: distributionBoards.location,
+            fedFrom: distributionBoards.fedFrom,
+            remark: distributionBoards.remark,
+          })
+          .from(distributionBoards)
+          .get();
+      assert.deepEqual(readInfo(), {
+        boardNumber: null,
+        location: null,
+        fedFrom: null,
+        remark: null,
+      });
+
+      const forward = repository.executeUpdate({
+        projectId: "project-1",
+        expectedRevision: 1,
+        source: "user",
+        command: createDistributionBoardUpdateProjectCommand(
+          structure.distributionBoard.id,
+          {
+            boardNumber: "UV 0.1",
+            location: "Raum 003 Technik",
+            fedFrom: "HAK",
+          }
+        ),
+      });
+      assert.deepEqual(readInfo(), {
+        boardNumber: "UV 0.1",
+        location: "Raum 003 Technik",
+        fedFrom: "HAK",
+        remark: null,
+      });
+      assert.deepEqual(
+        forward.inverse.payload.changes.map((change) => change.field),
+        ["boardNumber", "location", "fedFrom"]
+      );
+
+      // A board with info values is no longer the unchanged empty setup.
+      assert.throws(
+        () =>
+          repository.execute({
+            projectId: "project-1",
+            expectedRevision: 2,
+            source: "user",
+            command: insert.inverse,
+          }),
+        /changed before deletion/
+      );
+
+      const undoStep = new ProjectHistoryRepository(
+        context.db
+      ).getNextCommand("project-1", "undo");
+      assert.ok(undoStep);
+      repository.executeUpdate({
+        projectId: "project-1",
+        expectedRevision: 2,
+        source: "undo",
+        historyTargetChangeSetId: undoStep.changeSetId,
+        command: forward.inverse,
+      });
+      assert.deepEqual(readInfo(), {
+        boardNumber: null,
+        location: null,
+        fedFrom: null,
+        remark: null,
+      });
+
+      for (const value of ["", " UV 1", "x".repeat(51)]) {
+        assert.throws(
+          () =>
+            createDistributionBoardUpdateProjectCommand(
+              structure.distributionBoard.id,
+              { boardNumber: value }
+            ),
+          /boardNumber/
+        );
+      }
+    } finally {
+      context.close();
+    }
+  });
+
   it("sends distribution-board writes to the revision-safe API", async () => {
     const requests: Array<{ url: string; method: string; body: unknown }> = [];
     const originalFetch = globalThis.fetch;
diff --git a/tests/distribution-board-subtree-project-command.repository.test.ts b/tests/distribution-board-subtree-project-command.repository.test.ts
index 0266e4f..7975f2b 100644
--- a/tests/distribution-board-subtree-project-command.repository.test.ts
+++ b/tests/distribution-board-subtree-project-command.repository.test.ts
@@ -192,6 +192,67 @@ describe("distribution-board subtree project command", () => {
     }
   });
 
+  it("copies board info values and accepts snapshots stored before they existed", () => {
+    const context = createTestDatabase();
+    try {
+      const board = createPopulatedBoard(context);
+      context.db
+        .update(distributionBoards)
+        .set({ boardNumber: "UV 1.1", location: "Technik" })
+        .where(eq(distributionBoards.id, board.id))
+        .run();
+      const repository =
+        new DistributionBoardSubtreeProjectCommandRepository(context.db);
+      const withInfo = repository.capture("project-1", board.id);
+      const clone = cloneDistributionBoardSubtree(withInfo, "UV 1 Kopie");
+      assert.equal(clone.distributionBoard.boardNumber, "UV 1.1");
+      assert.equal(clone.distributionBoard.location, "Technik");
+
+      context.db
+        .update(distributionBoards)
+        .set({ boardNumber: null, location: null })
+        .where(eq(distributionBoards.id, board.id))
+        .run();
+      const legacySnapshot = structuredClone(
+        repository.capture("project-1", board.id)
+      );
+      const legacyBoard = legacySnapshot.distributionBoard as Record<
+        string,
+        unknown
+      >;
+      delete legacyBoard.boardNumber;
+      delete legacyBoard.location;
+      delete legacyBoard.fedFrom;
+      delete legacyBoard.remark;
+
+      const deleted = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        description: "Verteilung löschen",
+        command: createDistributionBoardDeleteSubtreeProjectCommand(
+          legacySnapshot
+        ),
+      });
+      assert.throws(
+        () => repository.capture("project-1", board.id),
+        /not found/
+      );
+      repository.execute({
+        projectId: "project-1",
+        expectedRevision: 1,
+        source: "user",
+        command: deleted.inverse,
+      });
+      assert.equal(
+        repository.capture("project-1", board.id).distributionBoard.fedFrom,
+        null
+      );
+    } finally {
+      context.close();
+    }
+  });
+
   it("rejects changed deletion snapshots without partial writes", () => {
     const context = createTestDatabase();
     try {
diff --git a/tests/print-document-model.test.ts b/tests/print-document-model.test.ts
new file mode 100644
index 0000000..a5165e8
--- /dev/null
+++ b/tests/print-document-model.test.ts
@@ -0,0 +1,176 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  buildPreliminaryBoardHierarchy,
+  formatProtectionDevice,
+  summarizePrintBoard,
+} from "../src/frontend/print/print-document-model.js";
+import type {
+  CircuitTreeResponseDto,
+  DistributionBoardDto,
+} from "../src/frontend/types.js";
+
+function board(
+  id: string,
+  info: Partial<DistributionBoardDto> = {}
+): DistributionBoardDto {
+  return {
+    id,
+    projectId: "project-1",
+    name: id,
+    floorId: null,
+    supplyType: "AV",
+    simultaneityFactor: 1,
+    boardNumber: null,
+    location: null,
+    fedFrom: null,
+    remark: null,
+    ...info,
+  };
+}
+
+function tree(
+  rows: Array<{
+    quantity: number;
+    powerPerUnit: number;
+    simultaneityFactor: number;
+    cosPhi?: number;
+  }>,
+  boardSimultaneityFactor = 1
+): CircuitTreeResponseDto {
+  const deviceRows = rows.map((row, index) => ({
+    id: `row-${index}`,
+    sortOrder: index,
+    name: "Gerät",
+    displayName: "Gerät",
+    manualQuantity: row.quantity,
+    rowTotalPower: row.quantity * row.powerPerUnit * row.simultaneityFactor,
+    ...row,
+  }));
+  const total = deviceRows.reduce((sum, row) => sum + row.rowTotalPower, 0);
+  return {
+    circuitListId: "list",
+    currentRevision: 1,
+    singlePhaseVoltageV: 230,
+    threePhaseVoltageV: 400,
+    distributionBoardSimultaneityFactor: boardSimultaneityFactor,
+    distributionBoardTotalPower: total,
+    distributionBoardTotalPowerWithSimultaneityFactor:
+      total * boardSimultaneityFactor,
+    headerComponents: [],
+    footerComponents: [],
+    sections: [
+      {
+        id: "section",
+        key: "single_phase",
+        displayName: "1-phasig 1",
+        prefix: "-2F1.",
+        sortOrder: 1,
+        sectionTotalPower: total,
+        components: [],
+        circuits: [
+          {
+            id: "circuit",
+            circuitListId: "list",
+            sectionId: "section",
+            equipmentIdentifier: "-2F1.1",
+            sortOrder: 1,
+            isReserve: false,
+            circuitTotalPower: total,
+            deviceRows,
+          },
+        ],
+      },
+    ],
+  };
+}
+
+function summary(
+  id: string,
+  info: Partial<DistributionBoardDto>,
+  demandKw: number
+) {
+  return summarizePrintBoard({
+    board: board(id, info),
+    circuitListId: id,
+    floorName: null,
+    tree: tree([{ quantity: 1, powerPerUnit: demandKw, simultaneityFactor: 1 }]),
+  });
+}
+
+describe("print document model", () => {
+  it("derives installed, device and demand power and the design current", () => {
+    const result = summarizePrintBoard({
+      board: board("uv"),
+      circuitListId: "uv",
+      floorName: "EG",
+      tree: tree(
+        [
+          { quantity: 4, powerPerUnit: 2, simultaneityFactor: 0.5, cosPhi: 0.8 },
+          { quantity: 1, powerPerUnit: 6, simultaneityFactor: 1 },
+        ],
+        0.5
+      ),
+    });
+    assert.equal(result.circuitCount, 1);
+    assert.equal(result.installedPowerKw, 14);
+    assert.equal(result.devicePowerKw, 10);
+    assert.equal(result.demandPowerKw, 5);
+    // S = (4 / 0.8 + 6 / 1) × 0.5 = 5.5 kVA → I = 5500 / (√3 · 400)
+    assert.ok(Math.abs(result.designCurrentA - 5500 / (Math.sqrt(3) * 400)) < 1e-9);
+  });
+
+  it("nests boards by matching free-text feed and sums downstream demand", () => {
+    const entries = buildPreliminaryBoardHierarchy([
+      summary("hv", { boardNumber: "HV 0.1", fedFrom: "HAK" }, 10),
+      summary("uv-a", { boardNumber: "UV 1.1", fedFrom: " hv 0.1 " }, 4),
+      summary("uv-b", { boardNumber: "UV 1.2", fedFrom: "UV 1.1" }, 2),
+      summary("uv-c", { name: "UV-C", fedFrom: "unbekannt" }, 1),
+    ]);
+    assert.deepEqual(
+      entries.map((entry) => [
+        entry.summary.board.id,
+        entry.depth,
+        entry.parentBoardId,
+        entry.cumulatedDemandPowerKw,
+      ]),
+      [
+        ["hv", 0, null, 16],
+        ["uv-a", 1, "hv", 6],
+        ["uv-b", 2, "uv-a", 2],
+        ["uv-c", 0, null, 1],
+      ]
+    );
+  });
+
+  it("keeps boards with cyclic feed texts at the top level", () => {
+    const entries = buildPreliminaryBoardHierarchy([
+      summary("a", { boardNumber: "A", fedFrom: "B" }, 1),
+      summary("b", { boardNumber: "B", fedFrom: "A" }, 1),
+    ]);
+    assert.equal(entries.length, 2);
+    assert.ok(entries.some((entry) => entry.parentBoardId === null));
+    assert.equal(
+      entries.reduce((sum, entry) => sum + (entry.depth === 0 ? entry.cumulatedDemandPowerKw : 0), 0),
+      2
+    );
+  });
+
+  it("formats protection devices for the plan table", () => {
+    assert.equal(
+      formatProtectionDevice({ type: "LS", ratedCurrentA: 16, tripCharacteristic: "B" }),
+      "LS B 16 A"
+    );
+    assert.equal(
+      formatProtectionDevice({
+        type: "FI_LS",
+        ratedCurrentA: 16,
+        tripCharacteristic: "B",
+        rcdType: "A",
+        ratedResidualCurrentMa: 30,
+      }),
+      "FI/LS B 16 A, 30 mA Typ A"
+    );
+    assert.equal(formatProtectionDevice(undefined), null);
+  });
+});
diff --git a/tests/project-snapshot.repository.test.ts b/tests/project-snapshot.repository.test.ts
index b062c68..449864a 100644
--- a/tests/project-snapshot.repository.test.ts
+++ b/tests/project-snapshot.repository.test.ts
@@ -377,6 +377,67 @@ describe("project snapshot repository", () => {
       context.close();
     }
   });
+
+  it("restores snapshots stored with an older supported schema version", () => {
+    const context = createTestDatabase();
+    try {
+      const repository = new ProjectSnapshotRepository(context.db);
+      const snapshot = repository.createNamed({
+        projectId: "project-1",
+        expectedRevision: 0,
+        name: "Vor dem Update",
+      });
+      assert.ok(snapshot);
+      // Rewrite the stored payload into the previous (version 5) shape, as it
+      // exists for snapshots created before the current version.
+      const payload = JSON.parse(
+        context.db
+          .select({ payloadJson: projectSnapshots.payloadJson })
+          .from(projectSnapshots)
+          .where(eq(projectSnapshots.id, snapshot.id))
+          .get()!.payloadJson
+      ) as {
+        schemaVersion: number;
+        project: Record<string, unknown>;
+        distributionBoards: Array<Record<string, unknown>>;
+      };
+      payload.schemaVersion = 5;
+      for (const field of ["siteAddress", "workStage", "projectLead", "projectEditor"]) {
+        delete payload.project[field];
+      }
+      for (const board of payload.distributionBoards) {
+        for (const field of ["boardNumber", "location", "fedFrom", "remark"]) {
+          delete board[field];
+        }
+      }
+      const payloadJson = JSON.stringify(payload);
+      context.db
+        .update(projectSnapshots)
+        .set({
+          schemaVersion: 5,
+          payloadJson,
+          payloadSha256: crypto
+            .createHash("sha256")
+            .update(payloadJson)
+            .digest("hex"),
+        })
+        .where(eq(projectSnapshots.id, snapshot.id))
+        .run();
+
+      const prepared = repository.prepareRestore("project-1", snapshot.id);
+      assert.ok(prepared);
+      const targetState = prepared.command.payload.targetState;
+      assert.equal(targetState.schemaVersion, projectStateSnapshotSchemaVersion);
+      assert.ok(targetState.distributionBoards.length > 0);
+      assert.ok(
+        targetState.distributionBoards.every(
+          (board) => board.boardNumber === null && board.fedFrom === null
+        )
+      );
+    } finally {
+      context.close();
+    }
+  });
 });
 
 describe("portable project transfer", () => {
diff --git a/tests/project-state-snapshot.test.ts b/tests/project-state-snapshot.test.ts
index 878eeca..8b84fdb 100644
--- a/tests/project-state-snapshot.test.ts
+++ b/tests/project-state-snapshot.test.ts
@@ -61,6 +61,10 @@ function protectedSnapshot() {
         floorId: null,
         supplyType: null,
         simultaneityFactor: 1,
+        boardNumber: "UV 1.1" as string | null,
+        location: "Raum 003 Technik" as string | null,
+        fedFrom: "HV 0.1" as string | null,
+        remark: null as string | null,
       },
     ],
     circuitLists: [
@@ -199,9 +203,52 @@ describe("project state snapshot model", () => {
     });
   });
 
+  it("upgrades snapshot version 5 with empty distribution-board info", () => {
+    const previous = protectedSnapshot();
+    previous.schemaVersion = 5 as typeof previous.schemaVersion;
+    for (const board of previous.distributionBoards) {
+      const record = board as Record<string, unknown>;
+      delete record.boardNumber;
+      delete record.location;
+      delete record.fedFrom;
+      delete record.remark;
+    }
+
+    const upgraded = parseProjectStateSnapshot(previous);
+
+    assert.equal(upgraded.schemaVersion, projectStateSnapshotSchemaVersion);
+    assert.deepEqual(
+      {
+        boardNumber: upgraded.distributionBoards[0]?.boardNumber,
+        location: upgraded.distributionBoards[0]?.location,
+        fedFrom: upgraded.distributionBoards[0]?.fedFrom,
+        remark: upgraded.distributionBoards[0]?.remark,
+      },
+      { boardNumber: null, location: null, fedFrom: null, remark: null }
+    );
+  });
+
+  it("keeps distribution-board info values and rejects them in older versions", () => {
+    const parsed = parseProjectStateSnapshot(protectedSnapshot());
+    assert.equal(parsed.distributionBoards[0]?.boardNumber, "UV 1.1");
+    assert.equal(parsed.distributionBoards[0]?.location, "Raum 003 Technik");
+    assert.equal(parsed.distributionBoards[0]?.fedFrom, "HV 0.1");
+
+    const mislabeled = protectedSnapshot();
+    mislabeled.schemaVersion = 5 as typeof mislabeled.schemaVersion;
+    assert.throws(() => parseProjectStateSnapshot(mislabeled));
+  });
+
   it("upgrades snapshot version 4 with the existing quantity as manual share", () => {
     const previous = protectedSnapshot();
     previous.schemaVersion = 4 as typeof previous.schemaVersion;
+    for (const board of previous.distributionBoards) {
+      const record = board as Record<string, unknown>;
+      delete record.boardNumber;
+      delete record.location;
+      delete record.fedFrom;
+      delete record.remark;
+    }
     previous.circuits[0]!.isReserve = false;
     previous.circuits[0]!.deviceRows = [{
       id: "row-1",

From 7692699ee284e27e699bc0dc5c8bbe85155c4bcf Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Fri, 25 Sep 2026 20:42:44 +0200
Subject: [PATCH 09/60] Add print cover fields and office profile
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Project settings gain siteAddress, workStage, projectLead and
  projectEditor (project.update-settings schema version 3, migration 0009);
  versions 2 and 1 stay executable and keep the current cover values.
  Snapshot schema 6 carries the fields; older versions upgrade with null.
- Global office profile (office name/address) next to the document logo:
  table document_branding_settings, PUT /api/document-branding/office,
  editable from the print view toolbar.
- Cover page reads all fields; empty values show the "[ergänzen]" marker.
  The Planstände editor column shows the project editor.
- Shared logo constants moved to a dependency-free module so the Next.js
  bundler can import them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |   30 +-
 docs/circuit-list-editor-api.md               |   14 +-
 docs/circuit-list-editor-known-limitations.md |    5 +-
 docs/current-architecture.md                  |    8 +-
 docs/print-view.md                            |   40 +-
 scripts/db-verify-circuit-schema.js           |    5 +
 src/app/projects/[projectId]/print/page.tsx   |  100 +-
 .../0008_project_cover_and_office_profile.sql |   10 +
 src/db/migrations/meta/0008_snapshot.json     | 2553 +++++++++++++++++
 src/db/migrations/meta/_journal.json          |    7 +
 .../document-branding.repository.ts           |   36 +-
 ...ect-settings-project-command.repository.ts |   59 +-
 ...roject-state-restore-command.repository.ts |    4 +
 .../project-state-snapshot.persistence.ts     |    8 +
 src/db/repositories/project.repository.ts     |    4 +
 src/db/schema/document-branding-settings.ts   |   13 +
 src/db/schema/projects.ts                     |    4 +
 .../project-settings-project-command.model.ts |   65 +-
 .../models/project-state-snapshot.model.ts    |   47 +-
 .../components/project-settings-modal.tsx     |   79 +-
 src/frontend/print/print-document.css         |    9 +-
 src/frontend/print/print-document.tsx         |   38 +-
 src/frontend/types.ts                         |    9 +
 src/frontend/utils/api.ts                     |   17 +-
 .../document-branding.controller.ts           |   18 +-
 src/server/controllers/project.controller.ts  |   21 +-
 src/server/routes/document-branding.routes.ts |    1 +
 src/shared/constants/document-branding.ts     |    9 +
 src/shared/constants/project-cover.ts         |   45 +
 .../validation/document-branding.schemas.ts   |   35 +-
 .../validation/project-structure.schemas.ts   |   19 +
 tests/document-branding.repository.test.ts    |   77 +
 tests/project-command.service.test.ts         |    4 +
 ...ettings-project-command.repository.test.ts |  135 +
 tests/project-state-snapshot.test.ts          |   64 +-
 35 files changed, 3479 insertions(+), 113 deletions(-)
 create mode 100644 src/db/migrations/0008_project_cover_and_office_profile.sql
 create mode 100644 src/db/migrations/meta/0008_snapshot.json
 create mode 100644 src/db/schema/document-branding-settings.ts
 create mode 100644 src/shared/constants/document-branding.ts
 create mode 100644 src/shared/constants/project-cover.ts
 create mode 100644 tests/document-branding.repository.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index 98c6a28..51b6616 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -251,10 +251,11 @@ snapshot verifies its checksum and the current-state hash, replaces supported
 project data atomically and records a new `restore` revision with a complete
 inverse command. Restore can therefore be undone and redone after a restart.
 Current snapshot schema version 6 additionally stores the distribution-board
-info fields `boardNumber`, `location`, `fedFrom` and `remark`; all older
-supported versions are upgraded with `null` for these fields. Stored named and
-automatic snapshots of every supported version (1 to 6) remain restorable;
-they are upgraded while parsing. Version 5 stores
+info fields `boardNumber`, `location`, `fedFrom` and `remark` and the project
+cover fields `siteAddress`, `workStage`, `projectLead` and `projectEditor`;
+all older supported versions are upgraded with `null` for these fields.
+Stored named and automatic snapshots of every supported version (1 to 6)
+remain restorable; they are upgraded while parsing. Version 5 stores
 the manual quantity share of every CircuitDeviceRow. Version 4 snapshots are upgraded with
 `manualQuantity = quantity`; they already contain the complete confirmed
 external-model source, import batches, room mappings and objects. Version 3
@@ -372,6 +373,10 @@ Project settings use the persistent `project.update-settings` command. Project
 metadata, the public-building classification, both voltage defaults and the
 enabled distribution-board supply types change in one revision and Undo/Redo
 restores them together; the project PUT route requires `expectedRevision`.
+Schema version 3 additionally carries the print cover fields `siteAddress`,
+`workStage`, `projectLead` and `projectEditor` (migration `0008`); version 2
+(without them) and baseline version 1 stay executable and keep the current
+cover values. The PUT route accepts the cover fields optionally.
 The public-building flag is the future sizing input for requiring halogen-free
 cables and lines. The system catalog is `AV`, `SV`, `EV`,
 `USV`, `MSR`, `SiBe`; at least one must be enabled and a type used by a board
@@ -475,12 +480,15 @@ Required operations:
 - The board hierarchy and "Σ inkl. unterlagert" in the overview are
   PRELIMINARY (text match of `fedFrom` against board number/name, plain sum,
   no upstream simultaneity factor). Replace this once the feed link is modeled.
-- Colors/fonts are the provisional kbp CD (`--pd-*` variables) until the
-  official CD specification exists. Cover fields shown as "[ergänzen]"
-  (address, Leistungsphase, office staff) have no data model yet.
-- The document logo is global office branding: table
-  `document_branding_assets` (migration `0007`), endpoints
-  `GET|PUT|DELETE /api/document-branding/logo` and `GET /api/document-branding`.
+- Colors/fonts follow the kbp corporate design (`--pd-*` variables in
+  `print-document.css`). Empty cover values are shown as
+  "[ergänzen]"; the Planstände editor column shows the project's current
+  `projectEditor` because snapshots do not record an editor.
+- The document logo and the office profile (office name/address on the
+  cover) are global office branding: tables `document_branding_assets`
+  (migration `0007`) and `document_branding_settings` (migration `0008`),
+  endpoints `GET|PUT|DELETE /api/document-branding/logo`,
+  `PUT /api/document-branding/office` and `GET /api/document-branding`.
   It is intentionally outside project revisions, snapshots and transfer.
   Uploads are PNG/JPEG/SVG up to 2 MB with a content signature check; the logo
   is served with `nosniff` and a restrictive CSP.
@@ -583,8 +591,6 @@ Users must be able to override sizing suggestions.
 - logical feed link between distribution boards (`fedFrom` stays free text
   until the project owner decides whether it references a board, a feeding
   circuit or both) and the resulting hierarchical power summation
-- data model for the remaining print cover fields (address, Leistungsphase,
-  project lead/editor) and the official kbp CD values
 
 Do not implement these while working on an unrelated phase.
 
diff --git a/docs/circuit-list-editor-api.md b/docs/circuit-list-editor-api.md
index 762a279..d325944 100644
--- a/docs/circuit-list-editor-api.md
+++ b/docs/circuit-list-editor-api.md
@@ -74,8 +74,9 @@ Protected-board structure uses
 persisted inverse of a delete. The dispatcher also supports the documented
 project-device, project settings, distribution-board and project-location
 commands. The generic editor commands listed here use schema version `1`.
-`project.update-settings` uses version `2` and still accepts supported baseline
-version `1` commands without changing the newer building classification.
+`project.update-settings` uses version `3` (including the print cover fields)
+and still accepts version `2` and supported baseline version `1` commands
+without changing the newer cover fields or building classification.
 Pre-baseline formats remain unsupported. Unsupported types or schema versions
 are rejected. Insert commands contain the complete entity or circuit block
 with stable ids; delete commands include the expected parent identity. Circuit
@@ -173,6 +174,9 @@ synchronizes linked circuit rows implicitly.
 - `PUT /projects/:projectId`
   - request:
     `{ "expectedRevision": 12, "isPublicBuilding": true, "singlePhaseVoltageV": 230, "threePhaseVoltageV": 400, "enabledDistributionBoardSupplyTypes": ["AV", "MSR", "SiBe"], ...projectMetadata }`
+  - optional print cover fields `siteAddress` (max. 500), `workStage` (max.
+    100), `projectLead` and `projectEditor` (max. 200 each); omitted fields keep
+    their value, empty strings are stored as `null`
   - executes `project.update-settings` as one atomic revision
   - response:
     `{ "project": { ... }, "revision": { ... }, "history": { ... } }`
@@ -437,7 +441,7 @@ Office-wide branding for the print view. These endpoints are mounted at
 and intentionally not part of project revisions, snapshots or transfer.
 
 - `GET /document-branding`
-  - returns `{ "logo": { "mimeType", "fileName", "sizeBytes", "updatedAtIso" } | null }`
+  - returns `{ "logo": { "mimeType", "fileName", "sizeBytes", "updatedAtIso" } | null, "office": { "officeName", "officeAddress" } }`
 - `GET /document-branding/logo`
   - returns the stored image bytes with its media type, or `404` without logo
   - responses carry `X-Content-Type-Options: nosniff` and a restrictive
@@ -449,3 +453,7 @@ and intentionally not part of project revisions, snapshots or transfer.
   - replaces an existing logo; returns the logo metadata
 - `DELETE /document-branding/logo`
   - removes the logo; returns `204`
+- `PUT /document-branding/office`
+  - request: `{ "officeName": "…" | null, "officeAddress": "…" | null }`
+    (at most 200 / 500 characters; empty text is stored as not set)
+  - returns `{ "office": { "officeName", "officeAddress" } }`
diff --git a/docs/circuit-list-editor-known-limitations.md b/docs/circuit-list-editor-known-limitations.md
index bea8b87..3e70e76 100644
--- a/docs/circuit-list-editor-known-limitations.md
+++ b/docs/circuit-list-editor-known-limitations.md
@@ -31,7 +31,8 @@
   supply structure and "Σ inkl. unterlagert" only from exact text matches with
   board numbers/names and adds values without an upstream simultaneity factor
   (see `docs/print-view.md`).
-- The print view cover page shows placeholders for address, Leistungsphase and
-  office staff, and uses a provisional kbp corporate design. On screen, long
+- The print view uses a kbp corporate design derived from logo and
+  presentation material. Snapshots do not record an editor, so the cover's
+  Planstände list shows the project's current editor for every entry. On screen, long
   board plans are not split into pages; pagination happens in the browser print
   dialog.
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index cbea92f..fe55413 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -232,8 +232,9 @@ und Historienstapel teilen dieselbe Transaktion. Create, Import aus der globalen
 Gerätebibliothek und Delete laufen über dieselbe Command-Grenze; ihre Antworten
 liefern Gerät und aktualisierten Historienstand an die Projektseite zurück.
 `project.update-settings` versioniert Projektname, interne und externe
-Projektnummer, Bauherr, Beschreibung, die Kennzeichnung als öffentliches
-Gebäude, beide Standardspannungen sowie die im Projekt freigeschalteten
+Projektnummer, Bauherr, Beschreibung, die Deckblattangaben (Anschrift,
+Leistungsphase, Projektleitung, Bearbeitung; Schema-Version 3, Migration
+`0008`), die Kennzeichnung als öffentliches Gebäude, beide Standardspannungen sowie die im Projekt freigeschalteten
 Verteiler-Netzarten als eine atomare Änderung. Die Gebäudekennzeichnung ist
 der spätere Eingang für die Auswahl halogenfreier Kabel und Leitungen. Der
 Systemkatalog besteht aus `AV`, `SV`, `EV`, `USV`, `MSR` und `SiBe`; mindestens
@@ -421,7 +422,8 @@ Derselbe Befehl versioniert die Felder der Verteiler-Infokarte
 Infokarte liegt im Bearbeiten-Dialog der Verteilung; die Werte sind lokale
 Planungswerte und sollen später über den Revit-Abgleich nur nach Vorschau und
 ausdrücklicher Bestätigung vorbelegt werden. `fedFrom` ist vorerst Freitext.
-Snapshot-Schema 6 enthält diese Felder; ältere Versionen werden mit `null`
+Snapshot-Schema 6 enthält diese Felder und die Deckblattangaben des
+Projekts; ältere Versionen werden mit `null`
 hochgestuft. Snapshot-Schema 5 enthält zusätzlich den manuellen Mengenanteil jeder
 Gerätezeile. Version 4 wird mit `manualQuantity = quantity` hochgestuft und
 enthält bereits den vollständigen externen Modellzustand
diff --git a/docs/print-view.md b/docs/print-view.md
index 3de19a5..49b5caf 100644
--- a/docs/print-view.md
+++ b/docs/print-view.md
@@ -1,7 +1,6 @@
 # Seitenansicht und PDF-Export
 
-Stand: erste Ausbaustufe (Beispiel zur Abstimmung). Die Seitenansicht ist
-rein lesend und verändert keine Projektdaten.
+Die Seitenansicht ist rein lesend und verändert keine Projektdaten.
 
 ## Aufruf
 
@@ -12,14 +11,15 @@ rein lesend und verändert keine Projektdaten.
   wird als Dateiname vorgeschlagen.
 - **Planformat** schaltet die Verteilerpläne zwischen A4 quer und A3 quer um.
   Deckblatt bleibt A4 hoch.
+- **Büroangaben** pflegt Büroname und Büroanschrift (Planverfasser, für alle
+  Projekte).
 - **Logo hinterlegen / ersetzen / entfernen** verwaltet das Büro-Logo.
 
 ## Seiten
 
 1. **Deckblatt (A4 hoch)** – tabellarisch: Projekt, Planverfasser, Dokument,
-   Planstände (aus benannten Sicherungspunkten) und Inhalt. Angaben ohne
-   Datenmodell erscheinen als orangefarbenes „[ergänzen]“ (Anschrift,
-   Leistungsphase, Projektleitung, Bearbeitung).
+   Planstände (aus benannten Sicherungspunkten) und Inhalt. Leere Angaben
+   erscheinen als orangefarbenes „[ergänzen]“.
 2. **Verteilerübersicht (quer)** – Versorgungsstruktur und Tabelle je
    Verteiler mit Stromkreisanzahl, P<sub>inst</sub> (Anzahl × Leistung je
    Stück), P<sub>Geräte</sub> (mit Geräte-GZF), Verteiler-GZF,
@@ -51,8 +51,34 @@ Seitenaufteilung langer Verteilerpläne entsteht erst beim Drucken.
 - **Corporate Design:** Farben (`--pd-*` in
   `src/frontend/print/print-document.css`) und Schrift (Arial) sind aus Logo
   und kbp-Präsentationsmaterial abgeleitet und werden durch die offizielle
-  CD-Vorgabe ersetzt. Der Büroname steht vorläufig als Konstante
-  `printOfficeName` in `src/frontend/print/print-document.tsx`.
+  CD-Vorgabe ersetzt, falls diese abweicht.
+- **Planstände:** Die Spalte „Bearbeitung“ zeigt für jeden Planstand die
+  aktuelle Bearbeitung aus den Projekteinstellungen, weil Sicherungspunkte
+  (noch) keinen Bearbeiter speichern.
+
+## Datenquellen des Deckblatts
+
+| Feld | Quelle |
+|---|---|
+| Bauvorhaben, Bauherr, Projektnummern, Beschreibung | Projekteinstellungen |
+| Anschrift Bauvorhaben, Leistungsphase, Projektleitung, Bearbeitung | Projekteinstellungen → Abschnitt „Deckblatt“ (`siteAddress`, `workStage`, `projectLead`, `projectEditor`) |
+| Büro, Anschrift Büro | Seitenansicht → „Büroangaben“ (global) |
+| Stand, Datenstand, Anzahl Verteiler, Inhalt | automatisch |
+| Planstände | benannte Sicherungspunkte |
+
+Die vier Projektfelder laufen über `project.update-settings` (Schema-Version
+3, Migration `0008`) und sind Teil von Snapshot-Schema 6 und Projektexport.
+Im `PUT /api/projects/:projectId` sind sie optional; fehlende Felder behalten
+ihren Wert.
+
+## Büroangaben
+
+- Tabelle `document_branding_settings` (Schlüssel/Wert, Migration `0008`),
+  global wie das Logo.
+- `GET /api/document-branding` liefert zusätzlich
+  `office: { officeName, officeAddress }`.
+- `PUT /api/document-branding/office` mit `{ "officeName", "officeAddress" }`
+  (max. 200 / 500 Zeichen, leerer Text = nicht gesetzt).
 
 ## Logo
 
diff --git a/scripts/db-verify-circuit-schema.js b/scripts/db-verify-circuit-schema.js
index 558178e..8d27b1d 100644
--- a/scripts/db-verify-circuit-schema.js
+++ b/scripts/db-verify-circuit-schema.js
@@ -13,6 +13,7 @@ const requiredTables = [
   "distribution_board_components",
   "distribution_board_component_protection_devices",
   "document_branding_assets",
+  "document_branding_settings",
 ];
 
 const tablePlaceholders = requiredTables.map(() => "?").join(", ");
@@ -88,6 +89,10 @@ const requiredProjectColumns = [
   "description",
   "is_public_building",
   "enabled_distribution_board_supply_types",
+  "site_address",
+  "work_stage",
+  "project_lead",
+  "project_editor",
 ];
 const projectColumns = new Set(
   db.prepare("PRAGMA table_info(projects)").all().map((column) => column.name)
diff --git a/src/app/projects/[projectId]/print/page.tsx b/src/app/projects/[projectId]/print/page.tsx
index 91eb433..11e6710 100644
--- a/src/app/projects/[projectId]/print/page.tsx
+++ b/src/app/projects/[projectId]/print/page.tsx
@@ -2,7 +2,7 @@
 
 import Link from "next/link";
 import { useParams } from "next/navigation";
-import { ChangeEvent, useEffect, useMemo, useState } from "react";
+import { ChangeEvent, FormEvent, useEffect, useMemo, useState } from "react";
 import "../../../../frontend/print/print-document.css";
 import {
   deleteDocumentLogo,
@@ -14,13 +14,20 @@ import {
   listDistributionBoards,
   listFloors,
   listProjectSnapshots,
+  updateOfficeProfile,
   uploadDocumentLogo,
 } from "../../../../frontend/utils/api";
 import type {
   DocumentLogoMetadataDto,
+  OfficeProfileDto,
   ProjectDto,
   ProjectSnapshotMetadataDto,
 } from "../../../../frontend/types";
+import { FormModal } from "../../../../frontend/components/form-modal";
+import {
+  officeProfileFieldLabels,
+  officeProfileFieldMaxLengths,
+} from "../../../../shared/constants/project-cover";
 import { PrintDocument } from "../../../../frontend/print/print-document";
 import {
   buildPreliminaryBoardHierarchy,
@@ -30,7 +37,7 @@ import {
 import {
   documentLogoMimeTypes,
   maxDocumentLogoBytes,
-} from "../../../../shared/validation/document-branding.schemas";
+} from "../../../../shared/constants/document-branding";
 
 type PlanFormat = "a4" | "a3";
 
@@ -61,6 +68,14 @@ export default function ProjectPrintPage() {
   const projectId = params.projectId;
   const [data, setData] = useState<PrintData | null>(null);
   const [logo, setLogo] = useState<DocumentLogoMetadataDto | null>(null);
+  const [office, setOffice] = useState<OfficeProfileDto>({
+    officeName: null,
+    officeAddress: null,
+  });
+  const [officeDraft, setOfficeDraft] = useState<{
+    officeName: string;
+    officeAddress: string;
+  } | null>(null);
   const [format, setFormat] = useState<PlanFormat>("a4");
   const [error, setError] = useState<string | null>(null);
   const [message, setMessage] = useState<string | null>(null);
@@ -116,6 +131,7 @@ export default function ProjectPrintPage() {
           .sort((left, right) => left.createdAtIso.localeCompare(right.createdAtIso)),
       });
       setLogo(branding.logo);
+      setOffice(branding.office);
       document.title = `Leistungsbilanz – ${project.name}`;
     }
     load().catch((err: unknown) => {
@@ -172,6 +188,28 @@ export default function ProjectPrintPage() {
     }
   }
 
+  async function handleOfficeSave(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    if (!officeDraft) {
+      return;
+    }
+    setIsBusy(true);
+    setError(null);
+    try {
+      const result = await updateOfficeProfile({
+        officeName: officeDraft.officeName.trim() || null,
+        officeAddress: officeDraft.officeAddress.trim() || null,
+      });
+      setOffice(result.office);
+      setOfficeDraft(null);
+      setMessage("Büroangaben gespeichert. Sie gelten für alle Projekte.");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Die Büroangaben konnten nicht gespeichert werden.");
+    } finally {
+      setIsBusy(false);
+    }
+  }
+
   async function handleLogoDelete() {
     if (!window.confirm("Hinterlegtes Logo für alle Projekte entfernen?")) {
       return;
@@ -213,6 +251,19 @@ export default function ProjectPrintPage() {
             <option value="a3">A3 quer</option>
           </select>
         </label>
+        <button
+          className="btn btn-sm btn-outline-primary"
+          disabled={isBusy}
+          onClick={() =>
+            setOfficeDraft({
+              officeName: office.officeName ?? "",
+              officeAddress: office.officeAddress ?? "",
+            })
+          }
+          type="button"
+        >
+          Büroangaben
+        </button>
         <label className={`btn btn-sm btn-outline-primary mb-0${isBusy ? " disabled" : ""}`}>
           {logo ? "Logo ersetzen" : "Logo hinterlegen"}
           <input
@@ -245,11 +296,56 @@ export default function ProjectPrintPage() {
           Zum Projekt
         </Link>
       </div>
+      {officeDraft ? (
+        <FormModal
+          description="Planverfasser auf dem Deckblatt. Gilt für alle Projekte."
+          isSaving={isBusy}
+          onClose={() => setOfficeDraft(null)}
+          onSubmit={handleOfficeSave}
+          submitLabel="Büroangaben speichern"
+          title="Büroangaben"
+        >
+          <div className="row g-3">
+            <div className="col-12">
+              <label className="form-label" htmlFor="office-name">
+                {officeProfileFieldLabels.officeName}
+              </label>
+              <input
+                autoFocus
+                className="form-control"
+                id="office-name"
+                maxLength={officeProfileFieldMaxLengths.officeName}
+                onChange={(event) =>
+                  setOfficeDraft({ ...officeDraft, officeName: event.target.value })
+                }
+                value={officeDraft.officeName}
+              />
+            </div>
+            <div className="col-12">
+              <label className="form-label" htmlFor="office-address">
+                {officeProfileFieldLabels.officeAddress}
+              </label>
+              <textarea
+                className="form-control"
+                id="office-address"
+                maxLength={officeProfileFieldMaxLengths.officeAddress}
+                onChange={(event) =>
+                  setOfficeDraft({ ...officeDraft, officeAddress: event.target.value })
+                }
+                placeholder={"Straße Nr.\nPLZ Ort"}
+                rows={3}
+                value={officeDraft.officeAddress}
+              />
+            </div>
+          </div>
+        </FormModal>
+      ) : null}
       {data ? (
         <PrintDocument
           entries={entries}
           logoSrc={logoSrc}
           namedSnapshots={data.namedSnapshots}
+          office={office}
           printedAt={printedAt}
           project={data.project}
         />
diff --git a/src/db/migrations/0008_project_cover_and_office_profile.sql b/src/db/migrations/0008_project_cover_and_office_profile.sql
new file mode 100644
index 0000000..34f2ba6
--- /dev/null
+++ b/src/db/migrations/0008_project_cover_and_office_profile.sql
@@ -0,0 +1,10 @@
+CREATE TABLE `document_branding_settings` (
+	`key` text PRIMARY KEY NOT NULL,
+	`value` text NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE `projects` ADD `site_address` text;--> statement-breakpoint
+ALTER TABLE `projects` ADD `work_stage` text;--> statement-breakpoint
+ALTER TABLE `projects` ADD `project_lead` text;--> statement-breakpoint
+ALTER TABLE `projects` ADD `project_editor` text;
\ No newline at end of file
diff --git a/src/db/migrations/meta/0008_snapshot.json b/src/db/migrations/meta/0008_snapshot.json
new file mode 100644
index 0000000..8d3cc3a
--- /dev/null
+++ b/src/db/migrations/meta/0008_snapshot.json
@@ -0,0 +1,2553 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "fb609719-ea17-4833-a27b-f75da0d3e860",
+  "prevId": "4db6e93a-3070-459a-94ef-587fd4929411",
+  "tables": {
+    "circuit_device_rows": {
+      "name": "circuit_device_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "level": {
+          "name": "level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number_snapshot": {
+          "name": "room_number_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_name_snapshot": {
+          "name": "room_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "manual_quantity": {
+          "name": "manual_quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_device_rows_circuit_id_idx": {
+          "name": "circuit_device_rows_circuit_id_idx",
+          "columns": [
+            "circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "circuit_device_rows_circuit_id_circuits_id_fk": {
+          "name": "circuit_device_rows_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_linked_project_device_id_project_devices_id_fk": {
+          "name": "circuit_device_rows_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_room_id_rooms_id_fk": {
+          "name": "circuit_device_rows_room_id_rooms_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_list_equipment_identifiers": {
+      "name": "circuit_list_equipment_identifiers",
+      "columns": {
+        "owner_type": {
+          "name": "owner_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_list_equipment_identifiers_owner_unique": {
+          "name": "circuit_list_equipment_identifiers_owner_unique",
+          "columns": [
+            "owner_type",
+            "owner_id"
+          ],
+          "isUnique": true
+        },
+        "circuit_list_equipment_identifiers_list_identifier_unique": {
+          "name": "circuit_list_equipment_identifiers_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_list_equipment_identifiers",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_lists": {
+      "name": "circuit_lists",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_lists_distribution_board_id_unique": {
+          "name": "circuit_lists_distribution_board_id_unique",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_lists_project_id_projects_id_fk": {
+          "name": "circuit_lists_project_id_projects_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_lists_distribution_board_id_distribution_boards_id_fk": {
+          "name": "circuit_lists_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_protection_devices": {
+      "name": "circuit_protection_devices",
+      "columns": {
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "circuit_protection_devices_circuit_id_circuits_id_fk": {
+          "name": "circuit_protection_devices_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_protection_devices",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_sections": {
+      "name": "circuit_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "group_number": {
+          "name": "group_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_sections_list_key_unique": {
+          "name": "circuit_sections_list_key_unique",
+          "columns": [
+            "circuit_list_id",
+            "key"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_prefix_unique": {
+          "name": "circuit_sections_list_prefix_unique",
+          "columns": [
+            "circuit_list_id",
+            "prefix"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_category_group_unique": {
+          "name": "circuit_sections_list_category_group_unique",
+          "columns": [
+            "circuit_list_id",
+            "category",
+            "group_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_sections_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_sections_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_sections",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuits": {
+      "name": "circuits",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "cable_type": {
+          "name": "cable_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_cross_section": {
+          "name": "cable_cross_section",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_length": {
+          "name": "cable_length",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_assignment": {
+          "name": "rcd_assignment",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_designation": {
+          "name": "terminal_designation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage": {
+          "name": "voltage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "control_requirement": {
+          "name": "control_requirement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_reserve": {
+          "name": "is_reserve",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuits_section_id_idx": {
+          "name": "circuits_section_id_idx",
+          "columns": [
+            "section_id"
+          ],
+          "isUnique": false
+        },
+        "circuits_list_equipment_identifier_unique": {
+          "name": "circuits_list_equipment_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuits_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuits_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuits_section_id_circuit_sections_id_fk": {
+          "name": "circuits_section_id_circuit_sections_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_component_protection_devices": {
+      "name": "distribution_board_component_protection_devices",
+      "columns": {
+        "component_id": {
+          "name": "component_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk": {
+          "name": "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk",
+          "tableFrom": "distribution_board_component_protection_devices",
+          "tableTo": "distribution_board_components",
+          "columnsFrom": [
+            "component_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_components": {
+      "name": "distribution_board_components",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "placement": {
+          "name": "placement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "distribution_board_components_list_identifier_unique": {
+          "name": "distribution_board_components_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        },
+        "distribution_board_components_section_role_unique": {
+          "name": "distribution_board_components_section_role_unique",
+          "columns": [
+            "section_id",
+            "role"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "distribution_board_components_circuit_list_id_circuit_lists_id_fk": {
+          "name": "distribution_board_components_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_board_components_section_id_circuit_sections_id_fk": {
+          "name": "distribution_board_components_section_id_circuit_sections_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_boards": {
+      "name": "distribution_boards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "supply_type": {
+          "name": "supply_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "board_number": {
+          "name": "board_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "location": {
+          "name": "location",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fed_from": {
+          "name": "fed_from",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_boards_project_id_projects_id_fk": {
+          "name": "distribution_boards_project_id_projects_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_floor_id_floors_id_fk": {
+          "name": "distribution_boards_floor_id_floors_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_assets": {
+      "name": "document_branding_assets",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_settings": {
+      "name": "document_branding_settings",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_csv_configurations": {
+      "name": "external_csv_configurations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration": {
+          "name": "configuration",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_csv_configurations_project_id_unique": {
+          "name": "external_csv_configurations_project_id_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_csv_configurations_project_id_projects_id_fk": {
+          "name": "external_csv_configurations_project_id_projects_id_fk",
+          "tableFrom": "external_csv_configurations",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_import_batches": {
+      "name": "external_import_batches",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "import_kind": {
+          "name": "import_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "imported_at_iso": {
+          "name": "imported_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "applied_project_revision": {
+          "name": "applied_project_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_snapshot": {
+          "name": "configuration_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "original_bytes": {
+          "name": "original_bytes",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "document": {
+          "name": "document",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_import_batches_project_revision_idx": {
+          "name": "external_import_batches_project_revision_idx",
+          "columns": [
+            "project_id",
+            "applied_project_revision"
+          ],
+          "isUnique": false
+        },
+        "external_import_batches_source_imported_idx": {
+          "name": "external_import_batches_source_imported_idx",
+          "columns": [
+            "source_id",
+            "imported_at_iso"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_import_batches_project_id_projects_id_fk": {
+          "name": "external_import_batches_project_id_projects_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_import_batches_source_id_external_model_sources_id_fk": {
+          "name": "external_import_batches_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_objects": {
+      "name": "external_model_objects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ifc_guid": {
+          "name": "ifc_guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen_import_batch_id": {
+          "name": "last_seen_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_accepted_import_batch_id": {
+          "name": "last_accepted_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "accepted_source_values": {
+          "name": "accepted_source_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "planning_values": {
+          "name": "planning_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "external_room_mapping_id": {
+          "name": "external_room_mapping_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "circuit_device_row_id": {
+          "name": "circuit_device_row_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "presence_status": {
+          "name": "presence_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'present'"
+        }
+      },
+      "indexes": {
+        "external_model_objects_source_ifc_guid_unique": {
+          "name": "external_model_objects_source_ifc_guid_unique",
+          "columns": [
+            "source_id",
+            "ifc_guid"
+          ],
+          "isUnique": true
+        },
+        "external_model_objects_project_presence_idx": {
+          "name": "external_model_objects_project_presence_idx",
+          "columns": [
+            "project_id",
+            "presence_status"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_distribution_board_idx": {
+          "name": "external_model_objects_distribution_board_idx",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_circuit_device_row_idx": {
+          "name": "external_model_objects_circuit_device_row_idx",
+          "columns": [
+            "circuit_device_row_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_model_objects_project_id_projects_id_fk": {
+          "name": "external_model_objects_project_id_projects_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_source_id_external_model_sources_id_fk": {
+          "name": "external_model_objects_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_seen_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_accepted_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk": {
+          "name": "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_room_mappings",
+          "columnsFrom": [
+            "external_room_mapping_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_model_objects_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_linked_project_device_id_project_devices_id_fk": {
+          "name": "external_model_objects_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk": {
+          "name": "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "circuit_device_rows",
+          "columnsFrom": [
+            "circuit_device_row_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_sources": {
+      "name": "external_model_sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_type": {
+          "name": "source_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'revit_csv'"
+        }
+      },
+      "indexes": {
+        "external_model_sources_project_type_unique": {
+          "name": "external_model_sources_project_type_unique",
+          "columns": [
+            "project_id",
+            "source_type"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_sources_project_id_projects_id_fk": {
+          "name": "external_model_sources_project_id_projects_id_fk",
+          "tableFrom": "external_model_sources",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_room_mappings": {
+      "name": "external_room_mappings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "normalized_source_room_key": {
+          "name": "normalized_source_room_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_floor_name": {
+          "name": "source_floor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_room_number": {
+          "name": "source_room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_room_name": {
+          "name": "source_room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_distribution_board_id": {
+          "name": "default_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_room_mappings_source_key_unique": {
+          "name": "external_room_mappings_source_key_unique",
+          "columns": [
+            "source_id",
+            "normalized_source_room_key"
+          ],
+          "isUnique": true
+        },
+        "external_room_mappings_project_room_idx": {
+          "name": "external_room_mappings_project_room_idx",
+          "columns": [
+            "project_id",
+            "room_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_room_mappings_project_id_projects_id_fk": {
+          "name": "external_room_mappings_project_id_projects_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_source_id_external_model_sources_id_fk": {
+          "name": "external_room_mappings_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_room_id_rooms_id_fk": {
+          "name": "external_room_mappings_room_id_rooms_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "default_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "floors": {
+      "name": "floors",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "floors_project_id_projects_id_fk": {
+          "name": "floors_project_id_projects_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "global_devices": {
+      "name": "global_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "installed_power_per_unit_kw": {
+          "name": "installed_power_per_unit_kw",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "demand_factor": {
+          "name": "demand_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase_count": {
+          "name": "phase_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_factor": {
+          "name": "power_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_change_sets": {
+      "name": "project_change_sets",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_revision_id": {
+          "name": "project_revision_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "command_type": {
+          "name": "command_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_schema_version": {
+          "name": "payload_schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "forward_payload_json": {
+          "name": "forward_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "inverse_payload_json": {
+          "name": "inverse_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_change_sets_revision_unique": {
+          "name": "project_change_sets_revision_unique",
+          "columns": [
+            "project_revision_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_change_sets_project_revision_id_project_revisions_id_fk": {
+          "name": "project_change_sets_project_revision_id_project_revisions_id_fk",
+          "tableFrom": "project_change_sets",
+          "tableTo": "project_revisions",
+          "columnsFrom": [
+            "project_revision_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_devices": {
+      "name": "project_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'single_phase'"
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "project_devices_project_id_projects_id_fk": {
+          "name": "project_devices_project_id_projects_id_fk",
+          "tableFrom": "project_devices",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_history_stack_entries": {
+      "name": "project_history_stack_entries",
+      "columns": {
+        "change_set_id": {
+          "name": "change_set_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stack": {
+          "name": "stack",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_history_stack_entries_position_unique": {
+          "name": "project_history_stack_entries_position_unique",
+          "columns": [
+            "project_id",
+            "stack",
+            "position"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_history_stack_entries_change_set_id_project_change_sets_id_fk": {
+          "name": "project_history_stack_entries_change_set_id_project_change_sets_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "project_change_sets",
+          "columnsFrom": [
+            "change_set_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "project_history_stack_entries_project_id_projects_id_fk": {
+          "name": "project_history_stack_entries_project_id_projects_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "project_history_stack_entries_stack_check": {
+          "name": "project_history_stack_entries_stack_check",
+          "value": "\"project_history_stack_entries\".\"stack\" in ('undo', 'redo')"
+        }
+      }
+    },
+    "project_revisions": {
+      "name": "project_revisions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision_number": {
+          "name": "revision_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_revisions_project_number_unique": {
+          "name": "project_revisions_project_number_unique",
+          "columns": [
+            "project_id",
+            "revision_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_revisions_project_id_projects_id_fk": {
+          "name": "project_revisions_project_id_projects_id_fk",
+          "tableFrom": "project_revisions",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_snapshots": {
+      "name": "project_snapshots",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_revision": {
+          "name": "source_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_version": {
+          "name": "schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'named'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "payload_json": {
+          "name": "payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_sha256": {
+          "name": "payload_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_by_actor_id": {
+          "name": "created_by_actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_snapshots_project_created_idx": {
+          "name": "project_snapshots_project_created_idx",
+          "columns": [
+            "project_id",
+            "created_at_iso"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_kind_revision_idx": {
+          "name": "project_snapshots_project_kind_revision_idx",
+          "columns": [
+            "project_id",
+            "kind",
+            "source_revision"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_name_unique": {
+          "name": "project_snapshots_project_name_unique",
+          "columns": [
+            "project_id",
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_snapshots_project_id_projects_id_fk": {
+          "name": "project_snapshots_project_id_projects_id_fk",
+          "tableFrom": "project_snapshots",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "internal_project_number": {
+          "name": "internal_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_project_number": {
+          "name": "external_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "building_owner": {
+          "name": "building_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_public_building": {
+          "name": "is_public_building",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "single_phase_voltage_v": {
+          "name": "single_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 230
+        },
+        "three_phase_voltage_v": {
+          "name": "three_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 400
+        },
+        "enabled_distribution_board_supply_types": {
+          "name": "enabled_distribution_board_supply_types",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'[\"AV\",\"SV\",\"EV\",\"USV\",\"MSR\",\"SiBe\"]'"
+        },
+        "site_address": {
+          "name": "site_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_lead": {
+          "name": "project_lead",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_editor": {
+          "name": "project_editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "current_revision": {
+          "name": "current_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "rooms": {
+      "name": "rooms",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number": {
+          "name": "room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_name": {
+          "name": "room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rooms_project_id_projects_id_fk": {
+          "name": "rooms_project_id_projects_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rooms_floor_id_floors_id_fk": {
+          "name": "rooms_floor_id_floors_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index 2b5f1f5..8322eb3 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -57,6 +57,13 @@
       "when": 1790411540872,
       "tag": "0007_board_info_and_document_logo",
       "breakpoints": true
+    },
+    {
+      "idx": 8,
+      "version": "6",
+      "when": 1790411560953,
+      "tag": "0008_project_cover_and_office_profile",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/db/repositories/document-branding.repository.ts b/src/db/repositories/document-branding.repository.ts
index 450e8d2..eadba0a 100644
--- a/src/db/repositories/document-branding.repository.ts
+++ b/src/db/repositories/document-branding.repository.ts
@@ -1,9 +1,10 @@
-import { eq } from "drizzle-orm";
+import { eq, inArray } from "drizzle-orm";
 import type { AppDatabase } from "../database-context.js";
 import {
   documentBrandingAssets,
   type DocumentBrandingAsset,
 } from "../schema/document-branding-assets.js";
+import { documentBrandingSettings } from "../schema/document-branding-settings.js";
 
 // Plain repository without revision semantics: branding is global office
 // configuration, not a project mutation.
@@ -49,4 +50,37 @@ export class DocumentBrandingRepository {
         .run().changes > 0
     );
   }
+
+  getSettings<TKey extends string>(keys: readonly TKey[]): Record<TKey, string | null> {
+    const rows = this.db
+      .select()
+      .from(documentBrandingSettings)
+      .where(inArray(documentBrandingSettings.key, [...keys]))
+      .all();
+    return Object.fromEntries(
+      keys.map((key) => [key, rows.find((row) => row.key === key)?.value ?? null])
+    ) as Record<TKey, string | null>;
+  }
+
+  /** Stores the given values atomically; `null` removes a setting. */
+  setSettings(values: Record<string, string | null>) {
+    const updatedAt = new Date();
+    this.db.transaction((tx) => {
+      for (const [key, value] of Object.entries(values)) {
+        if (value === null) {
+          tx.delete(documentBrandingSettings)
+            .where(eq(documentBrandingSettings.key, key))
+            .run();
+        } else {
+          tx.insert(documentBrandingSettings)
+            .values({ key, value, updatedAt })
+            .onConflictDoUpdate({
+              target: documentBrandingSettings.key,
+              set: { value, updatedAt },
+            })
+            .run();
+        }
+      }
+    });
+  }
 }
diff --git a/src/db/repositories/project-settings-project-command.repository.ts b/src/db/repositories/project-settings-project-command.repository.ts
index 01a38f3..905577a 100644
--- a/src/db/repositories/project-settings-project-command.repository.ts
+++ b/src/db/repositories/project-settings-project-command.repository.ts
@@ -1,9 +1,12 @@
 import { and, eq, isNotNull } from "drizzle-orm";
 import {
   assertProjectSettingsUpdateProjectCommand,
+  baselineProjectSettingsUpdateCommandSchemaVersion,
   createProjectSettingsUpdateProjectCommand,
+  withoutCoverProjectSettingsUpdateCommandSchemaVersion,
   type ProjectSettingsValues,
 } from "../../domain/models/project-settings-project-command.model.js";
+import { projectCoverFields } from "../../shared/constants/project-cover.js";
 import type {
   ExecuteProjectSettingsUpdateCommandInput,
   ProjectSettingsProjectCommandStore,
@@ -40,13 +43,27 @@ export class ProjectSettingsProjectCommandRepository
     if (!current) {
       throw new Error("Project not found.");
     }
+    const currentCoverValues = {
+      siteAddress: current.siteAddress,
+      workStage: current.workStage,
+      projectLead: current.projectLead,
+      projectEditor: current.projectEditor,
+    };
+    // Older command versions do not carry every value; missing values keep
+    // the current project state and are therefore also absent from the
+    // inverse of the same version.
+    const command = input.command;
     const target: ProjectSettingsValues =
-      input.command.schemaVersion === 1
+      command.schemaVersion === baselineProjectSettingsUpdateCommandSchemaVersion
         ? {
-            ...input.command.payload,
+            ...command.payload,
             isPublicBuilding: current.isPublicBuilding,
+            ...currentCoverValues,
           }
-        : input.command.payload;
+        : command.schemaVersion ===
+            withoutCoverProjectSettingsUpdateCommandSchemaVersion
+          ? { ...command.payload, ...currentCoverValues }
+          : command.payload;
     if (projectSettingsEqual(current, target)) {
       throw new Error("Project settings did not change.");
     }
@@ -62,11 +79,15 @@ export class ProjectSettingsProjectCommandRepository
       threePhaseVoltageV: current.threePhaseVoltageV,
       enabledDistributionBoardSupplyTypes:
         current.enabledDistributionBoardSupplyTypes,
+      ...currentCoverValues,
     };
     const inverse =
-      input.command.schemaVersion === 1
+      command.schemaVersion === baselineProjectSettingsUpdateCommandSchemaVersion
         ? createBaselineProjectSettingsUpdateCommand(inverseValues)
-        : createProjectSettingsUpdateProjectCommand(inverseValues);
+        : command.schemaVersion ===
+            withoutCoverProjectSettingsUpdateCommandSchemaVersion
+          ? createWithoutCoverProjectSettingsUpdateCommand(inverseValues)
+          : createProjectSettingsUpdateProjectCommand(inverseValues);
     assertDisabledSupplyTypesAreUnused(tx, input.projectId, target);
     const updated = tx
       .update(projects)
@@ -82,11 +103,32 @@ export class ProjectSettingsProjectCommandRepository
   }
 }
 
+function createWithoutCoverProjectSettingsUpdateCommand(
+  values: ProjectSettingsValues
+) {
+  return {
+    schemaVersion: withoutCoverProjectSettingsUpdateCommandSchemaVersion,
+    type: "project.update-settings" as const,
+    payload: {
+      name: values.name,
+      internalProjectNumber: values.internalProjectNumber,
+      externalProjectNumber: values.externalProjectNumber,
+      buildingOwner: values.buildingOwner,
+      description: values.description,
+      isPublicBuilding: values.isPublicBuilding,
+      singlePhaseVoltageV: values.singlePhaseVoltageV,
+      threePhaseVoltageV: values.threePhaseVoltageV,
+      enabledDistributionBoardSupplyTypes:
+        values.enabledDistributionBoardSupplyTypes,
+    },
+  };
+}
+
 function createBaselineProjectSettingsUpdateCommand(
   values: ProjectSettingsValues
 ) {
   return {
-    schemaVersion: 1 as const,
+    schemaVersion: baselineProjectSettingsUpdateCommandSchemaVersion,
     type: "project.update-settings" as const,
     payload: {
       name: values.name,
@@ -114,8 +156,9 @@ function projectSettingsEqual(
     current.description === target.description &&
     current.isPublicBuilding === target.isPublicBuilding &&
     current.singlePhaseVoltageV === target.singlePhaseVoltageV &&
-    current.threePhaseVoltageV === target.threePhaseVoltageV
-    && sameSupplyTypes(
+    current.threePhaseVoltageV === target.threePhaseVoltageV &&
+    projectCoverFields.every((field) => current[field] === target[field]) &&
+    sameSupplyTypes(
       current.enabledDistributionBoardSupplyTypes,
       target.enabledDistributionBoardSupplyTypes
     )
diff --git a/src/db/repositories/project-state-restore-command.repository.ts b/src/db/repositories/project-state-restore-command.repository.ts
index dcae184..cf6f9bc 100644
--- a/src/db/repositories/project-state-restore-command.repository.ts
+++ b/src/db/repositories/project-state-restore-command.repository.ts
@@ -233,6 +233,10 @@ function replaceProjectState(
       threePhaseVoltageV: state.project.threePhaseVoltageV,
       enabledDistributionBoardSupplyTypes:
         state.project.enabledDistributionBoardSupplyTypes,
+      siteAddress: state.project.siteAddress,
+      workStage: state.project.workStage,
+      projectLead: state.project.projectLead,
+      projectEditor: state.project.projectEditor,
     })
     .where(eq(projects.id, state.project.id))
     .run();
diff --git a/src/db/repositories/project-state-snapshot.persistence.ts b/src/db/repositories/project-state-snapshot.persistence.ts
index 4dbca90..84131e7 100644
--- a/src/db/repositories/project-state-snapshot.persistence.ts
+++ b/src/db/repositories/project-state-snapshot.persistence.ts
@@ -46,6 +46,10 @@ export function readProjectStateSnapshot(
       threePhaseVoltageV: projects.threePhaseVoltageV,
       enabledDistributionBoardSupplyTypes:
         projects.enabledDistributionBoardSupplyTypes,
+      siteAddress: projects.siteAddress,
+      workStage: projects.workStage,
+      projectLead: projects.projectLead,
+      projectEditor: projects.projectEditor,
       currentRevision: projects.currentRevision,
     })
     .from(projects)
@@ -249,6 +253,10 @@ export function readProjectStateSnapshot(
       threePhaseVoltageV: project.threePhaseVoltageV,
       enabledDistributionBoardSupplyTypes:
         project.enabledDistributionBoardSupplyTypes,
+      siteAddress: project.siteAddress,
+      workStage: project.workStage,
+      projectLead: project.projectLead,
+      projectEditor: project.projectEditor,
     },
     distributionBoards: boardRows,
     externalCsvConfiguration,
diff --git a/src/db/repositories/project.repository.ts b/src/db/repositories/project.repository.ts
index 171290e..f35ed4f 100644
--- a/src/db/repositories/project.repository.ts
+++ b/src/db/repositories/project.repository.ts
@@ -31,6 +31,10 @@ export class ProjectRepository {
       enabledDistributionBoardSupplyTypes: [
         ...defaultDistributionBoardSupplyTypes,
       ],
+      siteAddress: null,
+      workStage: null,
+      projectLead: null,
+      projectEditor: null,
       currentRevision: 0,
     };
     await db.insert(projects).values(project);
diff --git a/src/db/schema/document-branding-settings.ts b/src/db/schema/document-branding-settings.ts
new file mode 100644
index 0000000..746536b
--- /dev/null
+++ b/src/db/schema/document-branding-settings.ts
@@ -0,0 +1,13 @@
+import { sql } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+// Office-wide text settings for printed documents (e.g. office name and
+// address on the cover page). Global application data like
+// document_branding_assets: outside project revisions, snapshots and transfer.
+export const documentBrandingSettings = sqliteTable("document_branding_settings", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .notNull()
+    .default(sql`(unixepoch())`),
+});
diff --git a/src/db/schema/projects.ts b/src/db/schema/projects.ts
index d694258..5687fa8 100644
--- a/src/db/schema/projects.ts
+++ b/src/db/schema/projects.ts
@@ -21,5 +21,9 @@ export const projects = sqliteTable("projects", {
     .$type<DistributionBoardSupplyType[]>()
     .notNull()
     .default(sql`'["AV","SV","EV","USV","MSR","SiBe"]'`),
+  siteAddress: text("site_address"),
+  workStage: text("work_stage"),
+  projectLead: text("project_lead"),
+  projectEditor: text("project_editor"),
   currentRevision: integer("current_revision").notNull().default(0),
 });
diff --git a/src/domain/models/project-settings-project-command.model.ts b/src/domain/models/project-settings-project-command.model.ts
index 69e9c5c..fa1b29b 100644
--- a/src/domain/models/project-settings-project-command.model.ts
+++ b/src/domain/models/project-settings-project-command.model.ts
@@ -3,13 +3,23 @@ import {
   distributionBoardSupplyTypes,
   type DistributionBoardSupplyType,
 } from "../../shared/constants/distribution-board.js";
+import {
+  projectCoverFieldMaxLengths,
+  projectCoverFields,
+  type ProjectCoverField,
+} from "../../shared/constants/project-cover.js";
 
 export const projectSettingsUpdateCommandType =
   "project.update-settings" as const;
-export const projectSettingsUpdateCommandSchemaVersion = 2 as const;
-const previousProjectSettingsUpdateCommandSchemaVersion = 1 as const;
+// Version 3 adds the print cover fields. Versions 2 (without cover fields)
+// and 1 (additionally without the public-building flag) stay executable;
+// their missing values keep the current project values.
+export const projectSettingsUpdateCommandSchemaVersion = 3 as const;
+export const withoutCoverProjectSettingsUpdateCommandSchemaVersion = 2 as const;
+export const baselineProjectSettingsUpdateCommandSchemaVersion = 1 as const;
 
-export interface ProjectSettingsValues {
+export interface ProjectSettingsValues
+  extends Record<ProjectCoverField, string | null> {
   name: string;
   internalProjectNumber: string | null;
   externalProjectNumber: string | null;
@@ -21,8 +31,13 @@ export interface ProjectSettingsValues {
   enabledDistributionBoardSupplyTypes: DistributionBoardSupplyType[];
 }
 
-type PreviousProjectSettingsValues = Omit<
+export type WithoutCoverProjectSettingsValues = Omit<
   ProjectSettingsValues,
+  ProjectCoverField
+>;
+
+export type BaselineProjectSettingsValues = Omit<
+  WithoutCoverProjectSettingsValues,
   "isPublicBuilding"
 >;
 
@@ -32,15 +47,22 @@ export interface CurrentProjectSettingsUpdateProjectCommand
   type: typeof projectSettingsUpdateCommandType;
 }
 
-interface PreviousProjectSettingsUpdateProjectCommand
-  extends SerializedProjectCommand<PreviousProjectSettingsValues> {
-  schemaVersion: typeof previousProjectSettingsUpdateCommandSchemaVersion;
+export interface WithoutCoverProjectSettingsUpdateProjectCommand
+  extends SerializedProjectCommand<WithoutCoverProjectSettingsValues> {
+  schemaVersion: typeof withoutCoverProjectSettingsUpdateCommandSchemaVersion;
+  type: typeof projectSettingsUpdateCommandType;
+}
+
+export interface BaselineProjectSettingsUpdateProjectCommand
+  extends SerializedProjectCommand<BaselineProjectSettingsValues> {
+  schemaVersion: typeof baselineProjectSettingsUpdateCommandSchemaVersion;
   type: typeof projectSettingsUpdateCommandType;
 }
 
 export type ProjectSettingsUpdateProjectCommand =
   | CurrentProjectSettingsUpdateProjectCommand
-  | PreviousProjectSettingsUpdateProjectCommand;
+  | WithoutCoverProjectSettingsUpdateProjectCommand
+  | BaselineProjectSettingsUpdateProjectCommand;
 
 export function createProjectSettingsUpdateProjectCommand(
   values: ProjectSettingsValues
@@ -60,7 +82,10 @@ export function assertProjectSettingsUpdateProjectCommand(
   if (
     command.type !== projectSettingsUpdateCommandType ||
     (command.schemaVersion !== projectSettingsUpdateCommandSchemaVersion &&
-      command.schemaVersion !== previousProjectSettingsUpdateCommandSchemaVersion)
+      command.schemaVersion !==
+        withoutCoverProjectSettingsUpdateCommandSchemaVersion &&
+      command.schemaVersion !==
+        baselineProjectSettingsUpdateCommandSchemaVersion)
   ) {
     throw new Error("Unsupported project settings update command.");
   }
@@ -91,13 +116,23 @@ export function assertProjectSettingsUpdateProjectCommand(
       "Project settings update command contains invalid supply types."
     );
   }
-  const isPreviousSchema =
-    command.schemaVersion === previousProjectSettingsUpdateCommandSchemaVersion;
+  const payload = command.payload;
+  const expectedKeyCount =
+    command.schemaVersion === baselineProjectSettingsUpdateCommandSchemaVersion
+      ? 8
+      : command.schemaVersion ===
+          withoutCoverProjectSettingsUpdateCommandSchemaVersion
+        ? 9
+        : 9 + projectCoverFields.length;
   if (
-    (isPreviousSchema && Object.keys(command.payload).length !== 8) ||
-    (!isPreviousSchema &&
-      (typeof command.payload.isPublicBuilding !== "boolean" ||
-        Object.keys(command.payload).length !== 9))
+    Object.keys(payload).length !== expectedKeyCount ||
+    (command.schemaVersion !==
+      baselineProjectSettingsUpdateCommandSchemaVersion &&
+      typeof payload.isPublicBuilding !== "boolean") ||
+    (command.schemaVersion === projectSettingsUpdateCommandSchemaVersion &&
+      !projectCoverFields.every((field) =>
+        isNullableTrimmedString(payload[field], projectCoverFieldMaxLengths[field])
+      ))
   ) {
     throw new Error(
       "Project settings update command contains invalid values."
diff --git a/src/domain/models/project-state-snapshot.model.ts b/src/domain/models/project-state-snapshot.model.ts
index 57dafc5..5564e1f 100644
--- a/src/domain/models/project-state-snapshot.model.ts
+++ b/src/domain/models/project-state-snapshot.model.ts
@@ -4,6 +4,10 @@ import {
   distributionBoardSupplyTypes,
   type DistributionBoardInfoField,
 } from "../../shared/constants/distribution-board.js";
+import {
+  projectCoverFieldMaxLengths,
+  type ProjectCoverField,
+} from "../../shared/constants/project-cover.js";
 import {
   circuitGroupCategories,
 } from "../../shared/constants/circuit-group.js";
@@ -63,10 +67,30 @@ const previousProjectSchema = z
   })
   .strict();
 
-const projectSchema = previousProjectSchema
+const publicBuildingProjectSchema = previousProjectSchema
   .extend({ isPublicBuilding: z.boolean() })
   .strict();
 
+const projectCoverValueSchema = (field: ProjectCoverField) =>
+  z.string().trim().min(1).max(projectCoverFieldMaxLengths[field]).nullable();
+
+// Schema version 6 adds the print cover fields.
+const projectSchema = publicBuildingProjectSchema
+  .extend({
+    siteAddress: projectCoverValueSchema("siteAddress"),
+    workStage: projectCoverValueSchema("workStage"),
+    projectLead: projectCoverValueSchema("projectLead"),
+    projectEditor: projectCoverValueSchema("projectEditor"),
+  })
+  .strict();
+
+const emptyProjectCoverValues = {
+  siteAddress: null,
+  workStage: null,
+  projectLead: null,
+  projectEditor: null,
+};
+
 const legacyDistributionBoardSchema = z
   .object({
     id: idSchema,
@@ -494,7 +518,7 @@ export const projectStateSnapshotSchema = z
 const boardInfoProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(boardInfoProjectStateSnapshotSchemaVersion),
-    project: projectSchema,
+    project: publicBuildingProjectSchema,
     distributionBoards: z.array(legacyDistributionBoardSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
     externalModel: externalModelStateSchema,
@@ -505,7 +529,7 @@ const boardInfoProjectStateSnapshotSchema = z
 const previousProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(previousProjectStateSnapshotSchemaVersion),
-    project: projectSchema,
+    project: publicBuildingProjectSchema,
     distributionBoards: z.array(legacyDistributionBoardSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
     externalModel: externalModelStateSchema,
@@ -516,7 +540,7 @@ const previousProjectStateSnapshotSchema = z
 const externalModelProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(externalModelProjectStateSnapshotSchemaVersion),
-    project: projectSchema,
+    project: publicBuildingProjectSchema,
     distributionBoards: z.array(legacyDistributionBoardSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
     ...projectStateSnapshotContents,
@@ -526,7 +550,7 @@ const externalModelProjectStateSnapshotSchema = z
 const legacyProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(legacyProjectStateSnapshotSchemaVersion),
-    project: projectSchema,
+    project: publicBuildingProjectSchema,
     distributionBoards: z.array(legacyDistributionBoardSchema),
     ...projectStateSnapshotContents,
   })
@@ -581,12 +605,14 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
   }
   const schemaVersion = (value as { schemaVersion: number }).schemaVersion;
   // Every supported version before 6 lacks the distribution-board info
-  // fields; they are upgraded as empty (null) values.
+  // fields and the project cover fields; they are upgraded as empty (null)
+  // values.
   if (schemaVersion === boardInfoProjectStateSnapshotSchemaVersion) {
     const previous = boardInfoProjectStateSnapshotSchema.parse(value);
     return {
       ...previous,
       schemaVersion: projectStateSnapshotSchemaVersion,
+      project: { ...previous.project, ...emptyProjectCoverValues },
       distributionBoards: withEmptyDistributionBoardInfo(
         previous.distributionBoards
       ),
@@ -597,6 +623,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     return {
       ...previous,
       schemaVersion: projectStateSnapshotSchemaVersion,
+      project: { ...previous.project, ...emptyProjectCoverValues },
       distributionBoards: withEmptyDistributionBoardInfo(
         previous.distributionBoards
       ),
@@ -607,6 +634,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     return {
       ...previous,
       schemaVersion: projectStateSnapshotSchemaVersion,
+      project: { ...previous.project, ...emptyProjectCoverValues },
       distributionBoards: withEmptyDistributionBoardInfo(
         previous.distributionBoards
       ),
@@ -618,6 +646,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     return {
       ...legacy,
       schemaVersion: projectStateSnapshotSchemaVersion,
+      project: { ...legacy.project, ...emptyProjectCoverValues },
       distributionBoards: withEmptyDistributionBoardInfo(
         legacy.distributionBoards
       ),
@@ -630,7 +659,11 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     return {
       ...baseline,
       schemaVersion: projectStateSnapshotSchemaVersion,
-      project: { ...baseline.project, isPublicBuilding: false },
+      project: {
+        ...baseline.project,
+        isPublicBuilding: false,
+        ...emptyProjectCoverValues,
+      },
       distributionBoards: withEmptyDistributionBoardInfo(
         baseline.distributionBoards
       ),
diff --git a/src/frontend/components/project-settings-modal.tsx b/src/frontend/components/project-settings-modal.tsx
index 4af751c..21c40ad 100644
--- a/src/frontend/components/project-settings-modal.tsx
+++ b/src/frontend/components/project-settings-modal.tsx
@@ -7,9 +7,16 @@ import {
   distributionBoardSupplyTypes,
   type DistributionBoardSupplyType,
 } from "../../shared/constants/distribution-board";
+import {
+  projectCoverFieldLabels,
+  projectCoverFieldMaxLengths,
+  projectCoverFields,
+  type ProjectCoverField,
+} from "../../shared/constants/project-cover";
 import { FormModal } from "./form-modal";
 
-export interface ProjectSettingsInput {
+export interface ProjectSettingsInput
+  extends Record<ProjectCoverField, string | null> {
   name: string;
   internalProjectNumber: string | null;
   externalProjectNumber: string | null;
@@ -21,6 +28,13 @@ export interface ProjectSettingsInput {
   enabledDistributionBoardSupplyTypes: DistributionBoardSupplyType[];
 }
 
+const coverFieldPlaceholders: Record<ProjectCoverField, string> = {
+  siteAddress: "Straße Nr.\nPLZ Ort",
+  workStage: "z. B. LPH 5 – Ausführungsplanung",
+  projectLead: "",
+  projectEditor: "",
+};
+
 interface ProjectSettingsModalProps {
   isSaving: boolean;
   onClose: () => void;
@@ -71,6 +85,14 @@ export function ProjectSettingsModal({
   ] = useState<DistributionBoardSupplyType[]>(
     project.enabledDistributionBoardSupplyTypes
   );
+  const [coverValues, setCoverValues] = useState<
+    Record<ProjectCoverField, string>
+  >({
+    siteAddress: project.siteAddress ?? "",
+    workStage: project.workStage ?? "",
+    projectLead: project.projectLead ?? "",
+    projectEditor: project.projectEditor ?? "",
+  });
   const [transfer, setTransfer] = useState<unknown>(null);
   const [transferFilename, setTransferFilename] = useState("");
   const [importMode, setImportMode] = useState<"replace" | "duplicate">(
@@ -91,6 +113,10 @@ export function ProjectSettingsModal({
       singlePhaseVoltageV: Number(singlePhaseVoltageV),
       threePhaseVoltageV: Number(threePhaseVoltageV),
       enabledDistributionBoardSupplyTypes,
+      siteAddress: toNullableString(coverValues.siteAddress),
+      workStage: toNullableString(coverValues.workStage),
+      projectLead: toNullableString(coverValues.projectLead),
+      projectEditor: toNullableString(coverValues.projectEditor),
     });
   }
 
@@ -309,6 +335,57 @@ export function ProjectSettingsModal({
             value={threePhaseVoltageV}
           />
         </div>
+        <div className="col-12">
+          <hr className="my-2" />
+          <h3 className="h6">Deckblatt</h3>
+          <p className="text-secondary small">
+            Angaben für das Deckblatt der Seitenansicht. Büroname und
+            Büroanschrift werden projektübergreifend in der Seitenansicht
+            gepflegt.
+          </p>
+          <div className="row g-3">
+            {projectCoverFields.map((field) => (
+              <div
+                className={field === "siteAddress" ? "col-12" : "col-12 col-md-6"}
+                key={field}
+              >
+                <label className="form-label" htmlFor={`project-cover-${field}`}>
+                  {projectCoverFieldLabels[field]}
+                </label>
+                {field === "siteAddress" ? (
+                  <textarea
+                    className="form-control"
+                    id={`project-cover-${field}`}
+                    maxLength={projectCoverFieldMaxLengths[field]}
+                    onChange={(event) =>
+                      setCoverValues((current) => ({
+                        ...current,
+                        [field]: event.target.value,
+                      }))
+                    }
+                    placeholder={coverFieldPlaceholders[field]}
+                    rows={2}
+                    value={coverValues[field]}
+                  />
+                ) : (
+                  <input
+                    className="form-control"
+                    id={`project-cover-${field}`}
+                    maxLength={projectCoverFieldMaxLengths[field]}
+                    onChange={(event) =>
+                      setCoverValues((current) => ({
+                        ...current,
+                        [field]: event.target.value,
+                      }))
+                    }
+                    placeholder={coverFieldPlaceholders[field]}
+                    value={coverValues[field]}
+                  />
+                )}
+              </div>
+            ))}
+          </div>
+        </div>
         <div className="col-12">
           <hr className="my-2" />
           <h3 className="h6">Projekt importieren oder exportieren</h3>
diff --git a/src/frontend/print/print-document.css b/src/frontend/print/print-document.css
index 8a0784d..9fa3b79 100644
--- a/src/frontend/print/print-document.css
+++ b/src/frontend/print/print-document.css
@@ -1,6 +1,6 @@
-/* Print view (Seitenansicht) in the provisional kbp corporate design.
-   Colors are derived from the kbp logo and presentation material and will be
-   replaced by the official CD specification; change them only here.
+/* Print view (Seitenansicht) in the kbp corporate design. Colors are
+   derived from the kbp logo and presentation material; change them only
+   here.
    All selectors are scoped to .print-view. The @page rules (format, margins,
    page numbers) are injected by the print page because they need project
    data. */
@@ -113,6 +113,9 @@
   color: var(--pd-accent);
   font-weight: bold;
 }
+.pd-multiline {
+  white-space: pre-line;
+}
 .pd-logo {
   display: block;
   max-width: 100%;
diff --git a/src/frontend/print/print-document.tsx b/src/frontend/print/print-document.tsx
index 4270dbc..98a9df3 100644
--- a/src/frontend/print/print-document.tsx
+++ b/src/frontend/print/print-document.tsx
@@ -5,6 +5,7 @@ import type {
   CircuitTreeCircuitDto,
   CircuitTreeComponentDto,
   CircuitTreeDeviceRowDto,
+  OfficeProfileDto,
   ProjectDto,
   ProjectSnapshotMetadataDto,
 } from "../types";
@@ -18,17 +19,23 @@ import {
   type PrintBoardHierarchyEntry,
 } from "./print-document-model";
 
-// Provisional office data until the project/cover fields are added.
-export const printOfficeName = "kbp köhler beraten + planen GmbH";
-
 export interface PrintDocumentProps {
   project: ProjectDto;
+  office: OfficeProfileDto;
   entries: PrintBoardHierarchyEntry[];
   namedSnapshots: ProjectSnapshotMetadataDto[];
   logoSrc: string | null;
   printedAt: Date;
 }
 
+/** Shows a value or the orange "[ergänzen]" marker for missing data. */
+function Value({ value, multiline = false }: { value: string | null; multiline?: boolean }) {
+  if (!value) {
+    return <Placeholder />;
+  }
+  return multiline ? <span className="pd-multiline">{value}</span> : <>{value}</>;
+}
+
 const dateFormat = new Intl.DateTimeFormat("de-DE", {
   day: "2-digit",
   month: "2-digit",
@@ -129,6 +136,7 @@ function boardLabel(entry: PrintBoardHierarchyEntry) {
 
 function CoverSheet({
   project,
+  office,
   entries,
   namedSnapshots,
   logoSrc,
@@ -149,11 +157,11 @@ function CoverSheet({
         <caption>Projekt</caption>
         <tbody>
           <tr><th>Bauvorhaben</th><td>{project.name}</td></tr>
-          <tr><th>Anschrift</th><td><Placeholder /></td></tr>
-          <tr><th>Bauherr</th><td>{project.buildingOwner ?? <Placeholder />}</td></tr>
-          <tr><th>Projektnummer intern</th><td>{project.internalProjectNumber ?? <Placeholder />}</td></tr>
-          <tr><th>Projektnummer extern</th><td>{project.externalProjectNumber ?? <Placeholder />}</td></tr>
-          <tr><th>Leistungsphase</th><td><Placeholder /></td></tr>
+          <tr><th>Anschrift</th><td><Value multiline value={project.siteAddress} /></td></tr>
+          <tr><th>Bauherr</th><td><Value value={project.buildingOwner} /></td></tr>
+          <tr><th>Projektnummer intern</th><td><Value value={project.internalProjectNumber} /></td></tr>
+          <tr><th>Projektnummer extern</th><td><Value value={project.externalProjectNumber} /></td></tr>
+          <tr><th>Leistungsphase</th><td><Value value={project.workStage} /></td></tr>
           <tr><th>Gewerk</th><td>KG 440 – Starkstromanlagen</td></tr>
           <tr><th>Beschreibung</th><td>{project.description ?? "–"}</td></tr>
         </tbody>
@@ -163,10 +171,10 @@ function CoverSheet({
         <table className="pd-kv">
           <caption>Planverfasser</caption>
           <tbody>
-            <tr><th>Büro</th><td>{printOfficeName}</td></tr>
-            <tr><th>Anschrift</th><td><Placeholder /></td></tr>
-            <tr><th>Projektleitung</th><td><Placeholder /></td></tr>
-            <tr><th>Bearbeitung</th><td><Placeholder /></td></tr>
+            <tr><th>Büro</th><td><Value value={office.officeName} /></td></tr>
+            <tr><th>Anschrift</th><td><Value multiline value={office.officeAddress} /></td></tr>
+            <tr><th>Projektleitung</th><td><Value value={project.projectLead} /></td></tr>
+            <tr><th>Bearbeitung</th><td><Value value={project.projectEditor} /></td></tr>
           </tbody>
         </table>
         <table className="pd-kv">
@@ -192,7 +200,9 @@ function CoverSheet({
                 <td>{String.fromCharCode(97 + (index % 26))}</td>
                 <td>{dateFormat.format(new Date(snapshot.createdAtIso))}</td>
                 <td>{snapshot.name}</td>
-                <td><Placeholder /></td>
+                {/* Snapshots do not record an editor yet; the project's
+                    current editor is shown for every entry. */}
+                <td><Value value={project.projectEditor} /></td>
               </tr>
             ))
           ) : (
@@ -582,6 +592,7 @@ function SectionRows({
 
 export function PrintDocument({
   project,
+  office,
   entries,
   namedSnapshots,
   logoSrc,
@@ -594,6 +605,7 @@ export function PrintDocument({
         entries={entries}
         logoSrc={logoSrc}
         namedSnapshots={namedSnapshots}
+        office={office}
         project={project}
         stand={stand}
       />
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index a964b74..49bb77f 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -93,9 +93,18 @@ export interface ProjectDto {
   singlePhaseVoltageV: number;
   threePhaseVoltageV: number;
   enabledDistributionBoardSupplyTypes: DistributionBoardSupplyType[];
+  siteAddress: string | null;
+  workStage: string | null;
+  projectLead: string | null;
+  projectEditor: string | null;
   currentRevision: number;
 }
 
+export interface OfficeProfileDto {
+  officeName: string | null;
+  officeAddress: string | null;
+}
+
 export interface ProjectHistoryStateDto {
   projectId: string;
   currentRevision: number;
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index e5be802..d55a915 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -11,6 +11,7 @@ import type {
   DistributionBoardInfoDto,
   DocumentLogoMetadataDto,
   FloorDto,
+  OfficeProfileDto,
   GlobalDeviceDto,
   ProjectCommandDto,
   ProjectCommandResultDto,
@@ -258,7 +259,7 @@ export function updateProjectSettings(
     singlePhaseVoltageV: number;
     threePhaseVoltageV: number;
     enabledDistributionBoardSupplyTypes: ProjectDto["enabledDistributionBoardSupplyTypes"];
-  }
+  } & Partial<Pick<ProjectDto, "siteAddress" | "workStage" | "projectLead" | "projectEditor">>
 ) {
   return request<ProjectSettingsCommandResultDto>(
     `/api/projects/${projectId}`,
@@ -346,9 +347,17 @@ export function updateDistributionBoard(
 export const documentLogoUrl = "/api/document-branding/logo";
 
 export function getDocumentBranding() {
-  return request<{ logo: DocumentLogoMetadataDto | null }>(
-    "/api/document-branding"
-  );
+  return request<{
+    logo: DocumentLogoMetadataDto | null;
+    office: OfficeProfileDto;
+  }>("/api/document-branding");
+}
+
+export function updateOfficeProfile(office: OfficeProfileDto) {
+  return request<{ office: OfficeProfileDto }>("/api/document-branding/office", {
+    method: "PUT",
+    body: JSON.stringify(office),
+  });
 }
 
 export async function uploadDocumentLogo(file: File) {
diff --git a/src/server/controllers/document-branding.controller.ts b/src/server/controllers/document-branding.controller.ts
index eda6ce5..c8f6514 100644
--- a/src/server/controllers/document-branding.controller.ts
+++ b/src/server/controllers/document-branding.controller.ts
@@ -1,7 +1,9 @@
 import type { Request, Response } from "express";
 import type { DocumentBrandingAsset } from "../../db/schema/document-branding-assets.js";
+import { officeProfileFields } from "../../shared/constants/project-cover.js";
 import {
   maxDocumentLogoBytes,
+  updateOfficeProfileSchema,
   uploadDocumentLogoSchema,
   type DocumentLogoMimeType,
 } from "../../shared/validation/document-branding.schemas.js";
@@ -11,7 +13,21 @@ const logoKey = "logo";
 
 export function getDocumentBrandingHandler(_req: Request, res: Response) {
   const logo = documentBrandingRepository.get(logoKey);
-  return res.json({ logo: logo ? toLogoMetadata(logo) : null });
+  return res.json({
+    logo: logo ? toLogoMetadata(logo) : null,
+    office: documentBrandingRepository.getSettings(officeProfileFields),
+  });
+}
+
+export function updateOfficeProfileHandler(req: Request, res: Response) {
+  const parsed = updateOfficeProfileSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+  documentBrandingRepository.setSettings(parsed.data);
+  return res.json({
+    office: documentBrandingRepository.getSettings(officeProfileFields),
+  });
 }
 
 export function getDocumentLogoHandler(_req: Request, res: Response) {
diff --git a/src/server/controllers/project.controller.ts b/src/server/controllers/project.controller.ts
index f739542..e3cd43e 100644
--- a/src/server/controllers/project.controller.ts
+++ b/src/server/controllers/project.controller.ts
@@ -4,6 +4,10 @@ import {
   updateProjectSettingsSchema,
 } from "../../shared/validation/project-structure.schemas.js";
 import { createProjectSettingsUpdateProjectCommand } from "../../domain/models/project-settings-project-command.model.js";
+import {
+  projectCoverFields,
+  type ProjectCoverField,
+} from "../../shared/constants/project-cover.js";
 import { projectCommandService } from "../composition/project-command-stores.js";
 import { projectRepository } from "../composition/application-repositories.js";
 import { respondWithProjectCommandError } from "./project-command.controller.js";
@@ -46,12 +50,27 @@ export async function updateProjectSettings(req: Request, res: Response) {
   }
 
   const { expectedRevision, ...settings } = parsed.data;
+  const current = await projectRepository.findById(projectId);
+  if (!current) {
+    return res.status(404).json({ error: "Project not found" });
+  }
+  // Cover fields are optional in the request and keep their current value
+  // when omitted. `expectedRevision` rejects a project changed meanwhile.
+  const coverValues = Object.fromEntries(
+    projectCoverFields.map((field) => [
+      field,
+      settings[field] === undefined ? current[field] : settings[field],
+    ])
+  ) as Record<ProjectCoverField, string | null>;
   try {
     const result = projectCommandService.executeUser({
       projectId,
       expectedRevision,
       description: "Projekteinstellungen bearbeiten",
-      command: createProjectSettingsUpdateProjectCommand(settings),
+      command: createProjectSettingsUpdateProjectCommand({
+        ...settings,
+        ...coverValues,
+      }),
     });
     const project = await projectRepository.findById(projectId);
     if (!project) {
diff --git a/src/server/routes/document-branding.routes.ts b/src/server/routes/document-branding.routes.ts
index b12581b..298fc4d 100644
--- a/src/server/routes/document-branding.routes.ts
+++ b/src/server/routes/document-branding.routes.ts
@@ -4,6 +4,7 @@ import * as documentBrandingController from "../controllers/document-branding.co
 export const documentBrandingRouter = express.Router();
 
 documentBrandingRouter.get("/", documentBrandingController.getDocumentBrandingHandler);
+documentBrandingRouter.put("/office", documentBrandingController.updateOfficeProfileHandler);
 documentBrandingRouter.get("/logo", documentBrandingController.getDocumentLogoHandler);
 documentBrandingRouter.put("/logo", documentBrandingController.uploadDocumentLogoHandler);
 documentBrandingRouter.delete("/logo", documentBrandingController.deleteDocumentLogoHandler);
diff --git a/src/shared/constants/document-branding.ts b/src/shared/constants/document-branding.ts
new file mode 100644
index 0000000..71afec5
--- /dev/null
+++ b/src/shared/constants/document-branding.ts
@@ -0,0 +1,9 @@
+export const documentLogoMimeTypes = [
+  "image/png",
+  "image/jpeg",
+  "image/svg+xml",
+] as const;
+
+export type DocumentLogoMimeType = (typeof documentLogoMimeTypes)[number];
+
+export const maxDocumentLogoBytes = 2 * 1024 * 1024;
diff --git a/src/shared/constants/project-cover.ts b/src/shared/constants/project-cover.ts
new file mode 100644
index 0000000..5b405fd
--- /dev/null
+++ b/src/shared/constants/project-cover.ts
@@ -0,0 +1,45 @@
+/**
+ * Project data shown on the print view cover page. They are ordinary project
+ * settings (persisted through `project.update-settings`, part of logical
+ * snapshots and project transfer).
+ */
+export const projectCoverFields = [
+  "siteAddress",
+  "workStage",
+  "projectLead",
+  "projectEditor",
+] as const;
+
+export type ProjectCoverField = (typeof projectCoverFields)[number];
+
+export const projectCoverFieldLabels: Record<ProjectCoverField, string> = {
+  siteAddress: "Anschrift Bauvorhaben",
+  workStage: "Leistungsphase",
+  projectLead: "Projektleitung",
+  projectEditor: "Bearbeitung",
+};
+
+export const projectCoverFieldMaxLengths: Record<ProjectCoverField, number> = {
+  siteAddress: 500,
+  workStage: 100,
+  projectLead: 200,
+  projectEditor: 200,
+};
+
+/**
+ * Office-wide data for the cover page ("Planverfasser"). Global branding like
+ * the document logo, outside project revisions and snapshots.
+ */
+export const officeProfileFields = ["officeName", "officeAddress"] as const;
+
+export type OfficeProfileField = (typeof officeProfileFields)[number];
+
+export const officeProfileFieldLabels: Record<OfficeProfileField, string> = {
+  officeName: "Büro",
+  officeAddress: "Anschrift Büro",
+};
+
+export const officeProfileFieldMaxLengths: Record<OfficeProfileField, number> = {
+  officeName: 200,
+  officeAddress: 500,
+};
diff --git a/src/shared/validation/document-branding.schemas.ts b/src/shared/validation/document-branding.schemas.ts
index 3d40572..f88b03b 100644
--- a/src/shared/validation/document-branding.schemas.ts
+++ b/src/shared/validation/document-branding.schemas.ts
@@ -1,14 +1,15 @@
 import { z } from "zod";
+import {
+  documentLogoMimeTypes,
+  maxDocumentLogoBytes,
+} from "../constants/document-branding.js";
+import { officeProfileFieldMaxLengths } from "../constants/project-cover.js";
 
-export const documentLogoMimeTypes = [
-  "image/png",
-  "image/jpeg",
-  "image/svg+xml",
-] as const;
-
-export type DocumentLogoMimeType = (typeof documentLogoMimeTypes)[number];
-
-export const maxDocumentLogoBytes = 2 * 1024 * 1024;
+export {
+  documentLogoMimeTypes,
+  maxDocumentLogoBytes,
+  type DocumentLogoMimeType,
+} from "../constants/document-branding.js";
 
 export const uploadDocumentLogoSchema = z
   .object({
@@ -23,3 +24,19 @@ export const uploadDocumentLogoSchema = z
   .strict();
 
 export type UploadDocumentLogoInput = z.infer<typeof uploadDocumentLogoSchema>;
+
+// Empty text is stored as "not set" (null).
+const officeValueSchema = (maximumLength: number) =>
+  z
+    .string()
+    .trim()
+    .max(maximumLength)
+    .nullable()
+    .transform((value) => (value ? value : null));
+
+export const updateOfficeProfileSchema = z
+  .object({
+    officeName: officeValueSchema(officeProfileFieldMaxLengths.officeName),
+    officeAddress: officeValueSchema(officeProfileFieldMaxLengths.officeAddress),
+  })
+  .strict();
diff --git a/src/shared/validation/project-structure.schemas.ts b/src/shared/validation/project-structure.schemas.ts
index 4dd4c3c..143be0a 100644
--- a/src/shared/validation/project-structure.schemas.ts
+++ b/src/shared/validation/project-structure.schemas.ts
@@ -4,8 +4,22 @@ import {
   distributionBoardSupplyTypes,
   type DistributionBoardInfoField,
 } from "../constants/distribution-board.js";
+import {
+  projectCoverFieldMaxLengths,
+  type ProjectCoverField,
+} from "../constants/project-cover.js";
 import { expectedProjectRevisionSchema } from "./project-command.schemas.js";
 
+// Empty text is stored as null so "not entered" has one representation.
+const optionalCoverValueSchema = (field: ProjectCoverField) =>
+  z
+    .string()
+    .trim()
+    .max(projectCoverFieldMaxLengths[field])
+    .nullable()
+    .transform((value) => (value ? value : null))
+    .optional();
+
 export const createProjectSchema = z.object({
   name: z.string().trim().min(1).max(200),
   internalProjectNumber: z.string().trim().max(100).optional(),
@@ -34,6 +48,11 @@ export const updateProjectSettingsSchema = z
       .refine((values) => new Set(values).size === values.length, {
         message: "Netzarten dürfen nicht mehrfach ausgewählt werden.",
       }),
+    // Print cover fields; omitted fields keep their current value.
+    siteAddress: optionalCoverValueSchema("siteAddress"),
+    workStage: optionalCoverValueSchema("workStage"),
+    projectLead: optionalCoverValueSchema("projectLead"),
+    projectEditor: optionalCoverValueSchema("projectEditor"),
   })
   .strict();
 
diff --git a/tests/document-branding.repository.test.ts b/tests/document-branding.repository.test.ts
new file mode 100644
index 0000000..cde5bb9
--- /dev/null
+++ b/tests/document-branding.repository.test.ts
@@ -0,0 +1,77 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { DocumentBrandingRepository } from "../src/db/repositories/document-branding.repository.js";
+import { officeProfileFields } from "../src/shared/constants/project-cover.js";
+import { updateOfficeProfileSchema } from "../src/shared/validation/document-branding.schemas.js";
+
+function createRepository() {
+  const context = createDatabaseContext(":memory:");
+  migrate(context.db, {
+    migrationsFolder: path.resolve("src", "db", "migrations"),
+  });
+  return { context, repository: new DocumentBrandingRepository(context.db) };
+}
+
+describe("document branding repository", () => {
+  it("stores, replaces and removes the office profile", () => {
+    const { context, repository } = createRepository();
+    try {
+      assert.deepEqual(repository.getSettings(officeProfileFields), {
+        officeName: null,
+        officeAddress: null,
+      });
+      repository.setSettings(
+        updateOfficeProfileSchema.parse({
+          officeName: " kbp köhler beraten + planen GmbH ",
+          officeAddress: "Straße 1\n12345 Ort",
+        })
+      );
+      assert.deepEqual(repository.getSettings(officeProfileFields), {
+        officeName: "kbp köhler beraten + planen GmbH",
+        officeAddress: "Straße 1\n12345 Ort",
+      });
+      repository.setSettings(
+        updateOfficeProfileSchema.parse({ officeName: "Büro", officeAddress: "" })
+      );
+      assert.deepEqual(repository.getSettings(officeProfileFields), {
+        officeName: "Büro",
+        officeAddress: null,
+      });
+      assert.equal(
+        updateOfficeProfileSchema.safeParse({ officeName: "x".repeat(201), officeAddress: null })
+          .success,
+        false
+      );
+    } finally {
+      context.close();
+    }
+  });
+
+  it("replaces and deletes the logo", () => {
+    const { context, repository } = createRepository();
+    try {
+      repository.upsert({
+        key: "logo",
+        mimeType: "image/png",
+        fileName: "a.png",
+        data: Buffer.from([1, 2, 3]),
+      });
+      repository.upsert({
+        key: "logo",
+        mimeType: "image/svg+xml",
+        fileName: "b.svg",
+        data: Buffer.from("<svg/>"),
+      });
+      const logo = repository.get("logo");
+      assert.equal(logo?.mimeType, "image/svg+xml");
+      assert.equal(logo?.data.toString(), "<svg/>");
+      assert.equal(repository.delete("logo"), true);
+      assert.equal(repository.get("logo"), undefined);
+    } finally {
+      context.close();
+    }
+  });
+});
diff --git a/tests/project-command.service.test.ts b/tests/project-command.service.test.ts
index 545b3e1..861edcd 100644
--- a/tests/project-command.service.test.ts
+++ b/tests/project-command.service.test.ts
@@ -1074,6 +1074,10 @@ describe("project command service", () => {
             "MSR",
             "SiBe",
           ],
+          siteAddress: null,
+          workStage: null,
+          projectLead: null,
+          projectEditor: null,
         }),
       });
       assert.equal(updated.history.currentRevision, 1);
diff --git a/tests/project-settings-project-command.repository.test.ts b/tests/project-settings-project-command.repository.test.ts
index 0677767..610fbbe 100644
--- a/tests/project-settings-project-command.repository.test.ts
+++ b/tests/project-settings-project-command.repository.test.ts
@@ -52,6 +52,10 @@ function getSettings(context: DatabaseContext) {
       threePhaseVoltageV: projects.threePhaseVoltageV,
       enabledDistributionBoardSupplyTypes:
         projects.enabledDistributionBoardSupplyTypes,
+      siteAddress: projects.siteAddress,
+      workStage: projects.workStage,
+      projectLead: projects.projectLead,
+      projectEditor: projects.projectEditor,
       currentRevision: projects.currentRevision,
     })
     .from(projects)
@@ -81,6 +85,10 @@ function settings(
       "MSR",
       "SiBe",
     ],
+    siteAddress: null,
+    workStage: null,
+    projectLead: null,
+    projectEditor: null,
     ...overrides,
   };
 }
@@ -217,6 +225,10 @@ describe("project settings project-command repository", () => {
             "MSR",
             "SiBe",
           ],
+          siteAddress: null,
+          workStage: null,
+          projectLead: null,
+          projectEditor: null,
         },
       },
     ]);
@@ -289,6 +301,10 @@ describe("project settings project-command repository", () => {
           "MSR",
           "SiBe",
         ],
+        siteAddress: null,
+        workStage: null,
+        projectLead: null,
+        projectEditor: null,
       });
 
       const undoStep = history.getNextCommand("project-1", "undo");
@@ -317,6 +333,10 @@ describe("project settings project-command repository", () => {
           "MSR",
           "SiBe",
         ],
+        siteAddress: null,
+        workStage: null,
+        projectLead: null,
+        projectEditor: null,
         currentRevision: 2,
       });
       assert.deepEqual(getDerivedVoltages(context), {
@@ -356,6 +376,10 @@ describe("project settings project-command repository", () => {
           "MSR",
           "SiBe",
         ],
+        siteAddress: null,
+        workStage: null,
+        projectLead: null,
+        projectEditor: null,
         currentRevision: 3,
       });
       assert.deepEqual(getDerivedVoltages(context), {
@@ -433,6 +457,117 @@ describe("project settings project-command repository", () => {
     }
   });
 
+  it("persists the print cover fields with persisted undo", () => {
+    const context = createTestDatabase();
+    try {
+      const repository = new ProjectSettingsProjectCommandRepository(
+        context.db
+      );
+      const readCover = () =>
+        context.db
+          .select({
+            siteAddress: projects.siteAddress,
+            workStage: projects.workStage,
+            projectLead: projects.projectLead,
+            projectEditor: projects.projectEditor,
+          })
+          .from(projects)
+          .where(eq(projects.id, "project-1"))
+          .get();
+      const forward = repository.executeUpdate({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createProjectSettingsUpdateProjectCommand(
+          settings({
+            siteAddress: "Musterstraße 1\n12345 Musterstadt",
+            workStage: "LPH 5",
+            projectLead: "P. Leitung",
+            projectEditor: "B. Arbeiter",
+          })
+        ),
+      });
+      assert.deepEqual(readCover(), {
+        siteAddress: "Musterstraße 1\n12345 Musterstadt",
+        workStage: "LPH 5",
+        projectLead: "P. Leitung",
+        projectEditor: "B. Arbeiter",
+      });
+      assert.equal(forward.inverse.schemaVersion, 3);
+
+      const undoStep = new ProjectHistoryRepository(
+        context.db
+      ).getNextCommand("project-1", "undo");
+      assert.ok(undoStep);
+      repository.executeUpdate({
+        projectId: "project-1",
+        expectedRevision: 1,
+        source: "undo",
+        historyTargetChangeSetId: undoStep.changeSetId,
+        command: forward.inverse,
+      });
+      assert.deepEqual(readCover(), {
+        siteAddress: null,
+        workStage: null,
+        projectLead: null,
+        projectEditor: null,
+      });
+
+      assert.throws(
+        () =>
+          createProjectSettingsUpdateProjectCommand(
+            settings({ workStage: " LPH 5" })
+          ),
+        /invalid values/
+      );
+    } finally {
+      context.close();
+    }
+  });
+
+  it("keeps the cover fields when applying a version 2 command", () => {
+    const context = createTestDatabase();
+    try {
+      context.db
+        .update(projects)
+        .set({ workStage: "LPH 3", projectLead: "P. Leitung" })
+        .where(eq(projects.id, "project-1"))
+        .run();
+      const repository = new ProjectSettingsProjectCommandRepository(
+        context.db
+      );
+      const {
+        siteAddress: _siteAddress,
+        workStage: _workStage,
+        projectLead: _projectLead,
+        projectEditor: _projectEditor,
+        ...versionTwoPayload
+      } = settings({ name: "Stand aus Version 2" });
+      const forward = repository.executeUpdate({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: {
+          schemaVersion: 2,
+          type: "project.update-settings",
+          payload: versionTwoPayload,
+        },
+      });
+      const project = context.db
+        .select()
+        .from(projects)
+        .where(eq(projects.id, "project-1"))
+        .get();
+      assert.equal(project?.name, "Stand aus Version 2");
+      assert.equal(project?.workStage, "LPH 3");
+      assert.equal(project?.projectLead, "P. Leitung");
+      assert.equal(forward.inverse.schemaVersion, 2);
+      assert.equal(Object.keys(forward.inverse.payload).length, 9);
+    } finally {
+      context.close();
+    }
+  });
+
   it("persists the project supply-type selection and rejects disabling an in-use type", () => {
     const context = createTestDatabase();
     try {
diff --git a/tests/project-state-snapshot.test.ts b/tests/project-state-snapshot.test.ts
index 8b84fdb..04d4901 100644
--- a/tests/project-state-snapshot.test.ts
+++ b/tests/project-state-snapshot.test.ts
@@ -8,6 +8,23 @@ import {
 } from "../src/domain/models/project-state-snapshot.model.js";
 import { createNamedProjectSnapshotSchema } from "../src/shared/validation/project-snapshot.schemas.js";
 
+/** Removes the fields introduced by snapshot schema version 6. */
+function withoutVersionSixFields<
+  T extends { project: object; distributionBoards: object[] },
+>(snapshot: T): T {
+  const project = snapshot.project as Record<string, unknown>;
+  for (const field of ["siteAddress", "workStage", "projectLead", "projectEditor"]) {
+    delete project[field];
+  }
+  for (const board of snapshot.distributionBoards) {
+    const record = board as Record<string, unknown>;
+    for (const field of ["boardNumber", "location", "fedFrom", "remark"]) {
+      delete record[field];
+    }
+  }
+  return snapshot;
+}
+
 function minimalSnapshot() {
   return {
     schemaVersion: projectStateSnapshotSchemaVersion,
@@ -29,6 +46,10 @@ function minimalSnapshot() {
         "MSR",
         "SiBe",
       ],
+      siteAddress: "Musterstraße 1\n12345 Musterstadt" as string | null,
+      workStage: "LPH 5" as string | null,
+      projectLead: "P. Leitung" as string | null,
+      projectEditor: null as string | null,
     },
     distributionBoards: [],
     externalCsvConfiguration: null,
@@ -155,7 +176,7 @@ describe("project state snapshot model", () => {
   });
 
   it("upgrades the supported baseline snapshot with a safe building default", () => {
-    const baseline = structuredClone(minimalSnapshot());
+    const baseline = withoutVersionSixFields(structuredClone(minimalSnapshot()));
     baseline.schemaVersion = 1 as typeof baseline.schemaVersion;
     delete (baseline.project as Record<string, unknown>).isPublicBuilding;
     delete (baseline as Record<string, unknown>).externalCsvConfiguration;
@@ -169,7 +190,7 @@ describe("project state snapshot model", () => {
   });
 
   it("upgrades snapshot version 2 with an empty external CSV configuration", () => {
-    const previous = structuredClone(minimalSnapshot());
+    const previous = withoutVersionSixFields(structuredClone(minimalSnapshot()));
     previous.schemaVersion = 2 as typeof previous.schemaVersion;
     delete (previous as Record<string, unknown>).externalCsvConfiguration;
     delete (previous as Record<string, unknown>).externalModel;
@@ -187,7 +208,7 @@ describe("project state snapshot model", () => {
   });
 
   it("upgrades snapshot version 3 with an empty external model", () => {
-    const previous = structuredClone(minimalSnapshot());
+    const previous = withoutVersionSixFields(structuredClone(minimalSnapshot()));
     previous.schemaVersion = 3 as typeof previous.schemaVersion;
     delete (previous as Record<string, unknown>).externalModel;
 
@@ -203,20 +224,22 @@ describe("project state snapshot model", () => {
     });
   });
 
-  it("upgrades snapshot version 5 with empty distribution-board info", () => {
-    const previous = protectedSnapshot();
+  it("upgrades snapshot version 5 with empty board info and cover fields", () => {
+    const previous = withoutVersionSixFields(protectedSnapshot());
     previous.schemaVersion = 5 as typeof previous.schemaVersion;
-    for (const board of previous.distributionBoards) {
-      const record = board as Record<string, unknown>;
-      delete record.boardNumber;
-      delete record.location;
-      delete record.fedFrom;
-      delete record.remark;
-    }
 
     const upgraded = parseProjectStateSnapshot(previous);
 
     assert.equal(upgraded.schemaVersion, projectStateSnapshotSchemaVersion);
+    assert.deepEqual(
+      {
+        siteAddress: upgraded.project.siteAddress,
+        workStage: upgraded.project.workStage,
+        projectLead: upgraded.project.projectLead,
+        projectEditor: upgraded.project.projectEditor,
+      },
+      { siteAddress: null, workStage: null, projectLead: null, projectEditor: null }
+    );
     assert.deepEqual(
       {
         boardNumber: upgraded.distributionBoards[0]?.boardNumber,
@@ -228,27 +251,26 @@ describe("project state snapshot model", () => {
     );
   });
 
-  it("keeps distribution-board info values and rejects them in older versions", () => {
+  it("keeps board info and cover values and rejects them in older versions", () => {
     const parsed = parseProjectStateSnapshot(protectedSnapshot());
     assert.equal(parsed.distributionBoards[0]?.boardNumber, "UV 1.1");
     assert.equal(parsed.distributionBoards[0]?.location, "Raum 003 Technik");
     assert.equal(parsed.distributionBoards[0]?.fedFrom, "HV 0.1");
+    assert.equal(parsed.project.siteAddress, "Musterstraße 1\n12345 Musterstadt");
+    assert.equal(parsed.project.workStage, "LPH 5");
 
     const mislabeled = protectedSnapshot();
     mislabeled.schemaVersion = 5 as typeof mislabeled.schemaVersion;
     assert.throws(() => parseProjectStateSnapshot(mislabeled));
+
+    const missingCover = structuredClone(protectedSnapshot());
+    delete (missingCover.project as Record<string, unknown>).workStage;
+    assert.throws(() => parseProjectStateSnapshot(missingCover));
   });
 
   it("upgrades snapshot version 4 with the existing quantity as manual share", () => {
-    const previous = protectedSnapshot();
+    const previous = withoutVersionSixFields(protectedSnapshot());
     previous.schemaVersion = 4 as typeof previous.schemaVersion;
-    for (const board of previous.distributionBoards) {
-      const record = board as Record<string, unknown>;
-      delete record.boardNumber;
-      delete record.location;
-      delete record.fedFrom;
-      delete record.remark;
-    }
     previous.circuits[0]!.isReserve = false;
     previous.circuits[0]!.deviceRows = [{
       id: "row-1",

From 49488f4e1b3e1e242a0b8d28bf96f5945ed726b4 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 10:59:41 +0200
Subject: [PATCH 10/60] Add optional cable-sizing module
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Per-circuit cross-section recommendation as a separate module attached to
the circuit list. It never writes project data itself: "Übernehmen" applies
cable type, cross-section and length through the regular circuit.update
command, so revisions and Undo/Redo stay intact.

- Pure domain module (src/cable-sizing) with IEC 60364-5-52:2009 Annex B
  tables for PVC and XLPE, copper and aluminium, methods A1, A2, B1, B2, C,
  D1, D2 and E. Every value was cross-checked against public reproductions;
  where sources differ the lower value is used (docs/cable-sizing-module.md).
- Temperature and grouping between table values round to the safer value;
  values outside the tables return no result instead of a factor of 1.
  Ground methods use B.52.18 (D2) and B.52.19 A (D1).
- Overload protection: circuit-breakers In <= Iz; gG fuses additionally
  I2 <= 1.45 Iz with I2 = 1.6/1.9/2.1 In.
- Inputs prefilled from the circuit: power, phase (group or device rows),
  project voltage, power-weighted cos phi, length and protective device.
- Opened from a "Leitungsberechnung" button in the row actions, not from a
  grid cell, so cable cells keep the spreadsheet behavior.
- Stateless API under /api/cable-sizing; no database table or migration.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |  24 +-
 docs/README.md                                |   2 +
 docs/cable-sizing-module.md                   | 159 ++++
 docs/circuit-list-editor-api.md               |  22 +
 docs/circuit-list-editor-known-limitations.md |   8 +-
 docs/current-architecture.md                  |  12 +
 docs/spec/08-current-product-backlog.md       |   4 +-
 .../domain/cable-sizing-calculation.ts        | 689 ++++++++++++++++++
 .../domain/cable-sizing-contracts.ts          |  47 ++
 src/frontend/components/cable-sizing-api.ts   |  37 +
 .../components/cable-sizing-defaults.ts       |  54 ++
 .../components/cable-sizing-modal.tsx         | 571 +++++++++++++++
 .../components/circuit-tree-editor.tsx        |  52 ++
 .../controllers/cable-sizing.controller.ts    |  37 +
 src/server/index.ts                           |   2 +
 src/server/routes/cable-sizing.routes.ts      |   9 +
 tests/cable-sizing-calculation.test.ts        | 274 +++++++
 17 files changed, 1999 insertions(+), 4 deletions(-)
 create mode 100644 docs/cable-sizing-module.md
 create mode 100644 src/cable-sizing/domain/cable-sizing-calculation.ts
 create mode 100644 src/cable-sizing/domain/cable-sizing-contracts.ts
 create mode 100644 src/frontend/components/cable-sizing-api.ts
 create mode 100644 src/frontend/components/cable-sizing-defaults.ts
 create mode 100644 src/frontend/components/cable-sizing-modal.tsx
 create mode 100644 src/server/controllers/cable-sizing.controller.ts
 create mode 100644 src/server/routes/cable-sizing.routes.ts
 create mode 100644 tests/cable-sizing-calculation.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index ab8393e..d7c67ab 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -507,9 +507,31 @@ Before implementation, audit the current ProjectDevice, CircuitDeviceRow,
 command, snapshot, transfer and editor drag-and-drop paths. Propose concrete
 domain objects and commands before adding migrations.
 
+## Cable Sizing Module
+
+`src/cable-sizing` is an agreed, separate calculator module attached to the
+circuit list (see `docs/cable-sizing-module.md`). Rules:
+
+- The domain code stays pure: no imports from `db/`, `server/` or `frontend/`.
+- It never writes project data. Results are applied only by an explicit
+  "Übernehmen", which runs the regular `circuit.update` command.
+- It is opened from the circuit row action button "Leitungsberechnung", never
+  by clicking a grid cell; cable cells keep the normal spreadsheet behavior.
+- It has no database table and no migration; `/api/cable-sizing/*` is
+  stateless.
+- Reference data is IEC 60364-5-52:2009 Annex B. Change table values only with
+  a documented source in `docs/cable-sizing-module.md`; where sources differ,
+  use the lower value. Inputs outside the tables return no result instead of
+  assuming a factor of 1.
+- Inputs are prefilled from the circuit (power, phase, voltage, weighted cos φ,
+  length, protective device) and remain editable; manual cable entry without
+  a calculation stays possible.
+
 ## Future Sizing
 
-Do not implement full cable/protection sizing unless explicitly requested.
+Do not implement full automatic cable/protection sizing of all circuits
+unless explicitly requested. The cable sizing module above only suggests
+values for one circuit on demand.
 
 Keep the structure ready for it.
 
diff --git a/docs/README.md b/docs/README.md
index 69a2115..5e37408 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -15,6 +15,8 @@ ausdrücklich getrennt und dürfen nicht als bereits implementiert verstanden we
 - [Editor-API](circuit-list-editor-api.md) – unterstützte Circuit-First-Endpunkte
 - [Bekannte Einschränkungen](circuit-list-editor-known-limitations.md) –
   bewusst noch nicht implementierte oder begrenzte Funktionen
+- [Leitungsberechnung](cable-sizing-module.md) – optionales Rechenmodul,
+  Rechenweg, Datenbasis und Prüfnachweis der Tabellen
 
 ## Entwicklung und Betrieb
 
diff --git a/docs/cable-sizing-module.md b/docs/cable-sizing-module.md
new file mode 100644
index 0000000..374994e
--- /dev/null
+++ b/docs/cable-sizing-module.md
@@ -0,0 +1,159 @@
+# Leitungsberechnung (Cable-Sizing-Modul)
+
+Optionales, abgegrenztes Rechenmodul für die Querschnittsempfehlung eines
+Stromkreises. Es wurde als eigenständiges Modul vereinbart, das an die
+Stromkreisliste angedockt ist. Es **schreibt keine Projektdaten selbst**: Ein
+Ergebnis wird erst durch ausdrückliches „Übernehmen“ über den bestehenden
+Befehl `circuit.update` in den Stromkreis geschrieben. Revisionen und
+Undo/Redo bleiben damit unverändert gültig.
+
+Die vollständige, automatische Bemessung aller Stromkreise (siehe
+`docs/spec/06-future-sizing-and-calculations.md`) ist weiterhin **nicht**
+Teil dieses Moduls.
+
+## Aufbau und Andockpunkte
+
+```
+src/cable-sizing/domain/cable-sizing-calculation.ts   reine Berechnung + Tabellen
+src/cable-sizing/domain/cable-sizing-contracts.ts     Zod-Schema der API
+src/server/controllers/cable-sizing.controller.ts     zustandslose Endpunkte
+src/server/routes/cable-sizing.routes.ts              Router unter /api/cable-sizing
+src/frontend/components/cable-sizing-api.ts           Fetch-Client
+src/frontend/components/cable-sizing-defaults.ts      Vorbelegung aus dem Stromkreis
+src/frontend/components/cable-sizing-modal.tsx        Dialog
+tests/cable-sizing-calculation.test.ts                Tabellen, Rechnung, Vorbelegung
+```
+
+Das Domänenmodul importiert nichts aus `db/`, `server/` oder `frontend/`.
+Außerhalb dieser Dateien gibt es genau zwei Andockpunkte:
+
+1. `src/server/index.ts`: `app.use("/api/cable-sizing", cableSizingRouter)`.
+2. `src/frontend/components/circuit-tree-editor.tsx`: Zustand für den
+   geöffneten Dialog, ein Button **Leitungsberechnung** (Rechner-Icon) in der
+   Aktionsspalte jeder Stromkreiszeile, der Dialog selbst und
+   `handleApplyCableSizing`, das über `updateCircuitById` den regulären
+   `circuit.update`-Befehl ausführt.
+
+Der Aufruf liegt bewusst **nicht** auf einer Tabellenzelle: Klick, Doppelklick,
+Enter, F2 und Tippen in den Kabelspalten verhalten sich wie in jeder anderen
+Zelle (Spreadsheet-Regel in `AGENTS.md`). Es gibt keine eigene Datenbanktabelle
+und keine Migration.
+
+## Eingaben und Vorbelegung
+
+| Eingabe | Vorbelegung |
+|---|---|
+| Leistung | `circuitTotalPower` des Stromkreises (mit Geräte-GZF), nicht editierbar |
+| Phasen | 3~, wenn die Stromkreisgruppe 3-phasig ist oder eine Gerätezeile `three_phase` hat, sonst 1~ |
+| Spannung | `circuit.voltage` (aus den Projekteinstellungen abgeleitet); bei manuell abweichender Phasenzahl die jeweilige Projektspannung |
+| cos φ | leistungsgewichtet aus den Gerätezeilen: P / Σ(P_Zeile / cos φ_Zeile), fehlendes cos φ = 1; änderbar |
+| Länge | `cableLength` des Stromkreises |
+| Schutzorgan | Schutzgerät des Stromkreises: LS, FI/LS, AFDD = Leitungsschutzschalter; D0/NH = Sicherung gG; FI ohne Überstromauslöser wird nicht berücksichtigt |
+| Verlegeart, Isolierstoff, Leitermaterial, Temperatur, Häufung, max. ΔU, Oberschwingungen | Planereingaben |
+
+Kabeltyp und Querschnitt lassen sich im Dialog auch ohne Berechnung direkt
+eintragen. Weicht der Eintrag von der Empfehlung oder dem
+Praxis-Mindestquerschnitt ab, erscheint nur ein Hinweis.
+
+## Rechenweg
+
+1. Betriebsstrom I_B aus Leistung, Spannung, cos φ und Phasenzahl.
+2. Erforderliche Belastbarkeit: ohne Schutzorgan I_B; mit Schutzorgan
+   max(I_B, I_n, I₂/1,45) nach IEC 60364-4-43 (I_n ≤ I_z und I₂ ≤ 1,45 · I_z).
+   I₂/I_n: Leitungsschutzschalter 1,45; Sicherung gG 2,1 (I_n ≤ 4 A),
+   1,9 (4 A < I_n < 16 A), 1,6 (I_n ≥ 16 A).
+3. Tabellenwert I_z je Querschnitt × Temperaturfaktor × Häufungsfaktor
+   (× 0,86 bei 15–33 % 3. Harmonischer im Drehstromkreis).
+4. Spannungsfall ΔU = k · L · I_B · cos φ / (κ · A · U) mit k = 2 (1~) bzw.
+   √3 (3~), κ = 48 (Cu) bzw. 30 (Al) m/(Ω·mm²) bei Betriebstemperatur;
+   Reaktanz wird vernachlässigt.
+5. Empfehlung = größerer Querschnitt aus Belastbarkeit und Spannungsfall;
+   1-phasige Stromkreise werden auf den Praxis-Mindestquerschnitt 2,5 mm²
+   angehoben (Planungskonvention aus `docs/spec/06-…`, keine Rechenanforderung).
+6. Zusätzlich: maximale Länge für den zulässigen Spannungsfall.
+
+Temperaturen und Häufungen **zwischen** Tabellenwerten werden auf den nächsten
+ungünstigeren Tabellenwert gerundet (höhere Temperatur, mehr Stromkreise).
+Werte **außerhalb** der Tabellen liefern kein Ergebnis und eine Meldung – es
+wird nie stillschweigend mit Faktor 1 gerechnet.
+
+## Datenbasis und Prüfnachweis
+
+Grundlage ist **IEC 60364-5-52:2009, Anhang B**. Alle Werte wurden am
+26.09.2026 zeilenweise mit öffentlich zugänglichen Wiedergaben abgeglichen:
+TiSoft ElectricalDesign-Hilfe zu IEC 60364-5-52
+(`ti-soft.com/en/support/help/electricaldesign/standards/iec-60364-5-52/…`)
+und ECalPro (`ecalpro.com/standards/iec-60364/…`). Wo die Quellen voneinander
+abweichen, ist der kleinere, sichere Wert eingetragen.
+
+| Tabelle | Inhalt | Abgleich | Abweichungen |
+|---|---|---|---|
+| B.52.2 | PVC, 2 belastete Adern, Cu/Al, A1–D2 | TiSoft; Cu A1–C zusätzlich ECalPro | Cu A1 240 mm²: 321 / 320 → 320 |
+| B.52.3 | VPE, 2 belastete Adern, Cu/Al, A1–D2 | TiSoft | – |
+| B.52.4 | PVC, 3 belastete Adern, Cu/Al, A1–D2 | TiSoft | – |
+| B.52.5 | VPE, 3 belastete Adern, Cu/Al, A1–D2 | TiSoft | – |
+| B.52.10 / .11 | PVC, Verlegeart E, mehradrig, Cu / Al | TiSoft; Cu 2 Adern zusätzlich ECalPro | Cu 3 Adern 70 / 120 mm²: 198 / 278 bzw. 196 / 276 → 196 / 276 |
+| B.52.12 / .13 | VPE, Verlegeart E, mehradrig, Cu / Al | TiSoft | – |
+| B.52.14 | Temperatur Luft, PVC / VPE | TiSoft, ECalPro | – |
+| B.52.15 | Temperatur Erde, PVC / VPE | TiSoft | – |
+| B.52.17 | Häufung Luft, Zeile 1 (gebündelt) | TiSoft, ECalPro | – |
+| B.52.18 | Häufung Erde direkt, Kabel berührend | TiSoft | – |
+| B.52.19 A | Häufung mehradrige Kabel in berührenden Rohren im Erdreich | TiSoft | – |
+
+Anwendung der Tabellen:
+
+- Verlegearten A1, A2, B1, B2, C, E in Luft (Bezug 30 °C), D1 und D2 im
+  Erdreich (Bezug 20 °C, Bodenwärmewiderstand 2,5 K·m/W). Nach Tabelle B.52.1
+  ist **D1 = Leitung im Rohr/Kabelschutzrohr im Erdreich** und **D2 = Kabel
+  direkt im Erdreich**.
+- Häufung in Luft immer nach B.52.17 Zeile 1, auch für Verlegeart E; das ist
+  die ungünstigste Anordnung (einlagig auf Pritschen wären höhere Faktoren
+  zulässig). D1 nach B.52.19 A, D2 nach B.52.18 jeweils „berührend“.
+- Aluminium nur mit den echten Aluminiumwerten (ab 2,5 mm², D2 ab 16 mm²);
+  Querschnitte ohne Tabellenwert werden nie empfohlen.
+- Die Verlegearten F und G (Einzeladern mit Abstand) sind nicht enthalten.
+
+**Vor produktivem Einsatz:** Die nationalen Tabellen der DIN VDE 0298-4
+können in einzelnen Werten abweichen. Der Planer muss die Tabellen gegen den
+Normtext prüfen. Die Prüfung ist in `tests/cable-sizing-calculation.test.ts`
+über Stichwerte und eine Monotonieprüfung jeder Tabellenzeile abgesichert.
+
+## Nicht enthalten
+
+- Kurzschlussfestigkeit, Abschaltbedingungen (Schleifenimpedanz) und
+  Selektivität
+- Bodenwärmewiderstand ≠ 2,5 K·m/W, Häufung mit Abstand, Verlegearten F/G
+- Bemessung des Neutralleiters bei > 33 % 3. Harmonischer (nur Hinweis)
+- automatische Bemessung oder Prüfung aller Stromkreise
+
+## API
+
+`POST /api/cable-sizing/calculate` – zustandslos, liest und schreibt keine
+Projektdaten.
+
+```jsonc
+{
+  "phase": 1,                       // 1 | 3
+  "mode": "power",                  // "power" | "current"
+  "powerKw": 4.2,                   // bei mode "power"
+  "currentA": 18.3,                 // bei mode "current"
+  "cosPhi": 0.95,                   // 0,1 … 1
+  "voltage": 230,
+  "lengthM": 23.5,
+  "layingMethod": "C",              // A1 | A2 | B1 | B2 | C | D1 | D2 | E
+  "conductorMaterial": "copper",    // copper | aluminum
+  "insulation": "pvc",              // pvc | xlpe
+  "ambientTemperatureC": 30,        // Luft; bei D1/D2 Bodentemperatur
+  "groupingCircuits": 1,            // 1 … 100, Tabellen bis 20
+  "maxVoltageDropPercent": 3,
+  "harmonicNeutralLoad": "none",    // none | 15to33Percent | over33Percent
+  "existingProtection": { "ratedCurrentA": 16, "kind": "breaker" }, // optional; kind: breaker | fuse
+  "circuitCategory": "single_phase" // optional
+}
+```
+
+Antwort: `{ "result": CableSizingResult, "alerts": CableSizingAlert[] }`.
+`result.supported = false` mit `unsupportedReason` (`temperature` oder
+`grouping`), wenn die Eingaben außerhalb der Tabellen liegen.
+`GET /api/cable-sizing/laying-methods` und `GET /api/cable-sizing/insulation-materials`
+liefern die Auswahllisten.
diff --git a/docs/circuit-list-editor-api.md b/docs/circuit-list-editor-api.md
index 9ed9e0a..0b24cc0 100644
--- a/docs/circuit-list-editor-api.md
+++ b/docs/circuit-list-editor-api.md
@@ -391,6 +391,28 @@ inverse command. The former direct restore/reconnect endpoints are removed.
 `displayName` is included in the comparison but is not selected by default in the UI. Updating a
 project device never triggers synchronization implicitly.
 
+## Cable Sizing (optional module)
+
+Stateless calculator endpoints mounted at `/api/cable-sizing`. They neither
+read nor write project data; applying a result uses `circuit.update` through
+`POST /projects/:projectId/commands`.
+
+- `POST /cable-sizing/calculate`
+  - request: phase, mode (`power` | `current`), powerKw or currentA, cosPhi,
+    voltage, lengthM, layingMethod (`A1` | `A2` | `B1` | `B2` | `C` | `D1` |
+    `D2` | `E`), conductorMaterial, insulation (`pvc` | `xlpe`),
+    ambientTemperatureC, groupingCircuits, maxVoltageDropPercent,
+    harmonicNeutralLoad, optional `existingProtection`
+    (`{ ratedCurrentA, kind: "breaker" | "fuse" }`) and circuitCategory
+  - returns `{ "result": { ... }, "alerts": [ ... ] }`; `result.supported`
+    is `false` with `unsupportedReason` when temperature or grouping lie
+    outside the tables
+  - unknown fields are rejected (`400`)
+- `GET /cable-sizing/laying-methods`
+- `GET /cable-sizing/insulation-materials`
+
+Full request example and calculation rules: `docs/cable-sizing-module.md`.
+
 ## Revit CSV Foundation
 
 - `GET /projects/:projectId/external-csv/configuration`
diff --git a/docs/circuit-list-editor-known-limitations.md b/docs/circuit-list-editor-known-limitations.md
index 4f7f660..521a9dc 100644
--- a/docs/circuit-list-editor-known-limitations.md
+++ b/docs/circuit-list-editor-known-limitations.md
@@ -17,8 +17,12 @@
 - Persistence currently targets local SQLite; PostgreSQL is an architectural option, not an implemented runtime.
 - The global device library supports basic CRUD and copy operations, but has no
   versioning, permissions or controlled synchronization model.
-- Final electrical sizing logic is not implemented yet.
-- No full norm-compliant voltage-drop and protection-dimensioning calculation flow yet.
+- There is no automatic sizing of all circuits. The optional cable sizing
+  module suggests a cross-section for one circuit on demand (IEC 60364-5-52
+  Annex B tables; no short-circuit, disconnection-time or selectivity checks,
+  no methods F/G, soil resistivity fixed at 2.5 K·m/W) and does not validate
+  manually entered cable values. National tables (DIN VDE 0298-4) must be
+  checked by the planner; see `docs/cable-sizing-module.md`.
 - Sorting is view-only until users explicitly apply sorted order.
 - Complete-circuit drag supports one circuit at a time between groups of the
   same category. Cross-category moves and multi-circuit moves across group
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 92efc98..7e78fac 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -452,6 +452,18 @@ werden als Diff angezeigt und nur für ausdrücklich gewählte Felder und Zeilen
 Die globale Gerätebibliothek ist ein einfacher, datenbankweiter Vorlagenbestand.
 Kopieren in ein Projekt erzeugt ein eigenständiges Projektgerät.
 
+## Leitungsberechnung
+
+Das optionale Modul `src/cable-sizing` berechnet auf Anforderung eine
+Querschnittsempfehlung für einen Stromkreis (IEC 60364-5-52 Anhang B:
+Belastbarkeit, Temperatur, Häufung, Spannungsfall, Schutzorgan). Die
+Domänenlogik ist rein, `POST /api/cable-sizing/calculate` ist zustandslos und
+es gibt keine eigene Tabelle. Der Editor öffnet den Dialog über den Button
+„Leitungsberechnung“ in der Aktionsspalte; „Übernehmen“ schreibt Kabeltyp,
+Querschnitt und Länge über den regulären `circuit.update`-Befehl, also mit
+Revision und Undo/Redo. Details, Rechenweg und Prüfnachweis der Tabellen:
+`docs/cable-sizing-module.md`.
+
 ## Persistenz und Migration
 
 - SQLite ist die aktuell unterstützte Datenbank.
diff --git a/docs/spec/08-current-product-backlog.md b/docs/spec/08-current-product-backlog.md
index c90dd24..519fd8d 100644
--- a/docs/spec/08-current-product-backlog.md
+++ b/docs/spec/08-current-product-backlog.md
@@ -46,7 +46,9 @@ requirements and intended sequencing, not proof of implementation.
 - [x] Phase E: editor projection and editing.
 - [x] Phase F: documentation and full GUI verification.
 - [ ] Keep full electrical sizing and cable-dimensioning rules separate until
-  the planner supplies the calculation requirements.
+  the planner supplies the calculation requirements. The optional per-circuit
+  cable sizing module (`docs/cable-sizing-module.md`) exists; its tables must
+  be confirmed by the planner against DIN VDE 0298-4.
 - Detailed specification:
   `docs/spec/09-distribution-board-components-and-protection-groups.md`
 
diff --git a/src/cable-sizing/domain/cable-sizing-calculation.ts b/src/cable-sizing/domain/cable-sizing-calculation.ts
new file mode 100644
index 0000000..3c881bd
--- /dev/null
+++ b/src/cable-sizing/domain/cable-sizing-calculation.ts
@@ -0,0 +1,689 @@
+// Pure cable sizing domain logic. No imports from db/, server/ or frontend/;
+// the module is an optional calculator attached to the circuit list and never
+// writes project data itself (see docs/cable-sizing-module.md).
+//
+// Reference data: IEC 60364-5-52:2009, Annex B (tables B.52.2 to B.52.5,
+// B.52.10 to B.52.19). Every value was cross-checked against publicly
+// available reproductions of these tables; where sources disagreed the lower,
+// i.e. safer, value is used. The table-by-table verification record is in
+// docs/cable-sizing-module.md. National tables (DIN VDE 0298-4) may differ in
+// individual values and must be checked by the planner against the norm text.
+
+// -- Reference installation methods (IEC 60364-5-52, Table B.52.1) ----------
+
+export const LAYING_METHODS = ["A1", "A2", "B1", "B2", "C", "D1", "D2", "E"] as const;
+export type LayingMethod = (typeof LAYING_METHODS)[number];
+
+export const LAYING_METHOD_GROUP: Record<LayingMethod, "air" | "ground"> = {
+  A1: "air",
+  A2: "air",
+  B1: "air",
+  B2: "air",
+  C: "air",
+  E: "air",
+  D1: "ground",
+  D2: "ground",
+};
+
+export const LAYING_METHOD_LABELS: Record<LayingMethod, string> = {
+  A1: "A1 – Einzeladern im Rohr in wärmegedämmter Wand",
+  A2: "A2 – Mehradrige Leitung im Rohr in wärmegedämmter Wand",
+  B1: "B1 – Einzeladern im Rohr auf oder in der Wand",
+  B2: "B2 – Mehradrige Leitung im Rohr auf oder in der Wand",
+  C: "C – Mehradrige Leitung direkt auf oder in der Wand",
+  D1: "D1 – Leitung im Rohr oder Kabelschutzrohr im Erdreich",
+  D2: "D2 – Kabel direkt im Erdreich",
+  E: "E – Mehradrige Leitung frei in Luft",
+};
+
+// -- Insulation / conductor material ----------------------------------------
+
+export const INSULATION_MATERIALS = ["pvc", "xlpe"] as const;
+export type InsulationMaterial = (typeof INSULATION_MATERIALS)[number];
+
+export const INSULATION_MATERIAL_LABELS: Record<InsulationMaterial, string> = {
+  pvc: "PVC (70 °C), z. B. NYM, NYY",
+  xlpe: "VPE/XLPE (90 °C), z. B. N2XH, NHXH",
+};
+
+export const CONDUCTOR_MATERIALS = ["copper", "aluminum"] as const;
+export type ConductorMaterial = (typeof CONDUCTOR_MATERIALS)[number];
+
+// -- Harmonic neutral loading (IEC 60364-5-52, Annex E, three-phase only) ---
+
+export const HARMONIC_NEUTRAL_LOAD_OPTIONS = [
+  "none",
+  "15to33Percent",
+  "over33Percent",
+] as const;
+export type HarmonicNeutralLoad = (typeof HARMONIC_NEUTRAL_LOAD_OPTIONS)[number];
+
+export const HARMONIC_NEUTRAL_LOAD_LABELS: Record<HarmonicNeutralLoad, string> = {
+  none: "Keine nennenswerte 3. Harmonische (< 15 %) – Standardfall",
+  "15to33Percent": "3. Harmonische 15–33 % – Reduktionsfaktor 0,86",
+  over33Percent: "3. Harmonische > 33 % – Neutralleiter wie Außenleiter dimensionieren",
+};
+
+export const HARMONIC_REDUCTION_FACTOR = 0.86;
+
+// -- Current-carrying capacity tables ----------------------------------------
+
+export const CROSS_SECTIONS_MM2 = [
+  1.5, 2.5, 4, 6, 10, 16, 25, 35, 50, 70, 95, 120, 150, 185, 240,
+] as const;
+
+type CoreCount = 2 | 3;
+type CapacityRow = readonly (number | null)[];
+type CapacityTable = Record<LayingMethod, Record<CoreCount, CapacityRow>>;
+
+const n = null;
+
+/** Iz in A at 30 °C air / 20 °C ground, soil resistivity 2.5 K·m/W. */
+export const CURRENT_CAPACITY_A: Record<
+  InsulationMaterial,
+  Record<ConductorMaterial, CapacityTable>
+> = {
+  pvc: {
+    copper: {
+      // B.52.2 / B.52.4; E: B.52.10 multi-core. A1 2L 240 mm²: sources 320/321 → 320.
+      // E 3L 70/120 mm²: sources 196/198 and 276/278 → 196 and 276.
+      A1: {
+        2: [14.5, 19.5, 26, 34, 46, 61, 80, 99, 119, 151, 182, 210, 240, 273, 320],
+        3: [13.5, 18, 24, 31, 42, 56, 73, 89, 108, 136, 164, 188, 216, 245, 286],
+      },
+      A2: {
+        2: [14, 18.5, 25, 32, 43, 57, 75, 92, 110, 139, 167, 192, 219, 248, 291],
+        3: [13, 17.5, 23, 29, 39, 52, 68, 83, 99, 125, 150, 172, 196, 223, 261],
+      },
+      B1: {
+        2: [17.5, 24, 32, 41, 57, 76, 101, 125, 151, 192, 232, 269, 300, 341, 400],
+        3: [15.5, 21, 28, 36, 50, 68, 89, 110, 134, 171, 207, 239, 262, 296, 346],
+      },
+      B2: {
+        2: [16.5, 23, 30, 38, 52, 69, 90, 111, 133, 168, 201, 232, 258, 294, 344],
+        3: [15, 20, 27, 34, 46, 62, 80, 99, 118, 149, 179, 206, 225, 255, 297],
+      },
+      C: {
+        2: [19.5, 27, 36, 46, 63, 85, 112, 138, 168, 213, 258, 299, 344, 392, 461],
+        3: [17.5, 24, 32, 41, 57, 76, 96, 119, 144, 184, 223, 259, 299, 341, 403],
+      },
+      D1: {
+        2: [22, 29, 37, 46, 60, 78, 99, 119, 140, 173, 204, 231, 261, 292, 336],
+        3: [18, 24, 30, 38, 50, 64, 82, 98, 116, 143, 169, 192, 217, 243, 280],
+      },
+      D2: {
+        2: [22, 28, 38, 48, 64, 83, 110, 132, 156, 192, 230, 261, 293, 331, 382],
+        3: [19, 24, 33, 41, 54, 70, 92, 110, 130, 162, 193, 220, 246, 278, 320],
+      },
+      E: {
+        2: [22, 30, 40, 51, 70, 94, 119, 148, 180, 232, 282, 328, 379, 434, 514],
+        3: [18.5, 25, 34, 43, 60, 80, 101, 126, 153, 196, 238, 276, 319, 364, 430],
+      },
+    },
+    aluminum: {
+      // B.52.2 / B.52.4 aluminium; E: B.52.11. No values below 2.5 mm²
+      // (D2 below 16 mm²).
+      A1: {
+        2: [n, 15, 20, 26, 36, 48, 63, 77, 93, 118, 142, 164, 189, 215, 252],
+        3: [n, 14, 18.5, 24, 32, 43, 57, 70, 84, 107, 129, 149, 170, 194, 227],
+      },
+      A2: {
+        2: [n, 14.5, 19.5, 25, 33, 44, 58, 71, 86, 108, 130, 150, 172, 195, 229],
+        3: [n, 13.5, 17.5, 23, 31, 41, 53, 65, 78, 98, 118, 135, 155, 176, 207],
+      },
+      B1: {
+        2: [n, 18.5, 25, 32, 44, 60, 79, 97, 118, 150, 181, 210, 234, 266, 312],
+        3: [n, 16.5, 22, 28, 39, 53, 70, 86, 104, 133, 161, 186, 204, 230, 269],
+      },
+      B2: {
+        2: [n, 17.5, 24, 30, 41, 54, 71, 86, 104, 131, 157, 181, 201, 230, 269],
+        3: [n, 15.5, 21, 27, 36, 48, 62, 77, 92, 116, 139, 160, 176, 199, 232],
+      },
+      C: {
+        2: [n, 21, 28, 36, 49, 66, 83, 103, 125, 160, 195, 226, 261, 298, 352],
+        3: [n, 18.5, 25, 32, 44, 59, 73, 90, 110, 140, 170, 197, 227, 259, 305],
+      },
+      D1: {
+        2: [n, 22, 29, 36, 47, 61, 77, 93, 109, 135, 159, 180, 204, 228, 262],
+        3: [n, 18.5, 24, 30, 39, 50, 64, 77, 91, 112, 132, 150, 169, 190, 218],
+      },
+      D2: {
+        2: [n, n, n, n, n, 63, 82, 98, 117, 145, 173, 200, 224, 255, 298],
+        3: [n, n, n, n, n, 53, 69, 83, 99, 122, 148, 169, 189, 214, 250],
+      },
+      E: {
+        2: [n, 23, 31, 39, 54, 73, 89, 111, 135, 173, 210, 244, 282, 322, 380],
+        3: [n, 19.5, 26, 33, 46, 61, 78, 96, 117, 150, 183, 212, 245, 280, 330],
+      },
+    },
+  },
+  xlpe: {
+    copper: {
+      // B.52.3 / B.52.5; E: B.52.12 multi-core.
+      A1: {
+        2: [19, 26, 35, 45, 61, 81, 106, 131, 158, 200, 241, 278, 318, 362, 424],
+        3: [17, 23, 31, 40, 54, 73, 95, 117, 141, 179, 216, 249, 285, 324, 380],
+      },
+      A2: {
+        2: [18.5, 25, 33, 42, 57, 76, 99, 121, 145, 183, 220, 253, 290, 329, 386],
+        3: [16.5, 22, 30, 38, 51, 68, 89, 109, 130, 164, 197, 227, 259, 295, 346],
+      },
+      B1: {
+        2: [23, 31, 42, 54, 75, 100, 133, 164, 198, 253, 306, 354, 393, 449, 528],
+        3: [20, 28, 37, 48, 66, 88, 117, 144, 175, 222, 269, 312, 342, 384, 450],
+      },
+      B2: {
+        2: [22, 30, 40, 51, 69, 91, 119, 146, 175, 221, 265, 305, 334, 384, 459],
+        3: [19.5, 26, 35, 44, 60, 80, 105, 128, 154, 194, 233, 268, 300, 340, 398],
+      },
+      C: {
+        2: [24, 33, 45, 58, 80, 107, 138, 171, 209, 269, 328, 382, 441, 506, 599],
+        3: [22, 30, 40, 52, 71, 96, 119, 147, 179, 229, 278, 322, 371, 424, 500],
+      },
+      D1: {
+        2: [25, 33, 43, 53, 71, 91, 116, 139, 164, 203, 239, 271, 306, 343, 395],
+        3: [21, 28, 36, 44, 58, 75, 96, 115, 135, 167, 197, 223, 251, 281, 324],
+      },
+      D2: {
+        2: [27, 35, 46, 58, 77, 100, 129, 155, 183, 225, 270, 306, 343, 387, 448],
+        3: [23, 30, 39, 49, 65, 84, 107, 129, 153, 188, 226, 257, 287, 324, 375],
+      },
+      E: {
+        2: [26, 36, 49, 63, 86, 115, 149, 185, 225, 289, 352, 410, 473, 542, 641],
+        3: [23, 32, 42, 54, 75, 100, 127, 158, 192, 246, 298, 346, 399, 456, 538],
+      },
+    },
+    aluminum: {
+      // B.52.3 / B.52.5 aluminium; E: B.52.13.
+      A1: {
+        2: [n, 20, 27, 35, 48, 64, 84, 103, 125, 158, 191, 220, 253, 288, 338],
+        3: [n, 19, 25, 32, 44, 58, 76, 94, 113, 142, 171, 197, 226, 256, 300],
+      },
+      A2: {
+        2: [n, 19.5, 26, 33, 45, 60, 78, 96, 115, 145, 175, 201, 230, 262, 307],
+        3: [n, 18, 24, 31, 41, 55, 71, 87, 104, 131, 157, 180, 206, 233, 273],
+      },
+      B1: {
+        2: [n, 25, 33, 43, 59, 79, 105, 130, 157, 200, 242, 281, 307, 351, 412],
+        3: [n, 22, 29, 38, 52, 71, 93, 116, 140, 179, 217, 251, 267, 300, 351],
+      },
+      B2: {
+        2: [n, 23, 31, 40, 54, 72, 94, 115, 138, 175, 210, 242, 261, 300, 358],
+        3: [n, 21, 28, 35, 48, 64, 84, 103, 124, 156, 188, 216, 240, 272, 318],
+      },
+      C: {
+        2: [n, 26, 35, 45, 62, 84, 101, 126, 154, 198, 241, 280, 324, 371, 439],
+        3: [n, 24, 32, 41, 57, 76, 90, 112, 136, 174, 211, 245, 283, 323, 382],
+      },
+      D1: {
+        2: [n, 26, 33, 42, 55, 71, 90, 108, 128, 158, 186, 211, 238, 267, 307],
+        3: [n, 22, 28, 35, 46, 59, 75, 90, 106, 130, 154, 174, 197, 220, 253],
+      },
+      D2: {
+        2: [n, n, n, n, n, 76, 98, 117, 139, 170, 204, 233, 261, 296, 343],
+        3: [n, n, n, n, n, 64, 82, 98, 117, 144, 172, 197, 220, 250, 290],
+      },
+      E: {
+        2: [n, 28, 38, 49, 67, 91, 108, 135, 164, 211, 257, 300, 346, 397, 470],
+        3: [n, 24, 32, 42, 58, 77, 97, 120, 146, 187, 227, 263, 304, 347, 409],
+      },
+    },
+  },
+};
+
+// -- Correction factors ------------------------------------------------------
+
+/** B.52.14 (air, reference 30 °C) and B.52.15 (ground, reference 20 °C). */
+export const TEMPERATURE_FACTORS: Record<
+  "air" | "ground",
+  Record<InsulationMaterial, Record<number, number>>
+> = {
+  air: {
+    pvc: { 10: 1.22, 15: 1.17, 20: 1.12, 25: 1.06, 30: 1.0, 35: 0.94, 40: 0.87, 45: 0.79, 50: 0.71, 55: 0.61, 60: 0.5 },
+    xlpe: {
+      10: 1.15, 15: 1.12, 20: 1.08, 25: 1.04, 30: 1.0, 35: 0.96, 40: 0.91, 45: 0.87,
+      50: 0.82, 55: 0.76, 60: 0.71, 65: 0.65, 70: 0.58, 75: 0.5, 80: 0.41,
+    },
+  },
+  ground: {
+    pvc: { 10: 1.1, 15: 1.05, 20: 1.0, 25: 0.95, 30: 0.89, 35: 0.84, 40: 0.77, 45: 0.71, 50: 0.63, 55: 0.55, 60: 0.45 },
+    xlpe: {
+      10: 1.07, 15: 1.04, 20: 1.0, 25: 0.96, 30: 0.93, 35: 0.89, 40: 0.85, 45: 0.8,
+      50: 0.76, 55: 0.71, 60: 0.65, 65: 0.6, 70: 0.53, 75: 0.46, 80: 0.38,
+    },
+  },
+};
+
+export const REFERENCE_TEMPERATURE_C: Record<"air" | "ground", number> = {
+  air: 30,
+  ground: 20,
+};
+
+/**
+ * Grouping reduction factors for touching circuits/cables:
+ * air (A1–C, E): B.52.17 item 1 "bunched in air, on a surface, embedded or
+ * enclosed" – the most restrictive arrangement, also used for E (single
+ * layers on trays would allow higher factors);
+ * D1: B.52.19 A (multi-core cables in touching ducts);
+ * D2: B.52.18 (cables direct in ground, touching).
+ */
+export const GROUPING_FACTORS: Record<"air" | "D1" | "D2", Record<number, number>> = {
+  air: { 1: 1.0, 2: 0.8, 3: 0.7, 4: 0.65, 5: 0.6, 6: 0.57, 7: 0.54, 8: 0.52, 9: 0.5, 12: 0.45, 16: 0.41, 20: 0.38 },
+  D1: {
+    1: 1.0, 2: 0.85, 3: 0.75, 4: 0.7, 5: 0.65, 6: 0.6, 7: 0.57, 8: 0.54, 9: 0.52, 10: 0.49,
+    11: 0.47, 12: 0.45, 13: 0.44, 14: 0.42, 15: 0.41, 16: 0.39, 17: 0.38, 18: 0.37, 19: 0.35, 20: 0.34,
+  },
+  D2: { 1: 1.0, 2: 0.75, 3: 0.65, 4: 0.6, 5: 0.55, 6: 0.5, 7: 0.45, 8: 0.43, 9: 0.41, 12: 0.36, 16: 0.32, 20: 0.29 },
+};
+
+export const MAX_GROUPING_CIRCUITS = 20;
+
+function groupingTableFor(method: LayingMethod) {
+  return method === "D1" ? GROUPING_FACTORS.D1 : method === "D2" ? GROUPING_FACTORS.D2 : GROUPING_FACTORS.air;
+}
+
+/**
+ * Looks up a tabulated factor. Values between tabulated keys use the next
+ * higher key (the lower, safer factor); values above the table are not
+ * supported (null) and values below the smallest key use the smallest key
+ * (whose factor is lower than the true one, i.e. safe).
+ */
+function lookupConservative(table: Record<number, number>, value: number): { key: number; factor: number } | null {
+  const keys = Object.keys(table).map(Number).sort((a, b) => a - b);
+  const key = keys.find((candidate) => candidate >= value);
+  if (key === undefined) {
+    return null;
+  }
+  return { key, factor: table[key] };
+}
+
+/** Tabulated temperatures offered by the UI for a laying method and insulation. */
+export function temperatureOptions(method: LayingMethod, insulation: InsulationMaterial): number[] {
+  return Object.keys(TEMPERATURE_FACTORS[LAYING_METHOD_GROUP[method]][insulation])
+    .map(Number)
+    .sort((a, b) => a - b);
+}
+
+// -- Conductor resistivity for the voltage drop -------------------------------
+
+/** Conductivity in m/(Ω·mm²) at the maximum operating temperature (conservative). */
+export const KAPPA: Record<ConductorMaterial, number> = { copper: 48, aluminum: 30 };
+
+// -- Practical minimum cross-sections by circuit category --------------------
+// A planning convention from docs/spec/06-future-sizing-and-calculations.md
+// ("Standard Single-Phase Circuits ... cable cross-section: 2.5 mm²"), not a
+// calculation result. It only ever raises a recommendation.
+export type CircuitCategory = "lighting" | "single_phase" | "three_phase";
+
+export const PRACTICAL_MINIMUM_CROSS_SECTION_MM2: Partial<Record<CircuitCategory, number>> = {
+  single_phase: 2.5,
+};
+
+// -- Protective device --------------------------------------------------------
+
+export const PROTECTION_KINDS = ["breaker", "fuse"] as const;
+export type ProtectionKind = (typeof PROTECTION_KINDS)[number];
+
+export interface ExistingProtection {
+  ratedCurrentA: number;
+  /** breaker: circuit-breaker (I2 ≤ 1.45 In); fuse: gG fuse (I2 up to 2.1 In). */
+  kind: ProtectionKind;
+}
+
+/**
+ * Conventional tripping/fusing current I2 as multiple of In.
+ * Circuit-breakers (IEC 60898-1): 1.45. gG fuses (IEC 60269-2):
+ * In ≤ 4 A: 2.1, 4 A < In < 16 A: 1.9, In ≥ 16 A: 1.6.
+ */
+export function conventionalTrippingFactor(protection: ExistingProtection): number {
+  if (protection.kind === "breaker") {
+    return 1.45;
+  }
+  if (protection.ratedCurrentA <= 4) {
+    return 2.1;
+  }
+  return protection.ratedCurrentA < 16 ? 1.9 : 1.6;
+}
+
+/**
+ * Minimum Iz required by overload protection (IEC 60364-4-43, 433.1):
+ * In ≤ Iz and I2 ≤ 1.45 · Iz.
+ */
+export function minimumIzForProtection(protection: ExistingProtection): number {
+  return Math.max(
+    protection.ratedCurrentA,
+    (conventionalTrippingFactor(protection) * protection.ratedCurrentA) / 1.45
+  );
+}
+
+// -- Input / result -----------------------------------------------------------
+
+export interface CableSizingInput {
+  phase: 1 | 3;
+  mode: "power" | "current";
+  /** kW, only used when mode === "power" */
+  powerKw?: number;
+  /** A, only used when mode === "current" */
+  currentA?: number;
+  cosPhi: number;
+  /** Line voltage in V (project single-/three-phase voltage). */
+  voltage: number;
+  /** Single-run cable length in m. */
+  lengthM: number;
+  layingMethod: LayingMethod;
+  conductorMaterial: ConductorMaterial;
+  insulation: InsulationMaterial;
+  /** Ambient air temperature, or ground temperature for D1/D2. */
+  ambientTemperatureC: number;
+  /** Number of grouped circuits or multi-core cables, including this one. */
+  groupingCircuits: number;
+  maxVoltageDropPercent: number;
+  harmonicNeutralLoad: HarmonicNeutralLoad;
+  existingProtection?: ExistingProtection;
+  circuitCategory?: CircuitCategory;
+}
+
+export interface CrossSectionRow {
+  crossSectionMm2: number;
+  /** Tabulated Iz; null if the table has no value for this size. */
+  ratedCurrentA: number | null;
+  correctedCurrentA: number | null;
+  currentSufficient: boolean | null;
+  voltageDropPercent: number | null;
+  voltageDropSufficient: boolean | null;
+  /** Longest single run meeting maxVoltageDropPercent at this load. */
+  maxLengthForVoltageDropM: number | null;
+  recommended: boolean;
+}
+
+export interface ProtectionCoordinationResult {
+  ratedCurrentA: number;
+  kind: ProtectionKind;
+  /** I2 / In used for the check. */
+  conventionalTrippingFactor: number;
+  /** In ≤ Iz and I2 ≤ 1.45 · Iz for the recommended cross-section. */
+  coordinated: boolean;
+}
+
+export type UnsupportedReason = "temperature" | "grouping";
+
+export interface CableSizingResult {
+  /** false: the inputs are outside the tabulated range – no numeric result. */
+  supported: boolean;
+  unsupportedReason: UnsupportedReason | null;
+  operatingCurrentA: number;
+  /**
+   * Current the cross-section must carry after correction:
+   * max(Ib, In, I2/1.45) with an existing protective device, otherwise Ib.
+   */
+  designCurrentA: number;
+  /** Tabulated temperature/grouping actually used (rounded to the safe side). */
+  temperatureUsedC: number | null;
+  groupingUsed: number | null;
+  temperatureFactor: number | null;
+  groupingFactor: number | null;
+  crossSectionByCapacityMm2: number | null;
+  crossSectionByVoltageDropMm2: number | null;
+  recommendedCrossSectionMm2: number | null;
+  voltageDropAtRecommendedPercent: number | null;
+  combinedDerationFactor: number;
+  harmonicReductionApplied: boolean;
+  practicalMinimumApplied: boolean;
+  rows: CrossSectionRow[];
+  protectionCoordination: ProtectionCoordinationResult | null;
+}
+
+function operatingCurrentA(input: CableSizingInput): number {
+  if (input.mode === "current") {
+    return input.currentA ?? 0;
+  }
+  const powerW = (input.powerKw ?? 0) * 1000;
+  return input.phase === 1
+    ? powerW / (input.voltage * input.cosPhi)
+    : powerW / (Math.sqrt(3) * input.voltage * input.cosPhi);
+}
+
+export function calculateCableSizing(input: CableSizingInput): CableSizingResult {
+  const ib = operatingCurrentA(input);
+  const designCurrentA = input.existingProtection
+    ? Math.max(ib, minimumIzForProtection(input.existingProtection))
+    : ib;
+  const group = LAYING_METHOD_GROUP[input.layingMethod];
+  const temperature = lookupConservative(
+    TEMPERATURE_FACTORS[group][input.insulation],
+    input.ambientTemperatureC
+  );
+  const grouping =
+    input.groupingCircuits <= MAX_GROUPING_CIRCUITS
+      ? lookupConservative(groupingTableFor(input.layingMethod), Math.max(1, input.groupingCircuits))
+      : null;
+
+  const empty: CableSizingResult = {
+    supported: false,
+    unsupportedReason: !temperature ? "temperature" : "grouping",
+    operatingCurrentA: ib,
+    designCurrentA,
+    temperatureUsedC: temperature?.key ?? null,
+    groupingUsed: grouping?.key ?? null,
+    temperatureFactor: temperature?.factor ?? null,
+    groupingFactor: grouping?.factor ?? null,
+    crossSectionByCapacityMm2: null,
+    crossSectionByVoltageDropMm2: null,
+    recommendedCrossSectionMm2: null,
+    voltageDropAtRecommendedPercent: null,
+    combinedDerationFactor: 1,
+    harmonicReductionApplied: false,
+    practicalMinimumApplied: false,
+    rows: [],
+    protectionCoordination: null,
+  };
+  if (!temperature || !grouping) {
+    return empty;
+  }
+
+  const coreCount: CoreCount = input.phase === 1 ? 2 : 3;
+  const harmonicReductionApplied =
+    input.phase === 3 && input.harmonicNeutralLoad === "15to33Percent";
+  const combinedDerationFactor =
+    temperature.factor * grouping.factor * (harmonicReductionApplied ? HARMONIC_REDUCTION_FACTOR : 1);
+  const voltageDropCoefficient = input.phase === 1 ? 2 : Math.sqrt(3);
+  const kappa = KAPPA[input.conductorMaterial];
+
+  const ratedCurrents =
+    CURRENT_CAPACITY_A[input.insulation][input.conductorMaterial][input.layingMethod][coreCount];
+  const correctedCurrents = ratedCurrents.map((value) =>
+    value == null ? null : value * combinedDerationFactor
+  );
+  const voltageDrops = CROSS_SECTIONS_MM2.map(
+    (crossSection) =>
+      ((voltageDropCoefficient * input.lengthM * ib * input.cosPhi) / (kappa * crossSection) / input.voltage) * 100
+  );
+
+  const indexByCapacity = correctedCurrents.findIndex(
+    (value) => value != null && value >= designCurrentA
+  );
+  const indexByVoltageDrop = voltageDrops.findIndex(
+    (value, index) => ratedCurrents[index] != null && value <= input.maxVoltageDropPercent
+  );
+  let indexRecommended =
+    indexByCapacity >= 0 && indexByVoltageDrop >= 0 ? Math.max(indexByCapacity, indexByVoltageDrop) : -1;
+
+  const practicalMinimumMm2 = input.circuitCategory
+    ? PRACTICAL_MINIMUM_CROSS_SECTION_MM2[input.circuitCategory]
+    : undefined;
+  let practicalMinimumApplied = false;
+  if (indexRecommended >= 0 && practicalMinimumMm2 != null && CROSS_SECTIONS_MM2[indexRecommended] < practicalMinimumMm2) {
+    const minimumIndex = CROSS_SECTIONS_MM2.indexOf(practicalMinimumMm2 as (typeof CROSS_SECTIONS_MM2)[number]);
+    if (minimumIndex >= 0 && ratedCurrents[minimumIndex] != null) {
+      indexRecommended = minimumIndex;
+      practicalMinimumApplied = true;
+    }
+  }
+
+  const voltageDropCurrentBasis = ib * input.cosPhi;
+  const rows: CrossSectionRow[] = CROSS_SECTIONS_MM2.map((crossSection, index) => {
+    const rated = ratedCurrents[index];
+    const corrected = correctedCurrents[index];
+    return {
+      crossSectionMm2: crossSection,
+      ratedCurrentA: rated,
+      correctedCurrentA: corrected,
+      currentSufficient: corrected == null ? null : corrected >= designCurrentA,
+      voltageDropPercent: rated == null ? null : voltageDrops[index],
+      voltageDropSufficient: rated == null ? null : voltageDrops[index] <= input.maxVoltageDropPercent,
+      maxLengthForVoltageDropM:
+        rated == null || voltageDropCurrentBasis <= 0
+          ? null
+          : (input.maxVoltageDropPercent * kappa * crossSection * input.voltage) /
+            (100 * voltageDropCoefficient * voltageDropCurrentBasis),
+      recommended: index === indexRecommended,
+    };
+  });
+
+  let protectionCoordination: ProtectionCoordinationResult | null = null;
+  if (input.existingProtection && indexRecommended >= 0) {
+    const iz = rows[indexRecommended].correctedCurrentA;
+    const factor = conventionalTrippingFactor(input.existingProtection);
+    const inA = input.existingProtection.ratedCurrentA;
+    protectionCoordination = {
+      ratedCurrentA: inA,
+      kind: input.existingProtection.kind,
+      conventionalTrippingFactor: factor,
+      coordinated: iz != null && inA <= iz && factor * inA <= 1.45 * iz,
+    };
+  }
+
+  return {
+    ...empty,
+    supported: true,
+    unsupportedReason: null,
+    crossSectionByCapacityMm2: indexByCapacity >= 0 ? CROSS_SECTIONS_MM2[indexByCapacity] : null,
+    crossSectionByVoltageDropMm2: indexByVoltageDrop >= 0 ? CROSS_SECTIONS_MM2[indexByVoltageDrop] : null,
+    recommendedCrossSectionMm2: indexRecommended >= 0 ? CROSS_SECTIONS_MM2[indexRecommended] : null,
+    voltageDropAtRecommendedPercent: indexRecommended >= 0 ? voltageDrops[indexRecommended] : null,
+    combinedDerationFactor,
+    harmonicReductionApplied,
+    practicalMinimumApplied,
+    rows,
+    protectionCoordination,
+  };
+}
+
+// -- Alerts -------------------------------------------------------------------
+
+export interface CableSizingAlert {
+  kind: "critical" | "warn" | "info" | "ok";
+  text: string;
+}
+
+const numberFormat = (value: number, digits = 1) =>
+  value.toLocaleString("de-DE", { minimumFractionDigits: digits, maximumFractionDigits: digits });
+const crossSectionFormat = (value: number) =>
+  `${value.toLocaleString("de-DE", { maximumFractionDigits: 1 })} mm²`;
+
+export function buildCableSizingAlerts(input: CableSizingInput, result: CableSizingResult): CableSizingAlert[] {
+  const alerts: CableSizingAlert[] = [];
+  const group = LAYING_METHOD_GROUP[input.layingMethod];
+
+  if (!result.supported) {
+    alerts.push({
+      kind: "critical",
+      text:
+        result.unsupportedReason === "temperature"
+          ? `${group === "air" ? "Umgebungstemperatur" : "Bodentemperatur"} ${input.ambientTemperatureC} °C liegt außerhalb der Tabelle für ${input.insulation === "pvc" ? "PVC" : "VPE"} – keine Berechnung möglich.`
+          : `Häufung mit ${input.groupingCircuits} Stromkreisen liegt außerhalb der Tabelle (max. ${MAX_GROUPING_CIRCUITS}) – keine Berechnung möglich.`,
+    });
+    return alerts;
+  }
+
+  if (result.temperatureUsedC !== input.ambientTemperatureC) {
+    alerts.push({
+      kind: "info",
+      text: `Temperatur auf den nächsten Tabellenwert ${result.temperatureUsedC} °C gerundet (sichere Seite).`,
+    });
+  }
+  if (result.groupingUsed !== input.groupingCircuits) {
+    alerts.push({
+      kind: "info",
+      text: `Häufung auf den nächsten Tabellenwert ${result.groupingUsed} Stromkreise gerundet (sichere Seite).`,
+    });
+  }
+
+  const byCapacity = result.crossSectionByCapacityMm2;
+  const byDrop = result.crossSectionByVoltageDropMm2;
+  if (byCapacity == null) {
+    const dueToProtection =
+      input.existingProtection != null && result.designCurrentA > result.operatingCurrentA;
+    alerts.push({
+      kind: "critical",
+      text: dueToProtection
+        ? `Das vorhandene Schutzorgan (${input.existingProtection!.ratedCurrentA} A) verlangt Iz ≥ ${numberFormat(result.designCurrentA)} A – das erreicht bei Verlegeart ${input.layingMethod} kein Querschnitt bis 240 mm². Verlegeart oder Schutzorgan prüfen.`
+        : `Der Betriebsstrom ${numberFormat(result.operatingCurrentA)} A übersteigt bei Verlegeart ${input.layingMethod} die Belastbarkeit aller Querschnitte bis 240 mm².`,
+    });
+  } else if (byDrop == null) {
+    alerts.push({
+      kind: "critical",
+      text: `Der Spannungsfall von ${numberFormat(input.maxVoltageDropPercent)} % wird bei ${input.lengthM} m mit keinem Querschnitt bis 240 mm² eingehalten.`,
+    });
+  } else if (byDrop > byCapacity) {
+    alerts.push({
+      kind: "warn",
+      text: `Der Spannungsfall ist maßgeblich: ${crossSectionFormat(byCapacity)} reichen thermisch, für ΔU ≤ ${numberFormat(input.maxVoltageDropPercent)} % sind ${crossSectionFormat(byDrop)} nötig.`,
+    });
+  }
+  if (result.harmonicReductionApplied) {
+    alerts.push({
+      kind: "info",
+      text: "Reduktionsfaktor 0,86 wegen 15–33 % 3. Harmonischer im Neutralleiter angewendet.",
+    });
+  }
+  if (input.phase === 3 && input.harmonicNeutralLoad === "over33Percent") {
+    alerts.push({
+      kind: "warn",
+      text: "3. Harmonische > 33 %: Der Neutralleiter ist nach dem Neutralleiterstrom zu bemessen – hier nicht berücksichtigt.",
+    });
+  }
+  if (group === "ground") {
+    alerts.push({
+      kind: "info",
+      text: "Erdverlegung: Bodenwärmewiderstand 2,5 K·m/W angenommen (Tabellenreferenz).",
+    });
+  }
+  if (result.practicalMinimumApplied) {
+    alerts.push({
+      kind: "info",
+      text: `Auf ${crossSectionFormat(result.recommendedCrossSectionMm2!)} angehoben (Praxis-Mindestquerschnitt für 1-phasige Stromkreise, keine Rechenanforderung).`,
+    });
+  }
+  if (result.protectionCoordination) {
+    const coordination = result.protectionCoordination;
+    const kindLabel = coordination.kind === "breaker" ? "Leitungsschutzschalter" : "Sicherung gG";
+    alerts.push(
+      coordination.coordinated
+        ? {
+            kind: "info",
+            text: `Schutzorgan ${kindLabel} ${coordination.ratedCurrentA} A berücksichtigt: In ≤ Iz und I₂ = ${numberFormat(coordination.conventionalTrippingFactor, 2)} · In ≤ 1,45 · Iz. Kurzschlussschutz und Abschaltbedingungen sind nicht Teil dieser Berechnung.`,
+          }
+        : {
+            kind: "warn",
+            text: `Schutzorgan ${kindLabel} ${coordination.ratedCurrentA} A ist mit dem empfohlenen Querschnitt nicht koordiniert (In ≤ Iz, I₂ ≤ 1,45 · Iz).`,
+          }
+    );
+  }
+  const recommendedRow = result.rows.find((row) => row.recommended);
+  if (recommendedRow && byCapacity != null && byDrop != null) {
+    if (!alerts.some((alert) => alert.kind === "warn" || alert.kind === "critical")) {
+      alerts.push({
+        kind: "ok",
+        text: `${crossSectionFormat(recommendedRow.crossSectionMm2)} ${input.conductorMaterial === "aluminum" ? "Al" : "Cu"} erfüllt bei ${input.lengthM} m Belastbarkeit (${numberFormat(result.designCurrentA)} A) und Spannungsfall (ΔU ≤ ${numberFormat(input.maxVoltageDropPercent)} %).`,
+      });
+    }
+    if (recommendedRow.maxLengthForVoltageDropM != null) {
+      alerts.push({
+        kind: "info",
+        text: `Maximale Länge bei ${crossSectionFormat(recommendedRow.crossSectionMm2)} für ΔU ≤ ${numberFormat(input.maxVoltageDropPercent)} %: ${recommendedRow.maxLengthForVoltageDropM.toFixed(0)} m.`,
+      });
+    }
+  }
+  return alerts;
+}
diff --git a/src/cable-sizing/domain/cable-sizing-contracts.ts b/src/cable-sizing/domain/cable-sizing-contracts.ts
new file mode 100644
index 0000000..2a2cc02
--- /dev/null
+++ b/src/cable-sizing/domain/cable-sizing-contracts.ts
@@ -0,0 +1,47 @@
+// Request validation for the cable-sizing HTTP API. Pure - depends only on
+// zod and the sibling calculation module, never on db/server.
+import { z } from "zod";
+import {
+  CONDUCTOR_MATERIALS,
+  HARMONIC_NEUTRAL_LOAD_OPTIONS,
+  INSULATION_MATERIALS,
+  LAYING_METHODS,
+  PROTECTION_KINDS,
+  type CableSizingInput,
+} from "./cable-sizing-calculation.js";
+
+export const cableSizingRequestSchema = z
+  .object({
+    phase: z.union([z.literal(1), z.literal(3)]),
+    mode: z.enum(["power", "current"]),
+    powerKw: z.number().finite().min(0).optional(),
+    currentA: z.number().finite().min(0).optional(),
+    cosPhi: z.number().finite().min(0.1).max(1),
+    voltage: z.number().finite().positive(),
+    lengthM: z.number().finite().min(0).max(10000),
+    layingMethod: z.enum(LAYING_METHODS),
+    conductorMaterial: z.enum(CONDUCTOR_MATERIALS),
+    insulation: z.enum(INSULATION_MATERIALS),
+    ambientTemperatureC: z.number().finite().min(-40).max(120),
+    groupingCircuits: z.number().int().min(1).max(100),
+    maxVoltageDropPercent: z.number().finite().min(0.5).max(10),
+    harmonicNeutralLoad: z.enum(HARMONIC_NEUTRAL_LOAD_OPTIONS),
+    existingProtection: z
+      .object({
+        ratedCurrentA: z.number().finite().positive(),
+        kind: z.enum(PROTECTION_KINDS),
+      })
+      .strict()
+      .optional(),
+    circuitCategory: z.enum(["lighting", "single_phase", "three_phase"]).optional(),
+  })
+  .strict()
+  .refine((value) => (value.mode === "power" ? value.powerKw != null : value.currentA != null), {
+    message: "powerKw is required for mode 'power', currentA for mode 'current'",
+  });
+
+export type CableSizingRequest = z.infer<typeof cableSizingRequestSchema>;
+
+// The request schema must stay assignable to the domain input shape.
+type AssertAssignable<T extends CableSizingInput> = T;
+export type CableSizingRequestIsDomainInput = AssertAssignable<CableSizingRequest>;
diff --git a/src/frontend/components/cable-sizing-api.ts b/src/frontend/components/cable-sizing-api.ts
new file mode 100644
index 0000000..28530d2
--- /dev/null
+++ b/src/frontend/components/cable-sizing-api.ts
@@ -0,0 +1,37 @@
+// Thin fetch client for the cable-sizing module, kept separate from
+// ../utils/api.ts so the module stays self-contained (see
+// docs/cable-sizing-module.md).
+import type {
+  CableSizingAlert,
+  CableSizingInput,
+  CableSizingResult,
+} from "../../cable-sizing/domain/cable-sizing-calculation";
+
+export interface CalculateCableSizingResponse {
+  result: CableSizingResult;
+  alerts: CableSizingAlert[];
+}
+
+export async function calculateCableSizing(
+  input: CableSizingInput
+): Promise<CalculateCableSizingResponse> {
+  const response = await fetch("/api/cable-sizing/calculate", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(input),
+    cache: "no-store",
+  });
+  if (!response.ok) {
+    let details = await response.text();
+    try {
+      const parsed = JSON.parse(details) as { error?: unknown };
+      if (typeof parsed.error === "string") {
+        details = parsed.error;
+      }
+    } catch {
+      // keep raw text
+    }
+    throw new Error(details || `Anfrage fehlgeschlagen (Status ${response.status})`);
+  }
+  return response.json() as Promise<CalculateCableSizingResponse>;
+}
diff --git a/src/frontend/components/cable-sizing-defaults.ts b/src/frontend/components/cable-sizing-defaults.ts
new file mode 100644
index 0000000..ae4c7a4
--- /dev/null
+++ b/src/frontend/components/cable-sizing-defaults.ts
@@ -0,0 +1,54 @@
+// Derives the cable-sizing inputs that follow from the circuit itself, so the
+// planner starts from the circuit's real values instead of fixed defaults.
+import type {
+  CircuitCategory,
+  ExistingProtection,
+} from "../../cable-sizing/domain/cable-sizing-calculation";
+import type { CircuitTreeCircuitDto, CircuitTreeProtectionDeviceDto } from "../types";
+
+/** Three-phase if the circuit group or any device row is three-phase. */
+export function deriveCircuitPhase(
+  circuit: CircuitTreeCircuitDto,
+  circuitCategory?: CircuitCategory
+): 1 | 3 {
+  return circuitCategory === "three_phase" ||
+    circuit.deviceRows.some((row) => row.phaseType === "three_phase")
+    ? 3
+    : 1;
+}
+
+/**
+ * Power-weighted cos φ of the circuit: P / S with S = Σ P_row / cos φ_row.
+ * Rows without cos φ count as 1; a circuit without load yields 1.
+ */
+export function deriveCircuitCosPhi(circuit: CircuitTreeCircuitDto): number {
+  let activePowerKw = 0;
+  let apparentPowerKva = 0;
+  for (const row of circuit.deviceRows) {
+    activePowerKw += row.rowTotalPower;
+    apparentPowerKva += row.rowTotalPower / (row.cosPhi || 1);
+  }
+  if (activePowerKw <= 0 || apparentPowerKva <= 0) {
+    return 1;
+  }
+  return Math.round((activePowerKw / apparentPowerKva) * 100) / 100;
+}
+
+/**
+ * Maps the circuit's protective device to the overload-protection kind of the
+ * calculation. Circuit-breakers (LS, FI/LS, AFDD) are "breaker", D0 and NH
+ * fuse links "fuse"; a residual-current device without overcurrent release
+ * (FI) provides no overload protection and is ignored.
+ */
+export function toExistingProtection(
+  protection: CircuitTreeProtectionDeviceDto | undefined
+): ExistingProtection | undefined {
+  if (!protection || protection.type === "FI") {
+    return undefined;
+  }
+  const kind =
+    protection.type === "LS" || protection.type === "FI_LS" || protection.type === "AFDD"
+      ? "breaker"
+      : "fuse";
+  return { ratedCurrentA: protection.ratedCurrentA, kind };
+}
diff --git a/src/frontend/components/cable-sizing-modal.tsx b/src/frontend/components/cable-sizing-modal.tsx
new file mode 100644
index 0000000..deb01b2
--- /dev/null
+++ b/src/frontend/components/cable-sizing-modal.tsx
@@ -0,0 +1,571 @@
+"use client";
+
+import { type FormEvent, useMemo, useState } from "react";
+import {
+  CONDUCTOR_MATERIALS,
+  CROSS_SECTIONS_MM2,
+  HARMONIC_NEUTRAL_LOAD_LABELS,
+  HARMONIC_NEUTRAL_LOAD_OPTIONS,
+  INSULATION_MATERIALS,
+  INSULATION_MATERIAL_LABELS,
+  LAYING_METHODS,
+  LAYING_METHOD_GROUP,
+  LAYING_METHOD_LABELS,
+  MAX_GROUPING_CIRCUITS,
+  PRACTICAL_MINIMUM_CROSS_SECTION_MM2,
+  REFERENCE_TEMPERATURE_C,
+  temperatureOptions,
+  type CableSizingAlert,
+  type CableSizingInput,
+  type CableSizingResult,
+  type CircuitCategory,
+  type ConductorMaterial,
+  type HarmonicNeutralLoad,
+  type InsulationMaterial,
+  type LayingMethod,
+} from "../../cable-sizing/domain/cable-sizing-calculation";
+import { calculateCableSizing } from "./cable-sizing-api";
+import type { CircuitTreeCircuitDto } from "../types";
+import {
+  deriveCircuitCosPhi,
+  deriveCircuitPhase,
+  toExistingProtection,
+} from "./cable-sizing-defaults";
+import { FormModal } from "./form-modal";
+
+interface CableSizingModalProps {
+  circuit: CircuitTreeCircuitDto;
+  circuitCategory?: CircuitCategory;
+  singlePhaseVoltageV: number;
+  threePhaseVoltageV: number;
+  isSaving: boolean;
+  onClose: () => void;
+  onApply: (patch: {
+    cableCrossSection: string;
+    cableType?: string;
+    cableLength?: number;
+  }) => Promise<void>;
+}
+
+// Extracts the first decimal number from a free-text cross-section entry
+// like "2.5 mm²" or "2,5"; used only for the manual-entry sanity check.
+function parseCrossSectionMm2(text: string): number | null {
+  const match = text.match(/([0-9]+(?:[.,][0-9]+)?)/);
+  if (!match) return null;
+  const value = Number(match[1].replace(",", "."));
+  return Number.isFinite(value) ? value : null;
+}
+
+const formatNumber = (value: number, digits: number) =>
+  value.toLocaleString("de-DE", { minimumFractionDigits: digits, maximumFractionDigits: digits });
+
+export function CableSizingModal({
+  circuit,
+  circuitCategory,
+  singlePhaseVoltageV,
+  threePhaseVoltageV,
+  isSaving,
+  onClose,
+  onApply,
+}: CableSizingModalProps) {
+  const derivedPhase = deriveCircuitPhase(circuit, circuitCategory);
+  const derivedCosPhi = deriveCircuitCosPhi(circuit);
+  const existingProtection = toExistingProtection(circuit.protectionDevice);
+
+  const [layingMethod, setLayingMethod] = useState<LayingMethod>("C");
+  const [insulation, setInsulation] = useState<InsulationMaterial>("pvc");
+  const [conductorMaterial, setConductorMaterial] = useState<ConductorMaterial>("copper");
+  const [ambientTemperatureC, setAmbientTemperatureC] = useState(30);
+  const [groupingCircuits, setGroupingCircuits] = useState(1);
+  const [cosPhi, setCosPhi] = useState(derivedCosPhi);
+  const [maxVoltageDropPercent, setMaxVoltageDropPercent] = useState(3);
+  const [harmonicNeutralLoad, setHarmonicNeutralLoad] = useState<HarmonicNeutralLoad>("none");
+  const [lengthM, setLengthM] = useState(circuit.cableLength ?? 0);
+  const [phase, setPhase] = useState<1 | 3>(derivedPhase);
+
+  // Manual entry: applying never requires a calculation. Prefilled from the
+  // circuit so an existing cable specification is not lost.
+  const [manualCableType, setManualCableType] = useState(circuit.cableType ?? "");
+  const [manualCrossSection, setManualCrossSection] = useState(circuit.cableCrossSection ?? "");
+
+  const [calculating, setCalculating] = useState(false);
+  const [result, setResult] = useState<CableSizingResult | null>(null);
+  const [alerts, setAlerts] = useState<CableSizingAlert[]>([]);
+  const [error, setError] = useState<string | null>(null);
+
+  const voltage =
+    phase === derivedPhase && circuit.voltage
+      ? circuit.voltage
+      : phase === 3
+        ? threePhaseVoltageV
+        : singlePhaseVoltageV;
+  const group = LAYING_METHOD_GROUP[layingMethod];
+  const availableTemperatures = temperatureOptions(layingMethod, insulation);
+
+  const input: CableSizingInput = useMemo(
+    () => ({
+      phase,
+      mode: "power",
+      powerKw: circuit.circuitTotalPower,
+      cosPhi,
+      voltage,
+      lengthM,
+      layingMethod,
+      conductorMaterial,
+      insulation,
+      ambientTemperatureC,
+      groupingCircuits,
+      maxVoltageDropPercent,
+      harmonicNeutralLoad,
+      existingProtection,
+      circuitCategory,
+    }),
+    [
+      phase,
+      circuit.circuitTotalPower,
+      cosPhi,
+      voltage,
+      lengthM,
+      layingMethod,
+      conductorMaterial,
+      insulation,
+      ambientTemperatureC,
+      groupingCircuits,
+      maxVoltageDropPercent,
+      harmonicNeutralLoad,
+      existingProtection?.ratedCurrentA,
+      existingProtection?.kind,
+      circuitCategory,
+    ]
+  );
+
+  const manualCrossSectionWarning = useMemo(() => {
+    const trimmed = manualCrossSection.trim();
+    if (!trimmed) return null;
+    const parsed = parseCrossSectionMm2(trimmed);
+    if (parsed == null) return null;
+    if (!(CROSS_SECTIONS_MM2 as readonly number[]).includes(parsed)) {
+      return `${formatNumber(parsed, parsed % 1 ? 1 : 0)} mm² ist kein Normquerschnitt (${CROSS_SECTIONS_MM2.map((value) => formatNumber(value, value % 1 ? 1 : 0)).join(", ")}).`;
+    }
+    if (
+      result?.supported &&
+      result.recommendedCrossSectionMm2 != null &&
+      parsed < result.recommendedCrossSectionMm2
+    ) {
+      return `${formatNumber(parsed, parsed % 1 ? 1 : 0)} mm² ist kleiner als die zuletzt berechnete Empfehlung (${formatNumber(result.recommendedCrossSectionMm2, result.recommendedCrossSectionMm2 % 1 ? 1 : 0)} mm²).`;
+    }
+    const practicalMinimum = circuitCategory
+      ? PRACTICAL_MINIMUM_CROSS_SECTION_MM2[circuitCategory]
+      : undefined;
+    if (practicalMinimum != null && parsed < practicalMinimum) {
+      return `${formatNumber(parsed, parsed % 1 ? 1 : 0)} mm² liegt unter dem Praxis-Mindestquerschnitt für 1-phasige Stromkreise (${formatNumber(practicalMinimum, 1)} mm²).`;
+    }
+    return null;
+  }, [manualCrossSection, result, circuitCategory]);
+
+  function resetResult() {
+    setResult(null);
+    setAlerts([]);
+  }
+
+  function applyReferenceTemperature(method: LayingMethod, material: InsulationMaterial) {
+    const options = temperatureOptions(method, material);
+    const reference = REFERENCE_TEMPERATURE_C[LAYING_METHOD_GROUP[method]];
+    setAmbientTemperatureC(options.includes(reference) ? reference : options[0]);
+  }
+
+  async function handleCalculate() {
+    setCalculating(true);
+    setError(null);
+    try {
+      const response = await calculateCableSizing(input);
+      setResult(response.result);
+      setAlerts(response.alerts);
+      // The suggestion fills the manual field, which stays the single source
+      // of truth for what gets applied.
+      if (response.result.supported && response.result.recommendedCrossSectionMm2) {
+        const size = response.result.recommendedCrossSectionMm2;
+        setManualCrossSection(`${formatNumber(size, size % 1 ? 1 : 0)} mm²`);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Berechnung fehlgeschlagen");
+    } finally {
+      setCalculating(false);
+    }
+  }
+
+  async function handleSubmit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    if (!manualCrossSection.trim()) return;
+    await onApply({
+      cableCrossSection: manualCrossSection.trim(),
+      cableType: manualCableType.trim() || undefined,
+      cableLength: lengthM,
+    });
+  }
+
+  const recommendedRow = result?.rows.find((row) => row.recommended);
+
+  return (
+    <FormModal
+      description="Querschnittsempfehlung nach IEC 60364-5-52 Anhang B (Belastbarkeit, Temperatur, Häufung, Spannungsfall, Schutzorgan) oder direkte Eingabe. Die Empfehlung vor der Übernahme fachlich prüfen; nationale Tabellen (DIN VDE 0298-4) können abweichen."
+      isSaving={isSaving}
+      onClose={onClose}
+      onSubmit={handleSubmit}
+      submitDisabled={!manualCrossSection.trim()}
+      submitLabel="Übernehmen"
+      title={`Leitungsberechnung – ${circuit.equipmentIdentifier}${
+        circuit.displayName ? ` (${circuit.displayName})` : ""
+      }`}
+    >
+      <div className="row g-3">
+        <div className="col-12 col-md-4">
+          <label className="form-label" htmlFor="cable-sizing-length">
+            Leitungslänge [m]
+          </label>
+          <input
+            className="form-control"
+            id="cable-sizing-length"
+            min={0}
+            onChange={(event) => {
+              setLengthM(Number(event.target.value));
+              resetResult();
+            }}
+            type="number"
+            value={lengthM}
+          />
+        </div>
+        <div className="col-12 col-md-4">
+          <label className="form-label" htmlFor="cable-sizing-phase">
+            Phasen
+          </label>
+          <select
+            className="form-select"
+            id="cable-sizing-phase"
+            onChange={(event) => {
+              setPhase(Number(event.target.value) as 1 | 3);
+              resetResult();
+            }}
+            value={phase}
+          >
+            <option value={1}>1~ ({derivedPhase === 1 && circuit.voltage ? circuit.voltage : singlePhaseVoltageV} V)</option>
+            <option value={3}>3~ ({derivedPhase === 3 && circuit.voltage ? circuit.voltage : threePhaseVoltageV} V)</option>
+          </select>
+          {phase !== derivedPhase ? (
+            <div className="form-text text-warning">
+              Abweichend vom Stromkreis ({derivedPhase === 3 ? "3~" : "1~"}).
+            </div>
+          ) : null}
+        </div>
+        <div className="col-12 col-md-4">
+          <label className="form-label" htmlFor="cable-sizing-power">
+            Leistung (aus Stromkreis)
+          </label>
+          <input
+            className="form-control"
+            disabled
+            id="cable-sizing-power"
+            value={`${formatNumber(circuit.circuitTotalPower, 2)} kW`}
+          />
+        </div>
+        <div className="col-12 col-md-6">
+          <label className="form-label" htmlFor="cable-sizing-method">
+            Verlegeart
+          </label>
+          <select
+            autoFocus
+            className="form-select"
+            id="cable-sizing-method"
+            onChange={(event) => {
+              const method = event.target.value as LayingMethod;
+              setLayingMethod(method);
+              applyReferenceTemperature(method, insulation);
+              resetResult();
+            }}
+            value={layingMethod}
+          >
+            {LAYING_METHODS.map((method) => (
+              <option key={method} value={method}>
+                {LAYING_METHOD_LABELS[method]}
+              </option>
+            ))}
+          </select>
+        </div>
+        <div className="col-12 col-md-6">
+          <label className="form-label" htmlFor="cable-sizing-insulation">
+            Isolierstoff
+          </label>
+          <select
+            className="form-select"
+            id="cable-sizing-insulation"
+            onChange={(event) => {
+              const material = event.target.value as InsulationMaterial;
+              setInsulation(material);
+              if (!temperatureOptions(layingMethod, material).includes(ambientTemperatureC)) {
+                applyReferenceTemperature(layingMethod, material);
+              }
+              resetResult();
+            }}
+            value={insulation}
+          >
+            {INSULATION_MATERIALS.map((material) => (
+              <option key={material} value={material}>
+                {INSULATION_MATERIAL_LABELS[material]}
+              </option>
+            ))}
+          </select>
+        </div>
+        <div className="col-12 col-md-4">
+          <label className="form-label" htmlFor="cable-sizing-material">
+            Leitermaterial
+          </label>
+          <select
+            className="form-select"
+            id="cable-sizing-material"
+            onChange={(event) => {
+              setConductorMaterial(event.target.value as ConductorMaterial);
+              resetResult();
+            }}
+            value={conductorMaterial}
+          >
+            {CONDUCTOR_MATERIALS.map((material) => (
+              <option key={material} value={material}>
+                {material === "copper" ? "Kupfer" : "Aluminium"}
+              </option>
+            ))}
+          </select>
+        </div>
+        <div className="col-12 col-md-4">
+          <label className="form-label" htmlFor="cable-sizing-temperature">
+            {group === "air" ? "Umgebungstemperatur" : "Bodentemperatur"}
+          </label>
+          <select
+            className="form-select"
+            id="cable-sizing-temperature"
+            onChange={(event) => {
+              setAmbientTemperatureC(Number(event.target.value));
+              resetResult();
+            }}
+            value={ambientTemperatureC}
+          >
+            {availableTemperatures.map((temperature) => (
+              <option key={temperature} value={temperature}>
+                {temperature} °C
+              </option>
+            ))}
+          </select>
+        </div>
+        <div className="col-12 col-md-4">
+          <label className="form-label" htmlFor="cable-sizing-grouping">
+            Häufung (Stromkreise)
+          </label>
+          <input
+            className="form-control"
+            id="cable-sizing-grouping"
+            max={MAX_GROUPING_CIRCUITS}
+            min={1}
+            onChange={(event) => {
+              setGroupingCircuits(Math.max(1, Math.round(Number(event.target.value) || 1)));
+              resetResult();
+            }}
+            step={1}
+            type="number"
+            value={groupingCircuits}
+          />
+          <div className="form-text">
+            Anzahl gemeinsam verlegter Stromkreise, einschließlich dieses.
+          </div>
+        </div>
+        {phase === 3 ? (
+          <div className="col-12 col-md-6">
+            <label className="form-label" htmlFor="cable-sizing-harmonics">
+              Oberschwingungen im Neutralleiter
+            </label>
+            <select
+              className="form-select"
+              id="cable-sizing-harmonics"
+              onChange={(event) => {
+                setHarmonicNeutralLoad(event.target.value as HarmonicNeutralLoad);
+                resetResult();
+              }}
+              value={harmonicNeutralLoad}
+            >
+              {HARMONIC_NEUTRAL_LOAD_OPTIONS.map((option) => (
+                <option key={option} value={option}>
+                  {HARMONIC_NEUTRAL_LOAD_LABELS[option]}
+                </option>
+              ))}
+            </select>
+          </div>
+        ) : null}
+        <div className="col-12 col-md-3">
+          <label className="form-label" htmlFor="cable-sizing-cosphi">
+            cos φ
+          </label>
+          <input
+            className="form-control"
+            id="cable-sizing-cosphi"
+            max={1}
+            min={0.1}
+            onChange={(event) => {
+              setCosPhi(Math.min(1, Math.max(0.1, Number(event.target.value) || 1)));
+              resetResult();
+            }}
+            step={0.01}
+            type="number"
+            value={cosPhi}
+          />
+          <div className="form-text">
+            Aus den Gerätezeilen: {formatNumber(derivedCosPhi, 2)}
+          </div>
+        </div>
+        <div className="col-12 col-md-3">
+          <label className="form-label" htmlFor="cable-sizing-voltage-drop">
+            Max. ΔU [%]
+          </label>
+          <input
+            className="form-control"
+            id="cable-sizing-voltage-drop"
+            max={10}
+            min={0.5}
+            onChange={(event) => {
+              setMaxVoltageDropPercent(Number(event.target.value) || 3);
+              resetResult();
+            }}
+            step={0.5}
+            type="number"
+            value={maxVoltageDropPercent}
+          />
+        </div>
+        <div className="col-12">
+          <div className="form-text">
+            Schutzorgan:{" "}
+            {existingProtection
+              ? `${existingProtection.kind === "breaker" ? "Leitungsschutzschalter" : "Sicherung gG"} ${existingProtection.ratedCurrentA} A (aus dem Stromkreis, In ≤ Iz und I₂ ≤ 1,45 · Iz)`
+              : "keines mit Überstromschutz hinterlegt – Bemessung nur nach Betriebsstrom"}
+          </div>
+        </div>
+      </div>
+
+      <button
+        className="btn btn-secondary mt-3"
+        disabled={calculating}
+        onClick={handleCalculate}
+        type="button"
+      >
+        {calculating ? "Berechnet …" : "Berechnen"}
+      </button>
+      {error ? <p className="text-danger mt-2">{error}</p> : null}
+
+      {result ? (
+        <div className="mt-3">
+          {result.supported ? (
+            <div className="row g-2">
+              <div className="col-6 col-md-3">
+                <div className="text-muted small">Betriebsstrom I<sub>B</sub></div>
+                <div>{formatNumber(result.operatingCurrentA, 1)} A</div>
+              </div>
+              <div className="col-6 col-md-3">
+                <div className="text-muted small">Erforderliches I<sub>z</sub></div>
+                <div>
+                  <strong>{formatNumber(result.designCurrentA, 1)} A</strong>
+                </div>
+              </div>
+              <div className="col-6 col-md-3">
+                <div className="text-muted small">Empfohlener Querschnitt</div>
+                <div>
+                  <strong>
+                    {result.recommendedCrossSectionMm2 != null
+                      ? `${formatNumber(result.recommendedCrossSectionMm2, result.recommendedCrossSectionMm2 % 1 ? 1 : 0)} mm²`
+                      : "–"}
+                  </strong>
+                </div>
+              </div>
+              <div className="col-6 col-md-3">
+                <div className="text-muted small">ΔU bei Empfehlung</div>
+                <div>
+                  {result.voltageDropAtRecommendedPercent != null
+                    ? `${formatNumber(result.voltageDropAtRecommendedPercent, 2)} %`
+                    : "–"}
+                </div>
+              </div>
+              <div className="col-6 col-md-3">
+                <div className="text-muted small">Korrekturfaktor gesamt</div>
+                <div>{formatNumber(result.combinedDerationFactor, 2)}</div>
+              </div>
+              <div className="col-6 col-md-3">
+                <div className="text-muted small">Temperatur / Häufung (gerechnet)</div>
+                <div>
+                  {result.temperatureUsedC} °C ({formatNumber(result.temperatureFactor ?? 1, 2)}) /{" "}
+                  {result.groupingUsed} ({formatNumber(result.groupingFactor ?? 1, 2)})
+                </div>
+              </div>
+              <div className="col-6 col-md-3">
+                <div className="text-muted small">Max. Länge für ΔU</div>
+                <div>
+                  {recommendedRow?.maxLengthForVoltageDropM != null
+                    ? `${recommendedRow.maxLengthForVoltageDropM.toFixed(0)} m`
+                    : "–"}
+                </div>
+              </div>
+            </div>
+          ) : null}
+          {alerts.map((alert, index) => (
+            <div
+              className={`alert mt-2 mb-0 alert-${
+                alert.kind === "critical"
+                  ? "danger"
+                  : alert.kind === "warn"
+                    ? "warning"
+                    : alert.kind === "ok"
+                      ? "success"
+                      : "info"
+              }`}
+              key={index}
+            >
+              {alert.text}
+            </div>
+          ))}
+        </div>
+      ) : null}
+
+      <hr className="my-3" />
+      <p className="text-muted small mb-2">
+        Kabeltyp und Querschnitt direkt eingeben oder die Empfehlung übernehmen.
+        Beides landet in denselben Feldern und kann vor dem Übernehmen angepasst
+        werden.
+      </p>
+      <div className="row g-3">
+        <div className="col-12 col-md-6">
+          <label className="form-label" htmlFor="cable-sizing-manual-type">
+            Kabeltyp
+          </label>
+          <input
+            className="form-control"
+            id="cable-sizing-manual-type"
+            onChange={(event) => setManualCableType(event.target.value)}
+            placeholder="z. B. NYM-J 3x2,5"
+            value={manualCableType}
+          />
+        </div>
+        <div className="col-12 col-md-6">
+          <label className="form-label" htmlFor="cable-sizing-manual-cross-section">
+            Querschnitt
+          </label>
+          <input
+            className="form-control"
+            id="cable-sizing-manual-cross-section"
+            onChange={(event) => setManualCrossSection(event.target.value)}
+            placeholder="z. B. 4 mm²"
+            value={manualCrossSection}
+          />
+        </div>
+        {manualCrossSectionWarning ? (
+          <div className="col-12">
+            <div className="alert alert-warning mb-0">{manualCrossSectionWarning}</div>
+          </div>
+        ) : null}
+      </div>
+    </FormModal>
+  );
+}
diff --git a/src/frontend/components/circuit-tree-editor.tsx b/src/frontend/components/circuit-tree-editor.tsx
index e559303..6851122 100644
--- a/src/frontend/components/circuit-tree-editor.tsx
+++ b/src/frontend/components/circuit-tree-editor.tsx
@@ -5,6 +5,7 @@ import {
   ArrowDown,
   ArrowDown01,
   ArrowUp,
+  Calculator,
   Check,
   Columns3,
   FilterX,
@@ -160,6 +161,7 @@ import type {
 import { DistributionBoardComponentModal } from "./distribution-board-component-modal";
 import { CircuitGroupModal } from "./circuit-group-modal";
 import { CircuitProtectionModal } from "./circuit-protection-modal";
+import { CableSizingModal } from "./cable-sizing-modal";
 import {
   circuitGroupCategoryLabels,
   type CircuitGroupCategory,
@@ -319,6 +321,8 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     useState<CircuitGroupEditorIntent | null>(null);
   const [protectionEditorCircuit, setProtectionEditorCircuit] =
     useState<CircuitTreeCircuitDto | null>(null);
+  const [cableSizingEditorCircuit, setCableSizingEditorCircuit] =
+    useState<CircuitTreeCircuitDto | null>(null);
   const [projectDevices, setProjectDevices] = useState<ProjectDeviceDto[]>([]);
   const [isProjectDeviceDrawerOpen, setIsProjectDeviceDrawerOpen] =
     useState(false);
@@ -1439,6 +1443,31 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     });
   }
 
+  async function handleApplyCableSizing(patch: {
+    cableCrossSection: string;
+    cableType?: string;
+    cableLength?: number;
+  }) {
+    const circuit = cableSizingEditorCircuit;
+    if (!circuit) {
+      return;
+    }
+    await runCommand({
+      label: "Leitungsberechnung übernehmen",
+      redo: async () => {
+        const result = await updateCircuitById(
+          projectId,
+          getExpectedProjectRevision(),
+          circuit.id,
+          patch
+        );
+        applyProjectCommandResult(result);
+        setCableSizingEditorCircuit(null);
+        return null;
+      },
+    });
+  }
+
   async function handleRedo() {
     if (historyBusy || isSaving || !historyState || historyState.redoDepth === 0) {
       return;
@@ -3185,6 +3214,21 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
           onSave={handleSaveCircuitProtection}
         />
       ) : null}
+      {cableSizingEditorCircuit ? (
+        <CableSizingModal
+          circuit={cableSizingEditorCircuit}
+          circuitCategory={
+            data.sections.find(
+              (section) => section.id === cableSizingEditorCircuit.sectionId
+            )?.category
+          }
+          isSaving={isSaving}
+          onApply={handleApplyCableSizing}
+          onClose={() => setCableSizingEditorCircuit(null)}
+          singlePhaseVoltageV={data.singlePhaseVoltageV}
+          threePhaseVoltageV={data.threePhaseVoltageV}
+        />
+      ) : null}
       <div className="editor-toolbar">
         <IconButton
           disabled={!historyState || historyState.undoDepth === 0 || historyBusy || isSaving}
@@ -4530,6 +4574,14 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                   >
                     {row.circuit && row.rowType !== "deviceRow" ? (
                       <>
+                        <IconButton
+                          disabled={isSaving}
+                          icon={Calculator}
+                          label="Leitungsberechnung"
+                          onClick={() => setCableSizingEditorCircuit(row.circuit!)}
+                          tabIndex={-1}
+                          title="Leitungsberechnung: Querschnitt ermitteln oder Kabel eintragen"
+                        />
                         <IconButton
                           disabled={isSaving}
                           icon={ListPlus}
diff --git a/src/server/controllers/cable-sizing.controller.ts b/src/server/controllers/cable-sizing.controller.ts
new file mode 100644
index 0000000..8c6124e
--- /dev/null
+++ b/src/server/controllers/cable-sizing.controller.ts
@@ -0,0 +1,37 @@
+import type { Request, Response } from "express";
+import { cableSizingRequestSchema } from "../../cable-sizing/domain/cable-sizing-contracts.js";
+import {
+  buildCableSizingAlerts,
+  calculateCableSizing,
+  INSULATION_MATERIALS,
+  INSULATION_MATERIAL_LABELS,
+  LAYING_METHODS,
+  LAYING_METHOD_LABELS,
+} from "../../cable-sizing/domain/cable-sizing-calculation.js";
+
+// Stateless calculation: it neither reads nor writes project data. The
+// planner applies a result through the existing circuit.update command, which
+// keeps revisions and Undo/Redo intact. See docs/cable-sizing-module.md.
+export function calculateCableSizingHandler(req: Request, res: Response) {
+  const parsed = cableSizingRequestSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+  const result = calculateCableSizing(parsed.data);
+  return res.json({ result, alerts: buildCableSizingAlerts(parsed.data, result) });
+}
+
+export function listLayingMethodsHandler(_req: Request, res: Response) {
+  return res.json(
+    LAYING_METHODS.map((method) => ({ method, label: LAYING_METHOD_LABELS[method] }))
+  );
+}
+
+export function listInsulationMaterialsHandler(_req: Request, res: Response) {
+  return res.json(
+    INSULATION_MATERIALS.map((insulation) => ({
+      insulation,
+      label: INSULATION_MATERIAL_LABELS[insulation],
+    }))
+  );
+}
diff --git a/src/server/index.ts b/src/server/index.ts
index 1f5c9b2..02c5cdc 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -2,6 +2,7 @@ import express from "express";
 import { globalDeviceRouter } from "./routes/global-device.routes.js";
 import { projectDeviceRouter } from "./routes/project-device.routes.js";
 import { projectRouter } from "./routes/project.routes.js";
+import { cableSizingRouter } from "./routes/cable-sizing.routes.js";
 import { errorMiddleware } from "./middleware/error.middleware.js";
 import { createLogger, toErrorMeta } from "../shared/logging/logger.js";
 import { closeDefaultDatabase } from "../db/client.js";
@@ -48,6 +49,7 @@ app.get("/health", (_req, res) => {
   res.json({ ok: true });
 });
 
+app.use("/api/cable-sizing", cableSizingRouter);
 app.use("/api/projects", projectRouter);
 app.use("/api/global-devices", globalDeviceRouter);
 app.use("/api/project-devices", projectDeviceRouter);
diff --git a/src/server/routes/cable-sizing.routes.ts b/src/server/routes/cable-sizing.routes.ts
new file mode 100644
index 0000000..485e9c1
--- /dev/null
+++ b/src/server/routes/cable-sizing.routes.ts
@@ -0,0 +1,9 @@
+import express from "express";
+import * as cableSizingController from "../controllers/cable-sizing.controller.js";
+
+// Stateless calculator endpoints; no project data is read or written here.
+export const cableSizingRouter = express.Router();
+
+cableSizingRouter.post("/calculate", cableSizingController.calculateCableSizingHandler);
+cableSizingRouter.get("/laying-methods", cableSizingController.listLayingMethodsHandler);
+cableSizingRouter.get("/insulation-materials", cableSizingController.listInsulationMaterialsHandler);
diff --git a/tests/cable-sizing-calculation.test.ts b/tests/cable-sizing-calculation.test.ts
new file mode 100644
index 0000000..05e4f3d
--- /dev/null
+++ b/tests/cable-sizing-calculation.test.ts
@@ -0,0 +1,274 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  buildCableSizingAlerts,
+  calculateCableSizing,
+  conventionalTrippingFactor,
+  CROSS_SECTIONS_MM2,
+  CURRENT_CAPACITY_A,
+  minimumIzForProtection,
+  temperatureOptions,
+  type CableSizingInput,
+} from "../src/cable-sizing/domain/cable-sizing-calculation.js";
+import { cableSizingRequestSchema } from "../src/cable-sizing/domain/cable-sizing-contracts.js";
+import {
+  deriveCircuitCosPhi,
+  deriveCircuitPhase,
+  toExistingProtection,
+} from "../src/frontend/components/cable-sizing-defaults.js";
+import type { CircuitTreeCircuitDto } from "../src/frontend/types.js";
+
+const BASE_INPUT: CableSizingInput = {
+  phase: 1,
+  mode: "power",
+  powerKw: 5,
+  cosPhi: 1,
+  voltage: 230,
+  lengthM: 30,
+  layingMethod: "C",
+  conductorMaterial: "copper",
+  insulation: "pvc",
+  ambientTemperatureC: 30,
+  groupingCircuits: 1,
+  maxVoltageDropPercent: 3,
+  harmonicNeutralLoad: "none",
+};
+
+const capacity = (
+  insulation: "pvc" | "xlpe",
+  material: "copper" | "aluminum",
+  method: keyof (typeof CURRENT_CAPACITY_A)["pvc"]["copper"],
+  cores: 2 | 3,
+  crossSection: number
+) =>
+  CURRENT_CAPACITY_A[insulation][material][method][cores][
+    CROSS_SECTIONS_MM2.indexOf(crossSection as (typeof CROSS_SECTIONS_MM2)[number])
+  ];
+
+describe("cable sizing reference tables (IEC 60364-5-52 Annex B)", () => {
+  it("contains the checked PVC copper values", () => {
+    // B.52.2: A1 two loaded conductors (the previously wrong row)
+    assert.equal(capacity("pvc", "copper", "A1", 2, 2.5), 19.5);
+    assert.equal(capacity("pvc", "copper", "A1", 2, 16), 61);
+    assert.equal(capacity("pvc", "copper", "A1", 2, 120), 210);
+    // B.52.2: B2 from 50 mm² (previously copied from B1)
+    assert.equal(capacity("pvc", "copper", "B2", 2, 50), 133);
+    assert.equal(capacity("pvc", "copper", "B2", 2, 120), 232);
+    // B.52.4 and D1/D2
+    assert.equal(capacity("pvc", "copper", "C", 3, 6), 41);
+    assert.equal(capacity("pvc", "copper", "D1", 2, 2.5), 29);
+    assert.equal(capacity("pvc", "copper", "D2", 3, 16), 70);
+    // Conflicting sources resolved to the lower value
+    assert.equal(capacity("pvc", "copper", "A1", 2, 240), 320);
+    assert.equal(capacity("pvc", "copper", "E", 3, 70), 196);
+  });
+
+  it("uses the aluminium and XLPE tables instead of flat factors", () => {
+    assert.equal(capacity("pvc", "aluminum", "A1", 2, 1.5), null);
+    assert.equal(capacity("pvc", "aluminum", "C", 3, 16), 59);
+    assert.equal(capacity("pvc", "aluminum", "D2", 2, 10), null);
+    assert.equal(capacity("xlpe", "copper", "C", 2, 2.5), 33);
+    assert.equal(capacity("xlpe", "aluminum", "E", 3, 25), 97);
+  });
+
+  it("has a complete, increasing row for every combination", () => {
+    for (const insulation of ["pvc", "xlpe"] as const) {
+      for (const material of ["copper", "aluminum"] as const) {
+        for (const [method, rows] of Object.entries(CURRENT_CAPACITY_A[insulation][material])) {
+          for (const cores of [2, 3] as const) {
+            const row = rows[cores];
+            assert.equal(row.length, CROSS_SECTIONS_MM2.length, `${insulation}/${material}/${method}/${cores}`);
+            const values = row.filter((value): value is number => value != null);
+            for (let index = 1; index < values.length; index += 1) {
+              assert.ok(values[index] > values[index - 1], `${insulation}/${material}/${method}/${cores}`);
+            }
+          }
+        }
+      }
+    }
+  });
+});
+
+describe("calculateCableSizing", () => {
+  it("sizes the reference case (1~, 5 kW, 230 V, 30 m, method C, Cu/PVC)", () => {
+    const result = calculateCableSizing(BASE_INPUT);
+    assert.equal(result.supported, true);
+    assert.ok(Math.abs(result.operatingCurrentA - 21.739) < 0.01);
+    assert.equal(result.crossSectionByCapacityMm2, 2.5);
+    assert.equal(result.crossSectionByVoltageDropMm2, 4);
+    assert.equal(result.recommendedCrossSectionMm2, 4);
+    const recommended = result.rows.find((row) => row.recommended)!;
+    // The maximum length is the inverse of the voltage-drop formula.
+    const atMaximum = calculateCableSizing({
+      ...BASE_INPUT,
+      lengthM: recommended.maxLengthForVoltageDropM!,
+    });
+    assert.ok(Math.abs(atMaximum.rows.find((row) => row.crossSectionMm2 === 4)!.voltageDropPercent! - 3) < 1e-9);
+  });
+
+  it("rounds temperature and grouping to the next tabulated, safer value", () => {
+    const warm = calculateCableSizing({ ...BASE_INPUT, ambientTemperatureC: 32 });
+    assert.equal(warm.temperatureUsedC, 35);
+    assert.equal(warm.temperatureFactor, 0.94);
+    const cold = calculateCableSizing({ ...BASE_INPUT, ambientTemperatureC: 5 });
+    assert.equal(cold.temperatureUsedC, 10);
+    assert.equal(cold.temperatureFactor, 1.22);
+    const grouped = calculateCableSizing({ ...BASE_INPUT, groupingCircuits: 10 });
+    assert.equal(grouped.groupingUsed, 12);
+    assert.equal(grouped.groupingFactor, 0.45);
+    const alerts = buildCableSizingAlerts({ ...BASE_INPUT, groupingCircuits: 10 }, grouped);
+    assert.ok(alerts.some((alert) => alert.text.includes("12 Stromkreise gerundet")));
+  });
+
+  it("uses the PVC 70 °C air factors, not the 60 °C column", () => {
+    assert.equal(calculateCableSizing({ ...BASE_INPUT, ambientTemperatureC: 20 }).temperatureFactor, 1.12);
+    assert.equal(calculateCableSizing({ ...BASE_INPUT, ambientTemperatureC: 50 }).temperatureFactor, 0.71);
+    assert.equal(
+      calculateCableSizing({ ...BASE_INPUT, insulation: "xlpe", ambientTemperatureC: 65 }).temperatureFactor,
+      0.65
+    );
+  });
+
+  it("uses the ground tables for D1 (ducts) and D2 (direct)", () => {
+    const d1 = calculateCableSizing({ ...BASE_INPUT, layingMethod: "D1", ambientTemperatureC: 20, groupingCircuits: 10 });
+    assert.equal(d1.groupingFactor, 0.49);
+    const d2 = calculateCableSizing({ ...BASE_INPUT, layingMethod: "D2", ambientTemperatureC: 20, groupingCircuits: 10 });
+    assert.equal(d2.groupingUsed, 12);
+    assert.equal(d2.groupingFactor, 0.36);
+    assert.equal(calculateCableSizing({ ...BASE_INPUT, layingMethod: "D2", ambientTemperatureC: 30 }).temperatureFactor, 0.89);
+  });
+
+  it("refuses inputs outside the tables instead of assuming a factor of 1", () => {
+    const hot = calculateCableSizing({ ...BASE_INPUT, ambientTemperatureC: 65 });
+    assert.equal(hot.supported, false);
+    assert.equal(hot.unsupportedReason, "temperature");
+    assert.equal(hot.recommendedCrossSectionMm2, null);
+    assert.equal(buildCableSizingAlerts({ ...BASE_INPUT, ambientTemperatureC: 65 }, hot)[0]?.kind, "critical");
+    const crowded = calculateCableSizing({ ...BASE_INPUT, groupingCircuits: 21 });
+    assert.equal(crowded.supported, false);
+    assert.equal(crowded.unsupportedReason, "grouping");
+  });
+
+  it("never recommends a cross-section without tabulated capacity", () => {
+    const result = calculateCableSizing({
+      ...BASE_INPUT,
+      powerKw: 0.5,
+      lengthM: 5,
+      conductorMaterial: "aluminum",
+    });
+    assert.equal(result.recommendedCrossSectionMm2, 2.5);
+    assert.equal(result.rows[0].ratedCurrentA, null);
+    assert.equal(result.rows[0].recommended, false);
+  });
+
+  it("checks gG fuses with I2 = 1.6 In and circuit-breakers with In ≤ Iz", () => {
+    assert.equal(conventionalTrippingFactor({ kind: "breaker", ratedCurrentA: 16 }), 1.45);
+    assert.equal(conventionalTrippingFactor({ kind: "fuse", ratedCurrentA: 16 }), 1.6);
+    assert.equal(conventionalTrippingFactor({ kind: "fuse", ratedCurrentA: 10 }), 1.9);
+    assert.equal(conventionalTrippingFactor({ kind: "fuse", ratedCurrentA: 4 }), 2.1);
+    assert.ok(Math.abs(minimumIzForProtection({ kind: "fuse", ratedCurrentA: 16 }) - 17.655) < 0.01);
+
+    // At 40 °C: 1.5 mm² (C, 2 loaded) carries 19.5 × 0.87 = 16.97 A.
+    const input = { ...BASE_INPUT, powerKw: 1, lengthM: 5, ambientTemperatureC: 40 };
+    const breaker = calculateCableSizing({ ...input, existingProtection: { kind: "breaker", ratedCurrentA: 16 } });
+    assert.equal(breaker.recommendedCrossSectionMm2, 1.5);
+    assert.equal(breaker.protectionCoordination?.coordinated, true);
+    const fuse = calculateCableSizing({ ...input, existingProtection: { kind: "fuse", ratedCurrentA: 16 } });
+    assert.equal(fuse.recommendedCrossSectionMm2, 2.5);
+    assert.equal(fuse.protectionCoordination?.coordinated, true);
+  });
+
+  it("applies the 0.86 harmonic factor only for three-phase circuits with 15–33 %", () => {
+    const three = calculateCableSizing({ ...BASE_INPUT, phase: 3, voltage: 400, harmonicNeutralLoad: "15to33Percent" });
+    assert.equal(three.harmonicReductionApplied, true);
+    assert.ok(Math.abs(three.combinedDerationFactor - 0.86) < 1e-9);
+    const single = calculateCableSizing({ ...BASE_INPUT, harmonicNeutralLoad: "15to33Percent" });
+    assert.equal(single.harmonicReductionApplied, false);
+  });
+
+  it("raises single-phase circuits to the 2.5 mm² practical minimum", () => {
+    const result = calculateCableSizing({
+      ...BASE_INPUT,
+      powerKw: 1,
+      lengthM: 5,
+      circuitCategory: "single_phase",
+    });
+    assert.equal(result.recommendedCrossSectionMm2, 2.5);
+    assert.equal(result.practicalMinimumApplied, true);
+    const alerts = buildCableSizingAlerts({ ...BASE_INPUT, powerKw: 1, lengthM: 5, circuitCategory: "single_phase" }, result);
+    assert.ok(alerts.some((alert) => alert.text.includes("Auf 2,5 mm² angehoben")));
+    assert.ok(!alerts.some((alert) => /d.d mm²/.test(alert.text)));
+  });
+
+  it("offers only tabulated temperatures", () => {
+    assert.deepEqual(temperatureOptions("C", "pvc").at(-1), 60);
+    assert.deepEqual(temperatureOptions("C", "xlpe").at(-1), 80);
+    assert.deepEqual(temperatureOptions("D1", "pvc")[2], 20);
+  });
+});
+
+describe("cable sizing request schema", () => {
+  it("accepts a complete request and rejects unknown or legacy fields", () => {
+    assert.equal(cableSizingRequestSchema.safeParse(BASE_INPUT).success, true);
+    assert.equal(
+      cableSizingRequestSchema.safeParse({ ...BASE_INPUT, existingProtection: { kind: "fuse", ratedCurrentA: 25 } }).success,
+      true
+    );
+    assert.equal(
+      cableSizingRequestSchema.safeParse({ ...BASE_INPUT, existingProtectionRatedCurrentA: 16 }).success,
+      false
+    );
+    assert.equal(cableSizingRequestSchema.safeParse({ ...BASE_INPUT, layingMethod: "F" }).success, false);
+    assert.equal(cableSizingRequestSchema.safeParse({ ...BASE_INPUT, mode: "current" }).success, false);
+  });
+});
+
+describe("cable sizing defaults from the circuit", () => {
+  const circuit = (rows: Array<{ power: number; cosPhi?: number; phaseType?: string }>): CircuitTreeCircuitDto => ({
+    id: "circuit",
+    circuitListId: "list",
+    sectionId: "section",
+    equipmentIdentifier: "-2F1.1",
+    sortOrder: 1,
+    isReserve: rows.length === 0,
+    circuitTotalPower: rows.reduce((sum, row) => sum + row.power, 0),
+    deviceRows: rows.map((row, index) => ({
+      id: `row-${index}`,
+      sortOrder: index,
+      name: "Gerät",
+      displayName: "Gerät",
+      quantity: 1,
+      manualQuantity: 1,
+      powerPerUnit: row.power,
+      simultaneityFactor: 1,
+      rowTotalPower: row.power,
+      cosPhi: row.cosPhi,
+      phaseType: row.phaseType,
+    })),
+  });
+
+  it("derives a power-weighted cos φ", () => {
+    // P = 3 kW, S = 2 / 0.8 + 1 / 1 = 3.5 kVA → 0.857
+    assert.equal(deriveCircuitCosPhi(circuit([{ power: 2, cosPhi: 0.8 }, { power: 1 }])), 0.86);
+    assert.equal(deriveCircuitCosPhi(circuit([])), 1);
+  });
+
+  it("derives the phase from the group category or three-phase rows", () => {
+    assert.equal(deriveCircuitPhase(circuit([{ power: 1, phaseType: "single_phase" }]), "single_phase"), 1);
+    assert.equal(deriveCircuitPhase(circuit([{ power: 1, phaseType: "three_phase" }]), "single_phase"), 3);
+    assert.equal(deriveCircuitPhase(circuit([]), "three_phase"), 3);
+  });
+
+  it("maps protective devices to the overload-protection kind", () => {
+    assert.deepEqual(toExistingProtection({ type: "LS", ratedCurrentA: 16, tripCharacteristic: "B" }), {
+      kind: "breaker",
+      ratedCurrentA: 16,
+    });
+    assert.deepEqual(toExistingProtection({ type: "NH00", ratedCurrentA: 63, fuseUtilizationCategory: "gG" }), {
+      kind: "fuse",
+      ratedCurrentA: 63,
+    });
+    assert.equal(toExistingProtection({ type: "FI", ratedCurrentA: 40, rcdType: "A", ratedResidualCurrentMa: 30 }), undefined);
+    assert.equal(toExistingProtection(undefined), undefined);
+  });
+});

From db4a6c3a2ea5f839967a8a125419500de2f4e753 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 11:37:55 +0200
Subject: [PATCH 11/60] Add back arrow to the circuit list page

The arrow next to the "Stromkreisliste" heading returns to the project's
distribution board overview.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../[circuitListId]/tree-edit/page.tsx          | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/app/projects/[projectId]/circuit-lists/[circuitListId]/tree-edit/page.tsx b/src/app/projects/[projectId]/circuit-lists/[circuitListId]/tree-edit/page.tsx
index 89679cf..90893f6 100644
--- a/src/app/projects/[projectId]/circuit-lists/[circuitListId]/tree-edit/page.tsx
+++ b/src/app/projects/[projectId]/circuit-lists/[circuitListId]/tree-edit/page.tsx
@@ -1,5 +1,6 @@
 "use client";
 
+import { ArrowLeft } from "lucide-react";
 import Link from "next/link";
 import { useParams } from "next/navigation";
 import { CircuitTreeEditor } from "../../../../../../frontend/components/circuit-tree-editor";
@@ -10,9 +11,19 @@ export default function CircuitTreeEditPage() {
   return (
     <main className="container-fluid px-3 px-xxl-4 py-4">
       <div className="d-flex flex-wrap justify-content-between align-items-center gap-3 mb-3">
-        <div>
-          <h1 className="h4 mb-1">Stromkreisliste</h1>
-          <p className="text-secondary mb-0">Stromkreise und zugeordnete Geräte bearbeiten.</p>
+        <div className="d-flex align-items-center gap-2">
+          <Link
+            aria-label="Zurück zur Verteilerübersicht"
+            className="btn btn-outline-secondary btn-sm"
+            href={`/projects/${params.projectId}`}
+            title="Zurück zur Verteilerübersicht"
+          >
+            <ArrowLeft aria-hidden="true" size={18} />
+          </Link>
+          <div>
+            <h1 className="h4 mb-1">Stromkreisliste</h1>
+            <p className="text-secondary mb-0">Stromkreise und zugeordnete Geräte bearbeiten.</p>
+          </div>
         </div>
         <div className="d-flex gap-2">
           <Link href={`/projects/${params.projectId}`} className="btn btn-outline-secondary btn-sm">

From ced4917a860a00984f097599b848970241c91df8 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 11:52:38 +0200
Subject: [PATCH 12/60] Offer the AMEV simultaneity-factor table in the circuit
 list

The selected GZF cell shows a small table-icon button, and Alt+ArrowDown opens
the same picker from the selected or edited cell; Escape closes it. The
shared GzfPickerModal is reused. The picked mean value is committed through
commitEdit with an explicit target cell, so it is a regular undoable edit on
device rows, compact circuits, reserve circuits and the -frei- row.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |   3 +
 docs/circuit-list-editor-interactions.md      |  12 ++
 src/app/globals.css                           |  32 +++++
 .../components/circuit-tree-editor.tsx        | 110 ++++++++++++++++--
 4 files changed, 145 insertions(+), 12 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index f1a509d..ce438ce 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -164,6 +164,9 @@ Keyboard behavior:
 - Escape cancels
 - Tab / Shift+Tab navigates editable cells
 - Arrow keys navigate cells when not editing
+- Alt+ArrowDown on a GZF cell opens the AMEV table (`GzfPickerModal`); the
+  selected GZF cell also shows a small table-icon button. The picked value is
+  committed like a typed edit.
 
 Support Ctrl+Plus and Ctrl+Shift+Plus for insertion.
 
diff --git a/docs/circuit-list-editor-interactions.md b/docs/circuit-list-editor-interactions.md
index c8c02aa..6c793fc 100644
--- a/docs/circuit-list-editor-interactions.md
+++ b/docs/circuit-list-editor-interactions.md
@@ -44,6 +44,7 @@ Selection, keyboard movement, and editability checks run against this normalized
 - arrow keys: move selected cell in grid when not editing
 - type-to-edit: printable keys open edit mode and replace current display value with typed character
 - `Ctrl+Plus` / `Ctrl+Shift+Plus`: insert below the selected circuit or device context
+- `Alt+ArrowDown` on a GZF cell (selected or editing): open the AMEV simultaneity-factor table
 - `Delete`: delete the selected circuit or device context after confirmation
 
 For insertion, a circuit-level cell creates a reserve circuit directly after the selected circuit. A device-level cell creates a manual device row directly after the selected device. On the virtual `-frei-` row, or without a valid row selection, the shortcut creates a circuit at the end of the active section. Insertions use command history and never renumber existing equipment identifiers.
@@ -52,6 +53,17 @@ For deletion, a circuit-level cell targets the complete circuit and a device-lev
 
 Creating or deleting a device row updates the row and the circuit reserve state in one SQLite transaction.
 
+## AMEV Simultaneity Factor
+
+The selected GZF cell shows a small table-icon button; it and `Alt+ArrowDown` open
+the shared `GzfPickerModal` (AMEV Planungshilfe, Tabelle 3), which the project
+device dialog uses as well. "Übernehmen" commits the mean value of the chosen
+consumer group through the same path as a typed edit (`commitEdit` with an
+explicit target cell), so it is one undoable command and works on device rows,
+compact circuits, reserve circuits and the `-frei-` row. A running inline edit
+of the cell is discarded when the picker opens. The button only appears on the
+selected cell; the grid keeps its static-text cells.
+
 ## Equipment Identifier Validation
 
 Equipment identifiers are compared case-insensitively after trimming whitespace. A conflicting edit is highlighted before submission and cannot be committed. Existing conflicts are highlighted in the grid. Validation errors remain dismissible above the editor instead of replacing the complete workspace.
diff --git a/src/app/globals.css b/src/app/globals.css
index 22da5df..21b1050 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -1230,6 +1230,38 @@ a.kpi:hover {
   outline-offset: -2px;
 }
 
+/* Picker trigger on the selected GZF cell. Positioned over the cell so the
+   column width does not change while the selection moves. */
+.tree-grid td:has(> .cell-picker-trigger) {
+  position: relative;
+}
+
+.tree-grid .cell-picker-trigger {
+  position: absolute;
+  top: 50%;
+  left: 0.2rem;
+  transform: translateY(-50%);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 1.15rem;
+  height: 1.15rem;
+  border: 1px solid var(--accent-blue-strong-border);
+  border-radius: 3px;
+  padding: 0;
+  background: var(--panel-bg);
+  color: var(--color-primary);
+  cursor: pointer;
+}
+
+:root[data-bs-theme="dark"] .tree-grid .cell-picker-trigger {
+  color: var(--color-accent-pale);
+}
+
+.tree-grid .cell-picker-trigger:hover {
+  background: var(--accent-blue-soft-bg);
+}
+
 .tree-grid .section-title {
   display: flex;
   align-items: baseline;
diff --git a/src/frontend/components/circuit-tree-editor.tsx b/src/frontend/components/circuit-tree-editor.tsx
index 03aa38d..1e90d78 100644
--- a/src/frontend/components/circuit-tree-editor.tsx
+++ b/src/frontend/components/circuit-tree-editor.tsx
@@ -135,6 +135,8 @@ import type {
   CircuitSnapshot,
 } from "../../domain/models/circuit-structure-project-command.model";
 import { DistributionBoardComponentModal } from "./distribution-board-component-modal";
+import { GzfPickerModal } from "./gzf-picker-modal";
+import { TableProperties } from "lucide-react";
 import { CircuitGroupModal } from "./circuit-group-modal";
 import { CircuitProtectionModal } from "./circuit-protection-modal";
 import {
@@ -276,6 +278,8 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     useState<StructureComponentEditorIntent | null>(null);
   const [circuitGroupEditorIntent, setCircuitGroupEditorIntent] =
     useState<CircuitGroupEditorIntent | null>(null);
+  // GZF cell the AMEV picker writes to; null while the picker is closed.
+  const [gzfPickerCell, setGzfPickerCell] = useState<SelectedCell | null>(null);
   const [protectionEditorCircuit, setProtectionEditorCircuit] =
     useState<CircuitTreeCircuitDto | null>(null);
   const [projectDevices, setProjectDevices] = useState<ProjectDeviceDto[]>([]);
@@ -1829,22 +1833,26 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
   }
 
   // Commits the active editor input through command history so edits remain undoable.
+  // `target` commits a value for a cell without an open inline editor
+  // (AMEV GZF picker); the regular edit path passes no target.
   async function commitEdit(
     direction: SaveDirection = "stay",
-    draftOverride?: string
+    draftOverride?: string,
+    target?: SelectedCell
   ) {
-    if (!editingCell) {
+    const session = target ?? editingCell;
+    if (!session) {
       return;
     }
-    const row = findRow(editingCell.rowKey);
-    const cell = row?.cells.find((entry) => entry.cellKey === editingCell.cellKey);
+    const row = findRow(session.rowKey);
+    const cell = row?.cells.find((entry) => entry.cellKey === session.cellKey);
     if (!row || !cell || !cell.editable) {
       setEditingCell(null);
       return;
     }
-    const draft = draftOverride ?? editingCell.draft;
+    const draft = draftOverride ?? editingCell?.draft ?? "";
     if (
-      editingCell.cellKey === "equipmentIdentifier" &&
+      session.cellKey === "equipmentIdentifier" &&
       row.circuit &&
       hasEquipmentIdentifierConflict(allCircuits, row.circuit.id, draft)
     ) {
@@ -1852,7 +1860,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       return;
     }
 
-    let targetSelection: SelectedCell = { rowKey: editingCell.rowKey, cellKey: editingCell.cellKey };
+    let targetSelection: SelectedCell = { rowKey: session.rowKey, cellKey: session.cellKey };
     const nextSelectionIntent = () => {
       let selected = targetSelection;
       if (direction !== "stay") {
@@ -1875,7 +1883,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
         redo: async () => {
           const selection = await createFromPlaceholder(
             row.sectionId,
-            editingCell.cellKey,
+            session.cellKey,
             draft
           );
           targetSelection = selection;
@@ -1892,7 +1900,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       const command: HistoryCommand = {
         label: "Stromkreisfeld bearbeiten",
         redo: async () => {
-          await patchCircuit(row.circuit!.id, editingCell.cellKey, next);
+          await patchCircuit(row.circuit!.id, session.cellKey, next);
           return nextSelectionIntent();
         },
       };
@@ -1906,7 +1914,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       const command: HistoryCommand = {
         label: "Gerätefeld bearbeiten",
         redo: async () => {
-          await patchDeviceRow(row.device!.id, editingCell.cellKey, next);
+          await patchDeviceRow(row.device!.id, session.cellKey, next);
           return nextSelectionIntent();
         },
       };
@@ -1921,7 +1929,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
         label: "Gerätezeile im Reservestromkreis erstellen",
         redo: async () => {
           const editValues = createValuesFromEditPatch(
-            buildDeviceRowEditPatch(editingCell.cellKey, next)
+            buildDeviceRowEditPatch(session.cellKey, next)
           );
           const snapshot = createDeviceRowSnapshot(
             row.circuit!.id,
@@ -1941,7 +1949,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
             snapshot,
             "Gerätezeile im Reservestromkreis erstellen"
           );
-          targetSelection = { rowKey: `circuitCompact:${row.circuit!.id}`, cellKey: editingCell.cellKey };
+          targetSelection = { rowKey: `circuitCompact:${row.circuit!.id}`, cellKey: session.cellKey };
           return nextSelectionIntent();
         },
       };
@@ -1950,6 +1958,42 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     }
   }
 
+  function isGzfPickerCell(target: SelectedCell | null): target is SelectedCell {
+    return Boolean(
+      target &&
+        target.cellKey === "simultaneityFactor" &&
+        findCell(target.rowKey, target.cellKey)?.editable
+    );
+  }
+
+  // Opens the AMEV simultaneity-factor table for one GZF cell. A running
+  // inline edit is discarded because the picked value replaces it.
+  function openGzfPicker(target: SelectedCell) {
+    setEditingCell(null);
+    setSelectedCell(target);
+    setGzfPickerCell(target);
+  }
+
+  function closeGzfPicker() {
+    setGzfPickerCell(null);
+    focusGridWithoutScroll();
+  }
+
+  // Commits the picked mean value like a typed edit (undoable command).
+  function handleGzfPicked(value: number) {
+    const target = gzfPickerCell;
+    setGzfPickerCell(null);
+    if (!target) {
+      return;
+    }
+    // parseNumeric accepts only the German decimal comma.
+    const draft = value.toLocaleString("de-DE", {
+      maximumFractionDigits: 2,
+      useGrouping: false,
+    });
+    void commitEdit("stay", draft, target);
+  }
+
   // Cancels current edit session and restores grid keyboard focus.
   function cancelEdit() {
     if (!editingCell) {
@@ -2893,6 +2937,14 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
   // - printable key starts overwrite edit (type-to-edit)
   // - Arrow/Tab move selectedCell when not editing
   function handleContainerKeyDown(event: KeyboardEvent<HTMLDivElement>) {
+    // The picker modal sits outside the grid; keep grid keys from acting behind it.
+    if (gzfPickerCell) {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        closeGzfPicker();
+      }
+      return;
+    }
     if (editingCell) {
       if (event.key === "Tab") {
         event.preventDefault();
@@ -2960,6 +3012,11 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       moveHorizontal(-1);
       return;
     }
+    if (event.altKey && event.key === "ArrowDown" && isGzfPickerCell(selectedCell)) {
+      event.preventDefault();
+      openGzfPicker(selectedCell);
+      return;
+    }
     if (event.key === "ArrowDown") {
       event.preventDefault();
       moveVertical(1);
@@ -3122,6 +3179,9 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
           onSave={handleSaveCircuitGroup}
         />
       ) : null}
+      {gzfPickerCell ? (
+        <GzfPickerModal onClose={closeGzfPicker} onSelect={handleGzfPicked} />
+      ) : null}
       {protectionEditorCircuit ? (
         <CircuitProtectionModal
           equipmentIdentifier={
@@ -4423,6 +4483,13 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                               } else if (event.key === "Tab") {
                                 event.preventDefault();
                                 void commitEdit(event.shiftKey ? "prev" : "next");
+                              } else if (
+                                event.altKey &&
+                                event.key === "ArrowDown" &&
+                                column.key === "simultaneityFactor"
+                              ) {
+                                event.preventDefault();
+                                openGzfPicker({ rowKey: row.rowKey, cellKey: column.key });
                               }
                             }}
                             onBlur={() => {
@@ -4435,6 +4502,25 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                               });
                             }}
                           />
+                        ) : column.key === "simultaneityFactor" &&
+                          cell.editable &&
+                          isSelected ? (
+                          <>
+                            <button
+                              aria-label="Gleichzeitigkeitsfaktor nach AMEV wählen"
+                              className="cell-picker-trigger"
+                              onClick={(event) => {
+                                event.stopPropagation();
+                                openGzfPicker({ rowKey: row.rowKey, cellKey: column.key });
+                              }}
+                              onDoubleClick={(event) => event.stopPropagation()}
+                              title="Gleichzeitigkeitsfaktor nach AMEV wählen (Alt+↓)"
+                              type="button"
+                            >
+                              <TableProperties aria-hidden="true" size={13} />
+                            </button>
+                            {formatCellValue(cell.value, column.key)}
+                          </>
                         ) : (
                           formatCellValue(cell.value, column.key)
                         )}

From 79fcb75ffbde6298922e87810987db540a0b1acd Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 12:01:43 +0200
Subject: [PATCH 13/60] Create client ids without crypto.randomUUID

crypto.randomUUID() is only defined in secure contexts (HTTPS or
localhost). Opened over plain HTTP from another machine in the LAN, the
circuit list editor failed with "crypto.randomUUID is not a function"
whenever it created a circuit, device row, circuit group or distribution
board component, including typing into the -frei- row.

createClientId() uses crypto.randomUUID() where available and otherwise
builds an RFC 4122 version 4 UUID from crypto.getRandomValues(), which
works in every context. AGENTS.md notes the rule.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |  7 +++
 .../components/circuit-tree-editor.tsx        |  9 ++--
 src/frontend/utils/client-id.ts               | 27 +++++++++++
 tests/client-id.test.ts                       | 45 +++++++++++++++++++
 4 files changed, 84 insertions(+), 4 deletions(-)
 create mode 100644 src/frontend/utils/client-id.ts
 create mode 100644 tests/client-id.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index f1a509d..0e252dd 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -177,6 +177,13 @@ The circuit list editor must remain a custom spreadsheet-like component with con
 
 Avoid permanent Bootstrap form controls inside table cells. Table cells should show static text by default and switch to inputs only while editing.
 
+## Browser Runtime
+
+The web UI is also opened over plain HTTP from other machines in the LAN, which
+is not a secure context. Do not call secure-context-only browser APIs such as
+`crypto.randomUUID()` directly; create client-side ids with `createClientId()`
+from `src/frontend/utils/client-id.ts`.
+
 ## Drag-and-Drop Rules
 
 Dragging from the circuit identifier / circuit handle moves the whole circuit.
diff --git a/src/frontend/components/circuit-tree-editor.tsx b/src/frontend/components/circuit-tree-editor.tsx
index 03aa38d..8dc993e 100644
--- a/src/frontend/components/circuit-tree-editor.tsx
+++ b/src/frontend/components/circuit-tree-editor.tsx
@@ -76,6 +76,7 @@ import {
   type MutableDistributionBoardComponentRole,
 } from "../utils/distribution-board-component-editing";
 import { loadCircuitEditorSnapshot } from "../utils/circuit-editor-history";
+import { createClientId } from "../utils/client-id";
 import type {
   CellKey,
   ColumnDef,
@@ -977,7 +978,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     defaultSortOrder: number
   ) {
     return buildCircuitDeviceRowInsertSnapshot({
-      id: crypto.randomUUID(),
+      id: createClientId(),
       circuitId,
       values,
       defaultSortOrder,
@@ -1001,7 +1002,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       ),
       data
     );
-    const circuitId = crypto.randomUUID();
+    const circuitId = createClientId();
     const deviceRows = deviceRowValues.map((row, index) =>
       createDeviceRowSnapshot(circuitId, row, (index + 1) * 10)
     );
@@ -1169,7 +1170,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                         (section) => section.id === intent.sectionId
                       )?.components ?? [];
                 const snapshot = buildDistributionBoardComponentSnapshot({
-                  id: crypto.randomUUID(),
+                  id: createClientId(),
                   circuitListId,
                   role: intent.role,
                   sectionId: intent.sectionId,
@@ -1234,7 +1235,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                 projectId,
                 getExpectedProjectRevision(),
                 buildNewCircuitGroupSnapshot({
-                  id: crypto.randomUUID(),
+                  id: createClientId(),
                   circuitListId,
                   category: values.category,
                   displayName: values.displayName,
diff --git a/src/frontend/utils/client-id.ts b/src/frontend/utils/client-id.ts
new file mode 100644
index 0000000..f3804d5
--- /dev/null
+++ b/src/frontend/utils/client-id.ts
@@ -0,0 +1,27 @@
+/**
+ * Creates a random RFC 4122 version 4 UUID for new entities built in the
+ * browser.
+ *
+ * crypto.randomUUID() exists only in secure contexts (HTTPS or localhost).
+ * The app is also opened over plain HTTP from other machines in the LAN, where
+ * it is undefined, so fall back to crypto.getRandomValues(), which is
+ * available in every context.
+ */
+export function createClientId(
+  source: Pick<Crypto, "getRandomValues"> & Partial<Pick<Crypto, "randomUUID">> = crypto
+): string {
+  if (typeof source.randomUUID === "function") {
+    return source.randomUUID();
+  }
+  const bytes = source.getRandomValues(new Uint8Array(16));
+  bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
+  bytes[8] = (bytes[8] & 0x3f) | 0x80; // RFC 4122 variant
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20),
+  ].join("-");
+}
diff --git a/tests/client-id.test.ts b/tests/client-id.test.ts
new file mode 100644
index 0000000..95baa60
--- /dev/null
+++ b/tests/client-id.test.ts
@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import { webcrypto } from "node:crypto";
+import { describe, it } from "node:test";
+import { z } from "zod";
+import { createClientId } from "../src/frontend/utils/client-id.js";
+
+const uuidV4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+describe("client id", () => {
+  it("uses crypto.randomUUID when the context provides it", () => {
+    const id = createClientId({
+      getRandomValues: () => {
+        throw new Error("fallback must not be used");
+      },
+      randomUUID: () => "11111111-2222-4333-8444-555555555555",
+    });
+    assert.equal(id, "11111111-2222-4333-8444-555555555555");
+  });
+
+  it("falls back to getRandomValues outside a secure context", () => {
+    const insecure = {
+      getRandomValues: webcrypto.getRandomValues.bind(webcrypto),
+    } as Pick<Crypto, "getRandomValues">;
+    const ids = new Set<string>();
+    for (let index = 0; index < 200; index += 1) {
+      const id = createClientId(insecure);
+      assert.match(id, uuidV4);
+      assert.equal(z.string().uuid().safeParse(id).success, true);
+      ids.add(id);
+    }
+    assert.equal(ids.size, 200);
+  });
+
+  it("sets version and variant bits regardless of the random bytes", () => {
+    const allOnes = {
+      getRandomValues: <T extends ArrayBufferView | null>(array: T) => {
+        if (array instanceof Uint8Array) {
+          array.fill(0xff);
+        }
+        return array;
+      },
+    } as Pick<Crypto, "getRandomValues">;
+    assert.equal(createClientId(allOnes), "ffffffff-ffff-4fff-bfff-ffffffffffff");
+  });
+});

From 51cbab1750fa4d1e807fcd741464cc5d393ac203 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 12:20:09 +0200
Subject: [PATCH 14/60] Give cards the surface look of the PM app

Cards had a 3px petrol bar on the top edge, and Bootstrap's shadow-sm
class overrode their own shadow with !important. They now use the PM app
surface: a 1px border all around, a 16px radius and a soft diffuse shadow
with a faint inner highlight, with a stronger shadow and a weaker highlight
in dark mode. The shadow-sm classes are removed from the cards so the
shared rule applies. Menus, drawers and dialogs keep their shadows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |  4 ++++
 src/app/globals.css                           | 22 +++++++++++++++----
 src/app/projects/[projectId]/page.tsx         |  8 +++----
 src/app/projects/page.tsx                     |  6 ++---
 .../components/project-version-history.tsx    |  2 +-
 5 files changed, 30 insertions(+), 12 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index f1a509d..a5641e9 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -171,6 +171,10 @@ Support Ctrl+Plus and Ctrl+Shift+Plus for insertion.
 
 Bootstrap may be used for the general application UI, such as navigation, page layout, buttons, forms, cards, alerts and modals.
 
+Cards follow the PM app look: 1px border all around, 16px radius and the
+soft shadow defined on `.card` in `globals.css` (own dark-mode value). Do
+not add Bootstrap `shadow-*` classes or a colored top border to cards.
+
 Do not use Bootstrap as the core table/grid framework for the circuit list editor.
 
 The circuit list editor must remain a custom spreadsheet-like component with controlled cell selection, inline edit mode, row grouping, drag-and-drop indicators and keyboard behavior.
diff --git a/src/app/globals.css b/src/app/globals.css
index 22da5df..b51d98d 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -431,12 +431,26 @@ a.kpi:hover {
   color: var(--color-accent-pale);
 }
 
+/* Flächen-Look wie in der PM-App (Vorbild grow-monitor): gleichmäßiger
+   1-px-Rahmen statt farbigem Balken an der Oberkante, größerer Radius und ein
+   weicher Streuschatten mit feiner heller Innenkante oben. Der Akzent kommt
+   über Kopfzeile und Inhalt, nicht über die Kante. Karten tragen deshalb keine
+   Bootstrap-Klasse shadow-*, die den Schatten mit !important überschreiben
+   würde. */
 .card {
-  border-radius: var(--radius);
-  border-top: 3px solid var(--color-primary);
+  --bs-card-border-radius: 16px;
+  --bs-card-border-color: var(--color-border);
   box-shadow:
-    0 1px 2px var(--shadow-soft),
-    0 10px 24px -14px var(--shadow-strong);
+    0 4px 24px var(--shadow-soft),
+    0 1px 0 rgba(255, 255, 255, 0.7) inset;
+}
+
+/* Auf dunklem Grund ein kräftigerer Streuschatten und nur eine schwache
+   Innenkante, sonst wirkt sie wie ein harter weißer Strich. */
+:root[data-bs-theme="dark"] .card {
+  box-shadow:
+    0 4px 24px rgba(0, 0, 0, 0.4),
+    0 1px 0 rgba(255, 255, 255, 0.05) inset;
 }
 
 .card-header {
diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index fa342ea..f352536 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -904,7 +904,7 @@ export default function ProjectDetailPage() {
         ) : null}
 
         <section className="col-12" id="verteilungen">
-          <div className="card shadow-sm">
+          <div className="card">
             <div className="card-header d-flex justify-content-between align-items-center">
               <div>
                 <span>Verteilungen</span>
@@ -997,7 +997,7 @@ export default function ProjectDetailPage() {
         </section>
 
         <section className="col-12 col-lg-5" id="etagen">
-          <div className="card shadow-sm h-100">
+          <div className="card h-100">
             <div className="card-header d-flex justify-content-between align-items-center">
               <div>
                 <span>Etagen</span>
@@ -1028,7 +1028,7 @@ export default function ProjectDetailPage() {
         </section>
 
         <section className="col-12 col-lg-7" id="raeume">
-          <div className="card shadow-sm">
+          <div className="card">
             <div className="card-header d-flex justify-content-between align-items-center">
               <div>
                 <span>Räume</span>
@@ -1079,7 +1079,7 @@ export default function ProjectDetailPage() {
         </section>
       </div>
 
-      <section className="card shadow-sm mt-4" id="projektgeraete">
+      <section className="card mt-4" id="projektgeraete">
         <div className="card-header d-flex flex-wrap justify-content-between align-items-center gap-2">
           <div>
             <span>Projektgeräte</span>
diff --git a/src/app/projects/page.tsx b/src/app/projects/page.tsx
index 21409fd..4d8b7bd 100644
--- a/src/app/projects/page.tsx
+++ b/src/app/projects/page.tsx
@@ -238,7 +238,7 @@ export default function ProjectsPage() {
       {error ? <div className="alert alert-warning">{error}</div> : null}
 
       <div className="d-flex flex-column gap-4">
-        <section className="card shadow-sm">
+        <section className="card">
           <div className="card-header">Neues Projekt</div>
           <div className="card-body" style={{ maxWidth: 480 }}>
             <form className="vstack gap-3" onSubmit={handleCreateProject}>
@@ -271,7 +271,7 @@ export default function ProjectsPage() {
           </div>
         </section>
 
-        <section className="card shadow-sm">
+        <section className="card">
           <div className="card-header">Projekt importieren</div>
           <div className="card-body" style={{ maxWidth: 480 }}>
             <p className="text-secondary small">
@@ -326,7 +326,7 @@ export default function ProjectsPage() {
           </div>
         </section>
 
-        <section className="card shadow-sm">
+        <section className="card">
           <div className="card-header">Globale Geräte / Verbraucher</div>
         <div className="card-body border-bottom">
           <form className="row g-2" onSubmit={handleCreateGlobalDevice}>
diff --git a/src/frontend/components/project-version-history.tsx b/src/frontend/components/project-version-history.tsx
index 3907640..2ce4105 100644
--- a/src/frontend/components/project-version-history.tsx
+++ b/src/frontend/components/project-version-history.tsx
@@ -227,7 +227,7 @@ export function ProjectVersionHistory({
     history?.currentRevision === currentRevision;
 
   return (
-    <section className="card shadow-sm">
+    <section className="card">
       <div className="card-header d-flex flex-wrap justify-content-between align-items-center gap-2">
         <span>Versionen und Sicherungspunkte</span>
         <div className="d-flex align-items-center gap-2">

From cd89c4a4996be67191190520e1e52e4ff244481d Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 12:52:34 +0200
Subject: [PATCH 15/60] Add buildings above floors and a building structure
 page
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Projects with several buildings could not be structured: floors and rooms
hung directly off the project. Floors can now belong to a building
(migration 0009: table buildings, nullable floors.building_id). Rooms and
distribution boards keep their floor; their building follows from it.
Existing floors stay without a building.

Buildings use the location-structure command store with
project-building.insert/.update/.delete, inverses and persistent Undo/Redo;
deleting a building with assigned floors is rejected. Floor commands carry
buildingId since command version 2. Version 1 floor commands from existing
history predate buildings and are upgraded with buildingId = null before
they are executed and persisted, so forward and inverse keep one version.

Project snapshot schema 7 stores buildings and floor.buildingId; versions
1-6 are upgraded without buildings. Restore and portable transfer include
buildings, and the transfer remaps building ids.

Buildings, floors and rooms move from the project overview to their own
page /projects/:id/struktur with three columns (Gebäude -> Etagen -> Räume)
that filter each other, and a sidebar entry. Floor selects in the board and
room dialogs are grouped by building. Unchanged dialogs close without a
command. Details in docs/building-structure.md; see issue #6.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |   15 +-
 docs/README.md                                |    2 +
 docs/building-structure.md                    |   79 +
 docs/circuit-list-editor-api.md               |   22 +-
 docs/current-architecture.md                  |   10 +-
 ...history-and-external-model-architecture.md |    4 +
 scripts/db-verify-circuit-schema.js           |   14 +
 src/app/globals.css                           |  141 +
 src/app/projects/[projectId]/page.tsx         |  305 +-
 .../projects/[projectId]/struktur/page.tsx    |  792 +++++
 src/db/migrations/0009_buildings.sql          |    9 +
 src/db/migrations/meta/0009_snapshot.json     | 2626 +++++++++++++++++
 src/db/migrations/meta/_journal.json          |    7 +
 src/db/repositories/building.repository.ts    |   27 +
 ...on-structure-project-command.repository.ts |  171 +-
 ...roject-state-restore-command.repository.ts |    7 +
 .../project-state-snapshot.persistence.ts     |    8 +
 .../project-transfer.repository.ts            |    2 +
 src/db/schema/buildings.ts                    |   11 +
 src/db/schema/floors.ts                       |    6 +
 ...ocation-structure-project-command.model.ts |  349 ++-
 .../models/project-state-snapshot.model.ts    |   93 +-
 src/domain/models/project-transfer.model.ts   |   10 +
 .../services/project-command.service.ts       |   18 +
 src/frontend/components/Sidebar.tsx           |   74 +-
 .../components/floor-select-options.tsx       |   49 +
 src/frontend/components/room-modal.tsx        |   10 +-
 src/frontend/types.ts                         |   19 +
 src/frontend/utils/api.ts                     |   62 +-
 src/frontend/utils/building-structure.ts      |  284 ++
 src/frontend/utils/project-version-history.ts |    3 +
 .../composition/application-repositories.ts   |    2 +
 src/server/controllers/building.controller.ts |  111 +
 src/server/controllers/floor.controller.ts    |   12 +-
 src/server/routes/project.routes.ts           |   10 +
 .../validation/project-structure.schemas.ts   |   12 +
 tests/building-structure-frontend-api.test.ts |  100 +
 tests/building-structure-view.test.ts         |  284 ++
 tests/project-building-structure.test.ts      |  305 ++
 tests/project-command.service.test.ts         |   40 +
 tests/project-snapshot.repository.test.ts     |   27 +
 tests/project-state-snapshot.test.ts          |  124 +-
 42 files changed, 5883 insertions(+), 373 deletions(-)
 create mode 100644 docs/building-structure.md
 create mode 100644 src/app/projects/[projectId]/struktur/page.tsx
 create mode 100644 src/db/migrations/0009_buildings.sql
 create mode 100644 src/db/migrations/meta/0009_snapshot.json
 create mode 100644 src/db/repositories/building.repository.ts
 create mode 100644 src/db/schema/buildings.ts
 create mode 100644 src/frontend/components/floor-select-options.tsx
 create mode 100644 src/frontend/utils/building-structure.ts
 create mode 100644 src/server/controllers/building.controller.ts
 create mode 100644 tests/building-structure-frontend-api.test.ts
 create mode 100644 tests/building-structure-view.test.ts
 create mode 100644 tests/project-building-structure.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index 51b6616..bcd2ca6 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -250,11 +250,14 @@ not change the project revision or undo/redo stacks. Restoring a server-stored
 snapshot verifies its checksum and the current-state hash, replaces supported
 project data atomically and records a new `restore` revision with a complete
 inverse command. Restore can therefore be undone and redone after a restart.
-Current snapshot schema version 6 additionally stores the distribution-board
-info fields `boardNumber`, `location`, `fedFrom` and `remark` and the project
-cover fields `siteAddress`, `workStage`, `projectLead` and `projectEditor`;
-all older supported versions are upgraded with `null` for these fields.
-Stored named and automatic snapshots of every supported version (1 to 6)
+Current snapshot schema version 7 additionally stores the project buildings
+and `floors[].buildingId` (see `docs/building-structure.md`); versions 1 to 6
+are upgraded with no buildings and `buildingId = null`. Version 6 stores the
+distribution-board info fields `boardNumber`, `location`, `fedFrom` and
+`remark` and the project cover fields `siteAddress`, `workStage`,
+`projectLead` and `projectEditor`; all older supported versions are upgraded
+with `null` for these fields.
+Stored named and automatic snapshots of every supported version (1 to 7)
 remain restorable; they are upgraded while parsing. Version 5 stores
 the manual quantity share of every CircuitDeviceRow. Version 4 snapshots are upgraded with
 `manualQuantity = quantity`; they already contain the complete confirmed
@@ -270,7 +273,7 @@ project graph.
 Project-wide Revit CSV configuration uses
 `external-csv-configuration.update`. Its complete expected/target snapshot is
 persisted through the shared project-command transaction, so create, update,
-delete, Undo and Redo are revision-safe. Snapshot schema 5/6, restore and portable
+delete, Undo and Redo are revision-safe. Snapshot schema 5-7, restore and portable
 project duplication preserve the configuration; duplication remaps its internal
 id and project link.
 The project page exposes the Revit CSV modal. It edits the complete
diff --git a/docs/README.md b/docs/README.md
index 395b1ac..cdddb67 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -14,6 +14,8 @@ ausdrücklich getrennt und dürfen nicht als bereits implementiert verstanden we
   Drag-and-drop, Sortierung, Filterung und Undo/Redo
 - [Seitenansicht und PDF-Export](print-view.md) – Deckblatt,
   Verteilerübersicht, Verteilerpläne, Büro-Logo
+- [Gebäudestruktur](building-structure.md) – Gebäude → Etagen → Räume,
+  Befehle, Snapshot-Schema 7, eigene Seite
 - [Editor-API](circuit-list-editor-api.md) – unterstützte Circuit-First-Endpunkte
 - [Bekannte Einschränkungen](circuit-list-editor-known-limitations.md) –
   bewusst noch nicht implementierte oder begrenzte Funktionen
diff --git a/docs/building-structure.md b/docs/building-structure.md
new file mode 100644
index 0000000..1c1a455
--- /dev/null
+++ b/docs/building-structure.md
@@ -0,0 +1,79 @@
+# Gebäudestruktur (Gebäude → Etagen → Räume)
+
+Projekte mit mehreren Gebäuden werden über eine eigene Ebene **Gebäude**
+gegliedert. Etagen können einem Gebäude zugeordnet sein, Räume und Verteilungen
+hängen wie bisher an der Etage. Das Gebäude eines Raums oder einer Verteilung
+ergibt sich also aus der Etage; eine zweite, konkurrierende Zuordnung gibt es
+nicht. Abstimmung mit Julian: Issue #6.
+
+## Datenmodell
+
+| Tabelle | Feld | Bedeutung |
+|---|---|---|
+| `buildings` | `id`, `project_id` (FK, cascade), `name`, `sort_order` | Gebäude eines Projekts |
+| `floors` | `building_id` (nullable FK → `buildings`, `ON DELETE set null`) | optionales übergeordnetes Gebäude |
+
+Migration `0009_buildings`. Bestehende Etagen behalten `building_id = null` und
+erscheinen in der Oberfläche als „Ohne Gebäude“. Es gibt keine Zwangsmigration
+und kein automatisch angelegtes Standardgebäude.
+
+## Befehle, Undo/Redo
+
+Alle Änderungen laufen über die bestehende Orts-Struktur
+(`ProjectLocationStructureProjectCommandRepository`) mit Revision, Inverse und
+persistentem Undo/Redo:
+
+- `project-building.insert` / `project-building.delete` mit vollständigem
+  Gebäude-Snapshot (Schema-Version 1)
+- `project-building.update`: ändert nur den Namen
+- Löschen eines Gebäudes wird abgelehnt, solange Etagen zugeordnet sind
+  („Das Gebäude kann nicht gelöscht werden, solange Etagen zugeordnet sind.“)
+- Etagenbefehle `project-floor.insert/.update/.delete` haben seit
+  Schema-Version **2** das Feld `buildingId`. `project-floor.update` darf Name
+  und/oder Gebäude ändern, nicht aber `sortOrder`. Ein referenziertes Gebäude
+  muss zum Projekt gehören.
+- Version-1-Etagenbefehle aus bestehender Historie bleiben ausführbar. Sie
+  stammen aus der Zeit vor den Gebäuden und werden vor der Ausführung mit
+  `buildingId = null` auf Version 2 gehoben; auch die daraus neu gespeicherten
+  Vorwärts- und Inversbefehle sind Version 2. Das ist bei linearer Historie
+  exakt: Wird ein Gebäude später zugeordnet, liegt dieser neuere Befehl im
+  Undo-Stapel vor dem alten Befehl und wird zuerst zurückgenommen.
+- Raumbefehle bleiben unverändert (Version 1).
+
+## Snapshots und Transfer
+
+Projekt-Snapshot-Schema **7** enthält `buildings` und `floors[].buildingId`.
+Alle älteren unterstützten Versionen (1–6) werden beim Einlesen mit leerer
+Gebäudeliste und `buildingId = null` hochgestuft; gespeicherte Sicherungspunkte
+bleiben wiederherstellbar. Die Relationen werden geprüft (Gebäude gehört zum
+Projekt, `buildingId` verweist auf ein Gebäude des Snapshots). Restore löscht
+und schreibt Gebäude zusammen mit den Etagen; der Projekt-Transfer vergibt neue
+Gebäude-IDs und stellt die Etagenverweise um.
+
+## API
+
+- `GET /api/projects/:projectId/buildings` – Gebäude sortiert nach
+  `sortOrder`, Name
+- `POST /api/projects/:projectId/buildings` – `{ "name": "Haus A", "expectedRevision": 3 }`
+- `PUT /api/projects/:projectId/buildings/:buildingId` – `{ "name": "Haus B", "expectedRevision": 4 }`
+- `DELETE /api/projects/:projectId/buildings/:buildingId` – `{ "expectedRevision": 5 }`
+- `POST/PUT /api/projects/:projectId/floors[/:floorId]` akzeptieren zusätzlich
+  optional `buildingId` (`string | null`). Fehlt das Feld, bleibt beim Bearbeiten
+  das bisherige Gebäude erhalten; ältere Clients funktionieren unverändert.
+
+## Oberfläche
+
+Gebäude, Etagen und Räume werden auf der eigenen Seite
+`/projects/:projectId/struktur` („Gebäudestruktur“) gepflegt, erreichbar über
+die Seitenleiste und die Kennzahlen der Projektübersicht. Drei Spalten
+Gebäude → Etagen → Räume filtern sich gegenseitig: Klick auf ein Gebäude zeigt
+nur dessen Etagen, Klick auf eine Etage nur deren Räume, „Alle“ hebt den Filter
+auf. Hinzufügen, Bearbeiten und Löschen laufen über Icon-Buttons wie in der
+Stromkreisliste.
+
+## Offen
+
+- Revit: Das Gebäude kann später aus einem Revit-Parameter kommen und über die
+  bestehende CSV-Zuordnung gemappt werden (Frage an Julian in Issue #6).
+- Sortierung von Gebäuden per Drag-and-drop ist noch nicht umgesetzt; neue
+  Gebäude werden hinten angehängt.
diff --git a/docs/circuit-list-editor-api.md b/docs/circuit-list-editor-api.md
index d325944..156be62 100644
--- a/docs/circuit-list-editor-api.md
+++ b/docs/circuit-list-editor-api.md
@@ -257,15 +257,27 @@ returns HTTP `409` with `PROJECT_HISTORY_OPERATION_UNAVAILABLE`.
   `distribution-board.delete-subtree`. Persistent Undo/Redo restores or
   removes the same complete subtree, including protection devices.
 
-### Project Floors and Rooms
+### Project Buildings, Floors and Rooms
 
+- `GET /projects/:projectId/buildings`
+- `POST /projects/:projectId/buildings`
+  - body: `{ "name": "Haus A", "expectedRevision": 12 }`
+  - executes `project-building.insert` with a stable building id
+  - response: `{ "building": { ... }, "revision": { ... }, "history": { ... } }`
+- `PUT /projects/:projectId/buildings/:buildingId`
+  - body: `{ "name": "Haus B", "expectedRevision": 13 }` (name only)
+- `DELETE /projects/:projectId/buildings/:buildingId`
+  - body: `{ "expectedRevision": 14 }`
+  - rejects buildings with assigned floors
 - `POST /projects/:projectId/floors`
-  - body: `{ "name": "EG", "expectedRevision": 13 }`
-  - executes `project-floor.insert` with a stable floor id
+  - body: `{ "name": "EG", "buildingId": "building_1", "expectedRevision": 13 }`
+    (`buildingId` optional, `null` = no building)
+  - executes `project-floor.insert` (command version 2) with a stable floor id
   - response: `{ "floor": { ... }, "revision": { ... }, "history": { ... } }`
 - `PUT /projects/:projectId/floors/:floorId`
-  - body: `{ "name": "1. OG", "expectedRevision": 14 }`
-  - executes an exact persistent floor update
+  - body: `{ "name": "1. OG", "buildingId": null, "expectedRevision": 14 }`
+  - executes an exact persistent floor update of name and/or building; a
+    missing `buildingId` keeps the current building
 - `DELETE /projects/:projectId/floors/:floorId`
   - body: `{ "expectedRevision": 15 }`
   - rejects floors with assigned rooms or distribution boards
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index fe55413..191c3f4 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -246,9 +246,11 @@ Werte, Revision und Historienstapel gemeinsam. `PUT /api/projects/:projectId`
 verlangt deshalb `expectedRevision`, liefert Projekt plus aktualisierten
 Historienstand und besitzt keinen separaten direkten Settings-Schreibweg mehr.
 Kommando- und Snapshot-Payloads müssen dem aktuellen Baseline-Schema entsprechen.
-Die Projektseite zeigt Verteilungen, Etagen und Räume als kompakte
-Bestandsübersichten; ihre versionierten Erstellwege öffnen beschriftete Modals
-statt dauerhafter Eingabezeilen. Projektgeräte werden als durchsuchbare,
+Die Projektseite zeigt Verteilungen als kompakte Bestandsübersicht; ihre
+versionierten Erstellwege öffnen beschriftete Modals statt dauerhafter
+Eingabezeilen. Gebäude, Etagen und Räume werden auf der eigenen Seite
+„Gebäudestruktur“ (`/projects/:projectId/struktur`) gepflegt; Etagen können
+einem Gebäude zugeordnet sein (`docs/building-structure.md`). Projektgeräte werden als durchsuchbare,
 fünfspaltige Übersicht dargestellt. Manuelle Anlage, Übernahme aus der globalen
 Bibliothek und vollständige Bearbeitung erfolgen in einem gemeinsamen Modal.
 Die anschließende Vorschau verknüpfter Stromkreiszeilen bleibt davon getrennt,
@@ -422,6 +424,8 @@ Derselbe Befehl versioniert die Felder der Verteiler-Infokarte
 Infokarte liegt im Bearbeiten-Dialog der Verteilung; die Werte sind lokale
 Planungswerte und sollen später über den Revit-Abgleich nur nach Vorschau und
 ausdrücklicher Bestätigung vorbelegt werden. `fedFrom` ist vorerst Freitext.
+Snapshot-Schema 7 enthält zusätzlich die Gebäude und die Gebäudezuordnung
+der Etagen; ältere Versionen werden ohne Gebäude hochgestuft.
 Snapshot-Schema 6 enthält diese Felder und die Deckblattangaben des
 Projekts; ältere Versionen werden mit `null`
 hochgestuft. Snapshot-Schema 5 enthält zusätzlich den manuellen Mengenanteil jeder
diff --git a/docs/project-history-and-external-model-architecture.md b/docs/project-history-and-external-model-architecture.md
index 4c0a8ea..a7c1300 100644
--- a/docs/project-history-and-external-model-architecture.md
+++ b/docs/project-history-and-external-model-architecture.md
@@ -275,6 +275,10 @@ Completed foundation:
 - `project-floor.insert` and `project-room.insert` persist complete location
   records with stable ids; their inverses reject changed or referenced records
   so Undo never clears room assignments or device-row links implicitly
+- `project-building.insert/.update/.delete` persist complete building records;
+  deleting a building with assigned floors is rejected. Floor commands carry
+  `buildingId` since command version 2; version 1 floor commands from older
+  history are upgraded with `buildingId = null` before execution
 - the floor and room POST routes require the current expected revision and the
   project page tracks the returned history state
 
diff --git a/scripts/db-verify-circuit-schema.js b/scripts/db-verify-circuit-schema.js
index 8d27b1d..947767a 100644
--- a/scripts/db-verify-circuit-schema.js
+++ b/scripts/db-verify-circuit-schema.js
@@ -5,6 +5,7 @@ const dbPath = path.resolve("data", "leistungsbilanz.db");
 const db = new Database(dbPath, { readonly: true });
 
 const requiredTables = [
+  "buildings",
   "circuit_sections",
   "circuits",
   "circuit_device_rows",
@@ -100,6 +101,13 @@ const projectColumns = new Set(
 const missingProjectColumns = requiredProjectColumns.filter(
   (name) => !projectColumns.has(name)
 );
+const requiredFloorColumns = ["building_id"];
+const floorColumns = new Set(
+  db.prepare("PRAGMA table_info(floors)").all().map((column) => column.name)
+);
+const missingFloorColumns = requiredFloorColumns.filter(
+  (name) => !floorColumns.has(name)
+);
 const requiredDistributionBoardColumns = [
   "floor_id",
   "supply_type",
@@ -155,6 +163,7 @@ console.log(
   requiredCircuitSectionColumns.join(", ")
 );
 console.log("Required project columns:", requiredProjectColumns.join(", "));
+console.log("Required floor columns:", requiredFloorColumns.join(", "));
 console.log(
   "Required distribution-board columns:",
   requiredDistributionBoardColumns.join(", ")
@@ -171,6 +180,11 @@ if (missing.length > 0) {
   process.exit(1);
 }
 
+if (missingFloorColumns.length > 0) {
+  console.error("Missing floor columns:", missingFloorColumns.join(", "));
+  process.exit(1);
+}
+
 if (missingProjectDeviceColumns.length > 0) {
   console.error("Missing project-device columns:", missingProjectDeviceColumns.join(", "));
   process.exit(1);
diff --git a/src/app/globals.css b/src/app/globals.css
index 22da5df..f392303 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -1461,3 +1461,144 @@ a.kpi:hover {
 .sidebar-collapsed .sidebar-label {
   display: none;
 }
+
+/* ── Gebäudestruktur (Gebäude → Etagen → Räume) ─────────────────────── */
+
+.structure-columns {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  gap: var(--space-md);
+  align-items: start;
+}
+
+@media (min-width: 992px) {
+  .structure-columns {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+}
+
+.structure-column-title {
+  font-size: 1rem;
+  font-weight: 700;
+  margin: 0;
+  display: flex;
+  align-items: center;
+}
+
+.structure-icon-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.25rem 0.4rem;
+  line-height: 1;
+}
+
+.structure-back-link {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.35rem 0.45rem;
+  margin-top: 0.1rem;
+}
+
+.structure-list {
+  max-height: 70vh;
+  overflow-y: auto;
+}
+
+.structure-entry {
+  display: flex;
+  align-items: center;
+  gap: var(--space-sm);
+  padding: 0;
+}
+
+.structure-entry-main {
+  flex: 1 1 auto;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--space-sm);
+  padding: 0.55rem 0.75rem;
+  border: 0;
+  background: transparent;
+  color: inherit;
+  text-align: left;
+  font: inherit;
+}
+
+button.structure-entry-main {
+  cursor: pointer;
+}
+
+button.structure-entry-main:hover {
+  background: var(--surface-hover);
+}
+
+button.structure-entry-main:focus-visible {
+  outline: 2px solid var(--accent-blue);
+  outline-offset: -2px;
+}
+
+.structure-entry.is-selected {
+  background: var(--surface-selected);
+  box-shadow: inset 3px 0 0 var(--color-signal);
+}
+
+.structure-entry.is-selected .structure-entry-label {
+  font-weight: 600;
+}
+
+.structure-entry.is-selected button.structure-entry-main:hover {
+  background: transparent;
+}
+
+.structure-entry-text {
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+}
+
+.structure-entry-label {
+  overflow-wrap: anywhere;
+}
+
+.structure-entry-hint {
+  font-size: 0.78rem;
+  color: var(--color-ink-soft);
+}
+
+.structure-entry-meta {
+  flex: 0 0 auto;
+  font-size: 0.78rem;
+  color: var(--color-ink-soft);
+  white-space: nowrap;
+}
+
+.structure-entry-actions {
+  flex: 0 0 auto;
+  display: inline-flex;
+  gap: 4px;
+  padding-right: 0.75rem;
+}
+
+.structure-room-number {
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+}
+
+.structure-group-label {
+  font-size: 0.66rem;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  font-weight: 600;
+  color: var(--color-accent);
+  background: var(--panel-bg-subtle);
+  padding: 0.35rem 0.75rem;
+}
+
+.structure-empty {
+  color: var(--color-ink-soft);
+  font-size: 0.9rem;
+}
diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index 73f9460..0719078 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -8,17 +8,15 @@ import {
   copyDistributionBoard,
   copyProjectDeviceToGlobal,
   createDistributionBoard,
-  createFloor,
   createProjectDevice,
   createRoom,
-  deleteFloor,
   deleteProjectDevice,
-  deleteRoom,
   deleteDistributionBoard,
   disconnectProjectDeviceRows,
   exportProjectTransfer,
   getProject,
   getProjectDeviceSyncPreview,
+  listBuildings,
   listCircuitLists,
   listDistributionBoards,
   listFloors,
@@ -28,12 +26,11 @@ import {
   importProjectTransfer,
   synchronizeProjectDeviceRows,
   updateDistributionBoard,
-  updateFloor,
   updateProjectDevice,
   updateProjectSettings,
-  updateRoom,
 } from "../../../frontend/utils/api";
 import type {
+  BuildingDto,
   CircuitListDto,
   CreateRoomInput,
   CreateProjectDeviceInput,
@@ -67,7 +64,7 @@ import {
 import { FormModal } from "../../../frontend/components/form-modal";
 import { ProjectDeviceModal } from "../../../frontend/components/project-device-modal";
 import { RevitCsvModal } from "../../../frontend/components/revit-csv-modal";
-import { RoomModal } from "../../../frontend/components/room-modal";
+import { FloorSelectOptions } from "../../../frontend/components/floor-select-options";
 
 const projectDeviceSyncFieldLabels: Record<ProjectDeviceSyncField, string> = {
   name: "Technischer Name",
@@ -89,6 +86,7 @@ export default function ProjectDetailPage() {
   const [project, setProject] = useState<ProjectDto | null>(null);
   const [boards, setBoards] = useState<DistributionBoardDto[]>([]);
   const [circuitLists, setCircuitLists] = useState<CircuitListDto[]>([]);
+  const [buildings, setBuildings] = useState<BuildingDto[]>([]);
   const [floors, setFloors] = useState<FloorDto[]>([]);
   const [rooms, setRooms] = useState<RoomDto[]>([]);
   const [projectDevices, setProjectDevices] = useState<ProjectDeviceDto[]>([]);
@@ -116,14 +114,9 @@ export default function ProjectDetailPage() {
         remark: null,
       })
     );
-  const [floorName, setFloorName] = useState("");
-  const [editingFloor, setEditingFloor] = useState<FloorDto | null>(null);
-  const [editingRoom, setEditingRoom] = useState<RoomDto | null>(null);
   const [isProjectSettingsOpen, setIsProjectSettingsOpen] = useState(false);
   const [isRevitCsvOpen, setIsRevitCsvOpen] = useState(false);
-  const [structureModal, setStructureModal] = useState<
-    "board" | "floor" | "room" | null
-  >(null);
+  const [structureModal, setStructureModal] = useState<"board" | null>(null);
   const [isProjectDeviceModalOpen, setIsProjectDeviceModalOpen] =
     useState(false);
   const [editingProjectDevice, setEditingProjectDevice] =
@@ -147,6 +140,7 @@ export default function ProjectDetailPage() {
       getProject(projectId),
       listDistributionBoards(projectId),
       listCircuitLists(projectId),
+      listBuildings(projectId),
       listFloors(projectId),
       listRooms(projectId),
       listProjectDevices(projectId),
@@ -156,6 +150,7 @@ export default function ProjectDetailPage() {
         currentProject,
         distributionBoards,
         loadedCircuitLists,
+        loadedBuildings,
         loadedFloors,
         loadedRooms,
         loadedProjectDevices,
@@ -164,6 +159,7 @@ export default function ProjectDetailPage() {
         setProject(currentProject);
         setBoards(distributionBoards);
         setCircuitLists(loadedCircuitLists);
+        setBuildings(loadedBuildings);
         setFloors(loadedFloors);
         setRooms(loadedRooms);
         setProjectDevices(loadedProjectDevices);
@@ -176,6 +172,7 @@ export default function ProjectDetailPage() {
   }, [projectId]);
 
   const boardCount = useMemo(() => boards.length, [boards.length]);
+  const buildingCount = useMemo(() => buildings.length, [buildings.length]);
   const floorCount = useMemo(() => floors.length, [floors.length]);
   const roomCount = useMemo(() => rooms.length, [rooms.length]);
   const projectDeviceCount = useMemo(() => projectDevices.length, [projectDevices.length]);
@@ -260,74 +257,6 @@ export default function ProjectDetailPage() {
     }
   }
 
-  async function handleSaveFloor(event: FormEvent<HTMLFormElement>) {
-    event.preventDefault();
-    if (!projectId || !project || !floorName.trim()) {
-      return;
-    }
-    setIsSaving(true);
-    setError(null);
-    try {
-      const result = editingFloor
-        ? await updateFloor(
-            projectId,
-            editingFloor.id,
-            { name: floorName.trim() },
-            project.currentRevision
-          )
-        : await createFloor(
-            projectId,
-            { name: floorName.trim() },
-            project.currentRevision
-          );
-      setFloors((current) =>
-        editingFloor
-          ? current.map((floor) =>
-              floor.id === result.floor.id ? result.floor : floor
-            )
-          : [...current, result.floor]
-      );
-      applyProjectRevision(result.history.currentRevision);
-      setFloorName("");
-      setEditingFloor(null);
-      setStructureModal(null);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : "Etage konnte nicht gespeichert werden.");
-    } finally {
-      setIsSaving(false);
-    }
-  }
-
-  async function handleSaveRoom(input: CreateRoomInput) {
-    if (!projectId || !project) return;
-    setIsSaving(true);
-    setError(null);
-    try {
-      const result = editingRoom
-        ? await updateRoom(
-            projectId,
-            editingRoom.id,
-            input,
-            project.currentRevision
-          )
-        : await createRoom(projectId, input, project.currentRevision);
-      setRooms((current) =>
-        editingRoom
-          ? current.map((room) =>
-              room.id === result.room.id ? result.room : room
-            )
-          : [...current, result.room]
-      );
-      applyProjectRevision(result.history.currentRevision);
-      setEditingRoom(null);
-      setStructureModal(null);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : "Raum konnte nicht gespeichert werden.");
-    } finally {
-      setIsSaving(false);
-    }
-  }
-
   async function handleSaveProjectSettings(input: ProjectSettingsInput) {
     if (!projectId || !project) {
       return;
@@ -515,65 +444,6 @@ export default function ProjectDetailPage() {
     return result;
   }
 
-  function openCreateFloor() {
-    setEditingFloor(null);
-    setFloorName("");
-    setStructureModal("floor");
-  }
-
-  function openEditFloor(floor: FloorDto) {
-    setEditingFloor(floor);
-    setFloorName(floor.name);
-    setStructureModal("floor");
-  }
-
-  function openCreateRoom() {
-    setEditingRoom(null);
-    setStructureModal("room");
-  }
-
-  function openEditRoom(room: RoomDto) {
-    setEditingRoom(room);
-    setStructureModal("room");
-  }
-
-  async function handleDeleteFloor() {
-    if (!projectId || !project || !editingFloor) return;
-    if (!window.confirm(`Etage „${editingFloor.name}“ wirklich löschen?`)) return;
-    setIsSaving(true);
-    setError(null);
-    try {
-      const result = await deleteFloor(projectId, editingFloor.id, project.currentRevision);
-      setFloors((current) => current.filter((floor) => floor.id !== editingFloor.id));
-      applyProjectRevision(result.history.currentRevision);
-      setEditingFloor(null);
-      setFloorName("");
-      setStructureModal(null);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : "Etage konnte nicht gelöscht werden.");
-    } finally {
-      setIsSaving(false);
-    }
-  }
-
-  async function handleDeleteRoom() {
-    if (!projectId || !project || !editingRoom) return;
-    if (!window.confirm(`Raum „${editingRoom.roomNumber} ${editingRoom.roomName}“ wirklich löschen?`)) return;
-    setIsSaving(true);
-    setError(null);
-    try {
-      const result = await deleteRoom(projectId, editingRoom.id, project.currentRevision);
-      setRooms((current) => current.filter((room) => room.id !== editingRoom.id));
-      applyProjectRevision(result.history.currentRevision);
-      setEditingRoom(null);
-      setStructureModal(null);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : "Raum konnte nicht gelöscht werden.");
-    } finally {
-      setIsSaving(false);
-    }
-  }
-
   async function handleCopyBoard() {
     if (
       !projectId ||
@@ -902,14 +772,18 @@ export default function ProjectDetailPage() {
           <div className="kpi-label">Verteilungen</div>
           <div className="kpi-value">{boardCount}</div>
         </a>
-        <a className="kpi" href="#etagen">
+        <Link className="kpi" href={`/projects/${projectId}/struktur`}>
+          <div className="kpi-label">Gebäude</div>
+          <div className="kpi-value">{buildingCount}</div>
+        </Link>
+        <Link className="kpi" href={`/projects/${projectId}/struktur`}>
           <div className="kpi-label">Etagen</div>
           <div className="kpi-value">{floorCount}</div>
-        </a>
-        <a className="kpi" href="#raeume">
+        </Link>
+        <Link className="kpi" href={`/projects/${projectId}/struktur`}>
           <div className="kpi-label">Räume</div>
           <div className="kpi-value">{roomCount}</div>
-        </a>
+        </Link>
         <a className="kpi" href="#projektgeraete">
           <div className="kpi-label">Projektgeräte</div>
           <div className="kpi-value">{projectDeviceCount}</div>
@@ -1025,88 +899,6 @@ export default function ProjectDetailPage() {
             </div>
           </div>
         </section>
-
-        <section className="col-12 col-lg-5" id="etagen">
-          <div className="card shadow-sm h-100">
-            <div className="card-header d-flex justify-content-between align-items-center">
-              <div>
-                <span>Etagen</span>
-                <span className="badge text-bg-secondary ms-2">{floorCount}</span>
-              </div>
-              <button
-                className="btn btn-sm btn-outline-primary"
-                onClick={openCreateFloor}
-                type="button"
-              >
-                Hinzufügen
-              </button>
-            </div>
-            <ul className="list-group list-group-flush">
-              {floors.map((floor) => (
-                <li className="list-group-item d-flex justify-content-between align-items-center gap-2" key={floor.id}>
-                  <span>{floor.name}</span>
-                  <button className="btn btn-sm btn-outline-secondary" onClick={() => openEditFloor(floor)} type="button">
-                    Bearbeiten
-                  </button>
-                </li>
-              ))}
-              {!floors.length ? (
-                <li className="list-group-item text-secondary">Noch keine Etagen vorhanden.</li>
-              ) : null}
-            </ul>
-          </div>
-        </section>
-
-        <section className="col-12 col-lg-7" id="raeume">
-          <div className="card shadow-sm">
-            <div className="card-header d-flex justify-content-between align-items-center">
-              <div>
-                <span>Räume</span>
-                <span className="badge text-bg-secondary ms-2">{roomCount}</span>
-              </div>
-              <button
-                className="btn btn-sm btn-outline-primary"
-                onClick={openCreateRoom}
-                type="button"
-              >
-                Hinzufügen
-              </button>
-            </div>
-            <div className="table-responsive">
-              <table className="table table-hover align-middle mb-0">
-                <thead>
-                  <tr>
-                    <th>Raumnummer</th>
-                    <th>Raumname</th>
-                    <th>Etage</th>
-                    <th className="text-end">Aktionen</th>
-                  </tr>
-                </thead>
-                <tbody>
-                  {rooms.map((room) => (
-                    <tr key={room.id}>
-                      <td>{room.roomNumber}</td>
-                      <td>{room.roomName}</td>
-                      <td>{room.floorId ? floorById.get(room.floorId)?.name ?? "-" : "-"}</td>
-                      <td className="text-end">
-                        <button className="btn btn-sm btn-outline-secondary" onClick={() => openEditRoom(room)} type="button">
-                          Bearbeiten
-                        </button>
-                      </td>
-                    </tr>
-                  ))}
-                  {!rooms.length ? (
-                    <tr>
-                      <td colSpan={4} className="text-center text-secondary py-4">
-                        Noch keine Räume vorhanden.
-                      </td>
-                    </tr>
-                  ) : null}
-                </tbody>
-              </table>
-            </div>
-          </div>
-        </section>
       </div>
 
       <section className="card shadow-sm mt-4" id="projektgeraete">
@@ -1366,11 +1158,7 @@ export default function ProjectDetailPage() {
                 value={boardFloorId}
               >
                 <option value="">Ohne Etage</option>
-                {floors.map((floor) => (
-                  <option key={floor.id} value={floor.id}>
-                    {floor.name}
-                  </option>
-                ))}
+                <FloorSelectOptions buildings={buildings} floors={floors} />
               </select>
             </div>
             <div className="col-12 col-md-6">
@@ -1436,11 +1224,7 @@ export default function ProjectDetailPage() {
                 value={editingBoardFloorId}
               >
                 <option value="">Ohne Etage</option>
-                {floors.map((floor) => (
-                  <option key={floor.id} value={floor.id}>
-                    {floor.name}
-                  </option>
-                ))}
+                <FloorSelectOptions buildings={buildings} floors={floors} />
               </select>
             </div>
             <div className="col-12 col-md-6">
@@ -1572,57 +1356,6 @@ export default function ProjectDetailPage() {
         </FormModal>
       ) : null}
 
-      {structureModal === "floor" ? (
-        <FormModal
-          isSaving={isSaving}
-          onClose={() => {
-            setStructureModal(null);
-            setEditingFloor(null);
-          }}
-          onSubmit={handleSaveFloor}
-          submitDisabled={!floorName.trim()}
-          submitLabel={editingFloor ? "Änderungen speichern" : "Etage hinzufügen"}
-          title={editingFloor ? "Etage bearbeiten" : "Etage hinzufügen"}
-        >
-          <label className="form-label" htmlFor="floor-name">
-            Bezeichnung
-          </label>
-          <input
-            autoFocus
-            className="form-control"
-            id="floor-name"
-            onChange={(event) => setFloorName(event.target.value)}
-            placeholder="z. B. EG"
-            required
-            value={floorName}
-          />
-          {editingFloor ? (
-            <div className="border-top mt-4 pt-3">
-              <p className="text-secondary small mb-2">
-                Etagen mit zugeordneten Räumen oder Verteilungen können nicht gelöscht werden.
-              </p>
-              <button className="btn btn-outline-danger" disabled={isSaving} onClick={() => void handleDeleteFloor()} type="button">
-                Etage löschen
-              </button>
-            </div>
-          ) : null}
-        </FormModal>
-      ) : null}
-
-      {structureModal === "room" ? (
-        <RoomModal
-          floors={floors}
-          initialRoom={editingRoom ?? undefined}
-          isSaving={isSaving}
-          onClose={() => {
-            setStructureModal(null);
-            setEditingRoom(null);
-          }}
-          onDelete={editingRoom ? () => void handleDeleteRoom() : undefined}
-          onSave={handleSaveRoom}
-        />
-      ) : null}
-
       {isProjectDeviceModalOpen ? (
         <ProjectDeviceModal
           globalDevices={globalDevices}
diff --git a/src/app/projects/[projectId]/struktur/page.tsx b/src/app/projects/[projectId]/struktur/page.tsx
new file mode 100644
index 0000000..5b207c8
--- /dev/null
+++ b/src/app/projects/[projectId]/struktur/page.tsx
@@ -0,0 +1,792 @@
+"use client";
+
+import Link from "next/link";
+import { useParams } from "next/navigation";
+import {
+  type FormEvent,
+  type ReactNode,
+  useCallback,
+  useEffect,
+  useMemo,
+  useState,
+} from "react";
+import { ArrowLeft, Pencil, Plus, Trash2 } from "lucide-react";
+import {
+  createBuilding,
+  createFloor,
+  createRoom,
+  deleteBuilding,
+  deleteFloor,
+  deleteRoom,
+  getProject,
+  listBuildings,
+  listFloors,
+  listRooms,
+  updateBuilding,
+  updateFloor,
+  updateRoom,
+} from "../../../../frontend/utils/api";
+import type {
+  BuildingDto,
+  CreateRoomInput,
+  FloorDto,
+  ProjectCommandResultDto,
+  ProjectDto,
+  RoomDto,
+} from "../../../../frontend/types";
+import {
+  ALL_SELECTION,
+  UNASSIGNED_BUILDING_LABEL,
+  UNASSIGNED_FLOOR_LABEL,
+  UNASSIGNED_SELECTION,
+  countFloorsByBuilding,
+  countRoomsByFloor,
+  defaultBuildingIdForNewFloor,
+  defaultFloorIdForNewRoom,
+  describeRoomLocation,
+  filterFloorsByBuilding,
+  filterRooms,
+  groupFloorsByBuilding,
+  hasFloorsWithoutBuilding,
+  normalizeBuildingSelection,
+  normalizeFloorSelection,
+  showsRoomsWithoutFloorEntry,
+  type StructureSelection,
+} from "../../../../frontend/utils/building-structure";
+import { FormModal } from "../../../../frontend/components/form-modal";
+import { RoomModal } from "../../../../frontend/components/room-modal";
+
+const BUILDING_HAS_FLOORS_MESSAGE =
+  "Das Gebäude kann nicht gelöscht werden, solange Etagen zugeordnet sind.";
+
+type StructureDialog =
+  | { kind: "building"; building: BuildingDto | null }
+  | { kind: "floor"; floor: FloorDto | null }
+  | { kind: "room"; room: RoomDto | null; defaultFloorId: string };
+
+function formatCount(count: number, singular: string, plural: string) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+
+function compareRooms(left: RoomDto, right: RoomDto) {
+  return (
+    left.roomNumber.localeCompare(right.roomNumber, "de", { numeric: true }) ||
+    left.roomName.localeCompare(right.roomName, "de")
+  );
+}
+
+interface StructureColumnProps {
+  addLabel: string;
+  children: ReactNode;
+  count: number;
+  headingId: string;
+  isAddDisabled: boolean;
+  onAdd: () => void;
+  title: string;
+}
+
+function StructureColumn({
+  addLabel,
+  children,
+  count,
+  headingId,
+  isAddDisabled,
+  onAdd,
+  title,
+}: StructureColumnProps) {
+  return (
+    <section aria-labelledby={headingId} className="card shadow-sm structure-column">
+      <div className="card-header d-flex justify-content-between align-items-center gap-2">
+        <h2 className="structure-column-title" id={headingId}>
+          {title}
+          <span className="badge text-bg-secondary ms-2">{count}</span>
+        </h2>
+        <button
+          aria-label={addLabel}
+          className="btn btn-sm btn-outline-primary structure-icon-button"
+          disabled={isAddDisabled}
+          onClick={onAdd}
+          title={addLabel}
+          type="button"
+        >
+          <Plus aria-hidden="true" size={16} />
+        </button>
+      </div>
+      <ul className="list-group list-group-flush structure-list">{children}</ul>
+    </section>
+  );
+}
+
+interface StructureEntryProps {
+  actions?: ReactNode;
+  hint?: string;
+  isSelected?: boolean;
+  label: ReactNode;
+  meta?: string;
+  onSelect?: () => void;
+}
+
+function StructureEntry({
+  actions,
+  hint,
+  isSelected = false,
+  label,
+  meta,
+  onSelect,
+}: StructureEntryProps) {
+  const content = (
+    <>
+      <span className="structure-entry-text">
+        <span className="structure-entry-label">{label}</span>
+        {hint ? <span className="structure-entry-hint">{hint}</span> : null}
+      </span>
+      {meta ? <span className="structure-entry-meta">{meta}</span> : null}
+    </>
+  );
+  return (
+    <li
+      className={
+        isSelected
+          ? "list-group-item structure-entry is-selected"
+          : "list-group-item structure-entry"
+      }
+    >
+      {onSelect ? (
+        <button
+          aria-pressed={isSelected}
+          className="structure-entry-main"
+          onClick={onSelect}
+          type="button"
+        >
+          {content}
+        </button>
+      ) : (
+        <div className="structure-entry-main">{content}</div>
+      )}
+      {actions ? <div className="structure-entry-actions">{actions}</div> : null}
+    </li>
+  );
+}
+
+interface EntryActionsProps {
+  deleteLabel: string;
+  editLabel: string;
+  isDisabled: boolean;
+  onDelete: () => void;
+  onEdit: () => void;
+}
+
+function EntryActions({
+  deleteLabel,
+  editLabel,
+  isDisabled,
+  onDelete,
+  onEdit,
+}: EntryActionsProps) {
+  return (
+    <>
+      <button
+        aria-label={editLabel}
+        className="btn btn-sm btn-outline-secondary structure-icon-button"
+        disabled={isDisabled}
+        onClick={onEdit}
+        title={editLabel}
+        type="button"
+      >
+        <Pencil aria-hidden="true" size={14} />
+      </button>
+      <button
+        aria-label={deleteLabel}
+        className="btn btn-sm btn-outline-danger structure-icon-button"
+        disabled={isDisabled}
+        onClick={onDelete}
+        title={deleteLabel}
+        type="button"
+      >
+        <Trash2 aria-hidden="true" size={14} />
+      </button>
+    </>
+  );
+}
+
+export default function BuildingStructurePage() {
+  const params = useParams<{ projectId: string }>();
+  const projectId = params.projectId;
+  const [project, setProject] = useState<ProjectDto | null>(null);
+  const [buildings, setBuildings] = useState<BuildingDto[]>([]);
+  const [floors, setFloors] = useState<FloorDto[]>([]);
+  const [rooms, setRooms] = useState<RoomDto[]>([]);
+  const [buildingSelection, setBuildingSelection] =
+    useState<StructureSelection>(ALL_SELECTION);
+  const [floorSelection, setFloorSelection] =
+    useState<StructureSelection>(ALL_SELECTION);
+  const [dialog, setDialog] = useState<StructureDialog | null>(null);
+  const [dialogName, setDialogName] = useState("");
+  const [dialogBuildingId, setDialogBuildingId] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [isSaving, setIsSaving] = useState(false);
+
+  const reloadStructure = useCallback(async () => {
+    const [currentProject, loadedBuildings, loadedFloors, loadedRooms] =
+      await Promise.all([
+        getProject(projectId),
+        listBuildings(projectId),
+        listFloors(projectId),
+        listRooms(projectId),
+      ]);
+    setProject(currentProject);
+    setBuildings(loadedBuildings);
+    setFloors(loadedFloors);
+    setRooms(loadedRooms);
+  }, [projectId]);
+
+  useEffect(() => {
+    if (!projectId) {
+      return;
+    }
+    setIsLoading(true);
+    reloadStructure()
+      .then(() => setError(null))
+      .catch((err: unknown) =>
+        setError(
+          err instanceof Error
+            ? err.message
+            : "Gebäudestruktur konnte nicht geladen werden."
+        )
+      )
+      .finally(() => setIsLoading(false));
+  }, [projectId, reloadStructure]);
+
+  const effectiveBuildingSelection = normalizeBuildingSelection(
+    buildingSelection,
+    floors,
+    buildings
+  );
+  const effectiveFloorSelection = normalizeFloorSelection(
+    floorSelection,
+    rooms,
+    floors,
+    buildings,
+    effectiveBuildingSelection
+  );
+
+  const visibleFloors = useMemo(
+    () => filterFloorsByBuilding(floors, buildings, effectiveBuildingSelection),
+    [buildings, effectiveBuildingSelection, floors]
+  );
+  const visibleFloorGroups = useMemo(
+    () =>
+      effectiveBuildingSelection === ALL_SELECTION && buildings.length
+        ? groupFloorsByBuilding(visibleFloors, buildings)
+        : [{ buildingId: null, label: "", floors: visibleFloors }],
+    [buildings, effectiveBuildingSelection, visibleFloors]
+  );
+  const visibleRooms = useMemo(
+    () =>
+      filterRooms(
+        rooms,
+        floors,
+        buildings,
+        effectiveBuildingSelection,
+        effectiveFloorSelection
+      ).sort(compareRooms),
+    [buildings, effectiveBuildingSelection, effectiveFloorSelection, floors, rooms]
+  );
+  const roomsInBuildingSelection = useMemo(
+    () =>
+      filterRooms(rooms, floors, buildings, effectiveBuildingSelection, ALL_SELECTION)
+        .length,
+    [buildings, effectiveBuildingSelection, floors, rooms]
+  );
+  const floorCountByBuilding = useMemo(
+    () => countFloorsByBuilding(floors, buildings),
+    [buildings, floors]
+  );
+  const roomCountByFloor = useMemo(
+    () => countRoomsByFloor(rooms, floors),
+    [floors, rooms]
+  );
+  const showUnassignedBuilding = hasFloorsWithoutBuilding(floors, buildings);
+  const showUnassignedFloor = showsRoomsWithoutFloorEntry(
+    rooms,
+    floors,
+    effectiveBuildingSelection
+  );
+  const isBusy = isSaving || !project;
+
+  function selectBuilding(selection: StructureSelection) {
+    setBuildingSelection(selection);
+    setFloorSelection(ALL_SELECTION);
+  }
+
+  async function runCommand<TResult extends ProjectCommandResultDto>(
+    execute: (expectedRevision: number) => Promise<TResult>,
+    fallbackMessage: string
+  ): Promise<boolean> {
+    if (!project) {
+      return false;
+    }
+    setIsSaving(true);
+    setError(null);
+    try {
+      const result = await execute(project.currentRevision);
+      setProject((current) =>
+        current
+          ? { ...current, currentRevision: result.history.currentRevision }
+          : current
+      );
+      await reloadStructure();
+      return true;
+    } catch (err) {
+      setError(err instanceof Error ? err.message : fallbackMessage);
+      // Refresh the revision and lists so a stale state does not block the
+      // next attempt; the command error stays visible.
+      await reloadStructure().catch(() => undefined);
+      return false;
+    } finally {
+      setIsSaving(false);
+    }
+  }
+
+  function openBuildingDialog(building: BuildingDto | null) {
+    setDialogName(building?.name ?? "");
+    setDialog({ kind: "building", building });
+  }
+
+  function openFloorDialog(floor: FloorDto | null) {
+    setDialogName(floor?.name ?? "");
+    setDialogBuildingId(
+      floor
+        ? floor.buildingId ?? ""
+        : defaultBuildingIdForNewFloor(effectiveBuildingSelection)
+    );
+    setDialog({ kind: "floor", floor });
+  }
+
+  function openRoomDialog(room: RoomDto | null) {
+    setDialog({
+      kind: "room",
+      room,
+      defaultFloorId: defaultFloorIdForNewRoom(effectiveFloorSelection),
+    });
+  }
+
+  async function handleSaveBuilding(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    if (dialog?.kind !== "building" || !dialogName.trim()) {
+      return;
+    }
+    const editingBuilding = dialog.building;
+    const name = dialogName.trim();
+    // An unchanged dialog is not a command; the backend rejects no-op updates.
+    if (editingBuilding && editingBuilding.name === name) {
+      setDialog(null);
+      return;
+    }
+    const saved = await runCommand(
+      (expectedRevision) =>
+        editingBuilding
+          ? updateBuilding(projectId, editingBuilding.id, { name }, expectedRevision)
+          : createBuilding(projectId, { name }, expectedRevision),
+      "Gebäude konnte nicht gespeichert werden."
+    );
+    if (saved) {
+      setDialog(null);
+    }
+  }
+
+  async function handleSaveFloor(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    if (dialog?.kind !== "floor" || !dialogName.trim()) {
+      return;
+    }
+    const editingFloor = dialog.floor;
+    const input = {
+      name: dialogName.trim(),
+      buildingId: dialogBuildingId || null,
+    };
+    if (
+      editingFloor &&
+      editingFloor.name === input.name &&
+      editingFloor.buildingId === input.buildingId
+    ) {
+      setDialog(null);
+      return;
+    }
+    const saved = await runCommand(
+      (expectedRevision) =>
+        editingFloor
+          ? updateFloor(projectId, editingFloor.id, input, expectedRevision)
+          : createFloor(projectId, input, expectedRevision),
+      "Etage konnte nicht gespeichert werden."
+    );
+    if (saved) {
+      setDialog(null);
+    }
+  }
+
+  async function handleSaveRoom(input: CreateRoomInput) {
+    if (dialog?.kind !== "room") {
+      return;
+    }
+    const editingRoom = dialog.room;
+    if (
+      editingRoom &&
+      editingRoom.roomNumber === input.roomNumber.trim() &&
+      editingRoom.roomName === input.roomName.trim() &&
+      editingRoom.floorId === (input.floorId || null)
+    ) {
+      setDialog(null);
+      return;
+    }
+    const saved = await runCommand(
+      (expectedRevision) =>
+        editingRoom
+          ? updateRoom(projectId, editingRoom.id, input, expectedRevision)
+          : createRoom(projectId, input, expectedRevision),
+      "Raum konnte nicht gespeichert werden."
+    );
+    if (saved) {
+      setDialog(null);
+    }
+  }
+
+  async function handleDeleteBuilding(building: BuildingDto) {
+    if ((floorCountByBuilding.get(building.id) ?? 0) > 0) {
+      setError(BUILDING_HAS_FLOORS_MESSAGE);
+      return;
+    }
+    if (!window.confirm(`Gebäude „${building.name}“ wirklich löschen?`)) {
+      return;
+    }
+    await runCommand(
+      (expectedRevision) =>
+        deleteBuilding(projectId, building.id, expectedRevision),
+      "Gebäude konnte nicht gelöscht werden."
+    );
+  }
+
+  async function handleDeleteFloor(floor: FloorDto) {
+    if (!window.confirm(`Etage „${floor.name}“ wirklich löschen?`)) {
+      return;
+    }
+    await runCommand(
+      (expectedRevision) => deleteFloor(projectId, floor.id, expectedRevision),
+      "Etage konnte nicht gelöscht werden."
+    );
+  }
+
+  async function handleDeleteRoom(room: RoomDto) {
+    if (
+      !window.confirm(
+        `Raum „${room.roomNumber} ${room.roomName}“ wirklich löschen?`
+      )
+    ) {
+      return;
+    }
+    await runCommand(
+      (expectedRevision) => deleteRoom(projectId, room.id, expectedRevision),
+      "Raum konnte nicht gelöscht werden."
+    );
+  }
+
+  return (
+    <main className="container py-4">
+      <div className="page-header">
+        <div className="d-flex align-items-start gap-3">
+          <Link
+            aria-label="Zurück zur Projektübersicht"
+            className="btn btn-outline-secondary btn-sm structure-back-link"
+            href={`/projects/${projectId}`}
+            title="Zurück zur Projektübersicht"
+          >
+            <ArrowLeft aria-hidden="true" size={18} />
+          </Link>
+          <div>
+            <div className="kicker">{project?.name ?? "Projekt"}</div>
+            <h1>Gebäudestruktur</h1>
+            <p className="text-secondary mb-0">
+              Gebäude, Etagen und Räume des Projekts gliedern und pflegen.
+            </p>
+          </div>
+        </div>
+      </div>
+
+      {error ? (
+        <div className="alert alert-warning" role="alert">
+          {error}
+        </div>
+      ) : null}
+      {isLoading ? (
+        <p className="text-secondary" role="status">
+          Gebäudestruktur wird geladen …
+        </p>
+      ) : null}
+
+      <div className="structure-columns">
+        <StructureColumn
+          addLabel="Gebäude hinzufügen"
+          count={buildings.length}
+          headingId="structure-buildings-heading"
+          isAddDisabled={isBusy}
+          onAdd={() => openBuildingDialog(null)}
+          title="Gebäude"
+        >
+          <StructureEntry
+            isSelected={effectiveBuildingSelection === ALL_SELECTION}
+            label="Alle"
+            meta={formatCount(floors.length, "Etage", "Etagen")}
+            onSelect={() => selectBuilding(ALL_SELECTION)}
+          />
+          {buildings.map((building) => (
+            <StructureEntry
+              actions={
+                <EntryActions
+                  deleteLabel={`Gebäude „${building.name}“ löschen`}
+                  editLabel={`Gebäude „${building.name}“ bearbeiten`}
+                  isDisabled={isBusy}
+                  onDelete={() => void handleDeleteBuilding(building)}
+                  onEdit={() => openBuildingDialog(building)}
+                />
+              }
+              isSelected={effectiveBuildingSelection === building.id}
+              key={building.id}
+              label={building.name}
+              meta={formatCount(
+                floorCountByBuilding.get(building.id) ?? 0,
+                "Etage",
+                "Etagen"
+              )}
+              onSelect={() => selectBuilding(building.id)}
+            />
+          ))}
+          {showUnassignedBuilding ? (
+            <StructureEntry
+              isSelected={effectiveBuildingSelection === UNASSIGNED_SELECTION}
+              label={<em>{UNASSIGNED_BUILDING_LABEL}</em>}
+              meta={formatCount(
+                floorCountByBuilding.get(null) ?? 0,
+                "Etage",
+                "Etagen"
+              )}
+              onSelect={() => selectBuilding(UNASSIGNED_SELECTION)}
+            />
+          ) : null}
+          {!buildings.length && !isLoading ? (
+            <li className="list-group-item structure-empty">
+              Noch keine Gebäude vorhanden.
+            </li>
+          ) : null}
+        </StructureColumn>
+
+        <StructureColumn
+          addLabel="Etage hinzufügen"
+          count={visibleFloors.length}
+          headingId="structure-floors-heading"
+          isAddDisabled={isBusy}
+          onAdd={() => openFloorDialog(null)}
+          title="Etagen"
+        >
+          <StructureEntry
+            isSelected={effectiveFloorSelection === ALL_SELECTION}
+            label="Alle"
+            meta={formatCount(roomsInBuildingSelection, "Raum", "Räume")}
+            onSelect={() => setFloorSelection(ALL_SELECTION)}
+          />
+          {visibleFloorGroups.map((group) => (
+            <FloorGroupEntries
+              key={group.buildingId ?? "unassigned"}
+              label={group.label}
+            >
+              {group.floors.map((floor) => (
+                <StructureEntry
+                  actions={
+                    <EntryActions
+                      deleteLabel={`Etage „${floor.name}“ löschen`}
+                      editLabel={`Etage „${floor.name}“ bearbeiten`}
+                      isDisabled={isBusy}
+                      onDelete={() => void handleDeleteFloor(floor)}
+                      onEdit={() => openFloorDialog(floor)}
+                    />
+                  }
+                  isSelected={effectiveFloorSelection === floor.id}
+                  key={floor.id}
+                  label={floor.name}
+                  meta={formatCount(
+                    roomCountByFloor.get(floor.id) ?? 0,
+                    "Raum",
+                    "Räume"
+                  )}
+                  onSelect={() => setFloorSelection(floor.id)}
+                />
+              ))}
+            </FloorGroupEntries>
+          ))}
+          {showUnassignedFloor ? (
+            <StructureEntry
+              isSelected={effectiveFloorSelection === UNASSIGNED_SELECTION}
+              label={<em>{UNASSIGNED_FLOOR_LABEL}</em>}
+              meta={formatCount(roomCountByFloor.get(null) ?? 0, "Raum", "Räume")}
+              onSelect={() => setFloorSelection(UNASSIGNED_SELECTION)}
+            />
+          ) : null}
+          {!visibleFloors.length && !isLoading ? (
+            <li className="list-group-item structure-empty">
+              {floors.length
+                ? "Keine Etagen in dieser Auswahl."
+                : "Noch keine Etagen vorhanden."}
+            </li>
+          ) : null}
+        </StructureColumn>
+
+        <StructureColumn
+          addLabel="Raum hinzufügen"
+          count={visibleRooms.length}
+          headingId="structure-rooms-heading"
+          isAddDisabled={isBusy}
+          onAdd={() => openRoomDialog(null)}
+          title="Räume"
+        >
+          {visibleRooms.map((room) => (
+            <StructureEntry
+              actions={
+                <EntryActions
+                  deleteLabel={`Raum „${room.roomNumber} ${room.roomName}“ löschen`}
+                  editLabel={`Raum „${room.roomNumber} ${room.roomName}“ bearbeiten`}
+                  isDisabled={isBusy}
+                  onDelete={() => void handleDeleteRoom(room)}
+                  onEdit={() => openRoomDialog(room)}
+                />
+              }
+              hint={
+                effectiveFloorSelection === ALL_SELECTION
+                  ? describeRoomLocation(room, floors, buildings)
+                  : undefined
+              }
+              key={room.id}
+              label={
+                <>
+                  <span className="structure-room-number">{room.roomNumber}</span>{" "}
+                  {room.roomName}
+                </>
+              }
+            />
+          ))}
+          {!visibleRooms.length && !isLoading ? (
+            <li className="list-group-item structure-empty">
+              {rooms.length
+                ? "Keine Räume in dieser Auswahl."
+                : "Noch keine Räume vorhanden."}
+            </li>
+          ) : null}
+        </StructureColumn>
+      </div>
+
+      {dialog?.kind === "building" ? (
+        <FormModal
+          isSaving={isSaving}
+          onClose={() => setDialog(null)}
+          onSubmit={handleSaveBuilding}
+          submitDisabled={!dialogName.trim()}
+          submitLabel={dialog.building ? "Änderungen speichern" : "Gebäude hinzufügen"}
+          title={dialog.building ? "Gebäude bearbeiten" : "Gebäude hinzufügen"}
+        >
+          <label className="form-label" htmlFor="building-name">
+            Bezeichnung
+          </label>
+          <input
+            autoFocus
+            className="form-control"
+            id="building-name"
+            maxLength={200}
+            onChange={(event) => setDialogName(event.target.value)}
+            placeholder="z. B. Haus A"
+            required
+            value={dialogName}
+          />
+        </FormModal>
+      ) : null}
+
+      {dialog?.kind === "floor" ? (
+        <FormModal
+          isSaving={isSaving}
+          onClose={() => setDialog(null)}
+          onSubmit={handleSaveFloor}
+          submitDisabled={!dialogName.trim()}
+          submitLabel={dialog.floor ? "Änderungen speichern" : "Etage hinzufügen"}
+          title={dialog.floor ? "Etage bearbeiten" : "Etage hinzufügen"}
+        >
+          <div className="row g-3">
+            <div className="col-12 col-md-6">
+              <label className="form-label" htmlFor="floor-name">
+                Bezeichnung
+              </label>
+              <input
+                autoFocus
+                className="form-control"
+                id="floor-name"
+                maxLength={200}
+                onChange={(event) => setDialogName(event.target.value)}
+                placeholder="z. B. EG"
+                required
+                value={dialogName}
+              />
+            </div>
+            <div className="col-12 col-md-6">
+              <label className="form-label" htmlFor="floor-building">
+                Gebäude
+              </label>
+              <select
+                className="form-select"
+                id="floor-building"
+                onChange={(event) => setDialogBuildingId(event.target.value)}
+                value={dialogBuildingId}
+              >
+                <option value="">{UNASSIGNED_BUILDING_LABEL}</option>
+                {buildings.map((building) => (
+                  <option key={building.id} value={building.id}>
+                    {building.name}
+                  </option>
+                ))}
+              </select>
+            </div>
+          </div>
+        </FormModal>
+      ) : null}
+
+      {dialog?.kind === "room" ? (
+        <RoomModal
+          buildings={buildings}
+          floors={floors}
+          initialRoom={dialog.room ?? undefined}
+          initialValues={
+            dialog.defaultFloorId ? { floorId: dialog.defaultFloorId } : undefined
+          }
+          isSaving={isSaving}
+          onClose={() => setDialog(null)}
+          onSave={handleSaveRoom}
+        />
+      ) : null}
+    </main>
+  );
+}
+
+function FloorGroupEntries({
+  children,
+  label,
+}: {
+  children: ReactNode;
+  label: string;
+}) {
+  return (
+    <>
+      {label ? (
+        <li className="list-group-item structure-group-label">
+          {label}
+        </li>
+      ) : null}
+      {children}
+    </>
+  );
+}
diff --git a/src/db/migrations/0009_buildings.sql b/src/db/migrations/0009_buildings.sql
new file mode 100644
index 0000000..6f65174
--- /dev/null
+++ b/src/db/migrations/0009_buildings.sql
@@ -0,0 +1,9 @@
+CREATE TABLE `buildings` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`name` text NOT NULL,
+	`sort_order` integer DEFAULT 0 NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+ALTER TABLE `floors` ADD `building_id` text REFERENCES buildings(id) ON DELETE set null;
\ No newline at end of file
diff --git a/src/db/migrations/meta/0009_snapshot.json b/src/db/migrations/meta/0009_snapshot.json
new file mode 100644
index 0000000..1b7d566
--- /dev/null
+++ b/src/db/migrations/meta/0009_snapshot.json
@@ -0,0 +1,2626 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "2cd9adef-2f08-4635-b3d9-ecf71f624c7f",
+  "prevId": "fb609719-ea17-4833-a27b-f75da0d3e860",
+  "tables": {
+    "buildings": {
+      "name": "buildings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "buildings_project_id_projects_id_fk": {
+          "name": "buildings_project_id_projects_id_fk",
+          "tableFrom": "buildings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_device_rows": {
+      "name": "circuit_device_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "level": {
+          "name": "level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number_snapshot": {
+          "name": "room_number_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_name_snapshot": {
+          "name": "room_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "manual_quantity": {
+          "name": "manual_quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_device_rows_circuit_id_idx": {
+          "name": "circuit_device_rows_circuit_id_idx",
+          "columns": [
+            "circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "circuit_device_rows_circuit_id_circuits_id_fk": {
+          "name": "circuit_device_rows_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_linked_project_device_id_project_devices_id_fk": {
+          "name": "circuit_device_rows_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_room_id_rooms_id_fk": {
+          "name": "circuit_device_rows_room_id_rooms_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_list_equipment_identifiers": {
+      "name": "circuit_list_equipment_identifiers",
+      "columns": {
+        "owner_type": {
+          "name": "owner_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_list_equipment_identifiers_owner_unique": {
+          "name": "circuit_list_equipment_identifiers_owner_unique",
+          "columns": [
+            "owner_type",
+            "owner_id"
+          ],
+          "isUnique": true
+        },
+        "circuit_list_equipment_identifiers_list_identifier_unique": {
+          "name": "circuit_list_equipment_identifiers_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_list_equipment_identifiers",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_lists": {
+      "name": "circuit_lists",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_lists_distribution_board_id_unique": {
+          "name": "circuit_lists_distribution_board_id_unique",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_lists_project_id_projects_id_fk": {
+          "name": "circuit_lists_project_id_projects_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_lists_distribution_board_id_distribution_boards_id_fk": {
+          "name": "circuit_lists_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_protection_devices": {
+      "name": "circuit_protection_devices",
+      "columns": {
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "circuit_protection_devices_circuit_id_circuits_id_fk": {
+          "name": "circuit_protection_devices_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_protection_devices",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_sections": {
+      "name": "circuit_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "group_number": {
+          "name": "group_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_sections_list_key_unique": {
+          "name": "circuit_sections_list_key_unique",
+          "columns": [
+            "circuit_list_id",
+            "key"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_prefix_unique": {
+          "name": "circuit_sections_list_prefix_unique",
+          "columns": [
+            "circuit_list_id",
+            "prefix"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_category_group_unique": {
+          "name": "circuit_sections_list_category_group_unique",
+          "columns": [
+            "circuit_list_id",
+            "category",
+            "group_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_sections_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_sections_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_sections",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuits": {
+      "name": "circuits",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "cable_type": {
+          "name": "cable_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_cross_section": {
+          "name": "cable_cross_section",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_length": {
+          "name": "cable_length",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_assignment": {
+          "name": "rcd_assignment",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_designation": {
+          "name": "terminal_designation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage": {
+          "name": "voltage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "control_requirement": {
+          "name": "control_requirement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_reserve": {
+          "name": "is_reserve",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuits_section_id_idx": {
+          "name": "circuits_section_id_idx",
+          "columns": [
+            "section_id"
+          ],
+          "isUnique": false
+        },
+        "circuits_list_equipment_identifier_unique": {
+          "name": "circuits_list_equipment_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuits_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuits_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuits_section_id_circuit_sections_id_fk": {
+          "name": "circuits_section_id_circuit_sections_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_component_protection_devices": {
+      "name": "distribution_board_component_protection_devices",
+      "columns": {
+        "component_id": {
+          "name": "component_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk": {
+          "name": "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk",
+          "tableFrom": "distribution_board_component_protection_devices",
+          "tableTo": "distribution_board_components",
+          "columnsFrom": [
+            "component_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_components": {
+      "name": "distribution_board_components",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "placement": {
+          "name": "placement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "distribution_board_components_list_identifier_unique": {
+          "name": "distribution_board_components_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        },
+        "distribution_board_components_section_role_unique": {
+          "name": "distribution_board_components_section_role_unique",
+          "columns": [
+            "section_id",
+            "role"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "distribution_board_components_circuit_list_id_circuit_lists_id_fk": {
+          "name": "distribution_board_components_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_board_components_section_id_circuit_sections_id_fk": {
+          "name": "distribution_board_components_section_id_circuit_sections_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_boards": {
+      "name": "distribution_boards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "supply_type": {
+          "name": "supply_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "board_number": {
+          "name": "board_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "location": {
+          "name": "location",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fed_from": {
+          "name": "fed_from",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_boards_project_id_projects_id_fk": {
+          "name": "distribution_boards_project_id_projects_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_floor_id_floors_id_fk": {
+          "name": "distribution_boards_floor_id_floors_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_assets": {
+      "name": "document_branding_assets",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_settings": {
+      "name": "document_branding_settings",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_csv_configurations": {
+      "name": "external_csv_configurations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration": {
+          "name": "configuration",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_csv_configurations_project_id_unique": {
+          "name": "external_csv_configurations_project_id_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_csv_configurations_project_id_projects_id_fk": {
+          "name": "external_csv_configurations_project_id_projects_id_fk",
+          "tableFrom": "external_csv_configurations",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_import_batches": {
+      "name": "external_import_batches",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "import_kind": {
+          "name": "import_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "imported_at_iso": {
+          "name": "imported_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "applied_project_revision": {
+          "name": "applied_project_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_snapshot": {
+          "name": "configuration_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "original_bytes": {
+          "name": "original_bytes",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "document": {
+          "name": "document",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_import_batches_project_revision_idx": {
+          "name": "external_import_batches_project_revision_idx",
+          "columns": [
+            "project_id",
+            "applied_project_revision"
+          ],
+          "isUnique": false
+        },
+        "external_import_batches_source_imported_idx": {
+          "name": "external_import_batches_source_imported_idx",
+          "columns": [
+            "source_id",
+            "imported_at_iso"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_import_batches_project_id_projects_id_fk": {
+          "name": "external_import_batches_project_id_projects_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_import_batches_source_id_external_model_sources_id_fk": {
+          "name": "external_import_batches_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_objects": {
+      "name": "external_model_objects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ifc_guid": {
+          "name": "ifc_guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen_import_batch_id": {
+          "name": "last_seen_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_accepted_import_batch_id": {
+          "name": "last_accepted_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "accepted_source_values": {
+          "name": "accepted_source_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "planning_values": {
+          "name": "planning_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "external_room_mapping_id": {
+          "name": "external_room_mapping_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "circuit_device_row_id": {
+          "name": "circuit_device_row_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "presence_status": {
+          "name": "presence_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'present'"
+        }
+      },
+      "indexes": {
+        "external_model_objects_source_ifc_guid_unique": {
+          "name": "external_model_objects_source_ifc_guid_unique",
+          "columns": [
+            "source_id",
+            "ifc_guid"
+          ],
+          "isUnique": true
+        },
+        "external_model_objects_project_presence_idx": {
+          "name": "external_model_objects_project_presence_idx",
+          "columns": [
+            "project_id",
+            "presence_status"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_distribution_board_idx": {
+          "name": "external_model_objects_distribution_board_idx",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_circuit_device_row_idx": {
+          "name": "external_model_objects_circuit_device_row_idx",
+          "columns": [
+            "circuit_device_row_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_model_objects_project_id_projects_id_fk": {
+          "name": "external_model_objects_project_id_projects_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_source_id_external_model_sources_id_fk": {
+          "name": "external_model_objects_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_seen_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_accepted_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk": {
+          "name": "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_room_mappings",
+          "columnsFrom": [
+            "external_room_mapping_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_model_objects_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_linked_project_device_id_project_devices_id_fk": {
+          "name": "external_model_objects_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk": {
+          "name": "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "circuit_device_rows",
+          "columnsFrom": [
+            "circuit_device_row_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_sources": {
+      "name": "external_model_sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_type": {
+          "name": "source_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'revit_csv'"
+        }
+      },
+      "indexes": {
+        "external_model_sources_project_type_unique": {
+          "name": "external_model_sources_project_type_unique",
+          "columns": [
+            "project_id",
+            "source_type"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_sources_project_id_projects_id_fk": {
+          "name": "external_model_sources_project_id_projects_id_fk",
+          "tableFrom": "external_model_sources",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_room_mappings": {
+      "name": "external_room_mappings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "normalized_source_room_key": {
+          "name": "normalized_source_room_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_floor_name": {
+          "name": "source_floor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_room_number": {
+          "name": "source_room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_room_name": {
+          "name": "source_room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_distribution_board_id": {
+          "name": "default_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_room_mappings_source_key_unique": {
+          "name": "external_room_mappings_source_key_unique",
+          "columns": [
+            "source_id",
+            "normalized_source_room_key"
+          ],
+          "isUnique": true
+        },
+        "external_room_mappings_project_room_idx": {
+          "name": "external_room_mappings_project_room_idx",
+          "columns": [
+            "project_id",
+            "room_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_room_mappings_project_id_projects_id_fk": {
+          "name": "external_room_mappings_project_id_projects_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_source_id_external_model_sources_id_fk": {
+          "name": "external_room_mappings_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_room_id_rooms_id_fk": {
+          "name": "external_room_mappings_room_id_rooms_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "default_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "floors": {
+      "name": "floors",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "building_id": {
+          "name": "building_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "floors_project_id_projects_id_fk": {
+          "name": "floors_project_id_projects_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "floors_building_id_buildings_id_fk": {
+          "name": "floors_building_id_buildings_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "buildings",
+          "columnsFrom": [
+            "building_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "global_devices": {
+      "name": "global_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "installed_power_per_unit_kw": {
+          "name": "installed_power_per_unit_kw",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "demand_factor": {
+          "name": "demand_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase_count": {
+          "name": "phase_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_factor": {
+          "name": "power_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_change_sets": {
+      "name": "project_change_sets",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_revision_id": {
+          "name": "project_revision_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "command_type": {
+          "name": "command_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_schema_version": {
+          "name": "payload_schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "forward_payload_json": {
+          "name": "forward_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "inverse_payload_json": {
+          "name": "inverse_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_change_sets_revision_unique": {
+          "name": "project_change_sets_revision_unique",
+          "columns": [
+            "project_revision_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_change_sets_project_revision_id_project_revisions_id_fk": {
+          "name": "project_change_sets_project_revision_id_project_revisions_id_fk",
+          "tableFrom": "project_change_sets",
+          "tableTo": "project_revisions",
+          "columnsFrom": [
+            "project_revision_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_devices": {
+      "name": "project_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'single_phase'"
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "project_devices_project_id_projects_id_fk": {
+          "name": "project_devices_project_id_projects_id_fk",
+          "tableFrom": "project_devices",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_history_stack_entries": {
+      "name": "project_history_stack_entries",
+      "columns": {
+        "change_set_id": {
+          "name": "change_set_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stack": {
+          "name": "stack",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_history_stack_entries_position_unique": {
+          "name": "project_history_stack_entries_position_unique",
+          "columns": [
+            "project_id",
+            "stack",
+            "position"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_history_stack_entries_change_set_id_project_change_sets_id_fk": {
+          "name": "project_history_stack_entries_change_set_id_project_change_sets_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "project_change_sets",
+          "columnsFrom": [
+            "change_set_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "project_history_stack_entries_project_id_projects_id_fk": {
+          "name": "project_history_stack_entries_project_id_projects_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "project_history_stack_entries_stack_check": {
+          "name": "project_history_stack_entries_stack_check",
+          "value": "\"project_history_stack_entries\".\"stack\" in ('undo', 'redo')"
+        }
+      }
+    },
+    "project_revisions": {
+      "name": "project_revisions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision_number": {
+          "name": "revision_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_revisions_project_number_unique": {
+          "name": "project_revisions_project_number_unique",
+          "columns": [
+            "project_id",
+            "revision_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_revisions_project_id_projects_id_fk": {
+          "name": "project_revisions_project_id_projects_id_fk",
+          "tableFrom": "project_revisions",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_snapshots": {
+      "name": "project_snapshots",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_revision": {
+          "name": "source_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_version": {
+          "name": "schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'named'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "payload_json": {
+          "name": "payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_sha256": {
+          "name": "payload_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_by_actor_id": {
+          "name": "created_by_actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_snapshots_project_created_idx": {
+          "name": "project_snapshots_project_created_idx",
+          "columns": [
+            "project_id",
+            "created_at_iso"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_kind_revision_idx": {
+          "name": "project_snapshots_project_kind_revision_idx",
+          "columns": [
+            "project_id",
+            "kind",
+            "source_revision"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_name_unique": {
+          "name": "project_snapshots_project_name_unique",
+          "columns": [
+            "project_id",
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_snapshots_project_id_projects_id_fk": {
+          "name": "project_snapshots_project_id_projects_id_fk",
+          "tableFrom": "project_snapshots",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "internal_project_number": {
+          "name": "internal_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_project_number": {
+          "name": "external_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "building_owner": {
+          "name": "building_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_public_building": {
+          "name": "is_public_building",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "single_phase_voltage_v": {
+          "name": "single_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 230
+        },
+        "three_phase_voltage_v": {
+          "name": "three_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 400
+        },
+        "enabled_distribution_board_supply_types": {
+          "name": "enabled_distribution_board_supply_types",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'[\"AV\",\"SV\",\"EV\",\"USV\",\"MSR\",\"SiBe\"]'"
+        },
+        "site_address": {
+          "name": "site_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_lead": {
+          "name": "project_lead",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_editor": {
+          "name": "project_editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "current_revision": {
+          "name": "current_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "rooms": {
+      "name": "rooms",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number": {
+          "name": "room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_name": {
+          "name": "room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rooms_project_id_projects_id_fk": {
+          "name": "rooms_project_id_projects_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rooms_floor_id_floors_id_fk": {
+          "name": "rooms_floor_id_floors_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index 8322eb3..485b8f4 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -64,6 +64,13 @@
       "when": 1790411560953,
       "tag": "0008_project_cover_and_office_profile",
       "breakpoints": true
+    },
+    {
+      "idx": 9,
+      "version": "6",
+      "when": 1790419185882,
+      "tag": "0009_buildings",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/db/repositories/building.repository.ts b/src/db/repositories/building.repository.ts
new file mode 100644
index 0000000..011739f
--- /dev/null
+++ b/src/db/repositories/building.repository.ts
@@ -0,0 +1,27 @@
+import { and, asc, eq } from "drizzle-orm";
+import type { AppDatabase } from "../database-context.js";
+import { buildings } from "../schema/buildings.js";
+
+export class BuildingRepository {
+  constructor(private readonly database: AppDatabase) {}
+
+  async listByProject(projectId: string) {
+    return this.database
+      .select()
+      .from(buildings)
+      .where(eq(buildings.projectId, projectId))
+      .orderBy(asc(buildings.sortOrder), asc(buildings.name));
+  }
+
+  async findById(projectId: string, buildingId: string) {
+    return (
+      this.database
+        .select()
+        .from(buildings)
+        .where(
+          and(eq(buildings.projectId, projectId), eq(buildings.id, buildingId))
+        )
+        .get() ?? null
+    );
+  }
+}
diff --git a/src/db/repositories/project-location-structure-project-command.repository.ts b/src/db/repositories/project-location-structure-project-command.repository.ts
index 7cbadde..9ec3f48 100644
--- a/src/db/repositories/project-location-structure-project-command.repository.ts
+++ b/src/db/repositories/project-location-structure-project-command.repository.ts
@@ -1,23 +1,34 @@
 import { and, eq } from "drizzle-orm";
 import {
+  assertProjectBuildingDeleteProjectCommand,
+  assertProjectBuildingInsertProjectCommand,
+  assertProjectBuildingUpdateProjectCommand,
   assertProjectFloorDeleteProjectCommand,
   assertProjectFloorInsertProjectCommand,
   assertProjectFloorUpdateProjectCommand,
   assertProjectRoomDeleteProjectCommand,
   assertProjectRoomInsertProjectCommand,
   assertProjectRoomUpdateProjectCommand,
+  createProjectBuildingDeleteProjectCommand,
+  createProjectBuildingInsertProjectCommand,
+  createProjectBuildingUpdateProjectCommand,
   createProjectFloorDeleteProjectCommand,
   createProjectFloorInsertProjectCommand,
   createProjectFloorUpdateProjectCommand,
   createProjectRoomDeleteProjectCommand,
   createProjectRoomInsertProjectCommand,
   createProjectRoomUpdateProjectCommand,
+  projectBuildingDeleteCommandType,
+  projectBuildingInsertCommandType,
+  projectBuildingUpdateCommandType,
   projectFloorDeleteCommandType,
   projectFloorInsertCommandType,
   projectFloorUpdateCommandType,
   projectRoomDeleteCommandType,
   projectRoomInsertCommandType,
   projectRoomUpdateCommandType,
+  upgradeProjectFloorCommand,
+  type ProjectBuildingSnapshot,
   type ProjectFloorSnapshot,
   type ProjectLocationStructureProjectCommand,
   type ProjectRoomSnapshot,
@@ -27,6 +38,7 @@ import type {
   ProjectLocationStructureProjectCommandStore,
 } from "../../domain/ports/project-location-structure-project-command.store.js";
 import type { AppDatabase } from "../database-context.js";
+import { buildings } from "../schema/buildings.js";
 import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
 import { floors } from "../schema/floors.js";
 import { distributionBoards } from "../schema/distribution-boards.js";
@@ -40,11 +52,14 @@ export class ProjectLocationStructureProjectCommandRepository
   constructor(private readonly database: AppDatabase) {}
 
   execute(input: ExecuteProjectLocationStructureCommandInput) {
+    // Forward and inverse are persisted with one schema version, so a
+    // version 1 floor command from older history is upgraded first.
+    const command = toCurrentCommandVersion(input.command);
     return executeProjectCommandTransaction(
       this.database,
-      input,
+      { ...input, command },
       (tx) =>
-        this.applyCommand(tx, input.projectId, input.command)
+        this.applyCommand(tx, input.projectId, command)
     );
   }
 
@@ -54,23 +69,43 @@ export class ProjectLocationStructureProjectCommandRepository
     command: ProjectLocationStructureProjectCommand
   ): ProjectLocationStructureProjectCommand {
     switch (command.type) {
-      case projectFloorInsertCommandType:
+      case projectBuildingInsertCommandType:
+        assertProjectBuildingInsertProjectCommand(command);
+        return this.insertBuilding(database, projectId, command.payload.building);
+      case projectBuildingDeleteCommandType:
+        assertProjectBuildingDeleteProjectCommand(command);
+        return this.deleteBuilding(database, projectId, command.payload.building);
+      case projectBuildingUpdateCommandType:
+        assertProjectBuildingUpdateProjectCommand(command);
+        return this.updateBuilding(
+          database,
+          projectId,
+          command.payload.expected,
+          command.payload.target
+        );
+      case projectFloorInsertCommandType: {
         assertProjectFloorInsertProjectCommand(command);
+        const current = upgradeProjectFloorCommand(command);
         return this.insertFloor(
           database,
           projectId,
-          command.payload.floor
+          current.payload.floor
         );
-      case projectFloorDeleteCommandType:
+      }
+      case projectFloorDeleteCommandType: {
         assertProjectFloorDeleteProjectCommand(command);
+        const current = upgradeProjectFloorCommand(command);
         return this.deleteFloor(
           database,
           projectId,
-          command.payload.floor
+          current.payload.floor
         );
-      case projectFloorUpdateCommandType:
+      }
+      case projectFloorUpdateCommandType: {
         assertProjectFloorUpdateProjectCommand(command);
-        return this.updateFloor(database, projectId, command.payload.expected, command.payload.target);
+        const current = upgradeProjectFloorCommand(command);
+        return this.updateFloor(database, projectId, current.payload.expected, current.payload.target);
+      }
       case projectRoomInsertCommandType:
         assertProjectRoomInsertProjectCommand(command);
         return this.insertRoom(
@@ -100,6 +135,7 @@ export class ProjectLocationStructureProjectCommandRepository
     if (floor.projectId !== projectId) {
       throw new Error("Project-floor snapshot does not belong to project.");
     }
+    this.assertBuildingInProject(database, projectId, floor.buildingId);
     const existing = database
       .select({ id: floors.id })
       .from(floors)
@@ -167,6 +203,104 @@ export class ProjectLocationStructureProjectCommandRepository
     return createProjectFloorInsertProjectCommand(expected);
   }
 
+  private insertBuilding(
+    database: AppDatabase,
+    projectId: string,
+    building: ProjectBuildingSnapshot
+  ) {
+    this.assertProjectExists(database, projectId);
+    if (building.projectId !== projectId) {
+      throw new Error("Project-building snapshot does not belong to project.");
+    }
+    const existing = database
+      .select({ id: buildings.id })
+      .from(buildings)
+      .where(eq(buildings.id, building.id))
+      .get();
+    if (existing) {
+      throw new Error("Project-building id already exists.");
+    }
+    database.insert(buildings).values(building).run();
+    return createProjectBuildingDeleteProjectCommand(building);
+  }
+
+  private deleteBuilding(
+    database: AppDatabase,
+    projectId: string,
+    expected: ProjectBuildingSnapshot
+  ) {
+    const persisted = database
+      .select()
+      .from(buildings)
+      .where(and(eq(buildings.id, expected.id), eq(buildings.projectId, projectId)))
+      .get();
+    if (!persisted || !sameRecord(expected, persisted)) {
+      throw new Error("Project building changed before deletion.");
+    }
+    const referencedFloor = database
+      .select({ id: floors.id })
+      .from(floors)
+      .where(eq(floors.buildingId, expected.id))
+      .limit(1)
+      .get();
+    if (referencedFloor) {
+      throw new Error(
+        "Das Gebäude kann nicht gelöscht werden, solange Etagen zugeordnet sind."
+      );
+    }
+    const deleted = database
+      .delete(buildings)
+      .where(and(eq(buildings.id, expected.id), eq(buildings.projectId, projectId)))
+      .run();
+    if (deleted.changes !== 1) {
+      throw new Error("Project building could not be deleted.");
+    }
+    return createProjectBuildingInsertProjectCommand(expected);
+  }
+
+  private updateBuilding(
+    database: AppDatabase,
+    projectId: string,
+    expected: ProjectBuildingSnapshot,
+    target: ProjectBuildingSnapshot
+  ) {
+    const persisted = database
+      .select()
+      .from(buildings)
+      .where(and(eq(buildings.id, expected.id), eq(buildings.projectId, projectId)))
+      .get();
+    if (!persisted || !sameRecord(expected, persisted)) {
+      throw new Error("Project building changed before update.");
+    }
+    const updated = database
+      .update(buildings)
+      .set({ name: target.name })
+      .where(and(eq(buildings.id, expected.id), eq(buildings.projectId, projectId)))
+      .run();
+    if (updated.changes !== 1) {
+      throw new Error("Das Gebäude konnte nicht aktualisiert werden.");
+    }
+    return createProjectBuildingUpdateProjectCommand(target, expected);
+  }
+
+  private assertBuildingInProject(
+    database: AppDatabase,
+    projectId: string,
+    buildingId: string | null
+  ) {
+    if (buildingId === null) {
+      return;
+    }
+    const building = database
+      .select({ id: buildings.id })
+      .from(buildings)
+      .where(and(eq(buildings.id, buildingId), eq(buildings.projectId, projectId)))
+      .get();
+    if (!building) {
+      throw new Error("Project floor references a foreign building.");
+    }
+  }
+
   private insertRoom(
     database: AppDatabase,
     projectId: string,
@@ -217,9 +351,10 @@ export class ProjectLocationStructureProjectCommandRepository
     if (!persisted || !sameRecord(expected, persisted)) {
       throw new Error("Project floor changed before update.");
     }
+    this.assertBuildingInProject(database, projectId, target.buildingId);
     const updated = database
       .update(floors)
-      .set({ name: target.name })
+      .set({ name: target.name, buildingId: target.buildingId })
       .where(and(eq(floors.id, expected.id), eq(floors.projectId, projectId)))
       .run();
     if (updated.changes !== 1) {
@@ -326,6 +461,24 @@ export class ProjectLocationStructureProjectCommandRepository
   }
 }
 
+function toCurrentCommandVersion(
+  command: ProjectLocationStructureProjectCommand
+): ProjectLocationStructureProjectCommand {
+  switch (command.type) {
+    case projectFloorInsertCommandType:
+      assertProjectFloorInsertProjectCommand(command);
+      return upgradeProjectFloorCommand(command);
+    case projectFloorDeleteCommandType:
+      assertProjectFloorDeleteProjectCommand(command);
+      return upgradeProjectFloorCommand(command);
+    case projectFloorUpdateCommandType:
+      assertProjectFloorUpdateProjectCommand(command);
+      return upgradeProjectFloorCommand(command);
+    default:
+      return command;
+  }
+}
+
 function sameRecord(
   expected: object,
   actual: object
diff --git a/src/db/repositories/project-state-restore-command.repository.ts b/src/db/repositories/project-state-restore-command.repository.ts
index cf6f9bc..496f2cb 100644
--- a/src/db/repositories/project-state-restore-command.repository.ts
+++ b/src/db/repositories/project-state-restore-command.repository.ts
@@ -21,6 +21,7 @@ import { circuits } from "../schema/circuits.js";
 import { distributionBoardComponentProtectionDevices } from "../schema/distribution-board-component-protection-devices.js";
 import { distributionBoardComponents } from "../schema/distribution-board-components.js";
 import { distributionBoards } from "../schema/distribution-boards.js";
+import { buildings } from "../schema/buildings.js";
 import { floors } from "../schema/floors.js";
 import { projectDevices } from "../schema/project-devices.js";
 import { projectChangeSets } from "../schema/project-change-sets.js";
@@ -164,6 +165,7 @@ function canonicalProjectState(state: ProjectStateSnapshot) {
       }))
     ),
     projectDevices: byId(state.projectDevices),
+    buildings: byId(state.buildings),
     floors: byId(state.floors),
     rooms: byId(state.rooms),
     externalCsvConfiguration: state.externalCsvConfiguration,
@@ -219,6 +221,10 @@ function replaceProjectState(
     .delete(floors)
     .where(eq(floors.projectId, state.project.id))
     .run();
+  database
+    .delete(buildings)
+    .where(eq(buildings.projectId, state.project.id))
+    .run();
 
   database
     .update(projects)
@@ -241,6 +247,7 @@ function replaceProjectState(
     .where(eq(projects.id, state.project.id))
     .run();
 
+  insertMany(database, buildings, state.buildings);
   insertMany(database, floors, state.floors);
   if (state.externalCsvConfiguration !== null) {
     database
diff --git a/src/db/repositories/project-state-snapshot.persistence.ts b/src/db/repositories/project-state-snapshot.persistence.ts
index 84131e7..a11cd58 100644
--- a/src/db/repositories/project-state-snapshot.persistence.ts
+++ b/src/db/repositories/project-state-snapshot.persistence.ts
@@ -15,6 +15,7 @@ import { circuits } from "../schema/circuits.js";
 import { distributionBoardComponentProtectionDevices } from "../schema/distribution-board-component-protection-devices.js";
 import { distributionBoardComponents } from "../schema/distribution-board-components.js";
 import { distributionBoards } from "../schema/distribution-boards.js";
+import { buildings } from "../schema/buildings.js";
 import { floors } from "../schema/floors.js";
 import { projectDevices } from "../schema/project-devices.js";
 import { projects } from "../schema/projects.js";
@@ -219,6 +220,12 @@ export function readProjectStateSnapshot(
     .where(eq(projectDevices.projectId, projectId))
     .orderBy(asc(projectDevices.displayName), asc(projectDevices.id))
     .all();
+  const buildingRows = database
+    .select()
+    .from(buildings)
+    .where(eq(buildings.projectId, projectId))
+    .orderBy(asc(buildings.sortOrder), asc(buildings.id))
+    .all();
   const floorRows = database
     .select()
     .from(floors)
@@ -273,6 +280,7 @@ export function readProjectStateSnapshot(
       deviceRows: deviceRowsByCircuit.get(circuit.id) ?? [],
     })),
     projectDevices: projectDeviceRows,
+    buildings: buildingRows,
     floors: floorRows,
     rooms: roomRows,
   });
diff --git a/src/db/repositories/project-transfer.repository.ts b/src/db/repositories/project-transfer.repository.ts
index 07a5067..11f23f7 100644
--- a/src/db/repositories/project-transfer.repository.ts
+++ b/src/db/repositories/project-transfer.repository.ts
@@ -16,6 +16,7 @@ import { circuits } from "../schema/circuits.js";
 import { distributionBoardComponentProtectionDevices } from "../schema/distribution-board-component-protection-devices.js";
 import { distributionBoardComponents } from "../schema/distribution-board-components.js";
 import { distributionBoards } from "../schema/distribution-boards.js";
+import { buildings } from "../schema/buildings.js";
 import { floors } from "../schema/floors.js";
 import { projectDevices } from "../schema/project-devices.js";
 import { projects } from "../schema/projects.js";
@@ -127,6 +128,7 @@ function insertProjectState(
       .values(state.externalCsvConfiguration)
       .run();
   }
+  insertMany(database, buildings, state.buildings);
   insertMany(database, floors, state.floors);
   insertMany(database, rooms, state.rooms);
   insertMany(database, projectDevices, state.projectDevices);
diff --git a/src/db/schema/buildings.ts b/src/db/schema/buildings.ts
new file mode 100644
index 0000000..7d2fb78
--- /dev/null
+++ b/src/db/schema/buildings.ts
@@ -0,0 +1,11 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { projects } from "./projects.js";
+
+export const buildings = sqliteTable("buildings", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id")
+    .notNull()
+    .references(() => projects.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+  sortOrder: integer("sort_order").notNull().default(0),
+});
diff --git a/src/db/schema/floors.ts b/src/db/schema/floors.ts
index 5c68753..bd50534 100644
--- a/src/db/schema/floors.ts
+++ b/src/db/schema/floors.ts
@@ -1,4 +1,5 @@
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { buildings } from "./buildings.js";
 import { projects } from "./projects.js";
 
 export const floors = sqliteTable("floors", {
@@ -8,4 +9,9 @@ export const floors = sqliteTable("floors", {
     .references(() => projects.id, { onDelete: "cascade" }),
   name: text("name").notNull(),
   sortOrder: integer("sort_order").notNull().default(0),
+  // Optional parent building. Floors created before buildings existed stay
+  // without one and are shown as "Ohne Gebäude".
+  buildingId: text("building_id").references(() => buildings.id, {
+    onDelete: "set null",
+  }),
 });
diff --git a/src/domain/models/project-location-structure-project-command.model.ts b/src/domain/models/project-location-structure-project-command.model.ts
index 616add9..21dfa89 100644
--- a/src/domain/models/project-location-structure-project-command.model.ts
+++ b/src/domain/models/project-location-structure-project-command.model.ts
@@ -1,21 +1,42 @@
 import crypto from "node:crypto";
 import type { SerializedProjectCommand } from "./project-command.model.js";
 
+export const projectBuildingInsertCommandType = "project-building.insert" as const;
+export const projectBuildingDeleteCommandType = "project-building.delete" as const;
+export const projectBuildingUpdateCommandType = "project-building.update" as const;
 export const projectFloorInsertCommandType = "project-floor.insert" as const;
 export const projectFloorDeleteCommandType = "project-floor.delete" as const;
 export const projectFloorUpdateCommandType = "project-floor.update" as const;
 export const projectRoomInsertCommandType = "project-room.insert" as const;
 export const projectRoomDeleteCommandType = "project-room.delete" as const;
 export const projectRoomUpdateCommandType = "project-room.update" as const;
+/** Room commands, building commands and legacy floor commands. */
 export const projectLocationStructureCommandSchemaVersion = 1 as const;
+/**
+ * Floor commands carry `buildingId` since version 2. Version 1 floor
+ * commands stay executable from persisted history: they were recorded before
+ * buildings existed, so they are upgraded with `buildingId = null`.
+ */
+export const projectFloorCommandSchemaVersion = 2 as const;
+const legacyProjectFloorCommandSchemaVersion = 1 as const;
+
+export interface ProjectBuildingSnapshot {
+  id: string;
+  projectId: string;
+  name: string;
+  sortOrder: number;
+}
 
 export interface ProjectFloorSnapshot {
   id: string;
   projectId: string;
   name: string;
   sortOrder: number;
+  buildingId: string | null;
 }
 
+export type LegacyProjectFloorSnapshot = Omit<ProjectFloorSnapshot, "buildingId">;
+
 export interface ProjectRoomSnapshot {
   id: string;
   projectId: string;
@@ -24,39 +45,93 @@ export interface ProjectRoomSnapshot {
   roomName: string;
 }
 
+interface ProjectBuildingStructureCommandPayload {
+  building: ProjectBuildingSnapshot;
+}
+
 interface ProjectFloorStructureCommandPayload {
   floor: ProjectFloorSnapshot;
 }
 
+interface LegacyProjectFloorStructureCommandPayload {
+  floor: LegacyProjectFloorSnapshot;
+}
+
 interface ProjectRoomStructureCommandPayload {
   room: ProjectRoomSnapshot;
 }
 
+interface ProjectBuildingUpdateCommandPayload {
+  expected: ProjectBuildingSnapshot;
+  target: ProjectBuildingSnapshot;
+}
+
 interface ProjectFloorUpdateCommandPayload {
   expected: ProjectFloorSnapshot;
   target: ProjectFloorSnapshot;
 }
 
+interface LegacyProjectFloorUpdateCommandPayload {
+  expected: LegacyProjectFloorSnapshot;
+  target: LegacyProjectFloorSnapshot;
+}
+
 interface ProjectRoomUpdateCommandPayload {
   expected: ProjectRoomSnapshot;
   target: ProjectRoomSnapshot;
 }
 
+export interface ProjectBuildingInsertProjectCommand
+  extends SerializedProjectCommand<ProjectBuildingStructureCommandPayload> {
+  schemaVersion: typeof projectLocationStructureCommandSchemaVersion;
+  type: typeof projectBuildingInsertCommandType;
+}
+
+export interface ProjectBuildingDeleteProjectCommand
+  extends SerializedProjectCommand<ProjectBuildingStructureCommandPayload> {
+  schemaVersion: typeof projectLocationStructureCommandSchemaVersion;
+  type: typeof projectBuildingDeleteCommandType;
+}
+
+export interface ProjectBuildingUpdateProjectCommand
+  extends SerializedProjectCommand<ProjectBuildingUpdateCommandPayload> {
+  schemaVersion: typeof projectLocationStructureCommandSchemaVersion;
+  type: typeof projectBuildingUpdateCommandType;
+}
+
 export interface ProjectFloorInsertProjectCommand
   extends SerializedProjectCommand<ProjectFloorStructureCommandPayload> {
-  schemaVersion: typeof projectLocationStructureCommandSchemaVersion;
+  schemaVersion: typeof projectFloorCommandSchemaVersion;
   type: typeof projectFloorInsertCommandType;
 }
 
 export interface ProjectFloorDeleteProjectCommand
   extends SerializedProjectCommand<ProjectFloorStructureCommandPayload> {
-  schemaVersion: typeof projectLocationStructureCommandSchemaVersion;
+  schemaVersion: typeof projectFloorCommandSchemaVersion;
   type: typeof projectFloorDeleteCommandType;
 }
 
 export interface ProjectFloorUpdateProjectCommand
   extends SerializedProjectCommand<ProjectFloorUpdateCommandPayload> {
-  schemaVersion: typeof projectLocationStructureCommandSchemaVersion;
+  schemaVersion: typeof projectFloorCommandSchemaVersion;
+  type: typeof projectFloorUpdateCommandType;
+}
+
+export interface LegacyProjectFloorInsertProjectCommand
+  extends SerializedProjectCommand<LegacyProjectFloorStructureCommandPayload> {
+  schemaVersion: typeof legacyProjectFloorCommandSchemaVersion;
+  type: typeof projectFloorInsertCommandType;
+}
+
+export interface LegacyProjectFloorDeleteProjectCommand
+  extends SerializedProjectCommand<LegacyProjectFloorStructureCommandPayload> {
+  schemaVersion: typeof legacyProjectFloorCommandSchemaVersion;
+  type: typeof projectFloorDeleteCommandType;
+}
+
+export interface LegacyProjectFloorUpdateProjectCommand
+  extends SerializedProjectCommand<LegacyProjectFloorUpdateCommandPayload> {
+  schemaVersion: typeof legacyProjectFloorCommandSchemaVersion;
   type: typeof projectFloorUpdateCommandType;
 }
 
@@ -79,23 +154,46 @@ export interface ProjectRoomUpdateProjectCommand
 }
 
 export type ProjectLocationStructureProjectCommand =
+  | ProjectBuildingInsertProjectCommand
+  | ProjectBuildingDeleteProjectCommand
+  | ProjectBuildingUpdateProjectCommand
   | ProjectFloorInsertProjectCommand
   | ProjectFloorDeleteProjectCommand
   | ProjectFloorUpdateProjectCommand
+  | LegacyProjectFloorInsertProjectCommand
+  | LegacyProjectFloorDeleteProjectCommand
+  | LegacyProjectFloorUpdateProjectCommand
   | ProjectRoomInsertProjectCommand
   | ProjectRoomDeleteProjectCommand
   | ProjectRoomUpdateProjectCommand;
 
-export function createProjectFloorSnapshot(
+export function createProjectBuildingSnapshot(
   projectId: string,
   name: string,
   sortOrder: number
+): ProjectBuildingSnapshot {
+  const building: ProjectBuildingSnapshot = {
+    id: crypto.randomUUID(),
+    projectId,
+    name: name.trim(),
+    sortOrder,
+  };
+  assertProjectBuildingSnapshot(building);
+  return building;
+}
+
+export function createProjectFloorSnapshot(
+  projectId: string,
+  name: string,
+  sortOrder: number,
+  buildingId: string | null = null
 ): ProjectFloorSnapshot {
   const floor: ProjectFloorSnapshot = {
     id: crypto.randomUUID(),
     projectId,
     name: name.trim(),
     sortOrder,
+    buildingId: buildingId?.trim() || null,
   };
   assertProjectFloorSnapshot(floor);
   return floor;
@@ -120,12 +218,46 @@ export function createProjectRoomSnapshot(
   return room;
 }
 
+export function createProjectBuildingInsertProjectCommand(
+  building: ProjectBuildingSnapshot
+): ProjectBuildingInsertProjectCommand {
+  assertProjectBuildingSnapshot(building);
+  return {
+    schemaVersion: projectLocationStructureCommandSchemaVersion,
+    type: projectBuildingInsertCommandType,
+    payload: { building },
+  };
+}
+
+export function createProjectBuildingDeleteProjectCommand(
+  building: ProjectBuildingSnapshot
+): ProjectBuildingDeleteProjectCommand {
+  assertProjectBuildingSnapshot(building);
+  return {
+    schemaVersion: projectLocationStructureCommandSchemaVersion,
+    type: projectBuildingDeleteCommandType,
+    payload: { building },
+  };
+}
+
+export function createProjectBuildingUpdateProjectCommand(
+  expected: ProjectBuildingSnapshot,
+  target: ProjectBuildingSnapshot
+): ProjectBuildingUpdateProjectCommand {
+  assertMatchingBuildingUpdate(expected, target);
+  return {
+    schemaVersion: projectLocationStructureCommandSchemaVersion,
+    type: projectBuildingUpdateCommandType,
+    payload: { expected, target },
+  };
+}
+
 export function createProjectFloorInsertProjectCommand(
   floor: ProjectFloorSnapshot
 ): ProjectFloorInsertProjectCommand {
   assertProjectFloorSnapshot(floor);
   return {
-    schemaVersion: projectLocationStructureCommandSchemaVersion,
+    schemaVersion: projectFloorCommandSchemaVersion,
     type: projectFloorInsertCommandType,
     payload: { floor },
   };
@@ -136,7 +268,7 @@ export function createProjectFloorDeleteProjectCommand(
 ): ProjectFloorDeleteProjectCommand {
   assertProjectFloorSnapshot(floor);
   return {
-    schemaVersion: projectLocationStructureCommandSchemaVersion,
+    schemaVersion: projectFloorCommandSchemaVersion,
     type: projectFloorDeleteCommandType,
     payload: { floor },
   };
@@ -170,7 +302,7 @@ export function createProjectFloorUpdateProjectCommand(
 ): ProjectFloorUpdateProjectCommand {
   assertMatchingFloorUpdate(expected, target);
   return {
-    schemaVersion: projectLocationStructureCommandSchemaVersion,
+    schemaVersion: projectFloorCommandSchemaVersion,
     type: projectFloorUpdateCommandType,
     payload: { expected, target },
   };
@@ -188,9 +320,43 @@ export function createProjectRoomUpdateProjectCommand(
   };
 }
 
+export function assertProjectBuildingInsertProjectCommand(
+  command: SerializedProjectCommand<unknown>
+): asserts command is ProjectBuildingInsertProjectCommand {
+  assertProjectBuildingStructureProjectCommand(
+    command,
+    projectBuildingInsertCommandType
+  );
+}
+
+export function assertProjectBuildingDeleteProjectCommand(
+  command: SerializedProjectCommand<unknown>
+): asserts command is ProjectBuildingDeleteProjectCommand {
+  assertProjectBuildingStructureProjectCommand(
+    command,
+    projectBuildingDeleteCommandType
+  );
+}
+
+export function assertProjectBuildingUpdateProjectCommand(
+  command: SerializedProjectCommand<unknown>
+): asserts command is ProjectBuildingUpdateProjectCommand {
+  if (
+    command.schemaVersion !== projectLocationStructureCommandSchemaVersion ||
+    command.type !== projectBuildingUpdateCommandType ||
+    !isPlainObject(command.payload) ||
+    Object.keys(command.payload).length !== 2
+  ) {
+    throw new Error("Unsupported project-building update command.");
+  }
+  assertMatchingBuildingUpdate(command.payload.expected, command.payload.target);
+}
+
 export function assertProjectFloorInsertProjectCommand(
   command: SerializedProjectCommand<unknown>
-): asserts command is ProjectFloorInsertProjectCommand {
+): asserts command is
+  | ProjectFloorInsertProjectCommand
+  | LegacyProjectFloorInsertProjectCommand {
   assertProjectFloorStructureProjectCommand(
     command,
     projectFloorInsertCommandType
@@ -199,7 +365,9 @@ export function assertProjectFloorInsertProjectCommand(
 
 export function assertProjectFloorDeleteProjectCommand(
   command: SerializedProjectCommand<unknown>
-): asserts command is ProjectFloorDeleteProjectCommand {
+): asserts command is
+  | ProjectFloorDeleteProjectCommand
+  | LegacyProjectFloorDeleteProjectCommand {
   assertProjectFloorStructureProjectCommand(
     command,
     projectFloorDeleteCommandType
@@ -226,15 +394,26 @@ export function assertProjectRoomDeleteProjectCommand(
 
 export function assertProjectFloorUpdateProjectCommand(
   command: SerializedProjectCommand<unknown>
-): asserts command is ProjectFloorUpdateProjectCommand {
+): asserts command is
+  | ProjectFloorUpdateProjectCommand
+  | LegacyProjectFloorUpdateProjectCommand {
   if (
-    command.schemaVersion !== projectLocationStructureCommandSchemaVersion ||
     command.type !== projectFloorUpdateCommandType ||
     !isPlainObject(command.payload) ||
     Object.keys(command.payload).length !== 2
   ) {
     throw new Error("Unsupported project-floor update command.");
   }
+  if (command.schemaVersion === legacyProjectFloorCommandSchemaVersion) {
+    assertMatchingFloorUpdate(
+      upgradeLegacyFloorSnapshot(command.payload.expected),
+      upgradeLegacyFloorSnapshot(command.payload.target)
+    );
+    return;
+  }
+  if (command.schemaVersion !== projectFloorCommandSchemaVersion) {
+    throw new Error("Unsupported project-floor update command.");
+  }
   assertMatchingFloorUpdate(command.payload.expected, command.payload.target);
 }
 
@@ -252,6 +431,68 @@ export function assertProjectRoomUpdateProjectCommand(
   assertMatchingRoomUpdate(command.payload.expected, command.payload.target);
 }
 
+/**
+ * Upgrades a (validated) floor command of any supported version to the
+ * current version. Version 1 commands predate buildings; their floors had no
+ * building, so `buildingId` becomes null.
+ */
+export function upgradeProjectFloorCommand(
+  command:
+    | ProjectFloorInsertProjectCommand
+    | LegacyProjectFloorInsertProjectCommand
+): ProjectFloorInsertProjectCommand;
+export function upgradeProjectFloorCommand(
+  command:
+    | ProjectFloorDeleteProjectCommand
+    | LegacyProjectFloorDeleteProjectCommand
+): ProjectFloorDeleteProjectCommand;
+export function upgradeProjectFloorCommand(
+  command:
+    | ProjectFloorUpdateProjectCommand
+    | LegacyProjectFloorUpdateProjectCommand
+): ProjectFloorUpdateProjectCommand;
+export function upgradeProjectFloorCommand(
+  command:
+    | ProjectFloorInsertProjectCommand
+    | ProjectFloorDeleteProjectCommand
+    | ProjectFloorUpdateProjectCommand
+    | LegacyProjectFloorInsertProjectCommand
+    | LegacyProjectFloorDeleteProjectCommand
+    | LegacyProjectFloorUpdateProjectCommand
+) {
+  if (command.schemaVersion === projectFloorCommandSchemaVersion) {
+    return command;
+  }
+  switch (command.type) {
+    case projectFloorInsertCommandType:
+      return createProjectFloorInsertProjectCommand(
+        upgradeLegacyFloorSnapshot(command.payload.floor)
+      );
+    case projectFloorDeleteCommandType:
+      return createProjectFloorDeleteProjectCommand(
+        upgradeLegacyFloorSnapshot(command.payload.floor)
+      );
+    case projectFloorUpdateCommandType:
+      return createProjectFloorUpdateProjectCommand(
+        upgradeLegacyFloorSnapshot(command.payload.expected),
+        upgradeLegacyFloorSnapshot(command.payload.target)
+      );
+  }
+}
+
+function assertMatchingBuildingUpdate(expected: unknown, target: unknown) {
+  assertProjectBuildingSnapshot(expected);
+  assertProjectBuildingSnapshot(target);
+  if (
+    expected.id !== target.id ||
+    expected.projectId !== target.projectId ||
+    expected.sortOrder !== target.sortOrder ||
+    expected.name === target.name
+  ) {
+    throw new Error("Project-building update must change only the name.");
+  }
+}
+
 function assertMatchingFloorUpdate(expected: unknown, target: unknown) {
   assertProjectFloorSnapshot(expected);
   assertProjectFloorSnapshot(target);
@@ -259,9 +500,11 @@ function assertMatchingFloorUpdate(expected: unknown, target: unknown) {
     expected.id !== target.id ||
     expected.projectId !== target.projectId ||
     expected.sortOrder !== target.sortOrder ||
-    expected.name === target.name
+    (expected.name === target.name && expected.buildingId === target.buildingId)
   ) {
-    throw new Error("Project-floor update must change only the name.");
+    throw new Error(
+      "Project-floor update must change only the name or the building."
+    );
   }
 }
 
@@ -277,22 +520,49 @@ function assertMatchingRoomUpdate(expected: unknown, target: unknown) {
   }
 }
 
+export function assertProjectBuildingSnapshot(
+  building: unknown
+): asserts building is ProjectBuildingSnapshot {
+  if (!isPlainObject(building) || Object.keys(building).length !== 4) {
+    throw new Error("Project-building snapshot is invalid.");
+  }
+  assertNormalizedNonEmptyString(building.id, "building.id");
+  assertNormalizedNonEmptyString(building.projectId, "building.projectId");
+  assertNormalizedNonEmptyString(building.name, "building.name");
+  assertSortOrder(building.sortOrder, "building.sortOrder");
+}
+
 export function assertProjectFloorSnapshot(
   floor: unknown
 ): asserts floor is ProjectFloorSnapshot {
+  if (!isPlainObject(floor) || Object.keys(floor).length !== 5) {
+    throw new Error("Project-floor snapshot is invalid.");
+  }
+  assertLegacyFloorFields(floor);
+  if (floor.buildingId !== null) {
+    assertNormalizedNonEmptyString(floor.buildingId, "floor.buildingId");
+  }
+}
+
+function assertLegacyProjectFloorSnapshot(
+  floor: unknown
+): asserts floor is LegacyProjectFloorSnapshot {
   if (!isPlainObject(floor) || Object.keys(floor).length !== 4) {
     throw new Error("Project-floor snapshot is invalid.");
   }
+  assertLegacyFloorFields(floor);
+}
+
+function assertLegacyFloorFields(floor: Record<string, unknown>) {
   assertNormalizedNonEmptyString(floor.id, "floor.id");
   assertNormalizedNonEmptyString(floor.projectId, "floor.projectId");
   assertNormalizedNonEmptyString(floor.name, "floor.name");
-  if (
-    typeof floor.sortOrder !== "number" ||
-    !Number.isSafeInteger(floor.sortOrder) ||
-    floor.sortOrder < 0
-  ) {
-    throw new Error("floor.sortOrder must be a non-negative integer.");
-  }
+  assertSortOrder(floor.sortOrder, "floor.sortOrder");
+}
+
+function upgradeLegacyFloorSnapshot(floor: unknown): ProjectFloorSnapshot {
+  assertLegacyProjectFloorSnapshot(floor);
+  return { ...floor, buildingId: null };
 }
 
 export function assertProjectRoomSnapshot(
@@ -310,11 +580,11 @@ export function assertProjectRoomSnapshot(
   assertNormalizedNonEmptyString(room.roomName, "room.roomName");
 }
 
-function assertProjectFloorStructureProjectCommand(
+function assertProjectBuildingStructureProjectCommand(
   command: SerializedProjectCommand<unknown>,
   expectedType:
-    | typeof projectFloorInsertCommandType
-    | typeof projectFloorDeleteCommandType
+    | typeof projectBuildingInsertCommandType
+    | typeof projectBuildingDeleteCommandType
 ) {
   if (
     command.schemaVersion !== projectLocationStructureCommandSchemaVersion ||
@@ -322,6 +592,29 @@ function assertProjectFloorStructureProjectCommand(
     !isPlainObject(command.payload) ||
     Object.keys(command.payload).length !== 1
   ) {
+    throw new Error("Unsupported project-building structure command.");
+  }
+  assertProjectBuildingSnapshot(command.payload.building);
+}
+
+function assertProjectFloorStructureProjectCommand(
+  command: SerializedProjectCommand<unknown>,
+  expectedType:
+    | typeof projectFloorInsertCommandType
+    | typeof projectFloorDeleteCommandType
+) {
+  if (
+    command.type !== expectedType ||
+    !isPlainObject(command.payload) ||
+    Object.keys(command.payload).length !== 1
+  ) {
+    throw new Error("Unsupported project-floor structure command.");
+  }
+  if (command.schemaVersion === legacyProjectFloorCommandSchemaVersion) {
+    assertLegacyProjectFloorSnapshot(command.payload.floor);
+    return;
+  }
+  if (command.schemaVersion !== projectFloorCommandSchemaVersion) {
     throw new Error("Unsupported project-floor structure command.");
   }
   assertProjectFloorSnapshot(command.payload.floor);
@@ -344,6 +637,16 @@ function assertProjectRoomStructureProjectCommand(
   assertProjectRoomSnapshot(command.payload.room);
 }
 
+function assertSortOrder(value: unknown, field: string) {
+  if (
+    typeof value !== "number" ||
+    !Number.isSafeInteger(value) ||
+    value < 0
+  ) {
+    throw new Error(`${field} must be a non-negative integer.`);
+  }
+}
+
 function assertNormalizedNonEmptyString(
   value: unknown,
   field: string
diff --git a/src/domain/models/project-state-snapshot.model.ts b/src/domain/models/project-state-snapshot.model.ts
index 5564e1f..07db42d 100644
--- a/src/domain/models/project-state-snapshot.model.ts
+++ b/src/domain/models/project-state-snapshot.model.ts
@@ -35,7 +35,8 @@ import {
   type ExternalModelStateSnapshot,
 } from "../../external-model/domain/external-model-contracts.js";
 
-export const projectStateSnapshotSchemaVersion = 6 as const;
+export const projectStateSnapshotSchemaVersion = 7 as const;
+const coverProjectStateSnapshotSchemaVersion = 6 as const;
 const boardInfoProjectStateSnapshotSchemaVersion = 5 as const;
 const previousProjectStateSnapshotSchemaVersion = 4 as const;
 const externalModelProjectStateSnapshotSchemaVersion = 3 as const;
@@ -237,7 +238,7 @@ const projectDeviceSchema = z
   })
   .strict();
 
-const floorSchema = z
+const buildingSchema = z
   .object({
     id: idSchema,
     projectId: idSchema,
@@ -246,6 +247,19 @@ const floorSchema = z
   })
   .strict();
 
+const legacyFloorSchema = z
+  .object({
+    id: idSchema,
+    projectId: idSchema,
+    name: z.string().trim().min(1),
+    sortOrder: finiteNumberSchema,
+  })
+  .strict();
+
+const floorSchema = legacyFloorSchema
+  .extend({ buildingId: idSchema.nullable() })
+  .strict();
+
 const roomSchema = z
   .object({
     id: idSchema,
@@ -490,11 +504,24 @@ export function parseExternalModelStateSnapshot(
   return externalModelStateSchema.parse(value);
 }
 
-const projectStateSnapshotContents = {
+// Versions 1-6 have floors without a building and no building list.
+const previousProjectStateSnapshotContents = {
   circuitLists: z.array(circuitListSchema),
   circuitSections: z.array(circuitSectionSchema),
   circuits: z.array(circuitSchema),
   projectDevices: z.array(projectDeviceSchema),
+  floors: z.array(legacyFloorSchema),
+  rooms: z.array(roomSchema),
+  distributionBoardComponents: z.array(distributionBoardComponentSchema),
+  circuitProtectionDevices: z.array(circuitProtectionDeviceSchema),
+  distributionBoardComponentProtectionDevices: z.array(
+    componentProtectionDeviceSchema
+  ),
+};
+
+const projectStateSnapshotContents = {
+  ...previousProjectStateSnapshotContents,
+  buildings: z.array(buildingSchema),
   floors: z.array(floorSchema),
   rooms: z.array(roomSchema),
   distributionBoardComponents: z.array(distributionBoardComponentSchema),
@@ -515,6 +542,17 @@ export const projectStateSnapshotSchema = z
   })
   .strict();
 
+const coverProjectStateSnapshotSchema = z
+  .object({
+    schemaVersion: z.literal(coverProjectStateSnapshotSchemaVersion),
+    project: projectSchema,
+    distributionBoards: z.array(distributionBoardSchema),
+    externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
+    externalModel: externalModelStateSchema,
+    ...previousProjectStateSnapshotContents,
+  })
+  .strict();
+
 const boardInfoProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(boardInfoProjectStateSnapshotSchemaVersion),
@@ -522,7 +560,7 @@ const boardInfoProjectStateSnapshotSchema = z
     distributionBoards: z.array(legacyDistributionBoardSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
     externalModel: externalModelStateSchema,
-    ...projectStateSnapshotContents,
+    ...previousProjectStateSnapshotContents,
   })
   .strict();
 
@@ -533,7 +571,7 @@ const previousProjectStateSnapshotSchema = z
     distributionBoards: z.array(legacyDistributionBoardSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
     externalModel: externalModelStateSchema,
-    ...projectStateSnapshotContents,
+    ...previousProjectStateSnapshotContents,
   })
   .strict();
 
@@ -543,7 +581,7 @@ const externalModelProjectStateSnapshotSchema = z
     project: publicBuildingProjectSchema,
     distributionBoards: z.array(legacyDistributionBoardSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
-    ...projectStateSnapshotContents,
+    ...previousProjectStateSnapshotContents,
   })
   .strict();
 
@@ -552,7 +590,7 @@ const legacyProjectStateSnapshotSchema = z
     schemaVersion: z.literal(legacyProjectStateSnapshotSchemaVersion),
     project: publicBuildingProjectSchema,
     distributionBoards: z.array(legacyDistributionBoardSchema),
-    ...projectStateSnapshotContents,
+    ...previousProjectStateSnapshotContents,
   })
   .strict();
 
@@ -561,7 +599,7 @@ const baselineProjectStateSnapshotSchema = z
     schemaVersion: z.literal(baselineProjectStateSnapshotSchemaVersion),
     project: previousProjectSchema,
     distributionBoards: z.array(legacyDistributionBoardSchema),
-    ...projectStateSnapshotContents,
+    ...previousProjectStateSnapshotContents,
   })
   .strict();
 
@@ -595,6 +633,28 @@ export function parseProjectStateSnapshot(
 }
 
 function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
+  const cover = upgradeToCoverProjectStateSnapshot(value);
+  if (
+    cover === null ||
+    typeof cover !== "object" ||
+    Array.isArray(cover) ||
+    (cover as { schemaVersion?: unknown }).schemaVersion !==
+      coverProjectStateSnapshotSchemaVersion
+  ) {
+    return cover;
+  }
+  // Every supported version before 7 lacks buildings; its floors had no
+  // building.
+  const previous = coverProjectStateSnapshotSchema.parse(cover);
+  return {
+    ...previous,
+    schemaVersion: projectStateSnapshotSchemaVersion,
+    buildings: [],
+    floors: previous.floors.map((floor) => ({ ...floor, buildingId: null })),
+  };
+}
+
+function upgradeToCoverProjectStateSnapshot(value: unknown): unknown {
   if (
     value === null ||
     typeof value !== "object" ||
@@ -611,7 +671,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     const previous = boardInfoProjectStateSnapshotSchema.parse(value);
     return {
       ...previous,
-      schemaVersion: projectStateSnapshotSchemaVersion,
+      schemaVersion: coverProjectStateSnapshotSchemaVersion,
       project: { ...previous.project, ...emptyProjectCoverValues },
       distributionBoards: withEmptyDistributionBoardInfo(
         previous.distributionBoards
@@ -622,7 +682,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     const previous = previousProjectStateSnapshotSchema.parse(value);
     return {
       ...previous,
-      schemaVersion: projectStateSnapshotSchemaVersion,
+      schemaVersion: coverProjectStateSnapshotSchemaVersion,
       project: { ...previous.project, ...emptyProjectCoverValues },
       distributionBoards: withEmptyDistributionBoardInfo(
         previous.distributionBoards
@@ -633,7 +693,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     const previous = externalModelProjectStateSnapshotSchema.parse(value);
     return {
       ...previous,
-      schemaVersion: projectStateSnapshotSchemaVersion,
+      schemaVersion: coverProjectStateSnapshotSchemaVersion,
       project: { ...previous.project, ...emptyProjectCoverValues },
       distributionBoards: withEmptyDistributionBoardInfo(
         previous.distributionBoards
@@ -645,7 +705,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     const legacy = legacyProjectStateSnapshotSchema.parse(value);
     return {
       ...legacy,
-      schemaVersion: projectStateSnapshotSchemaVersion,
+      schemaVersion: coverProjectStateSnapshotSchemaVersion,
       project: { ...legacy.project, ...emptyProjectCoverValues },
       distributionBoards: withEmptyDistributionBoardInfo(
         legacy.distributionBoards
@@ -658,7 +718,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     const baseline = baselineProjectStateSnapshotSchema.parse(value);
     return {
       ...baseline,
-      schemaVersion: projectStateSnapshotSchemaVersion,
+      schemaVersion: coverProjectStateSnapshotSchemaVersion,
       project: {
         ...baseline.project,
         isPublicBuilding: false,
@@ -765,6 +825,7 @@ function assertProjectStateSnapshotRelations(
     snapshot.projectDevices,
     "project device"
   );
+  const buildingIds = uniqueIds(snapshot.buildings, "building");
   const floorIds = uniqueIds(snapshot.floors, "floor");
   const roomIds = uniqueIds(snapshot.rooms, "room");
   const circuitIds = uniqueIds(snapshot.circuits, "circuit");
@@ -843,8 +904,14 @@ function assertProjectStateSnapshotRelations(
       );
     }
   }
+  for (const building of snapshot.buildings) {
+    assertProjectOwnership(building.projectId, projectId, "building");
+  }
   for (const floor of snapshot.floors) {
     assertProjectOwnership(floor.projectId, projectId, "floor");
+    if (floor.buildingId !== null) {
+      assertReference(buildingIds, floor.buildingId, "floor building");
+    }
   }
   for (const room of snapshot.rooms) {
     assertProjectOwnership(room.projectId, projectId, "room");
diff --git a/src/domain/models/project-transfer.model.ts b/src/domain/models/project-transfer.model.ts
index 3f28f51..24c0a9c 100644
--- a/src/domain/models/project-transfer.model.ts
+++ b/src/domain/models/project-transfer.model.ts
@@ -84,6 +84,7 @@ export function remapProjectState(
     createId
   );
   const deviceIds = idMap(source.projectDevices, createId);
+  const buildingIds = idMap(source.buildings, createId);
   const floorIds = idMap(source.floors, createId);
   const roomIds = idMap(source.rooms, createId);
   const rowIds = new Map(
@@ -242,10 +243,19 @@ export function remapProjectState(
       id: requiredId(deviceIds, device.id),
       projectId: targetProjectId,
     })),
+    buildings: source.buildings.map((building) => ({
+      ...building,
+      id: requiredId(buildingIds, building.id),
+      projectId: targetProjectId,
+    })),
     floors: source.floors.map((floor) => ({
       ...floor,
       id: requiredId(floorIds, floor.id),
       projectId: targetProjectId,
+      buildingId:
+        floor.buildingId === null
+          ? null
+          : requiredId(buildingIds, floor.buildingId),
     })),
     rooms: source.rooms.map((room) => ({
       ...room,
diff --git a/src/domain/services/project-command.service.ts b/src/domain/services/project-command.service.ts
index bee31a3..91ee754 100644
--- a/src/domain/services/project-command.service.ts
+++ b/src/domain/services/project-command.service.ts
@@ -70,12 +70,18 @@ import {
   type SerializedProjectCommand,
 } from "../models/project-command.model.js";
 import {
+  assertProjectBuildingDeleteProjectCommand,
+  assertProjectBuildingInsertProjectCommand,
+  assertProjectBuildingUpdateProjectCommand,
   assertProjectFloorDeleteProjectCommand,
   assertProjectFloorInsertProjectCommand,
   assertProjectFloorUpdateProjectCommand,
   assertProjectRoomDeleteProjectCommand,
   assertProjectRoomInsertProjectCommand,
   assertProjectRoomUpdateProjectCommand,
+  projectBuildingDeleteCommandType,
+  projectBuildingInsertCommandType,
+  projectBuildingUpdateCommandType,
   projectFloorDeleteCommandType,
   projectFloorInsertCommandType,
   projectFloorUpdateCommandType,
@@ -492,6 +498,18 @@ export class ProjectCommandService implements ProjectCommandExecutor {
           command: input.command,
         }).revision;
       }
+      case projectBuildingInsertCommandType: {
+        assertProjectBuildingInsertProjectCommand(input.command);
+        return this.projectLocationStructureStore.execute({ ...input, command: input.command }).revision;
+      }
+      case projectBuildingDeleteCommandType: {
+        assertProjectBuildingDeleteProjectCommand(input.command);
+        return this.projectLocationStructureStore.execute({ ...input, command: input.command }).revision;
+      }
+      case projectBuildingUpdateCommandType: {
+        assertProjectBuildingUpdateProjectCommand(input.command);
+        return this.projectLocationStructureStore.execute({ ...input, command: input.command }).revision;
+      }
       case projectFloorInsertCommandType: {
         assertProjectFloorInsertProjectCommand(input.command);
         return this.projectLocationStructureStore.execute({
diff --git a/src/frontend/components/Sidebar.tsx b/src/frontend/components/Sidebar.tsx
index b3cbb4f..a94378e 100644
--- a/src/frontend/components/Sidebar.tsx
+++ b/src/frontend/components/Sidebar.tsx
@@ -7,14 +7,21 @@ import { listProjects } from "../utils/api";
 import type { ProjectDto } from "../types";
 import { ThemeToggle } from "./ThemeToggle";
 
+// Anchors on the project overview page (/projects/[id]).
 const PROJECT_SECTIONS = [
   { id: "verlauf", label: "Verlauf", icon: "↺" },
   { id: "verteilungen", label: "Verteilungen", icon: "⌁" },
-  { id: "etagen", label: "Etagen", icon: "▥" },
-  { id: "raeume", label: "Räume", icon: "⌂" },
   { id: "projektgeraete", label: "Projektgeräte", icon: "⚙" },
 ] as const;
 
+// Separate project sub-routes (/projects/[id]/<segment>).
+const PROJECT_ROUTES = [
+  { segment: "struktur", label: "Gebäudestruktur", icon: "▥" },
+] as const;
+
+// Matches the project overview and all of its sub-routes (group 2 = rest).
+const PROJECT_PATH_PATTERN = /^\/projects\/([^/]+)(\/.*)?$/;
+
 interface SidebarProps {
   isCollapsed: boolean;
   onToggleCollapsed: () => void;
@@ -22,8 +29,14 @@ interface SidebarProps {
 
 export function Sidebar({ isCollapsed, onToggleCollapsed }: SidebarProps) {
   const pathname = usePathname();
-  const projectMatch = pathname?.match(/^\/projects\/([^/]+)$/);
+  const projectMatch = pathname?.match(PROJECT_PATH_PATTERN);
   const activeProjectId = projectMatch ? projectMatch[1] : null;
+  const projectSubPath = projectMatch?.[2] ?? "";
+  // Section anchors only exist (and are observed) on the overview itself.
+  const overviewProjectId =
+    activeProjectId && (projectSubPath === "" || projectSubPath === "/")
+      ? activeProjectId
+      : null;
 
   const [projects, setProjects] = useState<ProjectDto[]>([]);
   const [activeSection, setActiveSection] = useState<string | null>(null);
@@ -42,7 +55,7 @@ export function Sidebar({ isCollapsed, onToggleCollapsed }: SidebarProps) {
   }, []);
 
   useEffect(() => {
-    if (!activeProjectId) {
+    if (!overviewProjectId) {
       setActiveSection(null);
       return;
     }
@@ -69,7 +82,7 @@ export function Sidebar({ isCollapsed, onToggleCollapsed }: SidebarProps) {
 
     elements.forEach((element) => observer.observe(element));
     return () => observer.disconnect();
-  }, [activeProjectId]);
+  }, [overviewProjectId]);
 
   return (
     <aside className={isCollapsed ? "sidebar sidebar-collapsed" : "sidebar"}>
@@ -122,17 +135,46 @@ export function Sidebar({ isCollapsed, onToggleCollapsed }: SidebarProps) {
         {activeProjectId && (
           <>
             <div className="sidebar-section-label">In diesem Projekt</div>
-            {PROJECT_SECTIONS.map(({ id, label, icon }) => (
-              <a
-                key={id}
-                href={`#${id}`}
-                className={activeSection === id ? "sidebar-link active" : "sidebar-link"}
-                title={label}
-              >
-                <span className="sidebar-icon">{icon}</span>
-                <span className="sidebar-label">{label}</span>
-              </a>
-            ))}
+            {PROJECT_SECTIONS.map(({ id, label, icon }) =>
+              overviewProjectId ? (
+                <a
+                  key={id}
+                  href={`#${id}`}
+                  className={activeSection === id ? "sidebar-link active" : "sidebar-link"}
+                  title={label}
+                >
+                  <span className="sidebar-icon">{icon}</span>
+                  <span className="sidebar-label">{label}</span>
+                </a>
+              ) : (
+                <Link
+                  key={id}
+                  href={`/projects/${activeProjectId}#${id}`}
+                  className="sidebar-link"
+                  title={label}
+                >
+                  <span className="sidebar-icon">{icon}</span>
+                  <span className="sidebar-label">{label}</span>
+                </Link>
+              )
+            )}
+            {PROJECT_ROUTES.map(({ segment, label, icon }) => {
+              const href = `/projects/${activeProjectId}/${segment}`;
+              const isActive =
+                pathname === href || Boolean(pathname?.startsWith(`${href}/`));
+              return (
+                <Link
+                  key={segment}
+                  href={href}
+                  aria-current={isActive ? "page" : undefined}
+                  className={isActive ? "sidebar-link active" : "sidebar-link"}
+                  title={label}
+                >
+                  <span className="sidebar-icon">{icon}</span>
+                  <span className="sidebar-label">{label}</span>
+                </Link>
+              );
+            })}
           </>
         )}
       </nav>
diff --git a/src/frontend/components/floor-select-options.tsx b/src/frontend/components/floor-select-options.tsx
new file mode 100644
index 0000000..bfaa2f6
--- /dev/null
+++ b/src/frontend/components/floor-select-options.tsx
@@ -0,0 +1,49 @@
+"use client";
+
+import React from "react";
+import type { BuildingDto, FloorDto } from "../types";
+import { groupFloorsByBuilding } from "../utils/building-structure";
+
+export type FloorOption = Pick<FloorDto, "id" | "name"> & {
+  buildingId?: string | null;
+};
+
+interface FloorSelectOptionsProps {
+  buildings?: ReadonlyArray<Pick<BuildingDto, "id" | "name">>;
+  floors: ReadonlyArray<FloorOption>;
+}
+
+/**
+ * Floor <option>s for a <select>, grouped by building via <optgroup> as soon
+ * as the project has buildings. The caller renders its own empty option
+ * ("Ohne Etage") before these.
+ */
+export function FloorSelectOptions({
+  buildings = [],
+  floors,
+}: FloorSelectOptionsProps) {
+  if (!buildings.length) {
+    return (
+      <>
+        {floors.map((floor) => (
+          <option key={floor.id} value={floor.id}>
+            {floor.name}
+          </option>
+        ))}
+      </>
+    );
+  }
+  return (
+    <>
+      {groupFloorsByBuilding(floors, buildings).map((group) => (
+        <optgroup key={group.buildingId ?? "unassigned"} label={group.label}>
+          {group.floors.map((floor) => (
+            <option key={floor.id} value={floor.id}>
+              {floor.name}
+            </option>
+          ))}
+        </optgroup>
+      ))}
+    </>
+  );
+}
diff --git a/src/frontend/components/room-modal.tsx b/src/frontend/components/room-modal.tsx
index e5648e0..eabeedd 100644
--- a/src/frontend/components/room-modal.tsx
+++ b/src/frontend/components/room-modal.tsx
@@ -1,11 +1,14 @@
 "use client";
 
 import React, { type FormEvent, useState } from "react";
-import type { CreateRoomInput, FloorDto, RoomDto } from "../types";
+import type { BuildingDto, CreateRoomInput, RoomDto } from "../types";
+import { FloorSelectOptions, type FloorOption } from "./floor-select-options";
 import { FormModal } from "./form-modal";
 
 interface RoomModalProps {
-  floors: FloorDto[];
+  /** When given, the floor select groups floors by building. */
+  buildings?: ReadonlyArray<Pick<BuildingDto, "id" | "name">>;
+  floors: ReadonlyArray<FloorOption>;
   initialRoom?: RoomDto;
   initialValues?: Partial<CreateRoomInput>;
   isSaving: boolean;
@@ -15,6 +18,7 @@ interface RoomModalProps {
 }
 
 export function RoomModal({
+  buildings,
   floors,
   initialRoom,
   initialValues,
@@ -83,7 +87,7 @@ export function RoomModal({
             value={floorId}
           >
             <option value="">Ohne Etage</option>
-            {floors.map((floor) => <option key={floor.id} value={floor.id}>{floor.name}</option>)}
+            <FloorSelectOptions buildings={buildings} floors={floors} />
           </select>
         </div>
       </div>
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 49bb77f..5c14f5e 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -226,11 +226,24 @@ export interface CircuitListDto {
   name: string;
 }
 
+export interface BuildingDto {
+  id: string;
+  projectId: string;
+  name: string;
+  sortOrder: number;
+}
+
+export interface ProjectBuildingCommandResultDto
+  extends ProjectCommandResultDto {
+  building: BuildingDto;
+}
+
 export interface FloorDto {
   id: string;
   projectId: string;
   name: string;
   sortOrder: number;
+  buildingId: string | null;
 }
 
 export interface ProjectFloorCommandResultDto
@@ -288,8 +301,14 @@ export interface ProjectDeviceCommandResultDto
   projectDevice: ProjectDeviceDto;
 }
 
+export interface CreateBuildingInput {
+  name: string;
+}
+
 export interface CreateFloorInput {
   name: string;
+  /** Omitted = keep the current assignment on update; null = no building. */
+  buildingId?: string | null;
 }
 
 export interface CreateRoomInput {
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index d55a915..e1f4608 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -1,5 +1,7 @@
 import type {
+  BuildingDto,
   CircuitListDto,
+  CreateBuildingInput,
   CreateFloorInput,
   CreateProjectDeviceInput,
   CreateRoomInput,
@@ -17,6 +19,7 @@ import type {
   ProjectCommandResultDto,
   ProjectDeviceCommandResultDto,
   ProjectDeviceDto,
+  ProjectBuildingCommandResultDto,
   ProjectFloorCommandResultDto,
   ProjectHistoryStateDto,
   ProjectRevisionPageDto,
@@ -881,6 +884,61 @@ export function renumberCircuitSectionCommand(
   );
 }
 
+export function listBuildings(projectId: string) {
+  return request<BuildingDto[]>(`/api/projects/${projectId}/buildings`);
+}
+
+export function createBuilding(
+  projectId: string,
+  input: CreateBuildingInput,
+  expectedRevision: number
+) {
+  return request<ProjectBuildingCommandResultDto>(
+    `/api/projects/${projectId}/buildings`,
+    {
+      method: "POST",
+      body: JSON.stringify({ name: input.name, expectedRevision }),
+    }
+  );
+}
+
+export function updateBuilding(
+  projectId: string,
+  buildingId: string,
+  input: CreateBuildingInput,
+  expectedRevision: number
+) {
+  return request<ProjectBuildingCommandResultDto>(
+    `/api/projects/${projectId}/buildings/${buildingId}`,
+    {
+      method: "PUT",
+      body: JSON.stringify({ name: input.name, expectedRevision }),
+    }
+  );
+}
+
+export function deleteBuilding(
+  projectId: string,
+  buildingId: string,
+  expectedRevision: number
+) {
+  return request<ProjectCommandResultDto>(
+    `/api/projects/${projectId}/buildings/${buildingId}`,
+    {
+      method: "DELETE",
+      body: JSON.stringify({ expectedRevision }),
+    }
+  );
+}
+
+// buildingId is only sent when the caller passes it (string or null);
+// an omitted buildingId keeps the current assignment on update.
+function toFloorRequestBody(input: CreateFloorInput, expectedRevision: number) {
+  return input.buildingId === undefined
+    ? { name: input.name, expectedRevision }
+    : { name: input.name, buildingId: input.buildingId, expectedRevision };
+}
+
 export function listFloors(projectId: string) {
   return request<FloorDto[]>(`/api/projects/${projectId}/floors`);
 }
@@ -894,7 +952,7 @@ export function createFloor(
     `/api/projects/${projectId}/floors`,
     {
       method: "POST",
-      body: JSON.stringify({ ...input, expectedRevision }),
+      body: JSON.stringify(toFloorRequestBody(input, expectedRevision)),
     }
   );
 }
@@ -907,7 +965,7 @@ export function updateFloor(
 ) {
   return request<ProjectFloorCommandResultDto>(`/api/projects/${projectId}/floors/${floorId}`, {
     method: "PUT",
-    body: JSON.stringify({ ...input, expectedRevision }),
+    body: JSON.stringify(toFloorRequestBody(input, expectedRevision)),
   });
 }
 
diff --git a/src/frontend/utils/building-structure.ts b/src/frontend/utils/building-structure.ts
new file mode 100644
index 0000000..0c9d6ab
--- /dev/null
+++ b/src/frontend/utils/building-structure.ts
@@ -0,0 +1,284 @@
+// Pure selection, filtering and grouping rules for the building structure
+// view (Gebäude → Etagen → Räume) and grouped floor selects.
+import type { BuildingDto, FloorDto, RoomDto } from "../types";
+
+/** Selection key for "Alle" in the building and floor columns. */
+export const ALL_SELECTION = "__all__";
+/** Selection key for "Ohne Gebäude" / "Ohne Etage". */
+export const UNASSIGNED_SELECTION = "__unassigned__";
+
+/** ALL_SELECTION, UNASSIGNED_SELECTION or a building/floor id. */
+export type StructureSelection = string;
+
+export const UNASSIGNED_BUILDING_LABEL = "Ohne Gebäude";
+export const UNASSIGNED_FLOOR_LABEL = "Ohne Etage";
+
+type BuildingLike = Pick<BuildingDto, "id" | "name">;
+type FloorLike = Pick<FloorDto, "id" | "name"> & {
+  buildingId?: string | null;
+};
+type RoomLike = Pick<RoomDto, "floorId">;
+
+export interface FloorGroup<TFloor extends FloorLike = FloorLike> {
+  /** null for floors without (known) building. */
+  buildingId: string | null;
+  label: string;
+  floors: TFloor[];
+}
+
+/**
+ * The building a floor belongs to, or null when it has none or references a
+ * building that is not (or no longer) loaded.
+ */
+export function resolveFloorBuildingId(
+  floor: FloorLike,
+  buildingIds: ReadonlySet<string>
+): string | null {
+  const buildingId = floor.buildingId ?? null;
+  return buildingId !== null && buildingIds.has(buildingId)
+    ? buildingId
+    : null;
+}
+
+function toIdSet(entries: ReadonlyArray<{ id: string }>) {
+  return new Set(entries.map((entry) => entry.id));
+}
+
+export function hasFloorsWithoutBuilding(
+  floors: ReadonlyArray<FloorLike>,
+  buildings: ReadonlyArray<BuildingLike>
+): boolean {
+  const buildingIds = toIdSet(buildings);
+  return floors.some(
+    (floor) => resolveFloorBuildingId(floor, buildingIds) === null
+  );
+}
+
+export function hasRoomsWithoutFloor(
+  rooms: ReadonlyArray<RoomLike>,
+  floors: ReadonlyArray<FloorLike>
+): boolean {
+  const floorIds = toIdSet(floors);
+  return rooms.some(
+    (room) => room.floorId === null || !floorIds.has(room.floorId)
+  );
+}
+
+/**
+ * Groups floors by building in building order; floors without a known
+ * building come last under "Ohne Gebäude". Empty groups are omitted and the
+ * floor order inside a group is preserved.
+ */
+export function groupFloorsByBuilding<TFloor extends FloorLike>(
+  floors: ReadonlyArray<TFloor>,
+  buildings: ReadonlyArray<BuildingLike>
+): FloorGroup<TFloor>[] {
+  const buildingIds = toIdSet(buildings);
+  const floorsByBuilding = new Map<string | null, TFloor[]>();
+  for (const floor of floors) {
+    const buildingId = resolveFloorBuildingId(floor, buildingIds);
+    const group = floorsByBuilding.get(buildingId) ?? [];
+    group.push(floor);
+    floorsByBuilding.set(buildingId, group);
+  }
+  const groups: FloorGroup<TFloor>[] = [];
+  for (const building of buildings) {
+    const groupFloors = floorsByBuilding.get(building.id);
+    if (groupFloors?.length) {
+      groups.push({
+        buildingId: building.id,
+        label: building.name,
+        floors: groupFloors,
+      });
+    }
+  }
+  const unassigned = floorsByBuilding.get(null);
+  if (unassigned?.length) {
+    groups.push({
+      buildingId: null,
+      label: UNASSIGNED_BUILDING_LABEL,
+      floors: unassigned,
+    });
+  }
+  return groups;
+}
+
+/** Floors shown in the floor column for a building selection. */
+export function filterFloorsByBuilding<TFloor extends FloorLike>(
+  floors: ReadonlyArray<TFloor>,
+  buildings: ReadonlyArray<BuildingLike>,
+  buildingSelection: StructureSelection
+): TFloor[] {
+  if (buildingSelection === ALL_SELECTION) {
+    return [...floors];
+  }
+  const buildingIds = toIdSet(buildings);
+  const targetBuildingId =
+    buildingSelection === UNASSIGNED_SELECTION ? null : buildingSelection;
+  return floors.filter(
+    (floor) => resolveFloorBuildingId(floor, buildingIds) === targetBuildingId
+  );
+}
+
+/**
+ * "Ohne Etage" is offered only when rooms without floor exist and the
+ * building selection can contain them ("Alle" or "Ohne Gebäude"), because a
+ * room without floor has no building either.
+ */
+export function showsRoomsWithoutFloorEntry(
+  rooms: ReadonlyArray<RoomLike>,
+  floors: ReadonlyArray<FloorLike>,
+  buildingSelection: StructureSelection
+): boolean {
+  return (
+    (buildingSelection === ALL_SELECTION ||
+      buildingSelection === UNASSIGNED_SELECTION) &&
+    hasRoomsWithoutFloor(rooms, floors)
+  );
+}
+
+/** Rooms shown in the room column for the current selections. */
+export function filterRooms<TRoom extends RoomLike>(
+  rooms: ReadonlyArray<TRoom>,
+  floors: ReadonlyArray<FloorLike>,
+  buildings: ReadonlyArray<BuildingLike>,
+  buildingSelection: StructureSelection,
+  floorSelection: StructureSelection
+): TRoom[] {
+  const floorIds = toIdSet(floors);
+  const isWithoutFloor = (room: RoomLike) =>
+    room.floorId === null || !floorIds.has(room.floorId);
+
+  if (floorSelection === UNASSIGNED_SELECTION) {
+    return showsRoomsWithoutFloorEntry(rooms, floors, buildingSelection)
+      ? rooms.filter(isWithoutFloor)
+      : [];
+  }
+  if (floorSelection !== ALL_SELECTION) {
+    return rooms.filter((room) => room.floorId === floorSelection);
+  }
+  if (buildingSelection === ALL_SELECTION) {
+    return [...rooms];
+  }
+  const visibleFloorIds = toIdSet(
+    filterFloorsByBuilding(floors, buildings, buildingSelection)
+  );
+  return rooms.filter(
+    (room) =>
+      (room.floorId !== null && visibleFloorIds.has(room.floorId)) ||
+      (buildingSelection === UNASSIGNED_SELECTION && isWithoutFloor(room))
+  );
+}
+
+/** Falls back to "Alle" when a selected building vanished. */
+export function normalizeBuildingSelection(
+  selection: StructureSelection,
+  floors: ReadonlyArray<FloorLike>,
+  buildings: ReadonlyArray<BuildingLike>
+): StructureSelection {
+  if (selection === ALL_SELECTION) {
+    return selection;
+  }
+  if (selection === UNASSIGNED_SELECTION) {
+    return hasFloorsWithoutBuilding(floors, buildings)
+      ? selection
+      : ALL_SELECTION;
+  }
+  return buildings.some((building) => building.id === selection)
+    ? selection
+    : ALL_SELECTION;
+}
+
+/** Falls back to "Alle" when a selected floor is no longer visible. */
+export function normalizeFloorSelection(
+  selection: StructureSelection,
+  rooms: ReadonlyArray<RoomLike>,
+  floors: ReadonlyArray<FloorLike>,
+  buildings: ReadonlyArray<BuildingLike>,
+  buildingSelection: StructureSelection
+): StructureSelection {
+  if (selection === ALL_SELECTION) {
+    return selection;
+  }
+  if (selection === UNASSIGNED_SELECTION) {
+    return showsRoomsWithoutFloorEntry(rooms, floors, buildingSelection)
+      ? selection
+      : ALL_SELECTION;
+  }
+  return filterFloorsByBuilding(floors, buildings, buildingSelection).some(
+    (floor) => floor.id === selection
+  )
+    ? selection
+    : ALL_SELECTION;
+}
+
+/** Building preselected in the floor dialog ("" = Ohne Gebäude). */
+export function defaultBuildingIdForNewFloor(
+  buildingSelection: StructureSelection
+): string {
+  return buildingSelection === ALL_SELECTION ||
+    buildingSelection === UNASSIGNED_SELECTION
+    ? ""
+    : buildingSelection;
+}
+
+/** Floor preselected in the room dialog ("" = Ohne Etage). */
+export function defaultFloorIdForNewRoom(
+  floorSelection: StructureSelection
+): string {
+  return floorSelection === ALL_SELECTION ||
+    floorSelection === UNASSIGNED_SELECTION
+    ? ""
+    : floorSelection;
+}
+
+export function countFloorsByBuilding(
+  floors: ReadonlyArray<FloorLike>,
+  buildings: ReadonlyArray<BuildingLike>
+): Map<string | null, number> {
+  const buildingIds = toIdSet(buildings);
+  const counts = new Map<string | null, number>();
+  for (const floor of floors) {
+    const buildingId = resolveFloorBuildingId(floor, buildingIds);
+    counts.set(buildingId, (counts.get(buildingId) ?? 0) + 1);
+  }
+  return counts;
+}
+
+/** Room counts per floor id; rooms without known floor count under null. */
+export function countRoomsByFloor(
+  rooms: ReadonlyArray<RoomLike>,
+  floors: ReadonlyArray<FloorLike>
+): Map<string | null, number> {
+  const floorIds = toIdSet(floors);
+  const counts = new Map<string | null, number>();
+  for (const room of rooms) {
+    const floorId =
+      room.floorId !== null && floorIds.has(room.floorId)
+        ? room.floorId
+        : null;
+    counts.set(floorId, (counts.get(floorId) ?? 0) + 1);
+  }
+  return counts;
+}
+
+/** "EG · Haus A", "EG" (floor without building) or "Ohne Etage". */
+export function describeRoomLocation(
+  room: RoomLike,
+  floors: ReadonlyArray<FloorLike>,
+  buildings: ReadonlyArray<BuildingLike>
+): string {
+  const floor =
+    room.floorId === null
+      ? undefined
+      : floors.find((entry) => entry.id === room.floorId);
+  if (!floor) {
+    return UNASSIGNED_FLOOR_LABEL;
+  }
+  const buildingId = resolveFloorBuildingId(floor, toIdSet(buildings));
+  const building =
+    buildingId === null
+      ? undefined
+      : buildings.find((entry) => entry.id === buildingId);
+  return building ? `${floor.name} · ${building.name}` : floor.name;
+}
diff --git a/src/frontend/utils/project-version-history.ts b/src/frontend/utils/project-version-history.ts
index 5685b29..a2880ec 100644
--- a/src/frontend/utils/project-version-history.ts
+++ b/src/frontend/utils/project-version-history.ts
@@ -46,6 +46,9 @@ const commandTypeLabels: Record<string, string> = {
   "circuit.move-group": "Stromkreis in andere Gruppe verschoben",
   "circuit-group.delete-subtree": "Stromkreisgruppe vollständig entfernt",
   "circuit-group.restore-subtree": "Stromkreisgruppe vollständig wiederhergestellt",
+  "project-building.insert": "Gebäude angelegt",
+  "project-building.update": "Gebäude bearbeitet",
+  "project-building.delete": "Gebäude entfernt",
   "project-floor.insert": "Geschoss angelegt",
   "project-floor.update": "Geschoss bearbeitet",
   "project-floor.delete": "Geschoss entfernt",
diff --git a/src/server/composition/application-repositories.ts b/src/server/composition/application-repositories.ts
index 944c843..4f9b5ee 100644
--- a/src/server/composition/application-repositories.ts
+++ b/src/server/composition/application-repositories.ts
@@ -6,6 +6,7 @@ import { CircuitRepository } from "../../db/repositories/circuit.repository.js";
 import { CircuitProtectionDeviceRepository } from "../../db/repositories/circuit-protection-device.repository.js";
 import { DistributionBoardComponentRepository } from "../../db/repositories/distribution-board-component.repository.js";
 import { DistributionBoardRepository } from "../../db/repositories/distribution-board.repository.js";
+import { BuildingRepository } from "../../db/repositories/building.repository.js";
 import { FloorRepository } from "../../db/repositories/floor.repository.js";
 import { GlobalDeviceRepository } from "../../db/repositories/global-device.repository.js";
 import { ProjectDeviceRepository } from "../../db/repositories/project-device.repository.js";
@@ -26,6 +27,7 @@ export const distributionBoardComponentRepository =
   new DistributionBoardComponentRepository(db);
 export const distributionBoardRepository =
   new DistributionBoardRepository(db);
+export const buildingRepository = new BuildingRepository(db);
 export const floorRepository = new FloorRepository(db);
 export const globalDeviceRepository = new GlobalDeviceRepository(db);
 export const projectDeviceRepository = new ProjectDeviceRepository(db);
diff --git a/src/server/controllers/building.controller.ts b/src/server/controllers/building.controller.ts
new file mode 100644
index 0000000..3a49120
--- /dev/null
+++ b/src/server/controllers/building.controller.ts
@@ -0,0 +1,111 @@
+import type { Request, Response } from "express";
+import {
+  createProjectBuildingDeleteProjectCommand,
+  createProjectBuildingInsertProjectCommand,
+  createProjectBuildingSnapshot,
+  createProjectBuildingUpdateProjectCommand,
+} from "../../domain/models/project-location-structure-project-command.model.js";
+import {
+  createBuildingSchema,
+  deleteProjectLocationSchema,
+  updateBuildingSchema,
+} from "../../shared/validation/project-structure.schemas.js";
+import { projectCommandService } from "../composition/project-command-stores.js";
+import { buildingRepository } from "../composition/application-repositories.js";
+import { respondWithProjectCommandError } from "./project-command.controller.js";
+
+export async function listBuildingsByProject(req: Request, res: Response) {
+  const { projectId } = req.params;
+  if (typeof projectId !== "string") {
+    return res.status(400).json({ error: "Invalid projectId" });
+  }
+
+  const result = await buildingRepository.listByProject(projectId);
+  return res.json(result);
+}
+
+export async function createBuilding(req: Request, res: Response) {
+  const { projectId } = req.params;
+  if (typeof projectId !== "string") {
+    return res.status(400).json({ error: "Invalid projectId" });
+  }
+
+  const parsed = createBuildingSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+
+  const existingBuildings = await buildingRepository.listByProject(projectId);
+  const nextSortOrder = existingBuildings.length
+    ? Math.max(...existingBuildings.map((building) => building.sortOrder)) + 1
+    : 0;
+  const building = createProjectBuildingSnapshot(
+    projectId,
+    parsed.data.name,
+    nextSortOrder
+  );
+  try {
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision: parsed.data.expectedRevision,
+      description: "Gebäude anlegen",
+      command: createProjectBuildingInsertProjectCommand(building),
+    });
+    return res.status(201).json({ ...result, building });
+  } catch (error) {
+    return respondWithProjectCommandError(error, res);
+  }
+}
+
+export async function updateBuilding(req: Request, res: Response) {
+  const { projectId, buildingId } = req.params;
+  if (typeof projectId !== "string" || typeof buildingId !== "string") {
+    return res.status(400).json({ error: "Invalid parameters" });
+  }
+  const parsed = updateBuildingSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+  const current = await buildingRepository.findById(projectId, buildingId);
+  if (!current) {
+    return res.status(404).json({ error: "Building not found" });
+  }
+  const target = { ...current, name: parsed.data.name };
+  try {
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision: parsed.data.expectedRevision,
+      description: "Gebäude bearbeiten",
+      command: createProjectBuildingUpdateProjectCommand(current, target),
+    });
+    return res.json({ ...result, building: target });
+  } catch (error) {
+    return respondWithProjectCommandError(error, res);
+  }
+}
+
+export async function deleteBuilding(req: Request, res: Response) {
+  const { projectId, buildingId } = req.params;
+  if (typeof projectId !== "string" || typeof buildingId !== "string") {
+    return res.status(400).json({ error: "Invalid parameters" });
+  }
+  const parsed = deleteProjectLocationSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+  const current = await buildingRepository.findById(projectId, buildingId);
+  if (!current) {
+    return res.status(404).json({ error: "Building not found" });
+  }
+  try {
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision: parsed.data.expectedRevision,
+      description: "Gebäude löschen",
+      command: createProjectBuildingDeleteProjectCommand(current),
+    });
+    return res.json(result);
+  } catch (error) {
+    return respondWithProjectCommandError(error, res);
+  }
+}
diff --git a/src/server/controllers/floor.controller.ts b/src/server/controllers/floor.controller.ts
index 085aa10..b000db3 100644
--- a/src/server/controllers/floor.controller.ts
+++ b/src/server/controllers/floor.controller.ts
@@ -42,7 +42,8 @@ export async function createFloor(req: Request, res: Response) {
   const floor = createProjectFloorSnapshot(
     projectId,
     parsed.data.name,
-    nextSortOrder
+    nextSortOrder,
+    parsed.data.buildingId ?? null
   );
   try {
     const result = projectCommandService.executeUser({
@@ -70,7 +71,14 @@ export async function updateFloor(req: Request, res: Response) {
   if (!current) {
     return res.status(404).json({ error: "Floor not found" });
   }
-  const target = { ...current, name: parsed.data.name };
+  const target = {
+    ...current,
+    name: parsed.data.name,
+    buildingId:
+      parsed.data.buildingId === undefined
+        ? current.buildingId
+        : parsed.data.buildingId,
+  };
   try {
     const result = projectCommandService.executeUser({
       projectId,
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index 8801784..0b61255 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -13,6 +13,12 @@ import {
   updateDistributionBoard,
 } from "../controllers/distribution-board.controller.js";
 import { listCircuitListsByProject } from "../controllers/circuit-list.controller.js";
+import {
+  createBuilding,
+  deleteBuilding,
+  listBuildingsByProject,
+  updateBuilding,
+} from "../controllers/building.controller.js";
 import { createFloor, deleteFloor, listFloorsByProject, updateFloor } from "../controllers/floor.controller.js";
 import { createRoom, deleteRoom, listRoomsByProject, updateRoom } from "../controllers/room.controller.js";
 import { getCircuitTree } from "../controllers/circuit-tree.controller.js";
@@ -100,6 +106,10 @@ projectRouter.get(
   "/:projectId/circuit-sections/:sectionId/next-identifier",
   getNextCircuitIdentifier
 );
+projectRouter.get("/:projectId/buildings", listBuildingsByProject);
+projectRouter.post("/:projectId/buildings", createBuilding);
+projectRouter.put("/:projectId/buildings/:buildingId", updateBuilding);
+projectRouter.delete("/:projectId/buildings/:buildingId", deleteBuilding);
 projectRouter.get("/:projectId/floors", listFloorsByProject);
 projectRouter.post("/:projectId/floors", createFloor);
 projectRouter.put("/:projectId/floors/:floorId", updateFloor);
diff --git a/src/shared/validation/project-structure.schemas.ts b/src/shared/validation/project-structure.schemas.ts
index 143be0a..5ab13bf 100644
--- a/src/shared/validation/project-structure.schemas.ts
+++ b/src/shared/validation/project-structure.schemas.ts
@@ -102,10 +102,22 @@ export const deleteDistributionBoardSchema = z
   })
   .strict();
 
+export const createBuildingSchema = z
+  .object({
+    expectedRevision: expectedProjectRevisionSchema,
+    name: z.string().trim().min(1).max(200),
+  })
+  .strict();
+
+export const updateBuildingSchema = createBuildingSchema;
+
+// A missing buildingId keeps the current value (older clients send only the
+// name); null removes the floor from its building.
 export const createFloorSchema = z
   .object({
     expectedRevision: expectedProjectRevisionSchema,
     name: z.string().trim().min(1).max(200),
+    buildingId: z.string().trim().min(1).nullable().optional(),
   })
   .strict();
 
diff --git a/tests/building-structure-frontend-api.test.ts b/tests/building-structure-frontend-api.test.ts
new file mode 100644
index 0000000..9e23150
--- /dev/null
+++ b/tests/building-structure-frontend-api.test.ts
@@ -0,0 +1,100 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  createBuilding,
+  createFloor,
+  deleteBuilding,
+  listBuildings,
+  updateBuilding,
+  updateFloor,
+} from "../src/frontend/utils/api.js";
+
+describe("building structure frontend API", () => {
+  it("sends building commands and optional floor building assignments", async () => {
+    const requests: Array<{ url: string; method: string; body: unknown }> = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+      requests.push({
+        url: String(input),
+        method: init?.method ?? "GET",
+        body: init?.body === undefined ? undefined : JSON.parse(String(init.body)),
+      });
+      return new Response(JSON.stringify([]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    };
+    try {
+      await listBuildings("project-1");
+      await createBuilding("project-1", { name: "Haus A" }, 3);
+      await updateBuilding("project-1", "building-1", { name: "Haus B" }, 4);
+      await deleteBuilding("project-1", "building-1", 5);
+      await createFloor(
+        "project-1",
+        { name: "EG", buildingId: "building-1" },
+        6
+      );
+      await createFloor("project-1", { name: "Dach", buildingId: null }, 7);
+      await createFloor("project-1", { name: "UG", buildingId: undefined }, 8);
+      await updateFloor(
+        "project-1",
+        "floor-1",
+        { name: "1. OG", buildingId: null },
+        9
+      );
+      await updateFloor("project-1", "floor-1", { name: "2. OG" }, 10);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+
+    assert.deepEqual(requests, [
+      {
+        url: "/api/projects/project-1/buildings",
+        method: "GET",
+        body: undefined,
+      },
+      {
+        url: "/api/projects/project-1/buildings",
+        method: "POST",
+        body: { name: "Haus A", expectedRevision: 3 },
+      },
+      {
+        url: "/api/projects/project-1/buildings/building-1",
+        method: "PUT",
+        body: { name: "Haus B", expectedRevision: 4 },
+      },
+      {
+        url: "/api/projects/project-1/buildings/building-1",
+        method: "DELETE",
+        body: { expectedRevision: 5 },
+      },
+      {
+        url: "/api/projects/project-1/floors",
+        method: "POST",
+        body: { name: "EG", buildingId: "building-1", expectedRevision: 6 },
+      },
+      {
+        url: "/api/projects/project-1/floors",
+        method: "POST",
+        body: { name: "Dach", buildingId: null, expectedRevision: 7 },
+      },
+      {
+        url: "/api/projects/project-1/floors",
+        method: "POST",
+        body: { name: "UG", expectedRevision: 8 },
+      },
+      {
+        url: "/api/projects/project-1/floors/floor-1",
+        method: "PUT",
+        body: { name: "1. OG", buildingId: null, expectedRevision: 9 },
+      },
+      {
+        url: "/api/projects/project-1/floors/floor-1",
+        method: "PUT",
+        body: { name: "2. OG", expectedRevision: 10 },
+      },
+    ]);
+    const updateWithoutBuilding = requests[8].body as Record<string, unknown>;
+    assert.equal("buildingId" in updateWithoutBuilding, false);
+  });
+});
diff --git a/tests/building-structure-view.test.ts b/tests/building-structure-view.test.ts
new file mode 100644
index 0000000..59271af
--- /dev/null
+++ b/tests/building-structure-view.test.ts
@@ -0,0 +1,284 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+  BuildingDto,
+  FloorDto,
+  RoomDto,
+} from "../src/frontend/types.js";
+import {
+  ALL_SELECTION,
+  UNASSIGNED_SELECTION,
+  countFloorsByBuilding,
+  countRoomsByFloor,
+  defaultBuildingIdForNewFloor,
+  defaultFloorIdForNewRoom,
+  describeRoomLocation,
+  filterFloorsByBuilding,
+  filterRooms,
+  groupFloorsByBuilding,
+  hasFloorsWithoutBuilding,
+  hasRoomsWithoutFloor,
+  normalizeBuildingSelection,
+  normalizeFloorSelection,
+  showsRoomsWithoutFloorEntry,
+} from "../src/frontend/utils/building-structure.js";
+
+function building(id: string, name: string, sortOrder: number): BuildingDto {
+  return { id, projectId: "project-1", name, sortOrder };
+}
+
+function floor(
+  id: string,
+  name: string,
+  buildingId: string | null,
+  sortOrder = 0
+): FloorDto {
+  return { id, projectId: "project-1", name, sortOrder, buildingId };
+}
+
+function room(id: string, floorId: string | null, roomNumber = id): RoomDto {
+  return {
+    id,
+    projectId: "project-1",
+    floorId,
+    roomNumber,
+    roomName: `Raum ${roomNumber}`,
+  };
+}
+
+const buildings = [building("b-a", "Haus A", 0), building("b-b", "Haus B", 1)];
+const floors = [
+  floor("f-free", "Außenanlage", null, 0),
+  floor("f-a-eg", "EG", "b-a", 1),
+  floor("f-b-eg", "EG", "b-b", 2),
+  floor("f-a-og", "1. OG", "b-a", 3),
+  floor("f-orphan", "Keller", "b-deleted", 4),
+];
+const rooms = [
+  room("r-a-eg", "f-a-eg"),
+  room("r-a-og", "f-a-og"),
+  room("r-b-eg", "f-b-eg"),
+  room("r-free", "f-free"),
+  room("r-orphan-floor", "f-orphan"),
+  room("r-none", null),
+  room("r-missing-floor", "f-deleted"),
+];
+
+const ids = (entries: ReadonlyArray<{ id: string }>) =>
+  entries.map((entry) => entry.id);
+
+describe("building structure view", () => {
+  it("groups floors in building order and puts unassigned floors last", () => {
+    const groups = groupFloorsByBuilding(floors, buildings);
+    assert.deepEqual(
+      groups.map((group) => ({
+        buildingId: group.buildingId,
+        label: group.label,
+        floors: ids(group.floors),
+      })),
+      [
+        { buildingId: "b-a", label: "Haus A", floors: ["f-a-eg", "f-a-og"] },
+        { buildingId: "b-b", label: "Haus B", floors: ["f-b-eg"] },
+        {
+          buildingId: null,
+          label: "Ohne Gebäude",
+          floors: ["f-free", "f-orphan"],
+        },
+      ]
+    );
+  });
+
+  it("omits empty groups", () => {
+    const groups = groupFloorsByBuilding(
+      [floor("f-1", "EG", "b-b")],
+      buildings
+    );
+    assert.deepEqual(
+      groups.map((group) => group.buildingId),
+      ["b-b"]
+    );
+    assert.deepEqual(groupFloorsByBuilding([], buildings), []);
+  });
+
+  it("filters floors by building selection", () => {
+    assert.deepEqual(
+      ids(filterFloorsByBuilding(floors, buildings, ALL_SELECTION)),
+      ids(floors)
+    );
+    assert.deepEqual(
+      ids(filterFloorsByBuilding(floors, buildings, "b-a")),
+      ["f-a-eg", "f-a-og"]
+    );
+    assert.deepEqual(
+      ids(filterFloorsByBuilding(floors, buildings, UNASSIGNED_SELECTION)),
+      ["f-free", "f-orphan"]
+    );
+  });
+
+  it("detects floors without building and rooms without floor", () => {
+    assert.equal(hasFloorsWithoutBuilding(floors, buildings), true);
+    assert.equal(
+      hasFloorsWithoutBuilding([floor("f-1", "EG", "b-a")], buildings),
+      false
+    );
+    assert.equal(hasRoomsWithoutFloor(rooms, floors), true);
+    assert.equal(hasRoomsWithoutFloor([room("r-1", "f-a-eg")], floors), false);
+  });
+
+  it("filters rooms for building and floor selections", () => {
+    assert.deepEqual(
+      ids(filterRooms(rooms, floors, buildings, ALL_SELECTION, ALL_SELECTION)),
+      ids(rooms)
+    );
+    assert.deepEqual(
+      ids(filterRooms(rooms, floors, buildings, "b-a", ALL_SELECTION)),
+      ["r-a-eg", "r-a-og"]
+    );
+    assert.deepEqual(
+      ids(filterRooms(rooms, floors, buildings, "b-a", "f-a-og")),
+      ["r-a-og"]
+    );
+    assert.deepEqual(
+      ids(filterRooms(rooms, floors, buildings, ALL_SELECTION, "f-b-eg")),
+      ["r-b-eg"]
+    );
+    assert.deepEqual(
+      ids(
+        filterRooms(
+          rooms,
+          floors,
+          buildings,
+          UNASSIGNED_SELECTION,
+          ALL_SELECTION
+        )
+      ),
+      ["r-free", "r-orphan-floor", "r-none", "r-missing-floor"]
+    );
+    assert.deepEqual(
+      ids(
+        filterRooms(
+          rooms,
+          floors,
+          buildings,
+          ALL_SELECTION,
+          UNASSIGNED_SELECTION
+        )
+      ),
+      ["r-none", "r-missing-floor"]
+    );
+    assert.deepEqual(
+      ids(filterRooms(rooms, floors, buildings, "b-a", UNASSIGNED_SELECTION)),
+      []
+    );
+  });
+
+  it("offers 'Ohne Etage' only where rooms without floor can belong", () => {
+    assert.equal(showsRoomsWithoutFloorEntry(rooms, floors, ALL_SELECTION), true);
+    assert.equal(
+      showsRoomsWithoutFloorEntry(rooms, floors, UNASSIGNED_SELECTION),
+      true
+    );
+    assert.equal(showsRoomsWithoutFloorEntry(rooms, floors, "b-a"), false);
+    assert.equal(
+      showsRoomsWithoutFloorEntry([room("r-1", "f-a-eg")], floors, ALL_SELECTION),
+      false
+    );
+  });
+
+  it("falls back to 'Alle' for vanished or hidden selections", () => {
+    assert.equal(normalizeBuildingSelection("b-a", floors, buildings), "b-a");
+    assert.equal(
+      normalizeBuildingSelection("b-deleted", floors, buildings),
+      ALL_SELECTION
+    );
+    assert.equal(
+      normalizeBuildingSelection(UNASSIGNED_SELECTION, floors, buildings),
+      UNASSIGNED_SELECTION
+    );
+    assert.equal(
+      normalizeBuildingSelection(
+        UNASSIGNED_SELECTION,
+        [floor("f-1", "EG", "b-a")],
+        buildings
+      ),
+      ALL_SELECTION
+    );
+
+    assert.equal(
+      normalizeFloorSelection("f-a-og", rooms, floors, buildings, "b-a"),
+      "f-a-og"
+    );
+    assert.equal(
+      normalizeFloorSelection("f-b-eg", rooms, floors, buildings, "b-a"),
+      ALL_SELECTION
+    );
+    assert.equal(
+      normalizeFloorSelection("f-deleted", rooms, floors, buildings, ALL_SELECTION),
+      ALL_SELECTION
+    );
+    assert.equal(
+      normalizeFloorSelection(
+        UNASSIGNED_SELECTION,
+        rooms,
+        floors,
+        buildings,
+        ALL_SELECTION
+      ),
+      UNASSIGNED_SELECTION
+    );
+    assert.equal(
+      normalizeFloorSelection(UNASSIGNED_SELECTION, rooms, floors, buildings, "b-a"),
+      ALL_SELECTION
+    );
+  });
+
+  it("preselects the selected building and floor for new entries", () => {
+    assert.equal(defaultBuildingIdForNewFloor("b-a"), "b-a");
+    assert.equal(defaultBuildingIdForNewFloor(ALL_SELECTION), "");
+    assert.equal(defaultBuildingIdForNewFloor(UNASSIGNED_SELECTION), "");
+    assert.equal(defaultFloorIdForNewRoom("f-a-eg"), "f-a-eg");
+    assert.equal(defaultFloorIdForNewRoom(ALL_SELECTION), "");
+    assert.equal(defaultFloorIdForNewRoom(UNASSIGNED_SELECTION), "");
+  });
+
+  it("counts floors per building and rooms per floor", () => {
+    assert.deepEqual(
+      [...countFloorsByBuilding(floors, buildings)],
+      [
+        [null, 2],
+        ["b-a", 2],
+        ["b-b", 1],
+      ]
+    );
+    assert.deepEqual(
+      [...countRoomsByFloor(rooms, floors)],
+      [
+        ["f-a-eg", 1],
+        ["f-a-og", 1],
+        ["f-b-eg", 1],
+        ["f-free", 1],
+        ["f-orphan", 1],
+        [null, 2],
+      ]
+    );
+  });
+
+  it("describes a room location with floor and building", () => {
+    assert.equal(
+      describeRoomLocation(room("r", "f-a-og"), floors, buildings),
+      "1. OG · Haus A"
+    );
+    assert.equal(
+      describeRoomLocation(room("r", "f-free"), floors, buildings),
+      "Außenanlage"
+    );
+    assert.equal(
+      describeRoomLocation(room("r", "f-orphan"), floors, buildings),
+      "Keller"
+    );
+    assert.equal(
+      describeRoomLocation(room("r", null), floors, buildings),
+      "Ohne Etage"
+    );
+  });
+});
diff --git a/tests/project-building-structure.test.ts b/tests/project-building-structure.test.ts
new file mode 100644
index 0000000..2c9ccdf
--- /dev/null
+++ b/tests/project-building-structure.test.ts
@@ -0,0 +1,305 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { eq } from "drizzle-orm";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import {
+  createDatabaseContext,
+  type DatabaseContext,
+} from "../src/db/database-context.js";
+import { ProjectHistoryRepository } from "../src/db/repositories/project-history.repository.js";
+import { ProjectLocationStructureProjectCommandRepository } from "../src/db/repositories/project-location-structure-project-command.repository.js";
+import { buildings } from "../src/db/schema/buildings.js";
+import { floors } from "../src/db/schema/floors.js";
+import { projects } from "../src/db/schema/projects.js";
+import {
+  assertProjectFloorInsertProjectCommand,
+  createProjectBuildingDeleteProjectCommand,
+  createProjectBuildingInsertProjectCommand,
+  createProjectBuildingSnapshot,
+  createProjectBuildingUpdateProjectCommand,
+  createProjectFloorInsertProjectCommand,
+  createProjectFloorSnapshot,
+  createProjectFloorUpdateProjectCommand,
+  projectFloorCommandSchemaVersion,
+  type ProjectLocationStructureProjectCommand,
+} from "../src/domain/models/project-location-structure-project-command.model.js";
+import {
+  createBuildingSchema,
+  createFloorSchema,
+  updateFloorSchema,
+} from "../src/shared/validation/project-structure.schemas.js";
+
+function createTestDatabase(): DatabaseContext {
+  const context = createDatabaseContext(":memory:");
+  migrate(context.db, {
+    migrationsFolder: path.resolve("src", "db", "migrations"),
+  });
+  context.db
+    .insert(projects)
+    .values([
+      { id: "project-1", name: "Test project" },
+      { id: "project-2", name: "Foreign project" },
+    ])
+    .run();
+  return context;
+}
+
+/** Executes a user command and returns a runner for its undo and redo. */
+function createRunner(context: DatabaseContext) {
+  const repository = new ProjectLocationStructureProjectCommandRepository(
+    context.db
+  );
+  const history = new ProjectHistoryRepository(context.db);
+  let revision = 0;
+  const run = (
+    command: ProjectLocationStructureProjectCommand,
+    source: "user" | "undo" | "redo" = "user"
+  ) => {
+    const step =
+      source === "user" ? null : history.getNextCommand("project-1", source);
+    if (source !== "user") {
+      assert.ok(step);
+    }
+    const result = repository.execute({
+      projectId: "project-1",
+      expectedRevision: revision,
+      source,
+      historyTargetChangeSetId: step?.changeSetId,
+      command,
+    });
+    revision += 1;
+    return result;
+  };
+  return { repository, run };
+}
+
+function getBuilding(context: DatabaseContext, id: string) {
+  return context.db.select().from(buildings).where(eq(buildings.id, id)).get();
+}
+
+function getFloor(context: DatabaseContext, id: string) {
+  return context.db.select().from(floors).where(eq(floors.id, id)).get();
+}
+
+describe("project building structure", () => {
+  it("creates, renames and deletes buildings with persisted undo and redo", () => {
+    const context = createTestDatabase();
+    try {
+      const { run } = createRunner(context);
+      const building = createProjectBuildingSnapshot("project-1", " Haus A ", 0);
+      assert.equal(building.name, "Haus A");
+
+      const insert = createProjectBuildingInsertProjectCommand(building);
+      const inserted = run(insert);
+      assert.deepEqual(getBuilding(context, building.id), building);
+
+      const renamed = { ...building, name: "Haus B" };
+      const update = createProjectBuildingUpdateProjectCommand(building, renamed);
+      const updated = run(update);
+      assert.equal(getBuilding(context, building.id)?.name, "Haus B");
+
+      run(updated.inverse, "undo");
+      assert.deepEqual(getBuilding(context, building.id), building);
+      run(inserted.inverse, "undo");
+      assert.equal(getBuilding(context, building.id), undefined);
+      run(insert, "redo");
+      run(update, "redo");
+      assert.deepEqual(getBuilding(context, building.id), renamed);
+
+      const deleted = run(createProjectBuildingDeleteProjectCommand(renamed));
+      assert.equal(getBuilding(context, building.id), undefined);
+      run(deleted.inverse, "undo");
+      assert.deepEqual(getBuilding(context, building.id), renamed);
+    } finally {
+      context.close();
+    }
+  });
+
+  it("assigns floors to buildings and blocks deleting a building in use", () => {
+    const context = createTestDatabase();
+    try {
+      const { run } = createRunner(context);
+      const houseA = createProjectBuildingSnapshot("project-1", "Haus A", 0);
+      const houseB = createProjectBuildingSnapshot("project-1", "Haus B", 1);
+      run(createProjectBuildingInsertProjectCommand(houseA));
+      run(createProjectBuildingInsertProjectCommand(houseB));
+
+      const floor = createProjectFloorSnapshot("project-1", "EG", 0, houseA.id);
+      const floorInsert = createProjectFloorInsertProjectCommand(floor);
+      assert.equal(floorInsert.schemaVersion, projectFloorCommandSchemaVersion);
+      run(floorInsert);
+      assert.deepEqual(getFloor(context, floor.id), floor);
+
+      const moved = { ...floor, buildingId: houseB.id };
+      const moveCommand = createProjectFloorUpdateProjectCommand(floor, moved);
+      const movedResult = run(moveCommand);
+      assert.equal(getFloor(context, floor.id)?.buildingId, houseB.id);
+
+      assert.throws(
+        () => run(createProjectBuildingDeleteProjectCommand(houseB)),
+        /solange Etagen zugeordnet/
+      );
+      assert.ok(getBuilding(context, houseB.id));
+
+      run(movedResult.inverse, "undo");
+      assert.equal(getFloor(context, floor.id)?.buildingId, houseA.id);
+      run(moveCommand, "redo");
+      assert.equal(getFloor(context, floor.id)?.buildingId, houseB.id);
+
+      const unassigned = { ...moved, buildingId: null };
+      run(createProjectFloorUpdateProjectCommand(moved, unassigned));
+      assert.equal(getFloor(context, floor.id)?.buildingId, null);
+      run(createProjectBuildingDeleteProjectCommand(houseB));
+      assert.equal(getBuilding(context, houseB.id), undefined);
+    } finally {
+      context.close();
+    }
+  });
+
+  it("rejects floors that reference a missing or foreign building", () => {
+    const context = createTestDatabase();
+    try {
+      const { run } = createRunner(context);
+      context.db
+        .insert(buildings)
+        .values({ id: "foreign", projectId: "project-2", name: "Fremd", sortOrder: 0 })
+        .run();
+      assert.throws(
+        () =>
+          run(
+            createProjectFloorInsertProjectCommand(
+              createProjectFloorSnapshot("project-1", "EG", 0, "foreign")
+            )
+          ),
+        /foreign building/
+      );
+      assert.throws(
+        () =>
+          run(
+            createProjectFloorInsertProjectCommand(
+              createProjectFloorSnapshot("project-1", "EG", 0, "missing")
+            )
+          ),
+        /foreign building/
+      );
+      assert.equal(context.db.select().from(floors).all().length, 0);
+
+      const floor = createProjectFloorSnapshot("project-1", "EG", 0);
+      run(createProjectFloorInsertProjectCommand(floor));
+      assert.throws(
+        () =>
+          run(
+            createProjectFloorUpdateProjectCommand(floor, {
+              ...floor,
+              buildingId: "foreign",
+            })
+          ),
+        /foreign building/
+      );
+      assert.throws(
+        () => createProjectFloorUpdateProjectCommand(floor, { ...floor }),
+        /only the name or the building/
+      );
+      assert.throws(
+        () =>
+          createProjectFloorUpdateProjectCommand(floor, {
+            ...floor,
+            sortOrder: 5,
+            name: "Erdgeschoss",
+          }),
+        /only the name or the building/
+      );
+    } finally {
+      context.close();
+    }
+  });
+
+  it("executes version 1 floor commands recorded before buildings existed", () => {
+    const context = createTestDatabase();
+    try {
+      const { run } = createRunner(context);
+      const legacyFloor = {
+        id: "floor-legacy",
+        projectId: "project-1",
+        name: "EG",
+        sortOrder: 0,
+      };
+      const legacyInsert = {
+        schemaVersion: 1 as const,
+        type: "project-floor.insert" as const,
+        payload: { floor: legacyFloor },
+      };
+      assertProjectFloorInsertProjectCommand(legacyInsert);
+      const inserted = run(legacyInsert);
+      assert.deepEqual(getFloor(context, legacyFloor.id), {
+        ...legacyFloor,
+        buildingId: null,
+      });
+      // The inverse is always written in the current version.
+      assert.equal(inserted.inverse.schemaVersion, projectFloorCommandSchemaVersion);
+
+      const legacyUpdate = {
+        schemaVersion: 1 as const,
+        type: "project-floor.update" as const,
+        payload: {
+          expected: legacyFloor,
+          target: { ...legacyFloor, name: "Erdgeschoss" },
+        },
+      };
+      const updated = run(legacyUpdate);
+      assert.equal(getFloor(context, legacyFloor.id)?.name, "Erdgeschoss");
+      run(updated.inverse, "undo");
+      assert.equal(getFloor(context, legacyFloor.id)?.name, "EG");
+
+      // A version 1 snapshot must not carry buildingId, a version 2 one must.
+      assert.throws(() =>
+        assertProjectFloorInsertProjectCommand({
+          schemaVersion: 1,
+          type: "project-floor.insert",
+          payload: { floor: { ...legacyFloor, buildingId: null } },
+        })
+      );
+      assert.throws(() =>
+        assertProjectFloorInsertProjectCommand({
+          schemaVersion: 2,
+          type: "project-floor.insert",
+          payload: { floor: legacyFloor },
+        })
+      );
+    } finally {
+      context.close();
+    }
+  });
+
+  it("validates building and floor requests", () => {
+    assert.equal(
+      createBuildingSchema.safeParse({ expectedRevision: 0, name: "Haus A" }).success,
+      true
+    );
+    assert.equal(
+      createBuildingSchema.safeParse({ expectedRevision: 0, name: " " }).success,
+      false
+    );
+    assert.equal(
+      createBuildingSchema.safeParse({
+        expectedRevision: 0,
+        name: "Haus A",
+        sortOrder: 1,
+      }).success,
+      false
+    );
+    for (const buildingId of [undefined, null, "building-1"]) {
+      assert.equal(
+        createFloorSchema.safeParse({ expectedRevision: 0, name: "EG", buildingId })
+          .success,
+        true
+      );
+    }
+    assert.equal(
+      updateFloorSchema.safeParse({ expectedRevision: 0, name: "EG", buildingId: "" })
+        .success,
+      false
+    );
+  });
+});
diff --git a/tests/project-command.service.test.ts b/tests/project-command.service.test.ts
index 861edcd..5630cb8 100644
--- a/tests/project-command.service.test.ts
+++ b/tests/project-command.service.test.ts
@@ -41,6 +41,7 @@ import { projectChangeSets } from "../src/db/schema/project-change-sets.js";
 import { projectDevices } from "../src/db/schema/project-devices.js";
 import { projectRevisions } from "../src/db/schema/project-revisions.js";
 import { projects } from "../src/db/schema/projects.js";
+import { buildings } from "../src/db/schema/buildings.js";
 import { floors } from "../src/db/schema/floors.js";
 import { rooms } from "../src/db/schema/rooms.js";
 import { externalCsvConfigurations } from "../src/db/schema/external-csv-configurations.js";
@@ -78,6 +79,8 @@ import {
   createDistributionBoardComponentUpdateProjectCommand,
 } from "../src/domain/models/distribution-board-component-structure-project-command.model.js";
 import {
+  createProjectBuildingInsertProjectCommand,
+  createProjectBuildingSnapshot,
   createProjectFloorInsertProjectCommand,
   createProjectFloorSnapshot,
   createProjectRoomInsertProjectCommand,
@@ -1610,6 +1613,43 @@ describe("project command service", () => {
     }
   });
 
+  it("dispatches building commands and floor assignments with persisted inverses", () => {
+    const context = createTestDatabase();
+    try {
+      const service = createService(context);
+      const building = createProjectBuildingSnapshot("project-1", "Haus A", 0);
+      service.executeUser({
+        projectId: "project-1",
+        expectedRevision: 0,
+        command: createProjectBuildingInsertProjectCommand(building),
+      });
+      const floor = createProjectFloorSnapshot("project-1", "EG", 0, building.id);
+      const created = service.executeUser({
+        projectId: "project-1",
+        expectedRevision: 1,
+        command: createProjectFloorInsertProjectCommand(floor),
+      });
+      assert.equal(created.history.currentRevision, 2);
+      assert.equal(
+        context.db.select().from(floors).where(eq(floors.id, floor.id)).get()
+          ?.buildingId,
+        building.id
+      );
+
+      createService(context).undo({ projectId: "project-1", expectedRevision: 2 });
+      createService(context).undo({ projectId: "project-1", expectedRevision: 3 });
+      assert.equal(context.db.select().from(buildings).all().length, 0);
+      createService(context).redo({ projectId: "project-1", expectedRevision: 4 });
+      createService(context).redo({ projectId: "project-1", expectedRevision: 5 });
+      assert.deepEqual(
+        context.db.select().from(floors).where(eq(floors.id, floor.id)).get(),
+        floor
+      );
+    } finally {
+      context.close();
+    }
+  });
+
   it("dispatches floor and room setup with their persisted inverses", () => {
     const context = createTestDatabase();
     try {
diff --git a/tests/project-snapshot.repository.test.ts b/tests/project-snapshot.repository.test.ts
index 449864a..0ed798d 100644
--- a/tests/project-snapshot.repository.test.ts
+++ b/tests/project-snapshot.repository.test.ts
@@ -20,6 +20,7 @@ import { circuits } from "../src/db/schema/circuits.js";
 import { distributionBoardComponentProtectionDevices } from "../src/db/schema/distribution-board-component-protection-devices.js";
 import { distributionBoardComponents } from "../src/db/schema/distribution-board-components.js";
 import { distributionBoards } from "../src/db/schema/distribution-boards.js";
+import { buildings } from "../src/db/schema/buildings.js";
 import { floors } from "../src/db/schema/floors.js";
 import { projectDevices } from "../src/db/schema/project-devices.js";
 import { projectSnapshots } from "../src/db/schema/project-snapshots.js";
@@ -59,6 +60,15 @@ function createTestDatabase(): DatabaseContext {
     .where(eq(circuitSections.circuitListId, list.id))
     .get();
   assert.ok(section);
+  context.db
+    .insert(buildings)
+    .values({
+      id: "building-1",
+      projectId: "project-1",
+      name: "Haus A",
+      sortOrder: 0,
+    })
+    .run();
   context.db
     .insert(floors)
     .values({
@@ -66,6 +76,7 @@ function createTestDatabase(): DatabaseContext {
       projectId: "project-1",
       name: "EG",
       sortOrder: 10,
+      buildingId: "building-1",
     })
     .run();
   context.db
@@ -248,7 +259,9 @@ describe("project snapshot repository", () => {
         "device-1"
       );
       assert.equal(state.projectDevices.length, 1);
+      assert.equal(state.buildings.length, 1);
       assert.equal(state.floors.length, 1);
+      assert.equal(state.floors[0].buildingId, "building-1");
       assert.equal(state.rooms.length, 1);
       assert.deepEqual(repository.listByProject("project-1"), [
         created,
@@ -400,8 +413,14 @@ describe("project snapshot repository", () => {
         schemaVersion: number;
         project: Record<string, unknown>;
         distributionBoards: Array<Record<string, unknown>>;
+        buildings?: unknown;
+        floors: Array<Record<string, unknown>>;
       };
       payload.schemaVersion = 5;
+      delete payload.buildings;
+      for (const floor of payload.floors) {
+        delete floor.buildingId;
+      }
       for (const field of ["siteAddress", "workStage", "projectLead", "projectEditor"]) {
         delete payload.project[field];
       }
@@ -434,6 +453,9 @@ describe("project snapshot repository", () => {
           (board) => board.boardNumber === null && board.fedFrom === null
         )
       );
+      // Version 5 predates buildings: the upgraded state has none.
+      assert.deepEqual(targetState.buildings, []);
+      assert.ok(targetState.floors.every((floor) => floor.buildingId === null));
     } finally {
       context.close();
     }
@@ -497,6 +519,11 @@ describe("portable project transfer", () => {
         copied.state.distributionBoards[0].floorId,
         copied.state.floors[0].id
       );
+      assert.notEqual(copied.state.buildings[0].id, "building-1");
+      assert.equal(
+        copied.state.floors[0].buildingId,
+        copied.state.buildings[0].id
+      );
       assert.equal(
         copied.state.distributionBoards[0].supplyType,
         "SV"
diff --git a/tests/project-state-snapshot.test.ts b/tests/project-state-snapshot.test.ts
index 04d4901..c75555f 100644
--- a/tests/project-state-snapshot.test.ts
+++ b/tests/project-state-snapshot.test.ts
@@ -8,10 +8,22 @@ import {
 } from "../src/domain/models/project-state-snapshot.model.js";
 import { createNamedProjectSnapshotSchema } from "../src/shared/validation/project-snapshot.schemas.js";
 
-/** Removes the fields introduced by snapshot schema version 6. */
-function withoutVersionSixFields<
-  T extends { project: object; distributionBoards: object[] },
+/** Removes the fields introduced by snapshot schema version 7. */
+function withoutVersionSevenFields<
+  T extends { floors: object[] },
 >(snapshot: T): T {
+  delete (snapshot as Record<string, unknown>).buildings;
+  for (const floor of snapshot.floors) {
+    delete (floor as Record<string, unknown>).buildingId;
+  }
+  return snapshot;
+}
+
+/** Removes the fields introduced by snapshot schema versions 6 and 7. */
+function withoutVersionSixFields<
+  T extends { project: object; distributionBoards: object[]; floors: object[] },
+>(snapshot: T): T {
+  withoutVersionSevenFields(snapshot);
   const project = snapshot.project as Record<string, unknown>;
   for (const field of ["siteAddress", "workStage", "projectLead", "projectEditor"]) {
     delete project[field];
@@ -66,7 +78,19 @@ function minimalSnapshot() {
     distributionBoardComponentProtectionDevices: [],
     circuits: [],
     projectDevices: [],
-    floors: [],
+    buildings: [] as Array<{
+      id: string;
+      projectId: string;
+      name: string;
+      sortOrder: number;
+    }>,
+    floors: [] as Array<{
+      id: string;
+      projectId: string;
+      name: string;
+      sortOrder: number;
+      buildingId: string | null;
+    }>,
     rooms: [],
   };
 }
@@ -306,7 +330,10 @@ describe("project state snapshot model", () => {
     delete (outdated.project as Record<string, unknown>).description;
     assert.throws(() => parseProjectStateSnapshot(outdated));
     assert.throws(() =>
-      parseProjectStateSnapshot({ ...minimalSnapshot(), schemaVersion: 7 })
+      parseProjectStateSnapshot({
+        ...minimalSnapshot(),
+        schemaVersion: projectStateSnapshotSchemaVersion + 1,
+      })
     );
   });
 
@@ -355,12 +382,99 @@ describe("project state snapshot model", () => {
       projectId: "project-2",
       name: "EG",
       sortOrder: 10,
+      buildingId: null,
     });
     assert.throws(
       () => parseProjectStateSnapshot(wrongOwner),
       /floor belongs to a different project/
     );
   });
+
+  it("keeps buildings and validates floor building references", () => {
+    const snapshot = minimalSnapshot();
+    snapshot.buildings.push({
+      id: "building-1",
+      projectId: "project-1",
+      name: "Haus A",
+      sortOrder: 0,
+    });
+    snapshot.floors.push(
+      {
+        id: "floor-1",
+        projectId: "project-1",
+        name: "EG",
+        sortOrder: 0,
+        buildingId: "building-1",
+      },
+      {
+        id: "floor-2",
+        projectId: "project-1",
+        name: "Keller",
+        sortOrder: 1,
+        buildingId: null,
+      }
+    );
+    const parsed = deserializeProjectStateSnapshot(
+      serializeProjectStateSnapshot(parseProjectStateSnapshot(snapshot))
+    );
+    assert.deepEqual(parsed.buildings, snapshot.buildings);
+    assert.deepEqual(
+      parsed.floors.map((floor) => floor.buildingId),
+      ["building-1", null]
+    );
+
+    const unknownBuilding = structuredClone(snapshot);
+    unknownBuilding.floors[0]!.buildingId = "building-x";
+    assert.throws(
+      () => parseProjectStateSnapshot(unknownBuilding),
+      /floor building/
+    );
+
+    const foreignBuilding = structuredClone(snapshot);
+    foreignBuilding.buildings[0]!.projectId = "project-2";
+    assert.throws(
+      () => parseProjectStateSnapshot(foreignBuilding),
+      /building belongs to a different project/
+    );
+
+    const floorWithoutBuildingField = structuredClone(snapshot);
+    delete (floorWithoutBuildingField.floors[1] as Record<string, unknown>)
+      .buildingId;
+    assert.throws(() => parseProjectStateSnapshot(floorWithoutBuildingField));
+  });
+
+  it("upgrades snapshot version 6 without buildings", () => {
+    const snapshot = minimalSnapshot();
+    snapshot.floors.push({
+      id: "floor-1",
+      projectId: "project-1",
+      name: "EG",
+      sortOrder: 0,
+      buildingId: null,
+    });
+    const previous = withoutVersionSevenFields(structuredClone(snapshot));
+    previous.schemaVersion = 6 as typeof previous.schemaVersion;
+
+    const upgraded = parseProjectStateSnapshot(previous);
+
+    assert.equal(upgraded.schemaVersion, projectStateSnapshotSchemaVersion);
+    assert.deepEqual(upgraded.buildings, []);
+    assert.deepEqual(upgraded.floors, [
+      {
+        id: "floor-1",
+        projectId: "project-1",
+        name: "EG",
+        sortOrder: 0,
+        buildingId: null,
+      },
+    ]);
+    // Version 6 cover values survive the upgrade.
+    assert.equal(upgraded.project.workStage, "LPH 5");
+
+    const mislabeled = structuredClone(snapshot);
+    mislabeled.schemaVersion = 6 as typeof mislabeled.schemaVersion;
+    assert.throws(() => parseProjectStateSnapshot(mislabeled));
+  });
 });
 
 describe("named project snapshot request", () => {

From ead01fe5bd910dbb76c977a679d1f5e906dbb036 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 12:53:24 +0200
Subject: [PATCH 16/60] Keep card markup and map shadow-sm to the card shadow

Removing the shadow-sm classes touched the page markup of the project
overview, which other branches change as well. The card rule now sets
Bootstrap's --bs-box-shadow-sm to the card shadow instead, so cards with
and without shadow-sm look the same and the pages stay as they are on main.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                       |  5 +++--
 src/app/globals.css                             | 17 ++++++++++-------
 src/app/projects/[projectId]/page.tsx           |  8 ++++----
 src/app/projects/page.tsx                       |  6 +++---
 .../components/project-version-history.tsx      |  2 +-
 5 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index a5641e9..bb3f10d 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -172,8 +172,9 @@ Support Ctrl+Plus and Ctrl+Shift+Plus for insertion.
 Bootstrap may be used for the general application UI, such as navigation, page layout, buttons, forms, cards, alerts and modals.
 
 Cards follow the PM app look: 1px border all around, 16px radius and the
-soft shadow defined on `.card` in `globals.css` (own dark-mode value). Do
-not add Bootstrap `shadow-*` classes or a colored top border to cards.
+soft shadow defined on `.card` in `globals.css` (own dark-mode value). The
+`.card` rule maps Bootstrap's `shadow-sm` to the same shadow; do not add other
+`shadow-*` classes or a colored top border to cards.
 
 Do not use Bootstrap as the core table/grid framework for the circuit list editor.
 
diff --git a/src/app/globals.css b/src/app/globals.css
index b51d98d..721f991 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -434,21 +434,24 @@ a.kpi:hover {
 /* Flächen-Look wie in der PM-App (Vorbild grow-monitor): gleichmäßiger
    1-px-Rahmen statt farbigem Balken an der Oberkante, größerer Radius und ein
    weicher Streuschatten mit feiner heller Innenkante oben. Der Akzent kommt
-   über Kopfzeile und Inhalt, nicht über die Kante. Karten tragen deshalb keine
-   Bootstrap-Klasse shadow-*, die den Schatten mit !important überschreiben
-   würde. */
+   über Kopfzeile und Inhalt, nicht über die Kante. Bootstraps shadow-sm
+   setzt box-shadow mit !important aus --bs-box-shadow-sm; die Karte legt diese
+   Variable auf denselben Schatten, damit Karten mit und ohne shadow-sm gleich
+   aussehen. */
 .card {
-  --bs-card-border-radius: 16px;
-  --bs-card-border-color: var(--color-border);
-  box-shadow:
+  --lb-card-shadow:
     0 4px 24px var(--shadow-soft),
     0 1px 0 rgba(255, 255, 255, 0.7) inset;
+  --bs-box-shadow-sm: var(--lb-card-shadow);
+  --bs-card-border-radius: 16px;
+  --bs-card-border-color: var(--color-border);
+  box-shadow: var(--lb-card-shadow);
 }
 
 /* Auf dunklem Grund ein kräftigerer Streuschatten und nur eine schwache
    Innenkante, sonst wirkt sie wie ein harter weißer Strich. */
 :root[data-bs-theme="dark"] .card {
-  box-shadow:
+  --lb-card-shadow:
     0 4px 24px rgba(0, 0, 0, 0.4),
     0 1px 0 rgba(255, 255, 255, 0.05) inset;
 }
diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index f352536..fa342ea 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -904,7 +904,7 @@ export default function ProjectDetailPage() {
         ) : null}
 
         <section className="col-12" id="verteilungen">
-          <div className="card">
+          <div className="card shadow-sm">
             <div className="card-header d-flex justify-content-between align-items-center">
               <div>
                 <span>Verteilungen</span>
@@ -997,7 +997,7 @@ export default function ProjectDetailPage() {
         </section>
 
         <section className="col-12 col-lg-5" id="etagen">
-          <div className="card h-100">
+          <div className="card shadow-sm h-100">
             <div className="card-header d-flex justify-content-between align-items-center">
               <div>
                 <span>Etagen</span>
@@ -1028,7 +1028,7 @@ export default function ProjectDetailPage() {
         </section>
 
         <section className="col-12 col-lg-7" id="raeume">
-          <div className="card">
+          <div className="card shadow-sm">
             <div className="card-header d-flex justify-content-between align-items-center">
               <div>
                 <span>Räume</span>
@@ -1079,7 +1079,7 @@ export default function ProjectDetailPage() {
         </section>
       </div>
 
-      <section className="card mt-4" id="projektgeraete">
+      <section className="card shadow-sm mt-4" id="projektgeraete">
         <div className="card-header d-flex flex-wrap justify-content-between align-items-center gap-2">
           <div>
             <span>Projektgeräte</span>
diff --git a/src/app/projects/page.tsx b/src/app/projects/page.tsx
index 4d8b7bd..21409fd 100644
--- a/src/app/projects/page.tsx
+++ b/src/app/projects/page.tsx
@@ -238,7 +238,7 @@ export default function ProjectsPage() {
       {error ? <div className="alert alert-warning">{error}</div> : null}
 
       <div className="d-flex flex-column gap-4">
-        <section className="card">
+        <section className="card shadow-sm">
           <div className="card-header">Neues Projekt</div>
           <div className="card-body" style={{ maxWidth: 480 }}>
             <form className="vstack gap-3" onSubmit={handleCreateProject}>
@@ -271,7 +271,7 @@ export default function ProjectsPage() {
           </div>
         </section>
 
-        <section className="card">
+        <section className="card shadow-sm">
           <div className="card-header">Projekt importieren</div>
           <div className="card-body" style={{ maxWidth: 480 }}>
             <p className="text-secondary small">
@@ -326,7 +326,7 @@ export default function ProjectsPage() {
           </div>
         </section>
 
-        <section className="card">
+        <section className="card shadow-sm">
           <div className="card-header">Globale Geräte / Verbraucher</div>
         <div className="card-body border-bottom">
           <form className="row g-2" onSubmit={handleCreateGlobalDevice}>
diff --git a/src/frontend/components/project-version-history.tsx b/src/frontend/components/project-version-history.tsx
index 2ce4105..3907640 100644
--- a/src/frontend/components/project-version-history.tsx
+++ b/src/frontend/components/project-version-history.tsx
@@ -227,7 +227,7 @@ export function ProjectVersionHistory({
     history?.currentRevision === currentRevision;
 
   return (
-    <section className="card">
+    <section className="card shadow-sm">
       <div className="card-header d-flex flex-wrap justify-content-between align-items-center gap-2">
         <span>Versionen und Sicherungspunkte</span>
         <div className="d-flex align-items-center gap-2">

From 5f4d9bf7898450772c02584756049a7cd624b136 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 12:57:50 +0200
Subject: [PATCH 17/60] Show the sidebar on every page except the print view

AppShell showed the sidebar only on the project list and overview, so it
disappeared on the building structure page and in the circuit list
editor. It is collapsible, so it now stays on every page. Only the print
view, a stand-alone document opened in its own tab and printed as PDF,
keeps the full width.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/app/globals.css                  | 2 +-
 src/frontend/components/AppShell.tsx | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/app/globals.css b/src/app/globals.css
index f392303..0c40c5c 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -220,7 +220,7 @@ a {
   --bs-alert-border-color: #205a38;
 }
 
-/* ── App-Shell / Seitenleiste (nur auf der Projektseite) ────────────────── */
+/* ── App-Shell / Seitenleiste (alle Seiten außer der Seitenansicht) ──── */
 
 .app-shell {
   display: grid;
diff --git a/src/frontend/components/AppShell.tsx b/src/frontend/components/AppShell.tsx
index bbfa0ae..77b7c78 100644
--- a/src/frontend/components/AppShell.tsx
+++ b/src/frontend/components/AppShell.tsx
@@ -4,12 +4,14 @@ import { useEffect, useState } from "react";
 import { usePathname } from "next/navigation";
 import { Sidebar } from "./Sidebar";
 
-const PROJECT_AREA_PATTERN = /^\/projects(\/[^/]+)?$/;
+// Every page shows the (collapsible) sidebar except the print view, which is
+// a stand-alone document opened in its own tab and printed as PDF.
+const PRINT_VIEW_PATTERN = /^\/projects\/[^/]+\/print(\/|$)/;
 const SIDEBAR_COLLAPSED_STORAGE_KEY = "leistungsbilanz:sidebar-collapsed";
 
 export function AppShell({ children }: { children: React.ReactNode }) {
   const pathname = usePathname();
-  const showSidebar = PROJECT_AREA_PATTERN.test(pathname ?? "");
+  const showSidebar = !PRINT_VIEW_PATTERN.test(pathname ?? "");
   const [isSidebarCollapsed, setIsSidebarCollapsed] = useState(false);
 
   useEffect(() => {

From 837b29c7c55d6ba1289ab711cc94f73da12ef5c3 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 12:55:38 +0200
Subject: [PATCH 18/60] Add icon actions and collapsible filters to the project
 overview
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The overview now uses the same icon buttons as the circuit list editor:
row actions are icon-only IconButtons (Pencil, Link2, Library, Trash2),
card-header and panel actions show icon plus text, and the circuit-list
link uses the new IconLink. The version history uses Undo2/Redo2, a
chevron toggle and a RotateCcw restore action. Page-header buttons stay
Bootstrap buttons with a lucide icon so the upcoming "Seitenansicht"
button of feature/print-view merges without conflicts and matches them.

The Verteilungen and Projektgeräte cards get a PM-style filter bar:
search plus MultiSelectDropdown (checkbox list with "Alle", closes on
outside click and Escape) and "Zurücksetzen" while a filter is active.
Only the bar collapses; the state is kept per card in localStorage and a
collapsed active filter shows "Filter aktiv". The header row shows
"x von y", and an empty-state row explains when filters hide everything.
The filter logic is a pure module (overview-filters.ts) with node tests;
selections that are no longer offered (deleted floor) are ignored.

IconButton now imports React explicitly like the other components that
are rendered in node tests with the classic JSX runtime.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |   8 +
 docs/current-architecture.md                  |   6 +
 src/app/globals.css                           | 257 +++++++++++
 src/app/projects/[projectId]/page.tsx         | 400 +++++++++++++-----
 src/frontend/components/filter-panel.tsx      | 120 ++++++
 src/frontend/components/icon-button.tsx       |   2 +-
 src/frontend/components/icon-link.tsx         |  40 ++
 .../components/multi-select-dropdown.tsx      | 127 ++++++
 .../components/project-version-history.tsx    | 113 ++---
 src/frontend/utils/overview-filters.ts        | 239 +++++++++++
 tests/overview-filters.test.ts                | 248 +++++++++++
 11 files changed, 1404 insertions(+), 156 deletions(-)
 create mode 100644 src/frontend/components/filter-panel.tsx
 create mode 100644 src/frontend/components/icon-link.tsx
 create mode 100644 src/frontend/components/multi-select-dropdown.tsx
 create mode 100644 src/frontend/utils/overview-filters.ts
 create mode 100644 tests/overview-filters.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index ab8393e..1eb5661 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -177,6 +177,14 @@ Column headers show the label (click to sort) with a funnel icon for the
 value filter; an active filter is highlighted and shows its value count.
 Header labels break only between words and put a trailing unit such as
 `[kW]` on a second line.
+The project overview uses the same rule: row actions are icon-only
+`IconButton`s, card-header and panel actions show icon plus text, navigation
+uses `IconLink` (`src/frontend/components/icon-link.tsx`). Page-header buttons
+stay Bootstrap `btn` with a lucide icon (`btn-with-icon`). List cards filter
+through a collapsible PM-style filter bar (`CollapsibleFilterPanel`,
+`MultiSelectDropdown`; logic in `src/frontend/utils/overview-filters.ts`): only
+the bar collapses, its state is kept per card in `localStorage`, a collapsed
+active filter shows "Filter aktiv".
 
 ## Bootstrap / Styling Rule
 
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 92efc98..189dffc 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -252,6 +252,12 @@ fünfspaltige Übersicht dargestellt. Manuelle Anlage, Übernahme aus der global
 Bibliothek und vollständige Bearbeitung erfolgen in einem gemeinsamen Modal.
 Die anschließende Vorschau verknüpfter Stromkreiszeilen bleibt davon getrennt,
 damit Änderungen weiterhin niemals still synchronisiert werden.
+Die Karten Verteilungen und Projektgeräte besitzen je eine einklappbare
+Filterleiste im Stil der PM-App (Suche, Mehrfachauswahl für Etage/Netzart bzw.
+Kategorie/Anschluss/Kostengruppe, „Zurücksetzen“, Anzeige „x von y“); die
+Filterlogik liegt rein in `src/frontend/utils/overview-filters.ts`, der
+Einklappzustand je Karte in `localStorage`. Aktionen verwenden wie der Editor
+`IconButton`/`IconLink`.
 `GET /api/projects/:projectId/export` verpackt denselben vollständigen
 Projektzustand in ein portables, format- und schema-versioniertes JSON-Dokument
 mit SHA-256-Prüfsumme. `POST /api/projects/:projectId/import` prüft Format,
diff --git a/src/app/globals.css b/src/app/globals.css
index fe81d07..dd26b0c 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -381,6 +381,263 @@ a {
   font-weight: 600;
 }
 
+/* ── Projektübersicht: Icon-Aktionen und einklappbare Filterleisten ─────
+   Aktionen nutzen IconButton/IconLink wie die Stromkreisliste; der Rahmen
+   kommt hier aus dem Kontext `.overview-actions`. Filterleisten folgen der
+   PM-App (Suche + Mehrfachauswahl mit „Alle“ + „Zurücksetzen“), angepasst an
+   die Tokens dieser App. */
+
+.btn-with-icon {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.4rem;
+}
+
+.overview-actions {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 0.3rem;
+}
+
+.overview-actions .icon-button {
+  min-width: 1.9rem;
+  min-height: 1.85rem;
+  padding: 0.2rem 0.45rem;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: var(--color-bg);
+  color: var(--color-ink);
+  font-size: 0.82rem;
+  font-weight: 500;
+  text-decoration: none;
+  white-space: nowrap;
+}
+
+.overview-actions .icon-button:disabled {
+  opacity: 0.45;
+}
+
+.overview-actions .icon-button-primary {
+  border-color: var(--color-primary);
+  background: var(--color-primary);
+  color: #fff;
+}
+
+.overview-actions .icon-button-primary:not(:disabled):hover {
+  border-color: var(--color-primary-dark);
+  background: var(--color-primary-dark);
+  color: #fff;
+}
+
+:root[data-bs-theme="dark"] .overview-actions .icon-button-primary {
+  border-color: var(--color-accent);
+  background: var(--color-accent);
+}
+
+:root[data-bs-theme="dark"] .overview-actions .icon-button-primary:not(:disabled):hover {
+  border-color: var(--color-accent-pale);
+  background: var(--color-accent-pale);
+  color: var(--color-primary-deep);
+}
+
+.overview-actions .icon-button-danger {
+  color: var(--color-danger);
+}
+
+.filter-panel {
+  padding: 0.55rem 1rem 0.7rem;
+  border-bottom: 1px solid var(--color-border);
+  background: var(--color-bg);
+}
+
+.filter-panel-header {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.filter-panel-header .filter-panel-toggle {
+  width: 24px;
+  height: 24px;
+  padding: 0;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: none;
+  color: var(--color-ink-soft);
+}
+
+.filter-panel-header .filter-panel-toggle:hover {
+  background: var(--color-surface);
+}
+
+.filter-panel-label,
+.filter-bar-label {
+  font-size: 0.78rem;
+  font-weight: 500;
+  color: var(--color-ink-soft);
+}
+
+.filter-panel-badge {
+  padding: 3px 10px;
+  border-radius: 999px;
+  background: #fbe9d9;
+  color: var(--color-attention-dark);
+  font-size: 0.72rem;
+  font-weight: 500;
+  white-space: nowrap;
+}
+
+:root[data-bs-theme="dark"] .filter-panel-badge {
+  background: #3a2e1c;
+  color: #f0b880;
+}
+
+.filter-panel-count {
+  margin-left: auto;
+  font-size: 0.78rem;
+  color: var(--color-ink-soft);
+  white-space: nowrap;
+}
+
+.filter-bar {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: flex-end;
+  gap: var(--space-sm) var(--space-md);
+  margin-top: 0.5rem;
+}
+
+.filter-bar-field,
+.filter-dropdown {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-xs);
+  margin: 0;
+}
+
+.filter-bar-search,
+.filter-dropdown-toggle {
+  min-height: 2.1rem;
+  padding: 0.35rem 0.65rem;
+  border: 1.5px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-bg);
+  color: var(--color-ink);
+  font: inherit;
+  font-size: 0.82rem;
+}
+
+.filter-bar-search {
+  width: 15em;
+}
+
+.filter-bar-search:focus,
+.filter-dropdown-toggle:focus-visible {
+  outline: 2px solid var(--color-accent);
+  outline-offset: 1px;
+  border-color: var(--color-accent);
+}
+
+.filter-dropdown-toggle {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  min-width: 11em;
+  max-width: 18em;
+  font-weight: 500;
+  cursor: pointer;
+}
+
+.filter-dropdown-toggle:hover,
+.filter-dropdown-toggle.is-active {
+  border-color: var(--color-accent);
+}
+
+.filter-dropdown-toggle.is-active {
+  color: var(--color-primary);
+}
+
+:root[data-bs-theme="dark"] .filter-dropdown-toggle.is-active {
+  color: var(--color-accent-pale);
+}
+
+.filter-dropdown-value {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.filter-dropdown-toggle svg {
+  flex: none;
+  color: var(--color-ink-soft);
+}
+
+.filter-dropdown-panel {
+  position: absolute;
+  top: calc(100% + 4px);
+  left: 0;
+  z-index: 20;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 220px;
+  max-height: 280px;
+  overflow-y: auto;
+  padding: 8px;
+  border: 1.5px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-bg);
+  box-shadow: 0 6px 20px var(--shadow-menu);
+}
+
+.filter-dropdown-option {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin: 0;
+  padding: 6px 8px;
+  border-radius: 6px;
+  color: var(--color-ink);
+  font-size: 0.82rem;
+  font-weight: 400;
+  cursor: pointer;
+}
+
+.filter-dropdown-option:hover {
+  background: var(--color-surface);
+}
+
+.filter-dropdown-option input {
+  accent-color: var(--color-primary);
+}
+
+.filter-dropdown-option-all {
+  margin-bottom: 2px;
+  padding-bottom: 8px;
+  border-bottom: 1px solid var(--color-border);
+  border-radius: 6px 6px 0 0;
+}
+
+.filter-dropdown-empty {
+  padding: 6px 8px;
+  color: var(--color-ink-soft);
+  font-size: 0.8rem;
+}
+
+.filter-bar .filter-bar-reset {
+  min-height: 2.1rem;
+  padding: 0.3rem 0.65rem;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-bg);
+  color: var(--color-ink);
+  font-size: 0.82rem;
+  font-weight: 500;
+}
+
 /* ── KPI-Kacheln ─────────────────────────────────────────────────────── */
 
 .kpi-grid {
diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index fa342ea..f937804 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -3,6 +3,47 @@
 import Link from "next/link";
 import { useParams } from "next/navigation";
 import { FormEvent, useEffect, useMemo, useState } from "react";
+import {
+  ArrowLeft,
+  FileUp,
+  Library,
+  Link2,
+  ListTree,
+  Pencil,
+  Plus,
+  RefreshCw,
+  Settings,
+  Trash2,
+  Unlink,
+  X,
+} from "lucide-react";
+import { IconButton } from "../../../frontend/components/icon-button";
+import { IconLink } from "../../../frontend/components/icon-link";
+import {
+  CollapsibleFilterPanel,
+  FilterSearchField,
+} from "../../../frontend/components/filter-panel";
+import { MultiSelectDropdown } from "../../../frontend/components/multi-select-dropdown";
+import {
+  circuitGroupCategories,
+  circuitGroupCategoryLabels,
+} from "../../../shared/constants/circuit-group";
+import { distributionBoardSupplyTypes } from "../../../shared/constants/distribution-board";
+import {
+  buildCostGroupFilterOptions,
+  buildFloorFilterOptions,
+  buildSupplyTypeFilterOptions,
+  emptyDistributionBoardFilters,
+  emptyProjectDeviceFilters,
+  filterDistributionBoards,
+  filterProjectDevices,
+  isDistributionBoardFilterActive,
+  isProjectDeviceFilterActive,
+  retainAvailableFilterValues,
+  type DistributionBoardFilters,
+  type FilterOption,
+  type ProjectDeviceFilters,
+} from "../../../frontend/utils/overview-filters";
 import {
   copyGlobalDeviceToProject,
   copyDistributionBoard,
@@ -77,6 +118,29 @@ const projectDeviceSyncFieldLabels: Record<ProjectDeviceSyncField, string> = {
   remark: "Bemerkung",
 };
 
+const projectDeviceCategoryFilterOptions: FilterOption[] =
+  circuitGroupCategories.map((category) => ({
+    id: category,
+    label: circuitGroupCategoryLabels[category],
+  }));
+
+const projectDevicePhaseTypeLabels: Record<ProjectDeviceDto["phaseType"], string> = {
+  single_phase: "1-phasig",
+  three_phase: "3-phasig",
+};
+
+const projectDevicePhaseTypeFilterOptions: FilterOption[] = (
+  ["single_phase", "three_phase"] as const
+).map((phaseType) => ({
+  id: phaseType,
+  label: projectDevicePhaseTypeLabels[phaseType],
+}));
+
+const boardFilterCollapsedStorageKey =
+  "leistungsbilanz:overview-filter-collapsed:distribution-boards";
+const projectDeviceFilterCollapsedStorageKey =
+  "leistungsbilanz:overview-filter-collapsed:project-devices";
+
 export default function ProjectDetailPage() {
   const params = useParams<{ projectId: string }>();
   const [projectId, setProjectId] = useState("");
@@ -113,7 +177,11 @@ export default function ProjectDetailPage() {
     useState(false);
   const [editingProjectDevice, setEditingProjectDevice] =
     useState<ProjectDeviceDto | null>(null);
-  const [projectDeviceQuery, setProjectDeviceQuery] = useState("");
+  const [boardFilters, setBoardFilters] = useState<DistributionBoardFilters>(
+    emptyDistributionBoardFilters
+  );
+  const [projectDeviceFilters, setProjectDeviceFilters] =
+    useState<ProjectDeviceFilters>(emptyProjectDeviceFilters);
   const [syncPreview, setSyncPreview] = useState<ProjectDeviceSyncPreviewDto | null>(null);
   const [selectedSyncRowIds, setSelectedSyncRowIds] = useState<string[]>([]);
   const [selectedSyncFields, setSelectedSyncFields] = useState<ProjectDeviceSyncField[]>([]);
@@ -164,22 +232,67 @@ export default function ProjectDetailPage() {
   const floorCount = useMemo(() => floors.length, [floors.length]);
   const roomCount = useMemo(() => rooms.length, [rooms.length]);
   const projectDeviceCount = useMemo(() => projectDevices.length, [projectDevices.length]);
-  const visibleProjectDevices = useMemo(() => {
-    const query = projectDeviceQuery.trim().toLocaleLowerCase("de");
-    if (!query) {
-      return projectDevices;
-    }
-    return projectDevices.filter((device) =>
-      [
-        device.name,
-        device.displayName,
-        device.category,
-        device.connectionKind,
-        device.costGroup,
-      ].some((value) => value?.toLocaleLowerCase("de").includes(query))
-    );
-  }, [projectDeviceQuery, projectDevices]);
+  const costGroupFilterOptions = useMemo(
+    () => buildCostGroupFilterOptions(projectDevices),
+    [projectDevices]
+  );
+  const effectiveProjectDeviceFilters = useMemo<ProjectDeviceFilters>(
+    () => ({
+      ...projectDeviceFilters,
+      costGroups: retainAvailableFilterValues(
+        projectDeviceFilters.costGroups,
+        costGroupFilterOptions
+      ),
+    }),
+    [costGroupFilterOptions, projectDeviceFilters]
+  );
+  const visibleProjectDevices = useMemo(
+    () =>
+      filterProjectDevices(
+        projectDevices,
+        effectiveProjectDeviceFilters,
+        circuitGroupCategoryLabels
+      ),
+    [effectiveProjectDeviceFilters, projectDevices]
+  );
   const floorById = useMemo(() => new Map(floors.map((item) => [item.id, item])), [floors]);
+  const floorFilterOptions = useMemo(
+    () => buildFloorFilterOptions(floors),
+    [floors]
+  );
+  const supplyTypeFilterOptions = useMemo(
+    () =>
+      buildSupplyTypeFilterOptions(
+        distributionBoardSupplyTypes,
+        project?.enabledDistributionBoardSupplyTypes ?? [],
+        boards,
+        distributionBoardSupplyTypeLabels
+      ),
+    [boards, project?.enabledDistributionBoardSupplyTypes]
+  );
+  const effectiveBoardFilters = useMemo<DistributionBoardFilters>(
+    () => ({
+      ...boardFilters,
+      floorIds: retainAvailableFilterValues(
+        boardFilters.floorIds,
+        floorFilterOptions
+      ),
+      supplyTypes: retainAvailableFilterValues(
+        boardFilters.supplyTypes,
+        supplyTypeFilterOptions
+      ),
+    }),
+    [boardFilters, floorFilterOptions, supplyTypeFilterOptions]
+  );
+  const visibleBoards = useMemo(
+    () =>
+      filterDistributionBoards(
+        boards,
+        effectiveBoardFilters,
+        new Map(floors.map((floor) => [floor.id, floor.name]))
+      ),
+    [boards, effectiveBoardFilters, floors]
+  );
   const circuitListByBoardId = useMemo(
     () => new Map(circuitLists.map((circuitList) => [circuitList.distributionBoardId, circuitList])),
     [circuitLists]
@@ -850,22 +963,28 @@ export default function ProjectDetailPage() {
         </div>
         <div className="d-flex gap-2">
           <button
-            className="btn btn-outline-primary"
+            className="btn btn-outline-primary btn-with-icon"
             disabled={!project}
             onClick={() => setIsRevitCsvOpen(true)}
             type="button"
           >
+            <FileUp aria-hidden="true" size={16} strokeWidth={2} />
             Revit-CSV
           </button>
           <button
-            className="btn btn-outline-primary"
+            className="btn btn-outline-primary btn-with-icon"
             disabled={!project}
             onClick={() => setIsProjectSettingsOpen(true)}
             type="button"
           >
+            <Settings aria-hidden="true" size={16} strokeWidth={2} />
             Projekteinstellungen
           </button>
-          <Link className="btn btn-outline-secondary" href="/projects">
+          <Link
+            className="btn btn-outline-secondary btn-with-icon"
+            href="/projects"
+          >
+            <ArrowLeft aria-hidden="true" size={16} strokeWidth={2} />
             Zur Projektübersicht
           </Link>
         </div>
@@ -910,14 +1029,52 @@ export default function ProjectDetailPage() {
                 <span>Verteilungen</span>
                 <span className="badge text-bg-secondary ms-2">{boardCount}</span>
               </div>
-              <button
-                className="btn btn-sm btn-primary"
-                onClick={openBoardCreator}
-                type="button"
-              >
-                Verteilung hinzufügen
-              </button>
+              <div className="overview-actions">
+                <IconButton
+                  icon={Plus}
+                  label="Verteilung hinzufügen"
+                  onClick={openBoardCreator}
+                  showLabel
+                  variant="primary"
+                />
+              </div>
             </div>
+            <CollapsibleFilterPanel
+              isFilterActive={isDistributionBoardFilterActive(
+                effectiveBoardFilters
+              )}
+              onReset={() => setBoardFilters(emptyDistributionBoardFilters)}
+              storageKey={boardFilterCollapsedStorageKey}
+              totalCount={boards.length}
+              visibleCount={visibleBoards.length}
+            >
+              <FilterSearchField
+                label="Suche"
+                onChange={(query) =>
+                  setBoardFilters((current) => ({ ...current, query }))
+                }
+                placeholder="Verteilung oder Etage …"
+                value={boardFilters.query}
+              />
+              <MultiSelectDropdown
+                emptyLabel="Keine Etagen vorhanden"
+                label="Etage"
+                onChange={(floorIds) =>
+                  setBoardFilters((current) => ({ ...current, floorIds }))
+                }
+                options={floorFilterOptions}
+                selected={effectiveBoardFilters.floorIds}
+              />
+              <MultiSelectDropdown
+                emptyLabel="Keine Netzarten vorhanden"
+                label="Netzart"
+                onChange={(supplyTypes) =>
+                  setBoardFilters((current) => ({ ...current, supplyTypes }))
+                }
+                options={supplyTypeFilterOptions}
+                selected={effectiveBoardFilters.supplyTypes}
+              />
+            </CollapsibleFilterPanel>
             <div className="table-responsive">
               <table className="table table-hover align-middle mb-0">
                 <thead>
@@ -930,7 +1087,7 @@ export default function ProjectDetailPage() {
                   </tr>
                 </thead>
                 <tbody>
-                  {boards.map((board) => {
+                  {visibleBoards.map((board) => {
                     const circuitList = circuitListByBoardId.get(board.id);
                     return (
                       <tr key={board.id}>
@@ -957,22 +1114,21 @@ export default function ProjectDetailPage() {
                           )}
                         </td>
                         <td className="text-end">
-                          <div className="d-inline-flex flex-wrap justify-content-end gap-2">
-                            <button
-                              className="btn btn-sm btn-outline-secondary"
+                          <div className="overview-actions justify-content-end">
+                            <IconButton
                               disabled={isSaving}
+                              icon={Pencil}
+                              label="Bearbeiten"
                               onClick={() => openBoardEditor(board)}
-                              type="button"
-                            >
-                              Bearbeiten
-                            </button>
+                            />
                             {circuitList ? (
-                              <Link
-                                className="btn btn-sm btn-primary"
+                              <IconLink
                                 href={`/projects/${projectId}/circuit-lists/${circuitList.id}/tree-edit`}
-                              >
-                                Stromkreisliste öffnen
-                              </Link>
+                                icon={ListTree}
+                                label="Stromkreisliste öffnen"
+                                showLabel
+                                variant="primary"
+                              />
                             ) : (
                               <span className="text-secondary small align-self-center">
                                 Keine Stromkreisliste vorhanden
@@ -992,6 +1148,11 @@ export default function ProjectDetailPage() {
                   ) : null}
                 </tbody>
               </table>
+              {boards.length > 0 && visibleBoards.length === 0 ? (
+                <p className="text-center text-secondary py-4 mb-0">
+                  Keine Verteilungen entsprechen den Filtern.
+                </p>
+              ) : null}
             </div>
           </div>
         </section>
@@ -1085,24 +1246,58 @@ export default function ProjectDetailPage() {
             <span>Projektgeräte</span>
             <span className="badge text-bg-secondary ms-2">{projectDeviceCount}</span>
           </div>
-          <div className="d-flex gap-2">
-            <input
-              aria-label="Projektgeräte durchsuchen"
-              className="form-control form-control-sm"
-              onChange={(event) => setProjectDeviceQuery(event.target.value)}
-              placeholder="Geräte durchsuchen"
-              type="search"
-              value={projectDeviceQuery}
-            />
-            <button
-              className="btn btn-sm btn-primary text-nowrap"
+          <div className="overview-actions">
+            <IconButton
+              icon={Plus}
+              label="Gerät hinzufügen"
               onClick={() => setIsProjectDeviceModalOpen(true)}
-              type="button"
-            >
-              Gerät hinzufügen
-            </button>
+              showLabel
+              variant="primary"
+            />
           </div>
         </div>
+        <CollapsibleFilterPanel
+          isFilterActive={isProjectDeviceFilterActive(
+            effectiveProjectDeviceFilters
+          )}
+          onReset={() => setProjectDeviceFilters(emptyProjectDeviceFilters)}
+          storageKey={projectDeviceFilterCollapsedStorageKey}
+          totalCount={projectDevices.length}
+          visibleCount={visibleProjectDevices.length}
+        >
+          <FilterSearchField
+            label="Suche"
+            onChange={(query) =>
+              setProjectDeviceFilters((current) => ({ ...current, query }))
+            }
+            placeholder="Gerät, Anschlussart, KG …"
+            value={projectDeviceFilters.query}
+          />
+          <MultiSelectDropdown
+            label="Kategorie"
+            onChange={(categories) =>
+              setProjectDeviceFilters((current) => ({ ...current, categories }))
+            }
+            options={projectDeviceCategoryFilterOptions}
+            selected={effectiveProjectDeviceFilters.categories}
+          />
+          <MultiSelectDropdown
+            label="Anschluss"
+            onChange={(phaseTypes) =>
+              setProjectDeviceFilters((current) => ({ ...current, phaseTypes }))
+            }
+            options={projectDevicePhaseTypeFilterOptions}
+            selected={effectiveProjectDeviceFilters.phaseTypes}
+          />
+          <MultiSelectDropdown
+            label="Kostengruppe"
+            onChange={(costGroups) =>
+              setProjectDeviceFilters((current) => ({ ...current, costGroups }))
+            }
+            options={costGroupFilterOptions}
+            selected={effectiveProjectDeviceFilters.costGroups}
+          />
+        </CollapsibleFilterPanel>
         <div className="table-responsive">
           <table className="table table-sm table-striped align-middle mb-0">
             <thead>
@@ -1121,11 +1316,13 @@ export default function ProjectDetailPage() {
                     <strong>{device.displayName}</strong>
                     <div className="small text-secondary">
                       {device.name}
-                      {device.category ? ` · ${device.category}` : ""}
+                      {device.category
+                        ? ` · ${circuitGroupCategoryLabels[device.category] ?? device.category}`
+                        : ""}
                     </div>
                   </td>
                   <td>
-                    {device.phaseType === "three_phase" ? "3-phasig" : "1-phasig"}
+                    {projectDevicePhaseTypeLabels[device.phaseType]}
                     {device.connectionKind ? (
                       <div className="small text-secondary">
                         {device.connectionKind}
@@ -1141,39 +1338,32 @@ export default function ProjectDetailPage() {
                   </td>
                   <td>{device.costGroup ?? "-"}</td>
                   <td className="text-end">
-                    <div className="d-inline-flex flex-wrap justify-content-end gap-1">
-                      <button
-                        className="btn btn-sm btn-outline-secondary"
-                        type="button"
+                    <div className="overview-actions justify-content-end">
+                      <IconButton
+                        disabled={isSaving}
+                        icon={Pencil}
+                        label="Bearbeiten"
                         onClick={() => setEditingProjectDevice(device)}
+                      />
+                      <IconButton
                         disabled={isSaving}
-                      >
-                        Bearbeiten
-                      </button>
-                      <button
-                        className="btn btn-sm btn-outline-primary"
-                        type="button"
+                        icon={Link2}
+                        label="Verknüpfungen"
                         onClick={() => void openProjectDeviceSyncPreview(device.id)}
+                      />
+                      <IconButton
                         disabled={isSaving}
-                      >
-                        Verknüpfungen
-                      </button>
-                      <button
-                        className="btn btn-sm btn-outline-secondary"
-                        type="button"
-                        onClick={() => handleCopyProjectToGlobal(device.id)}
+                        icon={Library}
+                        label="Nach global kopieren"
+                        onClick={() => void handleCopyProjectToGlobal(device.id)}
+                      />
+                      <IconButton
                         disabled={isSaving}
-                      >
-                        Nach global kopieren
-                      </button>
-                      <button
-                        className="btn btn-sm btn-outline-danger"
-                        type="button"
-                        onClick={() => handleDeleteProjectDevice(device.id)}
-                        disabled={isSaving}
-                      >
-                        Löschen
-                      </button>
+                        icon={Trash2}
+                        label="Löschen"
+                        onClick={() => void handleDeleteProjectDevice(device.id)}
+                        variant="danger"
+                      />
                     </div>
                   </td>
                 </tr>
@@ -1182,7 +1372,7 @@ export default function ProjectDetailPage() {
                 <tr>
                   <td colSpan={5} className="text-center text-secondary py-4">
                     {projectDevices.length
-                      ? "Keine Projektgeräte entsprechen der Suche."
+                      ? "Keine Projektgeräte entsprechen den Filtern."
                       : "Noch keine Projektgeräte vorhanden."}
                   </td>
                 </tr>
@@ -1199,9 +1389,13 @@ export default function ProjectDetailPage() {
                   Nur ausgewählte Felder und Zeilen werden übernommen. Der Anzeigename bleibt standardmäßig lokal.
                 </p>
               </div>
-              <button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSyncPreview(null)}>
-                Schließen
-              </button>
+              <div className="overview-actions">
+                <IconButton
+                  icon={X}
+                  label="Schließen"
+                  onClick={() => setSyncPreview(null)}
+                />
+              </div>
             </div>
 
             <div className="d-flex flex-wrap gap-3 mb-3">
@@ -1280,23 +1474,23 @@ export default function ProjectDetailPage() {
               </table>
             </div>
 
-            <div className="d-flex flex-wrap gap-2">
-              <button
-                className="btn btn-primary"
-                type="button"
-                onClick={() => void handleSynchronizeProjectDeviceRows()}
+            <div className="overview-actions">
+              <IconButton
                 disabled={isSaving || selectedSyncRowIds.length === 0 || selectedSyncFields.length === 0}
-              >
-                Auswahl synchronisieren
-              </button>
-              <button
-                className="btn btn-outline-danger"
-                type="button"
-                onClick={() => void handleDisconnectProjectDeviceRows()}
+                icon={RefreshCw}
+                label="Auswahl synchronisieren"
+                onClick={() => void handleSynchronizeProjectDeviceRows()}
+                showLabel
+                variant="primary"
+              />
+              <IconButton
                 disabled={isSaving || selectedSyncRowIds.length === 0}
-              >
-                Auswahl trennen
-              </button>
+                icon={Unlink}
+                label="Auswahl trennen"
+                onClick={() => void handleDisconnectProjectDeviceRows()}
+                showLabel
+                variant="danger"
+              />
             </div>
           </div>
         ) : null}
diff --git a/src/frontend/components/filter-panel.tsx b/src/frontend/components/filter-panel.tsx
new file mode 100644
index 0000000..afa1fde
--- /dev/null
+++ b/src/frontend/components/filter-panel.tsx
@@ -0,0 +1,120 @@
+"use client";
+
+import { ChevronDown, ChevronRight, FilterX } from "lucide-react";
+import React, { useEffect, useId, useState, type ReactNode } from "react";
+import { IconButton } from "./icon-button";
+
+function readCollapsed(storageKey: string) {
+  try {
+    return window.localStorage.getItem(storageKey) === "1";
+  } catch {
+    return false;
+  }
+}
+
+function writeCollapsed(storageKey: string, isCollapsed: boolean) {
+  try {
+    window.localStorage.setItem(storageKey, isCollapsed ? "1" : "0");
+  } catch {
+    // Storage unavailable (private mode, blocked): keep the in-memory state.
+  }
+}
+
+/**
+ * Collapsible filter area inside a card (PM app style): a small header row
+ * with toggle, label "Filter", a "Filter aktiv" badge while collapsed and the
+ * "x von y" count; below it the wrapping filter bar with a "Zurücksetzen"
+ * button while a filter is active. Only the bar collapses, never the card.
+ * The collapsed state is remembered per `storageKey` (default: expanded).
+ */
+export function CollapsibleFilterPanel({
+  storageKey,
+  isFilterActive,
+  visibleCount,
+  totalCount,
+  onReset,
+  children,
+}: {
+  storageKey: string;
+  isFilterActive: boolean;
+  visibleCount: number;
+  totalCount: number;
+  onReset: () => void;
+  children: ReactNode;
+}) {
+  const [isCollapsed, setIsCollapsed] = useState(false);
+  const barId = useId();
+
+  useEffect(() => {
+    setIsCollapsed(readCollapsed(storageKey));
+  }, [storageKey]);
+
+  function toggleCollapsed() {
+    const next = !isCollapsed;
+    setIsCollapsed(next);
+    writeCollapsed(storageKey, next);
+  }
+
+  return (
+    <div className="filter-panel">
+      <div className="filter-panel-header">
+        <IconButton
+          ariaControls={barId}
+          ariaExpanded={!isCollapsed}
+          className="filter-panel-toggle"
+          icon={isCollapsed ? ChevronRight : ChevronDown}
+          label={isCollapsed ? "Filter einblenden" : "Filter ausblenden"}
+          onClick={toggleCollapsed}
+        />
+        <span className="filter-panel-label">Filter</span>
+        {isCollapsed && isFilterActive ? (
+          <span className="filter-panel-badge">Filter aktiv</span>
+        ) : null}
+        <span aria-live="polite" className="filter-panel-count">
+          {visibleCount} von {totalCount}
+        </span>
+      </div>
+      {isCollapsed ? null : (
+        <div className="filter-bar" id={barId}>
+          {children}
+          {isFilterActive ? (
+            <IconButton
+              className="filter-bar-reset"
+              icon={FilterX}
+              label="Zurücksetzen"
+              onClick={onReset}
+              showLabel
+              title="Alle Filter zurücksetzen"
+            />
+          ) : null}
+        </div>
+      )}
+    </div>
+  );
+}
+
+/** Search field for a filter bar. */
+export function FilterSearchField({
+  label,
+  placeholder,
+  value,
+  onChange,
+}: {
+  label: string;
+  placeholder: string;
+  value: string;
+  onChange: (value: string) => void;
+}) {
+  return (
+    <label className="filter-bar-field">
+      <span className="filter-bar-label">{label}</span>
+      <input
+        className="filter-bar-search"
+        onChange={(event) => onChange(event.target.value)}
+        placeholder={placeholder}
+        type="search"
+        value={value}
+      />
+    </label>
+  );
+}
diff --git a/src/frontend/components/icon-button.tsx b/src/frontend/components/icon-button.tsx
index 605036d..4973029 100644
--- a/src/frontend/components/icon-button.tsx
+++ b/src/frontend/components/icon-button.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import type { LucideIcon } from "lucide-react";
-import type { ReactNode } from "react";
+import React, { type ReactNode } from "react";
 
 /**
  * Compact editor button with a lucide icon. `label` is always the accessible
diff --git a/src/frontend/components/icon-link.tsx b/src/frontend/components/icon-link.tsx
new file mode 100644
index 0000000..f5453c2
--- /dev/null
+++ b/src/frontend/components/icon-link.tsx
@@ -0,0 +1,40 @@
+"use client";
+
+import type { LucideIcon } from "lucide-react";
+import Link from "next/link";
+import React from "react";
+
+/**
+ * Navigation counterpart of `IconButton`: a Next.js link with the same
+ * look. `label` is always the accessible name and, unless `title` is given,
+ * the tooltip; with `showLabel` it is also rendered next to the icon.
+ */
+export function IconLink({
+  icon: Icon,
+  label,
+  title,
+  href,
+  variant = "default",
+  showLabel = false,
+  className,
+}: {
+  icon: LucideIcon;
+  label: string;
+  title?: string;
+  href: string;
+  variant?: "default" | "danger" | "primary";
+  showLabel?: boolean;
+  className?: string;
+}) {
+  return (
+    <Link
+      aria-label={showLabel ? undefined : label}
+      className={`icon-button icon-button-${variant}${className ? ` ${className}` : ""}`}
+      href={href}
+      title={title ?? label}
+    >
+      <Icon aria-hidden="true" size={15} strokeWidth={2} />
+      {showLabel ? <span>{label}</span> : null}
+    </Link>
+  );
+}
diff --git a/src/frontend/components/multi-select-dropdown.tsx b/src/frontend/components/multi-select-dropdown.tsx
new file mode 100644
index 0000000..4fa9c79
--- /dev/null
+++ b/src/frontend/components/multi-select-dropdown.tsx
@@ -0,0 +1,127 @@
+"use client";
+
+import { ChevronDown } from "lucide-react";
+import React, { useEffect, useId, useRef, useState } from "react";
+import {
+  toggleFilterValue,
+  type FilterOption,
+} from "../utils/overview-filters";
+
+/**
+ * Filter dropdown with a checkbox list (PM app style). An empty selection
+ * means "Alle"; the "Alle" entry clears the selection. Closes on outside
+ * click and Escape.
+ */
+export function MultiSelectDropdown({
+  label,
+  options,
+  selected,
+  onChange,
+  emptyLabel = "Keine Einträge vorhanden",
+}: {
+  label: string;
+  options: readonly FilterOption[];
+  selected: readonly string[];
+  onChange: (selected: string[]) => void;
+  emptyLabel?: string;
+}) {
+  const [isOpen, setIsOpen] = useState(false);
+  const containerRef = useRef<HTMLDivElement>(null);
+  const toggleRef = useRef<HTMLButtonElement>(null);
+  const labelId = useId();
+  const valueId = useId();
+  const panelId = useId();
+
+  useEffect(() => {
+    if (!isOpen) {
+      return;
+    }
+    function handlePointerDown(event: MouseEvent) {
+      if (
+        containerRef.current &&
+        !containerRef.current.contains(event.target as Node)
+      ) {
+        setIsOpen(false);
+      }
+    }
+    function handleKeyDown(event: KeyboardEvent) {
+      if (event.key === "Escape") {
+        setIsOpen(false);
+        toggleRef.current?.focus();
+      }
+    }
+    document.addEventListener("mousedown", handlePointerDown);
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      document.removeEventListener("mousedown", handlePointerDown);
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [isOpen]);
+
+  const summary =
+    selected.length === 0
+      ? "Alle"
+      : selected.length === 1
+        ? options.find((option) => option.id === selected[0])?.label ??
+          "1 ausgewählt"
+        : `${selected.length} ausgewählt`;
+
+  return (
+    <div className="filter-dropdown" ref={containerRef}>
+      <span className="filter-bar-label" id={labelId}>
+        {label}
+      </span>
+      <button
+        aria-controls={panelId}
+        aria-expanded={isOpen}
+        aria-haspopup="true"
+        aria-labelledby={`${labelId} ${valueId}`}
+        className={`filter-dropdown-toggle${selected.length ? " is-active" : ""}`}
+        onClick={() => setIsOpen((current) => !current)}
+        ref={toggleRef}
+        title={summary}
+        type="button"
+      >
+        <span className="filter-dropdown-value" id={valueId}>
+          {summary}
+        </span>
+        <ChevronDown aria-hidden="true" size={14} strokeWidth={2} />
+      </button>
+      {isOpen ? (
+        <div
+          aria-labelledby={labelId}
+          className="filter-dropdown-panel"
+          id={panelId}
+          role="group"
+        >
+          {options.length === 0 ? (
+            <div className="filter-dropdown-empty">{emptyLabel}</div>
+          ) : (
+            <>
+              <label className="filter-dropdown-option filter-dropdown-option-all">
+                <input
+                  checked={selected.length === 0}
+                  onChange={() => onChange([])}
+                  type="checkbox"
+                />
+                Alle
+              </label>
+              {options.map((option) => (
+                <label className="filter-dropdown-option" key={option.id}>
+                  <input
+                    checked={selected.includes(option.id)}
+                    onChange={() =>
+                      onChange(toggleFilterValue(selected, option.id))
+                    }
+                    type="checkbox"
+                  />
+                  {option.label}
+                </label>
+              ))}
+            </>
+          )}
+        </div>
+      ) : null}
+    </div>
+  );
+}
diff --git a/src/frontend/components/project-version-history.tsx b/src/frontend/components/project-version-history.tsx
index 3907640..316afa4 100644
--- a/src/frontend/components/project-version-history.tsx
+++ b/src/frontend/components/project-version-history.tsx
@@ -28,6 +28,14 @@ import {
   getProjectSnapshotRevisionDescription,
   mergeProjectRevisionPages,
 } from "../utils/project-version-history";
+import {
+  ChevronDown,
+  ChevronUp,
+  Redo2,
+  RotateCcw,
+  Undo2,
+} from "lucide-react";
+import { IconButton, IconButtonSeparator } from "./icon-button";
 
 interface ProjectVersionHistoryProps {
   projectId: string;
@@ -234,50 +242,50 @@ export function ProjectVersionHistory({
           <span className="badge text-bg-secondary">
             Aktuelle Revision {currentRevision}
           </span>
-          <button
-            className="btn btn-sm btn-outline-secondary"
-            disabled={
-              isBusy ||
-              isHistoryLoading ||
-              !historyIsCurrent ||
-              !history?.undoDepth
-            }
-            onClick={() => void handleHistoryCommand("undo")}
-            title={
-              history?.undoDepth
-                ? `${history.undoDepth} Änderung(en) können rückgängig gemacht werden`
-                : "Keine Änderung zum Rückgängigmachen"
-            }
-            type="button"
-          >
-            Rückgängig
-          </button>
-          <button
-            className="btn btn-sm btn-outline-secondary"
-            disabled={
-              isBusy ||
-              isHistoryLoading ||
-              !historyIsCurrent ||
-              !history?.redoDepth
-            }
-            onClick={() => void handleHistoryCommand("redo")}
-            title={
-              history?.redoDepth
-                ? `${history.redoDepth} Änderung(en) können wiederholt werden`
-                : "Keine Änderung zum Wiederholen"
-            }
-            type="button"
-          >
-            Wiederholen
-          </button>
-          <button
-            aria-expanded={isOpen}
-            className="btn btn-sm btn-outline-secondary"
-            onClick={() => setIsOpen((current) => !current)}
-            type="button"
-          >
-            {isOpen ? "Ausblenden" : "Anzeigen"}
-          </button>
+          <div className="overview-actions">
+            <IconButton
+              disabled={
+                isBusy ||
+                isHistoryLoading ||
+                !historyIsCurrent ||
+                !history?.undoDepth
+              }
+              icon={Undo2}
+              label="Rückgängig"
+              onClick={() => void handleHistoryCommand("undo")}
+              showLabel
+              title={
+                history?.undoDepth
+                  ? `${history.undoDepth} Änderung(en) können rückgängig gemacht werden`
+                  : "Keine Änderung zum Rückgängigmachen"
+              }
+            />
+            <IconButton
+              disabled={
+                isBusy ||
+                isHistoryLoading ||
+                !historyIsCurrent ||
+                !history?.redoDepth
+              }
+              icon={Redo2}
+              label="Wiederholen"
+              onClick={() => void handleHistoryCommand("redo")}
+              showLabel
+              title={
+                history?.redoDepth
+                  ? `${history.redoDepth} Änderung(en) können wiederholt werden`
+                  : "Keine Änderung zum Wiederholen"
+              }
+            />
+            <IconButtonSeparator />
+            <IconButton
+              ariaExpanded={isOpen}
+              icon={isOpen ? ChevronUp : ChevronDown}
+              label={isOpen ? "Ausblenden" : "Anzeigen"}
+              onClick={() => setIsOpen((current) => !current)}
+              showLabel
+            />
+          </div>
         </div>
       </div>
       {error ? (
@@ -381,14 +389,15 @@ export function ProjectVersionHistory({
                     </td>
                     <td>{formatDateTime(snapshot.createdAtIso)}</td>
                     <td className="text-end">
-                      <button
-                        className="btn btn-sm btn-outline-danger"
-                        disabled={isBusy}
-                        onClick={() => setRestoreCandidate(snapshot)}
-                        type="button"
-                      >
-                        Wiederherstellen
-                      </button>
+                      <div className="overview-actions justify-content-end">
+                        <IconButton
+                          disabled={isBusy}
+                          icon={RotateCcw}
+                          label="Wiederherstellen"
+                          onClick={() => setRestoreCandidate(snapshot)}
+                          variant="danger"
+                        />
+                      </div>
                     </td>
                   </tr>
                 ))}
diff --git a/src/frontend/utils/overview-filters.ts b/src/frontend/utils/overview-filters.ts
new file mode 100644
index 0000000..6384cec
--- /dev/null
+++ b/src/frontend/utils/overview-filters.ts
@@ -0,0 +1,239 @@
+import type {
+  DistributionBoardDto,
+  FloorDto,
+  ProjectDeviceDto,
+} from "../types";
+
+/**
+ * Pure filter logic for the project overview cards (Verteilungen,
+ * Projektgeräte). Every multi-select filter uses the PM semantics: an empty
+ * selection means "Alle", otherwise a record must match one selected value.
+ * Records without a value are addressed through the dedicated "none" ids.
+ */
+
+export interface FilterOption {
+  id: string;
+  label: string;
+}
+
+/** Option id for boards without floor ("Ohne Etage"). */
+export const withoutFloorFilterId = "__without_floor__";
+/** Option id for boards without supply type ("Nicht festgelegt"). */
+export const withoutSupplyTypeFilterId = "__without_supply_type__";
+/** Option id for project devices without cost group ("Ohne Kostengruppe"). */
+export const withoutCostGroupFilterId = "__without_cost_group__";
+
+export interface DistributionBoardFilters {
+  query: string;
+  floorIds: string[];
+  supplyTypes: string[];
+}
+
+export interface ProjectDeviceFilters {
+  query: string;
+  categories: string[];
+  phaseTypes: string[];
+  costGroups: string[];
+}
+
+export const emptyDistributionBoardFilters: DistributionBoardFilters = {
+  query: "",
+  floorIds: [],
+  supplyTypes: [],
+};
+
+export const emptyProjectDeviceFilters: ProjectDeviceFilters = {
+  query: "",
+  categories: [],
+  phaseTypes: [],
+  costGroups: [],
+};
+
+export function normalizeFilterQuery(query: string) {
+  return query.trim().toLocaleLowerCase("de");
+}
+
+function matchesQuery(
+  normalizedQuery: string,
+  values: readonly (string | null | undefined)[]
+) {
+  return (
+    !normalizedQuery ||
+    values.some((value) =>
+      value?.toLocaleLowerCase("de").includes(normalizedQuery)
+    )
+  );
+}
+
+function matchesSelection(selected: readonly string[], value: string) {
+  return selected.length === 0 || selected.includes(value);
+}
+
+/** Adds or removes one value from a multi-select selection. */
+export function toggleFilterValue(selected: readonly string[], value: string) {
+  return selected.includes(value)
+    ? selected.filter((entry) => entry !== value)
+    : [...selected, value];
+}
+
+/**
+ * Drops selected values that are no longer offered (e.g. a deleted floor), so
+ * no invisible selection keeps hiding records.
+ */
+export function retainAvailableFilterValues(
+  selected: readonly string[],
+  options: readonly FilterOption[]
+) {
+  const available = new Set(options.map((option) => option.id));
+  return selected.filter((value) => available.has(value));
+}
+
+export function isDistributionBoardFilterActive(
+  filters: DistributionBoardFilters
+) {
+  return (
+    normalizeFilterQuery(filters.query) !== "" ||
+    filters.floorIds.length > 0 ||
+    filters.supplyTypes.length > 0
+  );
+}
+
+export function isProjectDeviceFilterActive(filters: ProjectDeviceFilters) {
+  return (
+    normalizeFilterQuery(filters.query) !== "" ||
+    filters.categories.length > 0 ||
+    filters.phaseTypes.length > 0 ||
+    filters.costGroups.length > 0
+  );
+}
+
+/** Floors in their configured order, followed by "Ohne Etage". */
+export function buildFloorFilterOptions(
+  floors: readonly FloorDto[]
+): FilterOption[] {
+  return [
+    ...[...floors]
+      .sort(
+        (left, right) =>
+          left.sortOrder - right.sortOrder ||
+          left.name.localeCompare(right.name, "de", { numeric: true })
+      )
+      .map((floor) => ({ id: floor.id, label: floor.name })),
+    { id: withoutFloorFilterId, label: "Ohne Etage" },
+  ];
+}
+
+/**
+ * Supply types in catalog order: every enabled or used type, plus
+ * "Nicht festgelegt" when a board has no supply type.
+ */
+export function buildSupplyTypeFilterOptions(
+  catalog: readonly string[],
+  enabledSupplyTypes: readonly string[],
+  boards: readonly Pick<DistributionBoardDto, "supplyType">[],
+  labels: Readonly<Record<string, string>>
+): FilterOption[] {
+  const offered = new Set<string>(enabledSupplyTypes);
+  let hasBoardWithoutSupplyType = false;
+  for (const board of boards) {
+    if (board.supplyType) {
+      offered.add(board.supplyType);
+    } else {
+      hasBoardWithoutSupplyType = true;
+    }
+  }
+  const options: FilterOption[] = catalog
+    .filter((supplyType) => offered.has(supplyType))
+    .map((supplyType) => ({
+      id: supplyType,
+      label: labels[supplyType] ?? supplyType,
+    }));
+  if (hasBoardWithoutSupplyType) {
+    options.push({ id: withoutSupplyTypeFilterId, label: "Nicht festgelegt" });
+  }
+  return options;
+}
+
+export function filterDistributionBoards<
+  Board extends Pick<DistributionBoardDto, "name" | "floorId" | "supplyType">,
+>(
+  boards: readonly Board[],
+  filters: DistributionBoardFilters,
+  floorNameById: ReadonlyMap<string, string>
+): Board[] {
+  const query = normalizeFilterQuery(filters.query);
+  return boards.filter(
+    (board) =>
+      matchesQuery(query, [
+        board.name,
+        board.floorId ? floorNameById.get(board.floorId) : undefined,
+      ]) &&
+      matchesSelection(
+        filters.floorIds,
+        board.floorId ?? withoutFloorFilterId
+      ) &&
+      matchesSelection(
+        filters.supplyTypes,
+        board.supplyType ?? withoutSupplyTypeFilterId
+      )
+  );
+}
+
+function getCostGroupFilterValue(costGroup: string | null) {
+  const trimmed = costGroup?.trim() ?? "";
+  return trimmed || withoutCostGroupFilterId;
+}
+
+/** Distinct cost groups in natural order, followed by "Ohne Kostengruppe". */
+export function buildCostGroupFilterOptions(
+  devices: readonly Pick<ProjectDeviceDto, "costGroup">[]
+): FilterOption[] {
+  const costGroups = new Set<string>();
+  for (const device of devices) {
+    const value = getCostGroupFilterValue(device.costGroup);
+    if (value !== withoutCostGroupFilterId) {
+      costGroups.add(value);
+    }
+  }
+  return [
+    ...[...costGroups]
+      .sort((left, right) => left.localeCompare(right, "de", { numeric: true }))
+      .map((costGroup) => ({ id: costGroup, label: costGroup })),
+    { id: withoutCostGroupFilterId, label: "Ohne Kostengruppe" },
+  ];
+}
+
+export function filterProjectDevices<
+  Device extends Pick<
+    ProjectDeviceDto,
+    | "name"
+    | "displayName"
+    | "category"
+    | "phaseType"
+    | "connectionKind"
+    | "costGroup"
+  >,
+>(
+  devices: readonly Device[],
+  filters: ProjectDeviceFilters,
+  categoryLabels: Readonly<Record<string, string>> = {}
+): Device[] {
+  const query = normalizeFilterQuery(filters.query);
+  return devices.filter(
+    (device) =>
+      matchesQuery(query, [
+        device.name,
+        device.displayName,
+        device.category,
+        categoryLabels[device.category],
+        device.connectionKind,
+        device.costGroup,
+      ]) &&
+      matchesSelection(filters.categories, device.category) &&
+      matchesSelection(filters.phaseTypes, device.phaseType) &&
+      matchesSelection(
+        filters.costGroups,
+        getCostGroupFilterValue(device.costGroup)
+      )
+  );
+}
diff --git a/tests/overview-filters.test.ts b/tests/overview-filters.test.ts
new file mode 100644
index 0000000..8c87345
--- /dev/null
+++ b/tests/overview-filters.test.ts
@@ -0,0 +1,248 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  buildCostGroupFilterOptions,
+  buildFloorFilterOptions,
+  buildSupplyTypeFilterOptions,
+  emptyDistributionBoardFilters,
+  emptyProjectDeviceFilters,
+  filterDistributionBoards,
+  filterProjectDevices,
+  isDistributionBoardFilterActive,
+  isProjectDeviceFilterActive,
+  retainAvailableFilterValues,
+  toggleFilterValue,
+  withoutCostGroupFilterId,
+  withoutFloorFilterId,
+  withoutSupplyTypeFilterId,
+} from "../src/frontend/utils/overview-filters.js";
+import type {
+  DistributionBoardDto,
+  FloorDto,
+  ProjectDeviceDto,
+} from "../src/frontend/types.js";
+
+type TestBoard = Pick<
+  DistributionBoardDto,
+  "id" | "name" | "floorId" | "supplyType"
+>;
+
+function board(
+  id: string,
+  name: string,
+  floorId: string | null,
+  supplyType: DistributionBoardDto["supplyType"]
+): TestBoard {
+  return { id, name, floorId, supplyType };
+}
+
+function device(
+  id: string,
+  overrides: Partial<ProjectDeviceDto>
+): ProjectDeviceDto {
+  return {
+    id,
+    projectId: "project-1",
+    name: `device-${id}`,
+    displayName: `Gerät ${id}`,
+    phaseType: "single_phase",
+    connectionKind: null,
+    costGroup: null,
+    category: "single_phase",
+    quantity: 1,
+    powerPerUnit: 1,
+    simultaneityFactor: 1,
+    totalPower: 1,
+    cosPhi: null,
+    remark: null,
+    voltageV: null,
+    ...overrides,
+  };
+}
+
+const floors: FloorDto[] = [
+  { id: "floor-og", projectId: "project-1", name: "1. OG", sortOrder: 2 },
+  { id: "floor-eg", projectId: "project-1", name: "EG", sortOrder: 1 },
+];
+const floorNameById = new Map(floors.map((floor) => [floor.id, floor.name]));
+
+const boards = [
+  board("b1", "UV-EG-01", "floor-eg", "AV"),
+  board("b2", "UV-OG-01", "floor-og", "SV"),
+  board("b3", "HV", null, "AV"),
+  board("b4", "SiBe-Zentrale", null, null),
+];
+
+describe("overview filters: distribution boards", () => {
+  it("returns every board without an active filter", () => {
+    assert.equal(isDistributionBoardFilterActive(emptyDistributionBoardFilters), false);
+    assert.deepEqual(
+      filterDistributionBoards(boards, emptyDistributionBoardFilters, floorNameById),
+      boards
+    );
+  });
+
+  it("searches board and floor names case-insensitively and ignores blank queries", () => {
+    const byFloorName = filterDistributionBoards(
+      boards,
+      { ...emptyDistributionBoardFilters, query: "  og " },
+      floorNameById
+    );
+    assert.deepEqual(byFloorName.map((entry) => entry.id), ["b2"]);
+    const byBoardName = filterDistributionBoards(
+      boards,
+      { ...emptyDistributionBoardFilters, query: "sibe" },
+      floorNameById
+    );
+    assert.deepEqual(byBoardName.map((entry) => entry.id), ["b4"]);
+    assert.equal(
+      isDistributionBoardFilterActive({ ...emptyDistributionBoardFilters, query: "   " }),
+      false
+    );
+  });
+
+  it("filters floors with the dedicated option for boards without floor", () => {
+    const result = filterDistributionBoards(
+      boards,
+      { ...emptyDistributionBoardFilters, floorIds: ["floor-eg", withoutFloorFilterId] },
+      floorNameById
+    );
+    assert.deepEqual(result.map((entry) => entry.id), ["b1", "b3", "b4"]);
+  });
+
+  it("combines supply type with the other criteria", () => {
+    const filters = {
+      query: "",
+      floorIds: [withoutFloorFilterId],
+      supplyTypes: ["AV"],
+    };
+    assert.equal(isDistributionBoardFilterActive(filters), true);
+    assert.deepEqual(
+      filterDistributionBoards(boards, filters, floorNameById).map((entry) => entry.id),
+      ["b3"]
+    );
+    assert.deepEqual(
+      filterDistributionBoards(
+        boards,
+        { ...emptyDistributionBoardFilters, supplyTypes: [withoutSupplyTypeFilterId] },
+        floorNameById
+      ).map((entry) => entry.id),
+      ["b4"]
+    );
+  });
+
+  it("offers floors in configured order followed by 'Ohne Etage'", () => {
+    assert.deepEqual(buildFloorFilterOptions(floors), [
+      { id: "floor-eg", label: "EG" },
+      { id: "floor-og", label: "1. OG" },
+      { id: withoutFloorFilterId, label: "Ohne Etage" },
+    ]);
+  });
+
+  it("offers enabled and used supply types in catalog order", () => {
+    const options = buildSupplyTypeFilterOptions(
+      ["AV", "SV", "EV", "USV"],
+      ["USV", "AV"],
+      boards,
+      { AV: "AV – Allgemein", SV: "SV – Sicherheit" }
+    );
+    assert.deepEqual(options, [
+      { id: "AV", label: "AV – Allgemein" },
+      { id: "SV", label: "SV – Sicherheit" },
+      { id: "USV", label: "USV" },
+      { id: withoutSupplyTypeFilterId, label: "Nicht festgelegt" },
+    ]);
+  });
+});
+
+describe("overview filters: project devices", () => {
+  const devices = [
+    device("d1", {
+      displayName: "Steckdose Büro",
+      costGroup: "444",
+      connectionKind: "Steckdose",
+    }),
+    device("d2", {
+      displayName: "Durchlauferhitzer",
+      phaseType: "three_phase",
+      category: "three_phase",
+      costGroup: " 445 ",
+    }),
+    device("d3", {
+      displayName: "Downlight",
+      category: "lighting",
+      costGroup: "  ",
+    }),
+    device("d4", { displayName: "Kaffeemaschine", costGroup: null }),
+  ];
+
+  it("searches names, connection kind, cost group and the German category label", () => {
+    assert.deepEqual(
+      filterProjectDevices(devices, { ...emptyProjectDeviceFilters, query: "STECK" }).map(
+        (entry) => entry.id
+      ),
+      ["d1"]
+    );
+    assert.deepEqual(
+      filterProjectDevices(
+        devices,
+        { ...emptyProjectDeviceFilters, query: "beleucht" },
+        { lighting: "Beleuchtung" }
+      ).map((entry) => entry.id),
+      ["d3"]
+    );
+  });
+
+  it("filters category, phase type and cost group together", () => {
+    const filters = {
+      query: "",
+      categories: ["single_phase", "three_phase"],
+      phaseTypes: ["three_phase"],
+      costGroups: ["445"],
+    };
+    assert.equal(isProjectDeviceFilterActive(filters), true);
+    assert.deepEqual(
+      filterProjectDevices(devices, filters).map((entry) => entry.id),
+      ["d2"]
+    );
+  });
+
+  it("treats blank cost groups as 'Ohne Kostengruppe'", () => {
+    assert.deepEqual(
+      filterProjectDevices(devices, {
+        ...emptyProjectDeviceFilters,
+        costGroups: [withoutCostGroupFilterId],
+      }).map((entry) => entry.id),
+      ["d3", "d4"]
+    );
+    assert.deepEqual(buildCostGroupFilterOptions(devices), [
+      { id: "444", label: "444" },
+      { id: "445", label: "445" },
+      { id: withoutCostGroupFilterId, label: "Ohne Kostengruppe" },
+    ]);
+  });
+
+  it("returns an empty list when the filters hide every device", () => {
+    assert.deepEqual(
+      filterProjectDevices(devices, { ...emptyProjectDeviceFilters, query: "gibt es nicht" }),
+      []
+    );
+    assert.equal(isProjectDeviceFilterActive(emptyProjectDeviceFilters), false);
+  });
+});
+
+describe("overview filters: selection helpers", () => {
+  it("toggles values without mutating the selection", () => {
+    const selected = ["a"];
+    assert.deepEqual(toggleFilterValue(selected, "b"), ["a", "b"]);
+    assert.deepEqual(toggleFilterValue(selected, "a"), []);
+    assert.deepEqual(selected, ["a"]);
+  });
+
+  it("drops selected values that are no longer offered", () => {
+    assert.deepEqual(
+      retainAvailableFilterValues(["floor-eg", "deleted-floor"], buildFloorFilterOptions(floors)),
+      ["floor-eg"]
+    );
+  });
+});

From acff38afb8ba286c41646c7a8849cf840f838b82 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 13:15:54 +0200
Subject: [PATCH 19/60] Show a printer icon on the print view button

The "Seitenansicht" link in the project header had text only, while the
other header buttons show an icon plus text.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/app/projects/[projectId]/page.tsx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index 73f9460..c090ec5 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -60,6 +60,7 @@ import {
   toDistributionBoardInfoDraft,
   type DistributionBoardInfoDraft,
 } from "../../../frontend/components/distribution-board-info-card";
+import { Printer } from "lucide-react";
 import {
   ProjectSettingsModal,
   type ProjectSettingsInput,
@@ -867,10 +868,11 @@ export default function ProjectDetailPage() {
         </div>
         <div className="d-flex gap-2">
           <Link
-            className="btn btn-primary"
+            className="btn btn-primary d-inline-flex align-items-center gap-2"
             href={`/projects/${projectId}/print`}
             target="_blank"
           >
+            <Printer aria-hidden="true" size={16} />
             Seitenansicht
           </Link>
           <button

From 68b9ee850b55d06a4578251b0a9f1cdfcc1975c5 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 13:16:22 +0200
Subject: [PATCH 20/60] Search board info fields and confirm project device
 deletion

The distribution-board search also matches board number and location as
soon as the boards carry them (distribution-board info card of
feature/print-view); the fields are optional in the filter, so the branch
works with and without them. Deleting a project device now asks for
confirmation like the other delete actions, since the row action is a
small trash icon.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/app/projects/[projectId]/page.tsx  |  7 ++++++-
 src/frontend/utils/overview-filters.ts | 12 +++++++++++-
 tests/overview-filters.test.ts         | 23 +++++++++++++++++++++++
 3 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index f937804..fca0b4b 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -476,6 +476,11 @@ export default function ProjectDetailPage() {
     if (!projectId || !project) {
       return;
     }
+    const device = projectDevices.find((item) => item.id === projectDeviceId);
+    const deviceName = device?.displayName || device?.name || "Projektgerät";
+    if (!window.confirm(`Projektgerät „${deviceName}“ wirklich löschen?`)) {
+      return;
+    }
     setIsSaving(true);
     setError(null);
     try {
@@ -1053,7 +1058,7 @@ export default function ProjectDetailPage() {
                 onChange={(query) =>
                   setBoardFilters((current) => ({ ...current, query }))
                 }
-                placeholder="Verteilung oder Etage …"
+                placeholder="Name, Nr., Örtlichkeit oder Etage …"
                 value={boardFilters.query}
               />
               <MultiSelectDropdown
diff --git a/src/frontend/utils/overview-filters.ts b/src/frontend/utils/overview-filters.ts
index 6384cec..8757597 100644
--- a/src/frontend/utils/overview-filters.ts
+++ b/src/frontend/utils/overview-filters.ts
@@ -154,8 +154,16 @@ export function buildSupplyTypeFilterOptions(
   return options;
 }
 
+/**
+ * Board number and location come with the distribution-board info card
+ * (feature/print-view). They are optional here so the filter works with and
+ * without those fields and searches them as soon as the DTO carries them.
+ */
 export function filterDistributionBoards<
-  Board extends Pick<DistributionBoardDto, "name" | "floorId" | "supplyType">,
+  Board extends Pick<DistributionBoardDto, "name" | "floorId" | "supplyType"> & {
+    boardNumber?: string | null;
+    location?: string | null;
+  },
 >(
   boards: readonly Board[],
   filters: DistributionBoardFilters,
@@ -166,6 +174,8 @@ export function filterDistributionBoards<
     (board) =>
       matchesQuery(query, [
         board.name,
+        board.boardNumber,
+        board.location,
         board.floorId ? floorNameById.get(board.floorId) : undefined,
       ]) &&
       matchesSelection(
diff --git a/tests/overview-filters.test.ts b/tests/overview-filters.test.ts
index 8c87345..84c5807 100644
--- a/tests/overview-filters.test.ts
+++ b/tests/overview-filters.test.ts
@@ -82,6 +82,29 @@ describe("overview filters: distribution boards", () => {
     );
   });
 
+  it("also searches board number and location when the boards carry them", () => {
+    const withInfo = [
+      { ...boards[0]!, boardNumber: "UV 0.1", location: "Raum 003 Technik" },
+      { ...boards[1]!, boardNumber: null, location: null },
+    ];
+    assert.deepEqual(
+      filterDistributionBoards(
+        withInfo,
+        { ...emptyDistributionBoardFilters, query: "uv 0.1" },
+        floorNameById
+      ).map((entry) => entry.id),
+      [withInfo[0]!.id]
+    );
+    assert.deepEqual(
+      filterDistributionBoards(
+        withInfo,
+        { ...emptyDistributionBoardFilters, query: "technik" },
+        floorNameById
+      ).map((entry) => entry.id),
+      [withInfo[0]!.id]
+    );
+  });
+
   it("searches board and floor names case-insensitively and ignores blank queries", () => {
     const byFloorName = filterDistributionBoards(
       boards,

From 37a70b6b363959d3018c48d5c40b94e1d25a3163 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 14:50:48 +0200
Subject: [PATCH 21/60] Add the rough power balance module for early design
 phases
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In LPH 2/3 there are no circuits yet, but the office needs a power
balance by DIN 276 cost group, as in the Excel template "Leistungsbilanz -
KG400": each trade enters consumers by piece or by area (W/m²) with GLF
and cos phi; the balance sums AV and SV per cost group, adds a reserve and
derives the maximum current.

The module is separate from the circuit structure: own tables
(migration 0010), own folder src/estimate-balance and an import-free
shared calculation used by API and UI. Writes go through project commands
(estimate-balance.insert/.update/.delete with complete documents), so
revision checks and Undo/Redo apply; it is not part of project snapshots
or transfer yet. A comparison endpoint sums the device rows of all circuit
lists by cost group (longest prefix) against the estimate.

The UI adds a sidebar entry, a list of Stände (template KG 400, empty or
copy) and a spreadsheet-like editor with autosave, AMEV picker for the
GLF, totals, reserve, maximum current, comparison table and print layout.
The tests reproduce the template example exactly (143.24 kW, 148.48 kVA,
157.56 kW / 163.33 kVA with 10 % reserve, 235.75 A). See
docs/estimate-balance.md and issue #7.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |   21 +
 docs/README.md                                |    2 +
 docs/circuit-list-editor-api.md               |    6 +
 docs/estimate-balance.md                      |  108 +
 scripts/db-verify-circuit-schema.js           |    3 +
 src/app/globals.css                           |  490 +++
 .../grobbilanz/[balanceId]/page.tsx           |  743 +++++
 .../projects/[projectId]/grobbilanz/page.tsx  |  292 ++
 src/db/migrations/0010_estimate_balances.sql  |   43 +
 src/db/migrations/meta/0010_snapshot.json     | 2931 +++++++++++++++++
 src/db/migrations/meta/_journal.json          |    7 +
 ...mate-balance-project-command.repository.ts |  132 +
 .../estimate-balance.persistence.ts           |  121 +
 .../estimate-balance.repository.ts            |   60 +
 src/db/schema/estimate-balances.ts            |   61 +
 .../services/project-command.service.ts       |   30 +-
 .../api/estimate-balance-request.schemas.ts   |   33 +
 .../domain/estimate-balance-command.model.ts  |  320 ++
 .../estimate-balance-project-command.store.ts |   24 +
 src/frontend/components/Sidebar.tsx           |    1 +
 .../estimate-balance-create-modal.tsx         |  162 +
 .../estimate-balance-document.ts              |  301 ++
 .../estimate-balance-format.ts                |  122 +
 .../estimate-balance-sheet.tsx                |  652 ++++
 .../estimate-comparison-table.tsx             |   88 +
 .../estimate-balance/estimate-draft-input.tsx |  107 +
 .../estimate-balance/estimate-group-modal.tsx |  128 +
 src/frontend/types.ts                         |   31 +
 src/frontend/utils/api.ts                     |  104 +-
 src/frontend/utils/project-version-history.ts |    3 +
 .../composition/application-repositories.ts   |    2 +
 .../composition/project-command-stores.ts     |    6 +-
 .../estimate-balance.controller.ts            |  180 +
 src/server/routes/project.routes.ts           |   17 +
 .../estimate-balance/estimate-balance.ts      |  316 ++
 tests/estimate-balance-frontend.test.ts       |  435 +++
 tests/estimate-balance.test.ts                |  459 +++
 37 files changed, 8537 insertions(+), 4 deletions(-)
 create mode 100644 docs/estimate-balance.md
 create mode 100644 src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx
 create mode 100644 src/app/projects/[projectId]/grobbilanz/page.tsx
 create mode 100644 src/db/migrations/0010_estimate_balances.sql
 create mode 100644 src/db/migrations/meta/0010_snapshot.json
 create mode 100644 src/db/repositories/estimate-balance-project-command.repository.ts
 create mode 100644 src/db/repositories/estimate-balance.persistence.ts
 create mode 100644 src/db/repositories/estimate-balance.repository.ts
 create mode 100644 src/db/schema/estimate-balances.ts
 create mode 100644 src/estimate-balance/api/estimate-balance-request.schemas.ts
 create mode 100644 src/estimate-balance/domain/estimate-balance-command.model.ts
 create mode 100644 src/estimate-balance/domain/estimate-balance-project-command.store.ts
 create mode 100644 src/frontend/estimate-balance/estimate-balance-create-modal.tsx
 create mode 100644 src/frontend/estimate-balance/estimate-balance-document.ts
 create mode 100644 src/frontend/estimate-balance/estimate-balance-format.ts
 create mode 100644 src/frontend/estimate-balance/estimate-balance-sheet.tsx
 create mode 100644 src/frontend/estimate-balance/estimate-comparison-table.tsx
 create mode 100644 src/frontend/estimate-balance/estimate-draft-input.tsx
 create mode 100644 src/frontend/estimate-balance/estimate-group-modal.tsx
 create mode 100644 src/server/controllers/estimate-balance.controller.ts
 create mode 100644 src/shared/estimate-balance/estimate-balance.ts
 create mode 100644 tests/estimate-balance-frontend.test.ts
 create mode 100644 tests/estimate-balance.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index 77b0170..d435cf3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -576,6 +576,27 @@ Future sizing will need:
 
 Users must be able to override sizing suggestions.
 
+## Estimate Balance Module (Grobe Leistungsbilanz)
+
+`src/estimate-balance` plus `src/shared/estimate-balance` is a separate module
+for the early-phase power balance by DIN 276 cost group (see
+`docs/estimate-balance.md`). Rules:
+
+- It has its own tables (`estimate_*`) and never writes circuit, board or
+  project-device data; it only reads device rows for the comparison.
+- Writes use the project command mechanism (`estimate-balance.insert/.update/
+  .delete` with complete documents), so revision checks and Undo/Redo apply.
+- The calculation and comparison live in the import-free
+  `src/shared/estimate-balance/estimate-balance.ts` and are shared by API and UI;
+  displayed values use `roundEstimateValue`.
+- It is not part of project snapshots or project transfer yet (open question
+  in issue #7); do not add it there without a snapshot schema version.
+- UI: `/projects/:id/grobbilanz` (Stände) and `/grobbilanz/:balanceId` (editor,
+  `src/frontend/estimate-balance/`). The editor autosaves the whole document
+  debounced (one Undo step per save), keeps invalid raw input local, and on a
+  409 reloads only if the balance itself changed; otherwise it re-saves with
+  the new revision. `request()` throws `ApiRequestError` (status, code).
+
 ## Persistence and Migration Rules
 
 - SQLite is the currently supported database.
diff --git a/docs/README.md b/docs/README.md
index cdddb67..09a3668 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -16,6 +16,8 @@ ausdrücklich getrennt und dürfen nicht als bereits implementiert verstanden we
   Verteilerübersicht, Verteilerpläne, Büro-Logo
 - [Gebäudestruktur](building-structure.md) – Gebäude → Etagen → Räume,
   Befehle, Snapshot-Schema 7, eigene Seite
+- [Grobe Leistungsbilanz](estimate-balance.md) – LPH 2/3 nach Kostengruppen,
+  Rechnung, Vergleich mit der detaillierten Bilanz
 - [Editor-API](circuit-list-editor-api.md) – unterstützte Circuit-First-Endpunkte
 - [Bekannte Einschränkungen](circuit-list-editor-known-limitations.md) –
   bewusst noch nicht implementierte oder begrenzte Funktionen
diff --git a/docs/circuit-list-editor-api.md b/docs/circuit-list-editor-api.md
index 156be62..8e6e720 100644
--- a/docs/circuit-list-editor-api.md
+++ b/docs/circuit-list-editor-api.md
@@ -214,6 +214,12 @@ A stale `expectedRevision` returns HTTP `409` with
 `PROJECT_REVISION_CONFLICT`. Undo or redo without an eligible stack entry
 returns HTTP `409` with `PROJECT_HISTORY_OPERATION_UNAVAILABLE`.
 
+## Estimate Balance (Grobe Leistungsbilanz)
+
+Separate module under `/projects/:projectId/estimate-balances`; complete
+documents are written through `estimate-balance.insert/.update/.delete` project
+commands. Endpoints, payloads and calculation rules: `docs/estimate-balance.md`.
+
 ## Circuit-First Endpoints
 
 ### Distribution Board Setup
diff --git a/docs/estimate-balance.md b/docs/estimate-balance.md
new file mode 100644
index 0000000..4e43cec
--- /dev/null
+++ b/docs/estimate-balance.md
@@ -0,0 +1,108 @@
+# Grobe Leistungsbilanz (LPH 2/3)
+
+Eigenes Modul für die Leistungsbilanz der Vor- und Entwurfsplanung, gegliedert
+nach Kostengruppen (DIN 276, KG 400). Es gibt dort noch keine Verteilungen und
+Stromkreise: Jedes Gewerk trägt unter seiner Kostengruppe Verbraucher als
+Stückzahl mit Einzelleistung oder als Fläche mit W/m² ein. Aufbau und Rechnung
+folgen der bisherigen Excel-Vorlage „Leistungsbilanz – KG400“. Abstimmung:
+Issue #7.
+
+Das Modul ist **nicht** mit der Stromkreisstruktur verknüpft. Es liest die
+Gerätezeilen nur für den Vergleich „geschätzt ↔ detailliert“ und schreibt
+nichts in Stromkreislisten, Verteilungen oder Projektgeräte.
+
+## Aufbau
+
+```
+src/shared/estimate-balance/estimate-balance.ts          Datenform, Rechnung, Vergleich (rein, ohne Imports)
+src/estimate-balance/domain/estimate-balance-command.model.ts   Snapshot-Schema (Zod), Befehle
+src/estimate-balance/domain/estimate-balance-project-command.store.ts   Store-Port
+src/estimate-balance/api/estimate-balance-request.schemas.ts   Request-Schemas
+src/db/schema/estimate-balances.ts                        Tabellen (Migration 0010)
+src/db/repositories/estimate-balance*.ts                  Lesen, Schreiben, Befehls-Store
+src/server/controllers/estimate-balance.controller.ts     API
+src/app/projects/[projectId]/grobbilanz/                  Übersicht der Stände und Editor
+src/frontend/estimate-balance/                            Editor-Komponenten und Helfer
+```
+
+Die gemeinsame Datei unter `src/shared/estimate-balance` hat keine Imports, weil
+das Frontend sie direkt nutzt (Turbopack löst die `.js`-Suffixe der API nicht auf).
+
+## Datenmodell
+
+| Tabelle | Inhalt |
+|---|---|
+| `estimate_balances` | ein **Stand** je Projekt (z. B. Vorplanung, Entwurfsplanung): Name, LPH, Datum, Reserve AV/SV in %, Sortierung |
+| `estimate_groups` | Kostengruppe (`"410"` … `"480"`, `""` für „Allgemein“), Titel, „bearbeitet von“, Sortierung |
+| `estimate_rows` | Versorgung, Stromkreis-Nr. (Freitext), Verbraucher/Fläche, Anzahl bzw. Fläche, Einheit (`piece` = St., `area` = m²), Anschluss (fest/Steckdose), Einzelleistung in W bzw. W/m², GLF, cos φ, SV ja/nein, Anmerkung |
+
+Neue Stände entstehen aus der Vorlage KG 400 (410 Sanitär, 420 Wärme, 430 Luft,
+434 Kälte, 440 Starkstrom, 450 Schwachstrom, 460 Förder, 470 Nutzungsspezifisch,
+480 GA, Allgemein; Reserve AV 10 %), leer oder als Kopie eines bestehenden
+Stands mit neuen IDs. So lässt sich ein Stand einfrieren und später vergleichen.
+
+## Rechnung
+
+- Zeile: P = Anzahl bzw. Fläche × Einzelleistung × GLF, S = P / cos φ.
+- **AV** enthält alle Verbraucher (Normalversorgung). **SV** listet zusätzlich
+  die Zeilen mit „SV = ja“, die auch aus der Sicherheitsstromversorgung versorgt
+  werden müssen. Das ist die Lesart der Vorlage; die Regel liegt in
+  `calculateEstimateRow` und lässt sich dort zentral ändern.
+- Summen je Kostengruppe, Gesamtsumme, Reserve in % (AV und SV getrennt),
+  Leistung inklusive Reserve und Maximalstrom I = S / (√3 · U) mit der
+  Drehstromspannung aus den Projekteinstellungen.
+- Anzeige wie in der Tabellenkalkulation gerundet (`roundEstimateValue`,
+  40,175 → 40,18). Der Test `tests/estimate-balance.test.ts` rechnet das
+  Beispiel der Vorlage vollständig nach (143,24 kW, 148,48 kVA, mit 10 %
+  Reserve 157,56 kW / 163,33 kVA, 235,75 A).
+
+## Vergleich geschätzt ↔ detailliert
+
+`GET …/comparison` summiert alle Gerätezeilen aller Stromkreislisten des
+Projekts (Anzahl × Leistung je Stück × Geräte-GZF, wie der Stromkreisbaum) und
+ordnet sie über das Feld **Kostengruppe** der Gerätezeile zu. Maßgeblich ist das
+längste passende Präfix: `434` → Gruppe 434, `431` → Gruppe 430, `444` → 440.
+Zeilen ohne passende Kostengruppe erscheinen als „nicht zugeordnet“. Der
+Verteiler-GZF wird auf keiner Seite angewendet; ein fehlendes cos φ zählt als 1.
+Verglichen wird die AV-Leistung (kW) mit Differenz absolut und in %.
+
+## Befehle, Undo/Redo
+
+Alle Änderungen laufen über den bestehenden Projekt-Befehlsmechanismus mit
+Revision, Inverse und persistentem Undo/Redo:
+
+- `estimate-balance.insert` / `estimate-balance.delete` mit dem vollständigen
+  Stand (Gruppen und Zeilen)
+- `estimate-balance.update` mit vollständigem `expected`/`target`-Dokument; der
+  Store prüft, dass der gespeicherte Stand genau `expected` entspricht, und
+  ersetzt ihn atomar. Die Inverse ist das vertauschte Paar.
+
+Der Editor speichert das ganze Dokument verzögert (Autosave); jeder
+Speichervorgang ist ein Undo-Schritt. Unveränderte Dokumente erzeugen keine
+Revision (`{ unchanged: true }`).
+
+## Bewusst nicht enthalten (Fragen an Julian, Issue #7)
+
+- Die grobe Bilanz ist **nicht** Teil von Projekt-Snapshot, Restore und
+  Projekttransfer; das Snapshot-Schema bleibt unverändert. Ein Restore lässt
+  die Stände unverändert, eine Projektkopie übernimmt sie nicht.
+- Keine Rechte je Gewerk; „bearbeitet von“ ist ein Freitext je Kostengruppe.
+- Kostengruppen der Gerätezeilen sind nicht normiert; der Vergleich arbeitet
+  mit Präfixen.
+
+## API
+
+- `GET /api/projects/:projectId/estimate-balances`
+- `POST /api/projects/:projectId/estimate-balances` –
+  `{ "expectedRevision": 7, "name": "Entwurfsplanung", "workStage": "LPH 3", "dateIso": "2026-09-26", "template": "kg400" }`
+  (`template`: `kg400` | `empty` | `copy` mit `copyFromBalanceId`)
+- `GET /api/projects/:projectId/estimate-balances/:balanceId`
+- `PUT /api/projects/:projectId/estimate-balances/:balanceId` –
+  `{ "expectedRevision": 8, "balance": { …vollständiges Dokument… } }`
+- `DELETE /api/projects/:projectId/estimate-balances/:balanceId` – `{ "expectedRevision": 9 }`
+- `GET /api/projects/:projectId/estimate-balances/:balanceId/comparison`
+
+Validierung: Name 1–200 Zeichen, getrimmte Texte, Anzahl/Fläche und
+Einzelleistung ≥ 0, GLF 0–1, cos φ > 0 bis 1, Reserve 0–100 %, Datum
+`YYYY-MM-DD`, eindeutige Gruppen- und Zeilen-IDs, unbekannte Felder werden
+abgelehnt.
diff --git a/scripts/db-verify-circuit-schema.js b/scripts/db-verify-circuit-schema.js
index 947767a..fa91cc4 100644
--- a/scripts/db-verify-circuit-schema.js
+++ b/scripts/db-verify-circuit-schema.js
@@ -6,6 +6,9 @@ const db = new Database(dbPath, { readonly: true });
 
 const requiredTables = [
   "buildings",
+  "estimate_balances",
+  "estimate_groups",
+  "estimate_rows",
   "circuit_sections",
   "circuits",
   "circuit_device_rows",
diff --git a/src/app/globals.css b/src/app/globals.css
index 0c40c5c..b3f526a 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -1602,3 +1602,493 @@ button.structure-entry-main:focus-visible {
   color: var(--color-ink-soft);
   font-size: 0.9rem;
 }
+
+/* ── Grobe Leistungsbilanz ──────────────────────────────────────────── */
+/* Tabelle im Stil der Büro-Vorlage „Leistungsbilanz – KG400“: kompakte
+   Zellen-Inputs statt Bootstrap-Formularfelder, Druck als A4 quer. */
+
+.estimate-toolbar {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: var(--space-sm);
+}
+
+.estimate-save-status {
+  display: inline-flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: var(--space-sm);
+  font-size: 0.8rem;
+}
+
+.estimate-save-badge {
+  display: inline-block;
+  padding: 0.2rem 0.55rem;
+  border-radius: 999px;
+  font-weight: 600;
+  border: 1px solid var(--color-border);
+  color: var(--color-ink-soft);
+  background: var(--color-bg);
+}
+
+.estimate-save-badge.is-saved {
+  color: var(--color-signal-dark);
+  border-color: var(--color-signal);
+}
+
+.estimate-save-badge.is-busy {
+  color: var(--color-warn);
+  border-color: var(--color-warn);
+}
+
+.estimate-save-badge.is-error {
+  color: var(--color-danger);
+  border-color: var(--color-danger);
+  background: var(--color-danger-bg);
+}
+
+.estimate-save-hint {
+  color: var(--color-danger);
+}
+
+.estimate-header-fields {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--space-sm) var(--space-lg);
+  margin-bottom: var(--space-md);
+}
+
+.estimate-header-field {
+  display: flex;
+  align-items: center;
+  gap: var(--space-sm);
+  min-width: 10rem;
+}
+
+.estimate-header-field.is-wide {
+  flex: 1 1 18rem;
+}
+
+.estimate-header-label {
+  font-size: 0.7rem;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  font-weight: 600;
+  color: var(--color-ink-soft);
+}
+
+.estimate-header-value {
+  font-weight: 600;
+}
+
+.estimate-header-input {
+  font-size: 0.95rem;
+  font-weight: 600;
+  border-color: var(--panel-border);
+}
+
+.estimate-sheet-wrap {
+  overflow-x: auto;
+}
+
+.estimate-sheet {
+  width: 100%;
+  min-width: 1400px;
+  table-layout: fixed;
+  border-collapse: collapse;
+  font-size: 0.82rem;
+  background: var(--panel-bg);
+  color: var(--text-strong);
+}
+
+.estimate-comparison {
+  min-width: 640px;
+  table-layout: auto;
+}
+
+.estimate-sheet th,
+.estimate-sheet td {
+  border: 1px solid var(--panel-border);
+  padding: 2px 4px;
+  vertical-align: middle;
+}
+
+.estimate-sheet thead th {
+  background: var(--surface-header-row);
+  font-size: 0.72rem;
+  font-weight: 700;
+  text-align: center;
+  line-height: 1.2;
+}
+
+.estimate-th-hint {
+  display: block;
+  font-size: 0.68rem;
+  font-weight: 400;
+  color: var(--text-faint);
+}
+
+.estimate-col-kg { width: 3rem; }
+.estimate-col-supply { width: 4rem; }
+.estimate-col-circuit { width: 4.6rem; }
+.estimate-col-name { width: auto; }
+.estimate-col-quantity { width: 4.8rem; }
+.estimate-col-unit { width: 3.8rem; }
+.estimate-col-connection { width: 5rem; }
+.estimate-col-power { width: 6.4rem; }
+.estimate-col-gzf { width: 6.8rem; }
+.estimate-col-cosphi { width: 3.8rem; }
+.estimate-col-result { width: 4.6rem; }
+.estimate-col-sv { width: 3.2rem; }
+.estimate-col-remark { width: 9rem; }
+.estimate-col-actions { width: 2.4rem; }
+
+.estimate-cell-input,
+.estimate-cell-select {
+  width: 100%;
+  min-width: 0;
+  border: 1px solid transparent;
+  border-radius: 3px;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  padding: 1px 4px;
+  line-height: 1.4;
+}
+
+.estimate-cell-select {
+  padding-right: 0;
+  cursor: pointer;
+}
+
+.estimate-cell-input:hover:not(:disabled),
+.estimate-cell-select:hover:not(:disabled) {
+  border-color: var(--panel-border-strong);
+}
+
+.estimate-cell-input:focus,
+.estimate-cell-select:focus {
+  outline: none;
+  border-color: var(--accent-blue);
+  background: var(--panel-bg);
+  box-shadow: 0 0 0 2px var(--accent-blue-soft-bg);
+}
+
+.estimate-cell-input.is-numeric {
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+}
+
+.estimate-cell-input.is-invalid,
+.estimate-cell-input.is-invalid:focus,
+.estimate-cell-input.is-invalid:hover {
+  border-color: var(--color-danger);
+  background: var(--color-danger-bg);
+}
+
+.estimate-cell-input::placeholder {
+  color: var(--text-faint);
+  opacity: 0.7;
+}
+
+.estimate-unit-input,
+.estimate-gzf-input {
+  display: flex;
+  align-items: center;
+  gap: 2px;
+}
+
+.estimate-unit-label {
+  flex: 0 0 auto;
+  font-size: 0.7rem;
+  color: var(--text-faint);
+  min-width: 1.9rem;
+}
+
+.estimate-amev-button {
+  flex: 0 0 auto;
+  border: 1px solid var(--panel-border-strong);
+  border-radius: 3px;
+  background: var(--panel-bg-subtle);
+  color: var(--text-subtle);
+  font-size: 0.6rem;
+  font-weight: 700;
+  letter-spacing: 0.03em;
+  padding: 1px 3px;
+  line-height: 1.3;
+}
+
+.estimate-amev-button:hover:not(:disabled) {
+  border-color: var(--accent-blue);
+  color: var(--accent-blue);
+}
+
+.estimate-number {
+  text-align: right;
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+
+.estimate-number.is-muted {
+  color: var(--text-faint);
+}
+
+.estimate-number.is-over {
+  color: var(--color-attention-dark);
+}
+
+.estimate-number.is-under {
+  color: var(--color-signal-dark);
+}
+
+.estimate-center {
+  text-align: center;
+}
+
+.estimate-cost-group-cell {
+  font-weight: 700;
+  text-align: center;
+  font-variant-numeric: tabular-nums;
+}
+
+.estimate-group-title-row td {
+  background: var(--surface-component-header);
+  font-weight: 700;
+}
+
+.estimate-group-title {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: var(--space-xs) var(--space-lg);
+}
+
+.estimate-group-name {
+  font-size: 0.9rem;
+}
+
+.estimate-group-editor {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-xs);
+  font-weight: 400;
+  font-size: 0.75rem;
+  color: var(--text-muted);
+}
+
+.estimate-group-editor .estimate-cell-input {
+  width: 12rem;
+}
+
+.estimate-group-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 2px;
+}
+
+.estimate-group-title-row .estimate-actions-cell {
+  width: auto;
+  white-space: nowrap;
+}
+
+.estimate-icon-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.15rem 0.3rem;
+  line-height: 1;
+}
+
+.estimate-actions-cell {
+  text-align: center;
+}
+
+.estimate-empty-row td {
+  color: var(--text-faint);
+  font-style: italic;
+}
+
+.estimate-subtotal-row td {
+  background: var(--panel-bg-subtle);
+  font-weight: 700;
+}
+
+.estimate-total-label {
+  text-align: right;
+  font-weight: 700;
+}
+
+.estimate-total-hint {
+  font-weight: 400;
+  color: var(--text-faint);
+}
+
+.estimate-total-row td {
+  background: var(--surface-header-row);
+  font-weight: 600;
+}
+
+.estimate-total-row.is-strong td {
+  font-weight: 800;
+  border-top: 2px solid var(--panel-border-strong);
+}
+
+.estimate-add-group-row td {
+  background: var(--panel-bg);
+  padding: var(--space-sm) 4px;
+}
+
+.estimate-unassigned-row td {
+  font-style: italic;
+  color: var(--text-muted);
+}
+
+.estimate-collapse-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-xs);
+  border: 0;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  font-weight: 700;
+  padding: 0;
+}
+
+.estimate-list-table .estimate-number {
+  font-variant-numeric: tabular-nums;
+}
+
+/* Druck-Textwerte: auf dem Bildschirm unsichtbar, im Druck statt Inputs */
+.estimate-print-value {
+  display: none;
+}
+
+@page estimate-balance {
+  size: A4 landscape;
+  margin: 10mm;
+}
+
+@media print {
+  body:has(.estimate-print-root) .sidebar,
+  .estimate-print-root .estimate-no-print,
+  .estimate-print-root .alert,
+  .estimate-print-root input,
+  .estimate-print-root select,
+  .estimate-print-root button {
+    display: none !important;
+  }
+
+  body:has(.estimate-print-root) {
+    background: #fff !important;
+  }
+
+  body:has(.estimate-print-root) .app-shell {
+    display: block;
+  }
+
+  .estimate-print-root {
+    page: estimate-balance;
+    padding: 0 !important;
+    max-width: none;
+    color: #000;
+  }
+
+  .estimate-print-root .estimate-print-value {
+    display: inline;
+  }
+
+  .estimate-print-root .page-header {
+    margin-bottom: 4mm;
+  }
+
+  .estimate-print-root .page-header h1 {
+    font-size: 14pt;
+    color: #000;
+  }
+
+  .estimate-print-root .card {
+    border: 0;
+    box-shadow: none;
+    background: transparent;
+  }
+
+  .estimate-print-root .card-body,
+  .estimate-print-root .card-header {
+    padding: 0;
+    background: transparent;
+    border: 0;
+  }
+
+  .estimate-print-root .estimate-comparison-card {
+    margin-top: 6mm;
+    break-inside: avoid;
+  }
+
+  .estimate-sheet-wrap {
+    overflow: visible;
+  }
+
+  .estimate-sheet {
+    min-width: 0;
+    table-layout: auto;
+    font-size: 7.5pt;
+    background: #fff;
+    color: #000;
+  }
+
+  .estimate-sheet th,
+  .estimate-sheet td {
+    border-color: #999;
+    padding: 1px 3px;
+  }
+
+  .estimate-sheet thead {
+    display: table-header-group;
+  }
+
+  .estimate-sheet thead th,
+  .estimate-total-row td {
+    background: #e8e8e8 !important;
+  }
+
+  .estimate-group-title-row td {
+    background: #d9d9d9 !important;
+  }
+
+  .estimate-subtotal-row td {
+    background: #f2f2f2 !important;
+  }
+
+  .estimate-group-title-row,
+  .estimate-subtotal-row,
+  .estimate-total-row {
+    break-inside: avoid;
+    -webkit-print-color-adjust: exact;
+    print-color-adjust: exact;
+  }
+
+  .estimate-group-title-row {
+    break-after: avoid;
+  }
+
+  /* Totals print once at the end, not repeated on every page. */
+  .estimate-sheet tfoot {
+    display: table-row-group;
+    break-inside: avoid;
+  }
+
+  .estimate-col-actions {
+    width: 0;
+  }
+
+  .estimate-unit-input,
+  .estimate-gzf-input {
+    justify-content: flex-end;
+  }
+
+  .estimate-header-fields {
+    margin-bottom: 3mm;
+  }
+}
diff --git a/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx b/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx
new file mode 100644
index 0000000..2aa7f5e
--- /dev/null
+++ b/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx
@@ -0,0 +1,743 @@
+"use client";
+
+import Link from "next/link";
+import { useParams, useRouter } from "next/navigation";
+import { type MouseEvent, useCallback, useEffect, useRef, useState } from "react";
+import {
+  ArrowLeft,
+  ChevronDown,
+  ChevronRight,
+  Printer,
+  Redo2,
+  RefreshCw,
+  Undo2,
+} from "lucide-react";
+import {
+  ApiRequestError,
+  getEstimateBalance,
+  getEstimateComparison,
+  getProject,
+  getProjectHistory,
+  isRevisionConflictError,
+  redoProjectCommand,
+  undoProjectCommand,
+  updateEstimateBalance,
+} from "../../../../../frontend/utils/api";
+import type {
+  EstimateBalanceDto,
+  EstimateComparisonDto,
+  ProjectDto,
+  ProjectHistoryStateDto,
+} from "../../../../../frontend/types";
+import type { EstimateGroupSnapshot } from "../../../../../shared/estimate-balance/estimate-balance";
+import { GzfPickerModal } from "../../../../../frontend/components/gzf-picker-modal";
+import {
+  addEstimateGroup,
+  estimateBalanceFingerprint,
+  estimateTextLimits,
+  normalizeEstimateSortOrder,
+  toSaveableEstimateBalance,
+  updateEstimateGroup,
+  updateEstimateRow,
+  validateEstimateBalance,
+} from "../../../../../frontend/estimate-balance/estimate-balance-document";
+import { formatIsoDateGerman } from "../../../../../frontend/estimate-balance/estimate-balance-format";
+import {
+  EstimateBalanceSheet,
+  type EstimateBalanceUpdate,
+} from "../../../../../frontend/estimate-balance/estimate-balance-sheet";
+import { EstimateComparisonTable } from "../../../../../frontend/estimate-balance/estimate-comparison-table";
+import { DraftInput } from "../../../../../frontend/estimate-balance/estimate-draft-input";
+import {
+  EstimateGroupModal,
+  type EstimateGroupFormValues,
+} from "../../../../../frontend/estimate-balance/estimate-group-modal";
+
+const AUTOSAVE_DELAY_MS = 800;
+const CONFLICT_MESSAGE = "Die Bilanz wurde zwischenzeitlich geändert und neu geladen.";
+
+type SaveStatus = "saved" | "pending" | "saving" | "error" | "invalid";
+
+type GroupDialog = { group: EstimateGroupSnapshot | null };
+
+function errorMessage(error: unknown, fallback: string) {
+  return error instanceof Error && error.message ? error.message : fallback;
+}
+
+function isNotFoundError(error: unknown) {
+  return error instanceof ApiRequestError && error.status === 404;
+}
+
+export default function EstimateBalanceEditorPage() {
+  const params = useParams<{ projectId: string; balanceId: string }>();
+  const { projectId, balanceId } = params;
+  const router = useRouter();
+
+  const [project, setProject] = useState<ProjectDto | null>(null);
+  const [draft, setDraft] = useState<EstimateBalanceDto | null>(null);
+  const [history, setHistory] = useState<ProjectHistoryStateDto | null>(null);
+  const [comparison, setComparison] = useState<EstimateComparisonDto | null>(null);
+  const [comparisonError, setComparisonError] = useState<string | null>(null);
+  const [isComparisonOpen, setIsComparisonOpen] = useState(false);
+  const [saveStatus, setSaveStatus] = useState<SaveStatus>("saved");
+  const [saveError, setSaveError] = useState<string | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [notice, setNotice] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [isMissing, setIsMissing] = useState(false);
+  const [isHistoryBusy, setIsHistoryBusy] = useState(false);
+  const [invalidFieldKeys, setInvalidFieldKeys] = useState<ReadonlySet<string>>(
+    () => new Set()
+  );
+  const [groupDialog, setGroupDialog] = useState<GroupDialog | null>(null);
+  const [gzfTarget, setGzfTarget] = useState<{ groupId: string; rowId: string } | null>(
+    null
+  );
+
+  // Refs carry the latest values into timers, unload handlers and chained
+  // async saves without re-creating them.
+  const draftRef = useRef<EstimateBalanceDto | null>(null);
+  const revisionRef = useRef<number | null>(null);
+  const savedFingerprintRef = useRef<string | null>(null);
+  const saveInFlightRef = useRef<Promise<boolean> | null>(null);
+  const saveTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  useEffect(() => {
+    draftRef.current = draft;
+  }, [draft]);
+
+  const applyServerBalance = useCallback((balance: EstimateBalanceDto) => {
+    const normalized = normalizeEstimateSortOrder(balance);
+    savedFingerprintRef.current = estimateBalanceFingerprint(normalized);
+    draftRef.current = normalized;
+    setDraft(normalized);
+    setSaveStatus("saved");
+    setSaveError(null);
+  }, []);
+
+  const reloadComparison = useCallback(async () => {
+    try {
+      setComparison(await getEstimateComparison(projectId, balanceId));
+      setComparisonError(null);
+    } catch (err) {
+      setComparisonError(
+        errorMessage(err, "Der Vergleich konnte nicht geladen werden.")
+      );
+    }
+  }, [balanceId, projectId]);
+
+  /** Reloads project, document and history; replaces the local draft. */
+  const reloadAll = useCallback(async () => {
+    const balanceRequest = getEstimateBalance(projectId, balanceId);
+    // Handled below; avoids an "unhandled rejection" while project/history load.
+    balanceRequest.catch(() => undefined);
+    // Project and history are applied even when the balance is missing, so
+    // Redo stays available after its creation was undone.
+    const [currentProject, currentHistory] = await Promise.all([
+      getProject(projectId),
+      getProjectHistory(projectId).catch(() => null),
+    ]);
+    setProject(currentProject);
+    revisionRef.current = currentHistory?.currentRevision ?? currentProject.currentRevision;
+    setHistory(currentHistory);
+    const balance = await balanceRequest;
+    applyServerBalance(balance);
+    setIsMissing(false);
+    void reloadComparison();
+  }, [applyServerBalance, balanceId, projectId, reloadComparison]);
+
+  const handleReloadError = useCallback((err: unknown) => {
+    if (isNotFoundError(err)) {
+      setIsMissing(true);
+      setDraft(null);
+      draftRef.current = null;
+      return;
+    }
+    setError(errorMessage(err, "Die grobe Leistungsbilanz konnte nicht geladen werden."));
+  }, []);
+
+  useEffect(() => {
+    if (!projectId || !balanceId) {
+      return;
+    }
+    setIsLoading(true);
+    reloadAll()
+      .then(() => setError(null))
+      .catch(handleReloadError)
+      .finally(() => setIsLoading(false));
+  }, [balanceId, handleReloadError, projectId, reloadAll]);
+
+  const clearSaveTimer = useCallback(() => {
+    if (saveTimerRef.current) {
+      clearTimeout(saveTimerRef.current);
+      saveTimerRef.current = null;
+    }
+  }, []);
+
+  /**
+   * Saves the current draft if it differs from the last saved state. Saves
+   * never overlap: a save requested while another runs waits for it and then
+   * saves whatever changed in the meantime. Resolves to false when the draft
+   * could not be saved.
+   */
+  const saveNow = useCallback(async (): Promise<boolean> => {
+    clearSaveTimer();
+    while (saveInFlightRef.current) {
+      await saveInFlightRef.current;
+    }
+    const current = draftRef.current;
+    const revision = revisionRef.current;
+    if (!current || revision === null) {
+      return true;
+    }
+    const fingerprint = estimateBalanceFingerprint(current);
+    if (fingerprint === savedFingerprintRef.current) {
+      setSaveStatus("saved");
+      return true;
+    }
+    const problems = validateEstimateBalance(current);
+    if (problems.length) {
+      setSaveStatus("invalid");
+      setSaveError(problems.join(" "));
+      return false;
+    }
+    const body = toSaveableEstimateBalance(current);
+
+    /**
+     * Another command changed the project revision. When this document is
+     * still unchanged on the server (e.g. an edit in a circuit list), the
+     * draft is kept and saved again; otherwise the server state wins.
+     */
+    async function resolveConflict(): Promise<"retry" | "reloaded"> {
+      const [currentProject, serverBalance, currentHistory] = await Promise.all([
+        getProject(projectId),
+        getEstimateBalance(projectId, balanceId),
+        getProjectHistory(projectId).catch(() => null),
+      ]);
+      setProject(currentProject);
+      setHistory(currentHistory);
+      revisionRef.current = currentHistory?.currentRevision ?? currentProject.currentRevision;
+      if (estimateBalanceFingerprint(serverBalance) === savedFingerprintRef.current) {
+        return "retry";
+      }
+      applyServerBalance(serverBalance);
+      setNotice(CONFLICT_MESSAGE);
+      void reloadComparison();
+      return "reloaded";
+    }
+
+    const run = (async () => {
+      setSaveStatus("saving");
+      for (let attempt = 0; ; attempt += 1) {
+        try {
+          const result = await updateEstimateBalance(
+            projectId,
+            body,
+            attempt === 0 ? revision : revisionRef.current ?? revision
+          );
+          if (!("unchanged" in result)) {
+            revisionRef.current = result.history.currentRevision;
+            setHistory(result.history);
+            setProject((currentProject) =>
+              currentProject
+                ? { ...currentProject, currentRevision: result.history.currentRevision }
+                : currentProject
+            );
+          }
+          // The sent document is the saved state; the local draft is kept so
+          // typing is never interrupted by the server's copy.
+          savedFingerprintRef.current = fingerprint;
+          setSaveError(null);
+          const latest = draftRef.current;
+          if (latest && estimateBalanceFingerprint(latest) !== fingerprint) {
+            setSaveStatus("pending");
+          } else {
+            setSaveStatus("saved");
+          }
+          void reloadComparison();
+          return true;
+        } catch (err) {
+          if (isRevisionConflictError(err)) {
+            try {
+              if (attempt === 0 && (await resolveConflict()) === "retry") {
+                continue;
+              }
+              if (attempt > 0) {
+                await reloadAll();
+                setNotice(CONFLICT_MESSAGE);
+              }
+            } catch (reloadError) {
+              handleReloadError(reloadError);
+            }
+            return false;
+          }
+          if (isNotFoundError(err)) {
+            handleReloadError(err);
+            return false;
+          }
+          setSaveStatus("error");
+          setSaveError(errorMessage(err, "Die Änderungen konnten nicht gespeichert werden."));
+          return false;
+        }
+      }
+    })();
+    saveInFlightRef.current = run;
+    try {
+      return await run;
+    } finally {
+      saveInFlightRef.current = null;
+    }
+  }, [
+    applyServerBalance,
+    balanceId,
+    clearSaveTimer,
+    handleReloadError,
+    projectId,
+    reloadAll,
+    reloadComparison,
+  ]);
+
+  // Debounced autosave after every change of the draft.
+  useEffect(() => {
+    if (!draft) {
+      return;
+    }
+    if (estimateBalanceFingerprint(draft) === savedFingerprintRef.current) {
+      return;
+    }
+    setSaveStatus((status) => (status === "saving" ? status : "pending"));
+    clearSaveTimer();
+    saveTimerRef.current = setTimeout(() => {
+      saveTimerRef.current = null;
+      void saveNow();
+    }, AUTOSAVE_DELAY_MS);
+    return clearSaveTimer;
+  }, [clearSaveTimer, draft, saveNow]);
+
+  // Save immediately when the tab is hidden; on unload/unmount send the last
+  // change with keepalive so it survives the page.
+  useEffect(() => {
+    function hasUnsavedDraft() {
+      const current = draftRef.current;
+      return Boolean(
+        current && estimateBalanceFingerprint(current) !== savedFingerprintRef.current
+      );
+    }
+    function sendKeepalive(): boolean {
+      const current = draftRef.current;
+      const revision = revisionRef.current;
+      if (
+        !current ||
+        revision === null ||
+        saveInFlightRef.current ||
+        validateEstimateBalance(current).length
+      ) {
+        return false;
+      }
+      savedFingerprintRef.current = estimateBalanceFingerprint(current);
+      void updateEstimateBalance(projectId, toSaveableEstimateBalance(current), revision, {
+        keepalive: true,
+      }).catch(() => undefined);
+      return true;
+    }
+    function handleVisibilityChange() {
+      if (document.visibilityState === "hidden" && hasUnsavedDraft()) {
+        void saveNow();
+      }
+    }
+    function handleBeforeUnload(event: BeforeUnloadEvent) {
+      if (!hasUnsavedDraft() || sendKeepalive()) {
+        return;
+      }
+      // A save is still running or the draft is invalid: let the browser ask.
+      event.preventDefault();
+      event.returnValue = "";
+    }
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => {
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+      // In-app navigation (e.g. sidebar) unmounts the editor.
+      if (hasUnsavedDraft()) {
+        sendKeepalive();
+      }
+    };
+  }, [projectId, saveNow]);
+
+  const handleChange: EstimateBalanceUpdate = useCallback((update) => {
+    setNotice(null);
+    setDraft((current) => (current ? update(current) : current));
+  }, []);
+
+  const handleValidityChange = useCallback((fieldKey: string, isValid: boolean) => {
+    setInvalidFieldKeys((current) => {
+      if (isValid ? !current.has(fieldKey) : current.has(fieldKey)) {
+        return current;
+      }
+      const next = new Set(current);
+      if (isValid) {
+        next.delete(fieldKey);
+      } else {
+        next.add(fieldKey);
+      }
+      return next;
+    });
+  }, []);
+
+  async function handleHistory(direction: "undo" | "redo") {
+    setError(null);
+    setNotice(null);
+    setIsHistoryBusy(true);
+    try {
+      // Pending edits are saved first so they become their own undo step.
+      await saveNow();
+      const revision = revisionRef.current;
+      if (revision === null) {
+        return;
+      }
+      const result =
+        direction === "undo"
+          ? await undoProjectCommand(projectId, revision)
+          : await redoProjectCommand(projectId, revision);
+      revisionRef.current = result.history.currentRevision;
+      setHistory(result.history);
+      await reloadAll();
+    } catch (err) {
+      if (isRevisionConflictError(err)) {
+        await reloadAll().catch(handleReloadError);
+        setNotice(CONFLICT_MESSAGE);
+      } else if (isNotFoundError(err)) {
+        handleReloadError(err);
+      } else {
+        setError(
+          errorMessage(
+            err,
+            direction === "undo"
+              ? "Die letzte Änderung konnte nicht rückgängig gemacht werden."
+              : "Die letzte Änderung konnte nicht wiederholt werden."
+          )
+        );
+      }
+    } finally {
+      setIsHistoryBusy(false);
+    }
+  }
+
+  async function handleBackClick(event: MouseEvent<HTMLAnchorElement>) {
+    const current = draftRef.current;
+    if (!current || estimateBalanceFingerprint(current) === savedFingerprintRef.current) {
+      return;
+    }
+    event.preventDefault();
+    await saveNow();
+    router.push(`/projects/${projectId}/grobbilanz`);
+  }
+
+  function handleSaveGroup(values: EstimateGroupFormValues) {
+    const editingGroup = groupDialog?.group ?? null;
+    handleChange((current) =>
+      editingGroup
+        ? updateEstimateGroup(current, editingGroup.id, values)
+        : addEstimateGroup(current, values).balance
+    );
+    setGroupDialog(null);
+  }
+
+  function handleSelectGzf(value: number) {
+    if (gzfTarget) {
+      handleChange((current) =>
+        updateEstimateRow(current, gzfTarget.groupId, gzfTarget.rowId, {
+          simultaneityFactor: value,
+        })
+      );
+    }
+    setGzfTarget(null);
+  }
+
+  const isEditingDisabled = !draft || isHistoryBusy;
+  const invalidCount = invalidFieldKeys.size;
+  const listHref = `/projects/${projectId}/grobbilanz`;
+
+  return (
+    <main className="container-fluid py-4 estimate-print-root">
+      <div className="page-header estimate-page-header">
+        <div className="d-flex align-items-start gap-3">
+          <Link
+            aria-label="Zurück zur Übersicht der Stände"
+            className="btn btn-outline-secondary btn-sm structure-back-link estimate-no-print"
+            href={listHref}
+            onClick={(event) => void handleBackClick(event)}
+            title="Zurück zur Übersicht der Stände"
+          >
+            <ArrowLeft aria-hidden="true" size={18} />
+          </Link>
+          <div>
+            <div className="kicker">{project?.name ?? "Projekt"}</div>
+            <h1>Grobe Leistungsbilanz{draft ? ` – ${draft.name}` : ""}</h1>
+            <p className="text-secondary mb-0 estimate-no-print">
+              Leistungsabschätzung nach Kostengruppen (DIN 276) für LPH 2/3.
+            </p>
+          </div>
+        </div>
+        <div className="estimate-toolbar estimate-no-print">
+          <SaveStatusBadge
+            error={saveError}
+            invalidCount={invalidCount}
+            onRetry={() => void saveNow()}
+            status={saveStatus}
+          />
+          <div className="btn-group btn-group-sm" role="group" aria-label="Verlauf">
+            <button
+              aria-label="Rückgängig"
+              className="btn btn-outline-secondary"
+              disabled={isHistoryBusy || !history || history.undoDepth === 0}
+              onClick={() => void handleHistory("undo")}
+              title="Rückgängig (letzte Änderung im Projekt)"
+              type="button"
+            >
+              <Undo2 aria-hidden="true" size={16} />
+            </button>
+            <button
+              aria-label="Wiederholen"
+              className="btn btn-outline-secondary"
+              disabled={isHistoryBusy || !history || history.redoDepth === 0}
+              onClick={() => void handleHistory("redo")}
+              title="Wiederholen (im Projekt)"
+              type="button"
+            >
+              <Redo2 aria-hidden="true" size={16} />
+            </button>
+          </div>
+          <button
+            aria-label="Drucken"
+            className="btn btn-sm btn-outline-secondary"
+            disabled={!draft}
+            onClick={() => window.print()}
+            title="Drucken"
+            type="button"
+          >
+            <Printer aria-hidden="true" className="me-1" size={16} />
+            Drucken
+          </button>
+        </div>
+      </div>
+
+      {notice ? (
+        <div className="alert alert-info estimate-no-print" role="status">
+          {notice}
+        </div>
+      ) : null}
+      {error ? (
+        <div className="alert alert-warning estimate-no-print" role="alert">
+          {error}
+        </div>
+      ) : null}
+      {isLoading ? (
+        <p className="text-secondary" role="status">
+          Grobe Leistungsbilanz wird geladen …
+        </p>
+      ) : null}
+      {isMissing ? (
+        <div className="alert alert-warning" role="alert">
+          Dieser Stand existiert nicht (mehr), z. B. weil er gelöscht oder sein Anlegen
+          rückgängig gemacht wurde.{" "}
+          <Link href={listHref}>Zur Übersicht der Stände</Link>
+        </div>
+      ) : null}
+
+      {draft && project ? (
+        <>
+          <section className="card shadow-sm mb-3 estimate-sheet-card">
+            <div className="card-body">
+              <div className="estimate-header-fields">
+                <div className="estimate-header-field">
+                  <span className="estimate-header-label">Projekt</span>
+                  <span className="estimate-header-value">{project.name}</span>
+                </div>
+                <label className="estimate-header-field is-wide">
+                  <span className="estimate-header-label">Stand</span>
+                  <DraftInput
+                    ariaLabel="Bezeichnung des Stands"
+                    className="estimate-cell-input estimate-header-input"
+                    disabled={isEditingDisabled}
+                    format={(value: string) => value}
+                    maxLength={estimateTextLimits.balanceName}
+                    onCommit={(name) => handleChange((current) => ({ ...current, name }))}
+                    onValidityChange={(isValid) =>
+                      handleValidityChange("balance:name", isValid)
+                    }
+                    parse={(text) =>
+                      text.trim()
+                        ? { ok: true, value: text }
+                        : { ok: false, error: "Die Bezeichnung darf nicht leer sein." }
+                    }
+                    value={draft.name}
+                  />
+                </label>
+                <label className="estimate-header-field">
+                  <span className="estimate-header-label">LPH</span>
+                  <input
+                    aria-label="Leistungsphase"
+                    className="estimate-cell-input estimate-header-input"
+                    disabled={isEditingDisabled}
+                    maxLength={estimateTextLimits.workStage}
+                    onChange={(event) =>
+                      handleChange((current) => ({
+                        ...current,
+                        workStage: event.target.value,
+                      }))
+                    }
+                    placeholder="z. B. LPH 3"
+                    type="text"
+                    value={draft.workStage ?? ""}
+                  />
+                  <span className="estimate-print-value">{draft.workStage ?? ""}</span>
+                </label>
+                <label className="estimate-header-field">
+                  <span className="estimate-header-label">Datum</span>
+                  <input
+                    aria-label="Datum"
+                    className="estimate-cell-input estimate-header-input"
+                    disabled={isEditingDisabled}
+                    onChange={(event) =>
+                      handleChange((current) => ({
+                        ...current,
+                        dateIso: event.target.value || null,
+                      }))
+                    }
+                    type="date"
+                    value={draft.dateIso ?? ""}
+                  />
+                  <span className="estimate-print-value">
+                    {formatIsoDateGerman(draft.dateIso)}
+                  </span>
+                </label>
+              </div>
+              <EstimateBalanceSheet
+                balance={draft}
+                disabled={isEditingDisabled}
+                onAddGroup={() => setGroupDialog({ group: null })}
+                onChange={handleChange}
+                onEditGroup={(group) => setGroupDialog({ group })}
+                onOpenGzfPicker={(groupId, rowId) => setGzfTarget({ groupId, rowId })}
+                onValidityChange={handleValidityChange}
+                threePhaseVoltageV={project.threePhaseVoltageV}
+              />
+            </div>
+          </section>
+
+          <section
+            className={
+              isComparisonOpen
+                ? "card shadow-sm estimate-comparison-card"
+                : "card shadow-sm estimate-comparison-card estimate-no-print"
+            }
+          >
+            <div className="card-header d-flex justify-content-between align-items-center gap-2">
+              <button
+                aria-controls="estimate-comparison-body"
+                aria-expanded={isComparisonOpen}
+                className="estimate-collapse-toggle"
+                onClick={() => setIsComparisonOpen((open) => !open)}
+                type="button"
+              >
+                {isComparisonOpen ? (
+                  <ChevronDown aria-hidden="true" size={16} />
+                ) : (
+                  <ChevronRight aria-hidden="true" size={16} />
+                )}
+                Vergleich mit detaillierter Bilanz
+              </button>
+              {isComparisonOpen ? (
+                <button
+                  aria-label="Vergleich neu laden"
+                  className="btn btn-sm btn-outline-secondary structure-icon-button estimate-no-print"
+                  onClick={() => void reloadComparison()}
+                  title="Vergleich neu laden"
+                  type="button"
+                >
+                  <RefreshCw aria-hidden="true" size={14} />
+                </button>
+              ) : null}
+            </div>
+            {isComparisonOpen ? (
+              <div className="card-body" id="estimate-comparison-body">
+                {comparisonError ? (
+                  <div className="alert alert-warning" role="alert">
+                    {comparisonError}
+                  </div>
+                ) : null}
+                {comparison ? <EstimateComparisonTable comparison={comparison} /> : null}
+                <p className="text-secondary small mt-2 mb-0">
+                  Detailliert = Summe der Gerätezeilen aller Stromkreislisten (Anzahl ×
+                  Leistung × Geräte-GZF), zugeordnet über die Kostengruppe; ohne
+                  Verteiler-GZF.
+                </p>
+              </div>
+            ) : null}
+          </section>
+        </>
+      ) : null}
+
+      {groupDialog ? (
+        <EstimateGroupModal
+          group={groupDialog.group}
+          onClose={() => setGroupDialog(null)}
+          onSave={handleSaveGroup}
+        />
+      ) : null}
+      {gzfTarget ? (
+        <GzfPickerModal onClose={() => setGzfTarget(null)} onSelect={handleSelectGzf} />
+      ) : null}
+    </main>
+  );
+}
+
+function SaveStatusBadge({
+  error,
+  invalidCount,
+  onRetry,
+  status,
+}: {
+  error: string | null;
+  invalidCount: number;
+  onRetry: () => void;
+  status: SaveStatus;
+}) {
+  const label =
+    status === "saving"
+      ? "Wird gespeichert …"
+      : status === "pending"
+        ? "Ungespeicherte Änderungen"
+        : status === "error"
+          ? "Nicht gespeichert – Fehler"
+          : status === "invalid"
+            ? "Nicht gespeichert – ungültige Eingaben"
+            : "Gespeichert";
+  const tone =
+    status === "error" || status === "invalid"
+      ? "is-error"
+      : status === "saved"
+        ? "is-saved"
+        : "is-busy";
+  return (
+    <div className="estimate-save-status" role="status" aria-live="polite">
+      <span className={`estimate-save-badge ${tone}`} title={error ?? undefined}>
+        {label}
+      </span>
+      {invalidCount ? (
+        <span className="estimate-save-hint">
+          {invalidCount === 1
+            ? "1 ungültige Eingabe wird nicht gespeichert"
+            : `${invalidCount} ungültige Eingaben werden nicht gespeichert`}
+        </span>
+      ) : null}
+      {status === "error" ? (
+        <button className="btn btn-link btn-sm p-0" onClick={onRetry} type="button">
+          Erneut versuchen
+        </button>
+      ) : null}
+    </div>
+  );
+}
diff --git a/src/app/projects/[projectId]/grobbilanz/page.tsx b/src/app/projects/[projectId]/grobbilanz/page.tsx
new file mode 100644
index 0000000..4b2cf81
--- /dev/null
+++ b/src/app/projects/[projectId]/grobbilanz/page.tsx
@@ -0,0 +1,292 @@
+"use client";
+
+import Link from "next/link";
+import { useParams, useRouter } from "next/navigation";
+import { useCallback, useEffect, useState } from "react";
+import { ArrowLeft, Copy, FolderOpen, Plus, Trash2 } from "lucide-react";
+import {
+  createEstimateBalance,
+  deleteEstimateBalance,
+  getProject,
+  listEstimateBalances,
+} from "../../../../frontend/utils/api";
+import type {
+  CreateEstimateBalanceInput,
+  EstimateBalanceDto,
+  ProjectCommandResultDto,
+  ProjectDto,
+} from "../../../../frontend/types";
+import { calculateEstimateBalance } from "../../../../shared/estimate-balance/estimate-balance";
+import {
+  EstimateBalanceCreateModal,
+  type EstimateBalanceCreateDefaults,
+} from "../../../../frontend/estimate-balance/estimate-balance-create-modal";
+import { createCopyName } from "../../../../frontend/estimate-balance/estimate-balance-document";
+import {
+  formatIsoDateGerman,
+  formatKw,
+} from "../../../../frontend/estimate-balance/estimate-balance-format";
+
+function countRows(balance: EstimateBalanceDto) {
+  return balance.groups.reduce((sum, group) => sum + group.rows.length, 0);
+}
+
+export default function EstimateBalanceListPage() {
+  const params = useParams<{ projectId: string }>();
+  const projectId = params.projectId;
+  const router = useRouter();
+  const [project, setProject] = useState<ProjectDto | null>(null);
+  const [balances, setBalances] = useState<EstimateBalanceDto[]>([]);
+  const [createDefaults, setCreateDefaults] =
+    useState<EstimateBalanceCreateDefaults | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [isSaving, setIsSaving] = useState(false);
+
+  const reload = useCallback(async () => {
+    const [currentProject, loadedBalances] = await Promise.all([
+      getProject(projectId),
+      listEstimateBalances(projectId),
+    ]);
+    setProject(currentProject);
+    setBalances([...loadedBalances].sort((left, right) => left.sortOrder - right.sortOrder));
+  }, [projectId]);
+
+  useEffect(() => {
+    if (!projectId) {
+      return;
+    }
+    setIsLoading(true);
+    reload()
+      .then(() => setError(null))
+      .catch((err: unknown) =>
+        setError(
+          err instanceof Error
+            ? err.message
+            : "Grobe Leistungsbilanzen konnten nicht geladen werden."
+        )
+      )
+      .finally(() => setIsLoading(false));
+  }, [projectId, reload]);
+
+  async function runCommand<TResult extends ProjectCommandResultDto>(
+    execute: (expectedRevision: number) => Promise<TResult>,
+    fallbackMessage: string
+  ): Promise<TResult | null> {
+    if (!project) {
+      return null;
+    }
+    setIsSaving(true);
+    setError(null);
+    try {
+      const result = await execute(project.currentRevision);
+      setProject((current) =>
+        current ? { ...current, currentRevision: result.history.currentRevision } : current
+      );
+      await reload();
+      return result;
+    } catch (err) {
+      setError(err instanceof Error ? err.message : fallbackMessage);
+      // Refresh revision and list so a stale state does not block the next
+      // attempt; the command error stays visible.
+      await reload().catch(() => undefined);
+      return null;
+    } finally {
+      setIsSaving(false);
+    }
+  }
+
+  async function handleCreate(input: CreateEstimateBalanceInput) {
+    const result = await runCommand(
+      (expectedRevision) => createEstimateBalance(projectId, input, expectedRevision),
+      "Stand konnte nicht angelegt werden."
+    );
+    if (result) {
+      setCreateDefaults(null);
+      router.push(`/projects/${projectId}/grobbilanz/${result.balance.id}`);
+    }
+  }
+
+  async function handleDelete(balance: EstimateBalanceDto) {
+    if (
+      !window.confirm(
+        `Stand „${balance.name}“ der groben Leistungsbilanz wirklich löschen?`
+      )
+    ) {
+      return;
+    }
+    await runCommand(
+      (expectedRevision) => deleteEstimateBalance(projectId, balance.id, expectedRevision),
+      "Stand konnte nicht gelöscht werden."
+    );
+  }
+
+  const isBusy = isSaving || !project;
+  const voltage = project?.threePhaseVoltageV ?? 400;
+
+  return (
+    <main className="container py-4">
+      <div className="page-header">
+        <div className="d-flex align-items-start gap-3">
+          <Link
+            aria-label="Zurück zur Projektübersicht"
+            className="btn btn-outline-secondary btn-sm structure-back-link"
+            href={`/projects/${projectId}`}
+            title="Zurück zur Projektübersicht"
+          >
+            <ArrowLeft aria-hidden="true" size={18} />
+          </Link>
+          <div>
+            <div className="kicker">{project?.name ?? "Projekt"}</div>
+            <h1>Grobe Leistungsbilanz</h1>
+            <p className="text-secondary mb-0">
+              Leistungsabschätzung für Vor- und Entwurfsplanung (LPH 2/3), gegliedert nach
+              Kostengruppen der DIN 276 – unabhängig von den Stromkreislisten.
+            </p>
+          </div>
+        </div>
+        <button
+          className="btn btn-primary"
+          disabled={isBusy}
+          onClick={() => setCreateDefaults({})}
+          type="button"
+        >
+          <Plus aria-hidden="true" className="me-1" size={16} />
+          Neuer Stand
+        </button>
+      </div>
+
+      {error ? (
+        <div className="alert alert-warning" role="alert">
+          {error}
+        </div>
+      ) : null}
+      {isLoading ? (
+        <p className="text-secondary" role="status">
+          Grobe Leistungsbilanzen werden geladen …
+        </p>
+      ) : null}
+
+      <section aria-labelledby="estimate-list-heading" className="card shadow-sm">
+        <div className="card-header d-flex justify-content-between align-items-center">
+          <h2 className="structure-column-title" id="estimate-list-heading">
+            Stände
+            <span className="badge text-bg-secondary ms-2">{balances.length}</span>
+          </h2>
+        </div>
+        {balances.length ? (
+          <div className="table-responsive">
+            <table className="table table-hover align-middle mb-0 estimate-list-table">
+              <thead>
+                <tr>
+                  <th>Stand</th>
+                  <th>LPH</th>
+                  <th>Datum</th>
+                  <th className="text-end">AV kW</th>
+                  <th className="text-end">AV kVA</th>
+                  <th className="text-end">SV kW</th>
+                  <th className="text-end">SV kVA</th>
+                  <th className="text-end">Aktionen</th>
+                </tr>
+              </thead>
+              <tbody>
+                {balances.map((balance) => {
+                  const result = calculateEstimateBalance(balance, voltage);
+                  const href = `/projects/${projectId}/grobbilanz/${balance.id}`;
+                  const rowCount = countRows(balance);
+                  return (
+                    <tr key={balance.id}>
+                      <td>
+                        <Link className="fw-semibold" href={href}>
+                          {balance.name}
+                        </Link>
+                        <div className="text-secondary small">
+                          {balance.groups.length} Kostengruppen ·{" "}
+                          {rowCount === 1 ? "1 Zeile" : `${rowCount} Zeilen`}
+                        </div>
+                      </td>
+                      <td>{balance.workStage ?? "–"}</td>
+                      <td>{formatIsoDateGerman(balance.dateIso)}</td>
+                      <td className="text-end estimate-number">
+                        {formatKw(result.withReserve.av.kw)}
+                      </td>
+                      <td className="text-end estimate-number">
+                        {formatKw(result.withReserve.av.kva)}
+                      </td>
+                      <td className="text-end estimate-number">
+                        {formatKw(result.withReserve.sv.kw)}
+                      </td>
+                      <td className="text-end estimate-number">
+                        {formatKw(result.withReserve.sv.kva)}
+                      </td>
+                      <td className="text-end">
+                        <div className="d-inline-flex gap-1">
+                          <Link
+                            aria-label={`Stand „${balance.name}“ öffnen`}
+                            className="btn btn-sm btn-outline-primary"
+                            href={href}
+                            title="Öffnen"
+                          >
+                            <FolderOpen aria-hidden="true" className="me-1" size={14} />
+                            Öffnen
+                          </Link>
+                          <button
+                            aria-label={`Stand „${balance.name}“ als neuen Stand kopieren`}
+                            className="btn btn-sm btn-outline-secondary structure-icon-button"
+                            disabled={isBusy}
+                            onClick={() =>
+                              setCreateDefaults({
+                                name: createCopyName(balance.name),
+                                workStage: balance.workStage,
+                                template: "copy",
+                                copyFromBalanceId: balance.id,
+                              })
+                            }
+                            title="Als neuen Stand kopieren"
+                            type="button"
+                          >
+                            <Copy aria-hidden="true" size={14} />
+                          </button>
+                          <button
+                            aria-label={`Stand „${balance.name}“ löschen`}
+                            className="btn btn-sm btn-outline-danger structure-icon-button"
+                            disabled={isBusy}
+                            onClick={() => void handleDelete(balance)}
+                            title="Stand löschen"
+                            type="button"
+                          >
+                            <Trash2 aria-hidden="true" size={14} />
+                          </button>
+                        </div>
+                      </td>
+                    </tr>
+                  );
+                })}
+              </tbody>
+            </table>
+            <p className="text-secondary small px-3 py-2 mb-0">
+              Leistungen jeweils inklusive Reserve.
+            </p>
+          </div>
+        ) : !isLoading ? (
+          <div className="card-body">
+            <p className="structure-empty mb-0">
+              Noch kein Stand vorhanden. Mit „Neuer Stand“ eine grobe Leistungsbilanz auf
+              Basis der Vorlage KG 400 anlegen.
+            </p>
+          </div>
+        ) : null}
+      </section>
+
+      {createDefaults ? (
+        <EstimateBalanceCreateModal
+          balances={balances}
+          defaults={createDefaults}
+          isSaving={isSaving}
+          onClose={() => setCreateDefaults(null)}
+          onCreate={(input) => void handleCreate(input)}
+        />
+      ) : null}
+    </main>
+  );
+}
diff --git a/src/db/migrations/0010_estimate_balances.sql b/src/db/migrations/0010_estimate_balances.sql
new file mode 100644
index 0000000..645ccbe
--- /dev/null
+++ b/src/db/migrations/0010_estimate_balances.sql
@@ -0,0 +1,43 @@
+CREATE TABLE `estimate_balances` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`name` text NOT NULL,
+	`work_stage` text,
+	`date_iso` text,
+	`reserve_av_percent` real DEFAULT 0 NOT NULL,
+	`reserve_sv_percent` real DEFAULT 0 NOT NULL,
+	`sort_order` integer DEFAULT 0 NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX `estimate_balances_project_id_idx` ON `estimate_balances` (`project_id`);--> statement-breakpoint
+CREATE TABLE `estimate_groups` (
+	`id` text PRIMARY KEY NOT NULL,
+	`balance_id` text NOT NULL,
+	`cost_group` text DEFAULT '' NOT NULL,
+	`title` text NOT NULL,
+	`editor` text,
+	`sort_order` integer DEFAULT 0 NOT NULL,
+	FOREIGN KEY (`balance_id`) REFERENCES `estimate_balances`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX `estimate_groups_balance_id_idx` ON `estimate_groups` (`balance_id`);--> statement-breakpoint
+CREATE TABLE `estimate_rows` (
+	`id` text PRIMARY KEY NOT NULL,
+	`group_id` text NOT NULL,
+	`sort_order` integer DEFAULT 0 NOT NULL,
+	`supply` text,
+	`circuit_ref` text,
+	`name` text DEFAULT '' NOT NULL,
+	`quantity` real DEFAULT 0 NOT NULL,
+	`unit` text DEFAULT 'piece' NOT NULL,
+	`connection` text,
+	`power_per_unit_w` real DEFAULT 0 NOT NULL,
+	`simultaneity_factor` real DEFAULT 1 NOT NULL,
+	`cos_phi` real DEFAULT 1 NOT NULL,
+	`safety_supply` integer DEFAULT false NOT NULL,
+	`remark` text,
+	FOREIGN KEY (`group_id`) REFERENCES `estimate_groups`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX `estimate_rows_group_id_idx` ON `estimate_rows` (`group_id`);
\ No newline at end of file
diff --git a/src/db/migrations/meta/0010_snapshot.json b/src/db/migrations/meta/0010_snapshot.json
new file mode 100644
index 0000000..869d504
--- /dev/null
+++ b/src/db/migrations/meta/0010_snapshot.json
@@ -0,0 +1,2931 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "6df688bd-a78a-46a1-ba7a-4068119bf8bd",
+  "prevId": "2cd9adef-2f08-4635-b3d9-ecf71f624c7f",
+  "tables": {
+    "buildings": {
+      "name": "buildings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "buildings_project_id_projects_id_fk": {
+          "name": "buildings_project_id_projects_id_fk",
+          "tableFrom": "buildings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_device_rows": {
+      "name": "circuit_device_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "level": {
+          "name": "level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number_snapshot": {
+          "name": "room_number_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_name_snapshot": {
+          "name": "room_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "manual_quantity": {
+          "name": "manual_quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_device_rows_circuit_id_idx": {
+          "name": "circuit_device_rows_circuit_id_idx",
+          "columns": [
+            "circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "circuit_device_rows_circuit_id_circuits_id_fk": {
+          "name": "circuit_device_rows_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_linked_project_device_id_project_devices_id_fk": {
+          "name": "circuit_device_rows_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_room_id_rooms_id_fk": {
+          "name": "circuit_device_rows_room_id_rooms_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_list_equipment_identifiers": {
+      "name": "circuit_list_equipment_identifiers",
+      "columns": {
+        "owner_type": {
+          "name": "owner_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_list_equipment_identifiers_owner_unique": {
+          "name": "circuit_list_equipment_identifiers_owner_unique",
+          "columns": [
+            "owner_type",
+            "owner_id"
+          ],
+          "isUnique": true
+        },
+        "circuit_list_equipment_identifiers_list_identifier_unique": {
+          "name": "circuit_list_equipment_identifiers_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_list_equipment_identifiers",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_lists": {
+      "name": "circuit_lists",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_lists_distribution_board_id_unique": {
+          "name": "circuit_lists_distribution_board_id_unique",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_lists_project_id_projects_id_fk": {
+          "name": "circuit_lists_project_id_projects_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_lists_distribution_board_id_distribution_boards_id_fk": {
+          "name": "circuit_lists_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_protection_devices": {
+      "name": "circuit_protection_devices",
+      "columns": {
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "circuit_protection_devices_circuit_id_circuits_id_fk": {
+          "name": "circuit_protection_devices_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_protection_devices",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_sections": {
+      "name": "circuit_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "group_number": {
+          "name": "group_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_sections_list_key_unique": {
+          "name": "circuit_sections_list_key_unique",
+          "columns": [
+            "circuit_list_id",
+            "key"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_prefix_unique": {
+          "name": "circuit_sections_list_prefix_unique",
+          "columns": [
+            "circuit_list_id",
+            "prefix"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_category_group_unique": {
+          "name": "circuit_sections_list_category_group_unique",
+          "columns": [
+            "circuit_list_id",
+            "category",
+            "group_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_sections_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_sections_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_sections",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuits": {
+      "name": "circuits",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "cable_type": {
+          "name": "cable_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_cross_section": {
+          "name": "cable_cross_section",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_length": {
+          "name": "cable_length",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_assignment": {
+          "name": "rcd_assignment",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_designation": {
+          "name": "terminal_designation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage": {
+          "name": "voltage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "control_requirement": {
+          "name": "control_requirement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_reserve": {
+          "name": "is_reserve",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuits_section_id_idx": {
+          "name": "circuits_section_id_idx",
+          "columns": [
+            "section_id"
+          ],
+          "isUnique": false
+        },
+        "circuits_list_equipment_identifier_unique": {
+          "name": "circuits_list_equipment_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuits_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuits_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuits_section_id_circuit_sections_id_fk": {
+          "name": "circuits_section_id_circuit_sections_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_component_protection_devices": {
+      "name": "distribution_board_component_protection_devices",
+      "columns": {
+        "component_id": {
+          "name": "component_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk": {
+          "name": "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk",
+          "tableFrom": "distribution_board_component_protection_devices",
+          "tableTo": "distribution_board_components",
+          "columnsFrom": [
+            "component_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_components": {
+      "name": "distribution_board_components",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "placement": {
+          "name": "placement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "distribution_board_components_list_identifier_unique": {
+          "name": "distribution_board_components_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        },
+        "distribution_board_components_section_role_unique": {
+          "name": "distribution_board_components_section_role_unique",
+          "columns": [
+            "section_id",
+            "role"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "distribution_board_components_circuit_list_id_circuit_lists_id_fk": {
+          "name": "distribution_board_components_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_board_components_section_id_circuit_sections_id_fk": {
+          "name": "distribution_board_components_section_id_circuit_sections_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_boards": {
+      "name": "distribution_boards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "supply_type": {
+          "name": "supply_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "board_number": {
+          "name": "board_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "location": {
+          "name": "location",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fed_from": {
+          "name": "fed_from",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_boards_project_id_projects_id_fk": {
+          "name": "distribution_boards_project_id_projects_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_floor_id_floors_id_fk": {
+          "name": "distribution_boards_floor_id_floors_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_assets": {
+      "name": "document_branding_assets",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_settings": {
+      "name": "document_branding_settings",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_balances": {
+      "name": "estimate_balances",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "date_iso": {
+          "name": "date_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "reserve_av_percent": {
+          "name": "reserve_av_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "reserve_sv_percent": {
+          "name": "reserve_sv_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_balances_project_id_idx": {
+          "name": "estimate_balances_project_id_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_balances_project_id_projects_id_fk": {
+          "name": "estimate_balances_project_id_projects_id_fk",
+          "tableFrom": "estimate_balances",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_groups": {
+      "name": "estimate_groups",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "balance_id": {
+          "name": "balance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "editor": {
+          "name": "editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_groups_balance_id_idx": {
+          "name": "estimate_groups_balance_id_idx",
+          "columns": [
+            "balance_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_groups_balance_id_estimate_balances_id_fk": {
+          "name": "estimate_groups_balance_id_estimate_balances_id_fk",
+          "tableFrom": "estimate_groups",
+          "tableTo": "estimate_balances",
+          "columnsFrom": [
+            "balance_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_rows": {
+      "name": "estimate_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "supply": {
+          "name": "supply",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "circuit_ref": {
+          "name": "circuit_ref",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "unit": {
+          "name": "unit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'piece'"
+        },
+        "connection": {
+          "name": "connection",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_per_unit_w": {
+          "name": "power_per_unit_w",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "safety_supply": {
+          "name": "safety_supply",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "estimate_rows_group_id_idx": {
+          "name": "estimate_rows_group_id_idx",
+          "columns": [
+            "group_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_rows_group_id_estimate_groups_id_fk": {
+          "name": "estimate_rows_group_id_estimate_groups_id_fk",
+          "tableFrom": "estimate_rows",
+          "tableTo": "estimate_groups",
+          "columnsFrom": [
+            "group_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_csv_configurations": {
+      "name": "external_csv_configurations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration": {
+          "name": "configuration",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_csv_configurations_project_id_unique": {
+          "name": "external_csv_configurations_project_id_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_csv_configurations_project_id_projects_id_fk": {
+          "name": "external_csv_configurations_project_id_projects_id_fk",
+          "tableFrom": "external_csv_configurations",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_import_batches": {
+      "name": "external_import_batches",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "import_kind": {
+          "name": "import_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "imported_at_iso": {
+          "name": "imported_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "applied_project_revision": {
+          "name": "applied_project_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_snapshot": {
+          "name": "configuration_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "original_bytes": {
+          "name": "original_bytes",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "document": {
+          "name": "document",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_import_batches_project_revision_idx": {
+          "name": "external_import_batches_project_revision_idx",
+          "columns": [
+            "project_id",
+            "applied_project_revision"
+          ],
+          "isUnique": false
+        },
+        "external_import_batches_source_imported_idx": {
+          "name": "external_import_batches_source_imported_idx",
+          "columns": [
+            "source_id",
+            "imported_at_iso"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_import_batches_project_id_projects_id_fk": {
+          "name": "external_import_batches_project_id_projects_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_import_batches_source_id_external_model_sources_id_fk": {
+          "name": "external_import_batches_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_objects": {
+      "name": "external_model_objects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ifc_guid": {
+          "name": "ifc_guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen_import_batch_id": {
+          "name": "last_seen_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_accepted_import_batch_id": {
+          "name": "last_accepted_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "accepted_source_values": {
+          "name": "accepted_source_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "planning_values": {
+          "name": "planning_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "external_room_mapping_id": {
+          "name": "external_room_mapping_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "circuit_device_row_id": {
+          "name": "circuit_device_row_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "presence_status": {
+          "name": "presence_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'present'"
+        }
+      },
+      "indexes": {
+        "external_model_objects_source_ifc_guid_unique": {
+          "name": "external_model_objects_source_ifc_guid_unique",
+          "columns": [
+            "source_id",
+            "ifc_guid"
+          ],
+          "isUnique": true
+        },
+        "external_model_objects_project_presence_idx": {
+          "name": "external_model_objects_project_presence_idx",
+          "columns": [
+            "project_id",
+            "presence_status"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_distribution_board_idx": {
+          "name": "external_model_objects_distribution_board_idx",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_circuit_device_row_idx": {
+          "name": "external_model_objects_circuit_device_row_idx",
+          "columns": [
+            "circuit_device_row_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_model_objects_project_id_projects_id_fk": {
+          "name": "external_model_objects_project_id_projects_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_source_id_external_model_sources_id_fk": {
+          "name": "external_model_objects_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_seen_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_accepted_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk": {
+          "name": "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_room_mappings",
+          "columnsFrom": [
+            "external_room_mapping_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_model_objects_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_linked_project_device_id_project_devices_id_fk": {
+          "name": "external_model_objects_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk": {
+          "name": "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "circuit_device_rows",
+          "columnsFrom": [
+            "circuit_device_row_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_sources": {
+      "name": "external_model_sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_type": {
+          "name": "source_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'revit_csv'"
+        }
+      },
+      "indexes": {
+        "external_model_sources_project_type_unique": {
+          "name": "external_model_sources_project_type_unique",
+          "columns": [
+            "project_id",
+            "source_type"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_sources_project_id_projects_id_fk": {
+          "name": "external_model_sources_project_id_projects_id_fk",
+          "tableFrom": "external_model_sources",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_room_mappings": {
+      "name": "external_room_mappings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "normalized_source_room_key": {
+          "name": "normalized_source_room_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_floor_name": {
+          "name": "source_floor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_room_number": {
+          "name": "source_room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_room_name": {
+          "name": "source_room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_distribution_board_id": {
+          "name": "default_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_room_mappings_source_key_unique": {
+          "name": "external_room_mappings_source_key_unique",
+          "columns": [
+            "source_id",
+            "normalized_source_room_key"
+          ],
+          "isUnique": true
+        },
+        "external_room_mappings_project_room_idx": {
+          "name": "external_room_mappings_project_room_idx",
+          "columns": [
+            "project_id",
+            "room_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_room_mappings_project_id_projects_id_fk": {
+          "name": "external_room_mappings_project_id_projects_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_source_id_external_model_sources_id_fk": {
+          "name": "external_room_mappings_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_room_id_rooms_id_fk": {
+          "name": "external_room_mappings_room_id_rooms_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "default_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "floors": {
+      "name": "floors",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "building_id": {
+          "name": "building_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "floors_project_id_projects_id_fk": {
+          "name": "floors_project_id_projects_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "floors_building_id_buildings_id_fk": {
+          "name": "floors_building_id_buildings_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "buildings",
+          "columnsFrom": [
+            "building_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "global_devices": {
+      "name": "global_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "installed_power_per_unit_kw": {
+          "name": "installed_power_per_unit_kw",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "demand_factor": {
+          "name": "demand_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase_count": {
+          "name": "phase_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_factor": {
+          "name": "power_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_change_sets": {
+      "name": "project_change_sets",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_revision_id": {
+          "name": "project_revision_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "command_type": {
+          "name": "command_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_schema_version": {
+          "name": "payload_schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "forward_payload_json": {
+          "name": "forward_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "inverse_payload_json": {
+          "name": "inverse_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_change_sets_revision_unique": {
+          "name": "project_change_sets_revision_unique",
+          "columns": [
+            "project_revision_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_change_sets_project_revision_id_project_revisions_id_fk": {
+          "name": "project_change_sets_project_revision_id_project_revisions_id_fk",
+          "tableFrom": "project_change_sets",
+          "tableTo": "project_revisions",
+          "columnsFrom": [
+            "project_revision_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_devices": {
+      "name": "project_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'single_phase'"
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "project_devices_project_id_projects_id_fk": {
+          "name": "project_devices_project_id_projects_id_fk",
+          "tableFrom": "project_devices",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_history_stack_entries": {
+      "name": "project_history_stack_entries",
+      "columns": {
+        "change_set_id": {
+          "name": "change_set_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stack": {
+          "name": "stack",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_history_stack_entries_position_unique": {
+          "name": "project_history_stack_entries_position_unique",
+          "columns": [
+            "project_id",
+            "stack",
+            "position"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_history_stack_entries_change_set_id_project_change_sets_id_fk": {
+          "name": "project_history_stack_entries_change_set_id_project_change_sets_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "project_change_sets",
+          "columnsFrom": [
+            "change_set_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "project_history_stack_entries_project_id_projects_id_fk": {
+          "name": "project_history_stack_entries_project_id_projects_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "project_history_stack_entries_stack_check": {
+          "name": "project_history_stack_entries_stack_check",
+          "value": "\"project_history_stack_entries\".\"stack\" in ('undo', 'redo')"
+        }
+      }
+    },
+    "project_revisions": {
+      "name": "project_revisions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision_number": {
+          "name": "revision_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_revisions_project_number_unique": {
+          "name": "project_revisions_project_number_unique",
+          "columns": [
+            "project_id",
+            "revision_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_revisions_project_id_projects_id_fk": {
+          "name": "project_revisions_project_id_projects_id_fk",
+          "tableFrom": "project_revisions",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_snapshots": {
+      "name": "project_snapshots",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_revision": {
+          "name": "source_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_version": {
+          "name": "schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'named'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "payload_json": {
+          "name": "payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_sha256": {
+          "name": "payload_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_by_actor_id": {
+          "name": "created_by_actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_snapshots_project_created_idx": {
+          "name": "project_snapshots_project_created_idx",
+          "columns": [
+            "project_id",
+            "created_at_iso"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_kind_revision_idx": {
+          "name": "project_snapshots_project_kind_revision_idx",
+          "columns": [
+            "project_id",
+            "kind",
+            "source_revision"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_name_unique": {
+          "name": "project_snapshots_project_name_unique",
+          "columns": [
+            "project_id",
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_snapshots_project_id_projects_id_fk": {
+          "name": "project_snapshots_project_id_projects_id_fk",
+          "tableFrom": "project_snapshots",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "internal_project_number": {
+          "name": "internal_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_project_number": {
+          "name": "external_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "building_owner": {
+          "name": "building_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_public_building": {
+          "name": "is_public_building",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "single_phase_voltage_v": {
+          "name": "single_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 230
+        },
+        "three_phase_voltage_v": {
+          "name": "three_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 400
+        },
+        "enabled_distribution_board_supply_types": {
+          "name": "enabled_distribution_board_supply_types",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'[\"AV\",\"SV\",\"EV\",\"USV\",\"MSR\",\"SiBe\"]'"
+        },
+        "site_address": {
+          "name": "site_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_lead": {
+          "name": "project_lead",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_editor": {
+          "name": "project_editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "current_revision": {
+          "name": "current_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "rooms": {
+      "name": "rooms",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number": {
+          "name": "room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_name": {
+          "name": "room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rooms_project_id_projects_id_fk": {
+          "name": "rooms_project_id_projects_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rooms_floor_id_floors_id_fk": {
+          "name": "rooms_floor_id_floors_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index 485b8f4..209a0a2 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -71,6 +71,13 @@
       "when": 1790419185882,
       "tag": "0009_buildings",
       "breakpoints": true
+    },
+    {
+      "idx": 10,
+      "version": "6",
+      "when": 1790425784626,
+      "tag": "0010_estimate_balances",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/db/repositories/estimate-balance-project-command.repository.ts b/src/db/repositories/estimate-balance-project-command.repository.ts
new file mode 100644
index 0000000..b31ca78
--- /dev/null
+++ b/src/db/repositories/estimate-balance-project-command.repository.ts
@@ -0,0 +1,132 @@
+import { eq } from "drizzle-orm";
+import {
+  assertEstimateBalanceDeleteProjectCommand,
+  assertEstimateBalanceInsertProjectCommand,
+  assertEstimateBalanceUpdateProjectCommand,
+  createEstimateBalanceDeleteProjectCommand,
+  createEstimateBalanceInsertProjectCommand,
+  createEstimateBalanceUpdateProjectCommand,
+  estimateBalanceDeleteCommandType,
+  estimateBalanceInsertCommandType,
+  estimateBalanceUpdateCommandType,
+  normalizeEstimateBalanceSnapshot,
+  sameEstimateBalance,
+  type EstimateBalanceProjectCommand,
+} from "../../estimate-balance/domain/estimate-balance-command.model.js";
+import type {
+  EstimateBalanceProjectCommandStore,
+  ExecuteEstimateBalanceCommandInput,
+} from "../../estimate-balance/domain/estimate-balance-project-command.store.js";
+import type { EstimateBalanceSnapshot } from "../../shared/estimate-balance/estimate-balance.js";
+import type { AppDatabase } from "../database-context.js";
+import { estimateBalances } from "../schema/estimate-balances.js";
+import { projects } from "../schema/projects.js";
+import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import {
+  deleteEstimateBalance,
+  insertEstimateBalance,
+  readEstimateBalances,
+} from "./estimate-balance.persistence.js";
+
+export class EstimateBalanceProjectCommandRepository
+  implements EstimateBalanceProjectCommandStore
+{
+  constructor(private readonly database: AppDatabase) {}
+
+  execute(input: ExecuteEstimateBalanceCommandInput) {
+    return executeProjectCommandTransaction(this.database, input, (tx) =>
+      this.applyCommand(tx, input.projectId, input.command)
+    );
+  }
+
+  private applyCommand(
+    database: AppDatabase,
+    projectId: string,
+    command: EstimateBalanceProjectCommand
+  ): EstimateBalanceProjectCommand {
+    switch (command.type) {
+      case estimateBalanceInsertCommandType:
+        assertEstimateBalanceInsertProjectCommand(command);
+        return this.insert(database, projectId, command.payload.balance);
+      case estimateBalanceDeleteCommandType:
+        assertEstimateBalanceDeleteProjectCommand(command);
+        return this.delete(database, projectId, command.payload.balance);
+      case estimateBalanceUpdateCommandType:
+        assertEstimateBalanceUpdateProjectCommand(command);
+        return this.update(
+          database,
+          projectId,
+          command.payload.expected,
+          command.payload.target
+        );
+    }
+  }
+
+  private insert(
+    database: AppDatabase,
+    projectId: string,
+    balance: EstimateBalanceSnapshot
+  ) {
+    if (balance.projectId !== projectId) {
+      throw new Error("Estimate-balance snapshot does not belong to project.");
+    }
+    const project = database
+      .select({ id: projects.id })
+      .from(projects)
+      .where(eq(projects.id, projectId))
+      .get();
+    if (!project) {
+      throw new Error("Project does not exist.");
+    }
+    const existing = database
+      .select({ id: estimateBalances.id })
+      .from(estimateBalances)
+      .where(eq(estimateBalances.id, balance.id))
+      .get();
+    if (existing) {
+      throw new Error("Estimate-balance id already exists.");
+    }
+    const normalized = normalizeEstimateBalanceSnapshot(balance);
+    insertEstimateBalance(database, normalized);
+    return createEstimateBalanceDeleteProjectCommand(normalized);
+  }
+
+  private delete(
+    database: AppDatabase,
+    projectId: string,
+    expected: EstimateBalanceSnapshot
+  ) {
+    this.assertPersisted(database, projectId, expected, "deletion");
+    if (deleteEstimateBalance(database, projectId, expected.id) !== 1) {
+      throw new Error("Estimate balance could not be deleted.");
+    }
+    return createEstimateBalanceInsertProjectCommand(expected);
+  }
+
+  private update(
+    database: AppDatabase,
+    projectId: string,
+    expected: EstimateBalanceSnapshot,
+    target: EstimateBalanceSnapshot
+  ) {
+    this.assertPersisted(database, projectId, expected, "update");
+    // Group and row ids stay stable; replacing the whole document keeps the
+    // command exact and its inverse trivially the swapped pair.
+    deleteEstimateBalance(database, projectId, expected.id);
+    const normalized = normalizeEstimateBalanceSnapshot(target);
+    insertEstimateBalance(database, normalized);
+    return createEstimateBalanceUpdateProjectCommand(normalized, expected);
+  }
+
+  private assertPersisted(
+    database: AppDatabase,
+    projectId: string,
+    expected: EstimateBalanceSnapshot,
+    action: string
+  ) {
+    const [persisted] = readEstimateBalances(database, projectId, expected.id);
+    if (!persisted || !sameEstimateBalance(persisted, expected)) {
+      throw new Error(`Estimate balance changed before ${action}.`);
+    }
+  }
+}
diff --git a/src/db/repositories/estimate-balance.persistence.ts b/src/db/repositories/estimate-balance.persistence.ts
new file mode 100644
index 0000000..4d59aa6
--- /dev/null
+++ b/src/db/repositories/estimate-balance.persistence.ts
@@ -0,0 +1,121 @@
+import { and, asc, eq, inArray } from "drizzle-orm";
+import type { EstimateBalanceSnapshot } from "../../shared/estimate-balance/estimate-balance.js";
+import type { AppDatabase } from "../database-context.js";
+import {
+  estimateBalances,
+  estimateGroups,
+  estimateRows,
+} from "../schema/estimate-balances.js";
+
+/** Reads complete balance documents of a project, ordered like the UI shows them. */
+export function readEstimateBalances(
+  database: AppDatabase,
+  projectId: string,
+  balanceId?: string
+): EstimateBalanceSnapshot[] {
+  const balances = database
+    .select()
+    .from(estimateBalances)
+    .where(
+      balanceId
+        ? and(
+            eq(estimateBalances.projectId, projectId),
+            eq(estimateBalances.id, balanceId)
+          )
+        : eq(estimateBalances.projectId, projectId)
+    )
+    .orderBy(asc(estimateBalances.sortOrder), asc(estimateBalances.id))
+    .all();
+  if (!balances.length) {
+    return [];
+  }
+  const groups = database
+    .select()
+    .from(estimateGroups)
+    .where(inArray(estimateGroups.balanceId, balances.map((balance) => balance.id)))
+    .orderBy(asc(estimateGroups.sortOrder), asc(estimateGroups.id))
+    .all();
+  const rows = groups.length
+    ? database
+        .select()
+        .from(estimateRows)
+        .where(inArray(estimateRows.groupId, groups.map((group) => group.id)))
+        .orderBy(asc(estimateRows.sortOrder), asc(estimateRows.id))
+        .all()
+    : [];
+  return balances.map((balance) => ({
+    id: balance.id,
+    projectId: balance.projectId,
+    name: balance.name,
+    workStage: balance.workStage,
+    dateIso: balance.dateIso,
+    reserveAvPercent: balance.reserveAvPercent,
+    reserveSvPercent: balance.reserveSvPercent,
+    sortOrder: balance.sortOrder,
+    groups: groups
+      .filter((group) => group.balanceId === balance.id)
+      .map((group) => ({
+        id: group.id,
+        costGroup: group.costGroup,
+        title: group.title,
+        editor: group.editor,
+        sortOrder: group.sortOrder,
+        rows: rows
+          .filter((row) => row.groupId === group.id)
+          .map(({ groupId: _groupId, ...row }) => row),
+      })),
+  }));
+}
+
+/** Writes a complete balance document (the caller removed an older version first). */
+export function insertEstimateBalance(
+  database: AppDatabase,
+  balance: EstimateBalanceSnapshot
+) {
+  database
+    .insert(estimateBalances)
+    .values({
+      id: balance.id,
+      projectId: balance.projectId,
+      name: balance.name,
+      workStage: balance.workStage,
+      dateIso: balance.dateIso,
+      reserveAvPercent: balance.reserveAvPercent,
+      reserveSvPercent: balance.reserveSvPercent,
+      sortOrder: balance.sortOrder,
+    })
+    .run();
+  for (const group of balance.groups) {
+    database
+      .insert(estimateGroups)
+      .values({
+        id: group.id,
+        balanceId: balance.id,
+        costGroup: group.costGroup,
+        title: group.title,
+        editor: group.editor,
+        sortOrder: group.sortOrder,
+      })
+      .run();
+    if (group.rows.length) {
+      database
+        .insert(estimateRows)
+        .values(group.rows.map((row) => ({ ...row, groupId: group.id })))
+        .run();
+    }
+  }
+}
+
+/** Removes a balance with its groups and rows (foreign keys cascade). */
+export function deleteEstimateBalance(
+  database: AppDatabase,
+  projectId: string,
+  balanceId: string
+) {
+  return database
+    .delete(estimateBalances)
+    .where(
+      and(eq(estimateBalances.projectId, projectId), eq(estimateBalances.id, balanceId))
+    )
+    .run().changes;
+}
diff --git a/src/db/repositories/estimate-balance.repository.ts b/src/db/repositories/estimate-balance.repository.ts
new file mode 100644
index 0000000..4c70d27
--- /dev/null
+++ b/src/db/repositories/estimate-balance.repository.ts
@@ -0,0 +1,60 @@
+import { asc, eq } from "drizzle-orm";
+import type {
+  DetailedDeviceRowPower,
+  EstimateBalanceSnapshot,
+} from "../../shared/estimate-balance/estimate-balance.js";
+import { calculateRowTotalPower } from "../../domain/calculations/circuit-power-calculation.js";
+import type { AppDatabase } from "../database-context.js";
+import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
+import { circuitLists } from "../schema/circuit-lists.js";
+import { circuits } from "../schema/circuits.js";
+import { estimateBalances } from "../schema/estimate-balances.js";
+import { readEstimateBalances } from "./estimate-balance.persistence.js";
+
+/** Read side of the estimate-balance module; writes go through commands. */
+export class EstimateBalanceRepository {
+  constructor(private readonly database: AppDatabase) {}
+
+  listByProject(projectId: string): EstimateBalanceSnapshot[] {
+    return readEstimateBalances(this.database, projectId);
+  }
+
+  findById(projectId: string, balanceId: string): EstimateBalanceSnapshot | null {
+    return readEstimateBalances(this.database, projectId, balanceId)[0] ?? null;
+  }
+
+  nextSortOrder(projectId: string): number {
+    const rows = this.database
+      .select({ sortOrder: estimateBalances.sortOrder })
+      .from(estimateBalances)
+      .where(eq(estimateBalances.projectId, projectId))
+      .orderBy(asc(estimateBalances.sortOrder))
+      .all();
+    return rows.length ? Math.max(...rows.map((row) => row.sortOrder)) + 1 : 0;
+  }
+
+  /**
+   * Device rows of all circuit lists of the project with their total power
+   * (quantity · power per unit · device GZF, like the circuit tree).
+   */
+  listDetailedDeviceRowPower(projectId: string): DetailedDeviceRowPower[] {
+    return this.database
+      .select({
+        costGroup: circuitDeviceRows.costGroup,
+        quantity: circuitDeviceRows.quantity,
+        powerPerUnit: circuitDeviceRows.powerPerUnit,
+        simultaneityFactor: circuitDeviceRows.simultaneityFactor,
+        cosPhi: circuitDeviceRows.cosPhi,
+      })
+      .from(circuitDeviceRows)
+      .innerJoin(circuits, eq(circuits.id, circuitDeviceRows.circuitId))
+      .innerJoin(circuitLists, eq(circuitLists.id, circuits.circuitListId))
+      .where(eq(circuitLists.projectId, projectId))
+      .all()
+      .map((row) => ({
+        costGroup: row.costGroup,
+        kw: calculateRowTotalPower(row.quantity, row.powerPerUnit, row.simultaneityFactor),
+        cosPhi: row.cosPhi,
+      }));
+  }
+}
diff --git a/src/db/schema/estimate-balances.ts b/src/db/schema/estimate-balances.ts
new file mode 100644
index 0000000..81420f1
--- /dev/null
+++ b/src/db/schema/estimate-balances.ts
@@ -0,0 +1,61 @@
+import { index, integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { projects } from "./projects.js";
+
+// Grobe Leistungsbilanz (LPH 2/3): a separate module without links into the
+// circuit structure. See docs/estimate-balance.md.
+export const estimateBalances = sqliteTable(
+  "estimate_balances",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id")
+      .notNull()
+      .references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    workStage: text("work_stage"),
+    dateIso: text("date_iso"),
+    reserveAvPercent: real("reserve_av_percent").notNull().default(0),
+    reserveSvPercent: real("reserve_sv_percent").notNull().default(0),
+    sortOrder: integer("sort_order").notNull().default(0),
+  },
+  (table) => [index("estimate_balances_project_id_idx").on(table.projectId)]
+);
+
+export const estimateGroups = sqliteTable(
+  "estimate_groups",
+  {
+    id: text("id").primaryKey(),
+    balanceId: text("balance_id")
+      .notNull()
+      .references(() => estimateBalances.id, { onDelete: "cascade" }),
+    costGroup: text("cost_group").notNull().default(""),
+    title: text("title").notNull(),
+    editor: text("editor"),
+    sortOrder: integer("sort_order").notNull().default(0),
+  },
+  (table) => [index("estimate_groups_balance_id_idx").on(table.balanceId)]
+);
+
+export const estimateRows = sqliteTable(
+  "estimate_rows",
+  {
+    id: text("id").primaryKey(),
+    groupId: text("group_id")
+      .notNull()
+      .references(() => estimateGroups.id, { onDelete: "cascade" }),
+    sortOrder: integer("sort_order").notNull().default(0),
+    supply: text("supply"),
+    circuitRef: text("circuit_ref"),
+    name: text("name").notNull().default(""),
+    quantity: real("quantity").notNull().default(0),
+    unit: text("unit", { enum: ["piece", "area"] }).notNull().default("piece"),
+    connection: text("connection", { enum: ["fixed", "socket"] }),
+    powerPerUnitW: real("power_per_unit_w").notNull().default(0),
+    simultaneityFactor: real("simultaneity_factor").notNull().default(1),
+    cosPhi: real("cos_phi").notNull().default(1),
+    safetySupply: integer("safety_supply", { mode: "boolean" })
+      .notNull()
+      .default(false),
+    remark: text("remark"),
+  },
+  (table) => [index("estimate_rows_group_id_idx").on(table.groupId)]
+);
diff --git a/src/domain/services/project-command.service.ts b/src/domain/services/project-command.service.ts
index 91ee754..cf1f740 100644
--- a/src/domain/services/project-command.service.ts
+++ b/src/domain/services/project-command.service.ts
@@ -194,6 +194,15 @@ import {
   externalObjectDeleteCreatedCircuitCommandType,
 } from "../models/external-object-new-circuit-project-command.model.js";
 import type { ExternalObjectNewCircuitProjectCommandStore } from "../ports/external-object-new-circuit-project-command.store.js";
+import {
+  assertEstimateBalanceDeleteProjectCommand,
+  assertEstimateBalanceInsertProjectCommand,
+  assertEstimateBalanceUpdateProjectCommand,
+  estimateBalanceDeleteCommandType,
+  estimateBalanceInsertCommandType,
+  estimateBalanceUpdateCommandType,
+} from "../../estimate-balance/domain/estimate-balance-command.model.js";
+import type { EstimateBalanceProjectCommandStore } from "../../estimate-balance/domain/estimate-balance-project-command.store.js";
 
 interface DispatchProjectCommandInput {
   projectId: string;
@@ -233,7 +242,8 @@ export class ProjectCommandService implements ProjectCommandExecutor {
     private readonly externalInitialImportStore?: ExternalInitialImportProjectCommandStore,
     private readonly externalObjectRowAssignmentStore?: ExternalObjectRowAssignmentProjectCommandStore,
     private readonly externalObjectNewRowStore?: ExternalObjectNewRowProjectCommandStore,
-    private readonly externalObjectNewCircuitStore?: ExternalObjectNewCircuitProjectCommandStore
+    private readonly externalObjectNewCircuitStore?: ExternalObjectNewCircuitProjectCommandStore,
+    private readonly estimateBalanceStore?: EstimateBalanceProjectCommandStore
   ) {}
 
   executeUser(
@@ -654,6 +664,24 @@ export class ProjectCommandService implements ProjectCommandExecutor {
           command: input.command,
         }).revision;
       }
+      case estimateBalanceInsertCommandType:
+      case estimateBalanceDeleteCommandType:
+      case estimateBalanceUpdateCommandType: {
+        if (input.command.type === estimateBalanceInsertCommandType) {
+          assertEstimateBalanceInsertProjectCommand(input.command);
+        } else if (input.command.type === estimateBalanceDeleteCommandType) {
+          assertEstimateBalanceDeleteProjectCommand(input.command);
+        } else {
+          assertEstimateBalanceUpdateProjectCommand(input.command);
+        }
+        if (!this.estimateBalanceStore) {
+          throw new Error("Estimate-balance store is not available.");
+        }
+        return this.estimateBalanceStore.execute({
+          ...input,
+          command: input.command,
+        }).revision;
+      }
       case projectStateRestoreCommandType: {
         assertProjectStateRestoreCommand(input.command);
         return this.projectStateRestoreStore.execute({
diff --git a/src/estimate-balance/api/estimate-balance-request.schemas.ts b/src/estimate-balance/api/estimate-balance-request.schemas.ts
new file mode 100644
index 0000000..d1f1a5f
--- /dev/null
+++ b/src/estimate-balance/api/estimate-balance-request.schemas.ts
@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { expectedProjectRevisionSchema } from "../../shared/validation/project-command.schemas.js";
+
+export const createEstimateBalanceRequestSchema = z
+  .object({
+    expectedRevision: expectedProjectRevisionSchema,
+    name: z.string().trim().min(1).max(200),
+    workStage: z.string().trim().max(50).nullable().optional(),
+    dateIso: z
+      .string()
+      .regex(/^\d{4}-\d{2}-\d{2}$/)
+      .nullable()
+      .optional(),
+    template: z.enum(["kg400", "empty", "copy"]),
+    copyFromBalanceId: z.string().trim().min(1).optional(),
+  })
+  .strict()
+  .refine((input) => input.template !== "copy" || Boolean(input.copyFromBalanceId), {
+    message: "copyFromBalanceId is required for template copy",
+    path: ["copyFromBalanceId"],
+  });
+
+export const updateEstimateBalanceRequestSchema = z
+  .object({
+    expectedRevision: expectedProjectRevisionSchema,
+    // Validated in detail by parseEstimateBalanceSnapshot.
+    balance: z.unknown(),
+  })
+  .strict();
+
+export const deleteEstimateBalanceRequestSchema = z
+  .object({ expectedRevision: expectedProjectRevisionSchema })
+  .strict();
diff --git a/src/estimate-balance/domain/estimate-balance-command.model.ts b/src/estimate-balance/domain/estimate-balance-command.model.ts
new file mode 100644
index 0000000..44263e4
--- /dev/null
+++ b/src/estimate-balance/domain/estimate-balance-command.model.ts
@@ -0,0 +1,320 @@
+import crypto from "node:crypto";
+import { z } from "zod";
+import type { SerializedProjectCommand } from "../../domain/models/project-command.model.js";
+import {
+  estimateDefaultGroups,
+  type EstimateBalanceSnapshot,
+  type EstimateGroupSnapshot,
+} from "../../shared/estimate-balance/estimate-balance.js";
+
+export const estimateBalanceInsertCommandType = "estimate-balance.insert" as const;
+export const estimateBalanceDeleteCommandType = "estimate-balance.delete" as const;
+export const estimateBalanceUpdateCommandType = "estimate-balance.update" as const;
+export const estimateBalanceCommandSchemaVersion = 1 as const;
+
+const idSchema = z.string().trim().min(1).max(100);
+const trimmed = (max: number) =>
+  z.string().max(max).refine((value) => value === value.trim(), {
+    message: "must be trimmed",
+  });
+const nullableText = (max: number) =>
+  trimmed(max)
+    .refine((value) => value.length > 0, { message: "use null instead of empty" })
+    .nullable();
+const finite = z.number().finite();
+
+export const estimateRowSnapshotSchema = z
+  .object({
+    id: idSchema,
+    sortOrder: z.number().int().min(0),
+    supply: nullableText(50),
+    circuitRef: nullableText(50),
+    name: trimmed(200),
+    quantity: finite.min(0),
+    unit: z.enum(["piece", "area"]),
+    connection: z.enum(["fixed", "socket"]).nullable(),
+    powerPerUnitW: finite.min(0),
+    simultaneityFactor: finite.min(0).max(1),
+    cosPhi: finite.gt(0).max(1),
+    safetySupply: z.boolean(),
+    remark: nullableText(500),
+  })
+  .strict();
+
+export const estimateGroupSnapshotSchema = z
+  .object({
+    id: idSchema,
+    costGroup: trimmed(20),
+    title: trimmed(200).refine((value) => value.length > 0, {
+      message: "title must not be empty",
+    }),
+    editor: nullableText(100),
+    sortOrder: z.number().int().min(0),
+    rows: z.array(estimateRowSnapshotSchema).max(1000),
+  })
+  .strict();
+
+export const estimateBalanceSnapshotSchema = z
+  .object({
+    id: idSchema,
+    projectId: idSchema,
+    name: trimmed(200).refine((value) => value.length > 0, {
+      message: "name must not be empty",
+    }),
+    workStage: nullableText(50),
+    dateIso: z
+      .string()
+      .regex(/^\d{4}-\d{2}-\d{2}$/)
+      .refine((value) => !Number.isNaN(Date.parse(`${value}T00:00:00Z`)), {
+        message: "invalid date",
+      })
+      .nullable(),
+    reserveAvPercent: finite.min(0).max(100),
+    reserveSvPercent: finite.min(0).max(100),
+    sortOrder: z.number().int().min(0),
+    groups: z.array(estimateGroupSnapshotSchema).max(200),
+  })
+  .strict()
+  .superRefine((balance, context) => {
+    const ids = new Set<string>();
+    for (const group of balance.groups) {
+      for (const id of [group.id, ...group.rows.map((row) => row.id)]) {
+        if (ids.has(id)) {
+          context.addIssue({
+            code: "custom",
+            message: `duplicate id ${id}`,
+            path: ["groups"],
+          });
+        }
+        ids.add(id);
+      }
+    }
+  });
+
+export interface EstimateBalanceInsertProjectCommand
+  extends SerializedProjectCommand<{ balance: EstimateBalanceSnapshot }> {
+  schemaVersion: typeof estimateBalanceCommandSchemaVersion;
+  type: typeof estimateBalanceInsertCommandType;
+}
+
+export interface EstimateBalanceDeleteProjectCommand
+  extends SerializedProjectCommand<{ balance: EstimateBalanceSnapshot }> {
+  schemaVersion: typeof estimateBalanceCommandSchemaVersion;
+  type: typeof estimateBalanceDeleteCommandType;
+}
+
+export interface EstimateBalanceUpdateProjectCommand
+  extends SerializedProjectCommand<{
+    expected: EstimateBalanceSnapshot;
+    target: EstimateBalanceSnapshot;
+  }> {
+  schemaVersion: typeof estimateBalanceCommandSchemaVersion;
+  type: typeof estimateBalanceUpdateCommandType;
+}
+
+export type EstimateBalanceProjectCommand =
+  | EstimateBalanceInsertProjectCommand
+  | EstimateBalanceDeleteProjectCommand
+  | EstimateBalanceUpdateProjectCommand;
+
+/** Parses and normalizes a snapshot (sort orders of groups and rows follow the array order). */
+export function parseEstimateBalanceSnapshot(value: unknown): EstimateBalanceSnapshot {
+  const parsed = estimateBalanceSnapshotSchema.parse(value);
+  return normalizeEstimateBalanceSnapshot(parsed);
+}
+
+export function normalizeEstimateBalanceSnapshot(
+  balance: EstimateBalanceSnapshot
+): EstimateBalanceSnapshot {
+  return {
+    ...balance,
+    groups: balance.groups.map((group, groupIndex) => ({
+      ...group,
+      sortOrder: groupIndex,
+      rows: group.rows.map((row, rowIndex) => ({ ...row, sortOrder: rowIndex })),
+    })),
+  };
+}
+
+/** Stable JSON for exact equality checks of two snapshots. */
+export function canonicalEstimateBalance(balance: EstimateBalanceSnapshot): string {
+  const normalized = normalizeEstimateBalanceSnapshot(balance);
+  return JSON.stringify({
+    id: normalized.id,
+    projectId: normalized.projectId,
+    name: normalized.name,
+    workStage: normalized.workStage,
+    dateIso: normalized.dateIso,
+    reserveAvPercent: normalized.reserveAvPercent,
+    reserveSvPercent: normalized.reserveSvPercent,
+    sortOrder: normalized.sortOrder,
+    groups: normalized.groups.map((group) => ({
+      id: group.id,
+      costGroup: group.costGroup,
+      title: group.title,
+      editor: group.editor,
+      sortOrder: group.sortOrder,
+      rows: group.rows.map((row) => ({
+        id: row.id,
+        sortOrder: row.sortOrder,
+        supply: row.supply,
+        circuitRef: row.circuitRef,
+        name: row.name,
+        quantity: row.quantity,
+        unit: row.unit,
+        connection: row.connection,
+        powerPerUnitW: row.powerPerUnitW,
+        simultaneityFactor: row.simultaneityFactor,
+        cosPhi: row.cosPhi,
+        safetySupply: row.safetySupply,
+        remark: row.remark,
+      })),
+    })),
+  });
+}
+
+export function sameEstimateBalance(
+  left: EstimateBalanceSnapshot,
+  right: EstimateBalanceSnapshot
+): boolean {
+  return canonicalEstimateBalance(left) === canonicalEstimateBalance(right);
+}
+
+export function createEstimateBalanceSnapshot(input: {
+  projectId: string;
+  name: string;
+  workStage: string | null;
+  dateIso: string | null;
+  sortOrder: number;
+  template: "kg400" | "empty" | { copyFrom: EstimateBalanceSnapshot };
+  createId?: () => string;
+}): EstimateBalanceSnapshot {
+  const createId = input.createId ?? (() => crypto.randomUUID());
+  let groups: EstimateGroupSnapshot[] = [];
+  let reserveAvPercent = 10;
+  let reserveSvPercent = 0;
+  if (input.template === "kg400") {
+    groups = estimateDefaultGroups.map((group, index) => ({
+      id: createId(),
+      costGroup: group.costGroup,
+      title: group.title,
+      editor: null,
+      sortOrder: index,
+      rows: [],
+    }));
+  } else if (input.template !== "empty") {
+    const source = input.template.copyFrom;
+    reserveAvPercent = source.reserveAvPercent;
+    reserveSvPercent = source.reserveSvPercent;
+    groups = source.groups.map((group) => ({
+      ...group,
+      id: createId(),
+      rows: group.rows.map((row) => ({ ...row, id: createId() })),
+    }));
+  }
+  return parseEstimateBalanceSnapshot({
+    id: createId(),
+    projectId: input.projectId,
+    name: input.name.trim(),
+    workStage: input.workStage?.trim() || null,
+    dateIso: input.dateIso || null,
+    reserveAvPercent,
+    reserveSvPercent,
+    sortOrder: input.sortOrder,
+    groups,
+  });
+}
+
+export function createEstimateBalanceInsertProjectCommand(
+  balance: EstimateBalanceSnapshot
+): EstimateBalanceInsertProjectCommand {
+  return {
+    schemaVersion: estimateBalanceCommandSchemaVersion,
+    type: estimateBalanceInsertCommandType,
+    payload: { balance: parseEstimateBalanceSnapshot(balance) },
+  };
+}
+
+export function createEstimateBalanceDeleteProjectCommand(
+  balance: EstimateBalanceSnapshot
+): EstimateBalanceDeleteProjectCommand {
+  return {
+    schemaVersion: estimateBalanceCommandSchemaVersion,
+    type: estimateBalanceDeleteCommandType,
+    payload: { balance: parseEstimateBalanceSnapshot(balance) },
+  };
+}
+
+export function createEstimateBalanceUpdateProjectCommand(
+  expected: EstimateBalanceSnapshot,
+  target: EstimateBalanceSnapshot
+): EstimateBalanceUpdateProjectCommand {
+  const payload = {
+    expected: parseEstimateBalanceSnapshot(expected),
+    target: parseEstimateBalanceSnapshot(target),
+  };
+  assertMatchingUpdate(payload.expected, payload.target);
+  return {
+    schemaVersion: estimateBalanceCommandSchemaVersion,
+    type: estimateBalanceUpdateCommandType,
+    payload,
+  };
+}
+
+function assertMatchingUpdate(
+  expected: EstimateBalanceSnapshot,
+  target: EstimateBalanceSnapshot
+) {
+  if (expected.id !== target.id || expected.projectId !== target.projectId) {
+    throw new Error("Estimate-balance update must keep id and project.");
+  }
+  if (sameEstimateBalance(expected, target)) {
+    throw new Error("Estimate-balance update must change the balance.");
+  }
+}
+
+function assertCommandShape(
+  command: SerializedProjectCommand<unknown>,
+  type: string,
+  keys: string[]
+): Record<string, unknown> {
+  const payload = command.payload;
+  if (
+    command.schemaVersion !== estimateBalanceCommandSchemaVersion ||
+    command.type !== type ||
+    payload === null ||
+    typeof payload !== "object" ||
+    Array.isArray(payload) ||
+    Object.keys(payload).sort().join(",") !== [...keys].sort().join(",")
+  ) {
+    throw new Error("Unsupported estimate-balance command.");
+  }
+  return payload as Record<string, unknown>;
+}
+
+export function assertEstimateBalanceInsertProjectCommand(
+  command: SerializedProjectCommand<unknown>
+): asserts command is EstimateBalanceInsertProjectCommand {
+  const payload = assertCommandShape(command, estimateBalanceInsertCommandType, ["balance"]);
+  parseEstimateBalanceSnapshot(payload.balance);
+}
+
+export function assertEstimateBalanceDeleteProjectCommand(
+  command: SerializedProjectCommand<unknown>
+): asserts command is EstimateBalanceDeleteProjectCommand {
+  const payload = assertCommandShape(command, estimateBalanceDeleteCommandType, ["balance"]);
+  parseEstimateBalanceSnapshot(payload.balance);
+}
+
+export function assertEstimateBalanceUpdateProjectCommand(
+  command: SerializedProjectCommand<unknown>
+): asserts command is EstimateBalanceUpdateProjectCommand {
+  const payload = assertCommandShape(command, estimateBalanceUpdateCommandType, [
+    "expected",
+    "target",
+  ]);
+  assertMatchingUpdate(
+    parseEstimateBalanceSnapshot(payload.expected),
+    parseEstimateBalanceSnapshot(payload.target)
+  );
+}
diff --git a/src/estimate-balance/domain/estimate-balance-project-command.store.ts b/src/estimate-balance/domain/estimate-balance-project-command.store.ts
new file mode 100644
index 0000000..e5f7e04
--- /dev/null
+++ b/src/estimate-balance/domain/estimate-balance-project-command.store.ts
@@ -0,0 +1,24 @@
+import type {
+  AppendedProjectRevision,
+  ProjectRevisionSource,
+} from "../../domain/ports/project-revision.store.js";
+import type { EstimateBalanceProjectCommand } from "./estimate-balance-command.model.js";
+
+export interface ExecuteEstimateBalanceCommandInput {
+  projectId: string;
+  expectedRevision: number;
+  source: ProjectRevisionSource;
+  description?: string;
+  actorId?: string;
+  historyTargetChangeSetId?: string;
+  command: EstimateBalanceProjectCommand;
+}
+
+export interface ExecutedEstimateBalanceCommand {
+  revision: AppendedProjectRevision;
+  inverse: EstimateBalanceProjectCommand;
+}
+
+export interface EstimateBalanceProjectCommandStore {
+  execute(input: ExecuteEstimateBalanceCommandInput): ExecutedEstimateBalanceCommand;
+}
diff --git a/src/frontend/components/Sidebar.tsx b/src/frontend/components/Sidebar.tsx
index a94378e..395cd7c 100644
--- a/src/frontend/components/Sidebar.tsx
+++ b/src/frontend/components/Sidebar.tsx
@@ -17,6 +17,7 @@ const PROJECT_SECTIONS = [
 // Separate project sub-routes (/projects/[id]/<segment>).
 const PROJECT_ROUTES = [
   { segment: "struktur", label: "Gebäudestruktur", icon: "▥" },
+  { segment: "grobbilanz", label: "Grobe Leistungsbilanz", icon: "Σ" },
 ] as const;
 
 // Matches the project overview and all of its sub-routes (group 2 = rest).
diff --git a/src/frontend/estimate-balance/estimate-balance-create-modal.tsx b/src/frontend/estimate-balance/estimate-balance-create-modal.tsx
new file mode 100644
index 0000000..6d8f123
--- /dev/null
+++ b/src/frontend/estimate-balance/estimate-balance-create-modal.tsx
@@ -0,0 +1,162 @@
+"use client";
+
+import { type FormEvent, useState } from "react";
+import { FormModal } from "../components/form-modal";
+import type {
+  CreateEstimateBalanceInput,
+  EstimateBalanceDto,
+  EstimateBalanceTemplate,
+} from "../types";
+import { estimateTextLimits } from "./estimate-balance-document";
+import { getTodayIsoDate } from "./estimate-balance-format";
+
+export interface EstimateBalanceCreateDefaults {
+  name?: string;
+  workStage?: string | null;
+  template?: EstimateBalanceTemplate;
+  copyFromBalanceId?: string;
+}
+
+interface EstimateBalanceCreateModalProps {
+  balances: EstimateBalanceDto[];
+  defaults: EstimateBalanceCreateDefaults;
+  isSaving: boolean;
+  onClose: () => void;
+  onCreate: (input: CreateEstimateBalanceInput) => void;
+}
+
+/** "Neuer Stand": name, LPH, date and the starting content. */
+export function EstimateBalanceCreateModal({
+  balances,
+  defaults,
+  isSaving,
+  onClose,
+  onCreate,
+}: EstimateBalanceCreateModalProps) {
+  const [name, setName] = useState(defaults.name ?? "");
+  const [workStage, setWorkStage] = useState(defaults.workStage ?? "");
+  const [dateIso, setDateIso] = useState(getTodayIsoDate());
+  const [template, setTemplate] = useState<EstimateBalanceTemplate>(
+    defaults.template ?? "kg400"
+  );
+  const [copyFromBalanceId, setCopyFromBalanceId] = useState(
+    defaults.copyFromBalanceId ?? balances[0]?.id ?? ""
+  );
+  const isCopyInvalid = template === "copy" && !copyFromBalanceId;
+
+  function handleSubmit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    if (!name.trim() || isCopyInvalid) {
+      return;
+    }
+    onCreate({
+      name: name.trim(),
+      workStage: workStage.trim() || null,
+      dateIso: dateIso || null,
+      template,
+      ...(template === "copy" ? { copyFromBalanceId } : {}),
+    });
+  }
+
+  return (
+    <FormModal
+      isSaving={isSaving}
+      onClose={onClose}
+      onSubmit={handleSubmit}
+      submitDisabled={!name.trim() || isCopyInvalid}
+      submitLabel="Stand anlegen"
+      title="Neuer Stand"
+    >
+      <div className="row g-3">
+        <div className="col-12 col-md-6">
+          <label className="form-label" htmlFor="estimate-create-name">
+            Bezeichnung
+          </label>
+          <input
+            autoFocus
+            className="form-control"
+            id="estimate-create-name"
+            maxLength={estimateTextLimits.balanceName}
+            onChange={(event) => setName(event.target.value)}
+            placeholder="z. B. Entwurfsplanung"
+            required
+            value={name}
+          />
+        </div>
+        <div className="col-6 col-md-3">
+          <label className="form-label" htmlFor="estimate-create-work-stage">
+            LPH
+          </label>
+          <input
+            className="form-control"
+            id="estimate-create-work-stage"
+            maxLength={estimateTextLimits.workStage}
+            onChange={(event) => setWorkStage(event.target.value)}
+            placeholder="z. B. LPH 3"
+            value={workStage}
+          />
+        </div>
+        <div className="col-6 col-md-3">
+          <label className="form-label" htmlFor="estimate-create-date">
+            Datum
+          </label>
+          <input
+            className="form-control"
+            id="estimate-create-date"
+            onChange={(event) => setDateIso(event.target.value)}
+            type="date"
+            value={dateIso}
+          />
+        </div>
+        <div className="col-12 col-md-6">
+          <label className="form-label" htmlFor="estimate-create-template">
+            Inhalt
+          </label>
+          <select
+            className="form-select"
+            id="estimate-create-template"
+            onChange={(event) =>
+              setTemplate(event.target.value as EstimateBalanceTemplate)
+            }
+            value={template}
+          >
+            <option value="kg400">Vorlage KG 400</option>
+            <option value="empty">Leer</option>
+            <option disabled={!balances.length} value="copy">
+              Kopie von …
+            </option>
+          </select>
+        </div>
+        {template === "copy" ? (
+          <div className="col-12 col-md-6">
+            <label className="form-label" htmlFor="estimate-create-copy-from">
+              Kopie von Stand
+            </label>
+            <select
+              className="form-select"
+              id="estimate-create-copy-from"
+              onChange={(event) => setCopyFromBalanceId(event.target.value)}
+              required
+              value={copyFromBalanceId}
+            >
+              {balances.map((balance) => (
+                <option key={balance.id} value={balance.id}>
+                  {balance.workStage ? `${balance.name} (${balance.workStage})` : balance.name}
+                </option>
+              ))}
+            </select>
+          </div>
+        ) : null}
+        <div className="col-12">
+          <p className="text-secondary small mb-0">
+            {template === "kg400"
+              ? "Legt die Kostengruppen 410 bis 480 und „Allgemein“ ohne Einträge an."
+              : template === "empty"
+                ? "Legt einen Stand ohne Kostengruppen an."
+                : "Übernimmt alle Kostengruppen und Zeilen des gewählten Stands."}
+          </p>
+        </div>
+      </div>
+    </FormModal>
+  );
+}
diff --git a/src/frontend/estimate-balance/estimate-balance-document.ts b/src/frontend/estimate-balance/estimate-balance-document.ts
new file mode 100644
index 0000000..0049dc2
--- /dev/null
+++ b/src/frontend/estimate-balance/estimate-balance-document.ts
@@ -0,0 +1,301 @@
+// Pure, immutable editing rules for one "Grobe Leistungsbilanz" document.
+// The editor keeps the complete document as local draft and saves it as a
+// whole (PUT), so every edit is a function draft → new draft.
+import type {
+  EstimateBalanceSnapshot,
+  EstimateGroupSnapshot,
+  EstimateRowSnapshot,
+} from "../../shared/estimate-balance/estimate-balance";
+import { createClientId } from "../utils/client-id";
+
+export type MoveDirection = -1 | 1;
+
+/** Maximum text lengths accepted by the server. */
+export const estimateTextLimits = {
+  balanceName: 200,
+  workStage: 50,
+  costGroup: 20,
+  groupTitle: 200,
+  groupEditor: 100,
+  supply: 50,
+  circuitRef: 50,
+  rowName: 200,
+  remark: 500,
+} as const;
+
+export type EstimateRowPatch = Partial<Omit<EstimateRowSnapshot, "id" | "sortOrder">>;
+export type EstimateGroupPatch = Partial<Pick<EstimateGroupSnapshot, "costGroup" | "title" | "editor">>;
+
+export function createEstimateRow(
+  sortOrder: number,
+  createId: () => string = createClientId
+): EstimateRowSnapshot {
+  return {
+    id: createId(),
+    sortOrder,
+    supply: null,
+    circuitRef: null,
+    name: "",
+    quantity: 1,
+    unit: "piece",
+    connection: null,
+    powerPerUnitW: 0,
+    simultaneityFactor: 1,
+    cosPhi: 1,
+    safetySupply: false,
+    remark: null,
+  };
+}
+
+export function createEstimateGroup(
+  input: { costGroup: string; title: string; editor?: string | null },
+  sortOrder: number,
+  createId: () => string = createClientId
+): EstimateGroupSnapshot {
+  return {
+    id: createId(),
+    costGroup: input.costGroup,
+    title: input.title,
+    editor: input.editor ?? null,
+    sortOrder,
+    rows: [],
+  };
+}
+
+function bySortOrder<T extends { sortOrder: number }>(left: T, right: T) {
+  return left.sortOrder - right.sortOrder;
+}
+
+/** Orders groups and rows by sortOrder and renumbers both from 0. */
+export function normalizeEstimateSortOrder(
+  balance: EstimateBalanceSnapshot
+): EstimateBalanceSnapshot {
+  return {
+    ...balance,
+    groups: [...balance.groups].sort(bySortOrder).map((group, groupIndex) => ({
+      ...group,
+      sortOrder: groupIndex,
+      rows: [...group.rows].sort(bySortOrder).map((row, rowIndex) => ({
+        ...row,
+        sortOrder: rowIndex,
+      })),
+    })),
+  };
+}
+
+function renumber<T extends { sortOrder: number }>(items: T[]): T[] {
+  return items.map((item, index) =>
+    item.sortOrder === index ? item : { ...item, sortOrder: index }
+  );
+}
+
+function mapGroup(
+  balance: EstimateBalanceSnapshot,
+  groupId: string,
+  update: (group: EstimateGroupSnapshot) => EstimateGroupSnapshot
+): EstimateBalanceSnapshot {
+  let changed = false;
+  const groups = balance.groups.map((group) => {
+    if (group.id !== groupId) {
+      return group;
+    }
+    const next = update(group);
+    changed = next !== group;
+    return next;
+  });
+  // An unknown group or a no-op keeps the identical document.
+  return changed ? { ...balance, groups } : balance;
+}
+
+function moveItem<T>(items: T[], index: number, direction: MoveDirection): T[] | null {
+  const target = index + direction;
+  if (index < 0 || target < 0 || target >= items.length) {
+    return null;
+  }
+  const next = [...items];
+  [next[index], next[target]] = [next[target]!, next[index]!];
+  return next;
+}
+
+/** Appends a row (or inserts it after `afterRowId`) and returns the new row id. */
+export function addEstimateRow(
+  balance: EstimateBalanceSnapshot,
+  groupId: string,
+  options: { afterRowId?: string; createId?: () => string } = {}
+): { balance: EstimateBalanceSnapshot; rowId: string | null } {
+  let rowId: string | null = null;
+  const next = mapGroup(balance, groupId, (group) => {
+    const row = createEstimateRow(0, options.createId);
+    rowId = row.id;
+    const afterIndex = options.afterRowId
+      ? group.rows.findIndex((candidate) => candidate.id === options.afterRowId)
+      : -1;
+    const rows = [...group.rows];
+    rows.splice(afterIndex >= 0 ? afterIndex + 1 : rows.length, 0, row);
+    return { ...group, rows: renumber(rows) };
+  });
+  return { balance: next, rowId };
+}
+
+export function updateEstimateRow(
+  balance: EstimateBalanceSnapshot,
+  groupId: string,
+  rowId: string,
+  patch: EstimateRowPatch
+): EstimateBalanceSnapshot {
+  return mapGroup(balance, groupId, (group) => ({
+    ...group,
+    rows: group.rows.map((row) => (row.id === rowId ? { ...row, ...patch } : row)),
+  }));
+}
+
+export function removeEstimateRow(
+  balance: EstimateBalanceSnapshot,
+  groupId: string,
+  rowId: string
+): EstimateBalanceSnapshot {
+  return mapGroup(balance, groupId, (group) => ({
+    ...group,
+    rows: renumber(group.rows.filter((row) => row.id !== rowId)),
+  }));
+}
+
+export function moveEstimateRow(
+  balance: EstimateBalanceSnapshot,
+  groupId: string,
+  rowId: string,
+  direction: MoveDirection
+): EstimateBalanceSnapshot {
+  return mapGroup(balance, groupId, (group) => {
+    const rows = moveItem(
+      group.rows,
+      group.rows.findIndex((row) => row.id === rowId),
+      direction
+    );
+    return rows ? { ...group, rows: renumber(rows) } : group;
+  });
+}
+
+/** Appends a group and returns its id. */
+export function addEstimateGroup(
+  balance: EstimateBalanceSnapshot,
+  input: { costGroup: string; title: string; editor?: string | null },
+  createId: () => string = createClientId
+): { balance: EstimateBalanceSnapshot; groupId: string } {
+  const group = createEstimateGroup(input, balance.groups.length, createId);
+  return {
+    balance: { ...balance, groups: renumber([...balance.groups, group]) },
+    groupId: group.id,
+  };
+}
+
+export function updateEstimateGroup(
+  balance: EstimateBalanceSnapshot,
+  groupId: string,
+  patch: EstimateGroupPatch
+): EstimateBalanceSnapshot {
+  return mapGroup(balance, groupId, (group) => ({ ...group, ...patch }));
+}
+
+export function removeEstimateGroup(
+  balance: EstimateBalanceSnapshot,
+  groupId: string
+): EstimateBalanceSnapshot {
+  const groups = balance.groups.filter((group) => group.id !== groupId);
+  return groups.length === balance.groups.length
+    ? balance
+    : { ...balance, groups: renumber(groups) };
+}
+
+export function moveEstimateGroup(
+  balance: EstimateBalanceSnapshot,
+  groupId: string,
+  direction: MoveDirection
+): EstimateBalanceSnapshot {
+  const groups = moveItem(
+    balance.groups,
+    balance.groups.findIndex((group) => group.id === groupId),
+    direction
+  );
+  return groups ? { ...balance, groups: renumber(groups) } : balance;
+}
+
+function requiredText(value: string) {
+  return value.trim();
+}
+
+function optionalText(value: string | null) {
+  const trimmed = value?.trim() ?? "";
+  return trimmed ? trimmed : null;
+}
+
+/**
+ * The exact document the server accepts: strings trimmed, empty optional
+ * texts as null, sort orders continuous. Only fields of the shared snapshot
+ * type are copied, so no UI state can leak into the request.
+ */
+export function toSaveableEstimateBalance(
+  balance: EstimateBalanceSnapshot
+): EstimateBalanceSnapshot {
+  const normalized = normalizeEstimateSortOrder(balance);
+  return {
+    id: normalized.id,
+    projectId: normalized.projectId,
+    name: requiredText(normalized.name),
+    workStage: optionalText(normalized.workStage),
+    dateIso: normalized.dateIso || null,
+    reserveAvPercent: normalized.reserveAvPercent,
+    reserveSvPercent: normalized.reserveSvPercent,
+    sortOrder: normalized.sortOrder,
+    groups: normalized.groups.map((group) => ({
+      id: group.id,
+      costGroup: requiredText(group.costGroup),
+      title: requiredText(group.title),
+      editor: optionalText(group.editor),
+      sortOrder: group.sortOrder,
+      rows: group.rows.map((row) => ({
+        id: row.id,
+        sortOrder: row.sortOrder,
+        supply: optionalText(row.supply),
+        circuitRef: optionalText(row.circuitRef),
+        name: requiredText(row.name),
+        quantity: row.quantity,
+        unit: row.unit,
+        connection: row.connection,
+        powerPerUnitW: row.powerPerUnitW,
+        simultaneityFactor: row.simultaneityFactor,
+        cosPhi: row.cosPhi,
+        safetySupply: row.safetySupply,
+        remark: optionalText(row.remark),
+      })),
+    })),
+  };
+}
+
+/** Stable comparison key of the saveable document (dirty detection). */
+export function estimateBalanceFingerprint(balance: EstimateBalanceSnapshot): string {
+  return JSON.stringify(toSaveableEstimateBalance(balance));
+}
+
+/**
+ * German problems that would make the server reject the document. The
+ * editor never saves while this list is not empty.
+ */
+export function validateEstimateBalance(balance: EstimateBalanceSnapshot): string[] {
+  const problems: string[] = [];
+  const saveable = toSaveableEstimateBalance(balance);
+  if (!saveable.name) {
+    problems.push("Die Bezeichnung des Stands darf nicht leer sein.");
+  }
+  for (const group of saveable.groups) {
+    if (!group.title) {
+      problems.push(`Kostengruppe ${group.costGroup || "ohne Nummer"}: Titel fehlt.`);
+    }
+  }
+  return problems;
+}
+
+export function createCopyName(name: string) {
+  const copyName = `${name.trim()} (Kopie)`;
+  return copyName.slice(0, estimateTextLimits.balanceName);
+}
diff --git a/src/frontend/estimate-balance/estimate-balance-format.ts b/src/frontend/estimate-balance/estimate-balance-format.ts
new file mode 100644
index 0000000..85cddf3
--- /dev/null
+++ b/src/frontend/estimate-balance/estimate-balance-format.ts
@@ -0,0 +1,122 @@
+// Pure parsing and formatting rules of the "Grobe Leistungsbilanz" editor.
+// Numbers are entered and shown in German notation. As in the circuit list
+// editor, only "," is accepted as decimal separator: a "." is ambiguous
+// (decimal point or thousands separator) and is rejected instead of guessed.
+import { roundEstimateValue } from "../../shared/estimate-balance/estimate-balance";
+
+export type DecimalParseResult =
+  | { ok: true; value: number }
+  | { ok: false; error: string };
+
+export interface DecimalRange {
+  min?: number;
+  /** Excludes `min` itself (e.g. cos φ > 0). */
+  minExclusive?: boolean;
+  max?: number;
+}
+
+const DECIMAL_PATTERN = /^[+-]?(\d+(,\d*)?|,\d+)$/;
+
+function formatBound(value: number) {
+  return value.toLocaleString("de-DE", { maximumFractionDigits: 6, useGrouping: false });
+}
+
+export function parseGermanDecimal(text: string, range: DecimalRange = {}): DecimalParseResult {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return { ok: false, error: "Bitte einen Wert eingeben." };
+  }
+  if (trimmed.includes(".")) {
+    return { ok: false, error: "Dezimalstellen mit Komma eingeben (z. B. 0,8)." };
+  }
+  if (!DECIMAL_PATTERN.test(trimmed)) {
+    return { ok: false, error: "Ungültiger Zahlenwert." };
+  }
+  const value = Number(trimmed.replace(",", "."));
+  if (!Number.isFinite(value)) {
+    return { ok: false, error: "Ungültiger Zahlenwert." };
+  }
+  if (range.min !== undefined) {
+    if (range.minExclusive ? value <= range.min : value < range.min) {
+      return {
+        ok: false,
+        error: range.minExclusive
+          ? `Der Wert muss größer als ${formatBound(range.min)} sein.`
+          : `Der Wert darf nicht kleiner als ${formatBound(range.min)} sein.`,
+      };
+    }
+  }
+  if (range.max !== undefined && value > range.max) {
+    return { ok: false, error: `Der Wert darf nicht größer als ${formatBound(range.max)} sein.` };
+  }
+  return { ok: true, value };
+}
+
+/** Value ranges accepted by the server for the numeric document fields. */
+export const estimateNumberRanges = {
+  quantity: { min: 0 },
+  powerPerUnitW: { min: 0 },
+  simultaneityFactor: { min: 0, max: 1 },
+  cosPhi: { min: 0, minExclusive: true, max: 1 },
+  reservePercent: { min: 0, max: 100 },
+} satisfies Record<string, DecimalRange>;
+
+/**
+ * Text of a numeric input field: German comma, no thousands separator, so the
+ * shown text can be parsed again unchanged.
+ */
+export function formatDecimalInput(value: number, maximumFractionDigits = 6): string {
+  return value.toLocaleString("de-DE", { maximumFractionDigits, useGrouping: false });
+}
+
+/**
+ * Read-only display of a calculated value with thousands separator ("1.200",
+ * "30,24"). The value is rounded half away from zero first, like Excel does
+ * (40,175 → 40,18 instead of the binary-rounded 40,17).
+ */
+export function formatGermanNumber(
+  value: number,
+  minimumFractionDigits: number,
+  maximumFractionDigits = minimumFractionDigits
+): string {
+  const rounded = roundEstimateValue(value, maximumFractionDigits);
+  // "+ 0" turns -0 into 0 and avoids "-0,00".
+  return (rounded + 0).toLocaleString("de-DE", {
+    minimumFractionDigits,
+    maximumFractionDigits,
+  });
+}
+
+export function formatKw(value: number) {
+  return formatGermanNumber(value, 2);
+}
+
+export function formatAmpere(value: number) {
+  return formatGermanNumber(value, 2);
+}
+
+export function formatSignedKw(value: number) {
+  const text = formatKw(value);
+  return value > 0 && text !== "0,00" ? `+${text}` : text;
+}
+
+export function formatDeltaPercent(value: number | null) {
+  if (value === null) {
+    return "–";
+  }
+  const text = formatGermanNumber(value, 1);
+  return `${value > 0 && text !== "0,0" ? "+" : ""}${text} %`;
+}
+
+/** "2026-09-26" → "26.09.2026"; empty/invalid → "–". */
+export function formatIsoDateGerman(dateIso: string | null): string {
+  const match = dateIso?.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  return match ? `${match[3]}.${match[2]}.${match[1]}` : "–";
+}
+
+/** Local calendar date as YYYY-MM-DD (not UTC, so late evenings stay today). */
+export function getTodayIsoDate(now: Date = new Date()): string {
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  return `${now.getFullYear()}-${month}-${day}`;
+}
diff --git a/src/frontend/estimate-balance/estimate-balance-sheet.tsx b/src/frontend/estimate-balance/estimate-balance-sheet.tsx
new file mode 100644
index 0000000..debba7f
--- /dev/null
+++ b/src/frontend/estimate-balance/estimate-balance-sheet.tsx
@@ -0,0 +1,652 @@
+"use client";
+
+import type { ReactNode } from "react";
+import { ArrowDown, ArrowUp, Pencil, Plus, Trash2 } from "lucide-react";
+import {
+  calculateEstimateBalance,
+  calculateEstimateRow,
+  estimateRowConnectionLabels,
+  estimateRowUnitLabels,
+  type EstimateBalanceSnapshot,
+  type EstimateGroupSnapshot,
+  type EstimatePower,
+  type EstimateRowConnection,
+  type EstimateRowSnapshot,
+  type EstimateRowUnit,
+} from "../../shared/estimate-balance/estimate-balance";
+import {
+  addEstimateRow,
+  estimateTextLimits,
+  moveEstimateGroup,
+  removeEstimateGroup,
+  removeEstimateRow,
+  updateEstimateGroup,
+  updateEstimateRow,
+  type EstimateRowPatch,
+} from "./estimate-balance-document";
+import {
+  estimateNumberRanges,
+  formatAmpere,
+  formatDecimalInput,
+  formatKw,
+  parseGermanDecimal,
+  type DecimalRange,
+} from "./estimate-balance-format";
+import { DraftInput } from "./estimate-draft-input";
+
+export type EstimateBalanceUpdate = (
+  update: (balance: EstimateBalanceSnapshot) => EstimateBalanceSnapshot
+) => void;
+
+interface EstimateBalanceSheetProps {
+  balance: EstimateBalanceSnapshot;
+  disabled: boolean;
+  onAddGroup: () => void;
+  onChange: EstimateBalanceUpdate;
+  onEditGroup: (group: EstimateGroupSnapshot) => void;
+  onOpenGzfPicker: (groupId: string, rowId: string) => void;
+  onValidityChange: (fieldKey: string, isValid: boolean) => void;
+  threePhaseVoltageV: number;
+}
+
+// Leading columns up to cos φ; the power columns follow.
+const LEADING_COLUMN_COUNT = 10;
+const COLUMN_COUNT = 17;
+
+function NumberInput({
+  ariaLabel,
+  disabled,
+  fieldKey,
+  onCommit,
+  onValidityChange,
+  range,
+  value,
+}: {
+  ariaLabel: string;
+  disabled: boolean;
+  fieldKey: string;
+  onCommit: (value: number) => void;
+  onValidityChange: (fieldKey: string, isValid: boolean) => void;
+  range: DecimalRange;
+  value: number;
+}) {
+  return (
+    <DraftInput
+      ariaLabel={ariaLabel}
+      className="estimate-cell-input is-numeric"
+      disabled={disabled}
+      format={(current: number) => formatDecimalInput(current)}
+      inputMode="decimal"
+      onCommit={onCommit}
+      onValidityChange={(isValid) => onValidityChange(fieldKey, isValid)}
+      parse={(text) => parseGermanDecimal(text, range)}
+      value={value}
+    />
+  );
+}
+
+function TextInput({
+  ariaLabel,
+  disabled,
+  maxLength,
+  onChange,
+  placeholder,
+  value,
+}: {
+  ariaLabel: string;
+  disabled: boolean;
+  maxLength: number;
+  onChange: (value: string) => void;
+  placeholder?: string;
+  value: string | null;
+}) {
+  return (
+    <>
+      <input
+        aria-label={ariaLabel}
+        className="estimate-cell-input"
+        disabled={disabled}
+        maxLength={maxLength}
+        onChange={(event) => onChange(event.target.value)}
+        placeholder={placeholder}
+        type="text"
+        value={value ?? ""}
+      />
+      <span className="estimate-print-value">{value ?? ""}</span>
+    </>
+  );
+}
+
+function IconButton({
+  children,
+  disabled,
+  label,
+  onClick,
+  variant = "secondary",
+}: {
+  children: ReactNode;
+  disabled: boolean;
+  label: string;
+  onClick: () => void;
+  variant?: "secondary" | "danger" | "primary";
+}) {
+  return (
+    <button
+      aria-label={label}
+      className={`btn btn-sm btn-outline-${variant} estimate-icon-button`}
+      disabled={disabled}
+      onClick={onClick}
+      title={label}
+      type="button"
+    >
+      {children}
+    </button>
+  );
+}
+
+function PowerCells({ power, className = "" }: { power: EstimatePower; className?: string }) {
+  return (
+    <>
+      <td className={`estimate-number ${className}`}>{formatKw(power.kw)}</td>
+      <td className={`estimate-number ${className}`}>{formatKw(power.kva)}</td>
+    </>
+  );
+}
+
+function groupLabel(group: EstimateGroupSnapshot) {
+  return [group.costGroup, group.title].filter(Boolean).join(" ");
+}
+
+function EstimateRowLine({
+  disabled,
+  group,
+  onChange,
+  onOpenGzfPicker,
+  onValidityChange,
+  row,
+  rowIndex,
+}: {
+  disabled: boolean;
+  group: EstimateGroupSnapshot;
+  onChange: EstimateBalanceUpdate;
+  onOpenGzfPicker: (groupId: string, rowId: string) => void;
+  onValidityChange: (fieldKey: string, isValid: boolean) => void;
+  row: EstimateRowSnapshot;
+  rowIndex: number;
+}) {
+  const result = calculateEstimateRow(row);
+  const rowLabel = `${groupLabel(group)}, Zeile ${rowIndex + 1}`;
+  const fieldKey = (field: string) => `${row.id}:${field}`;
+
+  function patch(rowPatch: EstimateRowPatch) {
+    onChange((balance) => updateEstimateRow(balance, group.id, row.id, rowPatch));
+  }
+
+  return (
+    <tr className="estimate-row">
+      <td className="estimate-cost-group-cell" />
+      <td>
+        <TextInput
+          ariaLabel={`Versorgung (${rowLabel})`}
+          disabled={disabled}
+          maxLength={estimateTextLimits.supply}
+          onChange={(supply) => patch({ supply })}
+          placeholder="ELT"
+          value={row.supply}
+        />
+      </td>
+      <td>
+        <TextInput
+          ariaLabel={`Stromkreis-Nr. (${rowLabel})`}
+          disabled={disabled}
+          maxLength={estimateTextLimits.circuitRef}
+          onChange={(circuitRef) => patch({ circuitRef })}
+          value={row.circuitRef}
+        />
+      </td>
+      <td>
+        <TextInput
+          ariaLabel={`Verbraucher / Fläche (${rowLabel})`}
+          disabled={disabled}
+          maxLength={estimateTextLimits.rowName}
+          onChange={(name) => patch({ name })}
+          placeholder="Verbraucher oder Fläche"
+          value={row.name}
+        />
+      </td>
+      <td>
+        <NumberInput
+          ariaLabel={`Anzahl / Fläche (${rowLabel})`}
+          disabled={disabled}
+          fieldKey={fieldKey("quantity")}
+          onCommit={(quantity) => patch({ quantity })}
+          onValidityChange={onValidityChange}
+          range={estimateNumberRanges.quantity}
+          value={row.quantity}
+        />
+      </td>
+      <td>
+        <select
+          aria-label={`Einheit (${rowLabel})`}
+          className="estimate-cell-select"
+          disabled={disabled}
+          onChange={(event) => patch({ unit: event.target.value as EstimateRowUnit })}
+          value={row.unit}
+        >
+          {(Object.keys(estimateRowUnitLabels) as EstimateRowUnit[]).map((unit) => (
+            <option key={unit} value={unit}>
+              {estimateRowUnitLabels[unit]}
+            </option>
+          ))}
+        </select>
+        <span className="estimate-print-value">{estimateRowUnitLabels[row.unit]}</span>
+      </td>
+      <td>
+        <select
+          aria-label={`Anschluss (${rowLabel})`}
+          className="estimate-cell-select"
+          disabled={disabled}
+          onChange={(event) =>
+            patch({
+              connection: (event.target.value || null) as EstimateRowConnection | null,
+            })
+          }
+          value={row.connection ?? ""}
+        >
+          <option value="">–</option>
+          {(Object.keys(estimateRowConnectionLabels) as EstimateRowConnection[]).map(
+            (connection) => (
+              <option key={connection} value={connection}>
+                {estimateRowConnectionLabels[connection]}
+              </option>
+            )
+          )}
+        </select>
+        <span className="estimate-print-value">
+          {row.connection ? estimateRowConnectionLabels[row.connection] : ""}
+        </span>
+      </td>
+      <td>
+        <div className="estimate-unit-input">
+          <NumberInput
+            ariaLabel={`Einzelleistung in ${row.unit === "area" ? "W/m²" : "W"} (${rowLabel})`}
+            disabled={disabled}
+            fieldKey={fieldKey("powerPerUnitW")}
+            onCommit={(powerPerUnitW) => patch({ powerPerUnitW })}
+            onValidityChange={onValidityChange}
+            range={estimateNumberRanges.powerPerUnitW}
+            value={row.powerPerUnitW}
+          />
+          <span className="estimate-unit-label">{row.unit === "area" ? "W/m²" : "W"}</span>
+        </div>
+      </td>
+      <td>
+        <div className="estimate-gzf-input">
+          <NumberInput
+            ariaLabel={`Gleichzeitigkeitsfaktor (${rowLabel})`}
+            disabled={disabled}
+            fieldKey={fieldKey("simultaneityFactor")}
+            onCommit={(simultaneityFactor) => patch({ simultaneityFactor })}
+            onValidityChange={onValidityChange}
+            range={estimateNumberRanges.simultaneityFactor}
+            value={row.simultaneityFactor}
+          />
+          <button
+            aria-label={`Gleichzeitigkeitsfaktor nach AMEV wählen (${rowLabel})`}
+            className="estimate-amev-button estimate-no-print"
+            disabled={disabled}
+            onClick={() => onOpenGzfPicker(group.id, row.id)}
+            title="Gleichzeitigkeitsfaktor nach AMEV wählen"
+            type="button"
+          >
+            AMEV
+          </button>
+        </div>
+      </td>
+      <td>
+        <NumberInput
+          ariaLabel={`cos φ (${rowLabel})`}
+          disabled={disabled}
+          fieldKey={fieldKey("cosPhi")}
+          onCommit={(cosPhi) => patch({ cosPhi })}
+          onValidityChange={onValidityChange}
+          range={estimateNumberRanges.cosPhi}
+          value={row.cosPhi}
+        />
+      </td>
+      <PowerCells power={result.av} />
+      <td className="estimate-center">
+        <input
+          aria-label={`Sicherheitsversorgung (${rowLabel})`}
+          checked={row.safetySupply}
+          className="form-check-input estimate-no-print"
+          disabled={disabled}
+          onChange={(event) => patch({ safetySupply: event.target.checked })}
+          type="checkbox"
+        />
+        <span className="estimate-print-value">{row.safetySupply ? "ja" : "nein"}</span>
+      </td>
+      <PowerCells
+        className={row.safetySupply ? "" : "is-muted"}
+        power={result.sv}
+      />
+      <td>
+        <TextInput
+          ariaLabel={`Anmerkung (${rowLabel})`}
+          disabled={disabled}
+          maxLength={estimateTextLimits.remark}
+          onChange={(remark) => patch({ remark })}
+          value={row.remark}
+        />
+      </td>
+      <td className="estimate-actions-cell estimate-no-print">
+        <IconButton
+          disabled={disabled}
+          label={`Zeile löschen (${rowLabel})`}
+          onClick={() => onChange((balance) => removeEstimateRow(balance, group.id, row.id))}
+          variant="danger"
+        >
+          <Trash2 aria-hidden="true" size={13} />
+        </IconButton>
+      </td>
+    </tr>
+  );
+}
+
+/**
+ * Spreadsheet-like editor in the layout of the office template
+ * "Leistungsbilanz – KG400": one section per cost group with title and
+ * subtotal row, totals, reserve and maximum current at the end.
+ */
+export function EstimateBalanceSheet({
+  balance,
+  disabled,
+  onAddGroup,
+  onChange,
+  onEditGroup,
+  onOpenGzfPicker,
+  onValidityChange,
+  threePhaseVoltageV,
+}: EstimateBalanceSheetProps) {
+  const result = calculateEstimateBalance(balance, threePhaseVoltageV);
+
+  function confirmRemoveGroup(group: EstimateGroupSnapshot) {
+    const rowText =
+      group.rows.length === 1 ? "1 Zeile" : `${group.rows.length} Zeilen`;
+    if (
+      window.confirm(
+        `Kostengruppe „${groupLabel(group)}“ mit ${rowText} wirklich löschen?`
+      )
+    ) {
+      onChange((current) => removeEstimateGroup(current, group.id));
+    }
+  }
+
+  return (
+    <div className="estimate-sheet-wrap">
+      <table className="estimate-sheet">
+        <colgroup>
+          <col className="estimate-col-kg" />
+          <col className="estimate-col-supply" />
+          <col className="estimate-col-circuit" />
+          <col className="estimate-col-name" />
+          <col className="estimate-col-quantity" />
+          <col className="estimate-col-unit" />
+          <col className="estimate-col-connection" />
+          <col className="estimate-col-power" />
+          <col className="estimate-col-gzf" />
+          <col className="estimate-col-cosphi" />
+          <col className="estimate-col-result" />
+          <col className="estimate-col-result" />
+          <col className="estimate-col-sv" />
+          <col className="estimate-col-result" />
+          <col className="estimate-col-result" />
+          <col className="estimate-col-remark" />
+          <col className="estimate-col-actions" />
+        </colgroup>
+        <thead>
+          <tr>
+            <th rowSpan={2}>KG</th>
+            <th rowSpan={2}>
+              Versorgung
+              <span className="estimate-th-hint">ELT/ISP …</span>
+            </th>
+            <th rowSpan={2}>Stromkreis-Nr.</th>
+            <th rowSpan={2}>Verbraucher / Flächen</th>
+            <th colSpan={2}>
+              Anzahl / Fläche
+              <span className="estimate-th-hint">St. / m²</span>
+            </th>
+            <th rowSpan={2}>
+              Anschl.
+              <span className="estimate-th-hint">Fest/Steckd.</span>
+            </th>
+            <th rowSpan={2}>
+              Einzelleist.
+              <span className="estimate-th-hint">W bzw. W/m²</span>
+            </th>
+            <th rowSpan={2}>GL-Faktor</th>
+            <th rowSpan={2}>cos φ</th>
+            <th colSpan={2}>Nötige AV-Leistung</th>
+            <th colSpan={3}>Sicherheitsversorgung (SV)</th>
+            <th rowSpan={2}>Anmerkungen</th>
+            <th aria-label="Aktionen" className="estimate-no-print" rowSpan={2} />
+          </tr>
+          <tr>
+            <th>Wert</th>
+            <th>Einh.</th>
+            <th>kW</th>
+            <th>kVA</th>
+            <th>ja/nein</th>
+            <th>kW</th>
+            <th>kVA</th>
+          </tr>
+        </thead>
+        {balance.groups.map((group, groupIndex) => {
+          const groupResult = result.groups[groupIndex]!;
+          const label = groupLabel(group) || "Kostengruppe";
+          return (
+            <tbody className="estimate-group" key={group.id}>
+              <tr className="estimate-group-title-row">
+                <td className="estimate-cost-group-cell">{group.costGroup}</td>
+                <td colSpan={COLUMN_COUNT - 2}>
+                  <div className="estimate-group-title">
+                    <span className="estimate-group-name">{group.title}</span>
+                    <label className="estimate-group-editor">
+                      <span>bearbeitet von</span>
+                      <input
+                        aria-label={`Bearbeitet von (${label})`}
+                        className="estimate-cell-input"
+                        disabled={disabled}
+                        maxLength={estimateTextLimits.groupEditor}
+                        onChange={(event) =>
+                          onChange((current) =>
+                            updateEstimateGroup(current, group.id, {
+                              editor: event.target.value,
+                            })
+                          )
+                        }
+                        placeholder="Gewerk / Name"
+                        type="text"
+                        value={group.editor ?? ""}
+                      />
+                      <span className="estimate-print-value">{group.editor ?? ""}</span>
+                    </label>
+                  </div>
+                </td>
+                <td className="estimate-actions-cell estimate-no-print">
+                  <div className="estimate-group-actions">
+                    <IconButton
+                      disabled={disabled}
+                      label={`Zeile hinzufügen (${label})`}
+                      onClick={() =>
+                        onChange((current) => addEstimateRow(current, group.id).balance)
+                      }
+                      variant="primary"
+                    >
+                      <Plus aria-hidden="true" size={13} />
+                    </IconButton>
+                    <IconButton
+                      disabled={disabled}
+                      label={`Gruppe bearbeiten (${label})`}
+                      onClick={() => onEditGroup(group)}
+                    >
+                      <Pencil aria-hidden="true" size={13} />
+                    </IconButton>
+                    <IconButton
+                      disabled={disabled || groupIndex === 0}
+                      label={`Gruppe nach oben (${label})`}
+                      onClick={() =>
+                        onChange((current) => moveEstimateGroup(current, group.id, -1))
+                      }
+                    >
+                      <ArrowUp aria-hidden="true" size={13} />
+                    </IconButton>
+                    <IconButton
+                      disabled={disabled || groupIndex === balance.groups.length - 1}
+                      label={`Gruppe nach unten (${label})`}
+                      onClick={() =>
+                        onChange((current) => moveEstimateGroup(current, group.id, 1))
+                      }
+                    >
+                      <ArrowDown aria-hidden="true" size={13} />
+                    </IconButton>
+                    <IconButton
+                      disabled={disabled}
+                      label={`Gruppe löschen (${label})`}
+                      onClick={() => confirmRemoveGroup(group)}
+                      variant="danger"
+                    >
+                      <Trash2 aria-hidden="true" size={13} />
+                    </IconButton>
+                  </div>
+                </td>
+              </tr>
+              {group.rows.map((row, rowIndex) => (
+                <EstimateRowLine
+                  disabled={disabled}
+                  group={group}
+                  key={row.id}
+                  onChange={onChange}
+                  onOpenGzfPicker={onOpenGzfPicker}
+                  onValidityChange={onValidityChange}
+                  row={row}
+                  rowIndex={rowIndex}
+                />
+              ))}
+              {!group.rows.length ? (
+                <tr className="estimate-empty-row estimate-no-print">
+                  <td />
+                  <td colSpan={COLUMN_COUNT - 1}>
+                    Noch keine Einträge – mit „+“ eine Zeile hinzufügen.
+                  </td>
+                </tr>
+              ) : null}
+              <tr className="estimate-subtotal-row">
+                <td colSpan={LEADING_COLUMN_COUNT} className="estimate-total-label">
+                  Summe {label}
+                </td>
+                <PowerCells power={groupResult.av} />
+                <td />
+                <PowerCells power={groupResult.sv} />
+                <td />
+                <td className="estimate-no-print" />
+              </tr>
+            </tbody>
+          );
+        })}
+        <tfoot>
+          <tr className="estimate-no-print estimate-add-group-row">
+            <td colSpan={COLUMN_COUNT}>
+              <button
+                className="btn btn-sm btn-outline-primary"
+                disabled={disabled}
+                onClick={onAddGroup}
+                type="button"
+              >
+                <Plus aria-hidden="true" className="me-1" size={14} />
+                Kostengruppe hinzufügen
+              </button>
+            </td>
+          </tr>
+          <tr className="estimate-total-row">
+            <td colSpan={LEADING_COLUMN_COUNT} className="estimate-total-label">
+              Gesamtsumme
+            </td>
+            <PowerCells power={result.total.av} />
+            <td />
+            <PowerCells power={result.total.sv} />
+            <td colSpan={2} />
+          </tr>
+          <tr className="estimate-total-row">
+            <td colSpan={LEADING_COLUMN_COUNT - 1} className="estimate-total-label">
+              Reserveleistung
+            </td>
+            <td>
+              <div className="estimate-unit-input">
+                <NumberInput
+                  ariaLabel="Reserve AV in Prozent"
+                  disabled={disabled}
+                  fieldKey="balance:reserveAvPercent"
+                  onCommit={(reserveAvPercent) =>
+                    onChange((current) => ({ ...current, reserveAvPercent }))
+                  }
+                  onValidityChange={onValidityChange}
+                  range={estimateNumberRanges.reservePercent}
+                  value={balance.reserveAvPercent}
+                />
+                <span className="estimate-unit-label">%</span>
+              </div>
+            </td>
+            <PowerCells power={result.reserve.av} />
+            <td>
+              <div className="estimate-unit-input">
+                <NumberInput
+                  ariaLabel="Reserve SV in Prozent"
+                  disabled={disabled}
+                  fieldKey="balance:reserveSvPercent"
+                  onCommit={(reserveSvPercent) =>
+                    onChange((current) => ({ ...current, reserveSvPercent }))
+                  }
+                  onValidityChange={onValidityChange}
+                  range={estimateNumberRanges.reservePercent}
+                  value={balance.reserveSvPercent}
+                />
+                <span className="estimate-unit-label">%</span>
+              </div>
+            </td>
+            <PowerCells power={result.reserve.sv} />
+            <td colSpan={2} />
+          </tr>
+          <tr className="estimate-total-row is-strong">
+            <td colSpan={LEADING_COLUMN_COUNT} className="estimate-total-label">
+              Leistung inkl. Reserve
+            </td>
+            <PowerCells power={result.withReserve.av} />
+            <td />
+            <PowerCells power={result.withReserve.sv} />
+            <td colSpan={2} />
+          </tr>
+          <tr className="estimate-total-row">
+            <td colSpan={LEADING_COLUMN_COUNT} className="estimate-total-label">
+              Maximalstrom
+              <span className="estimate-total-hint">
+                {threePhaseVoltageV > 0
+                  ? ` (3~, U = ${formatDecimalInput(threePhaseVoltageV)} V)`
+                  : " (Drehstromspannung im Projekt fehlt)"}
+              </span>
+            </td>
+            <td className="estimate-number" colSpan={2}>
+              {formatAmpere(result.maxCurrentA.av)} A
+            </td>
+            <td />
+            <td className="estimate-number" colSpan={2}>
+              {formatAmpere(result.maxCurrentA.sv)} A
+            </td>
+            <td colSpan={2} />
+          </tr>
+        </tfoot>
+      </table>
+    </div>
+  );
+}
diff --git a/src/frontend/estimate-balance/estimate-comparison-table.tsx b/src/frontend/estimate-balance/estimate-comparison-table.tsx
new file mode 100644
index 0000000..f7098b0
--- /dev/null
+++ b/src/frontend/estimate-balance/estimate-comparison-table.tsx
@@ -0,0 +1,88 @@
+"use client";
+
+import {
+  roundEstimateValue,
+  type EstimateComparison,
+} from "../../shared/estimate-balance/estimate-balance";
+import { formatDeltaPercent, formatKw, formatSignedKw } from "./estimate-balance-format";
+
+function deltaClass(deltaKw: number) {
+  if (roundEstimateValue(deltaKw, 2) === 0) {
+    return "estimate-number";
+  }
+  return deltaKw > 0 ? "estimate-number is-over" : "estimate-number is-under";
+}
+
+/** Estimated AV power per cost group vs. the detailed circuit-list rows. */
+export function EstimateComparisonTable({ comparison }: { comparison: EstimateComparison }) {
+  return (
+    <div className="estimate-sheet-wrap">
+      <table className="estimate-sheet estimate-comparison">
+        <thead>
+          <tr>
+            <th>KG</th>
+            <th>Titel</th>
+            <th>geschätzt AV kW</th>
+            <th>detailliert kW</th>
+            <th>Δ kW</th>
+            <th>Δ %</th>
+          </tr>
+        </thead>
+        <tbody>
+          {comparison.groups.map((group) => (
+            <tr key={group.groupId}>
+              <td className="estimate-cost-group-cell">{group.costGroup}</td>
+              <td>
+                {group.title}
+                {group.detailedRowCount ? (
+                  <span className="estimate-th-hint">
+                    {group.detailedRowCount === 1
+                      ? "1 Gerätezeile"
+                      : `${group.detailedRowCount} Gerätezeilen`}
+                  </span>
+                ) : null}
+              </td>
+              <td className="estimate-number">{formatKw(group.estimatedAv.kw)}</td>
+              <td className="estimate-number">{formatKw(group.detailed.kw)}</td>
+              <td className={deltaClass(group.deltaKw)}>{formatSignedKw(group.deltaKw)}</td>
+              <td className={deltaClass(group.deltaKw)}>
+                {formatDeltaPercent(group.deltaPercent)}
+              </td>
+            </tr>
+          ))}
+          <tr className="estimate-unassigned-row">
+            <td />
+            <td>
+              ohne Kostengruppe / nicht zugeordnet
+              {comparison.unassigned.rowCount ? (
+                <span className="estimate-th-hint">
+                  {comparison.unassigned.rowCount === 1
+                    ? "1 Gerätezeile"
+                    : `${comparison.unassigned.rowCount} Gerätezeilen`}
+                </span>
+              ) : null}
+            </td>
+            <td className="estimate-number">–</td>
+            <td className="estimate-number">{formatKw(comparison.unassigned.kw)}</td>
+            <td className="estimate-number">–</td>
+            <td className="estimate-number">–</td>
+          </tr>
+        </tbody>
+        <tfoot>
+          <tr className="estimate-total-row is-strong">
+            <td />
+            <td className="estimate-total-label">Summe</td>
+            <td className="estimate-number">{formatKw(comparison.total.estimatedAv.kw)}</td>
+            <td className="estimate-number">{formatKw(comparison.total.detailed.kw)}</td>
+            <td className={deltaClass(comparison.total.deltaKw)}>
+              {formatSignedKw(comparison.total.deltaKw)}
+            </td>
+            <td className={deltaClass(comparison.total.deltaKw)}>
+              {formatDeltaPercent(comparison.total.deltaPercent)}
+            </td>
+          </tr>
+        </tfoot>
+      </table>
+    </div>
+  );
+}
diff --git a/src/frontend/estimate-balance/estimate-draft-input.tsx b/src/frontend/estimate-balance/estimate-draft-input.tsx
new file mode 100644
index 0000000..805b264
--- /dev/null
+++ b/src/frontend/estimate-balance/estimate-draft-input.tsx
@@ -0,0 +1,107 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+
+export type DraftParseResult<T> = { ok: true; value: T } | { ok: false; error: string };
+
+interface DraftInputProps<T> {
+  ariaLabel: string;
+  className?: string;
+  disabled?: boolean;
+  format: (value: T) => string;
+  inputMode?: "decimal" | "text";
+  maxLength?: number;
+  onCommit: (value: T) => void;
+  /** Reports whether the raw text is currently valid (false while invalid). */
+  onValidityChange?: (isValid: boolean) => void;
+  parse: (text: string) => DraftParseResult<T>;
+  placeholder?: string;
+  value: T;
+}
+
+/**
+ * Input that keeps the raw text the user typed. Only a valid text is
+ * committed into the document; an invalid text stays visible with a red
+ * border and is never saved. A value changed from outside (reload, undo)
+ * replaces the text unless the text already represents that value.
+ */
+export function DraftInput<T>({
+  ariaLabel,
+  className = "estimate-cell-input",
+  disabled,
+  format,
+  inputMode = "text",
+  maxLength,
+  onCommit,
+  onValidityChange,
+  parse,
+  placeholder,
+  value,
+}: DraftInputProps<T>) {
+  const [text, setText] = useState(() => format(value));
+  const [error, setError] = useState<string | null>(null);
+  const [syncedValue, setSyncedValue] = useState(value);
+
+  if (!Object.is(syncedValue, value)) {
+    // Adjusting state while rendering (instead of an effect) avoids a frame
+    // with stale text after an external change.
+    setSyncedValue(value);
+    const parsed = parse(text);
+    if (!parsed.ok || !Object.is(parsed.value, value)) {
+      setText(format(value));
+      setError(null);
+    }
+  }
+
+  const validityRef = useRef(onValidityChange);
+  useEffect(() => {
+    validityRef.current = onValidityChange;
+  });
+  const isValid = error === null;
+  useEffect(() => {
+    validityRef.current?.(isValid);
+  }, [isValid]);
+  // A removed input (deleted row) must not leave an invalid marker behind.
+  useEffect(() => () => validityRef.current?.(true), []);
+
+  function handleChange(nextText: string) {
+    setText(nextText);
+    const parsed = parse(nextText);
+    if (!parsed.ok) {
+      setError(parsed.error);
+      return;
+    }
+    setError(null);
+    if (!Object.is(parsed.value, value)) {
+      setSyncedValue(parsed.value);
+      onCommit(parsed.value);
+    }
+  }
+
+  function handleBlur() {
+    // Show the canonical notation again ("0,80" → "0,8") once editing ends.
+    if (error === null) {
+      setText(format(value));
+    }
+  }
+
+  return (
+    <>
+      <input
+        aria-invalid={error ? true : undefined}
+        aria-label={ariaLabel}
+        className={error ? `${className} is-invalid` : className}
+        disabled={disabled}
+        inputMode={inputMode}
+        maxLength={maxLength}
+        onBlur={handleBlur}
+        onChange={(event) => handleChange(event.target.value)}
+        placeholder={placeholder}
+        title={error ?? undefined}
+        type="text"
+        value={text}
+      />
+      <span className="estimate-print-value">{error ? format(value) : text}</span>
+    </>
+  );
+}
diff --git a/src/frontend/estimate-balance/estimate-group-modal.tsx b/src/frontend/estimate-balance/estimate-group-modal.tsx
new file mode 100644
index 0000000..8d56308
--- /dev/null
+++ b/src/frontend/estimate-balance/estimate-group-modal.tsx
@@ -0,0 +1,128 @@
+"use client";
+
+import { type FormEvent, useState } from "react";
+import { FormModal } from "../components/form-modal";
+import {
+  estimateDefaultGroups,
+  type EstimateGroupSnapshot,
+} from "../../shared/estimate-balance/estimate-balance";
+import { estimateTextLimits } from "./estimate-balance-document";
+
+export interface EstimateGroupFormValues {
+  costGroup: string;
+  title: string;
+  editor: string | null;
+}
+
+interface EstimateGroupModalProps {
+  group: EstimateGroupSnapshot | null;
+  onClose: () => void;
+  onSave: (values: EstimateGroupFormValues) => void;
+}
+
+/** Creates or edits the KG number, title and "bearbeitet von" of one group. */
+export function EstimateGroupModal({ group, onClose, onSave }: EstimateGroupModalProps) {
+  const [costGroup, setCostGroup] = useState(group?.costGroup ?? "");
+  const [title, setTitle] = useState(group?.title ?? "");
+  const [editor, setEditor] = useState(group?.editor ?? "");
+
+  function applyTemplate(index: string) {
+    const template = estimateDefaultGroups[Number(index)];
+    if (template) {
+      setCostGroup(template.costGroup);
+      setTitle(template.title);
+    }
+  }
+
+  function handleSubmit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    if (!title.trim()) {
+      return;
+    }
+    onSave({
+      costGroup: costGroup.trim(),
+      title: title.trim(),
+      editor: editor.trim() || null,
+    });
+  }
+
+  return (
+    <FormModal
+      isSaving={false}
+      onClose={onClose}
+      onSubmit={handleSubmit}
+      submitDisabled={!title.trim()}
+      submitLabel={group ? "Übernehmen" : "Kostengruppe hinzufügen"}
+      title={group ? "Kostengruppe bearbeiten" : "Kostengruppe hinzufügen"}
+    >
+      <div className="row g-3">
+        {!group ? (
+          <div className="col-12">
+            <label className="form-label" htmlFor="estimate-group-template">
+              Aus Vorlage KG 400 übernehmen
+            </label>
+            <select
+              className="form-select"
+              defaultValue=""
+              id="estimate-group-template"
+              onChange={(event) => applyTemplate(event.target.value)}
+            >
+              <option value="">– Vorlage wählen –</option>
+              {estimateDefaultGroups.map((template, index) => (
+                <option key={`${template.costGroup}-${template.title}`} value={index}>
+                  {[template.costGroup, template.title].filter(Boolean).join(" ")}
+                </option>
+              ))}
+            </select>
+          </div>
+        ) : null}
+        <div className="col-12 col-md-3">
+          <label className="form-label" htmlFor="estimate-group-cost-group">
+            KG (DIN 276)
+          </label>
+          <input
+            className="form-control"
+            id="estimate-group-cost-group"
+            maxLength={estimateTextLimits.costGroup}
+            onChange={(event) => setCostGroup(event.target.value)}
+            placeholder="z. B. 440"
+            value={costGroup}
+          />
+        </div>
+        <div className="col-12 col-md-9">
+          <label className="form-label" htmlFor="estimate-group-title">
+            Titel
+          </label>
+          <input
+            className="form-control"
+            id="estimate-group-title"
+            maxLength={estimateTextLimits.groupTitle}
+            onChange={(event) => setTitle(event.target.value)}
+            placeholder="z. B. Starkstromanlagen"
+            required
+            value={title}
+          />
+        </div>
+        <div className="col-12">
+          <label className="form-label" htmlFor="estimate-group-editor">
+            Bearbeitet von
+          </label>
+          <input
+            className="form-control"
+            id="estimate-group-editor"
+            maxLength={estimateTextLimits.groupEditor}
+            onChange={(event) => setEditor(event.target.value)}
+            placeholder="Gewerk oder Name (optional)"
+            value={editor}
+          />
+        </div>
+        <div className="col-12">
+          <p className="text-secondary small mb-0">
+            Ohne KG-Nummer (z. B. „Allgemein“) wird die Gruppe im Vergleich mit der
+            detaillierten Bilanz keiner Kostengruppe zugeordnet.
+          </p>
+        </div>
+      </div>
+    </FormModal>
+  );
+}
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 5c14f5e..11bde4a 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -535,3 +535,34 @@ export interface CreateCircuitDeviceRowInputDto {
 }
 
 import type { ProjectDeviceSyncField } from "../shared/constants/project-device-sync-fields";
+
+// ── Grobe Leistungsbilanz (LPH 2/3) ─────────────────────────────────────
+// The document shapes are shared with the API; see
+// src/shared/estimate-balance/estimate-balance.ts.
+import type {
+  EstimateBalanceSnapshot,
+  EstimateComparison,
+} from "../shared/estimate-balance/estimate-balance";
+
+export type EstimateBalanceDto = EstimateBalanceSnapshot;
+export type EstimateComparisonDto = EstimateComparison;
+
+export type EstimateBalanceTemplate = "kg400" | "empty" | "copy";
+
+export interface CreateEstimateBalanceInput {
+  name: string;
+  workStage?: string | null;
+  dateIso?: string | null;
+  template: EstimateBalanceTemplate;
+  /** Required for template "copy". */
+  copyFromBalanceId?: string;
+}
+
+export interface EstimateBalanceCommandResultDto extends ProjectCommandResultDto {
+  balance: EstimateBalanceDto;
+}
+
+/** PUT result: either a new revision or an unchanged document. */
+export type EstimateBalanceUpdateResultDto =
+  | EstimateBalanceCommandResultDto
+  | { unchanged: true; balance: EstimateBalanceDto };
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index e1f4608..501ed01 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -38,6 +38,11 @@ import type {
   ExternalInitialImportPlanDto,
   ApplyExternalInitialImportInput,
   ExternalInitialImportResultDto,
+  CreateEstimateBalanceInput,
+  EstimateBalanceCommandResultDto,
+  EstimateBalanceDto,
+  EstimateBalanceUpdateResultDto,
+  EstimateComparisonDto,
 } from "../types";
 import type { ExternalCsvConfiguration } from "../../external-model/csv/external-csv-contracts";
 import type { ProjectDeviceSyncField } from "../../shared/constants/project-device-sync-fields";
@@ -87,6 +92,30 @@ import type {
   CircuitGroupSubtreeSnapshot,
 } from "../../domain/models/circuit-group-subtree-snapshot.model";
 
+/**
+ * Error of a failed API request. The message stays the server's German
+ * error text; status and optional error code allow callers to react to
+ * specific failures such as a revision conflict (409).
+ */
+export class ApiRequestError extends Error {
+  readonly status: number;
+  readonly code: string | null;
+
+  constructor(message: string, status: number, code: string | null = null) {
+    super(message);
+    this.name = "ApiRequestError";
+    this.status = status;
+    this.code = code;
+  }
+}
+
+export function isRevisionConflictError(error: unknown) {
+  return (
+    error instanceof ApiRequestError &&
+    (error.status === 409 || error.code === "PROJECT_REVISION_CONFLICT")
+  );
+}
+
 async function request<T>(url: string, init?: RequestInit): Promise<T> {
   const response = await fetch(url, {
     ...init,
@@ -99,15 +128,23 @@ async function request<T>(url: string, init?: RequestInit): Promise<T> {
 
   if (!response.ok) {
     let details = await response.text();
+    let code: string | null = null;
     try {
-      const parsed = JSON.parse(details) as { error?: unknown };
+      const parsed = JSON.parse(details) as { error?: unknown; code?: unknown };
       if (typeof parsed.error === "string") {
         details = parsed.error;
       }
+      if (typeof parsed.code === "string") {
+        code = parsed.code;
+      }
     } catch {
       // Keep non-JSON error responses unchanged.
     }
-    throw new Error(details || `Anfrage fehlgeschlagen (Status ${response.status})`);
+    throw new ApiRequestError(
+      details || `Anfrage fehlgeschlagen (Status ${response.status})`,
+      response.status,
+      code
+    );
   }
 
   if (response.status === 204) {
@@ -1135,3 +1172,66 @@ export function disconnectProjectDeviceRows(
     }
   );
 }
+
+// ── Grobe Leistungsbilanz (LPH 2/3) ─────────────────────────────────────
+
+function estimateBalancesUrl(projectId: string, balanceId?: string) {
+  const base = `/api/projects/${projectId}/estimate-balances`;
+  return balanceId ? `${base}/${balanceId}` : base;
+}
+
+export function listEstimateBalances(projectId: string) {
+  return request<EstimateBalanceDto[]>(estimateBalancesUrl(projectId));
+}
+
+export function getEstimateBalance(projectId: string, balanceId: string) {
+  return request<EstimateBalanceDto>(estimateBalancesUrl(projectId, balanceId));
+}
+
+export function createEstimateBalance(
+  projectId: string,
+  input: CreateEstimateBalanceInput,
+  expectedRevision: number
+) {
+  return request<EstimateBalanceCommandResultDto>(estimateBalancesUrl(projectId), {
+    method: "POST",
+    body: JSON.stringify({ ...input, expectedRevision }),
+  });
+}
+
+/**
+ * Saves the complete target document. `keepalive` lets the request outlive
+ * the page, e.g. for the last autosave while the tab is being closed.
+ */
+export function updateEstimateBalance(
+  projectId: string,
+  balance: EstimateBalanceDto,
+  expectedRevision: number,
+  options: { keepalive?: boolean } = {}
+) {
+  return request<EstimateBalanceUpdateResultDto>(
+    estimateBalancesUrl(projectId, balance.id),
+    {
+      method: "PUT",
+      body: JSON.stringify({ expectedRevision, balance }),
+      ...(options.keepalive ? { keepalive: true } : {}),
+    }
+  );
+}
+
+export function deleteEstimateBalance(
+  projectId: string,
+  balanceId: string,
+  expectedRevision: number
+) {
+  return request<ProjectCommandResultDto>(estimateBalancesUrl(projectId, balanceId), {
+    method: "DELETE",
+    body: JSON.stringify({ expectedRevision }),
+  });
+}
+
+export function getEstimateComparison(projectId: string, balanceId: string) {
+  return request<EstimateComparisonDto>(
+    `${estimateBalancesUrl(projectId, balanceId)}/comparison`
+  );
+}
diff --git a/src/frontend/utils/project-version-history.ts b/src/frontend/utils/project-version-history.ts
index a2880ec..146cda8 100644
--- a/src/frontend/utils/project-version-history.ts
+++ b/src/frontend/utils/project-version-history.ts
@@ -68,6 +68,9 @@ const commandTypeLabels: Record<string, string> = {
   "external-object.unassign-and-delete-created-row":
     "Externes Objekt aus erzeugter Gerätezeile gelöst",
   "external-object.update-row-assignment": "Externe Objektzuordnung geändert",
+  "estimate-balance.insert": "Grobe Leistungsbilanz angelegt",
+  "estimate-balance.update": "Grobe Leistungsbilanz bearbeitet",
+  "estimate-balance.delete": "Grobe Leistungsbilanz entfernt",
 };
 
 export function getProjectRevisionSourceLabel(
diff --git a/src/server/composition/application-repositories.ts b/src/server/composition/application-repositories.ts
index 4f9b5ee..66fdd92 100644
--- a/src/server/composition/application-repositories.ts
+++ b/src/server/composition/application-repositories.ts
@@ -7,6 +7,7 @@ import { CircuitProtectionDeviceRepository } from "../../db/repositories/circuit
 import { DistributionBoardComponentRepository } from "../../db/repositories/distribution-board-component.repository.js";
 import { DistributionBoardRepository } from "../../db/repositories/distribution-board.repository.js";
 import { BuildingRepository } from "../../db/repositories/building.repository.js";
+import { EstimateBalanceRepository } from "../../db/repositories/estimate-balance.repository.js";
 import { FloorRepository } from "../../db/repositories/floor.repository.js";
 import { GlobalDeviceRepository } from "../../db/repositories/global-device.repository.js";
 import { ProjectDeviceRepository } from "../../db/repositories/project-device.repository.js";
@@ -28,6 +29,7 @@ export const distributionBoardComponentRepository =
 export const distributionBoardRepository =
   new DistributionBoardRepository(db);
 export const buildingRepository = new BuildingRepository(db);
+export const estimateBalanceRepository = new EstimateBalanceRepository(db);
 export const floorRepository = new FloorRepository(db);
 export const globalDeviceRepository = new GlobalDeviceRepository(db);
 export const projectDeviceRepository = new ProjectDeviceRepository(db);
diff --git a/src/server/composition/project-command-stores.ts b/src/server/composition/project-command-stores.ts
index 79a4a9f..8768173 100644
--- a/src/server/composition/project-command-stores.ts
+++ b/src/server/composition/project-command-stores.ts
@@ -27,6 +27,7 @@ import { ExternalInitialImportProjectCommandRepository } from "../../db/reposito
 import { ExternalObjectRowAssignmentProjectCommandRepository } from "../../db/repositories/external-object-row-assignment-project-command.repository.js";
 import { ExternalObjectNewRowProjectCommandRepository } from "../../db/repositories/external-object-new-row-project-command.repository.js";
 import { ExternalObjectNewCircuitProjectCommandRepository } from "../../db/repositories/external-object-new-circuit-project-command.repository.js";
+import { EstimateBalanceProjectCommandRepository } from "../../db/repositories/estimate-balance-project-command.repository.js";
 
 export const circuitProjectCommandStore = new CircuitProjectCommandRepository(db);
 export const circuitDeviceRowProjectCommandStore =
@@ -80,6 +81,8 @@ export const externalObjectNewRowProjectCommandStore =
   new ExternalObjectNewRowProjectCommandRepository(db);
 export const externalObjectNewCircuitProjectCommandStore =
   new ExternalObjectNewCircuitProjectCommandRepository(db);
+export const estimateBalanceProjectCommandStore =
+  new EstimateBalanceProjectCommandRepository(db);
 export const projectCommandService = new ProjectCommandService(
   circuitProjectCommandStore,
   circuitDeviceRowProjectCommandStore,
@@ -107,5 +110,6 @@ export const projectCommandService = new ProjectCommandService(
   externalInitialImportProjectCommandStore,
   externalObjectRowAssignmentProjectCommandStore,
   externalObjectNewRowProjectCommandStore,
-  externalObjectNewCircuitProjectCommandStore
+  externalObjectNewCircuitProjectCommandStore,
+  estimateBalanceProjectCommandStore
 );
diff --git a/src/server/controllers/estimate-balance.controller.ts b/src/server/controllers/estimate-balance.controller.ts
new file mode 100644
index 0000000..a22bcb1
--- /dev/null
+++ b/src/server/controllers/estimate-balance.controller.ts
@@ -0,0 +1,180 @@
+import type { Request, Response } from "express";
+import { ZodError } from "zod";
+import {
+  createEstimateBalanceDeleteProjectCommand,
+  createEstimateBalanceInsertProjectCommand,
+  createEstimateBalanceSnapshot,
+  createEstimateBalanceUpdateProjectCommand,
+  parseEstimateBalanceSnapshot,
+  sameEstimateBalance,
+} from "../../estimate-balance/domain/estimate-balance-command.model.js";
+import {
+  createEstimateBalanceRequestSchema,
+  deleteEstimateBalanceRequestSchema,
+  updateEstimateBalanceRequestSchema,
+} from "../../estimate-balance/api/estimate-balance-request.schemas.js";
+import { compareEstimateWithDetailed } from "../../shared/estimate-balance/estimate-balance.js";
+import { estimateBalanceRepository } from "../composition/application-repositories.js";
+import { projectCommandService } from "../composition/project-command-stores.js";
+import { respondWithProjectCommandError } from "./project-command.controller.js";
+
+function params(req: Request) {
+  const { projectId, balanceId } = req.params;
+  return {
+    projectId: typeof projectId === "string" ? projectId : null,
+    balanceId: typeof balanceId === "string" ? balanceId : null,
+  };
+}
+
+export function listEstimateBalances(req: Request, res: Response) {
+  const { projectId } = params(req);
+  if (!projectId) {
+    return res.status(400).json({ error: "Ungültige Projekt-ID." });
+  }
+  return res.json(estimateBalanceRepository.listByProject(projectId));
+}
+
+export function getEstimateBalance(req: Request, res: Response) {
+  const { projectId, balanceId } = params(req);
+  if (!projectId || !balanceId) {
+    return res.status(400).json({ error: "Ungültige Parameter." });
+  }
+  const balance = estimateBalanceRepository.findById(projectId, balanceId);
+  if (!balance) {
+    return res.status(404).json({ error: "Grobe Leistungsbilanz nicht gefunden." });
+  }
+  return res.json(balance);
+}
+
+export function createEstimateBalance(req: Request, res: Response) {
+  const { projectId } = params(req);
+  if (!projectId) {
+    return res.status(400).json({ error: "Ungültige Projekt-ID." });
+  }
+  const parsed = createEstimateBalanceRequestSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+  let template: Parameters<typeof createEstimateBalanceSnapshot>[0]["template"] =
+    parsed.data.template === "copy" ? "empty" : parsed.data.template;
+  if (parsed.data.template === "copy") {
+    const source = estimateBalanceRepository.findById(
+      projectId,
+      parsed.data.copyFromBalanceId!
+    );
+    if (!source) {
+      return res
+        .status(404)
+        .json({ error: "Der zu kopierende Stand wurde nicht gefunden." });
+    }
+    template = { copyFrom: source };
+  }
+  try {
+    const balance = createEstimateBalanceSnapshot({
+      projectId,
+      name: parsed.data.name,
+      workStage: parsed.data.workStage ?? null,
+      dateIso: parsed.data.dateIso ?? null,
+      sortOrder: estimateBalanceRepository.nextSortOrder(projectId),
+      template,
+    });
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision: parsed.data.expectedRevision,
+      description: "Grobe Leistungsbilanz anlegen",
+      command: createEstimateBalanceInsertProjectCommand(balance),
+    });
+    return res.status(201).json({ ...result, balance });
+  } catch (error) {
+    return respondWithProjectCommandError(error, res);
+  }
+}
+
+export function updateEstimateBalance(req: Request, res: Response) {
+  const { projectId, balanceId } = params(req);
+  if (!projectId || !balanceId) {
+    return res.status(400).json({ error: "Ungültige Parameter." });
+  }
+  const parsed = updateEstimateBalanceRequestSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+  let target;
+  try {
+    target = parseEstimateBalanceSnapshot(parsed.data.balance);
+  } catch (error) {
+    return res.status(400).json({
+      error: "Die grobe Leistungsbilanz enthält ungültige Werte.",
+      issues: error instanceof ZodError ? error.issues : undefined,
+    });
+  }
+  if (target.id !== balanceId || target.projectId !== projectId) {
+    return res
+      .status(400)
+      .json({ error: "Die Bilanz gehört nicht zu diesem Projekt oder dieser Adresse." });
+  }
+  const current = estimateBalanceRepository.findById(projectId, balanceId);
+  if (!current) {
+    return res.status(404).json({ error: "Grobe Leistungsbilanz nicht gefunden." });
+  }
+  if (sameEstimateBalance(current, target)) {
+    return res.json({ unchanged: true, balance: current });
+  }
+  try {
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision: parsed.data.expectedRevision,
+      description: "Grobe Leistungsbilanz bearbeiten",
+      command: createEstimateBalanceUpdateProjectCommand(current, target),
+    });
+    return res.json({
+      ...result,
+      balance: estimateBalanceRepository.findById(projectId, balanceId),
+    });
+  } catch (error) {
+    return respondWithProjectCommandError(error, res);
+  }
+}
+
+export function deleteEstimateBalance(req: Request, res: Response) {
+  const { projectId, balanceId } = params(req);
+  if (!projectId || !balanceId) {
+    return res.status(400).json({ error: "Ungültige Parameter." });
+  }
+  const parsed = deleteEstimateBalanceRequestSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+  const current = estimateBalanceRepository.findById(projectId, balanceId);
+  if (!current) {
+    return res.status(404).json({ error: "Grobe Leistungsbilanz nicht gefunden." });
+  }
+  try {
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision: parsed.data.expectedRevision,
+      description: "Grobe Leistungsbilanz löschen",
+      command: createEstimateBalanceDeleteProjectCommand(current),
+    });
+    return res.json(result);
+  } catch (error) {
+    return respondWithProjectCommandError(error, res);
+  }
+}
+
+export function getEstimateComparison(req: Request, res: Response) {
+  const { projectId, balanceId } = params(req);
+  if (!projectId || !balanceId) {
+    return res.status(400).json({ error: "Ungültige Parameter." });
+  }
+  const balance = estimateBalanceRepository.findById(projectId, balanceId);
+  if (!balance) {
+    return res.status(404).json({ error: "Grobe Leistungsbilanz nicht gefunden." });
+  }
+  return res.json(
+    compareEstimateWithDetailed(
+      balance,
+      estimateBalanceRepository.listDetailedDeviceRowPower(projectId)
+    )
+  );
+}
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index 0b61255..529def2 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -21,6 +21,14 @@ import {
 } from "../controllers/building.controller.js";
 import { createFloor, deleteFloor, listFloorsByProject, updateFloor } from "../controllers/floor.controller.js";
 import { createRoom, deleteRoom, listRoomsByProject, updateRoom } from "../controllers/room.controller.js";
+import {
+  createEstimateBalance,
+  deleteEstimateBalance,
+  getEstimateBalance,
+  getEstimateComparison,
+  listEstimateBalances,
+  updateEstimateBalance,
+} from "../controllers/estimate-balance.controller.js";
 import { getCircuitTree } from "../controllers/circuit-tree.controller.js";
 import { getNextCircuitIdentifier } from "../controllers/circuit.controller.js";
 import {
@@ -118,3 +126,12 @@ projectRouter.get("/:projectId/rooms", listRoomsByProject);
 projectRouter.post("/:projectId/rooms", createRoom);
 projectRouter.put("/:projectId/rooms/:roomId", updateRoom);
 projectRouter.delete("/:projectId/rooms/:roomId", deleteRoom);
+projectRouter.get("/:projectId/estimate-balances", listEstimateBalances);
+projectRouter.post("/:projectId/estimate-balances", createEstimateBalance);
+projectRouter.get("/:projectId/estimate-balances/:balanceId", getEstimateBalance);
+projectRouter.put("/:projectId/estimate-balances/:balanceId", updateEstimateBalance);
+projectRouter.delete("/:projectId/estimate-balances/:balanceId", deleteEstimateBalance);
+projectRouter.get(
+  "/:projectId/estimate-balances/:balanceId/comparison",
+  getEstimateComparison
+);
diff --git a/src/shared/estimate-balance/estimate-balance.ts b/src/shared/estimate-balance/estimate-balance.ts
new file mode 100644
index 0000000..1a7b5a5
--- /dev/null
+++ b/src/shared/estimate-balance/estimate-balance.ts
@@ -0,0 +1,316 @@
+/**
+ * Grobe Leistungsbilanz (LPH 2/3): shared data shapes and pure calculation.
+ *
+ * Used by the API (validation, comparison) and by the frontend (live totals),
+ * so this file has no imports: Turbopack resolves frontend imports without
+ * the `.js` suffix the API build needs.
+ */
+
+export type EstimateRowUnit = "piece" | "area";
+export type EstimateRowConnection = "fixed" | "socket";
+
+export interface EstimateRowSnapshot {
+  id: string;
+  sortOrder: number;
+  /** Versorgung, e.g. "ELT" or "ISP". */
+  supply: string | null;
+  /** Optional circuit reference, free text. */
+  circuitRef: string | null;
+  /** Verbraucher / Fläche. May be empty while a row is being typed. */
+  name: string;
+  /** Anzahl (unit "piece") or area in m² (unit "area"). */
+  quantity: number;
+  unit: EstimateRowUnit;
+  connection: EstimateRowConnection | null;
+  /** W per piece or W/m². */
+  powerPerUnitW: number;
+  simultaneityFactor: number;
+  cosPhi: number;
+  /** Also needed on the safety power supply (SV). */
+  safetySupply: boolean;
+  remark: string | null;
+}
+
+export interface EstimateGroupSnapshot {
+  id: string;
+  /** DIN 276 cost group, e.g. "410" or "434"; empty for "Allgemein". */
+  costGroup: string;
+  title: string;
+  /** Trade or person responsible for the entries ("bearbeitet von"). */
+  editor: string | null;
+  sortOrder: number;
+  rows: EstimateRowSnapshot[];
+}
+
+export interface EstimateBalanceSnapshot {
+  id: string;
+  projectId: string;
+  /** Stand, e.g. "Vorplanung" or "Entwurfsplanung". */
+  name: string;
+  workStage: string | null;
+  /** ISO date YYYY-MM-DD. */
+  dateIso: string | null;
+  reserveAvPercent: number;
+  reserveSvPercent: number;
+  sortOrder: number;
+  groups: EstimateGroupSnapshot[];
+}
+
+/** Default structure of the office template "Leistungsbilanz - KG400". */
+export const estimateDefaultGroups: ReadonlyArray<{ costGroup: string; title: string }> = [
+  { costGroup: "410", title: "Sanitärtechnik" },
+  { costGroup: "420", title: "Wärmeversorgung" },
+  { costGroup: "430", title: "Lufttechnische Anlagen" },
+  { costGroup: "434", title: "Kälteanlagen" },
+  { costGroup: "440", title: "Starkstromanlagen" },
+  { costGroup: "450", title: "Schwachstromanlagen" },
+  { costGroup: "460", title: "Fördertechnik" },
+  { costGroup: "470", title: "Nutzungsspezifische Anlagen" },
+  { costGroup: "480", title: "Gebäudeautomation" },
+  { costGroup: "", title: "Allgemein" },
+];
+
+export const estimateRowUnitLabels: Record<EstimateRowUnit, string> = {
+  piece: "St.",
+  area: "m²",
+};
+
+export const estimateRowConnectionLabels: Record<EstimateRowConnection, string> = {
+  fixed: "Fest",
+  socket: "Steckd.",
+};
+
+export interface EstimatePower {
+  kw: number;
+  kva: number;
+}
+
+export interface EstimateRowResult {
+  av: EstimatePower;
+  sv: EstimatePower;
+}
+
+export interface EstimateGroupResult {
+  groupId: string;
+  av: EstimatePower;
+  sv: EstimatePower;
+}
+
+export interface EstimateBalanceResult {
+  groups: EstimateGroupResult[];
+  total: { av: EstimatePower; sv: EstimatePower };
+  reserve: { av: EstimatePower; sv: EstimatePower };
+  withReserve: { av: EstimatePower; sv: EstimatePower };
+  /** Maximum current of the three-phase supply in A (S / (√3 · U)). */
+  maxCurrentA: { av: number; sv: number };
+}
+
+/**
+ * Rounds a calculated value for display like the spreadsheet does: binary
+ * floating point stores 40.175 as 40.17499…, so the scaled value is first
+ * cut to 6 decimals and only then rounded half away from zero
+ * (40.175 -> 40.18, -1.825 -> -1.83).
+ */
+export function roundEstimateValue(value: number, digits = 2): number {
+  const factor = 10 ** digits;
+  const scaled = Number((Math.abs(value) * factor).toFixed(6));
+  return (Math.sign(value) * Math.round(scaled)) / factor;
+}
+
+const zeroPower = (): EstimatePower => ({ kw: 0, kva: 0 });
+
+function addPower(left: EstimatePower, right: EstimatePower): EstimatePower {
+  return { kw: left.kw + right.kw, kva: left.kva + right.kva };
+}
+
+function scalePower(power: EstimatePower, factor: number): EstimatePower {
+  return { kw: power.kw * factor, kva: power.kva * factor };
+}
+
+/**
+ * Required power of one row: P = quantity · power per unit · GLF, S = P / cos φ.
+ * AV covers every consumer (normal supply); SV additionally lists the rows
+ * that must also be supplied by the safety power supply.
+ */
+export function calculateEstimateRow(
+  row: Pick<
+    EstimateRowSnapshot,
+    "quantity" | "powerPerUnitW" | "simultaneityFactor" | "cosPhi" | "safetySupply"
+  >
+): EstimateRowResult {
+  const kw = (row.quantity * row.powerPerUnitW * row.simultaneityFactor) / 1000;
+  const kva = row.cosPhi > 0 ? kw / row.cosPhi : 0;
+  const av = { kw, kva };
+  return { av, sv: row.safetySupply ? { ...av } : zeroPower() };
+}
+
+export function calculateEstimateBalance(
+  balance: Pick<EstimateBalanceSnapshot, "groups" | "reserveAvPercent" | "reserveSvPercent">,
+  threePhaseVoltageV: number
+): EstimateBalanceResult {
+  const groups = balance.groups.map((group) =>
+    group.rows.reduce<EstimateGroupResult>(
+      (sum, row) => {
+        const result = calculateEstimateRow(row);
+        return {
+          groupId: group.id,
+          av: addPower(sum.av, result.av),
+          sv: addPower(sum.sv, result.sv),
+        };
+      },
+      { groupId: group.id, av: zeroPower(), sv: zeroPower() }
+    )
+  );
+  const total = groups.reduce(
+    (sum, group) => ({ av: addPower(sum.av, group.av), sv: addPower(sum.sv, group.sv) }),
+    { av: zeroPower(), sv: zeroPower() }
+  );
+  const reserve = {
+    av: scalePower(total.av, balance.reserveAvPercent / 100),
+    sv: scalePower(total.sv, balance.reserveSvPercent / 100),
+  };
+  const withReserve = {
+    av: addPower(total.av, reserve.av),
+    sv: addPower(total.sv, reserve.sv),
+  };
+  const currentFactor =
+    threePhaseVoltageV > 0 ? 1000 / (Math.sqrt(3) * threePhaseVoltageV) : 0;
+  return {
+    groups,
+    total,
+    reserve,
+    withReserve,
+    maxCurrentA: {
+      av: withReserve.av.kva * currentFactor,
+      sv: withReserve.sv.kva * currentFactor,
+    },
+  };
+}
+
+/**
+ * Assigns a detailed cost group (e.g. "444" or "440.1") to the best matching
+ * estimate group: a group code with trailing zeros removed is a prefix
+ * ("430" -> "43", "434" -> "434"); the longest prefix wins. Returns null when
+ * no group matches.
+ */
+export function matchEstimateCostGroup(
+  detailedCostGroup: string | null,
+  groupCostGroups: readonly string[]
+): string | null {
+  const digits = (detailedCostGroup ?? "").replace(/\D/g, "");
+  if (!digits) {
+    return null;
+  }
+  let best: { code: string; length: number } | null = null;
+  for (const code of groupCostGroups) {
+    const codeDigits = code.replace(/\D/g, "");
+    const prefix = codeDigits.replace(/0+$/, "");
+    if (!prefix || !digits.startsWith(prefix)) {
+      continue;
+    }
+    if (!best || prefix.length > best.length) {
+      best = { code, length: prefix.length };
+    }
+  }
+  return best?.code ?? null;
+}
+
+export interface EstimateComparisonGroup {
+  groupId: string;
+  costGroup: string;
+  title: string;
+  estimatedAv: EstimatePower;
+  detailed: EstimatePower;
+  detailedRowCount: number;
+  deltaKw: number;
+  /** Relative deviation of the detailed value from the estimate, null without estimate. */
+  deltaPercent: number | null;
+}
+
+export interface EstimateComparison {
+  groups: EstimateComparisonGroup[];
+  unassigned: EstimatePower & { rowCount: number };
+  total: {
+    estimatedAv: EstimatePower;
+    detailed: EstimatePower;
+    deltaKw: number;
+    deltaPercent: number | null;
+  };
+}
+
+export interface DetailedDeviceRowPower {
+  costGroup: string | null;
+  /** Total power of the device row in kW (quantity · power · device GZF). */
+  kw: number;
+  cosPhi: number | null;
+}
+
+function delta(estimated: number, detailed: number) {
+  return {
+    deltaKw: detailed - estimated,
+    deltaPercent: estimated > 0 ? ((detailed - estimated) / estimated) * 100 : null,
+  };
+}
+
+/**
+ * Compares the estimate per cost group with the detailed device rows of all
+ * circuit lists. The distribution-board simultaneity factor is not applied
+ * on either side; a missing cos φ counts as 1.
+ */
+export function compareEstimateWithDetailed(
+  balance: Pick<EstimateBalanceSnapshot, "groups" | "reserveAvPercent" | "reserveSvPercent">,
+  detailedRows: readonly DetailedDeviceRowPower[]
+): EstimateComparison {
+  const estimate = calculateEstimateBalance(balance, 0);
+  const codes = balance.groups.map((group) => group.costGroup).filter(Boolean);
+  const detailedByCode = new Map<string, EstimatePower & { rowCount: number }>();
+  const unassigned = { kw: 0, kva: 0, rowCount: 0 };
+  for (const row of detailedRows) {
+    const kva = row.cosPhi && row.cosPhi > 0 ? row.kw / row.cosPhi : row.kw;
+    const code = matchEstimateCostGroup(row.costGroup, codes);
+    const target =
+      code === null
+        ? unassigned
+        : detailedByCode.get(code) ??
+          detailedByCode.set(code, { kw: 0, kva: 0, rowCount: 0 }).get(code)!;
+    target.kw += row.kw;
+    target.kva += kva;
+    target.rowCount += 1;
+  }
+  // A cost group code can appear in several groups; the detailed value is
+  // shown once, on the first group with that code.
+  const shownCodes = new Set<string>();
+  const groups = balance.groups.map((group, index) => {
+    const estimatedAv = estimate.groups[index]!.av;
+    const detailedEntry =
+      group.costGroup && !shownCodes.has(group.costGroup)
+        ? detailedByCode.get(group.costGroup)
+        : undefined;
+    if (group.costGroup) {
+      shownCodes.add(group.costGroup);
+    }
+    const detailed = { kw: detailedEntry?.kw ?? 0, kva: detailedEntry?.kva ?? 0 };
+    return {
+      groupId: group.id,
+      costGroup: group.costGroup,
+      title: group.title,
+      estimatedAv,
+      detailed,
+      detailedRowCount: detailedEntry?.rowCount ?? 0,
+      ...delta(estimatedAv.kw, detailed.kw),
+    };
+  });
+  const detailedTotal = groups.reduce(
+    (sum, group) => addPower(sum, group.detailed),
+    { kw: unassigned.kw, kva: unassigned.kva }
+  );
+  return {
+    groups,
+    unassigned,
+    total: {
+      estimatedAv: estimate.total.av,
+      detailed: detailedTotal,
+      ...delta(estimate.total.av.kw, detailedTotal.kw),
+    },
+  };
+}
diff --git a/tests/estimate-balance-frontend.test.ts b/tests/estimate-balance-frontend.test.ts
new file mode 100644
index 0000000..fa9368d
--- /dev/null
+++ b/tests/estimate-balance-frontend.test.ts
@@ -0,0 +1,435 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { EstimateBalanceSnapshot } from "../src/shared/estimate-balance/estimate-balance.js";
+import {
+  addEstimateGroup,
+  addEstimateRow,
+  createCopyName,
+  createEstimateRow,
+  estimateBalanceFingerprint,
+  moveEstimateGroup,
+  moveEstimateRow,
+  normalizeEstimateSortOrder,
+  removeEstimateGroup,
+  removeEstimateRow,
+  toSaveableEstimateBalance,
+  updateEstimateGroup,
+  updateEstimateRow,
+  validateEstimateBalance,
+} from "../src/frontend/estimate-balance/estimate-balance-document.js";
+import {
+  estimateNumberRanges,
+  formatAmpere,
+  formatDecimalInput,
+  formatDeltaPercent,
+  formatIsoDateGerman,
+  formatKw,
+  formatSignedKw,
+  getTodayIsoDate,
+  parseGermanDecimal,
+} from "../src/frontend/estimate-balance/estimate-balance-format.js";
+import {
+  ApiRequestError,
+  createEstimateBalance,
+  deleteEstimateBalance,
+  getEstimateBalance,
+  getEstimateComparison,
+  isRevisionConflictError,
+  listEstimateBalances,
+  updateEstimateBalance,
+} from "../src/frontend/utils/api.js";
+
+function sequentialIds(prefix = "id") {
+  let next = 0;
+  return () => `${prefix}-${++next}`;
+}
+
+function sampleBalance(): EstimateBalanceSnapshot {
+  return {
+    id: "balance-1",
+    projectId: "project-1",
+    name: "Entwurfsplanung",
+    workStage: "LPH 3",
+    dateIso: "2026-09-26",
+    reserveAvPercent: 20,
+    reserveSvPercent: 10,
+    sortOrder: 0,
+    groups: [
+      {
+        id: "group-410",
+        costGroup: "410",
+        title: "Sanitärtechnik",
+        editor: null,
+        sortOrder: 0,
+        rows: [
+          { ...createEstimateRow(0, () => "row-a"), name: "Hebeanlage", powerPerUnitW: 1200 },
+          { ...createEstimateRow(1, () => "row-b"), name: "Durchlauferhitzer" },
+        ],
+      },
+      {
+        id: "group-440",
+        costGroup: "440",
+        title: "Starkstromanlagen",
+        editor: "ELT",
+        sortOrder: 1,
+        rows: [],
+      },
+    ],
+  };
+}
+
+describe("estimate balance number input", () => {
+  it("accepts a comma as decimal separator", () => {
+    assert.deepEqual(parseGermanDecimal("0,8"), { ok: true, value: 0.8 });
+    assert.deepEqual(parseGermanDecimal(" 1200 "), { ok: true, value: 1200 });
+    assert.deepEqual(parseGermanDecimal(",5"), { ok: true, value: 0.5 });
+    assert.deepEqual(parseGermanDecimal("3,"), { ok: true, value: 3 });
+  });
+
+  it("rejects dots, empty input and garbage", () => {
+    for (const text of ["0.8", "1.200", "", "  ", "abc", "1,2,3", "1e3", "--1"]) {
+      assert.equal(parseGermanDecimal(text).ok, false, text);
+    }
+    const dot = parseGermanDecimal("0.8");
+    assert.equal(dot.ok === false && dot.error.includes("Komma"), true);
+  });
+
+  it("checks the server ranges of the document fields", () => {
+    assert.equal(parseGermanDecimal("-1", estimateNumberRanges.quantity).ok, false);
+    assert.equal(parseGermanDecimal("0", estimateNumberRanges.quantity).ok, true);
+    assert.equal(parseGermanDecimal("1,1", estimateNumberRanges.simultaneityFactor).ok, false);
+    assert.equal(parseGermanDecimal("1", estimateNumberRanges.simultaneityFactor).ok, true);
+    assert.equal(parseGermanDecimal("0", estimateNumberRanges.cosPhi).ok, false);
+    assert.equal(parseGermanDecimal("0,01", estimateNumberRanges.cosPhi).ok, true);
+    assert.equal(parseGermanDecimal("101", estimateNumberRanges.reservePercent).ok, false);
+  });
+
+  it("formats input text so it parses back unchanged", () => {
+    assert.equal(formatDecimalInput(1200), "1200");
+    assert.equal(formatDecimalInput(0.8), "0,8");
+    const parsed = parseGermanDecimal(formatDecimalInput(12345.678));
+    assert.deepEqual(parsed, { ok: true, value: 12345.678 });
+  });
+});
+
+describe("estimate balance display format", () => {
+  it("rounds half away from zero like Excel", () => {
+    assert.equal(formatKw(40.175), "40,18");
+    assert.equal(formatKw(30.24), "30,24");
+    assert.equal(formatKw(1234.5), "1.234,50");
+    assert.equal(formatKw(-0.001), "0,00");
+    assert.equal(formatAmpere(57.75), "57,75");
+    assert.equal(formatAmpere(235.749), "235,75");
+  });
+
+  it("shows signed deltas and percentages", () => {
+    assert.equal(formatSignedKw(1.5), "+1,50");
+    assert.equal(formatSignedKw(-1.825), "-1,83");
+    assert.equal(formatSignedKw(0.001), "0,00");
+    assert.equal(formatDeltaPercent(12.34), "+12,3 %");
+    assert.equal(formatDeltaPercent(-5), "-5,0 %");
+    assert.equal(formatDeltaPercent(null), "–");
+  });
+
+  it("formats dates", () => {
+    assert.equal(formatIsoDateGerman("2026-09-26"), "26.09.2026");
+    assert.equal(formatIsoDateGerman(null), "–");
+    assert.equal(getTodayIsoDate(new Date(2026, 0, 5, 23, 30)), "2026-01-05");
+  });
+});
+
+describe("estimate balance document editing", () => {
+  it("adds rows at the end or after a row with continuous sort orders", () => {
+    const createId = sequentialIds("new");
+    const appended = addEstimateRow(sampleBalance(), "group-410", { createId });
+    assert.equal(appended.rowId, "new-1");
+    assert.deepEqual(
+      appended.balance.groups[0]!.rows.map((row) => [row.id, row.sortOrder]),
+      [["row-a", 0], ["row-b", 1], ["new-1", 2]]
+    );
+    const inserted = addEstimateRow(sampleBalance(), "group-410", {
+      afterRowId: "row-a",
+      createId,
+    });
+    assert.deepEqual(
+      inserted.balance.groups[0]!.rows.map((row) => [row.id, row.sortOrder]),
+      [["row-a", 0], ["new-2", 1], ["row-b", 2]]
+    );
+    const unknownGroup = addEstimateRow(sampleBalance(), "missing", { createId });
+    assert.equal(unknownGroup.rowId, null);
+  });
+
+  it("creates rows with neutral defaults", () => {
+    const row = createEstimateRow(3, () => "row-x");
+    assert.deepEqual(row, {
+      id: "row-x",
+      sortOrder: 3,
+      supply: null,
+      circuitRef: null,
+      name: "",
+      quantity: 1,
+      unit: "piece",
+      connection: null,
+      powerPerUnitW: 0,
+      simultaneityFactor: 1,
+      cosPhi: 1,
+      safetySupply: false,
+      remark: null,
+    });
+  });
+
+  it("updates, removes and moves rows without touching the input", () => {
+    const original = sampleBalance();
+    const updated = updateEstimateRow(original, "group-410", "row-b", {
+      quantity: 3,
+      safetySupply: true,
+    });
+    assert.equal(updated.groups[0]!.rows[1]!.quantity, 3);
+    assert.equal(updated.groups[0]!.rows[1]!.safetySupply, true);
+    assert.equal(original.groups[0]!.rows[1]!.quantity, 1);
+
+    const removed = removeEstimateRow(original, "group-410", "row-a");
+    assert.deepEqual(
+      removed.groups[0]!.rows.map((row) => [row.id, row.sortOrder]),
+      [["row-b", 0]]
+    );
+
+    const moved = moveEstimateRow(original, "group-410", "row-b", -1);
+    assert.deepEqual(
+      moved.groups[0]!.rows.map((row) => [row.id, row.sortOrder]),
+      [["row-b", 0], ["row-a", 1]]
+    );
+    assert.equal(moveEstimateRow(original, "group-410", "row-a", -1), original);
+  });
+
+  it("adds, edits, moves and removes groups", () => {
+    const added = addEstimateGroup(
+      sampleBalance(),
+      { costGroup: "480", title: "Gebäudeautomation" },
+      () => "group-480"
+    );
+    assert.equal(added.groupId, "group-480");
+    assert.deepEqual(
+      added.balance.groups.map((group) => [group.id, group.sortOrder]),
+      [["group-410", 0], ["group-440", 1], ["group-480", 2]]
+    );
+    assert.equal(added.balance.groups[2]!.editor, null);
+
+    const edited = updateEstimateGroup(added.balance, "group-480", {
+      costGroup: "481",
+      editor: "MSR",
+    });
+    assert.equal(edited.groups[2]!.costGroup, "481");
+    assert.equal(edited.groups[2]!.title, "Gebäudeautomation");
+
+    const movedUp = moveEstimateGroup(edited, "group-480", -1);
+    assert.deepEqual(
+      movedUp.groups.map((group) => [group.id, group.sortOrder]),
+      [["group-410", 0], ["group-480", 1], ["group-440", 2]]
+    );
+    assert.equal(moveEstimateGroup(movedUp, "group-440", 1), movedUp);
+
+    const removed = removeEstimateGroup(movedUp, "group-410");
+    assert.deepEqual(
+      removed.groups.map((group) => [group.id, group.sortOrder]),
+      [["group-480", 0], ["group-440", 1]]
+    );
+    assert.equal(removeEstimateGroup(removed, "missing"), removed);
+  });
+
+  it("orders loaded documents by sortOrder", () => {
+    const balance = sampleBalance();
+    const shuffled: EstimateBalanceSnapshot = {
+      ...balance,
+      groups: [
+        { ...balance.groups[1]!, sortOrder: 7 },
+        {
+          ...balance.groups[0]!,
+          sortOrder: 2,
+          rows: [
+            { ...balance.groups[0]!.rows[1]!, sortOrder: 5 },
+            { ...balance.groups[0]!.rows[0]!, sortOrder: 1 },
+          ],
+        },
+      ],
+    };
+    const normalized = normalizeEstimateSortOrder(shuffled);
+    assert.deepEqual(
+      normalized.groups.map((group) => [group.id, group.sortOrder]),
+      [["group-410", 0], ["group-440", 1]]
+    );
+    assert.deepEqual(
+      normalized.groups[0]!.rows.map((row) => [row.id, row.sortOrder]),
+      [["row-a", 0], ["row-b", 1]]
+    );
+  });
+});
+
+describe("estimate balance saving", () => {
+  it("builds the trimmed server document with null for empty optional texts", () => {
+    let balance = sampleBalance();
+    balance = { ...balance, name: "  Entwurf ", workStage: "  ", dateIso: "" };
+    balance = updateEstimateGroup(balance, "group-440", { title: " Starkstrom ", editor: " " });
+    balance = updateEstimateRow(balance, "group-410", "row-a", {
+      name: " Hebeanlage ",
+      supply: " ELT ",
+      circuitRef: "",
+      remark: "   ",
+    });
+    const saveable = toSaveableEstimateBalance(balance);
+    assert.equal(saveable.name, "Entwurf");
+    assert.equal(saveable.workStage, null);
+    assert.equal(saveable.dateIso, null);
+    assert.equal(saveable.groups[1]!.title, "Starkstrom");
+    assert.equal(saveable.groups[1]!.editor, null);
+    assert.deepEqual(
+      {
+        name: saveable.groups[0]!.rows[0]!.name,
+        supply: saveable.groups[0]!.rows[0]!.supply,
+        circuitRef: saveable.groups[0]!.rows[0]!.circuitRef,
+        remark: saveable.groups[0]!.rows[0]!.remark,
+      },
+      { name: "Hebeanlage", supply: "ELT", circuitRef: null, remark: null }
+    );
+  });
+
+  it("copies only snapshot fields", () => {
+    const balance = sampleBalance() as EstimateBalanceSnapshot & { uiState?: string };
+    balance.uiState = "leak";
+    assert.equal("uiState" in toSaveableEstimateBalance(balance), false);
+  });
+
+  it("treats whitespace-only changes as unchanged", () => {
+    const balance = sampleBalance();
+    const withSpace = updateEstimateRow(balance, "group-410", "row-a", {
+      name: "Hebeanlage ",
+    });
+    assert.equal(estimateBalanceFingerprint(withSpace), estimateBalanceFingerprint(balance));
+    const changed = updateEstimateRow(balance, "group-410", "row-a", { quantity: 2 });
+    assert.notEqual(estimateBalanceFingerprint(changed), estimateBalanceFingerprint(balance));
+  });
+
+  it("reports documents the server would reject", () => {
+    assert.deepEqual(validateEstimateBalance(sampleBalance()), []);
+    const invalid = updateEstimateGroup(
+      { ...sampleBalance(), name: "  " },
+      "group-440",
+      { title: " " }
+    );
+    assert.equal(validateEstimateBalance(invalid).length, 2);
+  });
+
+  it("names copies", () => {
+    assert.equal(createCopyName("Entwurfsplanung "), "Entwurfsplanung (Kopie)");
+    assert.equal(createCopyName("x".repeat(200)).length, 200);
+  });
+});
+
+describe("estimate balance frontend API", () => {
+  it("calls the estimate balance endpoints", async () => {
+    const requests: Array<{ url: string; method: string; body: unknown; keepalive?: boolean }> =
+      [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+      requests.push({
+        url: String(input),
+        method: init?.method ?? "GET",
+        body: init?.body === undefined ? undefined : JSON.parse(String(init.body)),
+        ...(init?.keepalive ? { keepalive: true } : {}),
+      });
+      return new Response(JSON.stringify({}), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    };
+    try {
+      const balance = sampleBalance();
+      await listEstimateBalances("project-1");
+      await getEstimateBalance("project-1", "balance-1");
+      await createEstimateBalance(
+        "project-1",
+        { name: "Vorplanung", workStage: null, dateIso: "2026-09-26", template: "kg400" },
+        4
+      );
+      await createEstimateBalance(
+        "project-1",
+        { name: "Kopie", template: "copy", copyFromBalanceId: "balance-1" },
+        5
+      );
+      await updateEstimateBalance("project-1", balance, 6);
+      await updateEstimateBalance("project-1", balance, 7, { keepalive: true });
+      await deleteEstimateBalance("project-1", "balance-1", 8);
+      await getEstimateComparison("project-1", "balance-1");
+      const base = "/api/projects/project-1/estimate-balances";
+      assert.deepEqual(requests, [
+        { url: base, method: "GET", body: undefined },
+        { url: `${base}/balance-1`, method: "GET", body: undefined },
+        {
+          url: base,
+          method: "POST",
+          body: {
+            name: "Vorplanung",
+            workStage: null,
+            dateIso: "2026-09-26",
+            template: "kg400",
+            expectedRevision: 4,
+          },
+        },
+        {
+          url: base,
+          method: "POST",
+          body: {
+            name: "Kopie",
+            template: "copy",
+            copyFromBalanceId: "balance-1",
+            expectedRevision: 5,
+          },
+        },
+        {
+          url: `${base}/balance-1`,
+          method: "PUT",
+          body: { expectedRevision: 6, balance },
+        },
+        {
+          url: `${base}/balance-1`,
+          method: "PUT",
+          body: { expectedRevision: 7, balance },
+          keepalive: true,
+        },
+        { url: `${base}/balance-1`, method: "DELETE", body: { expectedRevision: 8 } },
+        { url: `${base}/balance-1/comparison`, method: "GET", body: undefined },
+      ]);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  it("exposes status and code of failed requests", async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async () =>
+      new Response(
+        JSON.stringify({
+          error: "Projektstand veraltet.",
+          code: "PROJECT_REVISION_CONFLICT",
+        }),
+        { status: 409, headers: { "Content-Type": "application/json" } }
+      );
+    try {
+      await assert.rejects(
+        updateEstimateBalance("project-1", sampleBalance(), 1),
+        (error: unknown) => {
+          assert.ok(error instanceof ApiRequestError);
+          assert.equal(error.message, "Projektstand veraltet.");
+          assert.equal(error.status, 409);
+          assert.equal(error.code, "PROJECT_REVISION_CONFLICT");
+          assert.equal(isRevisionConflictError(error), true);
+          return true;
+        }
+      );
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+    assert.equal(isRevisionConflictError(new ApiRequestError("x", 400)), false);
+    assert.equal(isRevisionConflictError(new Error("x")), false);
+  });
+});
diff --git a/tests/estimate-balance.test.ts b/tests/estimate-balance.test.ts
new file mode 100644
index 0000000..7d294da
--- /dev/null
+++ b/tests/estimate-balance.test.ts
@@ -0,0 +1,459 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import {
+  createDatabaseContext,
+  type DatabaseContext,
+} from "../src/db/database-context.js";
+import { EstimateBalanceProjectCommandRepository } from "../src/db/repositories/estimate-balance-project-command.repository.js";
+import { EstimateBalanceRepository } from "../src/db/repositories/estimate-balance.repository.js";
+import { ProjectHistoryRepository } from "../src/db/repositories/project-history.repository.js";
+import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
+import { circuitLists } from "../src/db/schema/circuit-lists.js";
+import { circuitSections } from "../src/db/schema/circuit-sections.js";
+import { circuits } from "../src/db/schema/circuits.js";
+import { distributionBoards } from "../src/db/schema/distribution-boards.js";
+import { estimateRows } from "../src/db/schema/estimate-balances.js";
+import { projects } from "../src/db/schema/projects.js";
+import {
+  createEstimateBalanceDeleteProjectCommand,
+  createEstimateBalanceInsertProjectCommand,
+  createEstimateBalanceSnapshot,
+  createEstimateBalanceUpdateProjectCommand,
+  parseEstimateBalanceSnapshot,
+  type EstimateBalanceProjectCommand,
+} from "../src/estimate-balance/domain/estimate-balance-command.model.js";
+import { createEstimateBalanceRequestSchema } from "../src/estimate-balance/api/estimate-balance-request.schemas.js";
+import {
+  calculateEstimateBalance,
+  calculateEstimateRow,
+  compareEstimateWithDetailed,
+  estimateDefaultGroups,
+  matchEstimateCostGroup,
+  roundEstimateValue,
+  type EstimateBalanceSnapshot,
+  type EstimateRowSnapshot,
+} from "../src/shared/estimate-balance/estimate-balance.js";
+
+const round2 = (value: number) => roundEstimateValue(value, 2);
+let nextId = 0;
+const id = () => `id-${++nextId}`;
+
+function row(
+  name: string,
+  quantity: number,
+  powerPerUnitW: number,
+  simultaneityFactor: number,
+  cosPhi: number,
+  extra: Partial<EstimateRowSnapshot> = {}
+): EstimateRowSnapshot {
+  return {
+    id: id(),
+    sortOrder: 0,
+    supply: "ELT",
+    circuitRef: null,
+    name,
+    quantity,
+    unit: "piece",
+    connection: null,
+    powerPerUnitW,
+    simultaneityFactor,
+    cosPhi,
+    safetySupply: false,
+    remark: null,
+    ...extra,
+  };
+}
+
+/** All rows of the office example "Leistungsbilanz - KG400" (Entwurfsplanung). */
+function templateExample(): EstimateBalanceSnapshot {
+  const rowsByGroup: Record<string, EstimateRowSnapshot[]> = {
+    "410": [
+      row("Durchlauferhitzer 11kW", 9, 11200, 0.3, 1),
+      row("Durchlauferhitzer 4,4kW", 4, 4400, 0.3, 1),
+    ],
+    "420": [
+      row("Fernwärmestation", 1, 1000, 0.8, 1),
+      row("Pumpen", 4, 200, 0.8, 0.9),
+      row("Schaltschrank Heizung", 1, 2000, 0.8, 1),
+    ],
+    "430": [
+      row("Lüftungsgerät", 1, 6000, 0.8, 0.9),
+      row("Schaltschrank Lüftung", 1, 2000, 0.8, 0.9),
+    ],
+    "434": [
+      row("Kälteaggregat Dach", 1, 1000, 0.8, 1),
+      row("Serverraum Kühlung Aggregat Dach", 1, 2000, 0.8, 1),
+      row("Serverraum Innengerät", 1, 1000, 0.8, 1),
+    ],
+    "440": [
+      row("Beleuchtungsanlage Klassenzimmer", 17, 500, 0.8, 0.95),
+      row("Beleuchtung Allgemein", 50, 45, 0.7, 0.95),
+      row("Außenbeleuchtung", 10, 100, 0.4, 0.95),
+      row("Fassadenbeleuchtung", 20, 60, 0.5, 0.95),
+      row("Beleuchtung MFR", 15, 50, 0.8, 0.95),
+      row("Steckdosen Klassenzimmer", 170, 300, 0.2, 0.95),
+      row("Steckdosen 230 V allg. Verbr.", 100, 500, 0.2, 0.95),
+      row("Veranstaltungstechnik", 1, 4000, 0.5, 0.95),
+      row("Küchentechnische Anlagen", 1, 10000, 0.4, 0.8),
+      row("Sicherheitsbeleuchtung Zentrale", 1, 2000, 0.8, 0.9),
+      row("Spezielle Experimentieranlagen", 1, 6000, 0.4, 0.9),
+    ],
+    "450": [row("EDV Systeme", 5, 3000, 0.8, 0.95)],
+    "460": [row("Aufzug", 1, 16000, 0.7, 0.95)],
+    "470": [row("E-Mobility Vorbereitung", 9, 11000, 0.3, 1)],
+    "480": [],
+    "": [row("Allgemein", 1, 2000, 1, 0.95)],
+  };
+  return {
+    id: "balance-1",
+    projectId: "project-1",
+    name: "Entwurfsplanung",
+    workStage: "LPH 3",
+    dateIso: "2023-06-30",
+    reserveAvPercent: 10,
+    reserveSvPercent: 0,
+    sortOrder: 0,
+    groups: estimateDefaultGroups.map((group, index) => ({
+      id: `group-${group.costGroup || "allg"}`,
+      costGroup: group.costGroup,
+      title: group.title,
+      editor: null,
+      sortOrder: index,
+      rows: rowsByGroup[group.costGroup] ?? [],
+    })),
+  };
+}
+
+function createTestDatabase(): DatabaseContext {
+  const context = createDatabaseContext(":memory:");
+  migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+  context.db
+    .insert(projects)
+    .values([
+      { id: "project-1", name: "Test project" },
+      { id: "project-2", name: "Foreign project" },
+    ])
+    .run();
+  return context;
+}
+
+describe("estimate balance calculation", () => {
+  it("reproduces the office template totals", () => {
+    const result = calculateEstimateBalance(templateExample(), 400);
+    const groupTotals = result.groups.map((group) => [
+      round2(group.av.kw),
+      round2(group.av.kva),
+    ]);
+    assert.deepEqual(groupTotals, [
+      [35.52, 35.52],
+      [3.04, 3.11],
+      [6.4, 7.11],
+      [3.2, 3.2],
+      [40.18, 43.31],
+      [12, 12.63],
+      [11.2, 11.79],
+      [29.7, 29.7],
+      [0, 0],
+      [2, 2.11],
+    ]);
+    assert.equal(round2(result.total.av.kw), 143.24);
+    assert.equal(round2(result.total.av.kva), 148.48);
+    assert.equal(round2(result.reserve.av.kw), 14.32);
+    assert.equal(round2(result.reserve.av.kva), 14.85);
+    assert.equal(round2(result.withReserve.av.kw), 157.56);
+    assert.equal(round2(result.withReserve.av.kva), 163.33);
+    assert.equal(round2(result.maxCurrentA.av), 235.75);
+    assert.equal(result.total.sv.kw, 0);
+    assert.equal(result.maxCurrentA.sv, 0);
+  });
+
+  it("counts safety-supply rows in AV and additionally in SV, also per m²", () => {
+    const area = calculateEstimateRow({
+      quantity: 250,
+      powerPerUnitW: 12,
+      simultaneityFactor: 0.8,
+      cosPhi: 0.95,
+      safetySupply: true,
+    });
+    assert.equal(round2(area.av.kw), 2.4);
+    assert.equal(round2(area.av.kva), 2.53);
+    assert.deepEqual(area.sv, area.av);
+    const balance = templateExample();
+    balance.reserveSvPercent = 20;
+    balance.groups[4]!.rows[9]!.safetySupply = true; // Sicherheitsbeleuchtung Zentrale
+    const result = calculateEstimateBalance(balance, 400);
+    assert.equal(round2(result.total.sv.kw), 1.6);
+    assert.equal(round2(result.withReserve.sv.kw), 1.92);
+    assert.equal(round2(result.total.av.kw), 143.24);
+  });
+
+  it("rounds displayed values like the spreadsheet", () => {
+    assert.equal(roundEstimateValue(40.175), 40.18);
+    assert.equal(roundEstimateValue(143.235), 143.24);
+    assert.equal(roundEstimateValue(-1.825), -1.83);
+    assert.equal(roundEstimateValue(0.711111), 0.71);
+    assert.equal(roundEstimateValue(235.749, 1), 235.7);
+  });
+
+  it("matches detailed cost groups to the most specific estimate group", () => {
+    const codes = ["410", "430", "434", "440", "480", ""];
+    assert.equal(matchEstimateCostGroup("444", codes), "440");
+    assert.equal(matchEstimateCostGroup("434", codes), "434");
+    assert.equal(matchEstimateCostGroup("431", codes), "430");
+    assert.equal(matchEstimateCostGroup("KG 481.1", codes), "480");
+    assert.equal(matchEstimateCostGroup("4", codes), null);
+    assert.equal(matchEstimateCostGroup("", codes), null);
+    assert.equal(matchEstimateCostGroup(null, codes), null);
+    assert.equal(matchEstimateCostGroup("450", codes), null);
+  });
+
+  it("compares the estimate with detailed device rows per cost group", () => {
+    const comparison = compareEstimateWithDetailed(templateExample(), [
+      { costGroup: "444", kw: 30, cosPhi: 0.9 },
+      { costGroup: "445", kw: 12, cosPhi: null },
+      { costGroup: "412", kw: 40, cosPhi: 1 },
+      { costGroup: null, kw: 5, cosPhi: 1 },
+      { costGroup: "399", kw: 1, cosPhi: 1 },
+    ]);
+    const kg440 = comparison.groups.find((group) => group.costGroup === "440")!;
+    assert.equal(round2(kg440.detailed.kw), 42);
+    assert.equal(round2(kg440.detailed.kva), 45.33);
+    assert.equal(kg440.detailedRowCount, 2);
+    assert.ok(Math.abs(kg440.deltaKw - 1.825) < 1e-9);
+    assert.equal(round2(kg440.deltaPercent!), 4.54);
+    const kg410 = comparison.groups.find((group) => group.costGroup === "410")!;
+    assert.equal(round2(kg410.deltaKw), 4.48);
+    const kg480 = comparison.groups.find((group) => group.costGroup === "480")!;
+    assert.equal(kg480.deltaPercent, null);
+    assert.deepEqual(comparison.unassigned, { kw: 6, kva: 6, rowCount: 2 });
+    assert.equal(round2(comparison.total.detailed.kw), 88);
+    assert.equal(round2(comparison.total.estimatedAv.kw), 143.24);
+  });
+});
+
+describe("estimate balance snapshots and commands", () => {
+  it("validates snapshots strictly", () => {
+    const valid = templateExample();
+    assert.equal(parseEstimateBalanceSnapshot(valid).groups[4]!.rows[3]!.sortOrder, 3);
+    const invalid: Array<(balance: EstimateBalanceSnapshot) => void> = [
+      (balance) => (balance.groups[0]!.rows[0]!.cosPhi = 0),
+      (balance) => (balance.groups[0]!.rows[0]!.simultaneityFactor = 1.5),
+      (balance) => (balance.groups[0]!.rows[0]!.quantity = -1),
+      (balance) => (balance.groups[0]!.rows[0]!.name = " Leerzeichen "),
+      (balance) => (balance.groups[0]!.rows[0]!.supply = ""),
+      (balance) => (balance.groups[0]!.title = ""),
+      (balance) => (balance.dateIso = "30.06.2023"),
+      (balance) => (balance.reserveAvPercent = 101),
+      (balance) => (balance.groups[1]!.rows[0]!.id = balance.groups[0]!.rows[0]!.id),
+      (balance) => ((balance.groups[0]!.rows[0] as unknown as Record<string, unknown>).extra = 1),
+    ];
+    for (const mutate of invalid) {
+      const balance = structuredClone(valid);
+      mutate(balance);
+      assert.throws(() => parseEstimateBalanceSnapshot(balance));
+    }
+    assert.equal(
+      createEstimateBalanceRequestSchema.safeParse({
+        expectedRevision: 0,
+        name: "Entwurf",
+        template: "copy",
+      }).success,
+      false
+    );
+  });
+
+  it("creates the KG 400 template and copies a Stand with new ids", () => {
+    const created = createEstimateBalanceSnapshot({
+      projectId: "project-1",
+      name: " Vorplanung ",
+      workStage: "LPH 2",
+      dateIso: "2026-09-26",
+      sortOrder: 0,
+      template: "kg400",
+    });
+    assert.equal(created.name, "Vorplanung");
+    assert.deepEqual(
+      created.groups.map((group) => group.costGroup),
+      estimateDefaultGroups.map((group) => group.costGroup)
+    );
+    assert.equal(created.reserveAvPercent, 10);
+    const source = templateExample();
+    const copy = createEstimateBalanceSnapshot({
+      projectId: "project-1",
+      name: "Entwurfsplanung Kopie",
+      workStage: null,
+      dateIso: null,
+      sortOrder: 1,
+      template: { copyFrom: source },
+    });
+    assert.notEqual(copy.id, source.id);
+    assert.notEqual(copy.groups[0]!.id, source.groups[0]!.id);
+    assert.notEqual(copy.groups[0]!.rows[0]!.id, source.groups[0]!.rows[0]!.id);
+    assert.equal(
+      round2(calculateEstimateBalance(copy, 400).total.av.kw),
+      143.24
+    );
+  });
+
+  it("inserts, updates and deletes balances with persisted undo and redo", () => {
+    const context = createTestDatabase();
+    try {
+      const store = new EstimateBalanceProjectCommandRepository(context.db);
+      const reader = new EstimateBalanceRepository(context.db);
+      const history = new ProjectHistoryRepository(context.db);
+      let revision = 0;
+      const run = (
+        command: EstimateBalanceProjectCommand,
+        source: "user" | "undo" | "redo" = "user"
+      ) => {
+        const step = source === "user" ? null : history.getNextCommand("project-1", source);
+        const result = store.execute({
+          projectId: "project-1",
+          expectedRevision: revision,
+          source,
+          historyTargetChangeSetId: step?.changeSetId,
+          command,
+        });
+        revision += 1;
+        return result;
+      };
+
+      const balance = templateExample();
+      const insert = createEstimateBalanceInsertProjectCommand(balance);
+      const inserted = run(insert);
+      const stored = reader.findById("project-1", balance.id);
+      assert.deepEqual(stored, parseEstimateBalanceSnapshot(balance));
+      assert.equal(reader.listByProject("project-2").length, 0);
+
+      const target = structuredClone(stored!);
+      target.groups[0]!.rows.splice(1, 1);
+      target.groups[0]!.rows[0]!.quantity = 10;
+      target.groups[8]!.rows.push(row("GLT-Schrank", 2, 500, 1, 0.95));
+      target.groups[8]!.editor = "MSR";
+      target.reserveAvPercent = 15;
+      const update = createEstimateBalanceUpdateProjectCommand(stored!, target);
+      const updated = run(update);
+      assert.deepEqual(
+        reader.findById("project-1", balance.id),
+        parseEstimateBalanceSnapshot(target)
+      );
+
+      run(updated.inverse, "undo");
+      assert.deepEqual(reader.findById("project-1", balance.id), stored);
+      run(update, "redo");
+      assert.deepEqual(
+        reader.findById("project-1", balance.id),
+        parseEstimateBalanceSnapshot(target)
+      );
+
+      // A stale expected document is rejected.
+      assert.throws(
+        () => run(createEstimateBalanceUpdateProjectCommand(stored!, { ...stored!, name: "X" })),
+        /changed before update/
+      );
+      assert.throws(
+        () => createEstimateBalanceUpdateProjectCommand(stored!, structuredClone(stored!)),
+        /must change/
+      );
+
+      const current = reader.findById("project-1", balance.id)!;
+      const deleted = run(createEstimateBalanceDeleteProjectCommand(current));
+      assert.equal(reader.findById("project-1", balance.id), null);
+      assert.equal(context.db.select().from(estimateRows).all().length, 0);
+      run(deleted.inverse, "undo");
+      assert.deepEqual(reader.findById("project-1", balance.id), current);
+      // The original insert's inverse no longer matches the edited balance.
+      assert.throws(() => run(inserted.inverse), /changed before deletion/);
+      run(createEstimateBalanceDeleteProjectCommand(current));
+      assert.equal(reader.listByProject("project-1").length, 0);
+
+      assert.throws(
+        () => run(createEstimateBalanceInsertProjectCommand({ ...balance, projectId: "project-2" })),
+        /does not belong to project/
+      );
+    } finally {
+      context.close();
+    }
+  });
+
+  it("sums detailed device rows of all circuit lists of the project", () => {
+    const context = createTestDatabase();
+    try {
+      context.db
+        .insert(distributionBoards)
+        .values({ id: "board-1", projectId: "project-1", name: "UV 1" })
+        .run();
+      context.db
+        .insert(circuitLists)
+        .values({ id: "list-1", projectId: "project-1", distributionBoardId: "board-1", name: "UV 1" })
+        .run();
+      context.db
+        .insert(circuitSections)
+        .values({
+          id: "section-1",
+          circuitListId: "list-1",
+          key: "lighting-1",
+          displayName: "Beleuchtung 1",
+          prefix: "1F1",
+          sortOrder: 0,
+        })
+        .run();
+      context.db
+        .insert(circuits)
+        .values({
+          id: "circuit-1",
+          circuitListId: "list-1",
+          sectionId: "section-1",
+          equipmentIdentifier: "-1F1",
+          displayName: "Licht",
+          sortOrder: 0,
+        })
+        .run();
+      context.db
+        .insert(circuitDeviceRows)
+        .values([
+          {
+            id: "row-1",
+            circuitId: "circuit-1",
+            name: "Leuchte",
+            displayName: "Leuchte",
+            costGroup: "445",
+            quantity: 10,
+            powerPerUnit: 0.05,
+            simultaneityFactor: 0.8,
+            cosPhi: 0.95,
+          },
+          {
+            id: "row-2",
+            circuitId: "circuit-1",
+            name: "Steckdose",
+            displayName: "Steckdose",
+            costGroup: null,
+            quantity: 2,
+            powerPerUnit: 0.2,
+            simultaneityFactor: 0.5,
+            cosPhi: null,
+          },
+        ])
+        .run();
+      const detailed = new EstimateBalanceRepository(context.db).listDetailedDeviceRowPower(
+        "project-1"
+      );
+      assert.deepEqual(
+        detailed.map((entry) => ({ ...entry, kw: round2(entry.kw) })),
+        [
+          { costGroup: "445", kw: 0.4, cosPhi: 0.95 },
+          { costGroup: null, kw: 0.2, cosPhi: null },
+        ]
+      );
+      assert.equal(
+        new EstimateBalanceRepository(context.db).listDetailedDeviceRowPower("project-2").length,
+        0
+      );
+    } finally {
+      context.close();
+    }
+  });
+});

From e06c7d91e2fff2c764cf19b03a7cb88e73ce90ed Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 17:48:37 +0200
Subject: [PATCH 22/60] Print the rough power balance in the kbp design

The print of the rough power balance was plain grey. It now follows the
kbp design of the print view: a title block with office logo, stand,
project, number, owner, address, work stage, date, editor and office;
header row in kbp blue, cost-group rows tinted with a lilac rule, bold
subtotals, the total including reserve as a blue band, colored
deviations in the comparison, Arial, exact print colors, and a footer
with project, stand and "Seite x von y" on every page.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/app/globals.css                           | 210 ++++++++++++++++--
 .../grobbilanz/[balanceId]/page.tsx           |   2 +
 .../estimate-print-header.tsx                 | 104 +++++++++
 3 files changed, 292 insertions(+), 24 deletions(-)
 create mode 100644 src/frontend/estimate-balance/estimate-print-header.tsx

diff --git a/src/app/globals.css b/src/app/globals.css
index b3f526a..4a0adc8 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -1965,14 +1965,23 @@ button.structure-entry-main:focus-visible {
   display: none;
 }
 
+/* Druck im kbp-CD der Seitenansicht (src/frontend/print/print-document.css):
+   gleiche Farben, Schrift, Titelblock und Fußzeile. Die Fußzeile mit
+   Seitenzahlen setzt EstimatePrintHeader als @page-Regel mit Projektdaten. */
+.estimate-print-titleblock {
+  display: none;
+}
+
 @page estimate-balance {
   size: A4 landscape;
-  margin: 10mm;
+  margin: 10mm 10mm 13mm;
 }
 
 @media print {
   body:has(.estimate-print-root) .sidebar,
   .estimate-print-root .estimate-no-print,
+  .estimate-print-root .estimate-page-header,
+  .estimate-print-root .estimate-header-fields,
   .estimate-print-root .alert,
   .estimate-print-root input,
   .estimate-print-root select,
@@ -1989,28 +1998,122 @@ button.structure-entry-main:focus-visible {
   }
 
   .estimate-print-root {
+    --ep-blue: #476088;
+    --ep-lilac: #9198c4;
+    --ep-line: #d6dae5;
+    --ep-tint: #f5f6fa;
+    --ep-text: #2b2b2b;
+    --ep-muted: #6b7280;
+    --ep-accent: #c9782a;
     page: estimate-balance;
     padding: 0 !important;
     max-width: none;
-    color: #000;
+    color: var(--ep-text);
+    font-family: Arial, "Helvetica Neue", Helvetica, sans-serif;
+    color-scheme: light;
+  }
+
+  .estimate-print-root * {
+    -webkit-print-color-adjust: exact;
+    print-color-adjust: exact;
   }
 
   .estimate-print-root .estimate-print-value {
     display: inline;
   }
 
-  .estimate-print-root .page-header {
+  /* Titelblock wie der Plankopf der Seitenansicht */
+  .estimate-print-titleblock {
+    display: grid;
+    grid-template-columns: 30mm 1fr auto auto;
     margin-bottom: 4mm;
+    border: 1.5px solid var(--ep-blue);
+    background: #fff;
+    font-size: 8.5pt;
+    break-inside: avoid;
   }
 
-  .estimate-print-root .page-header h1 {
-    font-size: 14pt;
-    color: #000;
+  .estimate-print-titleblock > * {
+    padding: 2.5mm 3.5mm;
+    border-left: 1px solid var(--ep-line);
   }
 
+  .estimate-print-titleblock > :first-child {
+    border-left: none;
+  }
+
+  .estimate-print-logo {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 16mm;
+    color: var(--ep-blue);
+    font-weight: bold;
+    text-align: center;
+  }
+
+  .estimate-print-logo img {
+    max-width: 100%;
+    max-height: 10mm;
+  }
+
+  .estimate-print-kicker {
+    color: var(--ep-muted);
+    font-size: 7pt;
+    letter-spacing: 0.05em;
+    text-transform: uppercase;
+  }
+
+  .estimate-print-heading {
+    display: flex;
+    align-items: baseline;
+    flex-wrap: wrap;
+    gap: 1mm 4mm;
+    margin-top: 1mm;
+  }
+
+  .estimate-print-stand {
+    color: var(--ep-blue);
+    font-size: 16pt;
+    font-weight: bold;
+  }
+
+  .estimate-print-project {
+    font-size: 12pt;
+    font-weight: bold;
+  }
+
+  .estimate-print-meta {
+    display: grid;
+    grid-template-columns: auto auto;
+    gap: 0.8mm 4mm;
+    align-content: center;
+    margin: 0;
+    font-size: 7.5pt;
+  }
+
+  .estimate-print-meta div {
+    display: contents;
+  }
+
+  .estimate-print-meta dt {
+    color: var(--ep-muted);
+    font-weight: normal;
+  }
+
+  .estimate-print-meta dd {
+    margin: 0;
+    font-weight: bold;
+  }
+
+  .estimate-print-meta.is-tinted {
+    background: var(--ep-tint);
+  }
+
+  /* Karten und Ränder der Bildschirmansicht entfallen */
   .estimate-print-root .card {
     border: 0;
-    box-shadow: none;
+    box-shadow: none !important;
     background: transparent;
   }
 
@@ -2026,54 +2129,117 @@ button.structure-entry-main:focus-visible {
     break-inside: avoid;
   }
 
+  .estimate-print-root .estimate-comparison-card .card-header {
+    margin-bottom: 2mm;
+    color: var(--ep-blue);
+    font-size: 10pt;
+    font-weight: bold;
+  }
+
   .estimate-sheet-wrap {
     overflow: visible;
   }
 
+  /* Tabelle */
   .estimate-sheet {
     min-width: 0;
     table-layout: auto;
-    font-size: 7.5pt;
+    font-size: 7.4pt;
+    line-height: 1.2;
     background: #fff;
-    color: #000;
+    color: var(--ep-text);
   }
 
   .estimate-sheet th,
   .estimate-sheet td {
-    border-color: #999;
-    padding: 1px 3px;
+    border: 1px solid var(--ep-line) !important;
+    padding: 0.7mm 1.5mm;
+    background: #fff;
+    color: var(--ep-text);
   }
 
   .estimate-sheet thead {
     display: table-header-group;
   }
 
-  .estimate-sheet thead th,
-  .estimate-total-row td {
-    background: #e8e8e8 !important;
+  .estimate-sheet thead th {
+    background: var(--ep-blue) !important;
+    border-color: var(--ep-blue) !important;
+    color: #fff !important;
+    font-weight: bold;
+    vertical-align: bottom;
+  }
+
+  .estimate-sheet thead .estimate-th-hint {
+    color: #dfe3f0 !important;
   }
 
   .estimate-group-title-row td {
-    background: #d9d9d9 !important;
+    background: var(--ep-tint) !important;
+    border-top: 1.5px solid var(--ep-lilac) !important;
+    font-weight: bold;
+  }
+
+  .estimate-group-title-row .estimate-cost-group-cell {
+    color: var(--ep-blue) !important;
+  }
+
+  .estimate-group-title-row .estimate-group-editor {
+    color: var(--ep-muted);
+    font-weight: normal;
   }
 
   .estimate-subtotal-row td {
-    background: #f2f2f2 !important;
+    border-bottom: 1.5px solid var(--ep-line) !important;
+    font-weight: bold;
+  }
+
+  .estimate-subtotal-row .estimate-total-label {
+    color: var(--ep-muted);
+  }
+
+  .estimate-total-row td {
+    background: var(--ep-tint) !important;
+    font-weight: bold;
+  }
+
+  .estimate-total-row.is-strong td {
+    background: var(--ep-blue) !important;
+    border-color: var(--ep-blue) !important;
+    color: #fff !important;
+  }
+
+  .estimate-total-row .estimate-total-hint {
+    color: var(--ep-muted);
+    font-weight: normal;
+  }
+
+  .estimate-total-row.is-strong .estimate-total-hint {
+    color: #dfe3f0;
+  }
+
+  .estimate-comparison .is-over {
+    color: var(--ep-accent) !important;
+    font-weight: bold;
+  }
+
+  .estimate-comparison .is-under {
+    color: var(--ep-blue) !important;
+    font-weight: bold;
   }
 
   .estimate-group-title-row,
   .estimate-subtotal-row,
-  .estimate-total-row {
+  .estimate-total-row,
+  .estimate-row {
     break-inside: avoid;
-    -webkit-print-color-adjust: exact;
-    print-color-adjust: exact;
   }
 
   .estimate-group-title-row {
     break-after: avoid;
   }
 
-  /* Totals print once at the end, not repeated on every page. */
+  /* Summen einmal am Ende, nicht auf jeder Seite */
   .estimate-sheet tfoot {
     display: table-row-group;
     break-inside: avoid;
@@ -2087,8 +2253,4 @@ button.structure-entry-main:focus-visible {
   .estimate-gzf-input {
     justify-content: flex-end;
   }
-
-  .estimate-header-fields {
-    margin-bottom: 3mm;
-  }
 }
diff --git a/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx b/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx
index 2aa7f5e..584f5cf 100644
--- a/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx
+++ b/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx
@@ -48,6 +48,7 @@ import {
 } from "../../../../../frontend/estimate-balance/estimate-balance-sheet";
 import { EstimateComparisonTable } from "../../../../../frontend/estimate-balance/estimate-comparison-table";
 import { DraftInput } from "../../../../../frontend/estimate-balance/estimate-draft-input";
+import { EstimatePrintHeader } from "../../../../../frontend/estimate-balance/estimate-print-header";
 import {
   EstimateGroupModal,
   type EstimateGroupFormValues,
@@ -461,6 +462,7 @@ export default function EstimateBalanceEditorPage() {
 
   return (
     <main className="container-fluid py-4 estimate-print-root">
+      {project && draft ? <EstimatePrintHeader balance={draft} project={project} /> : null}
       <div className="page-header estimate-page-header">
         <div className="d-flex align-items-start gap-3">
           <Link
diff --git a/src/frontend/estimate-balance/estimate-print-header.tsx b/src/frontend/estimate-balance/estimate-print-header.tsx
new file mode 100644
index 0000000..84ce3e9
--- /dev/null
+++ b/src/frontend/estimate-balance/estimate-print-header.tsx
@@ -0,0 +1,104 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { documentLogoUrl, getDocumentBranding } from "../utils/api";
+import type { EstimateBalanceDto, OfficeProfileDto, ProjectDto } from "../types";
+import { formatIsoDateGerman } from "./estimate-balance-format";
+
+interface EstimatePrintHeaderProps {
+  project: ProjectDto;
+  balance: EstimateBalanceDto;
+}
+
+function cssString(value: string) {
+  return JSON.stringify(value.replace(/[<>\r\n]/g, " "));
+}
+
+/**
+ * Print-only title block and page footer of the rough power balance in the
+ * kbp corporate design of the print view (Seitenansicht): logo, blue title,
+ * meta data, "Seite x von y". Hidden on screen.
+ */
+export function EstimatePrintHeader({ project, balance }: EstimatePrintHeaderProps) {
+  const [office, setOffice] = useState<OfficeProfileDto | null>(null);
+  const [hasLogo, setHasLogo] = useState(false);
+  const [logoVersion, setLogoVersion] = useState("");
+
+  useEffect(() => {
+    getDocumentBranding()
+      .then((branding) => {
+        setOffice(branding.office);
+        setHasLogo(Boolean(branding.logo));
+        setLogoVersion(branding.logo ? branding.logo.updatedAtIso : "");
+      })
+      .catch(() => {
+        setOffice(null);
+        setHasLogo(false);
+      });
+  }, []);
+
+  const stand = [balance.name, balance.workStage].filter(Boolean).join(" · ");
+  const date = balance.dateIso ? formatIsoDateGerman(balance.dateIso) : null;
+  const footer = `
+    @page estimate-balance {
+      size: A4 landscape;
+      margin: 10mm 10mm 13mm;
+      @bottom-left { content: ${cssString(`${project.name} · Grobe Leistungsbilanz`)}; font: 7.5pt Arial, sans-serif; color: #6b7280; }
+      @bottom-center { content: ${cssString(`Stand ${stand}${date ? ` · ${date}` : ""}`)}; font: 7.5pt Arial, sans-serif; color: #6b7280; }
+      @bottom-right { content: "Seite " counter(page) " von " counter(pages); font: 7.5pt Arial, sans-serif; color: #6b7280; }
+    }`;
+
+  return (
+    <>
+      <style>{footer}</style>
+      <header className="estimate-print-titleblock" aria-hidden="true">
+        <div className="estimate-print-logo">
+          {hasLogo ? (
+            <img alt="" src={`${documentLogoUrl}?v=${encodeURIComponent(logoVersion)}`} />
+          ) : (
+            <span>{office?.officeName ?? ""}</span>
+          )}
+        </div>
+        <div className="estimate-print-title">
+          <div className="estimate-print-kicker">Grobe Leistungsbilanz · KG 400</div>
+          <div className="estimate-print-heading">
+            <span className="estimate-print-stand">{balance.name}</span>
+            <span className="estimate-print-project">{project.name}</span>
+          </div>
+        </div>
+        <dl className="estimate-print-meta">
+          <div>
+            <dt>Projekt-Nr.</dt>
+            <dd>{project.internalProjectNumber ?? "–"}</dd>
+          </div>
+          <div>
+            <dt>Bauherr</dt>
+            <dd>{project.buildingOwner ?? "–"}</dd>
+          </div>
+          <div>
+            <dt>Anschrift</dt>
+            <dd>{project.siteAddress?.split("\n").join(", ") ?? "–"}</dd>
+          </div>
+        </dl>
+        <dl className="estimate-print-meta is-tinted">
+          <div>
+            <dt>Leistungsphase</dt>
+            <dd>{balance.workStage ?? "–"}</dd>
+          </div>
+          <div>
+            <dt>Datum</dt>
+            <dd>{date ?? "–"}</dd>
+          </div>
+          <div>
+            <dt>Bearbeitung</dt>
+            <dd>{project.projectEditor ?? "–"}</dd>
+          </div>
+          <div>
+            <dt>Büro</dt>
+            <dd>{office?.officeName ?? "–"}</dd>
+          </div>
+        </dl>
+      </header>
+    </>
+  );
+}

From 72189d23a50b12ade4672bd6901d2c78626710f2 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 17:56:53 +0200
Subject: [PATCH 23/60] Offer supply suggestions, drop the circuit column,
 center cells
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Versorgung field suggests ELT and MSR (plus values already used in
the balance) through a datalist and still accepts free text. The circuit
number column is not needed in early design phases; it is removed from
the data model, the regenerated migration 0010, the editor and the
print. All cells are centered except "Verbraucher / Flächen", group
titles and total labels.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/estimate-balance.md                      |  2 +-
 src/app/globals.css                           | 33 +++++++++++++++-
 src/db/migrations/0010_estimate_balances.sql  |  1 -
 src/db/migrations/meta/0010_snapshot.json     |  9 +----
 src/db/migrations/meta/_journal.json          |  2 +-
 src/db/schema/estimate-balances.ts            |  1 -
 .../domain/estimate-balance-command.model.ts  |  2 -
 .../estimate-balance-document.ts              |  3 --
 .../estimate-balance-sheet.tsx                | 39 ++++++++++++-------
 .../estimate-balance/estimate-balance.ts      |  4 +-
 tests/estimate-balance-frontend.test.ts       |  5 +--
 tests/estimate-balance.test.ts                |  1 -
 12 files changed, 60 insertions(+), 42 deletions(-)

diff --git a/docs/estimate-balance.md b/docs/estimate-balance.md
index 4e43cec..afe4780 100644
--- a/docs/estimate-balance.md
+++ b/docs/estimate-balance.md
@@ -34,7 +34,7 @@ das Frontend sie direkt nutzt (Turbopack löst die `.js`-Suffixe der API nicht a
 |---|---|
 | `estimate_balances` | ein **Stand** je Projekt (z. B. Vorplanung, Entwurfsplanung): Name, LPH, Datum, Reserve AV/SV in %, Sortierung |
 | `estimate_groups` | Kostengruppe (`"410"` … `"480"`, `""` für „Allgemein“), Titel, „bearbeitet von“, Sortierung |
-| `estimate_rows` | Versorgung, Stromkreis-Nr. (Freitext), Verbraucher/Fläche, Anzahl bzw. Fläche, Einheit (`piece` = St., `area` = m²), Anschluss (fest/Steckdose), Einzelleistung in W bzw. W/m², GLF, cos φ, SV ja/nein, Anmerkung |
+| `estimate_rows` | Versorgung (Auswahl ELT/MSR oder Freitext), Verbraucher/Fläche, Anzahl bzw. Fläche, Einheit (`piece` = St., `area` = m²), Anschluss (fest/Steckdose), Einzelleistung in W bzw. W/m², GLF, cos φ, SV ja/nein, Anmerkung |
 
 Neue Stände entstehen aus der Vorlage KG 400 (410 Sanitär, 420 Wärme, 430 Luft,
 434 Kälte, 440 Starkstrom, 450 Schwachstrom, 460 Förder, 470 Nutzungsspezifisch,
diff --git a/src/app/globals.css b/src/app/globals.css
index 4a0adc8..4f0bcb7 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -1731,7 +1731,6 @@ button.structure-entry-main:focus-visible {
 
 .estimate-col-kg { width: 3rem; }
 .estimate-col-supply { width: 4rem; }
-.estimate-col-circuit { width: 4.6rem; }
 .estimate-col-name { width: auto; }
 .estimate-col-quantity { width: 4.8rem; }
 .estimate-col-unit { width: 3.8rem; }
@@ -1965,6 +1964,36 @@ button.structure-entry-main:focus-visible {
   display: none;
 }
 
+/* Ausrichtung: alle Zellen zentriert, nur „Verbraucher / Flächen“, die
+   Gruppentitel und die Summenbeschriftungen stehen links bzw. rechts. */
+.estimate-sheet td,
+.estimate-sheet td.estimate-number,
+.estimate-sheet .estimate-cell-input,
+.estimate-sheet .estimate-cell-input.is-numeric {
+  text-align: center;
+}
+
+.estimate-sheet .estimate-cell-select {
+  text-align: center;
+  text-align-last: center;
+}
+
+.estimate-sheet .estimate-unit-input,
+.estimate-sheet .estimate-gzf-input {
+  justify-content: center;
+}
+
+.estimate-sheet td.estimate-name-cell,
+.estimate-sheet td.estimate-name-cell .estimate-cell-input,
+.estimate-sheet .estimate-group-title-row td:not(.estimate-cost-group-cell),
+.estimate-comparison td:nth-child(2) {
+  text-align: left;
+}
+
+.estimate-sheet td.estimate-total-label {
+  text-align: right;
+}
+
 /* Druck im kbp-CD der Seitenansicht (src/frontend/print/print-document.css):
    gleiche Farben, Schrift, Titelblock und Fußzeile. Die Fußzeile mit
    Seitenzahlen setzt EstimatePrintHeader als @page-Regel mit Projektdaten. */
@@ -2251,6 +2280,6 @@ button.structure-entry-main:focus-visible {
 
   .estimate-unit-input,
   .estimate-gzf-input {
-    justify-content: flex-end;
+    justify-content: center;
   }
 }
diff --git a/src/db/migrations/0010_estimate_balances.sql b/src/db/migrations/0010_estimate_balances.sql
index 645ccbe..bfa9dd3 100644
--- a/src/db/migrations/0010_estimate_balances.sql
+++ b/src/db/migrations/0010_estimate_balances.sql
@@ -27,7 +27,6 @@ CREATE TABLE `estimate_rows` (
 	`group_id` text NOT NULL,
 	`sort_order` integer DEFAULT 0 NOT NULL,
 	`supply` text,
-	`circuit_ref` text,
 	`name` text DEFAULT '' NOT NULL,
 	`quantity` real DEFAULT 0 NOT NULL,
 	`unit` text DEFAULT 'piece' NOT NULL,
diff --git a/src/db/migrations/meta/0010_snapshot.json b/src/db/migrations/meta/0010_snapshot.json
index 869d504..d58518a 100644
--- a/src/db/migrations/meta/0010_snapshot.json
+++ b/src/db/migrations/meta/0010_snapshot.json
@@ -1,7 +1,7 @@
 {
   "version": "6",
   "dialect": "sqlite",
-  "id": "6df688bd-a78a-46a1-ba7a-4068119bf8bd",
+  "id": "5376ae9f-67c7-4603-b3d2-8527136436f9",
   "prevId": "2cd9adef-2f08-4635-b3d9-ecf71f624c7f",
   "tables": {
     "buildings": {
@@ -1322,13 +1322,6 @@
           "notNull": false,
           "autoincrement": false
         },
-        "circuit_ref": {
-          "name": "circuit_ref",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
         "name": {
           "name": "name",
           "type": "text",
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index 209a0a2..f2c5dba 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -75,7 +75,7 @@
     {
       "idx": 10,
       "version": "6",
-      "when": 1790425784626,
+      "when": 1790438092269,
       "tag": "0010_estimate_balances",
       "breakpoints": true
     }
diff --git a/src/db/schema/estimate-balances.ts b/src/db/schema/estimate-balances.ts
index 81420f1..4425a03 100644
--- a/src/db/schema/estimate-balances.ts
+++ b/src/db/schema/estimate-balances.ts
@@ -44,7 +44,6 @@ export const estimateRows = sqliteTable(
       .references(() => estimateGroups.id, { onDelete: "cascade" }),
     sortOrder: integer("sort_order").notNull().default(0),
     supply: text("supply"),
-    circuitRef: text("circuit_ref"),
     name: text("name").notNull().default(""),
     quantity: real("quantity").notNull().default(0),
     unit: text("unit", { enum: ["piece", "area"] }).notNull().default("piece"),
diff --git a/src/estimate-balance/domain/estimate-balance-command.model.ts b/src/estimate-balance/domain/estimate-balance-command.model.ts
index 44263e4..f1b0da8 100644
--- a/src/estimate-balance/domain/estimate-balance-command.model.ts
+++ b/src/estimate-balance/domain/estimate-balance-command.model.ts
@@ -28,7 +28,6 @@ export const estimateRowSnapshotSchema = z
     id: idSchema,
     sortOrder: z.number().int().min(0),
     supply: nullableText(50),
-    circuitRef: nullableText(50),
     name: trimmed(200),
     quantity: finite.min(0),
     unit: z.enum(["piece", "area"]),
@@ -158,7 +157,6 @@ export function canonicalEstimateBalance(balance: EstimateBalanceSnapshot): stri
         id: row.id,
         sortOrder: row.sortOrder,
         supply: row.supply,
-        circuitRef: row.circuitRef,
         name: row.name,
         quantity: row.quantity,
         unit: row.unit,
diff --git a/src/frontend/estimate-balance/estimate-balance-document.ts b/src/frontend/estimate-balance/estimate-balance-document.ts
index 0049dc2..e2726d1 100644
--- a/src/frontend/estimate-balance/estimate-balance-document.ts
+++ b/src/frontend/estimate-balance/estimate-balance-document.ts
@@ -18,7 +18,6 @@ export const estimateTextLimits = {
   groupTitle: 200,
   groupEditor: 100,
   supply: 50,
-  circuitRef: 50,
   rowName: 200,
   remark: 500,
 } as const;
@@ -34,7 +33,6 @@ export function createEstimateRow(
     id: createId(),
     sortOrder,
     supply: null,
-    circuitRef: null,
     name: "",
     quantity: 1,
     unit: "piece",
@@ -257,7 +255,6 @@ export function toSaveableEstimateBalance(
         id: row.id,
         sortOrder: row.sortOrder,
         supply: optionalText(row.supply),
-        circuitRef: optionalText(row.circuitRef),
         name: requiredText(row.name),
         quantity: row.quantity,
         unit: row.unit,
diff --git a/src/frontend/estimate-balance/estimate-balance-sheet.tsx b/src/frontend/estimate-balance/estimate-balance-sheet.tsx
index debba7f..4703397 100644
--- a/src/frontend/estimate-balance/estimate-balance-sheet.tsx
+++ b/src/frontend/estimate-balance/estimate-balance-sheet.tsx
@@ -50,8 +50,12 @@ interface EstimateBalanceSheetProps {
 }
 
 // Leading columns up to cos φ; the power columns follow.
-const LEADING_COLUMN_COUNT = 10;
-const COLUMN_COUNT = 17;
+const LEADING_COLUMN_COUNT = 9;
+const COLUMN_COUNT = 16;
+
+/** Suggested supply values; free text stays possible. */
+const SUPPLY_SUGGESTIONS = ["ELT", "MSR"];
+const SUPPLY_LIST_ID = "estimate-supply-options";
 
 function NumberInput({
   ariaLabel,
@@ -85,9 +89,17 @@ function NumberInput({
   );
 }
 
+function supplyOptions(balance: EstimateBalanceSnapshot): string[] {
+  const used = balance.groups.flatMap((group) =>
+    group.rows.map((row) => row.supply?.trim() ?? "")
+  );
+  return [...new Set([...SUPPLY_SUGGESTIONS, ...used.filter(Boolean)])];
+}
+
 function TextInput({
   ariaLabel,
   disabled,
+  list,
   maxLength,
   onChange,
   placeholder,
@@ -95,6 +107,7 @@ function TextInput({
 }: {
   ariaLabel: string;
   disabled: boolean;
+  list?: string;
   maxLength: number;
   onChange: (value: string) => void;
   placeholder?: string;
@@ -106,6 +119,7 @@ function TextInput({
         aria-label={ariaLabel}
         className="estimate-cell-input"
         disabled={disabled}
+        list={list}
         maxLength={maxLength}
         onChange={(event) => onChange(event.target.value)}
         placeholder={placeholder}
@@ -189,22 +203,14 @@ function EstimateRowLine({
         <TextInput
           ariaLabel={`Versorgung (${rowLabel})`}
           disabled={disabled}
+          list={SUPPLY_LIST_ID}
           maxLength={estimateTextLimits.supply}
           onChange={(supply) => patch({ supply })}
           placeholder="ELT"
           value={row.supply}
         />
       </td>
-      <td>
-        <TextInput
-          ariaLabel={`Stromkreis-Nr. (${rowLabel})`}
-          disabled={disabled}
-          maxLength={estimateTextLimits.circuitRef}
-          onChange={(circuitRef) => patch({ circuitRef })}
-          value={row.circuitRef}
-        />
-      </td>
-      <td>
+      <td className="estimate-name-cell">
         <TextInput
           ariaLabel={`Verbraucher / Fläche (${rowLabel})`}
           disabled={disabled}
@@ -384,11 +390,15 @@ export function EstimateBalanceSheet({
 
   return (
     <div className="estimate-sheet-wrap">
+      <datalist id={SUPPLY_LIST_ID}>
+        {supplyOptions(balance).map((supply) => (
+          <option key={supply} value={supply} />
+        ))}
+      </datalist>
       <table className="estimate-sheet">
         <colgroup>
           <col className="estimate-col-kg" />
           <col className="estimate-col-supply" />
-          <col className="estimate-col-circuit" />
           <col className="estimate-col-name" />
           <col className="estimate-col-quantity" />
           <col className="estimate-col-unit" />
@@ -409,9 +419,8 @@ export function EstimateBalanceSheet({
             <th rowSpan={2}>KG</th>
             <th rowSpan={2}>
               Versorgung
-              <span className="estimate-th-hint">ELT/ISP …</span>
+              <span className="estimate-th-hint">ELT/MSR …</span>
             </th>
-            <th rowSpan={2}>Stromkreis-Nr.</th>
             <th rowSpan={2}>Verbraucher / Flächen</th>
             <th colSpan={2}>
               Anzahl / Fläche
diff --git a/src/shared/estimate-balance/estimate-balance.ts b/src/shared/estimate-balance/estimate-balance.ts
index 1a7b5a5..63d3753 100644
--- a/src/shared/estimate-balance/estimate-balance.ts
+++ b/src/shared/estimate-balance/estimate-balance.ts
@@ -12,10 +12,8 @@ export type EstimateRowConnection = "fixed" | "socket";
 export interface EstimateRowSnapshot {
   id: string;
   sortOrder: number;
-  /** Versorgung, e.g. "ELT" or "ISP". */
+  /** Versorgung, e.g. "ELT" or "MSR" (free text). */
   supply: string | null;
-  /** Optional circuit reference, free text. */
-  circuitRef: string | null;
   /** Verbraucher / Fläche. May be empty while a row is being typed. */
   name: string;
   /** Anzahl (unit "piece") or area in m² (unit "area"). */
diff --git a/tests/estimate-balance-frontend.test.ts b/tests/estimate-balance-frontend.test.ts
index fa9368d..ed5f4c7 100644
--- a/tests/estimate-balance-frontend.test.ts
+++ b/tests/estimate-balance-frontend.test.ts
@@ -165,7 +165,6 @@ describe("estimate balance document editing", () => {
       id: "row-x",
       sortOrder: 3,
       supply: null,
-      circuitRef: null,
       name: "",
       quantity: 1,
       unit: "piece",
@@ -273,7 +272,6 @@ describe("estimate balance saving", () => {
     balance = updateEstimateRow(balance, "group-410", "row-a", {
       name: " Hebeanlage ",
       supply: " ELT ",
-      circuitRef: "",
       remark: "   ",
     });
     const saveable = toSaveableEstimateBalance(balance);
@@ -286,10 +284,9 @@ describe("estimate balance saving", () => {
       {
         name: saveable.groups[0]!.rows[0]!.name,
         supply: saveable.groups[0]!.rows[0]!.supply,
-        circuitRef: saveable.groups[0]!.rows[0]!.circuitRef,
         remark: saveable.groups[0]!.rows[0]!.remark,
       },
-      { name: "Hebeanlage", supply: "ELT", circuitRef: null, remark: null }
+      { name: "Hebeanlage", supply: "ELT", remark: null }
     );
   });
 
diff --git a/tests/estimate-balance.test.ts b/tests/estimate-balance.test.ts
index 7d294da..1463fe4 100644
--- a/tests/estimate-balance.test.ts
+++ b/tests/estimate-balance.test.ts
@@ -52,7 +52,6 @@ function row(
     id: id(),
     sortOrder: 0,
     supply: "ELT",
-    circuitRef: null,
     name,
     quantity,
     unit: "piece",

From b7811085a30a9f9e08143cd4d15bc18a8cf04b4a Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 18:04:54 +0200
Subject: [PATCH 24/60] Keep print margins white in dark mode

The dark theme sets color-scheme: dark on the root element; Chrome then
paints the page margins of printed pages dark, even with a white
background. The print view forces the light scheme and a white root
background while printing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/frontend/print/print-document.css | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/frontend/print/print-document.css b/src/frontend/print/print-document.css
index 9fa3b79..e814293 100644
--- a/src/frontend/print/print-document.css
+++ b/src/frontend/print/print-document.css
@@ -450,6 +450,11 @@ span.pd-tb-logo-image {
   .print-view {
     background: #fff !important;
   }
+  /* The dark theme sets color-scheme: dark on the root; Chrome then paints
+     the page margins dark. Printing always uses the light scheme. */
+  html:has(.print-view) {
+    color-scheme: light !important;
+  }
   .pd-toolbar,
   .pd-sheet-footer {
     display: none !important;

From 7b2419b347470807a6a5a9a6bc395fe9ba51009b Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Sat, 26 Sep 2026 18:00:57 +0200
Subject: [PATCH 25/60] Polish the printed rough power balance

The printed page kept the dark app background in the page margins, the
consumer column wrapped while the empty remark column took the space, an
empty "bearbeitet von" label was printed, and numbers were printed as
typed (11200). Print margins are white now, the consumer column is wider,
empty editors are omitted and numbers print with thousands separators
(11.200) like the template.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/app/globals.css                           | 28 ++++++++++++++++++-
 .../estimate-balance-sheet.tsx                | 10 ++++++-
 .../estimate-balance/estimate-draft-input.tsx |  7 ++++-
 3 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/src/app/globals.css b/src/app/globals.css
index 4f0bcb7..dbf49fb 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -2018,10 +2018,36 @@ button.structure-entry-main:focus-visible {
     display: none !important;
   }
 
-  body:has(.estimate-print-root) {
+  html:has(.estimate-print-root),
+  body:has(.estimate-print-root),
+  body:has(.estimate-print-root) .app-shell,
+  body:has(.estimate-print-root) .app-shell-content {
     background: #fff !important;
   }
 
+  /* Der Dunkelmodus setzt color-scheme: dark; Chrome färbt damit auch den
+     Seitenrand dunkel. Im Druck gilt immer das helle Schema. */
+  html:has(.estimate-print-root) {
+    color-scheme: light !important;
+  }
+
+  .estimate-print-root .estimate-group-editor.is-empty {
+    display: none;
+  }
+
+  /* Verbraucher bekommt den Platz; Anmerkungen bleiben schmal. */
+  .estimate-sheet .estimate-col-name {
+    width: 52mm;
+  }
+
+  .estimate-sheet .estimate-col-remark {
+    width: 24mm;
+  }
+
+  .estimate-sheet .estimate-col-supply {
+    width: 13mm;
+  }
+
   body:has(.estimate-print-root) .app-shell {
     display: block;
   }
diff --git a/src/frontend/estimate-balance/estimate-balance-sheet.tsx b/src/frontend/estimate-balance/estimate-balance-sheet.tsx
index 4703397..07dc19c 100644
--- a/src/frontend/estimate-balance/estimate-balance-sheet.tsx
+++ b/src/frontend/estimate-balance/estimate-balance-sheet.tsx
@@ -31,6 +31,7 @@ import {
   formatKw,
   parseGermanDecimal,
   type DecimalRange,
+  formatGermanNumber,
 } from "./estimate-balance-format";
 import { DraftInput } from "./estimate-draft-input";
 
@@ -81,6 +82,7 @@ function NumberInput({
       disabled={disabled}
       format={(current: number) => formatDecimalInput(current)}
       inputMode="decimal"
+      printFormat={(current: number) => formatGermanNumber(current, 0, 3)}
       onCommit={onCommit}
       onValidityChange={(isValid) => onValidityChange(fieldKey, isValid)}
       parse={(text) => parseGermanDecimal(text, range)}
@@ -461,7 +463,13 @@ export function EstimateBalanceSheet({
                 <td colSpan={COLUMN_COUNT - 2}>
                   <div className="estimate-group-title">
                     <span className="estimate-group-name">{group.title}</span>
-                    <label className="estimate-group-editor">
+                    <label
+                      className={
+                        group.editor?.trim()
+                          ? "estimate-group-editor"
+                          : "estimate-group-editor is-empty"
+                      }
+                    >
                       <span>bearbeitet von</span>
                       <input
                         aria-label={`Bearbeitet von (${label})`}
diff --git a/src/frontend/estimate-balance/estimate-draft-input.tsx b/src/frontend/estimate-balance/estimate-draft-input.tsx
index 805b264..904fa2e 100644
--- a/src/frontend/estimate-balance/estimate-draft-input.tsx
+++ b/src/frontend/estimate-balance/estimate-draft-input.tsx
@@ -9,6 +9,8 @@ interface DraftInputProps<T> {
   className?: string;
   disabled?: boolean;
   format: (value: T) => string;
+  /** Printed text; defaults to the input text. */
+  printFormat?: (value: T) => string;
   inputMode?: "decimal" | "text";
   maxLength?: number;
   onCommit: (value: T) => void;
@@ -30,6 +32,7 @@ export function DraftInput<T>({
   className = "estimate-cell-input",
   disabled,
   format,
+  printFormat,
   inputMode = "text",
   maxLength,
   onCommit,
@@ -101,7 +104,9 @@ export function DraftInput<T>({
         type="text"
         value={text}
       />
-      <span className="estimate-print-value">{error ? format(value) : text}</span>
+      <span className="estimate-print-value">
+        {printFormat ? printFormat(value) : error ? format(value) : text}
+      </span>
     </>
   );
 }

From 0a17da2b8e5e24833a32631c5a610bceb1b5fe9d Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sat, 26 Sep 2026 21:02:48 +0200
Subject: [PATCH 26/60] Align runtime and editor documentation with current
 implementation

---
 README.md                                | 13 +++++++++----
 docs/circuit-list-editor-interactions.md |  5 +++++
 docs/current-architecture.md             | 15 ++++++++++++---
 docs/deployment.md                       | 21 +++++++++++++++------
 docs/development-workflow.md             |  8 +++++++-
 5 files changed, 48 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index 58f1832..55c4f65 100644
--- a/README.md
+++ b/README.md
@@ -4,10 +4,12 @@ Leistungsbilanz ist eine Webanwendung für die elektrische Ausführungsplanung.
 Mittelpunkt steht ein tabellenähnlicher Stromkreislisten-Editor, der Stromkreise,
 Gerätezeilen und wiederverwendbare Projektgeräte fachlich getrennt behandelt.
 
-Das Projekt befindet sich in aktiver Entwicklung. Der lokale Entwicklungsbetrieb
-mit SQLite und Docker Compose ist unterstützt. Ein Produktionsdeployment,
-Mehrbenutzerbetrieb und der Revit-/IFCGUID-Datenaustausch sind noch nicht
-implementiert.
+Das Projekt befindet sich in aktiver Entwicklung. Für SQLite stehen ein
+Docker-Server-Stack mit gebautem Anwendungscode und ein separater
+Entwicklungsstack bereit. Ein vollständig unterstütztes Produktionsdeployment
+und Mehrbenutzerbetrieb fehlen weiterhin. Revit-CSV-Konfiguration, Vorschau
+und bestätigter Erstimport sind implementiert; die Editoroberfläche zur
+Objektzuordnung, Folgeimporte und Rückexport stehen noch aus.
 
 ## Unterstützter Arbeitsablauf
 
@@ -25,6 +27,9 @@ implementiert.
 - Änderungen projektweit und auch nach einem Reload rückgängig machen und wiederholen
 - benannte Sicherungspunkte anlegen, wiederherstellen und Revisionen einsehen
 - automatische Sicherungspunkte mit begrenzter Aufbewahrung nutzen
+- Revit-CSV-Dateien konfigurieren, prüfen und nach expliziter Zuordnung von
+  Räumen, Verteilungen und Projektgeräten erstmals importieren; dabei entstehen
+  noch keine Stromkreise oder Gerätezeilen
 
 ## Technik
 
diff --git a/docs/circuit-list-editor-interactions.md b/docs/circuit-list-editor-interactions.md
index c8c02aa..01ca537 100644
--- a/docs/circuit-list-editor-interactions.md
+++ b/docs/circuit-list-editor-interactions.md
@@ -161,6 +161,11 @@ across multiple sections is atomic and occupies one history step. Explicit
 renumbering uses a collision-safe persistent project command and one
 project-history step.
 
+The editor creates client-side UUIDs through `createClientId` in
+`src/frontend/utils/client-id.ts`. It uses `crypto.randomUUID()` when available
+and otherwise generates a UUID v4 with `crypto.getRandomValues()`, so insertion
+also works over plain HTTP from another machine in the LAN.
+
 Covered operations include:
 
 - insert/delete circuit
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 92efc98..b9ffba2 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -27,9 +27,18 @@ Next.js App Router ── /api/* Rewrite ──▶ Express API :3000
                               data/leistungsbilanz.db (SQLite)
 ```
 
-Im Docker-Entwicklungssetup laufen Frontend und API in getrennten Containern. Das
-Frontend leitet `/api/*` über `API_INTERNAL_URL` an die API weiter. Die Datenbank
-liegt über einen Host-Mount außerhalb des Containers.
+In beiden Docker-Stacks laufen Frontend und API in getrennten Containern.
+`compose.yaml` startet den gebauten Stand, `compose.dev.yaml` die Entwicklung
+mit Hot Reload. Das Frontend leitet `/api/*` über `API_INTERNAL_URL` an die API
+weiter; beim gebauten Stand wird das Ziel zur Build-Zeit festgelegt. Die
+Datenbank liegt über einen Host-Mount außerhalb des Containers.
+
+Neue IDs für Stromkreise, Gerätezeilen, Gruppen und Verteilerkomponenten erzeugt
+der Editor über `src/frontend/utils/client-id.ts` (`createClientId`). Die
+Hilfsfunktion nutzt `crypto.randomUUID()`, sofern verfügbar, andernfalls
+`crypto.getRandomValues()` mit UUID-v4-Format. Damit funktioniert das Anlegen
+auch beim HTTP-Zugriff im LAN ohne sicheren Browserkontext. Die IDs entstehen
+vor dem Command und bleiben über Undo/Redo unverändert.
 
 ## Wichtige Einstiegspunkte
 
diff --git a/docs/deployment.md b/docs/deployment.md
index 909c2c0..0b5baba 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -16,9 +16,10 @@ und macOS keine inotify-Events durchreichen; das kostet dauerhaft CPU, auch
 ohne Benutzeraktivität. Dieser Stack gehört deshalb nur auf einen
 Entwicklungsrechner.
 
-Beides enthält weder TLS, Authentifizierung, Reverse Proxy, Prozesshärtung noch
-ein zentral betriebenes Datenbanksystem. Der Stack darf deshalb nicht öffentlich
-erreichbar gemacht werden.
+Beide Stacks enthalten weder TLS, Authentifizierung, einen vorgeschalteten
+Reverse Proxy noch ein zentral betriebenes Datenbanksystem. Die oben genannten
+Container-Schutzmaßnahmen ersetzen diese Funktionen nicht. Der Stack darf
+deshalb nicht öffentlich erreichbar gemacht werden.
 
 ## Topologie
 
@@ -34,6 +35,11 @@ erreicht, kann jedes Projekt lesen und ändern. Erreichbar ist sie nur aus dem
 Compose-Netz, praktisch also über den Next.js-Rewrite. Im Entwicklungs-Stack
 hängen beide Ports am Loopback und sind nicht aus dem LAN erreichbar.
 
+Beim HTTP-Zugriff auf den Server-Stack aus dem LAN erzeugt der Editor neue
+UUIDs über `createClientId`, mit `crypto.getRandomValues()` als Ersatz für das
+dort nicht verfügbare `crypto.randomUUID()`. HTTPS ist für diese
+ID-Erzeugung nicht erforderlich.
+
 ### Speichergrenzen
 
 Jeder Dienst hat ein `mem_limit`. Im Server-Stack ist zusätzlich
@@ -140,14 +146,17 @@ Vor einer produktiven Installation werden mindestens benötigt:
 - Entscheidung, ob SQLite für einen einzelnen Prozess genügt oder PostgreSQL für
   Mehrbenutzerbetrieb erforderlich ist
 
-Bis diese Punkte umgesetzt und getestet sind, besteht die „Installation“ aus dem
-lokalen Entwicklungsstart in der README.
+Der in der README beschriebene Server-Stack ermöglicht bereits den Betrieb des
+gebauten Stands in einer geschützten Umgebung. Ein vollständig unterstütztes
+Produktionssetup bleibt bis zur Umsetzung und Prüfung dieser Punkte offen.
 
 ## Backup und Wiederherstellung
 
 `npm run db:backup` erzeugt unter `data/backups/` ein konsistentes SQLite-Backup,
 öffnet es unabhängig und prüft Integrität sowie Fremdschlüssel. Diese
-Dateisicherungen sind von zukünftigen logischen Projektversionen getrennt.
+Dateisicherungen sind von den bereits vorhandenen benannten und automatischen
+logischen Projektsicherungen getrennt. Projektsicherungen werden über die
+Projektseite wiederhergestellt und unterstützen persistentes Undo/Redo.
 
 Eine produktive Restore-Anweisung wird erst zusammen mit einem unterstützten
 Produktionsbetrieb veröffentlicht. Lokale Wiederherstellung darf nur bei
diff --git a/docs/development-workflow.md b/docs/development-workflow.md
index b19b7ff..f630063 100644
--- a/docs/development-workflow.md
+++ b/docs/development-workflow.md
@@ -13,6 +13,11 @@ Ein sauberer Clone enthält keine SQLite-Datenbank. Beim ersten Start werden
 `data/leistungsbilanz.db`, alle Tabellen und Migrationseinträge automatisch
 angelegt. Das Frontend ist unter <http://localhost:3001> erreichbar.
 
+Dieser Standard-Stack verwendet gebauten Anwendungscode. Für die Entwicklung
+mit Quellcode-Mounts und Hot Reload stattdessen
+`docker compose -f compose.dev.yaml up --build --detach` verwenden; die Dienste
+sind dabei nur über die Loopback-Ports des Entwicklungsrechners erreichbar.
+
 Für direkte Node.js-Entwicklung:
 
 ```powershell
@@ -86,7 +91,8 @@ Bei Docker- oder Laufzeitänderungen zusätzlich:
 ```powershell
 docker compose up --build --detach
 docker compose ps
-Invoke-WebRequest http://localhost:3000/health
+Invoke-WebRequest http://localhost:3001/health
+Invoke-WebRequest http://localhost:3001/web-health
 ```
 
 Bei sichtbaren Editoränderungen ist außerdem ein kurzer GUI-Test erforderlich.

From 92da72bf1453251707ac494468b986d2bc450db8 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 10:50:23 +0200
Subject: [PATCH 27/60] Archive the Revit Dynamo integration concept

Keep the earlier Dynamo/API considerations as historical reference only.
Further Revit exchange will use CSV via the Linear plugin.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/README.md                                |    3 +
 ...amo-leistungsbilanz-integration-konzept.md | 1152 +++++++++++++++++
 2 files changed, 1155 insertions(+)
 create mode 100644 docs/archive/revit-dynamo-leistungsbilanz-integration-konzept.md

diff --git a/docs/README.md b/docs/README.md
index cdddb67..c7a3d88 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -52,3 +52,6 @@ Limitierungen und Roadmap.
 
 - [Frühe Codex-Promptvorlagen](archive/initial-codex-prompts.md) – historischer
   Arbeitsstand, keine aktuelle Implementierungsanweisung
+- [Revit-/Dynamo-Anbindung](archive/revit-dynamo-leistungsbilanz-integration-konzept.md) –
+  nicht weiterverfolgte Vorüberlegung zur direkten Dynamo-/API-Anbindung;
+  Diagnoseskripte über den Git-Tag `archive/dynamo-vorueberlegungen`
diff --git a/docs/archive/revit-dynamo-leistungsbilanz-integration-konzept.md b/docs/archive/revit-dynamo-leistungsbilanz-integration-konzept.md
new file mode 100644
index 0000000..aa0ae97
--- /dev/null
+++ b/docs/archive/revit-dynamo-leistungsbilanz-integration-konzept.md
@@ -0,0 +1,1152 @@
+# Revit-/Dynamo-Anbindung an die Leistungsbilanz
+
+> **Archiviert (September 2026), keine aktuelle Implementierungsanweisung.**
+> Die direkte Revit-Anbindung über Dynamo/Python, Revit-API und JSON wird nicht
+> weiterverfolgt. Die weitere Revit-Arbeit ist zurückgestellt und erfolgt, wenn
+> sie wieder aufgenommen wird, über den CSV-Export/-Import des Linear-Plugins
+> in Revit. Siehe
+> [Revit-CSV-Anforderungen](../spec/revit-csv-integration-requirements.md).
+> Die zugehörigen Dynamo-Diagnoseskripte sind über den Git-Tag
+> `archive/dynamo-vorueberlegungen` erreichbar.
+
+## Zweck dieses Dokuments
+
+Dieses Dokument beschreibt den aktuellen Stand und die gewünschte Zielrichtung für die Anbindung von Revit an die Leistungsbilanz-App.
+
+Es soll als Arbeitsgrundlage für Codex dienen. Codex soll **zuerst die bestehende Architektur des Repositories analysieren** und danach konkrete Vorschläge für:
+
+1. die API-Struktur der Leistungsbilanz,
+2. das Austauschformat zwischen Revit und Leistungsbilanz,
+3. die benötigten Dynamo-/Python-Skripte,
+4. die Synchronisationslogik Revit → Leistungsbilanz,
+5. die spätere Rückrichtung Leistungsbilanz → Revit
+
+erarbeiten.
+
+Die nachfolgend genannten Klassennamen, Endpoints und DTOs sind **Vorschläge und keine zwingenden Vorgaben**. Sie sollen an die tatsächlich vorhandene Architektur angepasst werden.
+
+---
+
+# 1. Ausgangssituation
+
+Die Leistungsbilanz-App soll Daten aus Revit übernehmen können.
+
+Ursprünglich war dafür ein CSV-basierter Import vorgesehen, weil Revit-Bauteillisten nativ als CSV exportiert werden können.
+
+Inzwischen ist klar, dass Dynamo mit Python genutzt werden kann und damit ein direkter Zugriff auf die Revit API möglich ist.
+
+Dadurch ist eine wesentlich sauberere direkte Integration möglich.
+
+Die CSV-Schnittstelle soll deshalb **nicht zwingend entfallen**, aber künftig eher als:
+
+- manueller Importweg,
+- Fallback,
+- allgemeine Austauschmöglichkeit,
+- Debug-/Testformat
+
+verstanden werden.
+
+Die primäre Revit-Integration soll perspektivisch über eine **versionierte API mit JSON als Austauschformat** erfolgen.
+
+---
+
+# 2. Aktueller Dynamo-Stand
+
+Ein erster Dynamo-Python-Test funktioniert bereits.
+
+Aktuell werden über die Revit API alle Exemplare der Kategorie:
+
+```text
+BuiltInCategory.OST_ElectricalFixtures
+```
+
+also Revit **Elektroinstallationen / Electrical Fixtures** gesammelt.
+
+Für den aktuellen Entwicklungsstand soll bewusst zunächst **nur diese Kategorie** betrachtet werden.
+
+Andere Kategorien können später ergänzt werden.
+
+---
+
+# 3. Bereits erfolgreich aus Revit gelesene Daten
+
+Der aktuelle Python-Ansatz kann bereits folgende Daten ausgeben:
+
+```text
+ElementId
+UniqueId
+Familie
+Typ
+MEP_Raumnummer
+MEP_Raumname
+IFC_GUID
+```
+
+Die Zuordnung zum MEP-Raum erfolgt über den zum FamilyInstance gehörenden MEP Space.
+
+Der aktuelle Test zeigt, dass das grundsätzliche Auslesen über Dynamo/Python funktioniert.
+
+---
+
+# 4. Relevante Identitäten
+
+Für die Kopplung zwischen Revit und Leistungsbilanz sollen mehrere Identifikatoren berücksichtigt werden.
+
+## 4.1 Revit UniqueId
+
+Die `UniqueId` soll die primäre Revit-seitige Elementidentität darstellen.
+
+Sie sollte für die dauerhafte Zuordnung eines Revit-Elements verwendet werden.
+
+Beispiel:
+
+```text
+revitUniqueId = "0a52cc55-..."
+```
+
+---
+
+## 4.2 ElementId
+
+Die Revit `ElementId` soll ebenfalls übertragen werden.
+
+Sie ist nützlich für:
+
+- Debugging,
+- Fehlersuche,
+- Anzeige für den Anwender,
+- direkte Suche eines Elements in Revit.
+
+Sie soll aber **nicht als alleiniger persistenter Schlüssel** zwischen den Systemen verwendet werden.
+
+---
+
+## 4.3 IFC GUID
+
+Die IFC GUID soll ebenfalls mitgeführt werden, sofern sie im Revit-Modell vorhanden ist.
+
+Damit entsteht perspektivisch eine Verbindung:
+
+```text
+Revit
+  ↕ UniqueId
+Leistungsbilanz
+  ↕ IFC GUID
+IFC
+```
+
+Die IFC GUID ist damit insbesondere für spätere IFC-basierte Integrationen relevant.
+
+---
+
+# 5. Zusätzlich benötigte Modellidentität
+
+Die `UniqueId` identifiziert ein Element innerhalb eines Revit-Modells.
+
+Deshalb benötigt die Leistungsbilanz zusätzlich eine stabile Identität des Revit-Modells.
+
+Vorgeschlagener Schlüssel:
+
+```text
+revitModelId
+```
+
+Beispiel:
+
+```text
+550e8400-e29b-41d4-a716-446655440000
+```
+
+Diese ID darf nicht ausschließlich aus folgenden Informationen erzeugt werden:
+
+```text
+Dateiname
+Dateipfad
+lokaler Speicherort
+```
+
+da sich diese ändern können.
+
+Mögliche Speicherorte in Revit:
+
+### Variante A – Projektparameter
+
+Zum Beispiel:
+
+```text
+LB_ProjectId
+LB_ModelId
+```
+
+Vorteile:
+
+- einfach umzusetzen,
+- sichtbar,
+- leicht zu debuggen,
+- direkt über Dynamo lesbar.
+
+### Variante B – Revit Extensible Storage
+
+Langfristig eleganter, weil integrationsspezifische Metadaten unsichtbar im Modell gespeichert werden können.
+
+Beispielsweise:
+
+```text
+LeistungsbilanzConnector
+{
+    modelId
+    projectId
+    lastSync
+}
+```
+
+Für einen ersten Prototyp ist ein Projektparameter wahrscheinlich ausreichend.
+
+---
+
+# 6. Grundprinzip der Zielarchitektur
+
+Die Revit-Schnittstelle soll nicht direkt an interne Datenbanktabellen gekoppelt werden.
+
+Empfohlen wird:
+
+```text
+┌──────────────────────────── REVIT ────────────────────────────┐
+│                                                               │
+│  Revit API                                                    │
+│      ↓                                                        │
+│  Dynamo + Python                                              │
+│      ↓                                                        │
+│  Revit-Adapter                                                │
+│      ↓                                                        │
+│  definiertes Austauschmodell                                 │
+│      ↓                                                        │
+│  JSON                                                         │
+│                                                               │
+└───────────────────────┬───────────────────────────────────────┘
+                        │
+                        │ HTTP / REST
+                        ▼
+┌──────────────────── LEISTUNGSBILANZ ──────────────────────────┐
+│                                                               │
+│  Revit Integration API                                        │
+│      ↓                                                        │
+│  Import-/Sync-Service                                         │
+│      ↓                                                        │
+│  persistierte Revit-Referenz                                  │
+│      ↓                                                        │
+│  Zuordnung zu DeviceRow / Circuit / bestehendem Datenmodell   │
+│                                                               │
+└───────────────────────────────────────────────────────────────┘
+```
+
+Wichtig:
+
+> JSON ist das Austauschformat. HTTP ist nur der Transportweg.
+
+Dasselbe Datenmodell soll deshalb bei Bedarf auch als JSON-Datei gespeichert und eingelesen werden können.
+
+---
+
+# 7. Austauschmodell / DTO
+
+Es soll ein klar definiertes und versioniertes Austauschformat geben.
+
+Beispiel:
+
+```json
+{
+  "schemaVersion": 1,
+  "source": "revit",
+  "model": {
+    "id": "550e8400-e29b-41d4-a716-446655440000",
+    "name": "26009_F60_ELT"
+  },
+  "elements": [
+    {
+      "uniqueId": "f4d3c...",
+      "elementId": 471123,
+      "ifcGuid": "2X9...",
+      "category": "Electrical Fixtures",
+      "family": "Steckdose JUNG LS990",
+      "type": "Schuko 1-fach",
+      "space": {
+        "number": "1.03",
+        "name": "Schlafen"
+      },
+      "parameters": {
+        "power": 250,
+        "cosPhi": 0.95
+      }
+    }
+  ]
+}
+```
+
+Das tatsächliche Schema soll durch Codex anhand des bestehenden Datenmodells der Leistungsbilanz konkretisiert werden.
+
+---
+
+# 8. Trennung zwischen Revit-Objekt und Leistungsbilanz-Objekt
+
+Ein Revit-Element soll **nicht direkt mit einer DeviceRow gleichgesetzt werden**.
+
+Das ist wichtig, weil:
+
+- Revit den geplanten Modellstand enthält,
+- Nutzer Werte in der Leistungsbilanz überschreiben können,
+- ein importiertes Revit-Element erst vom Nutzer einem bestehenden oder neuen Stromkreis bzw. einer DeviceRow zugeordnet werden kann,
+- ein erneuter Sync keine bewussten Benutzeränderungen überschreiben darf.
+
+Konzeptionell sollte deshalb eine separate Revit-Referenz existieren.
+
+Beispiel:
+
+```text
+RevitElement
+    │
+    │ verknüpft mit
+    ▼
+LinkedDevice / Zuordnung
+    │
+    ▼
+DeviceRow
+    │
+    ▼
+Circuit
+```
+
+Die tatsächliche Umsetzung muss Codex mit der vorhandenen Architektur abgleichen.
+
+Mögliche Eigenschaften einer persistierten Revit-Referenz:
+
+```text
+id
+revitModelId
+revitUniqueId
+revitElementId
+ifcGuid
+
+category
+family
+type
+
+spaceNumber
+spaceName
+
+rawData
+lastSeenAt
+lastSyncAt
+```
+
+Die Bezeichnung `RevitElement` ist nur ein Vorschlag.
+
+Wenn es im aktuellen Datenmodell bereits eine passende Entität gibt, soll diese verwendet oder erweitert werden.
+
+---
+
+# 9. Revit → Leistungsbilanz
+
+Der erste zu implementierende Sync soll in diese Richtung erfolgen.
+
+```text
+Revit
+  ↓
+Dynamo
+  ↓
+Python / Revit API
+  ↓
+JSON Payload
+  ↓
+HTTP POST
+  ↓
+Leistungsbilanz API
+  ↓
+Sync-Service
+```
+
+## Vorgeschlagenes Verhalten
+
+Der Benutzer startet in Dynamo bewusst einen Export bzw. Sync.
+
+Das Python-Skript:
+
+1. liest alle relevanten `OST_ElectricalFixtures`,
+2. liest die definierten Revit-Daten,
+3. erzeugt das versionierte JSON,
+4. sendet es an die Leistungsbilanz,
+5. wertet die HTTP-Antwort aus,
+6. zeigt dem Benutzer das Ergebnis in Dynamo an.
+
+---
+
+# 10. Snapshot-Sync statt Delta-Sync
+
+Für den ersten Stand soll **kein komplexer Delta-Sync** gebaut werden.
+
+Stattdessen soll Revit bei jedem Sync einen vollständigen Snapshot aller aktuell relevanten Elektroinstallationen liefern.
+
+Beispiel:
+
+```text
+vorher                   aktueller Snapshot
+------------------------------------------------
+Element A vorhanden      Element A vorhanden
+Element B vorhanden      Element B vorhanden
+Element C vorhanden      Element C fehlt
+                         Element D neu
+```
+
+Die Leistungsbilanz kann daraus ableiten:
+
+```text
+A → unchanged oder updated
+B → unchanged oder updated
+C → missing / deleted / not seen
+D → created
+```
+
+Das ist für zunächst einige hundert oder tausend Elemente ausreichend und deutlich robuster.
+
+---
+
+# 11. Upsert-Verhalten
+
+Auf Leistungsbilanzseite soll ein Revit-Element anhand eines stabilen Schlüssels identifiziert werden.
+
+Vorgeschlagen:
+
+```text
+(revitModelId, revitUniqueId)
+```
+
+Beim Empfang eines Snapshots:
+
+```text
+Element bereits vorhanden?
+        │
+        ├─ Nein
+        │    ↓
+        │  Create
+        │
+        └─ Ja
+             ↓
+           Update
+```
+
+Die Revit-Referenz soll dabei aktualisiert werden.
+
+Benutzerseitig überschriebene Werte einer DeviceRow dürfen dadurch jedoch nicht ungeprüft überschrieben werden.
+
+---
+
+# 12. Mögliche API-Struktur
+
+Nicht zwingend exakt so umsetzen.
+
+Codex soll prüfen, wie die aktuelle API strukturiert ist.
+
+Mögliche Endpoints:
+
+```http
+POST /api/integrations/revit/v1/models/{modelId}/sync
+```
+
+Alternativ logisch getrennt:
+
+```http
+POST /api/integrations/revit/v1/models/{modelId}/elements
+GET  /api/integrations/revit/v1/models/{modelId}/writeback
+```
+
+Beispielantwort auf einen Revit-Sync:
+
+```json
+{
+  "syncId": "sync-9384",
+  "received": 483,
+  "created": 17,
+  "updated": 45,
+  "unchanged": 421,
+  "missing": 3
+}
+```
+
+Die konkrete Antwortstruktur soll so gewählt werden, dass Dynamo dem Nutzer eine verständliche Zusammenfassung anzeigen kann.
+
+---
+
+# 13. Leistungsbilanz → Revit
+
+Die Rückrichtung soll später ebenfalls unterstützt werden.
+
+Sie soll jedoch zunächst **logisch vom Revit-Import getrennt** werden.
+
+Also:
+
+```text
+PUSH
+
+Revit
+  ↓
+Leistungsbilanz
+```
+
+und:
+
+```text
+PULL / WRITEBACK
+
+Leistungsbilanz
+  ↓
+Revit
+```
+
+Der Benutzer soll bewusst entscheiden können, wann Daten nach Revit zurückgeschrieben werden.
+
+Zum Beispiel:
+
+```text
+[ Revit-Daten importieren ]
+
+[ Änderungen nach Revit schreiben ]
+```
+
+---
+
+# 14. Writeback nicht generisch ausführen
+
+Die Leistungsbilanz soll nicht beliebige Parameter-Namen an Revit schicken, die Dynamo anschließend blind beschreibt.
+
+Stattdessen soll es ein definiertes Writeback-Schema geben.
+
+Beispiel:
+
+```json
+{
+  "updates": [
+    {
+      "uniqueId": "abcdef...",
+      "values": {
+        "circuitNumber": "UV01-2F17",
+        "panel": "UV01",
+        "connectedLoad": 250
+      }
+    }
+  ]
+}
+```
+
+Der Revit-Adapter besitzt anschließend eine feste Allowlist bzw. ein Mapping:
+
+```text
+circuitNumber
+    ↓
+LB_Stromkreisnummer
+
+panel
+    ↓
+LB_Verteiler
+
+connectedLoad
+    ↓
+LB_Anschlussleistung
+```
+
+Damit ist kontrolliert, welche Revit-Parameter durch die Leistungsbilanz beschrieben werden dürfen.
+
+---
+
+# 15. Field Ownership / Datenhoheit
+
+Für bidirektionale Synchronisation muss definiert sein, welches System für welches Feld führend ist.
+
+Beispiel:
+
+| Information | Führendes System |
+|---|---|
+| Revit UniqueId | Revit |
+| Revit ElementId | Revit |
+| IFC GUID | Revit |
+| Familie | Revit |
+| Typ | Revit |
+| MEP Raum | Revit |
+| MEP Raumnummer | Revit |
+| Zuordnung zu DeviceRow | Leistungsbilanz |
+| Zuordnung zu Circuit | Leistungsbilanz |
+| manuell überschriebene Leistung | Leistungsbilanz |
+| Sicherung | Leistungsbilanz |
+| Leitung | Leistungsbilanz |
+| Stromkreisnummer | Leistungsbilanz, ggf. Writeback |
+| Verteilerzuordnung | Leistungsbilanz, ggf. Writeback |
+
+Diese Tabelle muss anhand des bestehenden Datenmodells vervollständigt werden.
+
+Ziel ist, Konflikte wie diesen zu vermeiden:
+
+```text
+Revit:
+Leistung = 500 W
+
+Leistungsbilanz:
+Nutzer überschreibt auf 750 W
+
+nächster Revit-Sync:
+Revit liefert wieder 500 W
+```
+
+Der bewusste Benutzerwert darf nicht kommentarlos verloren gehen.
+
+---
+
+# 16. Rohdaten und normalisierte Daten
+
+Es sollte geprüft werden, ob zusätzlich zu den normalisierten Daten ein Teil des ursprünglichen Revit-Payloads gespeichert werden sollte.
+
+Beispiel:
+
+```text
+rawData / rawPayload
+```
+
+Vorteile:
+
+- Debugging,
+- spätere Erweiterung ohne sofortigen Revit-Neuexport,
+- Nachvollziehbarkeit,
+- Erkennung neuer Parameter.
+
+Dabei soll aber vermieden werden, die eigentliche Business-Logik auf unstrukturiertem JSON aufzubauen.
+
+---
+
+# 17. CSV und JSON-Datei weiterhin unterstützen
+
+Auch bei einer direkten API-Anbindung sollen Datei-basierte Wege sinnvoll bleiben.
+
+Mögliche Architektur:
+
+```text
+                        ┌─────────────────────┐
+                        │ Leistungsbilanz     │
+                        │ RevitSyncService    │
+                        └─────────┬───────────┘
+                                  │
+                    ┌─────────────┴─────────────┐
+                    │                           │
+                  REST                        Datei
+                    │                           │
+                    ▼                           ▼
+             Dynamo Python               JSON / CSV
+                    │
+                    ▼
+                  Revit
+```
+
+Der gleiche interne Import-Service sollte möglichst sowohl:
+
+```text
+HTTP JSON
+```
+
+als auch:
+
+```text
+JSON-Datei
+```
+
+verarbeiten können.
+
+CSV kann als separates allgemeines Importformat bestehen bleiben.
+
+---
+
+# 18. Kein direkter Datenbankzugriff aus Dynamo
+
+Dynamo soll nicht direkt auf SQLite, PostgreSQL oder andere Datenbanken der Leistungsbilanz zugreifen.
+
+Nicht empfohlen:
+
+```text
+Dynamo
+  ↓
+direkte SQL-Verbindung
+  ↓
+DB
+```
+
+Empfohlen:
+
+```text
+Dynamo
+  ↓
+API
+  ↓
+Business Logic
+  ↓
+ORM
+  ↓
+DB
+```
+
+Dadurch bleibt der Revit-Connector unabhängig von:
+
+- Tabellenstruktur,
+- ORM,
+- Migrationen,
+- internen Relationen,
+- späteren Änderungen des Backends.
+
+---
+
+# 19. Zunächst kein WebSocket / Echtzeit-Sync
+
+Für den aktuellen Anwendungsfall ist kein permanenter Echtzeitkanal erforderlich.
+
+Nicht notwendig:
+
+```text
+Leistungsbilanz wird geändert
+        ↓
+sofort automatische Änderung in Revit
+```
+
+Stattdessen soll zunächst mit expliziten Sync-Aktionen gearbeitet werden.
+
+Das ist auch im Hinblick auf Revit sinnvoll, da Änderungen über die Revit API kontrolliert und innerhalb gültiger Revit-Transactions vorgenommen werden müssen.
+
+---
+
+# 20. Fehlerbehandlung
+
+Die Integration muss mit Teilfehlern umgehen können.
+
+Beispiele:
+
+- ein Element besitzt keinen MEP Space,
+- IFC GUID fehlt,
+- ein erwarteter Parameter fehlt,
+- ein Revit-Parameter ist schreibgeschützt,
+- HTTP-Verbindung schlägt fehl,
+- API antwortet mit Validierungsfehler,
+- Element wurde zwischen Abfrage und Writeback gelöscht,
+- Revit-Modell ist noch nicht mit einem Leistungsbilanz-Projekt verknüpft.
+
+Das Dynamo-Skript soll möglichst nicht beim ersten fehlerhaften Element komplett abbrechen.
+
+Stattdessen sollte die Antwort z. B. unterscheiden:
+
+```text
+success
+warnings
+errors
+```
+
+und am Ende eine Zusammenfassung ausgeben.
+
+---
+
+# 21. Authentifizierung
+
+Codex soll prüfen, welche Authentifizierung die aktuelle Leistungsbilanz-App bereits verwendet.
+
+Der Dynamo-Connector soll keine unnötige zweite Authentifizierungsarchitektur einführen.
+
+Mögliche Varianten:
+
+- API Token,
+- projektbezogenes Integration Token,
+- bestehender Login-Mechanismus,
+- kurzfristige Connector-Tokens.
+
+Secrets sollen nicht fest im Dynamo-Python-Code hinterlegt werden.
+
+---
+
+# 22. Versionierung
+
+Das JSON-Schema und die API sollen versioniert sein.
+
+Beispielsweise:
+
+```text
+schemaVersion = 1
+```
+
+und/oder:
+
+```text
+/api/integrations/revit/v1/
+```
+
+Dadurch kann ein älteres Dynamo-Skript später noch mit einer neueren App-Version umgehen oder zumindest kontrolliert abgelehnt werden.
+
+---
+
+# 23. Langfristige Perspektive: Revit Add-in
+
+Dynamo + Python ist für die erste Implementierung ideal, weil schnell getestet und angepasst werden kann.
+
+Langfristig könnte daraus ein echtes Revit-Add-in in C#/.NET werden.
+
+Beispiel:
+
+```text
+Revit Ribbon
+
+┌──────── Leistungsbilanz ─────────┐
+│                                  │
+│  ↑ Daten übertragen              │
+│  ↓ Daten aus Leistungsbilanz     │
+│                                  │
+│  Projekt verbinden               │
+│  Sync-Status                     │
+│                                  │
+└──────────────────────────────────┘
+```
+
+Wichtig ist deshalb, dass die API nicht speziell auf Dynamo zugeschnitten wird.
+
+Ziel:
+
+```text
+heute:
+Dynamo + Python
+       ↓
+gleiche REST API
+
+später:
+Revit Add-in C#
+       ↓
+gleiche REST API
+```
+
+---
+
+# 24. Aktuell gewünschter Dynamo-Umfang
+
+Für den ersten produktiven Revit-Export soll Codex ein Dynamo-Python-Skript vorschlagen, das mindestens folgende Daten aus `OST_ElectricalFixtures` ermittelt:
+
+```text
+revitModelId
+ElementId
+UniqueId
+IFC GUID
+Kategorie
+Familie
+Typ
+MEP Raumnummer
+MEP Raumname
+```
+
+Zusätzlich soll Codex anhand der aktuellen Leistungsbilanz-Datenstruktur prüfen, welche weiteren Felder bereits jetzt sinnvoll mitgegeben werden sollten.
+
+Dazu könnten später gehören:
+
+```text
+Ebene
+BMK
+Leistung
+cosPhi
+Spannung
+Anzahl
+Kommentar
+Stromkreis
+Verteiler
+weitere Shared Parameters
+```
+
+Diese zusätzlichen Felder sollen aber nicht willkürlich eingebaut werden, sondern aus der bestehenden Architektur und den fachlichen Anforderungen der Leistungsbilanz abgeleitet werden.
+
+---
+
+# 25. Anforderungen an das Dynamo-Python-Skript
+
+Das Skript soll möglichst:
+
+- ohne externe Dynamo-Packages funktionieren,
+- nur Revit API / Dynamo-eigene Python-Möglichkeiten verwenden,
+- mit der im Projekt eingesetzten Revit-/Dynamo-Version kompatibel sein,
+- alle Elektroinstallationen im gesamten aktuellen Revit-Dokument lesen,
+- nicht nur die aktive Ansicht betrachten,
+- fehlende optionale Parameter tolerieren,
+- verständliche Fehlermeldungen liefern,
+- eine gut lesbare Statusausgabe an `OUT` zurückgeben,
+- JSON mit UTF-8 erzeugen,
+- HTTP-Requests ohne unnötige externe Python-Abhängigkeiten ausführen,
+- Timeouts behandeln,
+- API-Fehler auswerten,
+- keinen Datenverlust verursachen.
+
+Für spätere Writebacks muss das Skript Revit-Änderungen ausschließlich innerhalb gültiger Revit-Transactions durchführen.
+
+---
+
+# 26. Gewünschter Arbeitsauftrag an Codex
+
+## Schritt 1 – Repository analysieren
+
+Vor Änderungen zuerst:
+
+1. `AGENTS.md` lesen.
+2. Bestehende Architektur-Dokumentation lesen.
+3. Datenmodell der Leistungsbilanz nachvollziehen.
+4. Aktuelle Import-/CSV-Architektur untersuchen.
+5. Vorhandene API-Routen analysieren.
+6. Prüfen, ob bereits Entitäten oder Konzepte für:
+   - externe Modelle,
+   - Revit-Elemente,
+   - Linked Devices,
+   - Sync,
+   - Imports,
+   - Projekt-Historie
+   existieren.
+7. Authentifizierung und Berechtigungssystem prüfen.
+8. Bestehende Tests und Testkonventionen prüfen.
+
+Noch keine größere Implementierung beginnen, bevor diese Analyse abgeschlossen ist.
+
+---
+
+## Schritt 2 – Bestehende Architektur gegen dieses Konzept abgleichen
+
+Codex soll beantworten:
+
+1. Welche vorhandenen Entitäten können wiederverwendet werden?
+2. Brauchen wir überhaupt eine neue `RevitElement`-Entität?
+3. Wie passt die Revit-Referenz in das bestehende `LinkedDevice`-/DeviceRow-Konzept?
+4. Wo sollte das Sync-Verhalten im Backend liegen?
+5. Wie soll die Modellidentität gespeichert werden?
+6. Welche Felder sind Revit-Master?
+7. Welche Felder sind Leistungsbilanz-Master?
+8. Wie werden manuell überschriebene Werte geschützt?
+9. Wie werden nicht mehr vorhandene Revit-Elemente behandelt?
+10. Wie lässt sich das bestehende CSV-System sinnvoll weiterverwenden?
+
+---
+
+## Schritt 3 – Konkreten Zielentwurf erstellen
+
+Codex soll danach einen konkreten Entwurf liefern für:
+
+### Datenmodell
+
+Mit tatsächlichen Namen passend zum Repository.
+
+### API
+
+Mit:
+
+```text
+HTTP Method
+Route
+Request DTO
+Response DTO
+Validierung
+Fehlercodes
+Authentifizierung
+```
+
+### Sync-Service
+
+Mit klarer Verantwortung für:
+
+```text
+Create
+Update
+Unchanged
+Missing
+Deleted
+Linking
+Conflict handling
+```
+
+### Dynamo-Schnittstelle
+
+Mit dem exakten JSON, das Dynamo senden bzw. empfangen soll.
+
+---
+
+## Schritt 4 – Dynamo-Skripte vorschlagen
+
+Erst nachdem die Zielarchitektur feststeht, soll Codex konkrete Dynamo-Python-Skripte erstellen.
+
+Mindestens:
+
+### Script A – Revit → Leistungsbilanz
+
+Funktionen:
+
+```text
+Revit-Modell-ID ermitteln
+Electrical Fixtures sammeln
+Daten auslesen
+Payload erzeugen
+JSON serialisieren
+API aufrufen
+Antwort auswerten
+Status in Dynamo ausgeben
+```
+
+### Script B – Leistungsbilanz → Revit
+
+Noch nicht zwingend sofort implementieren, aber vollständig konzipieren.
+
+Funktionen:
+
+```text
+Writeback-Daten von API abrufen
+Element über UniqueId finden
+Allowlist-Mapping anwenden
+Werte prüfen
+Revit Transaction starten
+Parameter schreiben
+Ergebnis an API melden
+Status ausgeben
+```
+
+### Optional Script C – Debug-/Offline-Export
+
+Export des exakt gleichen Payloads als lokale JSON-Datei.
+
+Damit kann die Schnittstelle auch ohne erreichbare API getestet werden.
+
+---
+
+# 27. Erwartete Ausgabe von Codex
+
+Codex soll nach der Analyse **nicht sofort große Änderungen durchführen**, sondern zuerst eine strukturierte Empfehlung liefern.
+
+Gewünschte Reihenfolge:
+
+```text
+1. Analyse des Ist-Zustands
+2. Abweichungen / bereits vorhandene passende Architektur
+3. Empfohlenes Zieldesign
+4. Datenmodelländerungen
+5. API-Design
+6. Sync-Logik
+7. Exaktes JSON-Schema
+8. Vorschlag Dynamo Script A
+9. Vorschlag Dynamo Script B
+10. Migrations-/Implementierungsreihenfolge
+11. Tests
+12. Offene Entscheidungen
+```
+
+Bei Architekturentscheidungen soll Codex die einfachste robuste Lösung bevorzugen und unnötige neue Abstraktionen vermeiden.
+
+---
+
+# 28. Bevorzugte Implementierungsreihenfolge
+
+Voraussichtlich sinnvoll:
+
+```text
+Phase 1
+────────────────────────────
+Austauschformat / DTO festlegen
+
+Phase 2
+────────────────────────────
+Backend API für Revit-Snapshot
+
+Phase 3
+────────────────────────────
+Persistierung und Upsert-Logik
+
+Phase 4
+────────────────────────────
+Dynamo Revit → API
+
+Phase 5
+────────────────────────────
+UI für importierte / nicht zugeordnete Revit-Elemente
+
+Phase 6
+────────────────────────────
+Zuordnungs- und Override-Verhalten
+
+Phase 7
+────────────────────────────
+Writeback API
+
+Phase 8
+────────────────────────────
+Dynamo API → Revit
+
+Phase 9
+────────────────────────────
+ggf. später Revit C# Add-in
+```
+
+---
+
+# 29. Zentrale Architekturentscheidung
+
+Die wichtigste Vorgabe lautet:
+
+> Dynamo soll als Revit-Adapter dienen. Die eigentliche Fachlogik der Leistungsbilanz bleibt in der Leistungsbilanz-App.
+
+Dynamo soll deshalb nicht entscheiden:
+
+```text
+welche Sicherung gewählt wird
+welche Leitung verwendet wird
+wie Stromkreise aufgebaut werden
+wie Geräte gruppiert werden
+welche Leistungswerte fachlich gültig sind
+```
+
+Dynamo liefert primär Revit-Daten und schreibt später explizit freigegebene Ergebnisse zurück.
+
+Die fachliche Entscheidung bleibt in der Webapp.
+
+---
+
+# 30. Zielbild
+
+```text
+                        REVIT
+                          │
+                    Revit API
+                          │
+                   Dynamo / Python
+                          │
+                     JSON DTO
+                          │
+                    REST / HTTP
+                          │
+                          ▼
+                Leistungsbilanz API
+                          │
+                    Sync Service
+                          │
+              ┌───────────┴───────────┐
+              │                       │
+        Revit-Referenz          Business Logic
+              │                       │
+              └───────────┬───────────┘
+                          │
+                    DeviceRow
+                          │
+                       Circuit
+                          │
+                    Distributor
+```
+
+Später:
+
+```text
+Leistungsbilanz
+       │
+   Writeback
+       │
+       ▼
+Dynamo / Python
+       │
+       ▼
+     Revit
+```
+
+Das Ziel ist keine möglichst komplexe Echtzeitkopplung, sondern eine robuste, nachvollziehbare und versionierbare Integration, die zunächst über Dynamo/Python funktioniert und später bei Bedarf durch ein natives Revit-Add-in ersetzt werden kann.

From b9462e61c5c9ba9e9684f9ce276c3744e6f43767 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 10:51:13 +0200
Subject: [PATCH 28/60] Defer Revit work and remove Dynamo scripts

Further Revit exchange will use the CSV export/import of the Linear
plugin instead of Dynamo, as preferred by the internal Revit/CAD
steering committee. Mark the Revit documentation as deferred and remove
the Dynamo diagnostic scripts, which stay reachable through the tag
archive/dynamo-vorueberlegungen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .gitignore                                    |   1 -
 AGENTS.md                                     |  15 +-
 README.md                                     |   4 +-
 docs/README.md                                |   3 +-
 docs/circuit-list-editor-known-limitations.md |   2 +
 docs/current-architecture.md                  |   4 +
 ...history-and-external-model-architecture.md |   4 +
 docs/revit-requirements-llm-context.md        |   4 +
 docs/spec/07-implementation-phases-todo.md    |   6 +-
 docs/spec/08-current-product-backlog.md       |   3 +-
 .../revit-csv-integration-requirements.md     |  15 +-
 .../spec/revit-csv-phase-14-audit-and-plan.md |   4 +
 dynamo/01_check_model_identity.py             | 385 -------------
 ..._electrical_fixture_parameter_inventory.py | 517 ------------------
 dynamo/README.md                              |  69 ---
 15 files changed, 58 insertions(+), 978 deletions(-)
 delete mode 100644 dynamo/01_check_model_identity.py
 delete mode 100644 dynamo/02_export_electrical_fixture_parameter_inventory.py
 delete mode 100644 dynamo/README.md

diff --git a/.gitignore b/.gitignore
index e0ef1d2..a6e1ff5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,4 +6,3 @@ dist/
 data/*.db
 data/backups/*.db
 .codex/*.log
-dynamo/output/
diff --git a/AGENTS.md b/AGENTS.md
index 704aee9..4298762 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -532,6 +532,18 @@ Required operations:
 
 ## Revit / CSV External Model Work
 
+Status: further Revit work (editor assignment UI, follow-up import, return
+export) is deferred and will be tackled later. When it resumes, the exchange
+stays CSV-based and uses the CSV export/import of the Linear plugin in Revit.
+The internal Revit/CAD steering committee prefers this over manipulating the
+model directly through Dynamo. Do not start Dynamo, Revit API or JSON
+transport work. The Linear CSV layout is not yet known: check a sample export
+against the existing project CSV configuration before changing the parser.
+Earlier Dynamo considerations are archived in
+`docs/archive/revit-dynamo-leistungsbilanz-integration-konzept.md`; the
+removed diagnostic scripts remain reachable through the git tag
+`archive/dynamo-vorueberlegungen`.
+
 When explicitly working on Phase 14, use
 `docs/spec/revit-csv-integration-requirements.md` as the detailed source of
 truth together with the current architecture documents.
@@ -620,7 +632,8 @@ Users must be able to override sizing suggestions.
 
 ## Current Deferred Work
 
-- Revit/CSV/IFCGUID round-trip, except when Phase 14 is explicitly requested and
+- Revit/CSV/IFCGUID round-trip (deferred; later via Linear plugin CSV, never
+  Dynamo), except when Phase 14 is explicitly requested and
   `docs/spec/revit-csv-integration-requirements.md` is being followed
 - full electrical sizing
 - multi-user/PostgreSQL operation
diff --git a/README.md b/README.md
index 2577989..b3c026e 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,9 @@ Docker-Server-Stack mit gebautem Anwendungscode und ein separater
 Entwicklungsstack bereit. Ein vollständig unterstütztes Produktionsdeployment
 und Mehrbenutzerbetrieb fehlen weiterhin. Revit-CSV-Konfiguration, Vorschau
 und bestätigter Erstimport sind implementiert; die Editoroberfläche zur
-Objektzuordnung, Folgeimporte und Rückexport stehen noch aus.
+Objektzuordnung, Folgeimporte und Rückexport stehen noch aus. Die weitere
+Revit-Arbeit ist zurückgestellt und erfolgt später über den CSV-Export/-Import
+des Linear-Plugins in Revit.
 
 ## Unterstützter Arbeitsablauf
 
diff --git a/docs/README.md b/docs/README.md
index c7a3d88..4f84717 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -29,7 +29,8 @@ ausdrücklich getrennt und dürfen nicht als bereits implementiert verstanden we
 
 - [Projektversionen und externer Modellaustausch](project-history-and-external-model-architecture.md)
 - [LLM-Kontext für die Revit-Anforderungsplanung](revit-requirements-llm-context.md)
-- [Revit-CSV-Anforderungen](spec/revit-csv-integration-requirements.md)
+- [Revit-CSV-Anforderungen](spec/revit-csv-integration-requirements.md) –
+  zurückgestellt; später über den CSV-Export/-Import des Linear-Plugins
 - [Phase-14-Audit und Implementierungsplan](spec/revit-csv-phase-14-audit-and-plan.md)
 - [Zukünftige Dimensionierung](spec/06-future-sizing-and-calculations.md)
 - [Roadmap und Phasen](spec/07-implementation-phases-todo.md)
diff --git a/docs/circuit-list-editor-known-limitations.md b/docs/circuit-list-editor-known-limitations.md
index 3e70e76..a3840df 100644
--- a/docs/circuit-list-editor-known-limitations.md
+++ b/docs/circuit-list-editor-known-limitations.md
@@ -9,6 +9,8 @@
 - Named and automatic logical project snapshots can be listed and restored
   through the project page with persistent Undo/Redo. Automatic snapshots are
   created every 25 revisions and only their newest 12 entries are retained.
+- Further Revit work is deferred; it will later use the CSV export/import of
+  the Linear plugin in Revit, not Dynamo.
 - The Revit/CSV foundation and confirmed initial import are implemented.
   Existing-row assignment, move and detach plus creation of an external-only
   row in an existing or newly created circuit have atomic persistent commands.
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 1840d59..6eeb6e1 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -552,6 +552,10 @@ bei einem späteren Wechsel trotzdem einen eigenen PostgreSQL-Adapter.
 
 ## Revit-CSV-Grundlage
 
+**Zurückgestellt:** Die weitere Revit-Arbeit wird später angegangen, dann
+über den CSV-Export/-Import des Linear-Plugins in Revit statt über Dynamo.
+Details: [Revit-CSV-Anforderungen, Abschnitt 1](spec/revit-csv-integration-requirements.md).
+
 Der reine Adapter unter `src/external-model/csv` validiert die projektweite
 Transport- und Mappingkonfiguration und parst UTF-8-CSV verlustarm in eine
 klassifizierte Zellmatrix. Er erkennt Metadaten, Header, Passthrough-, Objekt-
diff --git a/docs/project-history-and-external-model-architecture.md b/docs/project-history-and-external-model-architecture.md
index a7c1300..f8ed263 100644
--- a/docs/project-history-and-external-model-architecture.md
+++ b/docs/project-history-and-external-model-architecture.md
@@ -113,6 +113,10 @@ Implemented automatic-snapshot policy:
 
 ## Revit / CSV / IFCGUID Round-Trip Direction
 
+**Deferred:** further Revit work will be tackled later, then through the
+CSV export/import of the Linear plugin in Revit instead of Dynamo. Details:
+[Revit-CSV requirements, section 1](spec/revit-csv-integration-requirements.md).
+
 External model exchange should use explicit staging and link entities instead of writing imported rows directly into circuits.
 
 Conceptual entities:
diff --git a/docs/revit-requirements-llm-context.md b/docs/revit-requirements-llm-context.md
index 314820b..cf10324 100644
--- a/docs/revit-requirements-llm-context.md
+++ b/docs/revit-requirements-llm-context.md
@@ -1,5 +1,9 @@
 # Kontext für die Revit-Anforderungsplanung
 
+**Zurückgestellt:** Die weitere Revit-Arbeit wird später angegangen, dann
+über den CSV-Export/-Import des Linear-Plugins in Revit statt über Dynamo.
+Details: [Revit-CSV-Anforderungen, Abschnitt 1](spec/revit-csv-integration-requirements.md).
+
 ## Zweck dieser Datei
 
 Diese Datei ist eine kompakte Übergabe an ein anderes LLM. Sie soll dabei
diff --git a/docs/spec/07-implementation-phases-todo.md b/docs/spec/07-implementation-phases-todo.md
index b665e85..f36d60d 100644
--- a/docs/spec/07-implementation-phases-todo.md
+++ b/docs/spec/07-implementation-phases-todo.md
@@ -532,6 +532,10 @@ Acceptance criteria:
 
 ## Phase 14: External Model Round-Trip
 
+**Zurückgestellt:** Die weitere Revit-Arbeit wird später angegangen, dann
+über den CSV-Export/-Import des Linear-Plugins in Revit statt über Dynamo.
+Details: [Revit-CSV-Anforderungen, Abschnitt 1](revit-csv-integration-requirements.md).
+
 Status: Phase 14.2 (persistente externe Objekte und bestätigter Erstimport) ist
 implementiert. Editor-Zuordnung, Rückexport und Folgeimport folgen. Siehe
 [Phase-14-Audit und Implementierungsplan](revit-csv-phase-14-audit-and-plan.md)
@@ -540,7 +544,7 @@ und die verbindlichen
 
 Goal:
 
-Exchange model objects and planning parameters with Revit or comparable tools through CSV or another agreed format.
+Exchange model objects and planning parameters with Revit through CSV (Linear plugin export/import).
 
 Tasks:
 
diff --git a/docs/spec/08-current-product-backlog.md b/docs/spec/08-current-product-backlog.md
index c90dd24..a9e902d 100644
--- a/docs/spec/08-current-product-backlog.md
+++ b/docs/spec/08-current-product-backlog.md
@@ -141,4 +141,5 @@ The pre-release cleanup established the following compatibility boundary:
 
 The Revit/CSV/IFCGUID round-trip follows the distribution-board component
 foundation as a separate jointly planned phase and must not be inferred from
-these tasks.
+these tasks. It is currently deferred and will later use the CSV
+export/import of the Linear plugin in Revit, not Dynamo.
diff --git a/docs/spec/revit-csv-integration-requirements.md b/docs/spec/revit-csv-integration-requirements.md
index 973c1a6..4ce65ee 100644
--- a/docs/spec/revit-csv-integration-requirements.md
+++ b/docs/spec/revit-csv-integration-requirements.md
@@ -2,6 +2,19 @@
 
 ## 1. Status und Verbindlichkeit
 
+> **Zurückgestellt (September 2026).** Die weitere Revit-Arbeit
+> (Editor-Oberfläche zur Objektzuordnung, Folgeimport, Rückexport) wird später
+> angegangen. Wenn sie wieder aufgenommen wird, bleibt der Austausch
+> CSV-basiert: Export und Import laufen über das Linear-Plugin in Revit. Das
+> entspricht der Vorgabe des internen Revit/CAD-Lenkungskreises, weil dabei
+> nicht direkt per Dynamo im Modell gearbeitet wird. Eine Dynamo- oder
+> API-Anbindung ist nicht vorgesehen; die früheren Vorüberlegungen liegen unter
+> [docs/archive](../archive/revit-dynamo-leistungsbilanz-integration-konzept.md).
+> Der Aufbau der Linear-CSV ist noch offen. Vor der Wiederaufnahme wird ein
+> Musterexport gegen die bestehende projektweite CSV-Konfiguration und den
+> Parser geprüft; erst danach wird entschieden, was anzupassen ist. Die bereits
+> umgesetzten Schritte bleiben unverändert nutzbar.
+
 Dieses Dokument ist die verbindliche fachliche und technische Arbeitsgrundlage für **Phase 14: External Model Round-Trip**.
 
 Es unterscheidet ausdrücklich zwischen:
@@ -1338,7 +1351,7 @@ Diese Punkte blockieren die Erstellung dieser Spezifikation nicht.
 - automatische raumbezogene Stromkreisvorschläge;
 - projektübergreifend wiederverwendbare Mappingprofile;
 - Teilmodelle und mehrere externe Quellen;
-- Dynamo/API/JSON-Transportadapter;
+- Dynamo/API/JSON-Transportadapter (nicht vorgesehen, siehe Abschnitt 1);
 - Rollen und Berechtigungen;
 - Hintergrundjobs;
 - PostgreSQL.
diff --git a/docs/spec/revit-csv-phase-14-audit-and-plan.md b/docs/spec/revit-csv-phase-14-audit-and-plan.md
index be50eb1..a4c21e4 100644
--- a/docs/spec/revit-csv-phase-14-audit-and-plan.md
+++ b/docs/spec/revit-csv-phase-14-audit-and-plan.md
@@ -2,6 +2,10 @@
 
 ## Status
 
+**Zurückgestellt:** Die weitere Revit-Arbeit wird später angegangen, dann
+über den CSV-Export/-Import des Linear-Plugins in Revit statt über Dynamo.
+Details: [Revit-CSV-Anforderungen, Abschnitt 1](revit-csv-integration-requirements.md).
+
 Phase 14.0 ist abgeschlossen und freigegeben. Dieses Dokument beschreibt den
 gegen den aktuellen Code geprüften Zielzuschnitt. Phase 14.1 ist abgeschlossen.
 Phase 14.2 hat mit den externen Domänenverträgen, Identitätsregeln und dem
diff --git a/dynamo/01_check_model_identity.py b/dynamo/01_check_model_identity.py
deleted file mode 100644
index a3fe009..0000000
--- a/dynamo/01_check_model_identity.py
+++ /dev/null
@@ -1,385 +0,0 @@
-"""Read-only Revit 2026 model-identity diagnostics for a Dynamo Python node.
-
-Optional Dynamo input:
-    IN[0]: output directory or complete .json file path
-
-The script intentionally performs no Revit transaction and changes no model
-data. OUT contains a compact summary plus the complete report.
-"""
-
-import datetime
-import json
-import os
-import platform
-import sys
-import tempfile
-import traceback
-
-import clr
-
-clr.AddReference("RevitAPI")
-clr.AddReference("RevitServices")
-
-from Autodesk.Revit.DB import ModelPathUtils, StorageType  # noqa: E402
-from RevitServices.Persistence import DocumentManager  # noqa: E402
-
-
-CHECKED_PARAMETER_NAMES = ("LB_ModelId", "LB_ProjectId")
-
-
-def safe_text(value):
-    if value is None:
-        return None
-    try:
-        return str(value)
-    except Exception:
-        return None
-
-
-def element_id_text(element_id):
-    if element_id is None:
-        return None
-    try:
-        return str(element_id.Value)
-    except Exception:
-        try:
-            return str(element_id.IntegerValue)
-        except Exception:
-            return safe_text(element_id)
-
-
-def forge_type_id_text(value):
-    if value is None:
-        return None
-    try:
-        return value.TypeId
-    except Exception:
-        return safe_text(value)
-
-
-def parameter_value(parameter):
-    result = {
-        "hasValue": False,
-        "raw": None,
-        "display": None,
-    }
-    try:
-        result["hasValue"] = bool(parameter.HasValue)
-    except Exception:
-        pass
-
-    try:
-        storage_type = parameter.StorageType
-        if storage_type == StorageType.String:
-            result["raw"] = parameter.AsString()
-        elif storage_type == StorageType.Integer:
-            result["raw"] = int(parameter.AsInteger())
-        elif storage_type == StorageType.Double:
-            result["raw"] = float(parameter.AsDouble())
-        elif storage_type == StorageType.ElementId:
-            result["raw"] = element_id_text(parameter.AsElementId())
-    except Exception as error:
-        result["readError"] = safe_text(error)
-
-    try:
-        result["display"] = parameter.AsValueString()
-    except Exception:
-        pass
-    return result
-
-
-def describe_parameter(parameter):
-    definition = None
-    try:
-        definition = parameter.Definition
-    except Exception:
-        pass
-
-    name = None
-    if definition is not None:
-        try:
-            name = definition.Name
-        except Exception:
-            pass
-
-    is_shared = False
-    try:
-        is_shared = bool(parameter.IsShared)
-    except Exception:
-        pass
-
-    shared_guid = None
-    if is_shared:
-        try:
-            shared_guid = str(parameter.GUID)
-        except Exception:
-            pass
-
-    data_type = None
-    group_type = None
-    if definition is not None:
-        try:
-            data_type = forge_type_id_text(definition.GetDataType())
-        except Exception:
-            pass
-        try:
-            group_type = forge_type_id_text(definition.GetGroupTypeId())
-        except Exception:
-            pass
-
-    unit_type = None
-    try:
-        unit_type = forge_type_id_text(parameter.GetUnitTypeId())
-    except Exception:
-        pass
-
-    try:
-        storage_type = str(parameter.StorageType)
-    except Exception:
-        storage_type = None
-
-    try:
-        is_read_only = bool(parameter.IsReadOnly)
-    except Exception:
-        is_read_only = None
-
-    try:
-        user_modifiable = bool(parameter.UserModifiable)
-    except Exception:
-        user_modifiable = None
-
-    return {
-        "name": name,
-        "parameterId": element_id_text(getattr(parameter, "Id", None)),
-        "isShared": is_shared,
-        "sharedGuid": shared_guid,
-        "storageType": storage_type,
-        "dataTypeId": data_type,
-        "groupTypeId": group_type,
-        "unitTypeId": unit_type,
-        "isReadOnly": is_read_only,
-        "userModifiable": user_modifiable,
-        "value": parameter_value(parameter),
-    }
-
-
-def sorted_parameters(element):
-    parameters = []
-    try:
-        parameters = [describe_parameter(parameter) for parameter in element.Parameters]
-    except Exception:
-        return []
-    return sorted(
-        parameters,
-        key=lambda parameter: (
-            (parameter.get("name") or "").casefold(),
-            parameter.get("parameterId") or "",
-        ),
-    )
-
-
-def named_parameter_occurrences(element, parameter_name):
-    result = []
-    try:
-        parameters = element.GetParameters(parameter_name)
-        if parameters is not None:
-            result = [describe_parameter(parameter) for parameter in parameters]
-    except Exception:
-        parameter = None
-        try:
-            parameter = element.LookupParameter(parameter_name)
-        except Exception:
-            pass
-        if parameter is not None:
-            result = [describe_parameter(parameter)]
-    return result
-
-
-def loaded_assembly_versions():
-    result = {}
-    try:
-        from System import AppDomain
-
-        for assembly in AppDomain.CurrentDomain.GetAssemblies():
-            try:
-                name = assembly.GetName()
-                simple_name = str(name.Name)
-                if simple_name in (
-                    "DynamoCore",
-                    "DynamoCoreWpf",
-                    "DynamoRevitDS",
-                    "RevitAPI",
-                    "RevitServices",
-                ):
-                    result[simple_name] = str(name.Version)
-            except Exception:
-                continue
-    except Exception:
-        pass
-    return dict(sorted(result.items()))
-
-
-def get_cloud_identity(document):
-    result = {"isModelInCloud": False}
-    try:
-        result["isModelInCloud"] = bool(document.IsModelInCloud)
-    except Exception:
-        return result
-    if not result["isModelInCloud"]:
-        return result
-
-    try:
-        model_path = document.GetCloudModelPath()
-        result["userVisiblePath"] = ModelPathUtils.ConvertModelPathToUserVisiblePath(
-            model_path
-        )
-        for property_name, output_name in (
-            ("GetProjectGUID", "projectGuid"),
-            ("GetModelGUID", "modelGuid"),
-        ):
-            try:
-                result[output_name] = str(getattr(model_path, property_name)())
-            except Exception:
-                pass
-    except Exception as error:
-        result["readError"] = safe_text(error)
-    return result
-
-
-def get_worksharing_identity(document):
-    result = {"isWorkshared": False}
-    try:
-        result["isWorkshared"] = bool(document.IsWorkshared)
-    except Exception:
-        return result
-    if not result["isWorkshared"]:
-        return result
-
-    try:
-        model_path = document.GetWorksharingCentralModelPath()
-        result["centralModelPath"] = ModelPathUtils.ConvertModelPathToUserVisiblePath(
-            model_path
-        )
-    except Exception as error:
-        result["readError"] = safe_text(error)
-    return result
-
-
-def resolve_output_path(configured_path, report_name):
-    timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
-    default_directory = os.path.join(tempfile.gettempdir(), "leistungsbilanz-dynamo")
-    raw_path = safe_text(configured_path)
-    if raw_path is None or not raw_path.strip():
-        directory = default_directory
-        file_path = os.path.join(directory, report_name + "-" + timestamp + ".json")
-    else:
-        expanded = os.path.abspath(os.path.expandvars(os.path.expanduser(raw_path.strip())))
-        if expanded.lower().endswith(".json"):
-            file_path = expanded
-            directory = os.path.dirname(file_path)
-        else:
-            directory = expanded
-            file_path = os.path.join(directory, report_name + "-" + timestamp + ".json")
-    if not directory:
-        directory = os.getcwd()
-    if not os.path.isdir(directory):
-        os.makedirs(directory)
-    return file_path
-
-
-def write_json(file_path, payload):
-    temporary_path = file_path + ".tmp"
-    with open(temporary_path, "w", encoding="utf-8", newline="\n") as output:
-        json.dump(payload, output, ensure_ascii=False, indent=2, sort_keys=True)
-        output.write("\n")
-    os.replace(temporary_path, file_path)
-
-
-def get_input(index, default=None):
-    values = globals().get("IN", [])
-    try:
-        value = values[index]
-        return default if value is None else value
-    except Exception:
-        return default
-
-
-def build_report():
-    document = DocumentManager.Instance.CurrentDBDocument
-    if document is None:
-        raise RuntimeError("No active Revit document is available.")
-
-    project_information = document.ProjectInformation
-    if project_information is None:
-        raise RuntimeError("The active document has no Project Information element.")
-
-    application = document.Application
-    checked_parameters = {
-        name: named_parameter_occurrences(project_information, name)
-        for name in CHECKED_PARAMETER_NAMES
-    }
-    warnings = []
-    for name in CHECKED_PARAMETER_NAMES:
-        occurrences = checked_parameters[name]
-        populated = [
-            parameter
-            for parameter in occurrences
-            if parameter.get("value", {}).get("raw") not in (None, "")
-        ]
-        if not occurrences:
-            warnings.append(name + " is not bound to Project Information.")
-        elif not populated:
-            warnings.append(name + " exists but has no value on Project Information.")
-        elif len(occurrences) > 1:
-            warnings.append(name + " occurs more than once; use a shared-parameter GUID later.")
-
-    return {
-        "reportSchemaVersion": 1,
-        "generatedAt": datetime.datetime.now(datetime.timezone.utc).isoformat(),
-        "readOnly": True,
-        "environment": {
-            "revitVersionNumber": safe_text(getattr(application, "VersionNumber", None)),
-            "revitVersionName": safe_text(getattr(application, "VersionName", None)),
-            "revitSubVersionNumber": safe_text(
-                getattr(application, "SubVersionNumber", None)
-            ),
-            "pythonImplementation": safe_text(getattr(sys.implementation, "name", None)),
-            "pythonVersion": platform.python_version(),
-            "assemblies": loaded_assembly_versions(),
-        },
-        "document": {
-            "title": safe_text(document.Title),
-            "pathName": safe_text(document.PathName),
-            "isFamilyDocument": bool(document.IsFamilyDocument),
-            "cloud": get_cloud_identity(document),
-            "worksharing": get_worksharing_identity(document),
-        },
-        "modelIdentityCandidates": {
-            "projectInformationUniqueId": safe_text(project_information.UniqueId),
-            "projectInformationElementId": element_id_text(project_information.Id),
-            "checkedProjectParameters": checked_parameters,
-        },
-        "projectInformationParameters": sorted_parameters(project_information),
-        "warnings": warnings,
-    }
-
-
-try:
-    report = build_report()
-    output_path = resolve_output_path(get_input(0), "model-identity")
-    write_json(output_path, report)
-    OUT = {
-        "ok": True,
-        "filePath": output_path,
-        "projectInformationUniqueId": report["modelIdentityCandidates"][
-            "projectInformationUniqueId"
-        ],
-        "warnings": report["warnings"],
-        "report": report,
-    }
-except Exception as error:
-    OUT = {
-        "ok": False,
-        "error": safe_text(error),
-        "traceback": traceback.format_exc(),
-    }
diff --git a/dynamo/02_export_electrical_fixture_parameter_inventory.py b/dynamo/02_export_electrical_fixture_parameter_inventory.py
deleted file mode 100644
index 440a222..0000000
--- a/dynamo/02_export_electrical_fixture_parameter_inventory.py
+++ /dev/null
@@ -1,517 +0,0 @@
-"""Export all Electrical Fixtures instance/type parameters from Revit 2026.
-
-Optional Dynamo inputs:
-    IN[0]: output directory or complete .json file path
-    IN[1]: include empty parameters (default True)
-    IN[2]: maximum aggregated sample values (default 5)
-
-The script is read-only and performs no Revit transaction.
-"""
-
-import datetime
-import json
-import os
-import platform
-import sys
-import tempfile
-import traceback
-
-import clr
-
-clr.AddReference("RevitAPI")
-clr.AddReference("RevitServices")
-
-from Autodesk.Revit.DB import (  # noqa: E402
-    BuiltInCategory,
-    FilteredElementCollector,
-    ModelPathUtils,
-    StorageType,
-)
-from RevitServices.Persistence import DocumentManager  # noqa: E402
-
-
-def safe_text(value):
-    if value is None:
-        return None
-    try:
-        return str(value)
-    except Exception:
-        return None
-
-
-def element_id_text(element_id):
-    if element_id is None:
-        return None
-    try:
-        return str(element_id.Value)
-    except Exception:
-        try:
-            return str(element_id.IntegerValue)
-        except Exception:
-            return safe_text(element_id)
-
-
-def forge_type_id_text(value):
-    if value is None:
-        return None
-    try:
-        return value.TypeId
-    except Exception:
-        return safe_text(value)
-
-
-def parameter_value(parameter):
-    result = {"hasValue": False, "raw": None, "display": None}
-    try:
-        result["hasValue"] = bool(parameter.HasValue)
-    except Exception:
-        pass
-
-    try:
-        storage_type = parameter.StorageType
-        if storage_type == StorageType.String:
-            result["raw"] = parameter.AsString()
-        elif storage_type == StorageType.Integer:
-            result["raw"] = int(parameter.AsInteger())
-        elif storage_type == StorageType.Double:
-            result["raw"] = float(parameter.AsDouble())
-        elif storage_type == StorageType.ElementId:
-            result["raw"] = element_id_text(parameter.AsElementId())
-    except Exception as error:
-        result["readError"] = safe_text(error)
-
-    try:
-        result["display"] = parameter.AsValueString()
-    except Exception:
-        pass
-    return result
-
-
-def describe_parameter(parameter, scope):
-    definition = None
-    try:
-        definition = parameter.Definition
-    except Exception:
-        pass
-
-    name = None
-    data_type = None
-    group_type = None
-    if definition is not None:
-        try:
-            name = definition.Name
-        except Exception:
-            pass
-        try:
-            data_type = forge_type_id_text(definition.GetDataType())
-        except Exception:
-            pass
-        try:
-            group_type = forge_type_id_text(definition.GetGroupTypeId())
-        except Exception:
-            pass
-
-    is_shared = False
-    try:
-        is_shared = bool(parameter.IsShared)
-    except Exception:
-        pass
-
-    shared_guid = None
-    if is_shared:
-        try:
-            shared_guid = str(parameter.GUID)
-        except Exception:
-            pass
-
-    unit_type = None
-    try:
-        unit_type = forge_type_id_text(parameter.GetUnitTypeId())
-    except Exception:
-        pass
-
-    try:
-        storage_type = str(parameter.StorageType)
-    except Exception:
-        storage_type = None
-
-    try:
-        is_read_only = bool(parameter.IsReadOnly)
-    except Exception:
-        is_read_only = None
-
-    try:
-        user_modifiable = bool(parameter.UserModifiable)
-    except Exception:
-        user_modifiable = None
-
-    return {
-        "scope": scope,
-        "name": name,
-        "parameterId": element_id_text(getattr(parameter, "Id", None)),
-        "isShared": is_shared,
-        "sharedGuid": shared_guid,
-        "storageType": storage_type,
-        "dataTypeId": data_type,
-        "groupTypeId": group_type,
-        "unitTypeId": unit_type,
-        "isReadOnly": is_read_only,
-        "userModifiable": user_modifiable,
-        "value": parameter_value(parameter),
-    }
-
-
-def has_meaningful_value(parameter_description):
-    value = parameter_description.get("value", {})
-    return bool(value.get("hasValue")) or value.get("raw") not in (None, "") or value.get(
-        "display"
-    ) not in (None, "")
-
-
-def read_parameters(element, scope, include_empty):
-    result = []
-    try:
-        for parameter in element.Parameters:
-            description = describe_parameter(parameter, scope)
-            if include_empty or has_meaningful_value(description):
-                result.append(description)
-    except Exception as error:
-        return [], [safe_text(error)]
-    result.sort(
-        key=lambda parameter: (
-            (parameter.get("name") or "").casefold(),
-            parameter.get("parameterId") or "",
-        )
-    )
-    return result, []
-
-
-def read_space(element, document):
-    try:
-        space = element.Space
-    except Exception as error:
-        return None, safe_text(error)
-    if space is None:
-        return None, None
-
-    level_name = None
-    try:
-        level = document.GetElement(space.LevelId)
-        level_name = None if level is None else safe_text(level.Name)
-    except Exception:
-        pass
-
-    return {
-        "uniqueId": safe_text(space.UniqueId),
-        "elementId": element_id_text(space.Id),
-        "number": safe_text(getattr(space, "Number", None)),
-        "name": safe_text(getattr(space, "Name", None)),
-        "levelName": level_name,
-    }, None
-
-
-def read_family_identity(element, document):
-    symbol = None
-    try:
-        symbol = element.Symbol
-    except Exception:
-        try:
-            symbol = document.GetElement(element.GetTypeId())
-        except Exception:
-            pass
-
-    family_name = None
-    type_name = None
-    type_unique_id = None
-    type_element_id = None
-    if symbol is not None:
-        try:
-            family_name = safe_text(symbol.Family.Name)
-        except Exception:
-            family_name = safe_text(getattr(symbol, "FamilyName", None))
-        type_name = safe_text(getattr(symbol, "Name", None))
-        type_unique_id = safe_text(getattr(symbol, "UniqueId", None))
-        type_element_id = element_id_text(getattr(symbol, "Id", None))
-
-    return {
-        "familyName": family_name,
-        "typeName": type_name,
-        "typeUniqueId": type_unique_id,
-        "typeElementId": type_element_id,
-    }, symbol
-
-
-def parameter_inventory_key(parameter):
-    stable_id = parameter.get("sharedGuid") or parameter.get("parameterId") or ""
-    return "|".join(
-        (
-            parameter.get("scope") or "",
-            stable_id,
-            parameter.get("name") or "",
-            parameter.get("dataTypeId") or "",
-        )
-    )
-
-
-def sample_value_key(value):
-    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
-
-
-def add_to_inventory(inventory, parameter, max_samples):
-    key = parameter_inventory_key(parameter)
-    entry = inventory.get(key)
-    if entry is None:
-        entry = {
-            "scope": parameter.get("scope"),
-            "name": parameter.get("name"),
-            "parameterId": parameter.get("parameterId"),
-            "isShared": parameter.get("isShared"),
-            "sharedGuid": parameter.get("sharedGuid"),
-            "storageType": parameter.get("storageType"),
-            "dataTypeId": parameter.get("dataTypeId"),
-            "groupTypeId": parameter.get("groupTypeId"),
-            "unitTypeId": parameter.get("unitTypeId"),
-            "occurrenceCount": 0,
-            "populatedCount": 0,
-            "sampleValues": [],
-            "_sampleKeys": set(),
-        }
-        inventory[key] = entry
-    entry["occurrenceCount"] += 1
-    if has_meaningful_value(parameter):
-        entry["populatedCount"] += 1
-    value = parameter.get("value")
-    value_key = sample_value_key(value)
-    if len(entry["sampleValues"]) < max_samples and value_key not in entry["_sampleKeys"]:
-        entry["_sampleKeys"].add(value_key)
-        entry["sampleValues"].append(value)
-
-
-def finalize_inventory(inventory):
-    result = []
-    for entry in inventory.values():
-        clean_entry = dict(entry)
-        clean_entry.pop("_sampleKeys", None)
-        result.append(clean_entry)
-    return sorted(
-        result,
-        key=lambda entry: (
-            entry.get("scope") or "",
-            (entry.get("name") or "").casefold(),
-            entry.get("sharedGuid") or entry.get("parameterId") or "",
-        ),
-    )
-
-
-def loaded_assembly_versions():
-    result = {}
-    try:
-        from System import AppDomain
-
-        for assembly in AppDomain.CurrentDomain.GetAssemblies():
-            try:
-                name = assembly.GetName()
-                simple_name = str(name.Name)
-                if simple_name in (
-                    "DynamoCore",
-                    "DynamoCoreWpf",
-                    "DynamoRevitDS",
-                    "RevitAPI",
-                    "RevitServices",
-                ):
-                    result[simple_name] = str(name.Version)
-            except Exception:
-                continue
-    except Exception:
-        pass
-    return dict(sorted(result.items()))
-
-
-def resolve_output_path(configured_path):
-    timestamp = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
-    default_directory = os.path.join(tempfile.gettempdir(), "leistungsbilanz-dynamo")
-    raw_path = safe_text(configured_path)
-    if raw_path is None or not raw_path.strip():
-        directory = default_directory
-        file_path = os.path.join(
-            directory, "electrical-fixture-parameters-" + timestamp + ".json"
-        )
-    else:
-        expanded = os.path.abspath(os.path.expandvars(os.path.expanduser(raw_path.strip())))
-        if expanded.lower().endswith(".json"):
-            file_path = expanded
-            directory = os.path.dirname(file_path)
-        else:
-            directory = expanded
-            file_path = os.path.join(
-                directory, "electrical-fixture-parameters-" + timestamp + ".json"
-            )
-    if not directory:
-        directory = os.getcwd()
-    if not os.path.isdir(directory):
-        os.makedirs(directory)
-    return file_path
-
-
-def write_json(file_path, payload):
-    temporary_path = file_path + ".tmp"
-    with open(temporary_path, "w", encoding="utf-8", newline="\n") as output:
-        json.dump(payload, output, ensure_ascii=False, indent=2, sort_keys=True)
-        output.write("\n")
-    os.replace(temporary_path, file_path)
-
-
-def get_input(index, default=None):
-    values = globals().get("IN", [])
-    try:
-        value = values[index]
-        return default if value is None else value
-    except Exception:
-        return default
-
-
-def build_report(include_empty, max_samples):
-    document = DocumentManager.Instance.CurrentDBDocument
-    if document is None:
-        raise RuntimeError("No active Revit document is available.")
-    if document.IsFamilyDocument:
-        raise RuntimeError("Open a Revit project document, not a family document.")
-
-    application = document.Application
-    collector = (
-        FilteredElementCollector(document)
-        .OfCategory(BuiltInCategory.OST_ElectricalFixtures)
-        .WhereElementIsNotElementType()
-    )
-    source_elements = list(collector)
-    source_elements.sort(key=lambda element: safe_text(element.UniqueId) or "")
-
-    elements = []
-    types_by_unique_id = {}
-    inventory = {}
-    errors = []
-    elements_without_space = 0
-
-    for element in source_elements:
-        element_errors = []
-        try:
-            family_identity, symbol = read_family_identity(element, document)
-            instance_parameters, parameter_errors = read_parameters(
-                element, "instance", include_empty
-            )
-            element_errors.extend(parameter_errors)
-            for parameter in instance_parameters:
-                add_to_inventory(inventory, parameter, max_samples)
-
-            type_unique_id = family_identity.get("typeUniqueId")
-            if symbol is not None and type_unique_id and type_unique_id not in types_by_unique_id:
-                type_parameters, type_errors = read_parameters(symbol, "type", include_empty)
-                element_errors.extend(type_errors)
-                for parameter in type_parameters:
-                    add_to_inventory(inventory, parameter, max_samples)
-                types_by_unique_id[type_unique_id] = {
-                    **family_identity,
-                    "parameters": type_parameters,
-                }
-
-            space, space_error = read_space(element, document)
-            if space_error:
-                element_errors.append("MEP Space: " + space_error)
-            if space is None:
-                elements_without_space += 1
-
-            elements.append(
-                {
-                    "uniqueId": safe_text(element.UniqueId),
-                    "elementId": element_id_text(element.Id),
-                    "categoryName": safe_text(
-                        None if element.Category is None else element.Category.Name
-                    ),
-                    "family": family_identity,
-                    "space": space,
-                    "instanceParameters": instance_parameters,
-                    "warnings": element_errors,
-                }
-            )
-        except Exception as error:
-            errors.append(
-                {
-                    "uniqueId": safe_text(getattr(element, "UniqueId", None)),
-                    "elementId": element_id_text(getattr(element, "Id", None)),
-                    "error": safe_text(error),
-                }
-            )
-
-    return {
-        "reportSchemaVersion": 1,
-        "generatedAt": datetime.datetime.now(datetime.timezone.utc).isoformat(),
-        "readOnly": True,
-        "complete": len(errors) == 0,
-        "scope": {
-            "builtInCategory": "OST_ElectricalFixtures",
-            "wholeDocument": True,
-            "elementTypesExcluded": True,
-            "includeEmptyParameters": include_empty,
-        },
-        "environment": {
-            "revitVersionNumber": safe_text(getattr(application, "VersionNumber", None)),
-            "revitVersionName": safe_text(getattr(application, "VersionName", None)),
-            "revitSubVersionNumber": safe_text(
-                getattr(application, "SubVersionNumber", None)
-            ),
-            "pythonImplementation": safe_text(getattr(sys.implementation, "name", None)),
-            "pythonVersion": platform.python_version(),
-            "assemblies": loaded_assembly_versions(),
-        },
-        "document": {
-            "title": safe_text(document.Title),
-            "pathName": safe_text(document.PathName),
-            "projectInformationUniqueId": safe_text(document.ProjectInformation.UniqueId),
-        },
-        "summary": {
-            "elementCount": len(source_elements),
-            "exportedElementCount": len(elements),
-            "typeCount": len(types_by_unique_id),
-            "parameterDefinitionCount": len(inventory),
-            "elementsWithoutMepSpace": elements_without_space,
-            "elementErrorCount": len(errors),
-        },
-        "parameterInventory": finalize_inventory(inventory),
-        "types": sorted(
-            types_by_unique_id.values(),
-            key=lambda entry: (
-                (entry.get("familyName") or "").casefold(),
-                (entry.get("typeName") or "").casefold(),
-                entry.get("typeUniqueId") or "",
-            ),
-        ),
-        "elements": elements,
-        "errors": errors,
-    }
-
-
-try:
-    include_empty_input = get_input(1, True)
-    include_empty = bool(include_empty_input)
-    try:
-        max_samples = int(get_input(2, 5))
-    except Exception:
-        max_samples = 5
-    max_samples = max(0, min(max_samples, 50))
-
-    report = build_report(include_empty, max_samples)
-    output_path = resolve_output_path(get_input(0))
-    write_json(output_path, report)
-    OUT = {
-        "ok": True,
-        "filePath": output_path,
-        "complete": report["complete"],
-        "summary": report["summary"],
-        "errors": report["errors"],
-    }
-except Exception as error:
-    OUT = {
-        "ok": False,
-        "error": safe_text(error),
-        "traceback": traceback.format_exc(),
-    }
diff --git a/dynamo/README.md b/dynamo/README.md
deleted file mode 100644
index 800eded..0000000
--- a/dynamo/README.md
+++ /dev/null
@@ -1,69 +0,0 @@
-# Revit 2026 / Dynamo diagnostics
-
-This directory contains self-contained Python scripts for a Dynamo **Python
-Script** node. They use only Dynamo's built-in Revit integration, the Revit API
-and the Python standard library. No Dynamo package is required.
-
-The scripts are read-only. They do not start a Revit transaction and do not
-change the open model.
-
-## Python engine
-
-Use the built-in `CPython3` engine in Revit 2026. Autodesk ships Dynamo with
-Revit; optional PythonNet3 packages are not required by these diagnostics.
-
-## 01 - Check model identity
-
-File: `01_check_model_identity.py`
-
-The script reports:
-
-- Revit, Dynamo and Python versions;
-- `ProjectInformation.UniqueId` as a native model-identity candidate;
-- all occurrences and values of `LB_ModelId` and `LB_ProjectId` on Project
-  Information;
-- all Project Information parameters;
-- optional cloud/worksharing identity information when the API exposes it.
-
-Input `IN[0]` is optional. It may be either an output directory or a complete
-`.json` file path. With no input, the report is written below the current
-Windows temporary directory in `leistungsbilanz-dynamo`.
-
-## 02 - Inventory Electrical Fixtures parameters
-
-File: `02_export_electrical_fixture_parameter_inventory.py`
-
-The script reads every instance of
-`BuiltInCategory.OST_ElectricalFixtures` in the complete current document. It
-exports:
-
-- element, family, type and MEP Space identities;
-- every instance parameter and value;
-- every unique family-type parameter and value;
-- an aggregated parameter inventory with occurrence counts and sample values;
-- per-element warnings instead of aborting at the first unreadable element.
-
-Inputs:
-
-- `IN[0]` (optional): output directory or complete `.json` path;
-- `IN[1]` (optional): include empty parameters, default `true`;
-- `IN[2]` (optional): maximum sample values per aggregated parameter, default
-  `5`.
-
-The default output location is again the Windows temporary directory. The
-generated report can contain model paths and project-specific parameter values;
-review it before sharing or committing it.
-
-## Running a script
-
-1. Open the target model in Revit 2026.
-2. Open Dynamo from **Manage > Visual Programming > Dynamo**.
-3. Create a graph and add a **Python Script** node.
-4. Select the `CPython3` engine for the node.
-5. Copy the complete content of the desired `.py` file into the node.
-6. Optionally connect a String node containing the output path to `IN[0]`.
-7. Run the graph and inspect `OUT` for status, counts and the generated path.
-
-For the first test, run `01_check_model_identity.py` in the Revit main model.
-Then run the parameter inventory. Keep both generated JSON files so their
-structure can be checked before the production snapshot DTO is finalized.

From 57a62b7e4ae90d234a3e7caafebf5de4ddc7e46b Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 11:17:24 +0200
Subject: [PATCH 29/60] Record the confirmed building structure decisions

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/building-structure.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/docs/building-structure.md b/docs/building-structure.md
index c48e895..db7f062 100644
--- a/docs/building-structure.md
+++ b/docs/building-structure.md
@@ -4,7 +4,8 @@ Projekte mit mehreren Gebäuden werden über eine eigene Ebene **Gebäude**
 gegliedert. Etagen können einem Gebäude zugeordnet sein, Räume und Verteilungen
 hängen wie bisher an der Etage. Das Gebäude eines Raums oder einer Verteilung
 ergibt sich also aus der Etage; eine zweite, konkurrierende Zuordnung gibt es
-nicht. Abstimmung mit Julian: Issue #6.
+nicht. Abgestimmt in Issue #6: Das Modell ist so bestätigt, und Gebäude mit
+zugeordneten Etagen lassen sich nicht löschen.
 
 ## Datenmodell
 
@@ -75,7 +76,8 @@ Stromkreisliste.
 
 ## Offen
 
-- Revit: Das Gebäude kann später aus einem Revit-Parameter kommen und über die
-  bestehende CSV-Zuordnung gemappt werden (Frage an Julian in Issue #6).
+- Revit: Eine Übernahme des Gebäudes aus Revit ist derzeit nicht geplant. Die
+  Revit-Arbeit ist insgesamt zurückgestellt und läuft später über die
+  Linear-CSV; das Modell steht einer späteren CSV-Zuordnung nicht im Weg.
 - Sortierung von Gebäuden per Drag-and-drop ist noch nicht umgesetzt; neue
   Gebäude werden hinten angehängt.

From 5cbbd3a84aaf56e9ef998448b85d2012bac20765 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 17:01:23 +0200
Subject: [PATCH 30/60] Align cable sizing with DIN VDE 0298-4

---
 AGENTS.md                                     |  11 +-
 docs/cable-sizing-module.md                   | 218 +++++++-----------
 docs/circuit-list-editor-api.md               |   7 +-
 docs/circuit-list-editor-known-limitations.md |  10 +-
 docs/current-architecture.md                  |   6 +-
 docs/spec/08-current-product-backlog.md       |   5 +-
 .../domain/cable-sizing-calculation.ts        | 146 ++++++------
 .../components/cable-sizing-modal.tsx         |  18 +-
 tests/cable-sizing-calculation.test.ts        |  85 +++++--
 9 files changed, 262 insertions(+), 244 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index a8f97c3..e9db70a 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -607,10 +607,13 @@ circuit list (see `docs/cable-sizing-module.md`). Rules:
   by clicking a grid cell; cable cells keep the normal spreadsheet behavior.
 - It has no database table and no migration; `/api/cable-sizing/*` is
   stateless.
-- Reference data is IEC 60364-5-52:2009 Annex B. Change table values only with
-  a documented source in `docs/cable-sizing-module.md`; where sources differ,
-  use the lower value. Inputs outside the tables return no result instead of
-  assuming a factor of 1.
+- Current-carrying capacities and correction factors use
+  DIN VDE 0298-4:2023-06 with Berichtigung 1:2023-10; the exact scope and the
+  separate basis of voltage-drop and protection checks are documented in
+  `docs/cable-sizing-module.md`. Inputs outside the supported tables return no
+  result instead of assuming a factor of 1. Direct burial, grouped method E,
+  aluminium below 25 mm² and neutral-current sizing above 33 % third harmonic
+  remain unsupported until their required inputs or normative basis exist.
 - Inputs are prefilled from the circuit (power, phase, voltage, weighted cos φ,
   length, protective device) and remain editable; manual cable entry without
   a calculation stays possible.
diff --git a/docs/cable-sizing-module.md b/docs/cable-sizing-module.md
index 374994e..cd8b08d 100644
--- a/docs/cable-sizing-module.md
+++ b/docs/cable-sizing-module.md
@@ -1,159 +1,109 @@
-# Leitungsberechnung (Cable-Sizing-Modul)
+# Leitungsberechnung
 
-Optionales, abgegrenztes Rechenmodul für die Querschnittsempfehlung eines
-Stromkreises. Es wurde als eigenständiges Modul vereinbart, das an die
-Stromkreisliste angedockt ist. Es **schreibt keine Projektdaten selbst**: Ein
-Ergebnis wird erst durch ausdrückliches „Übernehmen“ über den bestehenden
-Befehl `circuit.update` in den Stromkreis geschrieben. Revisionen und
-Undo/Redo bleiben damit unverändert gültig.
+Das optionale Modul gibt für einen einzelnen Stromkreis eine prüfbare
+Querschnittsempfehlung aus. Es schreibt selbst keine Projektdaten. Erst die
+ausdrückliche Aktion **Übernehmen** aktualisiert `cableCrossSection`,
+`cableType` und `cableLength` über den vorhandenen Befehl `circuit.update`.
+Revisionen sowie Undo/Redo bleiben dadurch erhalten.
 
-Die vollständige, automatische Bemessung aller Stromkreise (siehe
-`docs/spec/06-future-sizing-and-calculations.md`) ist weiterhin **nicht**
-Teil dieses Moduls.
+Eine automatische Bemessung aller Stromkreise ist weiterhin nicht Bestandteil
+des Moduls.
 
-## Aufbau und Andockpunkte
+## Aufbau
 
-```
-src/cable-sizing/domain/cable-sizing-calculation.ts   reine Berechnung + Tabellen
-src/cable-sizing/domain/cable-sizing-contracts.ts     Zod-Schema der API
+```text
+src/cable-sizing/domain/cable-sizing-calculation.ts   Berechnung und Tabellen
+src/cable-sizing/domain/cable-sizing-contracts.ts     API-Validierung
 src/server/controllers/cable-sizing.controller.ts     zustandslose Endpunkte
-src/server/routes/cable-sizing.routes.ts              Router unter /api/cable-sizing
+src/server/routes/cable-sizing.routes.ts              Router
 src/frontend/components/cable-sizing-api.ts           Fetch-Client
-src/frontend/components/cable-sizing-defaults.ts      Vorbelegung aus dem Stromkreis
+src/frontend/components/cable-sizing-defaults.ts      Vorbelegung
 src/frontend/components/cable-sizing-modal.tsx        Dialog
-tests/cable-sizing-calculation.test.ts                Tabellen, Rechnung, Vorbelegung
+tests/cable-sizing-calculation.test.ts                Tabellen und Grenzfälle
 ```
 
-Das Domänenmodul importiert nichts aus `db/`, `server/` oder `frontend/`.
-Außerhalb dieser Dateien gibt es genau zwei Andockpunkte:
+Das Domänenmodul hängt weder von Datenbank, Server noch React ab. Die API ist
+zustandslos. Im Stromkreis-Editor öffnet ein Rechner-Symbol den Dialog; die
+Kabelzellen behalten ihr übliches Spreadsheet-Verhalten.
 
-1. `src/server/index.ts`: `app.use("/api/cable-sizing", cableSizingRouter)`.
-2. `src/frontend/components/circuit-tree-editor.tsx`: Zustand für den
-   geöffneten Dialog, ein Button **Leitungsberechnung** (Rechner-Icon) in der
-   Aktionsspalte jeder Stromkreiszeile, der Dialog selbst und
-   `handleApplyCableSizing`, das über `updateCircuitById` den regulären
-   `circuit.update`-Befehl ausführt.
+## Eingaben
 
-Der Aufruf liegt bewusst **nicht** auf einer Tabellenzelle: Klick, Doppelklick,
-Enter, F2 und Tippen in den Kabelspalten verhalten sich wie in jeder anderen
-Zelle (Spreadsheet-Regel in `AGENTS.md`). Es gibt keine eigene Datenbanktabelle
-und keine Migration.
+Aus dem Stromkreis werden Leistung, Phasen, Spannung, leistungsgewichtetes
+cos φ, Leitungslänge und ein vorhandenes Überstromschutzorgan vorbelegt. Der
+Planer wählt Verlegeart, Isolierstoff, Leitermaterial, Temperatur, Häufung,
+zulässigen Spannungsfall und bei Drehstrom den Anteil der dritten Harmonischen.
 
-## Eingaben und Vorbelegung
+Eine Leitungslänge von `0 m` ist zulässig. Der Dialog weist sichtbar darauf
+hin, dass dann kein Spannungsfall angesetzt wird.
 
-| Eingabe | Vorbelegung |
-|---|---|
-| Leistung | `circuitTotalPower` des Stromkreises (mit Geräte-GZF), nicht editierbar |
-| Phasen | 3~, wenn die Stromkreisgruppe 3-phasig ist oder eine Gerätezeile `three_phase` hat, sonst 1~ |
-| Spannung | `circuit.voltage` (aus den Projekteinstellungen abgeleitet); bei manuell abweichender Phasenzahl die jeweilige Projektspannung |
-| cos φ | leistungsgewichtet aus den Gerätezeilen: P / Σ(P_Zeile / cos φ_Zeile), fehlendes cos φ = 1; änderbar |
-| Länge | `cableLength` des Stromkreises |
-| Schutzorgan | Schutzgerät des Stromkreises: LS, FI/LS, AFDD = Leitungsschutzschalter; D0/NH = Sicherung gG; FI ohne Überstromauslöser wird nicht berücksichtigt |
-| Verlegeart, Isolierstoff, Leitermaterial, Temperatur, Häufung, max. ΔU, Oberschwingungen | Planereingaben |
+## Normative Grundlage und Grenzen
 
-Kabeltyp und Querschnitt lassen sich im Dialog auch ohne Berechnung direkt
-eintragen. Weicht der Eintrag von der Empfehlung oder dem
-Praxis-Mindestquerschnitt ab, erscheint nur ein Hinweis.
+Die Strombelastbarkeiten und Korrekturfaktoren wurden gegen
+**DIN VDE 0298-4 (VDE 0298-4):2023-06** einschließlich
+**Berichtigung 1:2023-10** geprüft:
+
+- Strombelastbarkeit: Tabellen 3 bis 6.
+- Temperaturfaktoren: Tabellen 17 und 20.
+- Häufung A1 bis C: Tabelle 22 nach der korrigierten Zuordnung.
+- Häufung D: Tabelle 26 für sich berührende Rohre oder Kanäle im Erdreich.
+- Oberschwingungen: Anhang B, insbesondere Tabelle B.1.
+
+Unterstützt werden A1, A2, B1, B2, C, D und E. D bezeichnet ausschließlich
+mehradrige Kabel oder Mantelleitungen im Rohr beziehungsweise Kanal im
+Erdreich. Direkte Erdverlegung wird nicht angeboten, weil DIN VDE 0298-4 dafür
+auf die Kabel-Produktnorm DIN VDE 0276-603 verweist.
+
+Für Verlegeart E hängen Häufungsfaktoren von Trägerart, Abstand und Anzahl der
+Kabelpritschen ab. Diese Angaben gehören noch nicht zum Eingabemodell. Daher
+ist E nur für einen einzelnen Stromkreis berechenbar. Für D sind höchstens
+sechs gehäufte Stromkreise durch die verwendete Tabellenzeile abgedeckt.
+
+Aluminium wird erst ab 25 mm² angeboten, weil die verwendeten Tabellen keine
+kleineren Aluminiumquerschnitte enthalten. Bei mehr als 33 % dritter
+Harmonischer ist der Neutralleiterstrom Bemessungsgrundlage. Solange dieser
+nicht als Zahlenwert eingegeben und berechnet wird, liefert das Modul keine
+Empfehlung.
+
+Die Berechnung des Spannungsfalls ist eine vereinfachte Ergänzung mit
+Leitfähigkeit bei Betriebstemperatur; Reaktanz wird vernachlässigt. Ihre
+Planungsgrenzen folgen nicht allein aus DIN VDE 0298-4. Auch die Koordination
+mit Leitungsschutzschaltern und gG-Sicherungen gehört zur
+Überstromschutzbemessung und ist getrennt von der Strombelastbarkeit zu
+beurteilen. Der Dialog bezeichnet diese Ergebnisse deshalb nicht als vollständig
+normative Leitungsbemessung.
 
 ## Rechenweg
 
-1. Betriebsstrom I_B aus Leistung, Spannung, cos φ und Phasenzahl.
-2. Erforderliche Belastbarkeit: ohne Schutzorgan I_B; mit Schutzorgan
-   max(I_B, I_n, I₂/1,45) nach IEC 60364-4-43 (I_n ≤ I_z und I₂ ≤ 1,45 · I_z).
-   I₂/I_n: Leitungsschutzschalter 1,45; Sicherung gG 2,1 (I_n ≤ 4 A),
-   1,9 (4 A < I_n < 16 A), 1,6 (I_n ≥ 16 A).
-3. Tabellenwert I_z je Querschnitt × Temperaturfaktor × Häufungsfaktor
-   (× 0,86 bei 15–33 % 3. Harmonischer im Drehstromkreis).
-4. Spannungsfall ΔU = k · L · I_B · cos φ / (κ · A · U) mit k = 2 (1~) bzw.
-   √3 (3~), κ = 48 (Cu) bzw. 30 (Al) m/(Ω·mm²) bei Betriebstemperatur;
-   Reaktanz wird vernachlässigt.
-5. Empfehlung = größerer Querschnitt aus Belastbarkeit und Spannungsfall;
-   1-phasige Stromkreise werden auf den Praxis-Mindestquerschnitt 2,5 mm²
-   angehoben (Planungskonvention aus `docs/spec/06-…`, keine Rechenanforderung).
-6. Zusätzlich: maximale Länge für den zulässigen Spannungsfall.
+1. Betriebsstrom `I_B` aus Leistung, Spannung, cos φ und Phasenzahl.
+2. Erforderliche Belastbarkeit aus `I_B` und gegebenenfalls dem vorhandenen
+   Schutzorgan.
+3. Tabellenwert `I_z` multipliziert mit Temperatur-, Häufungs- und gegebenenfalls
+   Oberschwingungsfaktor.
+4. Vereinfachter Spannungsfall für jeden verfügbaren Querschnitt.
+5. Empfehlung als größerer Querschnitt aus Belastbarkeit und Spannungsfall.
+6. Bei einphasigen Stromkreisen Anhebung auf den vereinbarten praktischen
+   Mindestquerschnitt von 2,5 mm².
 
-Temperaturen und Häufungen **zwischen** Tabellenwerten werden auf den nächsten
-ungünstigeren Tabellenwert gerundet (höhere Temperatur, mehr Stromkreise).
-Werte **außerhalb** der Tabellen liefern kein Ergebnis und eine Meldung – es
-wird nie stillschweigend mit Faktor 1 gerechnet.
-
-## Datenbasis und Prüfnachweis
-
-Grundlage ist **IEC 60364-5-52:2009, Anhang B**. Alle Werte wurden am
-26.09.2026 zeilenweise mit öffentlich zugänglichen Wiedergaben abgeglichen:
-TiSoft ElectricalDesign-Hilfe zu IEC 60364-5-52
-(`ti-soft.com/en/support/help/electricaldesign/standards/iec-60364-5-52/…`)
-und ECalPro (`ecalpro.com/standards/iec-60364/…`). Wo die Quellen voneinander
-abweichen, ist der kleinere, sichere Wert eingetragen.
-
-| Tabelle | Inhalt | Abgleich | Abweichungen |
-|---|---|---|---|
-| B.52.2 | PVC, 2 belastete Adern, Cu/Al, A1–D2 | TiSoft; Cu A1–C zusätzlich ECalPro | Cu A1 240 mm²: 321 / 320 → 320 |
-| B.52.3 | VPE, 2 belastete Adern, Cu/Al, A1–D2 | TiSoft | – |
-| B.52.4 | PVC, 3 belastete Adern, Cu/Al, A1–D2 | TiSoft | – |
-| B.52.5 | VPE, 3 belastete Adern, Cu/Al, A1–D2 | TiSoft | – |
-| B.52.10 / .11 | PVC, Verlegeart E, mehradrig, Cu / Al | TiSoft; Cu 2 Adern zusätzlich ECalPro | Cu 3 Adern 70 / 120 mm²: 198 / 278 bzw. 196 / 276 → 196 / 276 |
-| B.52.12 / .13 | VPE, Verlegeart E, mehradrig, Cu / Al | TiSoft | – |
-| B.52.14 | Temperatur Luft, PVC / VPE | TiSoft, ECalPro | – |
-| B.52.15 | Temperatur Erde, PVC / VPE | TiSoft | – |
-| B.52.17 | Häufung Luft, Zeile 1 (gebündelt) | TiSoft, ECalPro | – |
-| B.52.18 | Häufung Erde direkt, Kabel berührend | TiSoft | – |
-| B.52.19 A | Häufung mehradrige Kabel in berührenden Rohren im Erdreich | TiSoft | – |
-
-Anwendung der Tabellen:
-
-- Verlegearten A1, A2, B1, B2, C, E in Luft (Bezug 30 °C), D1 und D2 im
-  Erdreich (Bezug 20 °C, Bodenwärmewiderstand 2,5 K·m/W). Nach Tabelle B.52.1
-  ist **D1 = Leitung im Rohr/Kabelschutzrohr im Erdreich** und **D2 = Kabel
-  direkt im Erdreich**.
-- Häufung in Luft immer nach B.52.17 Zeile 1, auch für Verlegeart E; das ist
-  die ungünstigste Anordnung (einlagig auf Pritschen wären höhere Faktoren
-  zulässig). D1 nach B.52.19 A, D2 nach B.52.18 jeweils „berührend“.
-- Aluminium nur mit den echten Aluminiumwerten (ab 2,5 mm², D2 ab 16 mm²);
-  Querschnitte ohne Tabellenwert werden nie empfohlen.
-- Die Verlegearten F und G (Einzeladern mit Abstand) sind nicht enthalten.
-
-**Vor produktivem Einsatz:** Die nationalen Tabellen der DIN VDE 0298-4
-können in einzelnen Werten abweichen. Der Planer muss die Tabellen gegen den
-Normtext prüfen. Die Prüfung ist in `tests/cable-sizing-calculation.test.ts`
-über Stichwerte und eine Monotonieprüfung jeder Tabellenzeile abgesichert.
+Temperaturen und Häufungen zwischen Tabellenwerten werden zum nächsten
+ungünstigeren Tabellenwert gerundet. Außerhalb des belegten Tabellenbereichs
+wird keine Empfehlung ausgegeben. Ein abweichender Querschnitt kann weiterhin
+manuell eingetragen und bewusst übernommen werden.
 
 ## Nicht enthalten
 
-- Kurzschlussfestigkeit, Abschaltbedingungen (Schleifenimpedanz) und
-  Selektivität
-- Bodenwärmewiderstand ≠ 2,5 K·m/W, Häufung mit Abstand, Verlegearten F/G
-- Bemessung des Neutralleiters bei > 33 % 3. Harmonischer (nur Hinweis)
-- automatische Bemessung oder Prüfung aller Stromkreise
+- direkte Erdverlegung
+- detaillierte Anordnung mehrerer Kabel bei Verlegeart E
+- Neutralleiterbemessung bei mehr als 33 % dritter Harmonischer
+- Kurzschlussfestigkeit, Schleifenimpedanz, Abschaltbedingungen und Selektivität
+- abweichender Bodenwärmewiderstand sowie Verlegearten F und G
+- automatische Berechnung oder Änderung mehrerer Stromkreise
 
 ## API
 
-`POST /api/cable-sizing/calculate` – zustandslos, liest und schreibt keine
-Projektdaten.
+`POST /api/cable-sizing/calculate` berechnet zustandslos. Die Verlegeart ist
+`A1 | A2 | B1 | B2 | C | D | E`; `lengthM` darf `0` sein. Das Ergebnis enthält
+`supported: false` und einen der Gründe `temperature`, `grouping` oder
+`harmonics`, wenn keine belastbare Empfehlung möglich ist.
 
-```jsonc
-{
-  "phase": 1,                       // 1 | 3
-  "mode": "power",                  // "power" | "current"
-  "powerKw": 4.2,                   // bei mode "power"
-  "currentA": 18.3,                 // bei mode "current"
-  "cosPhi": 0.95,                   // 0,1 … 1
-  "voltage": 230,
-  "lengthM": 23.5,
-  "layingMethod": "C",              // A1 | A2 | B1 | B2 | C | D1 | D2 | E
-  "conductorMaterial": "copper",    // copper | aluminum
-  "insulation": "pvc",              // pvc | xlpe
-  "ambientTemperatureC": 30,        // Luft; bei D1/D2 Bodentemperatur
-  "groupingCircuits": 1,            // 1 … 100, Tabellen bis 20
-  "maxVoltageDropPercent": 3,
-  "harmonicNeutralLoad": "none",    // none | 15to33Percent | over33Percent
-  "existingProtection": { "ratedCurrentA": 16, "kind": "breaker" }, // optional; kind: breaker | fuse
-  "circuitCategory": "single_phase" // optional
-}
-```
-
-Antwort: `{ "result": CableSizingResult, "alerts": CableSizingAlert[] }`.
-`result.supported = false` mit `unsupportedReason` (`temperature` oder
-`grouping`), wenn die Eingaben außerhalb der Tabellen liegen.
-`GET /api/cable-sizing/laying-methods` und `GET /api/cable-sizing/insulation-materials`
-liefern die Auswahllisten.
+`GET /api/cable-sizing/laying-methods` und
+`GET /api/cable-sizing/insulation-materials` liefern die Auswahllisten.
diff --git a/docs/circuit-list-editor-api.md b/docs/circuit-list-editor-api.md
index aea5130..e528f6e 100644
--- a/docs/circuit-list-editor-api.md
+++ b/docs/circuit-list-editor-api.md
@@ -433,14 +433,15 @@ read nor write project data; applying a result uses `circuit.update` through
 
 - `POST /cable-sizing/calculate`
   - request: phase, mode (`power` | `current`), powerKw or currentA, cosPhi,
-    voltage, lengthM, layingMethod (`A1` | `A2` | `B1` | `B2` | `C` | `D1` |
-    `D2` | `E`), conductorMaterial, insulation (`pvc` | `xlpe`),
+    voltage, lengthM, layingMethod (`A1` | `A2` | `B1` | `B2` | `C` | `D` |
+    `E`), conductorMaterial, insulation (`pvc` | `xlpe`),
     ambientTemperatureC, groupingCircuits, maxVoltageDropPercent,
     harmonicNeutralLoad, optional `existingProtection`
     (`{ ratedCurrentA, kind: "breaker" | "fuse" }`) and circuitCategory
   - returns `{ "result": { ... }, "alerts": [ ... ] }`; `result.supported`
     is `false` with `unsupportedReason` when temperature or grouping lie
-    outside the tables
+    outside the tables or the neutral current needed above 33 % third
+    harmonic is unavailable
   - unknown fields are rejected (`400`)
 - `GET /cable-sizing/laying-methods`
 - `GET /cable-sizing/insulation-materials`
diff --git a/docs/circuit-list-editor-known-limitations.md b/docs/circuit-list-editor-known-limitations.md
index 22a6297..78bb44e 100644
--- a/docs/circuit-list-editor-known-limitations.md
+++ b/docs/circuit-list-editor-known-limitations.md
@@ -20,11 +20,11 @@
 - The global device library supports basic CRUD and copy operations, but has no
   versioning, permissions or controlled synchronization model.
 - There is no automatic sizing of all circuits. The optional cable sizing
-  module suggests a cross-section for one circuit on demand (IEC 60364-5-52
-  Annex B tables; no short-circuit, disconnection-time or selectivity checks,
-  no methods F/G, soil resistivity fixed at 2.5 K·m/W) and does not validate
-  manually entered cable values. National tables (DIN VDE 0298-4) must be
-  checked by the planner; see `docs/cable-sizing-module.md`.
+  module suggests a cross-section for one circuit on demand using
+  DIN VDE 0298-4:2023-06 with Berichtigung 1:2023-10. It excludes direct
+  burial, grouped method E and neutral-current sizing above 33 % third
+  harmonic, and it does not check short-circuit withstand, disconnection time
+  or selectivity. See `docs/cable-sizing-module.md`.
 - Sorting is view-only until users explicitly apply sorted order.
 - Complete-circuit drag supports one circuit at a time between groups of the
   same category. Cross-category moves and multi-circuit moves across group
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 2b4e38c..2887e8a 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -507,8 +507,10 @@ Kopieren in ein Projekt erzeugt ein eigenständiges Projektgerät.
 ## Leitungsberechnung
 
 Das optionale Modul `src/cable-sizing` berechnet auf Anforderung eine
-Querschnittsempfehlung für einen Stromkreis (IEC 60364-5-52 Anhang B:
-Belastbarkeit, Temperatur, Häufung, Spannungsfall, Schutzorgan). Die
+Querschnittsempfehlung für einen Stromkreis. Strombelastbarkeit, Temperatur
+und Häufung beruhen auf DIN VDE 0298-4:2023-06 einschließlich
+Berichtigung 1:2023-10; Spannungsfall und Schutzorgan werden ergänzend und mit
+den in der Moduldokumentation beschriebenen Grenzen geprüft. Die
 Domänenlogik ist rein, `POST /api/cable-sizing/calculate` ist zustandslos und
 es gibt keine eigene Tabelle. Der Editor öffnet den Dialog über den Button
 „Leitungsberechnung“ in der Aktionsspalte; „Übernehmen“ schreibt Kabeltyp,
diff --git a/docs/spec/08-current-product-backlog.md b/docs/spec/08-current-product-backlog.md
index 9663e33..e7821b4 100644
--- a/docs/spec/08-current-product-backlog.md
+++ b/docs/spec/08-current-product-backlog.md
@@ -47,8 +47,9 @@ requirements and intended sequencing, not proof of implementation.
 - [x] Phase F: documentation and full GUI verification.
 - [ ] Keep full electrical sizing and cable-dimensioning rules separate until
   the planner supplies the calculation requirements. The optional per-circuit
-  cable sizing module (`docs/cable-sizing-module.md`) exists; its tables must
-  be confirmed by the planner against DIN VDE 0298-4.
+  cable sizing module (`docs/cable-sizing-module.md`) exists; its supported
+  tables were confirmed against DIN VDE 0298-4:2023-06 with
+  Berichtigung 1:2023-10. Unsupported arrangements stay explicitly blocked.
 - Detailed specification:
   `docs/spec/09-distribution-board-components-and-protection-groups.md`
 
diff --git a/src/cable-sizing/domain/cable-sizing-calculation.ts b/src/cable-sizing/domain/cable-sizing-calculation.ts
index 3c881bd..07dd052 100644
--- a/src/cable-sizing/domain/cable-sizing-calculation.ts
+++ b/src/cable-sizing/domain/cable-sizing-calculation.ts
@@ -2,16 +2,14 @@
 // the module is an optional calculator attached to the circuit list and never
 // writes project data itself (see docs/cable-sizing-module.md).
 //
-// Reference data: IEC 60364-5-52:2009, Annex B (tables B.52.2 to B.52.5,
-// B.52.10 to B.52.19). Every value was cross-checked against publicly
-// available reproductions of these tables; where sources disagreed the lower,
-// i.e. safer, value is used. The table-by-table verification record is in
-// docs/cable-sizing-module.md. National tables (DIN VDE 0298-4) may differ in
-// individual values and must be checked by the planner against the norm text.
+// Reference data: DIN VDE 0298-4 (VDE 0298-4):2023-06 together with
+// Berichtigung 1:2023-10. The table-by-table scope and the separate sources
+// required for voltage drop and protection coordination are documented in
+// docs/cable-sizing-module.md.
 
-// -- Reference installation methods (IEC 60364-5-52, Table B.52.1) ----------
+// -- Reference installation methods (DIN VDE 0298-4, Table 2) ---------------
 
-export const LAYING_METHODS = ["A1", "A2", "B1", "B2", "C", "D1", "D2", "E"] as const;
+export const LAYING_METHODS = ["A1", "A2", "B1", "B2", "C", "D", "E"] as const;
 export type LayingMethod = (typeof LAYING_METHODS)[number];
 
 export const LAYING_METHOD_GROUP: Record<LayingMethod, "air" | "ground"> = {
@@ -21,8 +19,7 @@ export const LAYING_METHOD_GROUP: Record<LayingMethod, "air" | "ground"> = {
   B2: "air",
   C: "air",
   E: "air",
-  D1: "ground",
-  D2: "ground",
+  D: "ground",
 };
 
 export const LAYING_METHOD_LABELS: Record<LayingMethod, string> = {
@@ -31,8 +28,7 @@ export const LAYING_METHOD_LABELS: Record<LayingMethod, string> = {
   B1: "B1 – Einzeladern im Rohr auf oder in der Wand",
   B2: "B2 – Mehradrige Leitung im Rohr auf oder in der Wand",
   C: "C – Mehradrige Leitung direkt auf oder in der Wand",
-  D1: "D1 – Leitung im Rohr oder Kabelschutzrohr im Erdreich",
-  D2: "D2 – Kabel direkt im Erdreich",
+  D: "D – Mehradriges Kabel im Rohr oder Kanal im Erdreich",
   E: "E – Mehradrige Leitung frei in Luft",
 };
 
@@ -49,7 +45,7 @@ export const INSULATION_MATERIAL_LABELS: Record<InsulationMaterial, string> = {
 export const CONDUCTOR_MATERIALS = ["copper", "aluminum"] as const;
 export type ConductorMaterial = (typeof CONDUCTOR_MATERIALS)[number];
 
-// -- Harmonic neutral loading (IEC 60364-5-52, Annex E, three-phase only) ---
+// -- Harmonic neutral loading (DIN VDE 0298-4, Annex B, three-phase only) ---
 
 export const HARMONIC_NEUTRAL_LOAD_OPTIONS = [
   "none",
@@ -61,7 +57,7 @@ export type HarmonicNeutralLoad = (typeof HARMONIC_NEUTRAL_LOAD_OPTIONS)[number]
 export const HARMONIC_NEUTRAL_LOAD_LABELS: Record<HarmonicNeutralLoad, string> = {
   none: "Keine nennenswerte 3. Harmonische (< 15 %) – Standardfall",
   "15to33Percent": "3. Harmonische 15–33 % – Reduktionsfaktor 0,86",
-  over33Percent: "3. Harmonische > 33 % – Neutralleiter wie Außenleiter dimensionieren",
+  over33Percent: "3. Harmonische > 33 % – ohne Neutralleiterstrom keine Empfehlung",
 };
 
 export const HARMONIC_REDUCTION_FACTOR = 0.86;
@@ -85,14 +81,13 @@ export const CURRENT_CAPACITY_A: Record<
 > = {
   pvc: {
     copper: {
-      // B.52.2 / B.52.4; E: B.52.10 multi-core. A1 2L 240 mm²: sources 320/321 → 320.
-      // E 3L 70/120 mm²: sources 196/198 and 276/278 → 196 and 276.
+      // DIN VDE 0298-4, tables 3 and 4.
       A1: {
-        2: [14.5, 19.5, 26, 34, 46, 61, 80, 99, 119, 151, 182, 210, 240, 273, 320],
+        2: [15.5, 19.5, 26, 34, 46, 61, 80, 99, 119, 151, 182, 210, 240, 273, 321],
         3: [13.5, 18, 24, 31, 42, 56, 73, 89, 108, 136, 164, 188, 216, 245, 286],
       },
       A2: {
-        2: [14, 18.5, 25, 32, 43, 57, 75, 92, 110, 139, 167, 192, 219, 248, 291],
+        2: [15.5, 18.5, 25, 32, 43, 57, 75, 92, 110, 139, 167, 192, 219, 248, 291],
         3: [13, 17.5, 23, 29, 39, 52, 68, 83, 99, 125, 150, 172, 196, 223, 261],
       },
       B1: {
@@ -107,22 +102,18 @@ export const CURRENT_CAPACITY_A: Record<
         2: [19.5, 27, 36, 46, 63, 85, 112, 138, 168, 213, 258, 299, 344, 392, 461],
         3: [17.5, 24, 32, 41, 57, 76, 96, 119, 144, 184, 223, 259, 299, 341, 403],
       },
-      D1: {
+      D: {
         2: [22, 29, 37, 46, 60, 78, 99, 119, 140, 173, 204, 231, 261, 292, 336],
         3: [18, 24, 30, 38, 50, 64, 82, 98, 116, 143, 169, 192, 217, 243, 280],
       },
-      D2: {
-        2: [22, 28, 38, 48, 64, 83, 110, 132, 156, 192, 230, 261, 293, 331, 382],
-        3: [19, 24, 33, 41, 54, 70, 92, 110, 130, 162, 193, 220, 246, 278, 320],
-      },
       E: {
         2: [22, 30, 40, 51, 70, 94, 119, 148, 180, 232, 282, 328, 379, 434, 514],
         3: [18.5, 25, 34, 43, 60, 80, 101, 126, 153, 196, 238, 276, 319, 364, 430],
       },
     },
     aluminum: {
-      // B.52.2 / B.52.4 aluminium; E: B.52.11. No values below 2.5 mm²
-      // (D2 below 16 mm²).
+      // DIN VDE 0298-4 aluminium values; the normalization below removes all
+      // entries below the first tabulated aluminium size of 25 mm².
       A1: {
         2: [n, 15, 20, 26, 36, 48, 63, 77, 93, 118, 142, 164, 189, 215, 252],
         3: [n, 14, 18.5, 24, 32, 43, 57, 70, 84, 107, 129, 149, 170, 194, 227],
@@ -143,14 +134,10 @@ export const CURRENT_CAPACITY_A: Record<
         2: [n, 21, 28, 36, 49, 66, 83, 103, 125, 160, 195, 226, 261, 298, 352],
         3: [n, 18.5, 25, 32, 44, 59, 73, 90, 110, 140, 170, 197, 227, 259, 305],
       },
-      D1: {
+      D: {
         2: [n, 22, 29, 36, 47, 61, 77, 93, 109, 135, 159, 180, 204, 228, 262],
         3: [n, 18.5, 24, 30, 39, 50, 64, 77, 91, 112, 132, 150, 169, 190, 218],
       },
-      D2: {
-        2: [n, n, n, n, n, 63, 82, 98, 117, 145, 173, 200, 224, 255, 298],
-        3: [n, n, n, n, n, 53, 69, 83, 99, 122, 148, 169, 189, 214, 250],
-      },
       E: {
         2: [n, 23, 31, 39, 54, 73, 89, 111, 135, 173, 210, 244, 282, 322, 380],
         3: [n, 19.5, 26, 33, 46, 61, 78, 96, 117, 150, 183, 212, 245, 280, 330],
@@ -180,14 +167,10 @@ export const CURRENT_CAPACITY_A: Record<
         2: [24, 33, 45, 58, 80, 107, 138, 171, 209, 269, 328, 382, 441, 506, 599],
         3: [22, 30, 40, 52, 71, 96, 119, 147, 179, 229, 278, 322, 371, 424, 500],
       },
-      D1: {
+      D: {
         2: [25, 33, 43, 53, 71, 91, 116, 139, 164, 203, 239, 271, 306, 343, 395],
         3: [21, 28, 36, 44, 58, 75, 96, 115, 135, 167, 197, 223, 251, 281, 324],
       },
-      D2: {
-        2: [27, 35, 46, 58, 77, 100, 129, 155, 183, 225, 270, 306, 343, 387, 448],
-        3: [23, 30, 39, 49, 65, 84, 107, 129, 153, 188, 226, 257, 287, 324, 375],
-      },
       E: {
         2: [26, 36, 49, 63, 86, 115, 149, 185, 225, 289, 352, 410, 473, 542, 641],
         3: [23, 32, 42, 54, 75, 100, 127, 158, 192, 246, 298, 346, 399, 456, 538],
@@ -215,14 +198,10 @@ export const CURRENT_CAPACITY_A: Record<
         2: [n, 26, 35, 45, 62, 84, 101, 126, 154, 198, 241, 280, 324, 371, 439],
         3: [n, 24, 32, 41, 57, 76, 90, 112, 136, 174, 211, 245, 283, 323, 382],
       },
-      D1: {
+      D: {
         2: [n, 26, 33, 42, 55, 71, 90, 108, 128, 158, 186, 211, 238, 267, 307],
         3: [n, 22, 28, 35, 46, 59, 75, 90, 106, 130, 154, 174, 197, 220, 253],
       },
-      D2: {
-        2: [n, n, n, n, n, 76, 98, 117, 139, 170, 204, 233, 261, 296, 343],
-        3: [n, n, n, n, n, 64, 82, 98, 117, 144, 172, 197, 220, 250, 290],
-      },
       E: {
         2: [n, 28, 38, 49, 67, 91, 108, 135, 164, 211, 257, 300, 346, 397, 470],
         3: [n, 24, 32, 42, 58, 77, 97, 120, 146, 187, 227, 263, 304, 347, 409],
@@ -231,9 +210,25 @@ export const CURRENT_CAPACITY_A: Record<
   },
 };
 
+// DIN VDE 0298-4 only supplies aluminium current-carrying capacities from
+// 25 mm² onward. Smaller values from the former IEC data set must therefore
+// never participate in a recommendation.
+for (const insulation of INSULATION_MATERIALS) {
+  for (const method of LAYING_METHODS) {
+    for (const coreCount of [2, 3] as const) {
+      const row = CURRENT_CAPACITY_A[insulation].aluminum[method][coreCount] as (number | null)[];
+      CROSS_SECTIONS_MM2.forEach((crossSection, index) => {
+        if (crossSection < 25) {
+          row[index] = null;
+        }
+      });
+    }
+  }
+}
+
 // -- Correction factors ------------------------------------------------------
 
-/** B.52.14 (air, reference 30 °C) and B.52.15 (ground, reference 20 °C). */
+/** DIN VDE 0298-4 tables 17 (air) and 20 (ground). */
 export const TEMPERATURE_FACTORS: Record<
   "air" | "ground",
   Record<InsulationMaterial, Record<number, number>>
@@ -260,26 +255,32 @@ export const REFERENCE_TEMPERATURE_C: Record<"air" | "ground", number> = {
 };
 
 /**
- * Grouping reduction factors for touching circuits/cables:
- * air (A1–C, E): B.52.17 item 1 "bunched in air, on a surface, embedded or
- * enclosed" – the most restrictive arrangement, also used for E (single
- * layers on trays would allow higher factors);
- * D1: B.52.19 A (multi-core cables in touching ducts);
- * D2: B.52.18 (cables direct in ground, touching).
+ * Grouping reduction factors according to the corrected references in
+ * DIN VDE 0298-4 Berichtigung 1:2023-10:
+ * A1–C use table 22, row 1 (bundled/touching), D uses table 26 for touching
+ * conduits/ducts in earth. Method E needs details about support, spacing and
+ * number of trays from table 23, which the current input model does not carry;
+ * it is therefore supported only for one circuit.
  */
-export const GROUPING_FACTORS: Record<"air" | "D1" | "D2", Record<number, number>> = {
-  air: { 1: 1.0, 2: 0.8, 3: 0.7, 4: 0.65, 5: 0.6, 6: 0.57, 7: 0.54, 8: 0.52, 9: 0.5, 12: 0.45, 16: 0.41, 20: 0.38 },
-  D1: {
-    1: 1.0, 2: 0.85, 3: 0.75, 4: 0.7, 5: 0.65, 6: 0.6, 7: 0.57, 8: 0.54, 9: 0.52, 10: 0.49,
-    11: 0.47, 12: 0.45, 13: 0.44, 14: 0.42, 15: 0.41, 16: 0.39, 17: 0.38, 18: 0.37, 19: 0.35, 20: 0.34,
+export const GROUPING_FACTORS: Record<"A1_TO_C" | "D" | "E", Record<number, number>> = {
+  A1_TO_C: {
+    1: 1.0, 2: 0.8, 3: 0.7, 4: 0.65, 5: 0.6, 6: 0.57, 7: 0.54, 8: 0.52,
+    9: 0.5, 10: 0.48, 12: 0.45, 14: 0.43, 16: 0.41, 18: 0.39, 20: 0.38,
   },
-  D2: { 1: 1.0, 2: 0.75, 3: 0.65, 4: 0.6, 5: 0.55, 6: 0.5, 7: 0.45, 8: 0.43, 9: 0.41, 12: 0.36, 16: 0.32, 20: 0.29 },
+  D: { 1: 1.0, 2: 0.85, 3: 0.75, 4: 0.7, 5: 0.65, 6: 0.6 },
+  E: { 1: 1.0 },
 };
 
-export const MAX_GROUPING_CIRCUITS = 20;
-
 function groupingTableFor(method: LayingMethod) {
-  return method === "D1" ? GROUPING_FACTORS.D1 : method === "D2" ? GROUPING_FACTORS.D2 : GROUPING_FACTORS.air;
+  return method === "D"
+    ? GROUPING_FACTORS.D
+    : method === "E"
+      ? GROUPING_FACTORS.E
+      : GROUPING_FACTORS.A1_TO_C;
+}
+
+export function maxGroupingCircuits(method: LayingMethod): number {
+  return Math.max(...Object.keys(groupingTableFor(method)).map(Number));
 }
 
 /**
@@ -373,7 +374,7 @@ export interface CableSizingInput {
   layingMethod: LayingMethod;
   conductorMaterial: ConductorMaterial;
   insulation: InsulationMaterial;
-  /** Ambient air temperature, or ground temperature for D1/D2. */
+  /** Ambient air temperature, or ground temperature for D. */
   ambientTemperatureC: number;
   /** Number of grouped circuits or multi-core cables, including this one. */
   groupingCircuits: number;
@@ -405,7 +406,7 @@ export interface ProtectionCoordinationResult {
   coordinated: boolean;
 }
 
-export type UnsupportedReason = "temperature" | "grouping";
+export type UnsupportedReason = "temperature" | "grouping" | "harmonics";
 
 export interface CableSizingResult {
   /** false: the inputs are outside the tabulated range – no numeric result. */
@@ -454,13 +455,23 @@ export function calculateCableSizing(input: CableSizingInput): CableSizingResult
     input.ambientTemperatureC
   );
   const grouping =
-    input.groupingCircuits <= MAX_GROUPING_CIRCUITS
+    input.groupingCircuits <= maxGroupingCircuits(input.layingMethod)
       ? lookupConservative(groupingTableFor(input.layingMethod), Math.max(1, input.groupingCircuits))
       : null;
+  const harmonicsSupported = !(
+    input.phase === 3 && input.harmonicNeutralLoad === "over33Percent"
+  );
+  const unsupportedReason: UnsupportedReason | null = !temperature
+    ? "temperature"
+    : !grouping
+      ? "grouping"
+      : !harmonicsSupported
+        ? "harmonics"
+        : null;
 
   const empty: CableSizingResult = {
     supported: false,
-    unsupportedReason: !temperature ? "temperature" : "grouping",
+    unsupportedReason,
     operatingCurrentA: ib,
     designCurrentA,
     temperatureUsedC: temperature?.key ?? null,
@@ -477,7 +488,7 @@ export function calculateCableSizing(input: CableSizingInput): CableSizingResult
     rows: [],
     protectionCoordination: null,
   };
-  if (!temperature || !grouping) {
+  if (unsupportedReason || !temperature || !grouping) {
     return empty;
   }
 
@@ -586,12 +597,17 @@ export function buildCableSizingAlerts(input: CableSizingInput, result: CableSiz
   const group = LAYING_METHOD_GROUP[input.layingMethod];
 
   if (!result.supported) {
+    const groupingMaximum = maxGroupingCircuits(input.layingMethod);
     alerts.push({
       kind: "critical",
       text:
         result.unsupportedReason === "temperature"
           ? `${group === "air" ? "Umgebungstemperatur" : "Bodentemperatur"} ${input.ambientTemperatureC} °C liegt außerhalb der Tabelle für ${input.insulation === "pvc" ? "PVC" : "VPE"} – keine Berechnung möglich.`
-          : `Häufung mit ${input.groupingCircuits} Stromkreisen liegt außerhalb der Tabelle (max. ${MAX_GROUPING_CIRCUITS}) – keine Berechnung möglich.`,
+          : result.unsupportedReason === "harmonics"
+            ? "Bei mehr als 33 % dritter Harmonischer muss nach dem Neutralleiterstrom bemessen werden. Ohne diesen Wert wird keine Querschnittsempfehlung ausgegeben."
+            : input.layingMethod === "E"
+              ? "Für Verlegeart E benötigt die Norm bei Häufung Angaben zu Trägerart, Abstand und Anzahl der Kabelpritschen. Ohne diese Angaben ist nur ein einzelner Stromkreis berechenbar."
+              : `Häufung mit ${input.groupingCircuits} Stromkreisen liegt für Verlegeart ${input.layingMethod} außerhalb der verwendeten Tabelle (max. ${groupingMaximum}) – keine Berechnung möglich.`,
     });
     return alerts;
   }
@@ -637,10 +653,10 @@ export function buildCableSizingAlerts(input: CableSizingInput, result: CableSiz
       text: "Reduktionsfaktor 0,86 wegen 15–33 % 3. Harmonischer im Neutralleiter angewendet.",
     });
   }
-  if (input.phase === 3 && input.harmonicNeutralLoad === "over33Percent") {
+  if (input.lengthM === 0) {
     alerts.push({
-      kind: "warn",
-      text: "3. Harmonische > 33 %: Der Neutralleiter ist nach dem Neutralleiterstrom zu bemessen – hier nicht berücksichtigt.",
+      kind: "info",
+      text: "Leitungslänge 0 m: Für diese Berechnung wird kein Spannungsfall angesetzt.",
     });
   }
   if (group === "ground") {
diff --git a/src/frontend/components/cable-sizing-modal.tsx b/src/frontend/components/cable-sizing-modal.tsx
index deb01b2..b15de3b 100644
--- a/src/frontend/components/cable-sizing-modal.tsx
+++ b/src/frontend/components/cable-sizing-modal.tsx
@@ -11,9 +11,9 @@ import {
   LAYING_METHODS,
   LAYING_METHOD_GROUP,
   LAYING_METHOD_LABELS,
-  MAX_GROUPING_CIRCUITS,
   PRACTICAL_MINIMUM_CROSS_SECTION_MM2,
   REFERENCE_TEMPERATURE_C,
+  maxGroupingCircuits,
   temperatureOptions,
   type CableSizingAlert,
   type CableSizingInput,
@@ -100,6 +100,7 @@ export function CableSizingModal({
         ? threePhaseVoltageV
         : singlePhaseVoltageV;
   const group = LAYING_METHOD_GROUP[layingMethod];
+  const groupingMaximum = maxGroupingCircuits(layingMethod);
   const availableTemperatures = temperatureOptions(layingMethod, insulation);
 
   const input: CableSizingInput = useMemo(
@@ -208,7 +209,7 @@ export function CableSizingModal({
 
   return (
     <FormModal
-      description="Querschnittsempfehlung nach IEC 60364-5-52 Anhang B (Belastbarkeit, Temperatur, Häufung, Spannungsfall, Schutzorgan) oder direkte Eingabe. Die Empfehlung vor der Übernahme fachlich prüfen; nationale Tabellen (DIN VDE 0298-4) können abweichen."
+      description="Querschnittsempfehlung mit Strombelastbarkeit, Temperatur- und Häufungsfaktoren nach DIN VDE 0298-4:2023-06 einschließlich Berichtigung 1:2023-10. Spannungsfall und Schutzorgan werden ergänzend geprüft. Die Empfehlung vor der Übernahme fachlich prüfen."
       isSaving={isSaving}
       onClose={onClose}
       onSubmit={handleSubmit}
@@ -234,6 +235,11 @@ export function CableSizingModal({
             type="number"
             value={lengthM}
           />
+          {lengthM === 0 ? (
+            <div className="form-text text-warning">
+              Bei 0 m wird kein Spannungsfall angesetzt.
+            </div>
+          ) : null}
         </div>
         <div className="col-12 col-md-4">
           <label className="form-label" htmlFor="cable-sizing-phase">
@@ -279,6 +285,7 @@ export function CableSizingModal({
             onChange={(event) => {
               const method = event.target.value as LayingMethod;
               setLayingMethod(method);
+              setGroupingCircuits((current) => Math.min(current, maxGroupingCircuits(method)));
               applyReferenceTemperature(method, insulation);
               resetResult();
             }}
@@ -362,7 +369,7 @@ export function CableSizingModal({
           <input
             className="form-control"
             id="cable-sizing-grouping"
-            max={MAX_GROUPING_CIRCUITS}
+            max={groupingMaximum}
             min={1}
             onChange={(event) => {
               setGroupingCircuits(Math.max(1, Math.round(Number(event.target.value) || 1)));
@@ -373,7 +380,10 @@ export function CableSizingModal({
             value={groupingCircuits}
           />
           <div className="form-text">
-            Anzahl gemeinsam verlegter Stromkreise, einschließlich dieses.
+            Anzahl gemeinsam verlegter Stromkreise, einschließlich dieses
+            {layingMethod === "E"
+              ? "; ohne Angaben zur Kabelpritsche ist nur 1 zulässig."
+              : `; für diese Verlegeart sind bis ${groupingMaximum} tabelliert.`}
           </div>
         </div>
         {phase === 3 ? (
diff --git a/tests/cable-sizing-calculation.test.ts b/tests/cable-sizing-calculation.test.ts
index 05e4f3d..39cfbb1 100644
--- a/tests/cable-sizing-calculation.test.ts
+++ b/tests/cable-sizing-calculation.test.ts
@@ -45,28 +45,34 @@ const capacity = (
     CROSS_SECTIONS_MM2.indexOf(crossSection as (typeof CROSS_SECTIONS_MM2)[number])
   ];
 
-describe("cable sizing reference tables (IEC 60364-5-52 Annex B)", () => {
+describe("cable sizing reference tables (DIN VDE 0298-4:2023-06)", () => {
   it("contains the checked PVC copper values", () => {
-    // B.52.2: A1 two loaded conductors (the previously wrong row)
+    assert.equal(capacity("pvc", "copper", "A1", 2, 1.5), 15.5);
+    assert.equal(capacity("pvc", "copper", "A2", 2, 1.5), 15.5);
     assert.equal(capacity("pvc", "copper", "A1", 2, 2.5), 19.5);
     assert.equal(capacity("pvc", "copper", "A1", 2, 16), 61);
     assert.equal(capacity("pvc", "copper", "A1", 2, 120), 210);
-    // B.52.2: B2 from 50 mm² (previously copied from B1)
+    // DIN table 3: B2 from 50 mm² (previously copied from B1)
     assert.equal(capacity("pvc", "copper", "B2", 2, 50), 133);
     assert.equal(capacity("pvc", "copper", "B2", 2, 120), 232);
-    // B.52.4 and D1/D2
+    // Tables 3 and 4, including reference method D in conduits/ducts.
     assert.equal(capacity("pvc", "copper", "C", 3, 6), 41);
-    assert.equal(capacity("pvc", "copper", "D1", 2, 2.5), 29);
-    assert.equal(capacity("pvc", "copper", "D2", 3, 16), 70);
-    // Conflicting sources resolved to the lower value
-    assert.equal(capacity("pvc", "copper", "A1", 2, 240), 320);
+    assert.equal(capacity("pvc", "copper", "D", 2, 2.5), 29);
+    assert.equal(capacity("pvc", "copper", "A1", 2, 240), 321);
     assert.equal(capacity("pvc", "copper", "E", 3, 70), 196);
   });
 
-  it("uses the aluminium and XLPE tables instead of flat factors", () => {
-    assert.equal(capacity("pvc", "aluminum", "A1", 2, 1.5), null);
-    assert.equal(capacity("pvc", "aluminum", "C", 3, 16), 59);
-    assert.equal(capacity("pvc", "aluminum", "D2", 2, 10), null);
+  it("uses aluminium only from the first DIN-tabulated size of 25 mm²", () => {
+    for (const insulation of ["pvc", "xlpe"] as const) {
+      for (const method of ["A1", "A2", "B1", "B2", "C", "D", "E"] as const) {
+        for (const cores of [2, 3] as const) {
+          for (const crossSection of CROSS_SECTIONS_MM2.filter((value) => value < 25)) {
+            assert.equal(capacity(insulation, "aluminum", method, cores, crossSection), null);
+          }
+        }
+      }
+    }
+    assert.equal(capacity("pvc", "aluminum", "C", 3, 25), 73);
     assert.equal(capacity("xlpe", "copper", "C", 2, 2.5), 33);
     assert.equal(capacity("xlpe", "aluminum", "E", 3, 25), 97);
   });
@@ -113,10 +119,15 @@ describe("calculateCableSizing", () => {
     const cold = calculateCableSizing({ ...BASE_INPUT, ambientTemperatureC: 5 });
     assert.equal(cold.temperatureUsedC, 10);
     assert.equal(cold.temperatureFactor, 1.22);
-    const grouped = calculateCableSizing({ ...BASE_INPUT, groupingCircuits: 10 });
+    const exact = calculateCableSizing({ ...BASE_INPUT, groupingCircuits: 10 });
+    assert.equal(exact.groupingUsed, 10);
+    assert.equal(exact.groupingFactor, 0.48);
+    assert.equal(calculateCableSizing({ ...BASE_INPUT, groupingCircuits: 14 }).groupingFactor, 0.43);
+    assert.equal(calculateCableSizing({ ...BASE_INPUT, groupingCircuits: 18 }).groupingFactor, 0.39);
+    const grouped = calculateCableSizing({ ...BASE_INPUT, groupingCircuits: 11 });
     assert.equal(grouped.groupingUsed, 12);
     assert.equal(grouped.groupingFactor, 0.45);
-    const alerts = buildCableSizingAlerts({ ...BASE_INPUT, groupingCircuits: 10 }, grouped);
+    const alerts = buildCableSizingAlerts({ ...BASE_INPUT, groupingCircuits: 11 }, grouped);
     assert.ok(alerts.some((alert) => alert.text.includes("12 Stromkreise gerundet")));
   });
 
@@ -129,13 +140,15 @@ describe("calculateCableSizing", () => {
     );
   });
 
-  it("uses the ground tables for D1 (ducts) and D2 (direct)", () => {
-    const d1 = calculateCableSizing({ ...BASE_INPUT, layingMethod: "D1", ambientTemperatureC: 20, groupingCircuits: 10 });
-    assert.equal(d1.groupingFactor, 0.49);
-    const d2 = calculateCableSizing({ ...BASE_INPUT, layingMethod: "D2", ambientTemperatureC: 20, groupingCircuits: 10 });
-    assert.equal(d2.groupingUsed, 12);
-    assert.equal(d2.groupingFactor, 0.36);
-    assert.equal(calculateCableSizing({ ...BASE_INPUT, layingMethod: "D2", ambientTemperatureC: 30 }).temperatureFactor, 0.89);
+  it("limits grouping to the corrected DIN tables for D and E", () => {
+    const d = calculateCableSizing({ ...BASE_INPUT, layingMethod: "D", ambientTemperatureC: 20, groupingCircuits: 6 });
+    assert.equal(d.groupingFactor, 0.6);
+    assert.equal(calculateCableSizing({ ...BASE_INPUT, layingMethod: "D", ambientTemperatureC: 20, groupingCircuits: 7 }).supported, false);
+    const e = calculateCableSizing({ ...BASE_INPUT, layingMethod: "E", groupingCircuits: 2 });
+    assert.equal(e.supported, false);
+    assert.equal(e.unsupportedReason, "grouping");
+    assert.ok(buildCableSizingAlerts({ ...BASE_INPUT, layingMethod: "E", groupingCircuits: 2 }, e)[0]?.text.includes("Kabelpritsche"));
+    assert.equal(calculateCableSizing({ ...BASE_INPUT, layingMethod: "D", ambientTemperatureC: 30 }).temperatureFactor, 0.89);
   });
 
   it("refuses inputs outside the tables instead of assuming a factor of 1", () => {
@@ -156,9 +169,11 @@ describe("calculateCableSizing", () => {
       lengthM: 5,
       conductorMaterial: "aluminum",
     });
-    assert.equal(result.recommendedCrossSectionMm2, 2.5);
-    assert.equal(result.rows[0].ratedCurrentA, null);
-    assert.equal(result.rows[0].recommended, false);
+    assert.equal(result.recommendedCrossSectionMm2, 25);
+    for (const row of result.rows.filter((row) => row.crossSectionMm2 < 25)) {
+      assert.equal(row.ratedCurrentA, null);
+      assert.equal(row.recommended, false);
+    }
   });
 
   it("checks gG fuses with I2 = 1.6 In and circuit-breakers with In ≤ Iz", () => {
@@ -186,6 +201,23 @@ describe("calculateCableSizing", () => {
     assert.equal(single.harmonicReductionApplied, false);
   });
 
+  it("does not recommend a cross-section above 33 % third harmonic without neutral current", () => {
+    const input = { ...BASE_INPUT, phase: 3 as const, voltage: 400, harmonicNeutralLoad: "over33Percent" as const };
+    const result = calculateCableSizing(input);
+    assert.equal(result.supported, false);
+    assert.equal(result.unsupportedReason, "harmonics");
+    assert.equal(result.recommendedCrossSectionMm2, null);
+    assert.equal(buildCableSizingAlerts(input, result)[0]?.kind, "critical");
+  });
+
+  it("allows zero length and states that no voltage drop is applied", () => {
+    const input = { ...BASE_INPUT, lengthM: 0 };
+    const result = calculateCableSizing(input);
+    assert.equal(result.supported, true);
+    assert.equal(result.voltageDropAtRecommendedPercent, 0);
+    assert.ok(buildCableSizingAlerts(input, result).some((alert) => alert.text.includes("kein Spannungsfall")));
+  });
+
   it("raises single-phase circuits to the 2.5 mm² practical minimum", () => {
     const result = calculateCableSizing({
       ...BASE_INPUT,
@@ -203,7 +235,7 @@ describe("calculateCableSizing", () => {
   it("offers only tabulated temperatures", () => {
     assert.deepEqual(temperatureOptions("C", "pvc").at(-1), 60);
     assert.deepEqual(temperatureOptions("C", "xlpe").at(-1), 80);
-    assert.deepEqual(temperatureOptions("D1", "pvc")[2], 20);
+    assert.deepEqual(temperatureOptions("D", "pvc")[2], 20);
   });
 });
 
@@ -219,6 +251,9 @@ describe("cable sizing request schema", () => {
       false
     );
     assert.equal(cableSizingRequestSchema.safeParse({ ...BASE_INPUT, layingMethod: "F" }).success, false);
+    assert.equal(cableSizingRequestSchema.safeParse({ ...BASE_INPUT, layingMethod: "D1" }).success, false);
+    assert.equal(cableSizingRequestSchema.safeParse({ ...BASE_INPUT, layingMethod: "D2" }).success, false);
+    assert.equal(cableSizingRequestSchema.safeParse({ ...BASE_INPUT, layingMethod: "D" }).success, true);
     assert.equal(cableSizingRequestSchema.safeParse({ ...BASE_INPUT, mode: "current" }).success, false);
   });
 });

From a6500e2b262219673303ad2b27a0d4405efd9bfc Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 18:36:48 +0200
Subject: [PATCH 31/60] Add estimate row project device handoff

---
 AGENTS.md                                     |   7 +
 docs/estimate-balance.md                      |  34 +++-
 src/app/globals.css                           |   9 +-
 .../grobbilanz/[balanceId]/page.tsx           | 157 +++++++++++++++++-
 .../components/project-device-modal.tsx       |  72 +++++++-
 .../estimate-balance-sheet.tsx                |  33 +++-
 .../estimate-project-device-prefill.ts        |  51 ++++++
 tests/estimate-balance-frontend.test.ts       |  50 ++++++
 tests/project-version-history.test.ts         |  42 ++++-
 9 files changed, 434 insertions(+), 21 deletions(-)
 create mode 100644 src/frontend/estimate-balance/estimate-project-device-prefill.ts

diff --git a/AGENTS.md b/AGENTS.md
index e9db70a..eae68d2 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -663,6 +663,13 @@ for the early-phase power balance by DIN 276 cost group (see
   debounced (one Undo step per save), keeps invalid raw input local, and on a
   409 reloads only if the balance itself changed; otherwise it re-saves with
   the new revision. `request()` throws `ApiRequestError` (status, code).
+- A single estimate row can be copied explicitly through the existing
+  ProjectDevice dialog. The dialog is only a prefilled proposal; creation
+  happens after confirmation through `project-device.insert`, with the current
+  project revision and normal Undo/Redo. The copy stores no link back to the
+  estimate row, never places a circuit row automatically, and does not change
+  estimate, snapshot or transfer schemas. Area rows require manual quantity
+  and power because W/m² remains outside the ProjectDevice model.
 
 ## Persistence and Migration Rules
 
diff --git a/docs/estimate-balance.md b/docs/estimate-balance.md
index b8b675b..c68758d 100644
--- a/docs/estimate-balance.md
+++ b/docs/estimate-balance.md
@@ -9,7 +9,10 @@ Issue #7.
 
 Das Modul ist **nicht** mit der Stromkreisstruktur verknüpft. Es liest die
 Gerätezeilen nur für den Vergleich „geschätzt ↔ detailliert“ und schreibt
-nichts in Stromkreislisten, Verteilungen oder Projektgeräte.
+nichts automatisch in Stromkreislisten, Verteilungen oder Projektgeräte. Eine
+ausdrückliche Einzelaktion kann die Werte einer Grobbilanz-Zeile als Vorschlag
+in den bestehenden Projektgeräte-Dialog übernehmen; erst dessen Bestätigung
+legt über `project-device.insert` ein unplatziertes Projektgerät an.
 
 ## Aufbau
 
@@ -67,6 +70,35 @@ Zeilen ohne passende Kostengruppe erscheinen als „nicht zugeordnet“. Der
 Verteiler-GZF wird auf keiner Seite angewendet; ein fehlendes cos φ zählt als 1.
 Verglichen wird die AV-Leistung (kW) mit Differenz absolut und in %.
 
+## Übernahme als Projektgerät
+
+Die Zeilenaktion „Als Projektgerät übernehmen“ ist eine einmalige, ausdrücklich
+bestätigte Kopie. Vor dem Öffnen des Dialogs werden ausstehende Änderungen der
+Grobbilanz gespeichert. Das Anlegen läuft anschließend mit der aktuellen
+Projektrevision über den normalen Projektgeräte-Befehl und ist dadurch wie ein
+manuell angelegtes Projektgerät rückgängig machbar.
+
+- Name und Anzeigename kommen aus dem Zeilennamen; Kostengruppe, GZF, cos φ und
+  Anmerkung werden vorgeschlagen. `fixed` und `socket` erscheinen als
+  „Festanschluss“ und „Steckdose“.
+- W werden für Stückzeilen in kW umgerechnet. Die Projektgeräte-Anzahl ist 1,
+  weil das Projektgerät als Vorlage für eine spätere Gerätezeile dient; die
+  ursprüngliche Stückzahl bleibt im Herkunftshinweis sichtbar.
+- Die Kategorie ist mangels Phaseninformation in der Grobbilanz mit
+  „1-phasig“ vorbelegt und muss im Dialog fachlich geprüft werden.
+- Flächenzeilen dürfen übernommen werden. Anzahl und Leistung je Stück bleiben
+  leer und müssen manuell angegeben werden, da das Projektgerät noch keine
+  Einheit W/m² kennt (siehe Issue #20).
+- SV wird nur im Herkunftshinweis gezeigt. Die tatsächliche Versorgungsart
+  gehört zur Verteilung.
+- Gleichnamige vorhandene Projektgeräte erzeugen eine Warnung, sperren das
+  Anlegen aber nicht.
+
+Zwischen Grobbilanz-Zeile und Projektgerät wird keine Verbindung gespeichert.
+Es gibt keine Stapelübernahme und keine automatische Platzierung in einer
+Verteilung oder einem Stromkreis. Snapshot-, Transfer- und
+Grobbilanz-Befehlsformate ändern sich dadurch nicht.
+
 ## Befehle, Undo/Redo
 
 Alle Änderungen laufen über den bestehenden Projekt-Befehlsmechanismus mit
diff --git a/src/app/globals.css b/src/app/globals.css
index e5474b8..de46d37 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -2141,7 +2141,7 @@ button.structure-entry-main:focus-visible {
 .estimate-col-result { width: 4.6rem; }
 .estimate-col-sv { width: 3.2rem; }
 .estimate-col-remark { width: 9rem; }
-.estimate-col-actions { width: 2.4rem; }
+.estimate-col-actions { width: 4.5rem; }
 
 .estimate-cell-input,
 .estimate-cell-select {
@@ -2286,6 +2286,13 @@ button.structure-entry-main:focus-visible {
   gap: 2px;
 }
 
+.estimate-row-actions {
+  display: flex;
+  justify-content: center;
+  gap: 2px;
+  white-space: nowrap;
+}
+
 .estimate-group-title-row .estimate-actions-cell {
   width: auto;
   white-space: nowrap;
diff --git a/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx b/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx
index 584f5cf..933449d 100644
--- a/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx
+++ b/src/app/projects/[projectId]/grobbilanz/[balanceId]/page.tsx
@@ -14,11 +14,13 @@ import {
 } from "lucide-react";
 import {
   ApiRequestError,
+  createProjectDevice,
   getEstimateBalance,
   getEstimateComparison,
   getProject,
   getProjectHistory,
   isRevisionConflictError,
+  listProjectDevices,
   redoProjectCommand,
   undoProjectCommand,
   updateEstimateBalance,
@@ -26,11 +28,17 @@ import {
 import type {
   EstimateBalanceDto,
   EstimateComparisonDto,
+  CreateProjectDeviceInput,
   ProjectDto,
+  ProjectDeviceDto,
   ProjectHistoryStateDto,
 } from "../../../../../frontend/types";
-import type { EstimateGroupSnapshot } from "../../../../../shared/estimate-balance/estimate-balance";
+import type {
+  EstimateGroupSnapshot,
+  EstimateRowSnapshot,
+} from "../../../../../shared/estimate-balance/estimate-balance";
 import { GzfPickerModal } from "../../../../../frontend/components/gzf-picker-modal";
+import { ProjectDeviceModal } from "../../../../../frontend/components/project-device-modal";
 import {
   addEstimateGroup,
   estimateBalanceFingerprint,
@@ -41,7 +49,11 @@ import {
   updateEstimateRow,
   validateEstimateBalance,
 } from "../../../../../frontend/estimate-balance/estimate-balance-document";
-import { formatIsoDateGerman } from "../../../../../frontend/estimate-balance/estimate-balance-format";
+import {
+  formatGermanNumber,
+  formatIsoDateGerman,
+} from "../../../../../frontend/estimate-balance/estimate-balance-format";
+import { createEstimateProjectDeviceInitialValues } from "../../../../../frontend/estimate-balance/estimate-project-device-prefill";
 import {
   EstimateBalanceSheet,
   type EstimateBalanceUpdate,
@@ -60,6 +72,10 @@ const CONFLICT_MESSAGE = "Die Bilanz wurde zwischenzeitlich geändert und neu ge
 type SaveStatus = "saved" | "pending" | "saving" | "error" | "invalid";
 
 type GroupDialog = { group: EstimateGroupSnapshot | null };
+type ProjectDeviceDialog = {
+  group: EstimateGroupSnapshot;
+  row: EstimateRowSnapshot;
+};
 
 function errorMessage(error: unknown, fallback: string) {
   return error instanceof Error && error.message ? error.message : fallback;
@@ -94,6 +110,11 @@ export default function EstimateBalanceEditorPage() {
   const [gzfTarget, setGzfTarget] = useState<{ groupId: string; rowId: string } | null>(
     null
   );
+  const [projectDeviceDialog, setProjectDeviceDialog] =
+    useState<ProjectDeviceDialog | null>(null);
+  const [projectDevices, setProjectDevices] = useState<ProjectDeviceDto[]>([]);
+  const [isPreparingProjectDevice, setIsPreparingProjectDevice] = useState(false);
+  const [isSavingProjectDevice, setIsSavingProjectDevice] = useState(false);
 
   // Refs carry the latest values into timers, unload handlers and chained
   // async saves without re-creating them.
@@ -456,7 +477,77 @@ export default function EstimateBalanceEditorPage() {
     setGzfTarget(null);
   }
 
-  const isEditingDisabled = !draft || isHistoryBusy;
+  async function handleOpenProjectDevice(groupId: string, rowId: string) {
+    setError(null);
+    setNotice(null);
+    setIsPreparingProjectDevice(true);
+    try {
+      if (!(await saveNow())) {
+        setError(
+          "Die Grobbilanz muss zuerst fehlerfrei gespeichert werden, bevor ein Projektgerät angelegt werden kann."
+        );
+        return;
+      }
+      const current = draftRef.current;
+      const group = current?.groups.find((entry) => entry.id === groupId);
+      const row = group?.rows.find((entry) => entry.id === rowId);
+      if (!group || !row) {
+        setError("Die gewählte Grobbilanz-Zeile ist nicht mehr vorhanden.");
+        return;
+      }
+      const existingDevices = await listProjectDevices(projectId);
+      setProjectDevices(existingDevices);
+      setProjectDeviceDialog({ group, row });
+    } catch (err) {
+      setError(
+        errorMessage(err, "Der Projektgeräte-Dialog konnte nicht vorbereitet werden.")
+      );
+    } finally {
+      setIsPreparingProjectDevice(false);
+    }
+  }
+
+  async function handleCreateProjectDevice(input: CreateProjectDeviceInput) {
+    const revision = revisionRef.current;
+    if (!projectDeviceDialog || revision === null) return;
+    setError(null);
+    setIsSavingProjectDevice(true);
+    try {
+      if (!(await saveNow())) {
+        setError(
+          "Die Grobbilanz muss zuerst fehlerfrei gespeichert werden, bevor das Projektgerät angelegt werden kann."
+        );
+        return;
+      }
+      const currentRevision = revisionRef.current;
+      if (currentRevision === null) return;
+      const result = await createProjectDevice(projectId, input, currentRevision);
+      revisionRef.current = result.history.currentRevision;
+      setHistory(result.history);
+      setProject((currentProject) =>
+        currentProject
+          ? { ...currentProject, currentRevision: result.history.currentRevision }
+          : currentProject
+      );
+      setProjectDevices((current) => [...current, result.projectDevice]);
+      setProjectDeviceDialog(null);
+      setNotice(`Projektgerät „${result.projectDevice.displayName}“ wurde angelegt.`);
+    } catch (err) {
+      if (isRevisionConflictError(err)) {
+        await reloadAll().catch(handleReloadError);
+        setError(
+          "Der Projektstand hat sich zwischenzeitlich geändert. Der aktuelle Stand wurde geladen; bitte das Projektgerät erneut speichern."
+        );
+      } else {
+        setError(errorMessage(err, "Das Projektgerät konnte nicht angelegt werden."));
+      }
+    } finally {
+      setIsSavingProjectDevice(false);
+    }
+  }
+
+  const isEditingDisabled =
+    !draft || isHistoryBusy || isPreparingProjectDevice || isSavingProjectDevice;
   const invalidCount = invalidFieldKeys.size;
   const listHref = `/projects/${projectId}/grobbilanz`;
 
@@ -623,6 +714,9 @@ export default function EstimateBalanceEditorPage() {
                 onChange={handleChange}
                 onEditGroup={(group) => setGroupDialog({ group })}
                 onOpenGzfPicker={(groupId, rowId) => setGzfTarget({ groupId, rowId })}
+                onTakeOverRow={(groupId, rowId) =>
+                  void handleOpenProjectDevice(groupId, rowId)
+                }
                 onValidityChange={handleValidityChange}
                 threePhaseVoltageV={project.threePhaseVoltageV}
               />
@@ -692,10 +786,67 @@ export default function EstimateBalanceEditorPage() {
       {gzfTarget ? (
         <GzfPickerModal onClose={() => setGzfTarget(null)} onSelect={handleSelectGzf} />
       ) : null}
+      {projectDeviceDialog ? (
+        <ProjectDeviceModal
+          context={
+            <EstimateProjectDeviceContext
+              balanceName={draft?.name ?? ""}
+              group={projectDeviceDialog.group}
+              row={projectDeviceDialog.row}
+            />
+          }
+          existingDevices={projectDevices}
+          globalDevices={[]}
+          initialValues={createEstimateProjectDeviceInitialValues(
+            projectDeviceDialog.group,
+            projectDeviceDialog.row
+          )}
+          isSaving={isSavingProjectDevice}
+          onClose={() => setProjectDeviceDialog(null)}
+          onImportGlobal={async () => undefined}
+          onSave={handleCreateProjectDevice}
+        />
+      ) : null}
     </main>
   );
 }
 
+function EstimateProjectDeviceContext({
+  balanceName,
+  group,
+  row,
+}: {
+  balanceName: string;
+  group: EstimateGroupSnapshot;
+  row: EstimateRowSnapshot;
+}) {
+  const originalUnit = row.unit === "area" ? "m²" : "St.";
+  const powerUnit = row.unit === "area" ? "W/m²" : "W";
+  return (
+    <>
+      <div>
+        <strong>Herkunft:</strong> Stand „{balanceName}“, Kostengruppe{" "}
+        {group.costGroup || "ohne Nummer"}.
+      </div>
+      <div>
+        Originalwerte: {formatGermanNumber(row.quantity, 0, 3)} {originalUnit} ×{" "}
+        {formatGermanNumber(row.powerPerUnitW, 0, 3)} {powerUnit}, GZF{" "}
+        {formatGermanNumber(row.simultaneityFactor, 0, 3)}, cos φ{" "}
+        {formatGermanNumber(row.cosPhi, 0, 3)}.
+      </div>
+      <div className="mt-1">
+        {row.unit === "area"
+          ? "Das Projektgerät dient als Vorlage. Für Flächenwerte sind Anzahl und Leistung je Stück manuell einzutragen."
+          : "Das Projektgerät ist eine Vorlage mit Anzahl 1."}{" "}
+        Kategorie bitte prüfen.
+        {row.safetySupply
+          ? " SV ist nur ein Hinweis; die Versorgungsart wird an der Verteilung festgelegt."
+          : ""}
+      </div>
+    </>
+  );
+}
+
 function SaveStatusBadge({
   error,
   invalidCount,
diff --git a/src/frontend/components/project-device-modal.tsx b/src/frontend/components/project-device-modal.tsx
index 27c24d0..0d95223 100644
--- a/src/frontend/components/project-device-modal.tsx
+++ b/src/frontend/components/project-device-modal.tsx
@@ -1,6 +1,6 @@
 "use client";
 
-import React, { FormEvent, useState } from "react";
+import React, { FormEvent, type ReactNode, useState } from "react";
 import type {
   CreateProjectDeviceInput,
   GlobalDeviceDto,
@@ -14,10 +14,20 @@ import {
 } from "../../shared/constants/circuit-group";
 import { GzfPickerModal } from "./gzf-picker-modal";
 
+export type ProjectDeviceModalInitialValues = Omit<
+  Partial<CreateProjectDeviceInput>,
+  "quantity" | "powerPerUnit"
+> & {
+  quantity?: number | null;
+  powerPerUnit?: number | null;
+};
+
 interface ProjectDeviceModalProps {
+  context?: ReactNode;
+  existingDevices?: ReadonlyArray<Pick<ProjectDeviceDto, "name" | "displayName">>;
   globalDevices: GlobalDeviceDto[];
   initialDevice?: ProjectDeviceDto;
-  initialValues?: Partial<CreateProjectDeviceInput>;
+  initialValues?: ProjectDeviceModalInitialValues;
   isSaving: boolean;
   onClose: () => void;
   onImportGlobal: (globalDeviceId: string) => Promise<void>;
@@ -25,6 +35,8 @@ interface ProjectDeviceModalProps {
 }
 
 export function ProjectDeviceModal({
+  context,
+  existingDevices = [],
   globalDevices,
   initialDevice,
   initialValues,
@@ -36,6 +48,11 @@ export function ProjectDeviceModal({
   const [values, setValues] = useState(() => toFormValues(initialDevice, initialValues));
   const [selectedGlobalDeviceId, setSelectedGlobalDeviceId] = useState("");
   const [isGzfPickerOpen, setIsGzfPickerOpen] = useState(false);
+  const hasDuplicateName = hasExistingProjectDeviceName(
+    values.name,
+    values.displayName,
+    existingDevices
+  );
 
   function update(key: keyof typeof values, value: string) {
     setValues((current) => ({ ...current, [key]: value }));
@@ -79,6 +96,17 @@ export function ProjectDeviceModal({
       submitLabel={initialDevice ? "Änderungen speichern" : "Gerät anlegen"}
       title={initialDevice ? "Projektgerät bearbeiten" : "Projektgerät hinzufügen"}
     >
+      {context ? (
+        <div className="alert alert-info small" role="note">
+          {context}
+        </div>
+      ) : null}
+      {hasDuplicateName ? (
+        <div className="alert alert-warning small" role="status">
+          Ein Projektgerät mit gleichem internen Namen oder Anzeigenamen ist bereits vorhanden.
+          Das Anlegen bleibt möglich.
+        </div>
+      ) : null}
       {!initialDevice && globalDevices.length > 0 ? (
         <div className="border rounded p-3 mb-4">
           <label className="form-label" htmlFor="global-project-device">
@@ -287,7 +315,7 @@ function NumberField({
 
 function toFormValues(
   device?: ProjectDeviceDto,
-  initialValues?: Partial<CreateProjectDeviceInput>
+  initialValues?: ProjectDeviceModalInitialValues
 ) {
   return {
     name: device?.name ?? initialValues?.name ?? "",
@@ -295,14 +323,24 @@ function toFormValues(
     connectionKind: device?.connectionKind ?? initialValues?.connectionKind ?? "",
     costGroup: device?.costGroup ?? initialValues?.costGroup ?? "",
     category: device?.category ?? initialValues?.category ?? "single_phase",
-    quantity: String(device?.quantity ?? initialValues?.quantity ?? 1),
-    powerPerUnit: String(device?.powerPerUnit ?? initialValues?.powerPerUnit ?? 0.1),
+    quantity: toInitialNumber(device?.quantity, initialValues?.quantity, 1),
+    powerPerUnit: toInitialNumber(device?.powerPerUnit, initialValues?.powerPerUnit, 0.1),
     simultaneityFactor: String(device?.simultaneityFactor ?? initialValues?.simultaneityFactor ?? 1),
     cosPhi: String(device?.cosPhi ?? initialValues?.cosPhi ?? 1),
     remark: device?.remark ?? initialValues?.remark ?? "",
   };
 }
 
+function toInitialNumber(
+  deviceValue: number | undefined,
+  initialValue: number | null | undefined,
+  fallback: number
+) {
+  if (deviceValue !== undefined) return String(deviceValue);
+  if (initialValue === null) return "";
+  return String(initialValue ?? fallback);
+}
+
 function optionalString(value: string) {
   return value.trim() || undefined;
 }
@@ -315,7 +353,29 @@ function parseDecimal(value: string) {
   return Number(value.trim().replace(",", "."));
 }
 
-function isNumberInRange(value: string, min: number, max = Number.POSITIVE_INFINITY) {
+export function isProjectDeviceNumberInRange(
+  value: string,
+  min: number,
+  max = Number.POSITIVE_INFINITY
+) {
+  if (!value.trim()) return false;
   const parsed = parseDecimal(value);
   return Number.isFinite(parsed) && parsed >= min && parsed <= max;
 }
+
+const isNumberInRange = isProjectDeviceNumberInRange;
+
+export function hasExistingProjectDeviceName(
+  name: string,
+  displayName: string,
+  existingDevices: ReadonlyArray<Pick<ProjectDeviceDto, "name" | "displayName">>
+) {
+  const candidates = new Set(
+    [name, displayName].map((value) => value.trim().toLocaleLowerCase("de-DE")).filter(Boolean)
+  );
+  return existingDevices.some((device) =>
+    [device.name, device.displayName].some((value) =>
+      candidates.has(value.trim().toLocaleLowerCase("de-DE"))
+    )
+  );
+}
diff --git a/src/frontend/estimate-balance/estimate-balance-sheet.tsx b/src/frontend/estimate-balance/estimate-balance-sheet.tsx
index 07dc19c..4bfa927 100644
--- a/src/frontend/estimate-balance/estimate-balance-sheet.tsx
+++ b/src/frontend/estimate-balance/estimate-balance-sheet.tsx
@@ -1,7 +1,7 @@
 "use client";
 
 import type { ReactNode } from "react";
-import { ArrowDown, ArrowUp, Pencil, Plus, Trash2 } from "lucide-react";
+import { ArrowDown, ArrowUp, PackagePlus, Pencil, Plus, Trash2 } from "lucide-react";
 import {
   calculateEstimateBalance,
   calculateEstimateRow,
@@ -46,6 +46,7 @@ interface EstimateBalanceSheetProps {
   onChange: EstimateBalanceUpdate;
   onEditGroup: (group: EstimateGroupSnapshot) => void;
   onOpenGzfPicker: (groupId: string, rowId: string) => void;
+  onTakeOverRow: (groupId: string, rowId: string) => void;
   onValidityChange: (fieldKey: string, isValid: boolean) => void;
   threePhaseVoltageV: number;
 }
@@ -178,6 +179,7 @@ function EstimateRowLine({
   group,
   onChange,
   onOpenGzfPicker,
+  onTakeOverRow,
   onValidityChange,
   row,
   rowIndex,
@@ -186,6 +188,7 @@ function EstimateRowLine({
   group: EstimateGroupSnapshot;
   onChange: EstimateBalanceUpdate;
   onOpenGzfPicker: (groupId: string, rowId: string) => void;
+  onTakeOverRow: (groupId: string, rowId: string) => void;
   onValidityChange: (fieldKey: string, isValid: boolean) => void;
   row: EstimateRowSnapshot;
   rowIndex: number;
@@ -348,14 +351,24 @@ function EstimateRowLine({
         />
       </td>
       <td className="estimate-actions-cell estimate-no-print">
-        <IconButton
-          disabled={disabled}
-          label={`Zeile löschen (${rowLabel})`}
-          onClick={() => onChange((balance) => removeEstimateRow(balance, group.id, row.id))}
-          variant="danger"
-        >
-          <Trash2 aria-hidden="true" size={13} />
-        </IconButton>
+        <div className="estimate-row-actions">
+          <IconButton
+            disabled={disabled}
+            label={`Als Projektgerät übernehmen (${rowLabel})`}
+            onClick={() => onTakeOverRow(group.id, row.id)}
+            variant="primary"
+          >
+            <PackagePlus aria-hidden="true" size={13} />
+          </IconButton>
+          <IconButton
+            disabled={disabled}
+            label={`Zeile löschen (${rowLabel})`}
+            onClick={() => onChange((balance) => removeEstimateRow(balance, group.id, row.id))}
+            variant="danger"
+          >
+            <Trash2 aria-hidden="true" size={13} />
+          </IconButton>
+        </div>
       </td>
     </tr>
   );
@@ -373,6 +386,7 @@ export function EstimateBalanceSheet({
   onChange,
   onEditGroup,
   onOpenGzfPicker,
+  onTakeOverRow,
   onValidityChange,
   threePhaseVoltageV,
 }: EstimateBalanceSheetProps) {
@@ -546,6 +560,7 @@ export function EstimateBalanceSheet({
                   key={row.id}
                   onChange={onChange}
                   onOpenGzfPicker={onOpenGzfPicker}
+                  onTakeOverRow={onTakeOverRow}
                   onValidityChange={onValidityChange}
                   row={row}
                   rowIndex={rowIndex}
diff --git a/src/frontend/estimate-balance/estimate-project-device-prefill.ts b/src/frontend/estimate-balance/estimate-project-device-prefill.ts
new file mode 100644
index 0000000..4ef9b52
--- /dev/null
+++ b/src/frontend/estimate-balance/estimate-project-device-prefill.ts
@@ -0,0 +1,51 @@
+import type { CreateProjectDeviceInput } from "../types";
+import type {
+  EstimateGroupSnapshot,
+  EstimateRowSnapshot,
+} from "../../shared/estimate-balance/estimate-balance";
+
+export type EstimateProjectDeviceInitialValues = Omit<
+  Partial<CreateProjectDeviceInput>,
+  "quantity" | "powerPerUnit"
+> & {
+  quantity?: number | null;
+  powerPerUnit?: number | null;
+};
+
+const connectionLabels = {
+  fixed: "Festanschluss",
+  socket: "Steckdose",
+} as const;
+
+/**
+ * Builds the editable ProjectDevice proposal for one estimate row. Area rows
+ * deliberately leave quantity and power blank because W/m² has no equivalent
+ * in the current ProjectDevice model.
+ */
+export function createEstimateProjectDeviceInitialValues(
+  group: Pick<EstimateGroupSnapshot, "costGroup">,
+  row: Pick<
+    EstimateRowSnapshot,
+    | "name"
+    | "unit"
+    | "connection"
+    | "powerPerUnitW"
+    | "simultaneityFactor"
+    | "cosPhi"
+    | "remark"
+  >
+): EstimateProjectDeviceInitialValues {
+  const name = row.name.trim();
+  return {
+    name,
+    displayName: name,
+    category: "single_phase",
+    connectionKind: row.connection ? connectionLabels[row.connection] : undefined,
+    costGroup: group.costGroup || undefined,
+    quantity: row.unit === "area" ? null : 1,
+    powerPerUnit: row.unit === "area" ? null : row.powerPerUnitW / 1000,
+    simultaneityFactor: row.simultaneityFactor,
+    cosPhi: row.cosPhi,
+    remark: row.remark ?? undefined,
+  };
+}
diff --git a/tests/estimate-balance-frontend.test.ts b/tests/estimate-balance-frontend.test.ts
index ed5f4c7..7604de2 100644
--- a/tests/estimate-balance-frontend.test.ts
+++ b/tests/estimate-balance-frontend.test.ts
@@ -28,6 +28,7 @@ import {
   getTodayIsoDate,
   parseGermanDecimal,
 } from "../src/frontend/estimate-balance/estimate-balance-format.js";
+import { createEstimateProjectDeviceInitialValues } from "../src/frontend/estimate-balance/estimate-project-device-prefill.js";
 import {
   ApiRequestError,
   createEstimateBalance,
@@ -264,6 +265,55 @@ describe("estimate balance document editing", () => {
   });
 });
 
+describe("estimate row to project device prefill", () => {
+  it("maps a piece row to one reusable project-device template", () => {
+    const balance = sampleBalance();
+    const group = balance.groups[0]!;
+    const row = {
+      ...group.rows[0]!,
+      name: " Hebeanlage ",
+      quantity: 4,
+      connection: "fixed" as const,
+      powerPerUnitW: 1250,
+      simultaneityFactor: 0.8,
+      cosPhi: 0.9,
+      remark: "bauseits",
+    };
+
+    assert.deepEqual(createEstimateProjectDeviceInitialValues(group, row), {
+      name: "Hebeanlage",
+      displayName: "Hebeanlage",
+      category: "single_phase",
+      connectionKind: "Festanschluss",
+      costGroup: "410",
+      quantity: 1,
+      powerPerUnit: 1.25,
+      simultaneityFactor: 0.8,
+      cosPhi: 0.9,
+      remark: "bauseits",
+    });
+  });
+
+  it("leaves quantity and power blank for an area row", () => {
+    const balance = sampleBalance();
+    const group = balance.groups[1]!;
+    const row = {
+      ...createEstimateRow(0, () => "area-row"),
+      name: "Bürofläche",
+      unit: "area" as const,
+      connection: "socket" as const,
+      quantity: 250,
+      powerPerUnitW: 15,
+    };
+
+    const initial = createEstimateProjectDeviceInitialValues(group, row);
+    assert.equal(initial.quantity, null);
+    assert.equal(initial.powerPerUnit, null);
+    assert.equal(initial.connectionKind, "Steckdose");
+    assert.equal(initial.costGroup, "440");
+  });
+});
+
 describe("estimate balance saving", () => {
   it("builds the trimmed server document with null for empty optional texts", () => {
     let balance = sampleBalance();
diff --git a/tests/project-version-history.test.ts b/tests/project-version-history.test.ts
index 59a2aac..4e85d41 100644
--- a/tests/project-version-history.test.ts
+++ b/tests/project-version-history.test.ts
@@ -3,7 +3,11 @@ import { describe, it } from "node:test";
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import { ProjectVersionHistory } from "../src/frontend/components/project-version-history.js";
-import { ProjectDeviceModal } from "../src/frontend/components/project-device-modal.js";
+import {
+  hasExistingProjectDeviceName,
+  isProjectDeviceNumberInRange,
+  ProjectDeviceModal,
+} from "../src/frontend/components/project-device-modal.js";
 import { ProjectSettingsModal } from "../src/frontend/components/project-settings-modal.js";
 import type {
   ProjectRevisionSummaryDto,
@@ -324,6 +328,42 @@ describe("project device modal presentation", () => {
     assert.match(markup, /1-phasig/);
     assert.match(markup, /3-phasig/);
   });
+
+  it("rejects empty required numbers while keeping zero valid", () => {
+    assert.equal(isProjectDeviceNumberInRange("", 0), false);
+    assert.equal(isProjectDeviceNumberInRange("   ", 0), false);
+    assert.equal(isProjectDeviceNumberInRange("0", 0), true);
+    assert.equal(isProjectDeviceNumberInRange("0,8", 0, 1), true);
+  });
+
+  it("renders blank area values as invalid and warns about duplicate names", () => {
+    const markup = renderToStaticMarkup(
+      createElement(ProjectDeviceModal, {
+        existingDevices: [{ name: "Bürofläche", displayName: "Bürofläche" }],
+        globalDevices: [],
+        initialValues: {
+          name: "Bürofläche",
+          displayName: "Bürofläche",
+          quantity: null,
+          powerPerUnit: null,
+        },
+        isSaving: false,
+        onClose: () => undefined,
+        onImportGlobal: async () => undefined,
+        onSave: async () => undefined,
+      })
+    );
+    assert.match(markup, /gleichem internen Namen oder Anzeigenamen/);
+    assert.match(markup, /id="device-quantity"[^>]*value=""/);
+    assert.match(markup, /id="device-power"[^>]*value=""/);
+    assert.match(markup, /<button class="btn btn-primary" disabled="" type="submit">/);
+    assert.equal(
+      hasExistingProjectDeviceName(" bürofläche ", "", [
+        { name: "BÜROFLÄCHE", displayName: "Fläche" },
+      ]),
+      true
+    );
+  });
 });
 
 describe("project version history API", () => {

From dce31ee14306dd5b8dfc4e24ff7959c59c60395d Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 20:00:03 +0200
Subject: [PATCH 32/60] Add optional room areas

---
 AGENTS.md                                     |   25 +-
 docs/building-structure.md                    |   45 +-
 docs/circuit-list-editor-api.md               |   23 +-
 docs/current-architecture.md                  |   13 +-
 .../projects/[projectId]/struktur/page.tsx    |   85 +-
 .../migrations/0011_glossy_norman_osborn.sql  |    1 +
 src/db/migrations/meta/0011_snapshot.json     | 2931 +++++++++++++++++
 src/db/migrations/meta/_journal.json          |    7 +
 ...on-structure-project-command.repository.ts |   29 +-
 src/db/schema/rooms.ts                        |    4 +-
 ...ocation-structure-project-command.model.ts |  158 +-
 .../models/project-state-snapshot.model.ts    |   69 +-
 src/frontend/components/room-modal.tsx        |   36 +-
 src/frontend/types.ts                         |    2 +
 src/frontend/utils/building-structure.ts      |   66 +
 src/frontend/utils/room-area.ts               |   30 +
 src/server/controllers/room.controller.ts     |    1 +
 .../validation/project-structure.schemas.ts   |    2 +
 tests/building-structure-view.test.ts         |   46 +-
 tests/print-view-migration.test.ts            |    6 +
 ...ructure-project-command.repository.test.ts |   71 +-
 tests/project-snapshot.repository.test.ts     |    6 +
 ...t-state-restore-command.repository.test.ts |    1 +
 tests/project-state-snapshot.test.ts          |   29 +-
 tests/revit-csv-frontend-api.test.ts          |    2 +-
 tests/room-area.test.ts                       |   59 +
 26 files changed, 3669 insertions(+), 78 deletions(-)
 create mode 100644 src/db/migrations/0011_glossy_norman_osborn.sql
 create mode 100644 src/db/migrations/meta/0011_snapshot.json
 create mode 100644 src/frontend/utils/room-area.ts
 create mode 100644 tests/room-area.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index eae68d2..b0b28ff 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -284,14 +284,16 @@ not change the project revision or undo/redo stacks. Restoring a server-stored
 snapshot verifies its checksum and the current-state hash, replaces supported
 project data atomically and records a new `restore` revision with a complete
 inverse command. Restore can therefore be undone and redone after a restart.
-Current snapshot schema version 7 additionally stores the project buildings
-and `floors[].buildingId` (see `docs/building-structure.md`); versions 1 to 6
-are upgraded with no buildings and `buildingId = null`. Version 6 stores the
+Current snapshot schema version 8 additionally stores the optional net room
+area `rooms[].areaM2` (see `docs/building-structure.md`); versions 1 to 7 are
+upgraded with `areaM2 = null`. Version 7 stores the project buildings and
+`floors[].buildingId`; versions 1 to 6 are upgraded with no buildings and
+`buildingId = null`. Version 6 stores the
 distribution-board info fields `boardNumber`, `location`, `fedFrom` and
 `remark` and the project cover fields `siteAddress`, `workStage`,
 `projectLead` and `projectEditor`; all older supported versions are upgraded
 with `null` for these fields.
-Stored named and automatic snapshots of every supported version (1 to 7)
+Stored named and automatic snapshots of every supported version (1 to 8)
 remain restorable; they are upgraded while parsing. Version 5 stores
 the manual quantity share of every CircuitDeviceRow. Version 4 snapshots are upgraded with
 `manualQuantity = quantity`; they already contain the complete confirmed
@@ -307,7 +309,7 @@ project graph.
 Project-wide Revit CSV configuration uses
 `external-csv-configuration.update`. Its complete expected/target snapshot is
 persisted through the shared project-command transaction, so create, update,
-delete, Undo and Redo are revision-safe. Snapshot schema 5-7, restore and portable
+delete, Undo and Redo are revision-safe. Snapshot schema 5-8, restore and portable
 project duplication preserve the configuration; duplication remaps its internal
 id and project link.
 The project page exposes the Revit CSV modal. It edits the complete
@@ -481,10 +483,15 @@ These fields are intended to be prefillable from Revit parameters later, but
 only through the Phase 14 rules (preview, explicit confirmation, no silent
 overwrite).
 Floor and room setup uses persistent insert, update and delete commands with
-complete stable snapshots. Their inverses remove or restore only unchanged records and
-reject floors with assigned rooms/distribution boards or rooms referenced by
-device rows. All write routes require `expectedRevision` and return the updated
-history state.
+complete stable snapshots. Room command schema version 2 stores the optional,
+finite, non-negative net room area `areaM2`; persisted version-1 commands are
+upgraded with `areaM2 = null` and exact record comparison prevents them from
+silently overwriting a newer area. Room areas are maintained manually, shown
+with two decimals and summarized per floor and building with a separate missing
+count. Revit import and W/m² use remain follow-up work. Command inverses remove
+or restore only unchanged records and reject floors with
+assigned rooms/distribution boards or rooms referenced by device rows. All
+write routes require `expectedRevision` and return the updated history state.
 
 Required operations:
 
diff --git a/docs/building-structure.md b/docs/building-structure.md
index db7f062..21059b4 100644
--- a/docs/building-structure.md
+++ b/docs/building-structure.md
@@ -13,6 +13,7 @@ zugeordneten Etagen lassen sich nicht löschen.
 |---|---|---|
 | `buildings` | `id`, `project_id` (FK, cascade), `name`, `sort_order` | Gebäude eines Projekts |
 | `floors` | `building_id` (nullable FK → `buildings`, `ON DELETE set null`) | optionales übergeordnetes Gebäude |
+| `rooms` | `area_m2` (nullable `REAL`) | optional gepflegte Netto-Raumfläche in m² |
 
 Migration `0009_buildings`. Bestehende Etagen behalten `building_id = null` und
 erscheinen in der Oberfläche als „Ohne Gebäude“. Es gibt keine Zwangsmigration
@@ -20,6 +21,11 @@ und kein automatisch angelegtes Standardgebäude. Vor dem Anwenden der Migration
 auf eine bestehende Datenbank ist wie bei jeder Schemamigration eine separate
 Datenbanksicherung anzulegen.
 
+Migration `0011_glossy_norman_osborn` ergänzt ausschließlich das nullable Feld
+`rooms.area_m2`. Bestehende Räume behalten damit eine unbekannte Fläche. Vor
+dem Anwenden auf eine bestehende Datenbank ist ebenfalls eine separate
+Datenbanksicherung erforderlich.
+
 ## Befehle, Undo/Redo
 
 Alle Änderungen laufen über die bestehende Orts-Struktur
@@ -41,17 +47,22 @@ persistentem Undo/Redo:
   Vorwärts- und Inversbefehle sind Version 2. Das ist bei linearer Historie
   exakt: Wird ein Gebäude später zugeordnet, liegt dieser neuere Befehl im
   Undo-Stapel vor dem alten Befehl und wird zuerst zurückgenommen.
-- Raumbefehle bleiben unverändert (Version 1).
+- Raumbefehle `project-room.insert/.update/.delete` haben seit Schema-Version
+  **2** das Feld `areaM2`. Version-1-Befehle werden beim Einlesen mit
+  `areaM2 = null` hochgestuft. Vor einem alten Update oder Delete wird weiterhin
+  der vollständige erwartete Datensatz verglichen; eine inzwischen vorhandene
+  Fläche kann deshalb nicht unbemerkt gelöscht werden.
 
 ## Snapshots und Transfer
 
-Projekt-Snapshot-Schema **7** enthält `buildings` und `floors[].buildingId`.
-Alle älteren unterstützten Versionen (1–6) werden beim Einlesen mit leerer
-Gebäudeliste und `buildingId = null` hochgestuft; gespeicherte Sicherungspunkte
-bleiben wiederherstellbar. Die Relationen werden geprüft (Gebäude gehört zum
-Projekt, `buildingId` verweist auf ein Gebäude des Snapshots). Restore löscht
-und schreibt Gebäude zusammen mit den Etagen; der Projekt-Transfer vergibt neue
-Gebäude-IDs und stellt die Etagenverweise um.
+Projekt-Snapshot-Schema **8** enthält zusätzlich `rooms[].areaM2`. Version 7
+wird mit `areaM2 = null` hochgestuft; die älteren unterstützten Versionen 1–6
+werden außerdem mit leerer Gebäudeliste und `buildingId = null` hochgestuft.
+Gespeicherte Sicherungspunkte bleiben wiederherstellbar. Die Relationen werden
+geprüft (Gebäude gehört zum Projekt, `buildingId` verweist auf ein Gebäude des
+Snapshots). Restore und Projekttransfer erhalten die Raumfläche. Das portable
+Transferformat bleibt Version 2, weil es den versionierten Projektsnapshot
+bereits einbettet; beim Duplizieren werden nur IDs und Relationen umgesetzt.
 
 ## API
 
@@ -63,6 +74,10 @@ Gebäude-IDs und stellt die Etagenverweise um.
 - `POST/PUT /api/projects/:projectId/floors[/:floorId]` akzeptieren zusätzlich
   optional `buildingId` (`string | null`). Fehlt das Feld, bleibt beim Bearbeiten
   das bisherige Gebäude erhalten; ältere Clients funktionieren unverändert.
+- `POST/PUT /api/projects/:projectId/rooms[/:roomId]` akzeptieren zusätzlich
+  optional `areaM2` (`number | null`, endlich und ≥ 0). Beim Anlegen bedeutet
+  ein fehlendes Feld `null`; beim Bearbeiten bleibt die vorhandene Fläche
+  erhalten, wenn das Feld fehlt.
 
 ## Oberfläche
 
@@ -74,10 +89,24 @@ nur dessen Etagen, Klick auf eine Etage nur deren Räume, „Alle“ hebt den Fi
 auf. Hinzufügen, Bearbeiten und Löschen laufen über Icon-Buttons wie in der
 Stromkreisliste.
 
+Der Raumdialog pflegt die optionale **Fläche [m²]** mit deutscher
+Dezimaltrennzeichen-Eingabe. Gemeint ist die Netto-Raumfläche, wie sie der
+Revit-Raumparameter „Fläche“ liefert, nicht eine Flächenart nach DIN 277. Die
+Fläche wird ohne fachliche Rundung gespeichert und mit zwei Nachkommastellen
+angezeigt. Die Gebäudestruktur zeigt die Fläche je Raum sowie Summen je Etage,
+je Gebäude, „Ohne Etage“ und „Ohne Gebäude“. Fehlende Flächen werden nicht als
+Nullfläche ausgegeben, sondern separat gezählt, damit Teilsummen erkennbar
+bleiben.
+
 ## Offen
 
 - Revit: Eine Übernahme des Gebäudes aus Revit ist derzeit nicht geplant. Die
   Revit-Arbeit ist insgesamt zurückgestellt und läuft später über die
   Linear-CSV; das Modell steht einer späteren CSV-Zuordnung nicht im Weg.
+- Raumflächen werden derzeit ausschließlich manuell gepflegt. Ein späterer
+  Revit-Abgleich muss die Phase-14-Regeln mit externem Modellzustand, Vorschau
+  und ausdrücklicher Bestätigung einhalten.
+- Eine W/m²-Auswertung oder Übernahme der Raumfläche in Flächenlasten ist nicht
+  Teil dieser Funktion; das ist Folgethema von Issue #20.
 - Sortierung von Gebäuden per Drag-and-drop ist noch nicht umgesetzt; neue
   Gebäude werden hinten angehängt.
diff --git a/docs/circuit-list-editor-api.md b/docs/circuit-list-editor-api.md
index e528f6e..c9cd2b7 100644
--- a/docs/circuit-list-editor-api.md
+++ b/docs/circuit-list-editor-api.md
@@ -67,6 +67,12 @@ Prüfsumme; Ersetzen übernimmt die Grobbilanzen atomar und mit Undo/Redo,
 Duplizieren vergibt neue IDs. Transferformat 1 bleibt ohne Grobbilanzen
 importierbar.
 
+Das aktuelle Projekt-Snapshot-Schema 8 enthält außerdem die optionale
+Netto-Raumfläche `rooms[].areaM2`. Snapshot-Versionen 1–7 werden dafür mit
+`areaM2 = null` hochgestuft. Restore, Export und Import erhalten vorhandene
+Flächen; eine eigene Transferformat-Version ist nicht nötig, weil Format 2 den
+versionierten Projektsnapshot einbettet.
+
 The public dispatcher supports the Circuit and CircuitDeviceRow commands
 `circuit.update`, `circuit.insert`, `circuit.delete`,
 `circuit-device-row.update`, `circuit-device-row.insert`,
@@ -297,19 +303,26 @@ commands. Endpoints, payloads and calculation rules: `docs/estimate-balance.md`.
   - rejects floors with assigned rooms or distribution boards
 - `POST /projects/:projectId/rooms`
   - body:
-    `{ "floorId": "floor_1", "roomNumber": "001", "roomName": "Technik", "expectedRevision": 14 }`
-  - executes `project-room.insert` with a stable room id; `floorId` is optional
-    and must belong to the project when present
+    `{ "floorId": "floor_1", "roomNumber": "001", "roomName": "Technik", "areaM2": 18.75, "expectedRevision": 14 }`
+  - executes `project-room.insert` command version 2 with a stable room id;
+    `floorId` and `areaM2` are optional. An omitted or explicit `null` area
+    creates a room without area; a value must be finite and non-negative.
   - response: `{ "room": { ... }, "revision": { ... }, "history": { ... } }`
 - `PUT /projects/:projectId/rooms/:roomId`
   - body:
-    `{ "floorId": null, "roomNumber": "101", "roomName": "Büro", "expectedRevision": 16 }`
-  - updates number, name and optional floor as one persistent command
+    `{ "floorId": null, "roomNumber": "101", "roomName": "Büro", "areaM2": null, "expectedRevision": 16 }`
+  - updates number, name, optional floor and area as one persistent version-2
+    command. If `areaM2` is omitted, the current area is retained; `null`
+    explicitly clears it.
 - `DELETE /projects/:projectId/rooms/:roomId`
   - body: `{ "expectedRevision": 17 }`
   - rejects rooms referenced by device rows
 - Persistent Undo/Redo restores exact previous and target records without
   silently clearing foreign keys.
+- Stored version-1 room commands remain executable and are upgraded with
+  `areaM2 = null`. Exact expected-record checks reject an old update or delete
+  if a newer command has added an area, so legacy history cannot silently
+  erase it.
 - Stale revisions return `409 PROJECT_REVISION_CONFLICT`.
 
 ### Tree Endpoint
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 2887e8a..baf6883 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -464,8 +464,10 @@ Derselbe Befehl versioniert die Felder der Verteiler-Infokarte
 Infokarte liegt im Bearbeiten-Dialog der Verteilung; die Werte sind lokale
 Planungswerte und sollen später über den Revit-Abgleich nur nach Vorschau und
 ausdrücklicher Bestätigung vorbelegt werden. `fedFrom` ist vorerst Freitext.
-Snapshot-Schema 7 enthält zusätzlich die Gebäude und die Gebäudezuordnung
-der Etagen; ältere Versionen werden ohne Gebäude hochgestuft.
+Snapshot-Schema 8 enthält zusätzlich die optionale Netto-Raumfläche
+`rooms[].areaM2`; Versionen 1–7 werden dafür mit `null` hochgestuft.
+Snapshot-Schema 7 enthält die Gebäude und die Gebäudezuordnung der Etagen;
+ältere Versionen werden ohne Gebäude hochgestuft.
 Snapshot-Schema 6 enthält diese Felder und die Deckblattangaben des
 Projekts; ältere Versionen werden mit `null`
 hochgestuft. Snapshot-Schema 5 enthält zusätzlich den manuellen Mengenanteil jeder
@@ -483,7 +485,12 @@ Baseline-Version 1 wird zusätzlich mit `isPublicBuilding = false` hochgestuft;
 dieser Baseline werden nicht eingelesen.
 Persistente Insert-, Update- und Delete-Commands versionieren Anlage,
 Bearbeitung und Löschung von Geschossen und Räumen mit stabilen UUIDs und
-exakten Vorher-/Nachher-Snapshots. Ein Geschoss wird nur
+exakten Vorher-/Nachher-Snapshots. Raumbefehle verwenden Version 2 und führen
+die nullable, nicht negative Netto-Raumfläche `areaM2`; Version-1-Befehle
+werden mit `null` hochgestuft und bleiben durch den vollständigen
+Snapshotvergleich konfliktfest. Der Raumdialog pflegt die Fläche manuell mit
+deutscher Dezimaleingabe, die Gebäudestruktur zeigt zwei Nachkommastellen sowie
+Summen und die Anzahl fehlender Flächen je Etage und Gebäude. Ein Geschoss wird nur
 entfernt, solange ihm weder ein Raum noch eine Verteilung zugeordnet wurde. Ein
 Raum wird nur entfernt, solange keine CircuitDeviceRow auf ihn verweist. Alle
 Schreibendpunkte verlangen `expectedRevision` und liefern den aktualisierten
diff --git a/src/app/projects/[projectId]/struktur/page.tsx b/src/app/projects/[projectId]/struktur/page.tsx
index 5b207c8..3cefa62 100644
--- a/src/app/projects/[projectId]/struktur/page.tsx
+++ b/src/app/projects/[projectId]/struktur/page.tsx
@@ -48,13 +48,17 @@ import {
   filterRooms,
   groupFloorsByBuilding,
   hasFloorsWithoutBuilding,
+  hasRoomsWithoutFloor,
   normalizeBuildingSelection,
   normalizeFloorSelection,
   showsRoomsWithoutFloorEntry,
+  summarizeRoomAreas,
+  type RoomAreaSummary,
   type StructureSelection,
 } from "../../../../frontend/utils/building-structure";
 import { FormModal } from "../../../../frontend/components/form-modal";
 import { RoomModal } from "../../../../frontend/components/room-modal";
+import { formatRoomArea } from "../../../../frontend/utils/room-area";
 
 const BUILDING_HAS_FLOORS_MESSAGE =
   "Das Gebäude kann nicht gelöscht werden, solange Etagen zugeordnet sind.";
@@ -68,6 +72,23 @@ function formatCount(count: number, singular: string, plural: string) {
   return `${count} ${count === 1 ? singular : plural}`;
 }
 
+function formatAreaSummary(summary: RoomAreaSummary) {
+  return `${formatRoomArea(summary.areaM2)} m² · ${formatCount(
+    summary.missingAreaCount,
+    "Raum ohne Fläche",
+    "Räume ohne Fläche"
+  )}`;
+}
+
+function formatStructureMeta(
+  count: number,
+  singular: string,
+  plural: string,
+  summary: RoomAreaSummary
+) {
+  return `${formatCount(count, singular, plural)} · ${formatAreaSummary(summary)}`;
+}
+
 function compareRooms(left: RoomDto, right: RoomDto) {
   return (
     left.roomNumber.localeCompare(right.roomNumber, "de", { numeric: true }) ||
@@ -307,7 +328,25 @@ export default function BuildingStructurePage() {
     () => countRoomsByFloor(rooms, floors),
     [floors, rooms]
   );
-  const showUnassignedBuilding = hasFloorsWithoutBuilding(floors, buildings);
+  const areaSummaries = useMemo(
+    () => summarizeRoomAreas(rooms, floors, buildings),
+    [buildings, floors, rooms]
+  );
+  const emptyAreaSummary: RoomAreaSummary = {
+    areaM2: 0,
+    roomCount: 0,
+    missingAreaCount: 0,
+  };
+  const selectedBuildingAreaSummary =
+    effectiveBuildingSelection === ALL_SELECTION
+      ? areaSummaries.total
+      : areaSummaries.byBuilding.get(
+          effectiveBuildingSelection === UNASSIGNED_SELECTION
+            ? null
+            : effectiveBuildingSelection
+        ) ?? emptyAreaSummary;
+  const showUnassignedBuilding =
+    hasFloorsWithoutBuilding(floors, buildings) || hasRoomsWithoutFloor(rooms, floors);
   const showUnassignedFloor = showsRoomsWithoutFloorEntry(
     rooms,
     floors,
@@ -435,7 +474,8 @@ export default function BuildingStructurePage() {
       editingRoom &&
       editingRoom.roomNumber === input.roomNumber.trim() &&
       editingRoom.roomName === input.roomName.trim() &&
-      editingRoom.floorId === (input.floorId || null)
+      editingRoom.floorId === (input.floorId || null) &&
+      editingRoom.areaM2 === input.areaM2
     ) {
       setDialog(null);
       return;
@@ -536,7 +576,12 @@ export default function BuildingStructurePage() {
           <StructureEntry
             isSelected={effectiveBuildingSelection === ALL_SELECTION}
             label="Alle"
-            meta={formatCount(floors.length, "Etage", "Etagen")}
+            meta={formatStructureMeta(
+              floors.length,
+              "Etage",
+              "Etagen",
+              areaSummaries.total
+            )}
             onSelect={() => selectBuilding(ALL_SELECTION)}
           />
           {buildings.map((building) => (
@@ -553,10 +598,11 @@ export default function BuildingStructurePage() {
               isSelected={effectiveBuildingSelection === building.id}
               key={building.id}
               label={building.name}
-              meta={formatCount(
+              meta={formatStructureMeta(
                 floorCountByBuilding.get(building.id) ?? 0,
                 "Etage",
-                "Etagen"
+                "Etagen",
+                areaSummaries.byBuilding.get(building.id) ?? emptyAreaSummary
               )}
               onSelect={() => selectBuilding(building.id)}
             />
@@ -565,10 +611,11 @@ export default function BuildingStructurePage() {
             <StructureEntry
               isSelected={effectiveBuildingSelection === UNASSIGNED_SELECTION}
               label={<em>{UNASSIGNED_BUILDING_LABEL}</em>}
-              meta={formatCount(
+              meta={formatStructureMeta(
                 floorCountByBuilding.get(null) ?? 0,
                 "Etage",
-                "Etagen"
+                "Etagen",
+                areaSummaries.byBuilding.get(null) ?? emptyAreaSummary
               )}
               onSelect={() => selectBuilding(UNASSIGNED_SELECTION)}
             />
@@ -591,7 +638,12 @@ export default function BuildingStructurePage() {
           <StructureEntry
             isSelected={effectiveFloorSelection === ALL_SELECTION}
             label="Alle"
-            meta={formatCount(roomsInBuildingSelection, "Raum", "Räume")}
+            meta={formatStructureMeta(
+              roomsInBuildingSelection,
+              "Raum",
+              "Räume",
+              selectedBuildingAreaSummary
+            )}
             onSelect={() => setFloorSelection(ALL_SELECTION)}
           />
           {visibleFloorGroups.map((group) => (
@@ -613,10 +665,11 @@ export default function BuildingStructurePage() {
                   isSelected={effectiveFloorSelection === floor.id}
                   key={floor.id}
                   label={floor.name}
-                  meta={formatCount(
+                  meta={formatStructureMeta(
                     roomCountByFloor.get(floor.id) ?? 0,
                     "Raum",
-                    "Räume"
+                    "Räume",
+                    areaSummaries.byFloor.get(floor.id) ?? emptyAreaSummary
                   )}
                   onSelect={() => setFloorSelection(floor.id)}
                 />
@@ -627,7 +680,12 @@ export default function BuildingStructurePage() {
             <StructureEntry
               isSelected={effectiveFloorSelection === UNASSIGNED_SELECTION}
               label={<em>{UNASSIGNED_FLOOR_LABEL}</em>}
-              meta={formatCount(roomCountByFloor.get(null) ?? 0, "Raum", "Räume")}
+              meta={formatStructureMeta(
+                roomCountByFloor.get(null) ?? 0,
+                "Raum",
+                "Räume",
+                areaSummaries.byFloor.get(null) ?? emptyAreaSummary
+              )}
               onSelect={() => setFloorSelection(UNASSIGNED_SELECTION)}
             />
           ) : null}
@@ -671,6 +729,11 @@ export default function BuildingStructurePage() {
                   {room.roomName}
                 </>
               }
+              meta={
+                room.areaM2 === null
+                  ? "Fläche fehlt"
+                  : `${formatRoomArea(room.areaM2)} m²`
+              }
             />
           ))}
           {!visibleRooms.length && !isLoading ? (
diff --git a/src/db/migrations/0011_glossy_norman_osborn.sql b/src/db/migrations/0011_glossy_norman_osborn.sql
new file mode 100644
index 0000000..c91b51b
--- /dev/null
+++ b/src/db/migrations/0011_glossy_norman_osborn.sql
@@ -0,0 +1 @@
+ALTER TABLE `rooms` ADD `area_m2` real;
\ No newline at end of file
diff --git a/src/db/migrations/meta/0011_snapshot.json b/src/db/migrations/meta/0011_snapshot.json
new file mode 100644
index 0000000..2974cf1
--- /dev/null
+++ b/src/db/migrations/meta/0011_snapshot.json
@@ -0,0 +1,2931 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "63f27b3a-7378-462d-8119-b67d67903dbb",
+  "prevId": "5376ae9f-67c7-4603-b3d2-8527136436f9",
+  "tables": {
+    "buildings": {
+      "name": "buildings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "buildings_project_id_projects_id_fk": {
+          "name": "buildings_project_id_projects_id_fk",
+          "tableFrom": "buildings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_device_rows": {
+      "name": "circuit_device_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "level": {
+          "name": "level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number_snapshot": {
+          "name": "room_number_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_name_snapshot": {
+          "name": "room_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "manual_quantity": {
+          "name": "manual_quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_device_rows_circuit_id_idx": {
+          "name": "circuit_device_rows_circuit_id_idx",
+          "columns": [
+            "circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "circuit_device_rows_circuit_id_circuits_id_fk": {
+          "name": "circuit_device_rows_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_linked_project_device_id_project_devices_id_fk": {
+          "name": "circuit_device_rows_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_room_id_rooms_id_fk": {
+          "name": "circuit_device_rows_room_id_rooms_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_list_equipment_identifiers": {
+      "name": "circuit_list_equipment_identifiers",
+      "columns": {
+        "owner_type": {
+          "name": "owner_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_list_equipment_identifiers_owner_unique": {
+          "name": "circuit_list_equipment_identifiers_owner_unique",
+          "columns": [
+            "owner_type",
+            "owner_id"
+          ],
+          "isUnique": true
+        },
+        "circuit_list_equipment_identifiers_list_identifier_unique": {
+          "name": "circuit_list_equipment_identifiers_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_list_equipment_identifiers",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_lists": {
+      "name": "circuit_lists",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_lists_distribution_board_id_unique": {
+          "name": "circuit_lists_distribution_board_id_unique",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_lists_project_id_projects_id_fk": {
+          "name": "circuit_lists_project_id_projects_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_lists_distribution_board_id_distribution_boards_id_fk": {
+          "name": "circuit_lists_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_protection_devices": {
+      "name": "circuit_protection_devices",
+      "columns": {
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "circuit_protection_devices_circuit_id_circuits_id_fk": {
+          "name": "circuit_protection_devices_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_protection_devices",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_sections": {
+      "name": "circuit_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "group_number": {
+          "name": "group_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_sections_list_key_unique": {
+          "name": "circuit_sections_list_key_unique",
+          "columns": [
+            "circuit_list_id",
+            "key"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_prefix_unique": {
+          "name": "circuit_sections_list_prefix_unique",
+          "columns": [
+            "circuit_list_id",
+            "prefix"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_category_group_unique": {
+          "name": "circuit_sections_list_category_group_unique",
+          "columns": [
+            "circuit_list_id",
+            "category",
+            "group_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_sections_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_sections_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_sections",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuits": {
+      "name": "circuits",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "cable_type": {
+          "name": "cable_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_cross_section": {
+          "name": "cable_cross_section",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_length": {
+          "name": "cable_length",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_assignment": {
+          "name": "rcd_assignment",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_designation": {
+          "name": "terminal_designation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage": {
+          "name": "voltage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "control_requirement": {
+          "name": "control_requirement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_reserve": {
+          "name": "is_reserve",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuits_section_id_idx": {
+          "name": "circuits_section_id_idx",
+          "columns": [
+            "section_id"
+          ],
+          "isUnique": false
+        },
+        "circuits_list_equipment_identifier_unique": {
+          "name": "circuits_list_equipment_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuits_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuits_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuits_section_id_circuit_sections_id_fk": {
+          "name": "circuits_section_id_circuit_sections_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_component_protection_devices": {
+      "name": "distribution_board_component_protection_devices",
+      "columns": {
+        "component_id": {
+          "name": "component_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk": {
+          "name": "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk",
+          "tableFrom": "distribution_board_component_protection_devices",
+          "tableTo": "distribution_board_components",
+          "columnsFrom": [
+            "component_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_components": {
+      "name": "distribution_board_components",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "placement": {
+          "name": "placement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "distribution_board_components_list_identifier_unique": {
+          "name": "distribution_board_components_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        },
+        "distribution_board_components_section_role_unique": {
+          "name": "distribution_board_components_section_role_unique",
+          "columns": [
+            "section_id",
+            "role"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "distribution_board_components_circuit_list_id_circuit_lists_id_fk": {
+          "name": "distribution_board_components_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_board_components_section_id_circuit_sections_id_fk": {
+          "name": "distribution_board_components_section_id_circuit_sections_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_boards": {
+      "name": "distribution_boards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "supply_type": {
+          "name": "supply_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "board_number": {
+          "name": "board_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "location": {
+          "name": "location",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fed_from": {
+          "name": "fed_from",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_boards_project_id_projects_id_fk": {
+          "name": "distribution_boards_project_id_projects_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_floor_id_floors_id_fk": {
+          "name": "distribution_boards_floor_id_floors_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_assets": {
+      "name": "document_branding_assets",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_settings": {
+      "name": "document_branding_settings",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_balances": {
+      "name": "estimate_balances",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "date_iso": {
+          "name": "date_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "reserve_av_percent": {
+          "name": "reserve_av_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "reserve_sv_percent": {
+          "name": "reserve_sv_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_balances_project_id_idx": {
+          "name": "estimate_balances_project_id_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_balances_project_id_projects_id_fk": {
+          "name": "estimate_balances_project_id_projects_id_fk",
+          "tableFrom": "estimate_balances",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_groups": {
+      "name": "estimate_groups",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "balance_id": {
+          "name": "balance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "editor": {
+          "name": "editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_groups_balance_id_idx": {
+          "name": "estimate_groups_balance_id_idx",
+          "columns": [
+            "balance_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_groups_balance_id_estimate_balances_id_fk": {
+          "name": "estimate_groups_balance_id_estimate_balances_id_fk",
+          "tableFrom": "estimate_groups",
+          "tableTo": "estimate_balances",
+          "columnsFrom": [
+            "balance_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_rows": {
+      "name": "estimate_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "supply": {
+          "name": "supply",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "unit": {
+          "name": "unit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'piece'"
+        },
+        "connection": {
+          "name": "connection",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_per_unit_w": {
+          "name": "power_per_unit_w",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "safety_supply": {
+          "name": "safety_supply",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "estimate_rows_group_id_idx": {
+          "name": "estimate_rows_group_id_idx",
+          "columns": [
+            "group_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_rows_group_id_estimate_groups_id_fk": {
+          "name": "estimate_rows_group_id_estimate_groups_id_fk",
+          "tableFrom": "estimate_rows",
+          "tableTo": "estimate_groups",
+          "columnsFrom": [
+            "group_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_csv_configurations": {
+      "name": "external_csv_configurations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration": {
+          "name": "configuration",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_csv_configurations_project_id_unique": {
+          "name": "external_csv_configurations_project_id_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_csv_configurations_project_id_projects_id_fk": {
+          "name": "external_csv_configurations_project_id_projects_id_fk",
+          "tableFrom": "external_csv_configurations",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_import_batches": {
+      "name": "external_import_batches",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "import_kind": {
+          "name": "import_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "imported_at_iso": {
+          "name": "imported_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "applied_project_revision": {
+          "name": "applied_project_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_snapshot": {
+          "name": "configuration_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "original_bytes": {
+          "name": "original_bytes",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "document": {
+          "name": "document",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_import_batches_project_revision_idx": {
+          "name": "external_import_batches_project_revision_idx",
+          "columns": [
+            "project_id",
+            "applied_project_revision"
+          ],
+          "isUnique": false
+        },
+        "external_import_batches_source_imported_idx": {
+          "name": "external_import_batches_source_imported_idx",
+          "columns": [
+            "source_id",
+            "imported_at_iso"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_import_batches_project_id_projects_id_fk": {
+          "name": "external_import_batches_project_id_projects_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_import_batches_source_id_external_model_sources_id_fk": {
+          "name": "external_import_batches_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_objects": {
+      "name": "external_model_objects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ifc_guid": {
+          "name": "ifc_guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen_import_batch_id": {
+          "name": "last_seen_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_accepted_import_batch_id": {
+          "name": "last_accepted_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "accepted_source_values": {
+          "name": "accepted_source_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "planning_values": {
+          "name": "planning_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "external_room_mapping_id": {
+          "name": "external_room_mapping_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "circuit_device_row_id": {
+          "name": "circuit_device_row_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "presence_status": {
+          "name": "presence_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'present'"
+        }
+      },
+      "indexes": {
+        "external_model_objects_source_ifc_guid_unique": {
+          "name": "external_model_objects_source_ifc_guid_unique",
+          "columns": [
+            "source_id",
+            "ifc_guid"
+          ],
+          "isUnique": true
+        },
+        "external_model_objects_project_presence_idx": {
+          "name": "external_model_objects_project_presence_idx",
+          "columns": [
+            "project_id",
+            "presence_status"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_distribution_board_idx": {
+          "name": "external_model_objects_distribution_board_idx",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_circuit_device_row_idx": {
+          "name": "external_model_objects_circuit_device_row_idx",
+          "columns": [
+            "circuit_device_row_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_model_objects_project_id_projects_id_fk": {
+          "name": "external_model_objects_project_id_projects_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_source_id_external_model_sources_id_fk": {
+          "name": "external_model_objects_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_seen_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_accepted_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk": {
+          "name": "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_room_mappings",
+          "columnsFrom": [
+            "external_room_mapping_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_model_objects_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_linked_project_device_id_project_devices_id_fk": {
+          "name": "external_model_objects_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk": {
+          "name": "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "circuit_device_rows",
+          "columnsFrom": [
+            "circuit_device_row_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_sources": {
+      "name": "external_model_sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_type": {
+          "name": "source_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'revit_csv'"
+        }
+      },
+      "indexes": {
+        "external_model_sources_project_type_unique": {
+          "name": "external_model_sources_project_type_unique",
+          "columns": [
+            "project_id",
+            "source_type"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_sources_project_id_projects_id_fk": {
+          "name": "external_model_sources_project_id_projects_id_fk",
+          "tableFrom": "external_model_sources",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_room_mappings": {
+      "name": "external_room_mappings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "normalized_source_room_key": {
+          "name": "normalized_source_room_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_floor_name": {
+          "name": "source_floor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_room_number": {
+          "name": "source_room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_room_name": {
+          "name": "source_room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_distribution_board_id": {
+          "name": "default_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_room_mappings_source_key_unique": {
+          "name": "external_room_mappings_source_key_unique",
+          "columns": [
+            "source_id",
+            "normalized_source_room_key"
+          ],
+          "isUnique": true
+        },
+        "external_room_mappings_project_room_idx": {
+          "name": "external_room_mappings_project_room_idx",
+          "columns": [
+            "project_id",
+            "room_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_room_mappings_project_id_projects_id_fk": {
+          "name": "external_room_mappings_project_id_projects_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_source_id_external_model_sources_id_fk": {
+          "name": "external_room_mappings_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_room_id_rooms_id_fk": {
+          "name": "external_room_mappings_room_id_rooms_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "default_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "floors": {
+      "name": "floors",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "building_id": {
+          "name": "building_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "floors_project_id_projects_id_fk": {
+          "name": "floors_project_id_projects_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "floors_building_id_buildings_id_fk": {
+          "name": "floors_building_id_buildings_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "buildings",
+          "columnsFrom": [
+            "building_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "global_devices": {
+      "name": "global_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "installed_power_per_unit_kw": {
+          "name": "installed_power_per_unit_kw",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "demand_factor": {
+          "name": "demand_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase_count": {
+          "name": "phase_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_factor": {
+          "name": "power_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_change_sets": {
+      "name": "project_change_sets",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_revision_id": {
+          "name": "project_revision_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "command_type": {
+          "name": "command_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_schema_version": {
+          "name": "payload_schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "forward_payload_json": {
+          "name": "forward_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "inverse_payload_json": {
+          "name": "inverse_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_change_sets_revision_unique": {
+          "name": "project_change_sets_revision_unique",
+          "columns": [
+            "project_revision_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_change_sets_project_revision_id_project_revisions_id_fk": {
+          "name": "project_change_sets_project_revision_id_project_revisions_id_fk",
+          "tableFrom": "project_change_sets",
+          "tableTo": "project_revisions",
+          "columnsFrom": [
+            "project_revision_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_devices": {
+      "name": "project_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'single_phase'"
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "project_devices_project_id_projects_id_fk": {
+          "name": "project_devices_project_id_projects_id_fk",
+          "tableFrom": "project_devices",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_history_stack_entries": {
+      "name": "project_history_stack_entries",
+      "columns": {
+        "change_set_id": {
+          "name": "change_set_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stack": {
+          "name": "stack",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_history_stack_entries_position_unique": {
+          "name": "project_history_stack_entries_position_unique",
+          "columns": [
+            "project_id",
+            "stack",
+            "position"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_history_stack_entries_change_set_id_project_change_sets_id_fk": {
+          "name": "project_history_stack_entries_change_set_id_project_change_sets_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "project_change_sets",
+          "columnsFrom": [
+            "change_set_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "project_history_stack_entries_project_id_projects_id_fk": {
+          "name": "project_history_stack_entries_project_id_projects_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "project_history_stack_entries_stack_check": {
+          "name": "project_history_stack_entries_stack_check",
+          "value": "\"project_history_stack_entries\".\"stack\" in ('undo', 'redo')"
+        }
+      }
+    },
+    "project_revisions": {
+      "name": "project_revisions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision_number": {
+          "name": "revision_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_revisions_project_number_unique": {
+          "name": "project_revisions_project_number_unique",
+          "columns": [
+            "project_id",
+            "revision_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_revisions_project_id_projects_id_fk": {
+          "name": "project_revisions_project_id_projects_id_fk",
+          "tableFrom": "project_revisions",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_snapshots": {
+      "name": "project_snapshots",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_revision": {
+          "name": "source_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_version": {
+          "name": "schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'named'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "payload_json": {
+          "name": "payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_sha256": {
+          "name": "payload_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_by_actor_id": {
+          "name": "created_by_actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_snapshots_project_created_idx": {
+          "name": "project_snapshots_project_created_idx",
+          "columns": [
+            "project_id",
+            "created_at_iso"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_kind_revision_idx": {
+          "name": "project_snapshots_project_kind_revision_idx",
+          "columns": [
+            "project_id",
+            "kind",
+            "source_revision"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_name_unique": {
+          "name": "project_snapshots_project_name_unique",
+          "columns": [
+            "project_id",
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_snapshots_project_id_projects_id_fk": {
+          "name": "project_snapshots_project_id_projects_id_fk",
+          "tableFrom": "project_snapshots",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "internal_project_number": {
+          "name": "internal_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_project_number": {
+          "name": "external_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "building_owner": {
+          "name": "building_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_public_building": {
+          "name": "is_public_building",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "single_phase_voltage_v": {
+          "name": "single_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 230
+        },
+        "three_phase_voltage_v": {
+          "name": "three_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 400
+        },
+        "enabled_distribution_board_supply_types": {
+          "name": "enabled_distribution_board_supply_types",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'[\"AV\",\"SV\",\"EV\",\"USV\",\"MSR\",\"SiBe\"]'"
+        },
+        "site_address": {
+          "name": "site_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_lead": {
+          "name": "project_lead",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_editor": {
+          "name": "project_editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "current_revision": {
+          "name": "current_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "rooms": {
+      "name": "rooms",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number": {
+          "name": "room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_name": {
+          "name": "room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "area_m2": {
+          "name": "area_m2",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rooms_project_id_projects_id_fk": {
+          "name": "rooms_project_id_projects_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rooms_floor_id_floors_id_fk": {
+          "name": "rooms_floor_id_floors_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index f2c5dba..90c3bd0 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -78,6 +78,13 @@
       "when": 1790438092269,
       "tag": "0010_estimate_balances",
       "breakpoints": true
+    },
+    {
+      "idx": 11,
+      "version": "6",
+      "when": 1790531351492,
+      "tag": "0011_glossy_norman_osborn",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/db/repositories/project-location-structure-project-command.repository.ts b/src/db/repositories/project-location-structure-project-command.repository.ts
index 9ec3f48..51edb3b 100644
--- a/src/db/repositories/project-location-structure-project-command.repository.ts
+++ b/src/db/repositories/project-location-structure-project-command.repository.ts
@@ -28,6 +28,7 @@ import {
   projectRoomInsertCommandType,
   projectRoomUpdateCommandType,
   upgradeProjectFloorCommand,
+  upgradeProjectRoomCommand,
   type ProjectBuildingSnapshot,
   type ProjectFloorSnapshot,
   type ProjectLocationStructureProjectCommand,
@@ -106,23 +107,29 @@ export class ProjectLocationStructureProjectCommandRepository
         const current = upgradeProjectFloorCommand(command);
         return this.updateFloor(database, projectId, current.payload.expected, current.payload.target);
       }
-      case projectRoomInsertCommandType:
+      case projectRoomInsertCommandType: {
         assertProjectRoomInsertProjectCommand(command);
+        const current = upgradeProjectRoomCommand(command);
         return this.insertRoom(
           database,
           projectId,
-          command.payload.room
+          current.payload.room
         );
-      case projectRoomDeleteCommandType:
+      }
+      case projectRoomDeleteCommandType: {
         assertProjectRoomDeleteProjectCommand(command);
+        const current = upgradeProjectRoomCommand(command);
         return this.deleteRoom(
           database,
           projectId,
-          command.payload.room
+          current.payload.room
         );
-      case projectRoomUpdateCommandType:
+      }
+      case projectRoomUpdateCommandType: {
         assertProjectRoomUpdateProjectCommand(command);
-        return this.updateRoom(database, projectId, command.payload.expected, command.payload.target);
+        const current = upgradeProjectRoomCommand(command);
+        return this.updateRoom(database, projectId, current.payload.expected, current.payload.target);
+      }
     }
   }
 
@@ -393,6 +400,7 @@ export class ProjectLocationStructureProjectCommandRepository
         floorId: target.floorId,
         roomNumber: target.roomNumber,
         roomName: target.roomName,
+        areaM2: target.areaM2,
       })
       .where(and(eq(rooms.id, expected.id), eq(rooms.projectId, projectId)))
       .run();
@@ -474,6 +482,15 @@ function toCurrentCommandVersion(
     case projectFloorUpdateCommandType:
       assertProjectFloorUpdateProjectCommand(command);
       return upgradeProjectFloorCommand(command);
+    case projectRoomInsertCommandType:
+      assertProjectRoomInsertProjectCommand(command);
+      return upgradeProjectRoomCommand(command);
+    case projectRoomDeleteCommandType:
+      assertProjectRoomDeleteProjectCommand(command);
+      return upgradeProjectRoomCommand(command);
+    case projectRoomUpdateCommandType:
+      assertProjectRoomUpdateProjectCommand(command);
+      return upgradeProjectRoomCommand(command);
     default:
       return command;
   }
diff --git a/src/db/schema/rooms.ts b/src/db/schema/rooms.ts
index 271106d..47988bd 100644
--- a/src/db/schema/rooms.ts
+++ b/src/db/schema/rooms.ts
@@ -1,4 +1,4 @@
-import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { real, sqliteTable, text } from "drizzle-orm/sqlite-core";
 import { floors } from "./floors.js";
 import { projects } from "./projects.js";
 
@@ -10,4 +10,6 @@ export const rooms = sqliteTable("rooms", {
   floorId: text("floor_id").references(() => floors.id, { onDelete: "set null" }),
   roomNumber: text("room_number").notNull(),
   roomName: text("room_name").notNull(),
+  /** Optional net room area from the Revit room parameter "Fläche". */
+  areaM2: real("area_m2"),
 });
diff --git a/src/domain/models/project-location-structure-project-command.model.ts b/src/domain/models/project-location-structure-project-command.model.ts
index 21dfa89..8580527 100644
--- a/src/domain/models/project-location-structure-project-command.model.ts
+++ b/src/domain/models/project-location-structure-project-command.model.ts
@@ -10,7 +10,7 @@ export const projectFloorUpdateCommandType = "project-floor.update" as const;
 export const projectRoomInsertCommandType = "project-room.insert" as const;
 export const projectRoomDeleteCommandType = "project-room.delete" as const;
 export const projectRoomUpdateCommandType = "project-room.update" as const;
-/** Room commands, building commands and legacy floor commands. */
+/** Building commands and legacy floor/room commands. */
 export const projectLocationStructureCommandSchemaVersion = 1 as const;
 /**
  * Floor commands carry `buildingId` since version 2. Version 1 floor
@@ -19,6 +19,9 @@ export const projectLocationStructureCommandSchemaVersion = 1 as const;
  */
 export const projectFloorCommandSchemaVersion = 2 as const;
 const legacyProjectFloorCommandSchemaVersion = 1 as const;
+/** Room commands carry `areaM2` since version 2. */
+export const projectRoomCommandSchemaVersion = 2 as const;
+const legacyProjectRoomCommandSchemaVersion = 1 as const;
 
 export interface ProjectBuildingSnapshot {
   id: string;
@@ -43,8 +46,11 @@ export interface ProjectRoomSnapshot {
   floorId: string | null;
   roomNumber: string;
   roomName: string;
+  areaM2: number | null;
 }
 
+export type LegacyProjectRoomSnapshot = Omit<ProjectRoomSnapshot, "areaM2">;
+
 interface ProjectBuildingStructureCommandPayload {
   building: ProjectBuildingSnapshot;
 }
@@ -61,6 +67,10 @@ interface ProjectRoomStructureCommandPayload {
   room: ProjectRoomSnapshot;
 }
 
+interface LegacyProjectRoomStructureCommandPayload {
+  room: LegacyProjectRoomSnapshot;
+}
+
 interface ProjectBuildingUpdateCommandPayload {
   expected: ProjectBuildingSnapshot;
   target: ProjectBuildingSnapshot;
@@ -81,6 +91,11 @@ interface ProjectRoomUpdateCommandPayload {
   target: ProjectRoomSnapshot;
 }
 
+interface LegacyProjectRoomUpdateCommandPayload {
+  expected: LegacyProjectRoomSnapshot;
+  target: LegacyProjectRoomSnapshot;
+}
+
 export interface ProjectBuildingInsertProjectCommand
   extends SerializedProjectCommand<ProjectBuildingStructureCommandPayload> {
   schemaVersion: typeof projectLocationStructureCommandSchemaVersion;
@@ -137,19 +152,37 @@ export interface LegacyProjectFloorUpdateProjectCommand
 
 export interface ProjectRoomInsertProjectCommand
   extends SerializedProjectCommand<ProjectRoomStructureCommandPayload> {
-  schemaVersion: typeof projectLocationStructureCommandSchemaVersion;
+  schemaVersion: typeof projectRoomCommandSchemaVersion;
   type: typeof projectRoomInsertCommandType;
 }
 
 export interface ProjectRoomDeleteProjectCommand
   extends SerializedProjectCommand<ProjectRoomStructureCommandPayload> {
-  schemaVersion: typeof projectLocationStructureCommandSchemaVersion;
+  schemaVersion: typeof projectRoomCommandSchemaVersion;
   type: typeof projectRoomDeleteCommandType;
 }
 
 export interface ProjectRoomUpdateProjectCommand
   extends SerializedProjectCommand<ProjectRoomUpdateCommandPayload> {
-  schemaVersion: typeof projectLocationStructureCommandSchemaVersion;
+  schemaVersion: typeof projectRoomCommandSchemaVersion;
+  type: typeof projectRoomUpdateCommandType;
+}
+
+export interface LegacyProjectRoomInsertProjectCommand
+  extends SerializedProjectCommand<LegacyProjectRoomStructureCommandPayload> {
+  schemaVersion: typeof legacyProjectRoomCommandSchemaVersion;
+  type: typeof projectRoomInsertCommandType;
+}
+
+export interface LegacyProjectRoomDeleteProjectCommand
+  extends SerializedProjectCommand<LegacyProjectRoomStructureCommandPayload> {
+  schemaVersion: typeof legacyProjectRoomCommandSchemaVersion;
+  type: typeof projectRoomDeleteCommandType;
+}
+
+export interface LegacyProjectRoomUpdateProjectCommand
+  extends SerializedProjectCommand<LegacyProjectRoomUpdateCommandPayload> {
+  schemaVersion: typeof legacyProjectRoomCommandSchemaVersion;
   type: typeof projectRoomUpdateCommandType;
 }
 
@@ -165,7 +198,10 @@ export type ProjectLocationStructureProjectCommand =
   | LegacyProjectFloorUpdateProjectCommand
   | ProjectRoomInsertProjectCommand
   | ProjectRoomDeleteProjectCommand
-  | ProjectRoomUpdateProjectCommand;
+  | ProjectRoomUpdateProjectCommand
+  | LegacyProjectRoomInsertProjectCommand
+  | LegacyProjectRoomDeleteProjectCommand
+  | LegacyProjectRoomUpdateProjectCommand;
 
 export function createProjectBuildingSnapshot(
   projectId: string,
@@ -205,6 +241,7 @@ export function createProjectRoomSnapshot(
     floorId?: string;
     roomNumber: string;
     roomName: string;
+    areaM2?: number | null;
   }
 ): ProjectRoomSnapshot {
   const room: ProjectRoomSnapshot = {
@@ -213,6 +250,7 @@ export function createProjectRoomSnapshot(
     floorId: input.floorId?.trim() || null,
     roomNumber: input.roomNumber.trim(),
     roomName: input.roomName.trim(),
+    areaM2: input.areaM2 ?? null,
   };
   assertProjectRoomSnapshot(room);
   return room;
@@ -279,7 +317,7 @@ export function createProjectRoomInsertProjectCommand(
 ): ProjectRoomInsertProjectCommand {
   assertProjectRoomSnapshot(room);
   return {
-    schemaVersion: projectLocationStructureCommandSchemaVersion,
+    schemaVersion: projectRoomCommandSchemaVersion,
     type: projectRoomInsertCommandType,
     payload: { room },
   };
@@ -290,7 +328,7 @@ export function createProjectRoomDeleteProjectCommand(
 ): ProjectRoomDeleteProjectCommand {
   assertProjectRoomSnapshot(room);
   return {
-    schemaVersion: projectLocationStructureCommandSchemaVersion,
+    schemaVersion: projectRoomCommandSchemaVersion,
     type: projectRoomDeleteCommandType,
     payload: { room },
   };
@@ -314,7 +352,7 @@ export function createProjectRoomUpdateProjectCommand(
 ): ProjectRoomUpdateProjectCommand {
   assertMatchingRoomUpdate(expected, target);
   return {
-    schemaVersion: projectLocationStructureCommandSchemaVersion,
+    schemaVersion: projectRoomCommandSchemaVersion,
     type: projectRoomUpdateCommandType,
     payload: { expected, target },
   };
@@ -376,7 +414,9 @@ export function assertProjectFloorDeleteProjectCommand(
 
 export function assertProjectRoomInsertProjectCommand(
   command: SerializedProjectCommand<unknown>
-): asserts command is ProjectRoomInsertProjectCommand {
+): asserts command is
+  | ProjectRoomInsertProjectCommand
+  | LegacyProjectRoomInsertProjectCommand {
   assertProjectRoomStructureProjectCommand(
     command,
     projectRoomInsertCommandType
@@ -385,7 +425,9 @@ export function assertProjectRoomInsertProjectCommand(
 
 export function assertProjectRoomDeleteProjectCommand(
   command: SerializedProjectCommand<unknown>
-): asserts command is ProjectRoomDeleteProjectCommand {
+): asserts command is
+  | ProjectRoomDeleteProjectCommand
+  | LegacyProjectRoomDeleteProjectCommand {
   assertProjectRoomStructureProjectCommand(
     command,
     projectRoomDeleteCommandType
@@ -419,15 +461,26 @@ export function assertProjectFloorUpdateProjectCommand(
 
 export function assertProjectRoomUpdateProjectCommand(
   command: SerializedProjectCommand<unknown>
-): asserts command is ProjectRoomUpdateProjectCommand {
+): asserts command is
+  | ProjectRoomUpdateProjectCommand
+  | LegacyProjectRoomUpdateProjectCommand {
   if (
-    command.schemaVersion !== projectLocationStructureCommandSchemaVersion ||
     command.type !== projectRoomUpdateCommandType ||
     !isPlainObject(command.payload) ||
     Object.keys(command.payload).length !== 2
   ) {
     throw new Error("Unsupported project-room update command.");
   }
+  if (command.schemaVersion === legacyProjectRoomCommandSchemaVersion) {
+    assertMatchingRoomUpdate(
+      upgradeLegacyRoomSnapshot(command.payload.expected),
+      upgradeLegacyRoomSnapshot(command.payload.target)
+    );
+    return;
+  }
+  if (command.schemaVersion !== projectRoomCommandSchemaVersion) {
+    throw new Error("Unsupported project-room update command.");
+  }
   assertMatchingRoomUpdate(command.payload.expected, command.payload.target);
 }
 
@@ -480,6 +533,51 @@ export function upgradeProjectFloorCommand(
   }
 }
 
+/** Upgrades persisted version-1 room commands with an empty area. */
+export function upgradeProjectRoomCommand(
+  command:
+    | ProjectRoomInsertProjectCommand
+    | LegacyProjectRoomInsertProjectCommand
+): ProjectRoomInsertProjectCommand;
+export function upgradeProjectRoomCommand(
+  command:
+    | ProjectRoomDeleteProjectCommand
+    | LegacyProjectRoomDeleteProjectCommand
+): ProjectRoomDeleteProjectCommand;
+export function upgradeProjectRoomCommand(
+  command:
+    | ProjectRoomUpdateProjectCommand
+    | LegacyProjectRoomUpdateProjectCommand
+): ProjectRoomUpdateProjectCommand;
+export function upgradeProjectRoomCommand(
+  command:
+    | ProjectRoomInsertProjectCommand
+    | ProjectRoomDeleteProjectCommand
+    | ProjectRoomUpdateProjectCommand
+    | LegacyProjectRoomInsertProjectCommand
+    | LegacyProjectRoomDeleteProjectCommand
+    | LegacyProjectRoomUpdateProjectCommand
+) {
+  if (command.schemaVersion === projectRoomCommandSchemaVersion) {
+    return command;
+  }
+  switch (command.type) {
+    case projectRoomInsertCommandType:
+      return createProjectRoomInsertProjectCommand(
+        upgradeLegacyRoomSnapshot(command.payload.room)
+      );
+    case projectRoomDeleteCommandType:
+      return createProjectRoomDeleteProjectCommand(
+        upgradeLegacyRoomSnapshot(command.payload.room)
+      );
+    case projectRoomUpdateCommandType:
+      return createProjectRoomUpdateProjectCommand(
+        upgradeLegacyRoomSnapshot(command.payload.expected),
+        upgradeLegacyRoomSnapshot(command.payload.target)
+      );
+  }
+}
+
 function assertMatchingBuildingUpdate(expected: unknown, target: unknown) {
   assertProjectBuildingSnapshot(expected);
   assertProjectBuildingSnapshot(target);
@@ -568,6 +666,29 @@ function upgradeLegacyFloorSnapshot(floor: unknown): ProjectFloorSnapshot {
 export function assertProjectRoomSnapshot(
   room: unknown
 ): asserts room is ProjectRoomSnapshot {
+  if (!isPlainObject(room) || Object.keys(room).length !== 6) {
+    throw new Error("Project-room snapshot is invalid.");
+  }
+  assertNormalizedNonEmptyString(room.id, "room.id");
+  assertNormalizedNonEmptyString(room.projectId, "room.projectId");
+  if (room.floorId !== null) {
+    assertNormalizedNonEmptyString(room.floorId, "room.floorId");
+  }
+  assertNormalizedNonEmptyString(room.roomNumber, "room.roomNumber");
+  assertNormalizedNonEmptyString(room.roomName, "room.roomName");
+  if (
+    room.areaM2 !== null &&
+    (typeof room.areaM2 !== "number" ||
+      !Number.isFinite(room.areaM2) ||
+      room.areaM2 < 0)
+  ) {
+    throw new Error("room.areaM2 must be null or a non-negative finite number.");
+  }
+}
+
+function assertLegacyProjectRoomSnapshot(
+  room: unknown
+): asserts room is LegacyProjectRoomSnapshot {
   if (!isPlainObject(room) || Object.keys(room).length !== 5) {
     throw new Error("Project-room snapshot is invalid.");
   }
@@ -580,6 +701,11 @@ export function assertProjectRoomSnapshot(
   assertNormalizedNonEmptyString(room.roomName, "room.roomName");
 }
 
+function upgradeLegacyRoomSnapshot(room: unknown): ProjectRoomSnapshot {
+  assertLegacyProjectRoomSnapshot(room);
+  return { ...room, areaM2: null };
+}
+
 function assertProjectBuildingStructureProjectCommand(
   command: SerializedProjectCommand<unknown>,
   expectedType:
@@ -627,13 +753,19 @@ function assertProjectRoomStructureProjectCommand(
     | typeof projectRoomDeleteCommandType
 ) {
   if (
-    command.schemaVersion !== projectLocationStructureCommandSchemaVersion ||
     command.type !== expectedType ||
     !isPlainObject(command.payload) ||
     Object.keys(command.payload).length !== 1
   ) {
     throw new Error("Unsupported project-room structure command.");
   }
+  if (command.schemaVersion === legacyProjectRoomCommandSchemaVersion) {
+    assertLegacyProjectRoomSnapshot(command.payload.room);
+    return;
+  }
+  if (command.schemaVersion !== projectRoomCommandSchemaVersion) {
+    throw new Error("Unsupported project-room structure command.");
+  }
   assertProjectRoomSnapshot(command.payload.room);
 }
 
diff --git a/src/domain/models/project-state-snapshot.model.ts b/src/domain/models/project-state-snapshot.model.ts
index 07db42d..b03bfbd 100644
--- a/src/domain/models/project-state-snapshot.model.ts
+++ b/src/domain/models/project-state-snapshot.model.ts
@@ -35,7 +35,8 @@ import {
   type ExternalModelStateSnapshot,
 } from "../../external-model/domain/external-model-contracts.js";
 
-export const projectStateSnapshotSchemaVersion = 7 as const;
+export const projectStateSnapshotSchemaVersion = 8 as const;
+const buildingProjectStateSnapshotSchemaVersion = 7 as const;
 const coverProjectStateSnapshotSchemaVersion = 6 as const;
 const boardInfoProjectStateSnapshotSchemaVersion = 5 as const;
 const previousProjectStateSnapshotSchemaVersion = 4 as const;
@@ -260,7 +261,7 @@ const floorSchema = legacyFloorSchema
   .extend({ buildingId: idSchema.nullable() })
   .strict();
 
-const roomSchema = z
+const legacyRoomSchema = z
   .object({
     id: idSchema,
     projectId: idSchema,
@@ -270,6 +271,10 @@ const roomSchema = z
   })
   .strict();
 
+const roomSchema = legacyRoomSchema
+  .extend({ areaM2: finiteNumberSchema.nonnegative().nullable() })
+  .strict();
+
 const distributionBoardComponentSchema = z
   .object({
     id: idSchema,
@@ -504,14 +509,27 @@ export function parseExternalModelStateSnapshot(
   return externalModelStateSchema.parse(value);
 }
 
-// Versions 1-6 have floors without a building and no building list.
+// Versions 1-6 have floors without a building and no building list. Versions
+// 1-7 have rooms without an area.
 const previousProjectStateSnapshotContents = {
   circuitLists: z.array(circuitListSchema),
   circuitSections: z.array(circuitSectionSchema),
   circuits: z.array(circuitSchema),
   projectDevices: z.array(projectDeviceSchema),
   floors: z.array(legacyFloorSchema),
-  rooms: z.array(roomSchema),
+  rooms: z.array(legacyRoomSchema),
+  distributionBoardComponents: z.array(distributionBoardComponentSchema),
+  circuitProtectionDevices: z.array(circuitProtectionDeviceSchema),
+  distributionBoardComponentProtectionDevices: z.array(
+    componentProtectionDeviceSchema
+  ),
+};
+
+const buildingProjectStateSnapshotContents = {
+  ...previousProjectStateSnapshotContents,
+  buildings: z.array(buildingSchema),
+  floors: z.array(floorSchema),
+  rooms: z.array(legacyRoomSchema),
   distributionBoardComponents: z.array(distributionBoardComponentSchema),
   circuitProtectionDevices: z.array(circuitProtectionDeviceSchema),
   distributionBoardComponentProtectionDevices: z.array(
@@ -520,15 +538,8 @@ const previousProjectStateSnapshotContents = {
 };
 
 const projectStateSnapshotContents = {
-  ...previousProjectStateSnapshotContents,
-  buildings: z.array(buildingSchema),
-  floors: z.array(floorSchema),
+  ...buildingProjectStateSnapshotContents,
   rooms: z.array(roomSchema),
-  distributionBoardComponents: z.array(distributionBoardComponentSchema),
-  circuitProtectionDevices: z.array(circuitProtectionDeviceSchema),
-  distributionBoardComponentProtectionDevices: z.array(
-    componentProtectionDeviceSchema
-  ),
 };
 
 export const projectStateSnapshotSchema = z
@@ -542,6 +553,17 @@ export const projectStateSnapshotSchema = z
   })
   .strict();
 
+const buildingProjectStateSnapshotSchema = z
+  .object({
+    schemaVersion: z.literal(buildingProjectStateSnapshotSchemaVersion),
+    project: projectSchema,
+    distributionBoards: z.array(distributionBoardSchema),
+    externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
+    externalModel: externalModelStateSchema,
+    ...buildingProjectStateSnapshotContents,
+  })
+  .strict();
+
 const coverProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(coverProjectStateSnapshotSchemaVersion),
@@ -634,6 +656,20 @@ export function parseProjectStateSnapshot(
 
 function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
   const cover = upgradeToCoverProjectStateSnapshot(value);
+  if (
+    cover !== null &&
+    typeof cover === "object" &&
+    !Array.isArray(cover) &&
+    (cover as { schemaVersion?: unknown }).schemaVersion ===
+      buildingProjectStateSnapshotSchemaVersion
+  ) {
+    const previous = buildingProjectStateSnapshotSchema.parse(cover);
+    return {
+      ...previous,
+      schemaVersion: projectStateSnapshotSchemaVersion,
+      rooms: previous.rooms.map((room) => ({ ...room, areaM2: null })),
+    };
+  }
   if (
     cover === null ||
     typeof cover !== "object" ||
@@ -644,14 +680,15 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     return cover;
   }
   // Every supported version before 7 lacks buildings; its floors had no
-  // building.
+  // building. Build version 7 first so the room-area upgrade above remains a
+  // single exact transition.
   const previous = coverProjectStateSnapshotSchema.parse(cover);
-  return {
+  return upgradePreviousProjectStateSnapshot({
     ...previous,
-    schemaVersion: projectStateSnapshotSchemaVersion,
+    schemaVersion: buildingProjectStateSnapshotSchemaVersion,
     buildings: [],
     floors: previous.floors.map((floor) => ({ ...floor, buildingId: null })),
-  };
+  });
 }
 
 function upgradeToCoverProjectStateSnapshot(value: unknown): unknown {
diff --git a/src/frontend/components/room-modal.tsx b/src/frontend/components/room-modal.tsx
index eabeedd..b8a0ff0 100644
--- a/src/frontend/components/room-modal.tsx
+++ b/src/frontend/components/room-modal.tsx
@@ -4,6 +4,10 @@ import React, { type FormEvent, useState } from "react";
 import type { BuildingDto, CreateRoomInput, RoomDto } from "../types";
 import { FloorSelectOptions, type FloorOption } from "./floor-select-options";
 import { FormModal } from "./form-modal";
+import {
+  formatOptionalRoomAreaInput,
+  parseRoomAreaInput,
+} from "../utils/room-area";
 
 interface RoomModalProps {
   /** When given, the floor select groups floors by building. */
@@ -36,14 +40,21 @@ export function RoomModal({
   const [floorId, setFloorId] = useState(
     initialRoom?.floorId ?? initialValues?.floorId ?? ""
   );
+  const [areaText, setAreaText] = useState(() =>
+    formatOptionalRoomAreaInput(
+      initialRoom ? initialRoom.areaM2 : initialValues?.areaM2
+    )
+  );
+  const parsedArea = parseRoomAreaInput(areaText);
 
   async function handleSubmit(event: FormEvent<HTMLFormElement>) {
     event.preventDefault();
-    if (!roomNumber.trim() || !roomName.trim()) return;
+    if (!roomNumber.trim() || !roomName.trim() || !parsedArea.ok) return;
     await onSave({
       floorId: floorId || undefined,
       roomNumber: roomNumber.trim(),
       roomName: roomName.trim(),
+      areaM2: parsedArea.value,
     });
   }
 
@@ -52,7 +63,7 @@ export function RoomModal({
       isSaving={isSaving}
       onClose={onClose}
       onSubmit={handleSubmit}
-      submitDisabled={!roomNumber.trim() || !roomName.trim()}
+      submitDisabled={!roomNumber.trim() || !roomName.trim() || !parsedArea.ok}
       submitLabel={initialRoom ? "Änderungen speichern" : "Raum anlegen"}
       title={initialRoom ? "Raum bearbeiten" : "Raum hinzufügen"}
     >
@@ -90,6 +101,27 @@ export function RoomModal({
             <FloorSelectOptions buildings={buildings} floors={floors} />
           </select>
         </div>
+        <div className="col-12 col-md-6">
+          <label className="form-label" htmlFor="room-area">
+            Fläche [m²]
+          </label>
+          <input
+            aria-describedby="room-area-help"
+            aria-invalid={!parsedArea.ok}
+            className={`form-control${parsedArea.ok ? "" : " is-invalid"}`}
+            id="room-area"
+            inputMode="decimal"
+            onChange={(event) => setAreaText(event.target.value)}
+            placeholder="z. B. 23,45"
+            type="text"
+            value={areaText}
+          />
+          <div className={parsedArea.ok ? "form-text" : "invalid-feedback"} id="room-area-help">
+            {parsedArea.ok
+              ? "Optionale Netto-Raumfläche; Eingabe mit Dezimalkomma."
+              : parsedArea.error}
+          </div>
+        </div>
       </div>
       {initialRoom && onDelete ? (
         <div className="border-top mt-4 pt-3">
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 11bde4a..e8a2289 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -257,6 +257,7 @@ export interface RoomDto {
   floorId: string | null;
   roomNumber: string;
   roomName: string;
+  areaM2: number | null;
 }
 
 export interface GlobalDeviceDto {
@@ -315,6 +316,7 @@ export interface CreateRoomInput {
   floorId?: string;
   roomNumber: string;
   roomName: string;
+  areaM2: number | null;
 }
 
 export interface CreateGlobalDeviceInput {
diff --git a/src/frontend/utils/building-structure.ts b/src/frontend/utils/building-structure.ts
index 0c9d6ab..11c1a1e 100644
--- a/src/frontend/utils/building-structure.ts
+++ b/src/frontend/utils/building-structure.ts
@@ -18,6 +18,19 @@ type FloorLike = Pick<FloorDto, "id" | "name"> & {
   buildingId?: string | null;
 };
 type RoomLike = Pick<RoomDto, "floorId">;
+type RoomAreaLike = Pick<RoomDto, "floorId" | "areaM2">;
+
+export interface RoomAreaSummary {
+  areaM2: number;
+  roomCount: number;
+  missingAreaCount: number;
+}
+
+export interface StructureAreaSummaries {
+  total: RoomAreaSummary;
+  byBuilding: Map<string | null, RoomAreaSummary>;
+  byFloor: Map<string | null, RoomAreaSummary>;
+}
 
 export interface FloorGroup<TFloor extends FloorLike = FloorLike> {
   /** null for floors without (known) building. */
@@ -262,6 +275,59 @@ export function countRoomsByFloor(
   return counts;
 }
 
+/**
+ * Sums only known room areas and counts missing values separately. Rooms with
+ * no known floor/building are grouped under null for the corresponding UI
+ * entries "Ohne Etage" and "Ohne Gebäude".
+ */
+export function summarizeRoomAreas(
+  rooms: ReadonlyArray<RoomAreaLike>,
+  floors: ReadonlyArray<FloorLike>,
+  buildings: ReadonlyArray<BuildingLike>
+): StructureAreaSummaries {
+  const buildingIds = toIdSet(buildings);
+  const floorsById = new Map(floors.map((floor) => [floor.id, floor]));
+  const byBuilding = new Map<string | null, RoomAreaSummary>();
+  const byFloor = new Map<string | null, RoomAreaSummary>();
+  const total = emptyAreaSummary();
+
+  for (const room of rooms) {
+    const floor = room.floorId === null ? undefined : floorsById.get(room.floorId);
+    const floorId = floor?.id ?? null;
+    const buildingId = floor
+      ? resolveFloorBuildingId(floor, buildingIds)
+      : null;
+    addRoomArea(total, room.areaM2);
+    addRoomArea(summaryFor(byFloor, floorId), room.areaM2);
+    addRoomArea(summaryFor(byBuilding, buildingId), room.areaM2);
+  }
+  return { total, byBuilding, byFloor };
+}
+
+function emptyAreaSummary(): RoomAreaSummary {
+  return { areaM2: 0, roomCount: 0, missingAreaCount: 0 };
+}
+
+function summaryFor(
+  summaries: Map<string | null, RoomAreaSummary>,
+  key: string | null
+) {
+  const existing = summaries.get(key);
+  if (existing) return existing;
+  const created = emptyAreaSummary();
+  summaries.set(key, created);
+  return created;
+}
+
+function addRoomArea(summary: RoomAreaSummary, areaM2: number | null) {
+  summary.roomCount += 1;
+  if (areaM2 === null) {
+    summary.missingAreaCount += 1;
+  } else {
+    summary.areaM2 += areaM2;
+  }
+}
+
 /** "EG · Haus A", "EG" (floor without building) or "Ohne Etage". */
 export function describeRoomLocation(
   room: RoomLike,
diff --git a/src/frontend/utils/room-area.ts b/src/frontend/utils/room-area.ts
new file mode 100644
index 0000000..fa54fd8
--- /dev/null
+++ b/src/frontend/utils/room-area.ts
@@ -0,0 +1,30 @@
+export type RoomAreaParseResult =
+  | { ok: true; value: number | null }
+  | { ok: false; error: string };
+
+/** Parses an optional German decimal without rounding the stored value. */
+export function parseRoomAreaInput(text: string): RoomAreaParseResult {
+  const normalized = text.trim();
+  if (!normalized) return { ok: true, value: null };
+  if (!/^(?:\d+(?:,\d*)?|,\d+)$/.test(normalized)) {
+    return {
+      ok: false,
+      error: "Bitte eine nicht negative Zahl mit Komma eingeben.",
+    };
+  }
+  const value = Number(normalized.replace(",", "."));
+  return Number.isFinite(value) && value >= 0
+    ? { ok: true, value }
+    : { ok: false, error: "Die Fläche muss mindestens 0 m² betragen." };
+}
+
+export function formatRoomArea(areaM2: number): string {
+  return areaM2.toLocaleString("de-DE", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  });
+}
+
+export function formatOptionalRoomAreaInput(areaM2: number | null | undefined): string {
+  return areaM2 === null || areaM2 === undefined ? "" : formatRoomArea(areaM2);
+}
diff --git a/src/server/controllers/room.controller.ts b/src/server/controllers/room.controller.ts
index 3e78628..b65c42a 100644
--- a/src/server/controllers/room.controller.ts
+++ b/src/server/controllers/room.controller.ts
@@ -67,6 +67,7 @@ export async function updateRoom(req: Request, res: Response) {
     floorId: parsed.data.floorId,
     roomNumber: parsed.data.roomNumber,
     roomName: parsed.data.roomName,
+    areaM2: parsed.data.areaM2 === undefined ? current.areaM2 : parsed.data.areaM2,
   };
   try {
     const result = projectCommandService.executeUser({
diff --git a/src/shared/validation/project-structure.schemas.ts b/src/shared/validation/project-structure.schemas.ts
index 5ab13bf..b8655ba 100644
--- a/src/shared/validation/project-structure.schemas.ts
+++ b/src/shared/validation/project-structure.schemas.ts
@@ -135,6 +135,7 @@ export const createRoomSchema = z
     floorId: z.string().trim().min(1).optional(),
     roomNumber: z.string().trim().min(1).max(50),
     roomName: z.string().trim().min(1).max(200),
+    areaM2: z.number().finite().nonnegative().nullable().optional(),
   })
   .strict();
 
@@ -144,6 +145,7 @@ export const updateRoomSchema = z
     floorId: z.string().trim().min(1).nullable(),
     roomNumber: z.string().trim().min(1).max(50),
     roomName: z.string().trim().min(1).max(200),
+    areaM2: z.number().finite().nonnegative().nullable().optional(),
   })
   .strict();
 
diff --git a/tests/building-structure-view.test.ts b/tests/building-structure-view.test.ts
index 59271af..a024818 100644
--- a/tests/building-structure-view.test.ts
+++ b/tests/building-structure-view.test.ts
@@ -21,6 +21,7 @@ import {
   normalizeBuildingSelection,
   normalizeFloorSelection,
   showsRoomsWithoutFloorEntry,
+  summarizeRoomAreas,
 } from "../src/frontend/utils/building-structure.js";
 
 function building(id: string, name: string, sortOrder: number): BuildingDto {
@@ -36,13 +37,19 @@ function floor(
   return { id, projectId: "project-1", name, sortOrder, buildingId };
 }
 
-function room(id: string, floorId: string | null, roomNumber = id): RoomDto {
+function room(
+  id: string,
+  floorId: string | null,
+  roomNumber = id,
+  areaM2: number | null = null
+): RoomDto {
   return {
     id,
     projectId: "project-1",
     floorId,
     roomNumber,
     roomName: `Raum ${roomNumber}`,
+    areaM2,
   };
 }
 
@@ -263,6 +270,43 @@ describe("building structure view", () => {
     );
   });
 
+  it("sums known areas and counts missing areas per floor and building", () => {
+    const areaRooms = [
+      room("a", "f-a-eg", "a", 20.25),
+      room("b", "f-a-eg"),
+      room("c", "f-free", "c", 5.5),
+      room("d", null, "d", 3),
+      room("e", "f-deleted"),
+    ];
+    const summaries = summarizeRoomAreas(areaRooms, floors, buildings);
+
+    assert.deepEqual(summaries.total, {
+      areaM2: 28.75,
+      roomCount: 5,
+      missingAreaCount: 2,
+    });
+    assert.deepEqual(summaries.byFloor.get("f-a-eg"), {
+      areaM2: 20.25,
+      roomCount: 2,
+      missingAreaCount: 1,
+    });
+    assert.deepEqual(summaries.byFloor.get(null), {
+      areaM2: 3,
+      roomCount: 2,
+      missingAreaCount: 1,
+    });
+    assert.deepEqual(summaries.byBuilding.get("b-a"), {
+      areaM2: 20.25,
+      roomCount: 2,
+      missingAreaCount: 1,
+    });
+    assert.deepEqual(summaries.byBuilding.get(null), {
+      areaM2: 8.5,
+      roomCount: 3,
+      missingAreaCount: 1,
+    });
+  });
+
   it("describes a room location with floor and building", () => {
     assert.equal(
       describeRoomLocation(room("r", "f-a-og"), floors, buildings),
diff --git a/tests/print-view-migration.test.ts b/tests/print-view-migration.test.ts
index f94baf8..19e4dcc 100644
--- a/tests/print-view-migration.test.ts
+++ b/tests/print-view-migration.test.ts
@@ -28,10 +28,13 @@ it("upgrades a populated pre-print database through the current schema without c
         VALUES ('b', 'p', 'Existing board', 0.7);
       INSERT INTO floors (id, project_id, name, sort_order)
         VALUES ('f', 'p', 'Existing floor', 3);
+      INSERT INTO rooms (id, project_id, floor_id, room_number, room_name)
+        VALUES ('r', 'p', 'f', '101', 'Existing room');
     `);
     const oldProject = context.sqlite.prepare("SELECT * FROM projects").get() as Record<string, unknown>;
     const oldBoard = context.sqlite.prepare("SELECT * FROM distribution_boards").get() as Record<string, unknown>;
     const oldFloor = context.sqlite.prepare("SELECT * FROM floors").get() as Record<string, unknown>;
+    const oldRoom = context.sqlite.prepare("SELECT * FROM rooms").get() as Record<string, unknown>;
     const backup = path.join(staging, "before-print.db");
     files.push(backup);
     await context.sqlite.backup(backup);
@@ -40,12 +43,15 @@ it("upgrades a populated pre-print database through the current schema without c
     const project = context.sqlite.prepare("SELECT * FROM projects").get() as Record<string, unknown>;
     const board = context.sqlite.prepare("SELECT * FROM distribution_boards").get() as Record<string, unknown>;
     const floor = context.sqlite.prepare("SELECT * FROM floors").get() as Record<string, unknown>;
+    const room = context.sqlite.prepare("SELECT * FROM rooms").get() as Record<string, unknown>;
     for (const [key, value] of Object.entries(oldProject)) assert.deepEqual(project[key], value);
     for (const [key, value] of Object.entries(oldBoard)) assert.deepEqual(board[key], value);
     for (const [key, value] of Object.entries(oldFloor)) assert.deepEqual(floor[key], value);
+    for (const [key, value] of Object.entries(oldRoom)) assert.deepEqual(room[key], value);
     for (const field of ["site_address", "work_stage", "project_lead", "project_editor"]) assert.equal(project[field], null);
     for (const field of ["board_number", "location", "fed_from", "remark"]) assert.equal(board[field], null);
     assert.equal(floor.building_id, null);
+    assert.equal(room.area_m2, null);
     assert.equal(context.sqlite.prepare("SELECT count(*) AS count FROM buildings").get()!.count, 0);
     assert.equal(context.sqlite.prepare("SELECT count(*) AS count FROM document_branding_assets").get()!.count, 0);
     assert.equal(context.sqlite.prepare("SELECT count(*) AS count FROM document_branding_settings").get()!.count, 0);
diff --git a/tests/project-location-structure-project-command.repository.test.ts b/tests/project-location-structure-project-command.repository.test.ts
index 6378965..03f70f9 100644
--- a/tests/project-location-structure-project-command.repository.test.ts
+++ b/tests/project-location-structure-project-command.repository.test.ts
@@ -22,6 +22,11 @@ import {
   createProjectRoomInsertProjectCommand,
   createProjectRoomSnapshot,
   createProjectRoomUpdateProjectCommand,
+  projectRoomCommandSchemaVersion,
+  projectRoomDeleteCommandType,
+  projectRoomUpdateCommandType,
+  type LegacyProjectRoomDeleteProjectCommand,
+  type LegacyProjectRoomUpdateProjectCommand,
 } from "../src/domain/models/project-location-structure-project-command.model.js";
 import {
   createFloor,
@@ -66,10 +71,12 @@ describe("project-location structure project command", () => {
       floorId: floor.id,
       roomNumber: " 001 ",
       roomName: " Technik ",
+      areaM2: 23.456,
     });
     assert.equal(floor.name, "EG");
     assert.equal(room.roomNumber, "001");
     assert.equal(room.roomName, "Technik");
+    assert.equal(room.areaM2, 23.456);
     assert.throws(
       () =>
         createProjectFloorInsertProjectCommand({
@@ -113,6 +120,7 @@ describe("project-location structure project command", () => {
           floorId: "floor-1",
           roomNumber: "001",
           roomName: "Technik",
+          areaM2: 23.456,
         },
         8
       );
@@ -120,7 +128,7 @@ describe("project-location structure project command", () => {
       await updateRoom(
         "project-1",
         "room-1",
-        { roomNumber: "101", roomName: "Büro" },
+        { roomNumber: "101", roomName: "Büro", areaM2: null },
         10
       );
       await deleteFloor("project-1", "floor-1", 11);
@@ -141,6 +149,7 @@ describe("project-location structure project command", () => {
           floorId: "floor-1",
           roomNumber: "001",
           roomName: "Technik",
+          areaM2: 23.456,
           expectedRevision: 8,
         },
       },
@@ -155,6 +164,7 @@ describe("project-location structure project command", () => {
         body: {
           roomNumber: "101",
           roomName: "Büro",
+          areaM2: null,
           floorId: null,
           expectedRevision: 10,
         },
@@ -199,6 +209,7 @@ describe("project-location structure project command", () => {
         floorId: null,
         roomNumber: "002",
         roomName: "Lager",
+        areaM2: 48.125,
       };
       const roomCommand = createProjectRoomUpdateProjectCommand(room, updatedRoom);
       const roomResult = repository.execute({
@@ -427,6 +438,64 @@ describe("project-location structure project command", () => {
     }
   });
 
+  it("upgrades version-1 room commands without overwriting a newer area", () => {
+    const context = createTestDatabase();
+    try {
+      const repository = new ProjectLocationStructureProjectCommandRepository(context.db);
+      const history = new ProjectHistoryRepository(context.db);
+      const room = createProjectRoomSnapshot("project-1", {
+        roomNumber: "001",
+        roomName: "Technik",
+      });
+      context.db.insert(rooms).values(room).run();
+      const { areaM2: _expectedArea, ...legacyExpected } = room;
+      const legacyTarget = { ...legacyExpected, roomName: "Technik alt" };
+      const legacyUpdate: LegacyProjectRoomUpdateProjectCommand = {
+        schemaVersion: 1,
+        type: projectRoomUpdateCommandType,
+        payload: { expected: legacyExpected, target: legacyTarget },
+      };
+
+      const updated = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: legacyUpdate,
+      });
+      assert.equal(updated.inverse.schemaVersion, projectRoomCommandSchemaVersion);
+      assert.equal(context.db.select().from(rooms).get()?.areaM2, null);
+
+      const undo = history.getNextCommand("project-1", "undo");
+      assert.ok(undo);
+      repository.execute({
+        projectId: "project-1",
+        expectedRevision: 1,
+        source: "undo",
+        historyTargetChangeSetId: undo.changeSetId,
+        command: updated.inverse,
+      });
+      context.db.update(rooms).set({ areaM2: 12.5 }).where(eq(rooms.id, room.id)).run();
+      const legacyDelete: LegacyProjectRoomDeleteProjectCommand = {
+        schemaVersion: 1,
+        type: projectRoomDeleteCommandType,
+        payload: { room: legacyExpected },
+      };
+      assert.throws(
+        () =>
+          repository.execute({
+            projectId: "project-1",
+            expectedRevision: 2,
+            source: "user",
+            command: legacyDelete,
+          }),
+        /changed before deletion/
+      );
+      assert.equal(context.db.select().from(rooms).get()?.areaM2, 12.5);
+    } finally {
+      context.close();
+    }
+  });
+
   it("rejects foreign, stale and changed locations without partial writes", () => {
     const context = createTestDatabase();
     try {
diff --git a/tests/project-snapshot.repository.test.ts b/tests/project-snapshot.repository.test.ts
index 9131205..7a02fec 100644
--- a/tests/project-snapshot.repository.test.ts
+++ b/tests/project-snapshot.repository.test.ts
@@ -142,6 +142,7 @@ function createTestDatabase(): DatabaseContext {
       floorId: "floor-1",
       roomNumber: "001",
       roomName: "Technik",
+      areaM2: 31.75,
     })
     .run();
   context.db
@@ -461,12 +462,16 @@ describe("project snapshot repository", () => {
         distributionBoards: Array<Record<string, unknown>>;
         buildings?: unknown;
         floors: Array<Record<string, unknown>>;
+        rooms: Array<Record<string, unknown>>;
       };
       payload.schemaVersion = 5;
       delete payload.buildings;
       for (const floor of payload.floors) {
         delete floor.buildingId;
       }
+      for (const room of payload.rooms) {
+        delete room.areaM2;
+      }
       for (const field of ["siteAddress", "workStage", "projectLead", "projectEditor"]) {
         delete payload.project[field];
       }
@@ -597,6 +602,7 @@ describe("portable project transfer", () => {
         copied.state.circuits[0].deviceRows[0].roomId,
         copied.state.rooms[0].id
       );
+      assert.equal(copied.state.rooms[0].areaM2, 31.75);
       assert.equal(
         copied.state.distributionBoards[0].floorId,
         copied.state.floors[0].id
diff --git a/tests/project-state-restore-command.repository.test.ts b/tests/project-state-restore-command.repository.test.ts
index 2f9a841..b093f9e 100644
--- a/tests/project-state-restore-command.repository.test.ts
+++ b/tests/project-state-restore-command.repository.test.ts
@@ -96,6 +96,7 @@ function createTestDatabase(): DatabaseContext {
       floorId: "floor-1",
       roomNumber: "001",
       roomName: "Technik",
+      areaM2: 31.75,
     })
     .run();
   context.db
diff --git a/tests/project-state-snapshot.test.ts b/tests/project-state-snapshot.test.ts
index c75555f..c067c19 100644
--- a/tests/project-state-snapshot.test.ts
+++ b/tests/project-state-snapshot.test.ts
@@ -91,7 +91,14 @@ function minimalSnapshot() {
       sortOrder: number;
       buildingId: string | null;
     }>,
-    rooms: [],
+    rooms: [] as Array<{
+      id: string;
+      projectId: string;
+      floorId: string | null;
+      roomNumber: string;
+      roomName: string;
+      areaM2: number | null;
+    }>,
   };
 }
 
@@ -443,6 +450,26 @@ describe("project state snapshot model", () => {
     assert.throws(() => parseProjectStateSnapshot(floorWithoutBuildingField));
   });
 
+  it("keeps room areas and upgrades snapshot version 7 with an empty area", () => {
+    const current = minimalSnapshot();
+    current.rooms.push({
+      id: "room-1",
+      projectId: "project-1",
+      floorId: null,
+      roomNumber: "001",
+      roomName: "Technik",
+      areaM2: 23.456,
+    });
+    assert.equal(parseProjectStateSnapshot(current).rooms[0]?.areaM2, 23.456);
+
+    const previous = structuredClone(current);
+    previous.schemaVersion = 7 as typeof previous.schemaVersion;
+    delete (previous.rooms[0] as Partial<(typeof previous.rooms)[number]>).areaM2;
+    const upgraded = parseProjectStateSnapshot(previous);
+    assert.equal(upgraded.schemaVersion, projectStateSnapshotSchemaVersion);
+    assert.equal(upgraded.rooms[0]?.areaM2, null);
+  });
+
   it("upgrades snapshot version 6 without buildings", () => {
     const snapshot = minimalSnapshot();
     snapshot.floors.push({
diff --git a/tests/revit-csv-frontend-api.test.ts b/tests/revit-csv-frontend-api.test.ts
index 3603aa7..add2eb7 100644
--- a/tests/revit-csv-frontend-api.test.ts
+++ b/tests/revit-csv-frontend-api.test.ts
@@ -151,7 +151,7 @@ describe("Revit CSV modal presentation", () => {
       objects: [],
       existing: {
         floors: [{ id: "floor-1", name: "EG", sortOrder: 0 }],
-        rooms: [{ id: "room-1", floorId: "floor-1", roomNumber: "101", roomName: "Büro" }],
+        rooms: [{ id: "room-1", floorId: "floor-1", roomNumber: "101", roomName: "Büro", areaM2: null }],
         distributionBoards: [{ id: "board-1", name: "UV-01", floorId: "floor-1" }],
         projectDevices: [{ id: "device-1", name: "Steckdose", displayName: "Steckdose", category: "single_phase", connectionKind: null, powerPerUnit: 100 }],
       },
diff --git a/tests/room-area.test.ts b/tests/room-area.test.ts
new file mode 100644
index 0000000..e00f336
--- /dev/null
+++ b/tests/room-area.test.ts
@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { RoomModal } from "../src/frontend/components/room-modal.js";
+import {
+  formatRoomArea,
+  parseRoomAreaInput,
+} from "../src/frontend/utils/room-area.js";
+import {
+  createRoomSchema,
+  updateRoomSchema,
+} from "../src/shared/validation/project-structure.schemas.js";
+
+describe("room area input", () => {
+  it("parses optional German decimals without rounding", () => {
+    assert.deepEqual(parseRoomAreaInput(""), { ok: true, value: null });
+    assert.deepEqual(parseRoomAreaInput(" 23,456 "), { ok: true, value: 23.456 });
+    assert.deepEqual(parseRoomAreaInput(",5"), { ok: true, value: 0.5 });
+    assert.deepEqual(parseRoomAreaInput("0"), { ok: true, value: 0 });
+    for (const value of ["-1", "23.45", "abc", "1,2,3"]) {
+      assert.equal(parseRoomAreaInput(value).ok, false, value);
+    }
+    assert.equal(formatRoomArea(23.456), "23,46");
+  });
+
+  it("validates finite non-negative API values and remains backward compatible", () => {
+    const base = {
+      expectedRevision: 1,
+      roomNumber: "101",
+      roomName: "Büro",
+    };
+    assert.equal(createRoomSchema.safeParse({ ...base, areaM2: 23.456 }).success, true);
+    assert.equal(createRoomSchema.safeParse({ ...base, areaM2: null }).success, true);
+    assert.equal(createRoomSchema.safeParse(base).success, true);
+    assert.equal(updateRoomSchema.safeParse({ ...base, floorId: null }).success, true);
+    assert.equal(createRoomSchema.safeParse({ ...base, areaM2: -1 }).success, false);
+    assert.equal(createRoomSchema.safeParse({ ...base, areaM2: Number.NaN }).success, false);
+  });
+
+  it("renders the optional area with two decimals in the shared room dialog", () => {
+    const markup = renderToStaticMarkup(
+      createElement(RoomModal, {
+        floors: [],
+        initialValues: {
+          roomNumber: "101",
+          roomName: "Büro",
+          areaM2: 23.4,
+        },
+        isSaving: false,
+        onClose: () => undefined,
+        onSave: async () => undefined,
+      })
+    );
+    assert.match(markup, /Fläche \[m²\]/);
+    assert.match(markup, /value="23,40"/);
+    assert.match(markup, /Netto-Raumfläche/);
+  });
+});

From b50c00c0ac2ea2406d300ea9a77b92ce62c0339f Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 20:36:43 +0200
Subject: [PATCH 33/60] Bring documentation in line with integrated features

List the building structure, room areas, rough power balance and cable
sizing in the README and documentation map, add an architecture section
for the rough power balance, correct stale snapshot schema references and
record the integrated contributor features in the backlog.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 AGENTS.md                               |  2 +-
 README.md                               | 12 +++++++++-
 docs/README.md                          |  4 ++--
 docs/current-architecture.md            | 29 +++++++++++++++++++++----
 docs/spec/08-current-product-backlog.md | 19 ++++++++++++++++
 5 files changed, 58 insertions(+), 8 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index b0b28ff..8312d55 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -323,7 +323,7 @@ immutable import batches with original bytes plus the classified cell matrix,
 normalized source-room mappings and external objects unique by
 `(sourceId, ifcGuid)`. Source values, planning values and overrides are separate.
 The general external-model repository is read-only; runtime writes belong only
-to typed command adapters. Snapshot/restore and portable project transfer schema version 5/6
+to typed command adapters. Snapshot/restore and portable project transfer schema versions 5-8
 capture the complete external state and remap every internal UUID and link while
 preserving IFCGUIDs, source values, original bytes and the classified matrix.
 Import batches additionally store the monotonic project CSV configuration
diff --git a/README.md b/README.md
index b3c026e..b01ae85 100644
--- a/README.md
+++ b/README.md
@@ -15,12 +15,16 @@ des Linear-Plugins in Revit.
 
 ## Unterstützter Arbeitsablauf
 
-- Projekte, Verteilungen, Etagen und Räume verwalten
+- Projekte und Verteilungen verwalten; Gebäude, Etagen und Räume auf einer
+  eigenen Seite pflegen, Räume optional mit Fläche und Summen je Etage und
+  Gebäude
 - pro Verteilung geschützte Stromkreisgruppen für Beleuchtung, 1-phasige und
   3-phasige Stromkreise verwalten
 - Hauptschalter, Überspannungsableiter, Gruppenschutz und zusätzliche
   Verteilergeräte in der Stromkreisliste abbilden
 - Schutzgeräte je Stromkreis und optional je Gruppe konfigurieren
+- Leitungsquerschnitte für einzelne Stromkreise auf Anforderung nach
+  DIN VDE 0298-4 berechnen und ausdrücklich übernehmen
 - leere, einzeilige und mehrzeilige Stromkreise abbilden
 - Stromkreise und Gerätezeilen per Drag-and-drop umstrukturieren
 - Projektgeräte einfügen, verknüpfen und kontrolliert synchronisieren
@@ -31,6 +35,9 @@ des Linear-Plugins in Revit.
 - automatische Sicherungspunkte mit begrenzter Aufbewahrung nutzen
 - Seitenansicht mit Deckblatt, Verteilerübersicht und Verteilerplänen öffnen
   und über den Browser als PDF drucken; Büroangaben und Logo zentral pflegen
+- grobe Leistungsbilanzen für LPH 2/3 nach Kostengruppen führen, mit der
+  detaillierten Bilanz vergleichen und einzelne Zeilen als Projektgerät
+  übernehmen
 - Revit-CSV-Dateien konfigurieren, prüfen und nach expliziter Zuordnung von
   Räumen, Verteilungen und Projektgeräten erstmals importieren; dabei entstehen
   noch keine Stromkreise oder Gerätezeilen
@@ -152,6 +159,9 @@ vor der Baseline werden nicht unterstützt.
 - [Editor-Interaktionen](docs/circuit-list-editor-interactions.md)
 - [API des Stromkreislisten-Editors](docs/circuit-list-editor-api.md)
 - [Seitenansicht und PDF-Export](docs/print-view.md)
+- [Gebäudestruktur und Raumflächen](docs/building-structure.md)
+- [Grobe Leistungsbilanz](docs/estimate-balance.md)
+- [Leitungsberechnung](docs/cable-sizing-module.md)
 - [Entwicklungs- und Contributor-Workflow](docs/development-workflow.md)
 - [Bekannte Einschränkungen](docs/circuit-list-editor-known-limitations.md)
 - [Roadmap](docs/spec/07-implementation-phases-todo.md)
diff --git a/docs/README.md b/docs/README.md
index c04103a..01b5588 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -15,9 +15,9 @@ ausdrücklich getrennt und dürfen nicht als bereits implementiert verstanden we
 - [Seitenansicht und PDF-Export](print-view.md) – Deckblatt,
   Verteilerübersicht, Verteilerpläne, Büro-Logo
 - [Gebäudestruktur](building-structure.md) – Gebäude → Etagen → Räume,
-  Befehle, Snapshot-Schema 7, eigene Seite
+  Raumflächen und Summen, Befehle, Snapshot-Schema 8, eigene Seite
 - [Grobe Leistungsbilanz](estimate-balance.md) – LPH 2/3 nach Kostengruppen,
-  Rechnung, Vergleich mit der detaillierten Bilanz
+  Rechnung, Vergleich mit der detaillierten Bilanz, Übernahme als Projektgerät
 - [Editor-API](circuit-list-editor-api.md) – unterstützte Circuit-First-Endpunkte
 - [Bekannte Einschränkungen](circuit-list-editor-known-limitations.md) –
   bewusst noch nicht implementierte oder begrenzte Funktionen
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index baf6883..332b6a9 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -43,8 +43,13 @@ vor dem Command und bleiben über Undo/Redo unverändert.
 ## Wichtige Einstiegspunkte
 
 - `src/app/projects/page.tsx` – Projektliste und globale Gerätebibliothek
-- `src/app/projects/[projectId]/page.tsx` – Projektstammdaten, Verteilungen,
-  Räume und Projektgeräte
+- `src/app/projects/[projectId]/page.tsx` – Projektstammdaten, Verteilungen
+  und Projektgeräte
+- `src/app/projects/[projectId]/struktur/page.tsx` – Gebäude, Etagen, Räume
+  und Raumflächen
+- `src/app/projects/[projectId]/grobbilanz/` – Stände und Editor der groben
+  Leistungsbilanz
+- `src/app/projects/[projectId]/print/page.tsx` – Seitenansicht und PDF-Export
 - `src/app/projects/[projectId]/circuit-lists/[circuitListId]/tree-edit/page.tsx`
   – unterstützte Editorroute
 - `src/frontend/components/circuit-tree-editor.tsx` – Editorzustand,
@@ -525,6 +530,22 @@ Querschnitt und Länge über den regulären `circuit.update`-Befehl, also mit
 Revision und Undo/Redo. Details, Rechenweg und Prüfnachweis der Tabellen:
 `docs/cable-sizing-module.md`.
 
+## Grobe Leistungsbilanz
+
+Das Modul `src/estimate-balance` mit der importfreien Rechnung in
+`src/shared/estimate-balance` führt Leistungsbilanzen für LPH 2/3 nach
+DIN-276-Kostengruppen in eigenen Tabellen (`estimate_*`, Migration `0010`).
+Es ist nicht mit der Stromkreisstruktur verknüpft und liest Gerätezeilen nur
+für den Vergleich „geschätzt ↔ detailliert“ über das längste passende
+Kostengruppen-Präfix. Schreibzugriffe laufen über `estimate-balance.insert`,
+`.update` und `.delete` mit vollständigen Dokumenten, also mit Revision und
+Undo/Redo. Grobbilanzen sind Teil von Transferformat 2, aber bewusst nicht Teil
+der logischen Snapshots; ein Restore lässt sie unverändert. Einzelne Zeilen
+lassen sich über den vorbelegten Projektgeräte-Dialog ausdrücklich als
+Projektgerät kopieren (`project-device.insert`, ohne gespeicherte Verknüpfung).
+Oberfläche: `/projects/:projectId/grobbilanz`. Details:
+`docs/estimate-balance.md`.
+
 ## Persistenz und Migration
 
 - SQLite ist die aktuell unterstützte Datenbank.
@@ -559,7 +580,7 @@ Revision und Undo/Redo. Details, Rechenweg und Prüfnachweis der Tabellen:
   `toLowerCase()` gegen das vollständige Register der Stromkreisliste und wird
   von jedem Anlage-/Umbenennungspfad für Stromkreise und Verteilerkomponenten
   aufgerufen, auch dort, wo zuvor kein Vorab-Check existierte. Snapshot- und
-  Transfer-Integration verwenden aktuell Snapshot-Schema 6. Persistente
+  Transfer-Integration verwenden aktuell Snapshot-Schema 8. Persistente
   Insert/Delete/Update-Commands für veränderliche Verteilerkomponenten,
   Gruppen einschließlich befüllter Unterbäume sowie vollständige
   Gruppensortierung sind integriert. Der Editor zeigt die geschützte Struktur
@@ -591,7 +612,7 @@ einschließlich BOM, CRLF und Quotierung bytegleich zurück. Der lokale Befehl
 
 `external_csv_configurations` enthält höchstens eine versionierte Konfiguration
 je Projekt. `external-csv-configuration.update` schreibt Anlage, Änderung oder
-Entfernung zusammen mit Revision und persistentem Undo/Redo. Snapshot-Schema 6,
+Entfernung zusammen mit Revision und persistentem Undo/Redo. Snapshot-Schema 5–8,
 Restore und portabler Projekttransfer enthalten diesen Zustand; beim Duplizieren
 werden Konfigurations-UUID und Projektlink remapped.
 
diff --git a/docs/spec/08-current-product-backlog.md b/docs/spec/08-current-product-backlog.md
index e7821b4..d31eecc 100644
--- a/docs/spec/08-current-product-backlog.md
+++ b/docs/spec/08-current-product-backlog.md
@@ -135,6 +135,25 @@ The pre-release cleanup established the following compatibility boundary:
 - [x] Keep column visibility and order as a project-specific UI preference so
   all distribution boards in the same project open with the same columns.
 
+## Integrated Contributor Features (September 2026)
+
+- [x] Client ids without secure-context browser APIs (`createClientId`).
+- [x] Icon actions, compact column headers and the AMEV picker in the circuit
+  list; icon actions and collapsible filters on the project overview.
+- [x] Print view with cover, board overview, board plans, board info card and
+  office branding.
+- [x] Buildings above floors and a dedicated building structure page.
+- [x] Optional net room area with sums per floor and building.
+- [x] Optional cable-sizing module for one circuit on demand
+  (DIN VDE 0298-4:2023-06 with Berichtigung 1).
+- [x] Rough power balance for LPH 2/3 by cost group, including the comparison
+  with the detailed balance and the explicit copy of one row as a
+  ProjectDevice.
+
+Open follow-ups (Gitea issues): logical feed link between distribution boards
+(#3), bill of quantities export (#5), area-based loads in W/m² for
+ProjectDevices and device rows (#20).
+
 ## Recommended Sequence
 
 1. [x] Distribution-board floor and supply fields.

From b893c725343c9f5e2bca8e64fdf88c4fa528c0a4 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 22:21:58 +0200
Subject: [PATCH 34/60] Add logical distribution board feed links

---
 src/db/migrations/0012_good_gateway.sql       |    4 +
 src/db/migrations/meta/0012_snapshot.json     | 2986 +++++++++++++++++
 src/db/migrations/meta/_journal.json          |    7 +
 ...rd-structure-project-command.repository.ts |   95 +-
 ...oard-subtree-project-command.repository.ts |   63 +
 ...roject-state-restore-command.repository.ts |   44 +-
 .../project-transfer.repository.ts            |   29 +-
 src/db/schema/circuit-lists.ts                |    4 +-
 src/db/schema/circuits.ts                     |    4 +-
 src/db/schema/distribution-boards.ts          |   58 +-
 ...istribution-board-project-command.model.ts |   42 +-
 ...stribution-board-subtree-snapshot.model.ts |   17 +
 .../models/project-state-snapshot.model.ts    |  112 +-
 src/domain/models/project-transfer.model.ts   |    8 +
 src/frontend/types.ts                         |    2 +
 src/frontend/utils/api.ts                     |    8 +-
 .../distribution-board.controller.ts          |   14 +
 .../validation/project-structure.schemas.ts   |    2 +
 ...ructure-project-command.repository.test.ts |  153 +
 tests/distribution-board-subtree.test.ts      |    7 +
 tests/print-view-migration.test.ts            |    2 +
 tests/project-snapshot.repository.test.ts     |    9 +-
 tests/project-state-snapshot.test.ts          |  107 +-
 23 files changed, 3732 insertions(+), 45 deletions(-)
 create mode 100644 src/db/migrations/0012_good_gateway.sql
 create mode 100644 src/db/migrations/meta/0012_snapshot.json

diff --git a/src/db/migrations/0012_good_gateway.sql b/src/db/migrations/0012_good_gateway.sql
new file mode 100644
index 0000000..57ad9dc
--- /dev/null
+++ b/src/db/migrations/0012_good_gateway.sql
@@ -0,0 +1,4 @@
+ALTER TABLE `distribution_boards` ADD `feeding_distribution_board_id` text REFERENCES distribution_boards(id);--> statement-breakpoint
+ALTER TABLE `distribution_boards` ADD `feeding_circuit_id` text REFERENCES circuits(id);--> statement-breakpoint
+CREATE INDEX `distribution_boards_feeding_board_idx` ON `distribution_boards` (`feeding_distribution_board_id`);--> statement-breakpoint
+CREATE INDEX `distribution_boards_feeding_circuit_idx` ON `distribution_boards` (`feeding_circuit_id`);
\ No newline at end of file
diff --git a/src/db/migrations/meta/0012_snapshot.json b/src/db/migrations/meta/0012_snapshot.json
new file mode 100644
index 0000000..832cf1a
--- /dev/null
+++ b/src/db/migrations/meta/0012_snapshot.json
@@ -0,0 +1,2986 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "8029e6ab-56de-4345-8d38-0ca7462640de",
+  "prevId": "63f27b3a-7378-462d-8119-b67d67903dbb",
+  "tables": {
+    "buildings": {
+      "name": "buildings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "buildings_project_id_projects_id_fk": {
+          "name": "buildings_project_id_projects_id_fk",
+          "tableFrom": "buildings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_device_rows": {
+      "name": "circuit_device_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "level": {
+          "name": "level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number_snapshot": {
+          "name": "room_number_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_name_snapshot": {
+          "name": "room_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "manual_quantity": {
+          "name": "manual_quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_device_rows_circuit_id_idx": {
+          "name": "circuit_device_rows_circuit_id_idx",
+          "columns": [
+            "circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "circuit_device_rows_circuit_id_circuits_id_fk": {
+          "name": "circuit_device_rows_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_linked_project_device_id_project_devices_id_fk": {
+          "name": "circuit_device_rows_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_room_id_rooms_id_fk": {
+          "name": "circuit_device_rows_room_id_rooms_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_list_equipment_identifiers": {
+      "name": "circuit_list_equipment_identifiers",
+      "columns": {
+        "owner_type": {
+          "name": "owner_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_list_equipment_identifiers_owner_unique": {
+          "name": "circuit_list_equipment_identifiers_owner_unique",
+          "columns": [
+            "owner_type",
+            "owner_id"
+          ],
+          "isUnique": true
+        },
+        "circuit_list_equipment_identifiers_list_identifier_unique": {
+          "name": "circuit_list_equipment_identifiers_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_list_equipment_identifiers",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_lists": {
+      "name": "circuit_lists",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_lists_distribution_board_id_unique": {
+          "name": "circuit_lists_distribution_board_id_unique",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_lists_project_id_projects_id_fk": {
+          "name": "circuit_lists_project_id_projects_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_lists_distribution_board_id_distribution_boards_id_fk": {
+          "name": "circuit_lists_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_protection_devices": {
+      "name": "circuit_protection_devices",
+      "columns": {
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "circuit_protection_devices_circuit_id_circuits_id_fk": {
+          "name": "circuit_protection_devices_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_protection_devices",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_sections": {
+      "name": "circuit_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "group_number": {
+          "name": "group_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_sections_list_key_unique": {
+          "name": "circuit_sections_list_key_unique",
+          "columns": [
+            "circuit_list_id",
+            "key"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_prefix_unique": {
+          "name": "circuit_sections_list_prefix_unique",
+          "columns": [
+            "circuit_list_id",
+            "prefix"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_category_group_unique": {
+          "name": "circuit_sections_list_category_group_unique",
+          "columns": [
+            "circuit_list_id",
+            "category",
+            "group_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_sections_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_sections_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_sections",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuits": {
+      "name": "circuits",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "cable_type": {
+          "name": "cable_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_cross_section": {
+          "name": "cable_cross_section",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_length": {
+          "name": "cable_length",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_assignment": {
+          "name": "rcd_assignment",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_designation": {
+          "name": "terminal_designation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage": {
+          "name": "voltage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "control_requirement": {
+          "name": "control_requirement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_reserve": {
+          "name": "is_reserve",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuits_section_id_idx": {
+          "name": "circuits_section_id_idx",
+          "columns": [
+            "section_id"
+          ],
+          "isUnique": false
+        },
+        "circuits_list_equipment_identifier_unique": {
+          "name": "circuits_list_equipment_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuits_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuits_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuits_section_id_circuit_sections_id_fk": {
+          "name": "circuits_section_id_circuit_sections_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_component_protection_devices": {
+      "name": "distribution_board_component_protection_devices",
+      "columns": {
+        "component_id": {
+          "name": "component_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk": {
+          "name": "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk",
+          "tableFrom": "distribution_board_component_protection_devices",
+          "tableTo": "distribution_board_components",
+          "columnsFrom": [
+            "component_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_components": {
+      "name": "distribution_board_components",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "placement": {
+          "name": "placement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "distribution_board_components_list_identifier_unique": {
+          "name": "distribution_board_components_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        },
+        "distribution_board_components_section_role_unique": {
+          "name": "distribution_board_components_section_role_unique",
+          "columns": [
+            "section_id",
+            "role"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "distribution_board_components_circuit_list_id_circuit_lists_id_fk": {
+          "name": "distribution_board_components_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_board_components_section_id_circuit_sections_id_fk": {
+          "name": "distribution_board_components_section_id_circuit_sections_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_boards": {
+      "name": "distribution_boards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "supply_type": {
+          "name": "supply_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "board_number": {
+          "name": "board_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "location": {
+          "name": "location",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fed_from": {
+          "name": "fed_from",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "feeding_distribution_board_id": {
+          "name": "feeding_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "feeding_circuit_id": {
+          "name": "feeding_circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "distribution_boards_feeding_board_idx": {
+          "name": "distribution_boards_feeding_board_idx",
+          "columns": [
+            "feeding_distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "distribution_boards_feeding_circuit_idx": {
+          "name": "distribution_boards_feeding_circuit_idx",
+          "columns": [
+            "feeding_circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "distribution_boards_project_id_projects_id_fk": {
+          "name": "distribution_boards_project_id_projects_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_floor_id_floors_id_fk": {
+          "name": "distribution_boards_floor_id_floors_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_feeding_distribution_board_id_distribution_boards_id_fk": {
+          "name": "distribution_boards_feeding_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "feeding_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_feeding_circuit_id_circuits_id_fk": {
+          "name": "distribution_boards_feeding_circuit_id_circuits_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "feeding_circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_assets": {
+      "name": "document_branding_assets",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_settings": {
+      "name": "document_branding_settings",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_balances": {
+      "name": "estimate_balances",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "date_iso": {
+          "name": "date_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "reserve_av_percent": {
+          "name": "reserve_av_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "reserve_sv_percent": {
+          "name": "reserve_sv_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_balances_project_id_idx": {
+          "name": "estimate_balances_project_id_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_balances_project_id_projects_id_fk": {
+          "name": "estimate_balances_project_id_projects_id_fk",
+          "tableFrom": "estimate_balances",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_groups": {
+      "name": "estimate_groups",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "balance_id": {
+          "name": "balance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "editor": {
+          "name": "editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_groups_balance_id_idx": {
+          "name": "estimate_groups_balance_id_idx",
+          "columns": [
+            "balance_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_groups_balance_id_estimate_balances_id_fk": {
+          "name": "estimate_groups_balance_id_estimate_balances_id_fk",
+          "tableFrom": "estimate_groups",
+          "tableTo": "estimate_balances",
+          "columnsFrom": [
+            "balance_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_rows": {
+      "name": "estimate_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "supply": {
+          "name": "supply",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "unit": {
+          "name": "unit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'piece'"
+        },
+        "connection": {
+          "name": "connection",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_per_unit_w": {
+          "name": "power_per_unit_w",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "safety_supply": {
+          "name": "safety_supply",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "estimate_rows_group_id_idx": {
+          "name": "estimate_rows_group_id_idx",
+          "columns": [
+            "group_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_rows_group_id_estimate_groups_id_fk": {
+          "name": "estimate_rows_group_id_estimate_groups_id_fk",
+          "tableFrom": "estimate_rows",
+          "tableTo": "estimate_groups",
+          "columnsFrom": [
+            "group_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_csv_configurations": {
+      "name": "external_csv_configurations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration": {
+          "name": "configuration",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_csv_configurations_project_id_unique": {
+          "name": "external_csv_configurations_project_id_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_csv_configurations_project_id_projects_id_fk": {
+          "name": "external_csv_configurations_project_id_projects_id_fk",
+          "tableFrom": "external_csv_configurations",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_import_batches": {
+      "name": "external_import_batches",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "import_kind": {
+          "name": "import_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "imported_at_iso": {
+          "name": "imported_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "applied_project_revision": {
+          "name": "applied_project_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_snapshot": {
+          "name": "configuration_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "original_bytes": {
+          "name": "original_bytes",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "document": {
+          "name": "document",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_import_batches_project_revision_idx": {
+          "name": "external_import_batches_project_revision_idx",
+          "columns": [
+            "project_id",
+            "applied_project_revision"
+          ],
+          "isUnique": false
+        },
+        "external_import_batches_source_imported_idx": {
+          "name": "external_import_batches_source_imported_idx",
+          "columns": [
+            "source_id",
+            "imported_at_iso"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_import_batches_project_id_projects_id_fk": {
+          "name": "external_import_batches_project_id_projects_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_import_batches_source_id_external_model_sources_id_fk": {
+          "name": "external_import_batches_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_objects": {
+      "name": "external_model_objects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ifc_guid": {
+          "name": "ifc_guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen_import_batch_id": {
+          "name": "last_seen_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_accepted_import_batch_id": {
+          "name": "last_accepted_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "accepted_source_values": {
+          "name": "accepted_source_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "planning_values": {
+          "name": "planning_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "external_room_mapping_id": {
+          "name": "external_room_mapping_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "circuit_device_row_id": {
+          "name": "circuit_device_row_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "presence_status": {
+          "name": "presence_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'present'"
+        }
+      },
+      "indexes": {
+        "external_model_objects_source_ifc_guid_unique": {
+          "name": "external_model_objects_source_ifc_guid_unique",
+          "columns": [
+            "source_id",
+            "ifc_guid"
+          ],
+          "isUnique": true
+        },
+        "external_model_objects_project_presence_idx": {
+          "name": "external_model_objects_project_presence_idx",
+          "columns": [
+            "project_id",
+            "presence_status"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_distribution_board_idx": {
+          "name": "external_model_objects_distribution_board_idx",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_circuit_device_row_idx": {
+          "name": "external_model_objects_circuit_device_row_idx",
+          "columns": [
+            "circuit_device_row_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_model_objects_project_id_projects_id_fk": {
+          "name": "external_model_objects_project_id_projects_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_source_id_external_model_sources_id_fk": {
+          "name": "external_model_objects_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_seen_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_accepted_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk": {
+          "name": "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_room_mappings",
+          "columnsFrom": [
+            "external_room_mapping_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_model_objects_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_linked_project_device_id_project_devices_id_fk": {
+          "name": "external_model_objects_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk": {
+          "name": "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "circuit_device_rows",
+          "columnsFrom": [
+            "circuit_device_row_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_sources": {
+      "name": "external_model_sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_type": {
+          "name": "source_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'revit_csv'"
+        }
+      },
+      "indexes": {
+        "external_model_sources_project_type_unique": {
+          "name": "external_model_sources_project_type_unique",
+          "columns": [
+            "project_id",
+            "source_type"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_sources_project_id_projects_id_fk": {
+          "name": "external_model_sources_project_id_projects_id_fk",
+          "tableFrom": "external_model_sources",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_room_mappings": {
+      "name": "external_room_mappings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "normalized_source_room_key": {
+          "name": "normalized_source_room_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_floor_name": {
+          "name": "source_floor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_room_number": {
+          "name": "source_room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_room_name": {
+          "name": "source_room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_distribution_board_id": {
+          "name": "default_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_room_mappings_source_key_unique": {
+          "name": "external_room_mappings_source_key_unique",
+          "columns": [
+            "source_id",
+            "normalized_source_room_key"
+          ],
+          "isUnique": true
+        },
+        "external_room_mappings_project_room_idx": {
+          "name": "external_room_mappings_project_room_idx",
+          "columns": [
+            "project_id",
+            "room_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_room_mappings_project_id_projects_id_fk": {
+          "name": "external_room_mappings_project_id_projects_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_source_id_external_model_sources_id_fk": {
+          "name": "external_room_mappings_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_room_id_rooms_id_fk": {
+          "name": "external_room_mappings_room_id_rooms_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "default_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "floors": {
+      "name": "floors",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "building_id": {
+          "name": "building_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "floors_project_id_projects_id_fk": {
+          "name": "floors_project_id_projects_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "floors_building_id_buildings_id_fk": {
+          "name": "floors_building_id_buildings_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "buildings",
+          "columnsFrom": [
+            "building_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "global_devices": {
+      "name": "global_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "installed_power_per_unit_kw": {
+          "name": "installed_power_per_unit_kw",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "demand_factor": {
+          "name": "demand_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase_count": {
+          "name": "phase_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_factor": {
+          "name": "power_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_change_sets": {
+      "name": "project_change_sets",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_revision_id": {
+          "name": "project_revision_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "command_type": {
+          "name": "command_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_schema_version": {
+          "name": "payload_schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "forward_payload_json": {
+          "name": "forward_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "inverse_payload_json": {
+          "name": "inverse_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_change_sets_revision_unique": {
+          "name": "project_change_sets_revision_unique",
+          "columns": [
+            "project_revision_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_change_sets_project_revision_id_project_revisions_id_fk": {
+          "name": "project_change_sets_project_revision_id_project_revisions_id_fk",
+          "tableFrom": "project_change_sets",
+          "tableTo": "project_revisions",
+          "columnsFrom": [
+            "project_revision_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_devices": {
+      "name": "project_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'single_phase'"
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "project_devices_project_id_projects_id_fk": {
+          "name": "project_devices_project_id_projects_id_fk",
+          "tableFrom": "project_devices",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_history_stack_entries": {
+      "name": "project_history_stack_entries",
+      "columns": {
+        "change_set_id": {
+          "name": "change_set_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stack": {
+          "name": "stack",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_history_stack_entries_position_unique": {
+          "name": "project_history_stack_entries_position_unique",
+          "columns": [
+            "project_id",
+            "stack",
+            "position"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_history_stack_entries_change_set_id_project_change_sets_id_fk": {
+          "name": "project_history_stack_entries_change_set_id_project_change_sets_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "project_change_sets",
+          "columnsFrom": [
+            "change_set_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "project_history_stack_entries_project_id_projects_id_fk": {
+          "name": "project_history_stack_entries_project_id_projects_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "project_history_stack_entries_stack_check": {
+          "name": "project_history_stack_entries_stack_check",
+          "value": "\"project_history_stack_entries\".\"stack\" in ('undo', 'redo')"
+        }
+      }
+    },
+    "project_revisions": {
+      "name": "project_revisions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision_number": {
+          "name": "revision_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_revisions_project_number_unique": {
+          "name": "project_revisions_project_number_unique",
+          "columns": [
+            "project_id",
+            "revision_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_revisions_project_id_projects_id_fk": {
+          "name": "project_revisions_project_id_projects_id_fk",
+          "tableFrom": "project_revisions",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_snapshots": {
+      "name": "project_snapshots",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_revision": {
+          "name": "source_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_version": {
+          "name": "schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'named'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "payload_json": {
+          "name": "payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_sha256": {
+          "name": "payload_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_by_actor_id": {
+          "name": "created_by_actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_snapshots_project_created_idx": {
+          "name": "project_snapshots_project_created_idx",
+          "columns": [
+            "project_id",
+            "created_at_iso"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_kind_revision_idx": {
+          "name": "project_snapshots_project_kind_revision_idx",
+          "columns": [
+            "project_id",
+            "kind",
+            "source_revision"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_name_unique": {
+          "name": "project_snapshots_project_name_unique",
+          "columns": [
+            "project_id",
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_snapshots_project_id_projects_id_fk": {
+          "name": "project_snapshots_project_id_projects_id_fk",
+          "tableFrom": "project_snapshots",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "internal_project_number": {
+          "name": "internal_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_project_number": {
+          "name": "external_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "building_owner": {
+          "name": "building_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_public_building": {
+          "name": "is_public_building",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "single_phase_voltage_v": {
+          "name": "single_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 230
+        },
+        "three_phase_voltage_v": {
+          "name": "three_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 400
+        },
+        "enabled_distribution_board_supply_types": {
+          "name": "enabled_distribution_board_supply_types",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'[\"AV\",\"SV\",\"EV\",\"USV\",\"MSR\",\"SiBe\"]'"
+        },
+        "site_address": {
+          "name": "site_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_lead": {
+          "name": "project_lead",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_editor": {
+          "name": "project_editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "current_revision": {
+          "name": "current_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "rooms": {
+      "name": "rooms",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number": {
+          "name": "room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_name": {
+          "name": "room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "area_m2": {
+          "name": "area_m2",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rooms_project_id_projects_id_fk": {
+          "name": "rooms_project_id_projects_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rooms_floor_id_floors_id_fk": {
+          "name": "rooms_floor_id_floors_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index 90c3bd0..548734d 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -85,6 +85,13 @@
       "when": 1790531351492,
       "tag": "0011_glossy_norman_osborn",
       "breakpoints": true
+    },
+    {
+      "idx": 12,
+      "version": "6",
+      "when": 1790540142918,
+      "tag": "0012_good_gateway",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/db/repositories/distribution-board-structure-project-command.repository.ts b/src/db/repositories/distribution-board-structure-project-command.repository.ts
index db2cede..a4fba2b 100644
--- a/src/db/repositories/distribution-board-structure-project-command.repository.ts
+++ b/src/db/repositories/distribution-board-structure-project-command.repository.ts
@@ -325,6 +325,16 @@ export class DistributionBoardStructureProjectCommandRepository
         patch.supplyType
       );
     }
+    this.assertFeedingReference(database, input.projectId, current.id, {
+      feedingDistributionBoardId:
+        patch.feedingDistributionBoardId === undefined
+          ? current.feedingDistributionBoardId
+          : patch.feedingDistributionBoardId,
+      feedingCircuitId:
+        patch.feedingCircuitId === undefined
+          ? current.feedingCircuitId
+          : patch.feedingCircuitId,
+    });
     const inversePatch = Object.fromEntries(
       input.command.payload.changes.map((change) => [
         change.field,
@@ -333,7 +343,8 @@ export class DistributionBoardStructureProjectCommandRepository
     ) as DistributionBoardUpdatePatch;
     const inverse = createDistributionBoardUpdateProjectCommand(
       current.id,
-      inversePatch
+      inversePatch,
+      input.command.schemaVersion
     );
     const updated = database
       .update(distributionBoards)
@@ -352,6 +363,77 @@ export class DistributionBoardStructureProjectCommandRepository
     }
     return inverse;
   }
+
+  private assertFeedingReference(
+    database: AppDatabase,
+    projectId: string,
+    distributionBoardId: string,
+    reference: {
+      feedingDistributionBoardId: string | null;
+      feedingCircuitId: string | null;
+    }
+  ) {
+    const { feedingDistributionBoardId, feedingCircuitId } = reference;
+    if (feedingDistributionBoardId === null) {
+      if (feedingCircuitId !== null) {
+        throw new Error(
+          "Ein speisender Stromkreis erfordert eine speisende Verteilung."
+        );
+      }
+      return;
+    }
+    if (feedingDistributionBoardId === distributionBoardId) {
+      throw new Error("Eine Verteilung kann sich nicht selbst speisen.");
+    }
+    const projectBoards = database
+      .select({
+        id: distributionBoards.id,
+        feedingDistributionBoardId:
+          distributionBoards.feedingDistributionBoardId,
+      })
+      .from(distributionBoards)
+      .where(eq(distributionBoards.projectId, projectId))
+      .all();
+    const boardById = new Map(projectBoards.map((board) => [board.id, board]));
+    if (!boardById.has(feedingDistributionBoardId)) {
+      throw new Error(
+        "Die speisende Verteilung gehört nicht zum Projekt."
+      );
+    }
+    const visited = new Set<string>([distributionBoardId]);
+    let currentId: string | null = feedingDistributionBoardId;
+    while (currentId !== null) {
+      if (visited.has(currentId)) {
+        throw new Error("Die Einspeisungsverknüpfung würde einen Zyklus erzeugen.");
+      }
+      visited.add(currentId);
+      currentId = boardById.get(currentId)?.feedingDistributionBoardId ?? null;
+    }
+    if (feedingCircuitId === null) {
+      return;
+    }
+    const feedingCircuit = database
+      .select({
+        projectId: circuitLists.projectId,
+        distributionBoardId: circuitLists.distributionBoardId,
+      })
+      .from(circuits)
+      .innerJoin(
+        circuitLists,
+        eq(circuitLists.id, circuits.circuitListId)
+      )
+      .where(eq(circuits.id, feedingCircuitId))
+      .get();
+    if (
+      !feedingCircuit ||
+      feedingCircuit.projectId !== projectId ||
+      feedingCircuit.distributionBoardId !== feedingDistributionBoardId
+    ) {
+      throw new Error(
+        "Der speisende Stromkreis gehört nicht zur gewählten Verteilung."
+      );
+    }
+  }
 }
 
 function assertSupplyTypeEnabled(
@@ -392,11 +474,20 @@ function structureMatches(
     location,
     fedFrom,
     remark,
+    feedingDistributionBoardId,
+    feedingCircuitId,
     ...actualDistributionBoard
   } = actual.board;
   if (
     simultaneityFactor !== 1 ||
-    [boardNumber, location, fedFrom, remark].some((value) => value !== null) ||
+    [
+      boardNumber,
+      location,
+      fedFrom,
+      remark,
+      feedingDistributionBoardId,
+      feedingCircuitId,
+    ].some((value) => value !== null) ||
     !sameRecord(
       expected.distributionBoard,
       actualDistributionBoard
diff --git a/src/db/repositories/distribution-board-subtree-project-command.repository.ts b/src/db/repositories/distribution-board-subtree-project-command.repository.ts
index 6788dcc..5d33b75 100644
--- a/src/db/repositories/distribution-board-subtree-project-command.repository.ts
+++ b/src/db/repositories/distribution-board-subtree-project-command.repository.ts
@@ -300,6 +300,69 @@ export class DistributionBoardSubtreeProjectCommandRepository
         );
       }
     }
+    const feedingDistributionBoardId =
+      snapshot.distributionBoard.feedingDistributionBoardId;
+    const feedingCircuitId = snapshot.distributionBoard.feedingCircuitId;
+    if (feedingDistributionBoardId === null) {
+      if (feedingCircuitId !== null) {
+        throw new Error(
+          "Ein speisender Stromkreis erfordert eine speisende Verteilung."
+        );
+      }
+    } else {
+      if (feedingDistributionBoardId === snapshot.distributionBoard.id) {
+        throw new Error("Eine Verteilung kann sich nicht selbst speisen.");
+      }
+      const projectBoards = database
+        .select({
+          id: distributionBoards.id,
+          feedingDistributionBoardId:
+            distributionBoards.feedingDistributionBoardId,
+        })
+        .from(distributionBoards)
+        .where(eq(distributionBoards.projectId, projectId))
+        .all();
+      const boardById = new Map(projectBoards.map((board) => [board.id, board]));
+      if (!boardById.has(feedingDistributionBoardId)) {
+        throw new Error(
+          "Die speisende Verteilung gehört nicht zum Projekt."
+        );
+      }
+      const visited = new Set<string>([snapshot.distributionBoard.id]);
+      let currentId: string | null = feedingDistributionBoardId;
+      while (currentId !== null) {
+        if (visited.has(currentId)) {
+          throw new Error(
+            "Die Einspeisungsverknüpfung würde einen Zyklus erzeugen."
+          );
+        }
+        visited.add(currentId);
+        currentId = boardById.get(currentId)?.feedingDistributionBoardId ?? null;
+      }
+      if (feedingCircuitId !== null) {
+        const feedingCircuit = database
+          .select({
+            projectId: circuitLists.projectId,
+            distributionBoardId: circuitLists.distributionBoardId,
+          })
+          .from(circuits)
+          .innerJoin(
+            circuitLists,
+            eq(circuitLists.id, circuits.circuitListId)
+          )
+          .where(eq(circuits.id, feedingCircuitId))
+          .get();
+        if (
+          !feedingCircuit ||
+          feedingCircuit.projectId !== projectId ||
+          feedingCircuit.distributionBoardId !== feedingDistributionBoardId
+        ) {
+          throw new Error(
+            "Der speisende Stromkreis gehört nicht zur gewählten Verteilung."
+          );
+        }
+      }
+    }
     const linkedProjectDeviceIds = uniqueStrings(
       snapshot.circuits.flatMap((circuit) =>
         circuit.deviceRows.flatMap((row) =>
diff --git a/src/db/repositories/project-state-restore-command.repository.ts b/src/db/repositories/project-state-restore-command.repository.ts
index 97cfe17..386d805 100644
--- a/src/db/repositories/project-state-restore-command.repository.ts
+++ b/src/db/repositories/project-state-restore-command.repository.ts
@@ -270,6 +270,14 @@ function replaceProjectState(
   database: AppDatabase,
   state: ProjectStateSnapshot
 ) {
+  database
+    .update(distributionBoards)
+    .set({
+      feedingDistributionBoardId: null,
+      feedingCircuitId: null,
+    })
+    .where(eq(distributionBoards.projectId, state.project.id))
+    .run();
   database
     .delete(externalModelSources)
     .where(eq(externalModelSources.projectId, state.project.id))
@@ -330,7 +338,15 @@ function replaceProjectState(
   }
   insertMany(database, rooms, state.rooms);
   insertMany(database, projectDevices, state.projectDevices);
-  insertMany(database, distributionBoards, state.distributionBoards);
+  insertMany(
+    database,
+    distributionBoards,
+    state.distributionBoards.map((board) => ({
+      ...board,
+      feedingDistributionBoardId: null,
+      feedingCircuitId: null,
+    }))
+  );
   insertMany(database, circuitLists, state.circuitLists);
   insertMany(database, circuitSections, state.circuitSections);
   insertMany(
@@ -341,6 +357,7 @@ function replaceProjectState(
       isReserve: circuit.isReserve ? 1 : 0,
     }))
   );
+  restoreDistributionBoardFeedingReferences(database, state);
   insertMany(
     database,
     distributionBoardComponents,
@@ -378,6 +395,31 @@ function replaceProjectState(
   insertMany(database, externalModelObjects, state.externalModel.objects);
 }
 
+function restoreDistributionBoardFeedingReferences(
+  database: AppDatabase,
+  state: ProjectStateSnapshot
+) {
+  for (const board of state.distributionBoards) {
+    if (
+      board.feedingDistributionBoardId === null &&
+      board.feedingCircuitId === null
+    ) {
+      continue;
+    }
+    const updated = database
+      .update(distributionBoards)
+      .set({
+        feedingDistributionBoardId: board.feedingDistributionBoardId,
+        feedingCircuitId: board.feedingCircuitId,
+      })
+      .where(eq(distributionBoards.id, board.id))
+      .run();
+    if (updated.changes !== 1) {
+      throw new Error("Distribution-board feeding reference could not be restored.");
+    }
+  }
+}
+
 function insertMany<TTable extends Parameters<AppDatabase["insert"]>[0]>(
   database: AppDatabase,
   table: TTable,
diff --git a/src/db/repositories/project-transfer.repository.ts b/src/db/repositories/project-transfer.repository.ts
index 21647ff..1d93afd 100644
--- a/src/db/repositories/project-transfer.repository.ts
+++ b/src/db/repositories/project-transfer.repository.ts
@@ -173,7 +173,15 @@ function insertProjectState(
   insertMany(database, floors, state.floors);
   insertMany(database, rooms, state.rooms);
   insertMany(database, projectDevices, state.projectDevices);
-  insertMany(database, distributionBoards, state.distributionBoards);
+  insertMany(
+    database,
+    distributionBoards,
+    state.distributionBoards.map((board) => ({
+      ...board,
+      feedingDistributionBoardId: null,
+      feedingCircuitId: null,
+    }))
+  );
   insertMany(database, circuitLists, state.circuitLists);
   insertMany(database, circuitSections, state.circuitSections);
   insertMany(
@@ -184,6 +192,25 @@ function insertProjectState(
       isReserve: circuit.isReserve ? 1 : 0,
     }))
   );
+  for (const board of state.distributionBoards) {
+    if (
+      board.feedingDistributionBoardId === null &&
+      board.feedingCircuitId === null
+    ) {
+      continue;
+    }
+    const updated = database
+      .update(distributionBoards)
+      .set({
+        feedingDistributionBoardId: board.feedingDistributionBoardId,
+        feedingCircuitId: board.feedingCircuitId,
+      })
+      .where(eq(distributionBoards.id, board.id))
+      .run();
+    if (updated.changes !== 1) {
+      throw new Error("Distribution-board feeding reference could not be imported.");
+    }
+  }
   insertMany(
     database,
     distributionBoardComponents,
diff --git a/src/db/schema/circuit-lists.ts b/src/db/schema/circuit-lists.ts
index 0af5138..2283aeb 100644
--- a/src/db/schema/circuit-lists.ts
+++ b/src/db/schema/circuit-lists.ts
@@ -1,4 +1,4 @@
-import { sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import { sqliteTable, text, unique, type AnySQLiteColumn } from "drizzle-orm/sqlite-core";
 import { distributionBoards } from "./distribution-boards.js";
 import { projects } from "./projects.js";
 
@@ -11,7 +11,7 @@ export const circuitLists = sqliteTable(
       .references(() => projects.id, { onDelete: "cascade" }),
     distributionBoardId: text("distribution_board_id")
       .notNull()
-      .references(() => distributionBoards.id, { onDelete: "cascade" }),
+      .references((): AnySQLiteColumn => distributionBoards.id, { onDelete: "cascade" }),
     name: text("name").notNull(),
   },
   (table) => [unique("circuit_lists_distribution_board_id_unique").on(table.distributionBoardId)]
diff --git a/src/db/schema/circuits.ts b/src/db/schema/circuits.ts
index 6e3ed3e..15ef0e3 100644
--- a/src/db/schema/circuits.ts
+++ b/src/db/schema/circuits.ts
@@ -1,4 +1,4 @@
-import { index, integer, real, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+import { index, integer, real, sqliteTable, text, unique, type AnySQLiteColumn } from "drizzle-orm/sqlite-core";
 import { circuitLists } from "./circuit-lists.js";
 import { circuitSections } from "./circuit-sections.js";
 
@@ -8,7 +8,7 @@ export const circuits = sqliteTable(
     id: text("id").primaryKey(),
     circuitListId: text("circuit_list_id")
       .notNull()
-      .references(() => circuitLists.id, { onDelete: "cascade" }),
+      .references((): AnySQLiteColumn => circuitLists.id, { onDelete: "cascade" }),
     sectionId: text("section_id")
       .notNull()
       .references(() => circuitSections.id, { onDelete: "cascade" }),
diff --git a/src/db/schema/distribution-boards.ts b/src/db/schema/distribution-boards.ts
index eb63486..60bbe4d 100644
--- a/src/db/schema/distribution-boards.ts
+++ b/src/db/schema/distribution-boards.ts
@@ -1,24 +1,44 @@
-import { real, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { index, real, sqliteTable, text, type AnySQLiteColumn } from "drizzle-orm/sqlite-core";
+import { circuits } from "./circuits.js";
 import { floors } from "./floors.js";
 import { projects } from "./projects.js";
 import type { DistributionBoardSupplyType } from "../../shared/constants/distribution-board.js";
 
-export const distributionBoards = sqliteTable("distribution_boards", {
-  id: text("id").primaryKey(),
-  projectId: text("project_id")
-    .notNull()
-    .references(() => projects.id, { onDelete: "cascade" }),
-  name: text("name").notNull(),
-  floorId: text("floor_id").references(() => floors.id, {
-    onDelete: "set null",
-  }),
-  supplyType: text("supply_type").$type<DistributionBoardSupplyType>(),
-  simultaneityFactor: real("simultaneity_factor")
-    .notNull()
-    .default(1),
-  boardNumber: text("board_number"),
-  location: text("location"),
-  fedFrom: text("fed_from"),
-  remark: text("remark"),
-});
+export const distributionBoards = sqliteTable(
+  "distribution_boards",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id")
+      .notNull()
+      .references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    floorId: text("floor_id").references(() => floors.id, {
+      onDelete: "set null",
+    }),
+    supplyType: text("supply_type").$type<DistributionBoardSupplyType>(),
+    simultaneityFactor: real("simultaneity_factor")
+      .notNull()
+      .default(1),
+    boardNumber: text("board_number"),
+    location: text("location"),
+    fedFrom: text("fed_from"),
+    remark: text("remark"),
+    feedingDistributionBoardId: text("feeding_distribution_board_id").references(
+      (): AnySQLiteColumn => distributionBoards.id,
+      { onDelete: "restrict" }
+    ),
+    feedingCircuitId: text("feeding_circuit_id").references(
+      (): AnySQLiteColumn => circuits.id,
+      { onDelete: "restrict" }
+    ),
+  },
+  (table) => [
+    index("distribution_boards_feeding_board_idx").on(
+      table.feedingDistributionBoardId
+    ),
+    index("distribution_boards_feeding_circuit_idx").on(
+      table.feedingCircuitId
+    ),
+  ]
+);
 
diff --git a/src/domain/models/distribution-board-project-command.model.ts b/src/domain/models/distribution-board-project-command.model.ts
index 2e917d0..961cf53 100644
--- a/src/domain/models/distribution-board-project-command.model.ts
+++ b/src/domain/models/distribution-board-project-command.model.ts
@@ -9,16 +9,18 @@ import type { SerializedProjectCommand } from "./project-command.model.js";
 
 export const distributionBoardUpdateCommandType =
   "distribution-board.update" as const;
-// The info-card fields were added additively to schema version 1: every
-// previously stored command remains valid, and the inverse is still derived
-// from the persisted row for exactly the changed fields.
-export const distributionBoardUpdateCommandSchemaVersion = 1 as const;
+// Version 2 adds logical feeding references. Version-1 commands remain
+// executable and can only change the fields they originally knew.
+export const distributionBoardUpdateCommandSchemaVersion = 2 as const;
+const legacyDistributionBoardUpdateCommandSchemaVersion = 1 as const;
 
 export interface DistributionBoardUpdateValues
   extends Record<DistributionBoardInfoField, string | null> {
   floorId: string | null;
   supplyType: DistributionBoardSupplyType | null;
   simultaneityFactor: number;
+  feedingDistributionBoardId: string | null;
+  feedingCircuitId: string | null;
 }
 
 export type DistributionBoardUpdateField =
@@ -41,16 +43,20 @@ export interface DistributionBoardUpdateCommandPayload {
 
 export interface DistributionBoardUpdateProjectCommand
   extends SerializedProjectCommand<DistributionBoardUpdateCommandPayload> {
-  schemaVersion: typeof distributionBoardUpdateCommandSchemaVersion;
+  schemaVersion:
+    | typeof legacyDistributionBoardUpdateCommandSchemaVersion
+    | typeof distributionBoardUpdateCommandSchemaVersion;
   type: typeof distributionBoardUpdateCommandType;
 }
 
 export function createDistributionBoardUpdateProjectCommand(
   distributionBoardId: string,
-  patch: DistributionBoardUpdatePatch
+  patch: DistributionBoardUpdatePatch,
+  schemaVersion: DistributionBoardUpdateProjectCommand["schemaVersion"] =
+    distributionBoardUpdateCommandSchemaVersion
 ): DistributionBoardUpdateProjectCommand {
   const command: DistributionBoardUpdateProjectCommand = {
-    schemaVersion: distributionBoardUpdateCommandSchemaVersion,
+    schemaVersion,
     type: distributionBoardUpdateCommandType,
     payload: {
       distributionBoardId,
@@ -68,7 +74,8 @@ export function assertDistributionBoardUpdateProjectCommand(
   command: SerializedProjectCommand<unknown>
 ): asserts command is DistributionBoardUpdateProjectCommand {
   if (
-    command.schemaVersion !== distributionBoardUpdateCommandSchemaVersion ||
+    (command.schemaVersion !== legacyDistributionBoardUpdateCommandSchemaVersion &&
+      command.schemaVersion !== distributionBoardUpdateCommandSchemaVersion) ||
     command.type !== distributionBoardUpdateCommandType ||
     !isPlainObject(command.payload)
   ) {
@@ -93,7 +100,12 @@ export function assertDistributionBoardUpdateProjectCommand(
       (change.field !== "floorId" &&
         change.field !== "supplyType" &&
         change.field !== "simultaneityFactor" &&
+        change.field !== "feedingDistributionBoardId" &&
+        change.field !== "feedingCircuitId" &&
         !isInfoField(change.field)) ||
+      (command.schemaVersion === legacyDistributionBoardUpdateCommandSchemaVersion &&
+        (change.field === "feedingDistributionBoardId" ||
+          change.field === "feedingCircuitId")) ||
       seen.has(change.field)
     ) {
       throw new Error(
@@ -105,7 +117,9 @@ export function assertDistributionBoardUpdateProjectCommand(
     } else if (change.field === "floorId") {
       if (
         change.value !== null &&
-        (typeof change.value !== "string" || !change.value.trim())
+        (typeof change.value !== "string" ||
+          !change.value.trim() ||
+          change.value !== change.value.trim())
       ) {
         throw new Error("floorId must be a non-empty string or null.");
       }
@@ -118,6 +132,16 @@ export function assertDistributionBoardUpdateProjectCommand(
       ) {
         throw new Error("supplyType is invalid.");
       }
+    } else if (
+      change.field === "feedingDistributionBoardId" ||
+      change.field === "feedingCircuitId"
+    ) {
+      if (
+        change.value !== null &&
+        (typeof change.value !== "string" || !change.value.trim())
+      ) {
+        throw new Error(`${change.field} must be a non-empty string or null.`);
+      }
     } else if (
       typeof change.value !== "number" ||
       !Number.isFinite(change.value) ||
diff --git a/src/domain/models/distribution-board-subtree-snapshot.model.ts b/src/domain/models/distribution-board-subtree-snapshot.model.ts
index a0269fc..700a52b 100644
--- a/src/domain/models/distribution-board-subtree-snapshot.model.ts
+++ b/src/domain/models/distribution-board-subtree-snapshot.model.ts
@@ -74,6 +74,8 @@ export interface DistributionBoardSubtreeSnapshot {
     floorId: string | null;
     supplyType: DistributionBoardSupplyType | null;
     simultaneityFactor: number;
+    feedingDistributionBoardId: string | null;
+    feedingCircuitId: string | null;
   } & Record<DistributionBoardInfoField, string | null>;
   circuitList: {
     id: string;
@@ -184,6 +186,9 @@ export function normalizeDistributionBoardSubtreeSnapshot(
   for (const field of distributionBoardInfoFields) {
     board[field] = board[field] ?? null;
   }
+  board.feedingDistributionBoardId =
+    board.feedingDistributionBoardId ?? null;
+  board.feedingCircuitId = board.feedingCircuitId ?? null;
   return { ...snapshot, distributionBoard: board };
 }
 
@@ -227,6 +232,18 @@ export function assertDistributionBoardSubtreeSnapshot(
       assertNullableString(board[field], `distributionBoard.${field}`);
     }
   }
+  if (board.feedingDistributionBoardId !== undefined) {
+    assertNullableString(
+      board.feedingDistributionBoardId,
+      "distributionBoard.feedingDistributionBoardId"
+    );
+  }
+  if (board.feedingCircuitId !== undefined) {
+    assertNullableString(
+      board.feedingCircuitId,
+      "distributionBoard.feedingCircuitId"
+    );
+  }
   for (const field of [
     "id",
     "projectId",
diff --git a/src/domain/models/project-state-snapshot.model.ts b/src/domain/models/project-state-snapshot.model.ts
index b03bfbd..ea3aba7 100644
--- a/src/domain/models/project-state-snapshot.model.ts
+++ b/src/domain/models/project-state-snapshot.model.ts
@@ -35,7 +35,8 @@ import {
   type ExternalModelStateSnapshot,
 } from "../../external-model/domain/external-model-contracts.js";
 
-export const projectStateSnapshotSchemaVersion = 8 as const;
+export const projectStateSnapshotSchemaVersion = 9 as const;
+const roomAreaProjectStateSnapshotSchemaVersion = 8 as const;
 const buildingProjectStateSnapshotSchemaVersion = 7 as const;
 const coverProjectStateSnapshotSchemaVersion = 6 as const;
 const boardInfoProjectStateSnapshotSchemaVersion = 5 as const;
@@ -112,7 +113,7 @@ const distributionBoardInfoValueSchema = (field: DistributionBoardInfoField) =>
     .max(distributionBoardInfoFieldMaxLengths[field])
     .nullable();
 
-const distributionBoardSchema = legacyDistributionBoardSchema
+const distributionBoardWithoutFeedingSchema = legacyDistributionBoardSchema
   .extend({
     boardNumber: distributionBoardInfoValueSchema("boardNumber"),
     location: distributionBoardInfoValueSchema("location"),
@@ -121,6 +122,13 @@ const distributionBoardSchema = legacyDistributionBoardSchema
   })
   .strict();
 
+const distributionBoardSchema = distributionBoardWithoutFeedingSchema
+  .extend({
+    feedingDistributionBoardId: idSchema.nullable(),
+    feedingCircuitId: idSchema.nullable(),
+  })
+  .strict();
+
 function withEmptyDistributionBoardInfo(
   boards: Array<z.infer<typeof legacyDistributionBoardSchema>>
 ) {
@@ -133,6 +141,16 @@ function withEmptyDistributionBoardInfo(
   }));
 }
 
+function withEmptyDistributionBoardFeeding(
+  boards: Array<z.infer<typeof distributionBoardWithoutFeedingSchema>>
+) {
+  return boards.map((board) => ({
+    ...board,
+    feedingDistributionBoardId: null,
+    feedingCircuitId: null,
+  }));
+}
+
 const circuitListSchema = z
   .object({
     id: idSchema,
@@ -553,11 +571,22 @@ export const projectStateSnapshotSchema = z
   })
   .strict();
 
+const roomAreaProjectStateSnapshotSchema = z
+  .object({
+    schemaVersion: z.literal(roomAreaProjectStateSnapshotSchemaVersion),
+    project: projectSchema,
+    distributionBoards: z.array(distributionBoardWithoutFeedingSchema),
+    externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
+    externalModel: externalModelStateSchema,
+    ...projectStateSnapshotContents,
+  })
+  .strict();
+
 const buildingProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(buildingProjectStateSnapshotSchemaVersion),
     project: projectSchema,
-    distributionBoards: z.array(distributionBoardSchema),
+    distributionBoards: z.array(distributionBoardWithoutFeedingSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
     externalModel: externalModelStateSchema,
     ...buildingProjectStateSnapshotContents,
@@ -568,7 +597,7 @@ const coverProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(coverProjectStateSnapshotSchemaVersion),
     project: projectSchema,
-    distributionBoards: z.array(distributionBoardSchema),
+    distributionBoards: z.array(distributionBoardWithoutFeedingSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
     externalModel: externalModelStateSchema,
     ...previousProjectStateSnapshotContents,
@@ -655,6 +684,27 @@ export function parseProjectStateSnapshot(
 }
 
 function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
+  const roomArea = upgradeToRoomAreaProjectStateSnapshot(value);
+  if (
+    roomArea !== null &&
+    typeof roomArea === "object" &&
+    !Array.isArray(roomArea) &&
+    (roomArea as { schemaVersion?: unknown }).schemaVersion ===
+      roomAreaProjectStateSnapshotSchemaVersion
+  ) {
+    const previous = roomAreaProjectStateSnapshotSchema.parse(roomArea);
+    return {
+      ...previous,
+      schemaVersion: projectStateSnapshotSchemaVersion,
+      distributionBoards: withEmptyDistributionBoardFeeding(
+        previous.distributionBoards
+      ),
+    };
+  }
+  return roomArea;
+}
+
+function upgradeToRoomAreaProjectStateSnapshot(value: unknown): unknown {
   const cover = upgradeToCoverProjectStateSnapshot(value);
   if (
     cover !== null &&
@@ -666,7 +716,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     const previous = buildingProjectStateSnapshotSchema.parse(cover);
     return {
       ...previous,
-      schemaVersion: projectStateSnapshotSchemaVersion,
+      schemaVersion: roomAreaProjectStateSnapshotSchemaVersion,
       rooms: previous.rooms.map((room) => ({ ...room, areaM2: null })),
     };
   }
@@ -683,7 +733,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
   // building. Build version 7 first so the room-area upgrade above remains a
   // single exact transition.
   const previous = coverProjectStateSnapshotSchema.parse(cover);
-  return upgradePreviousProjectStateSnapshot({
+  return upgradeToRoomAreaProjectStateSnapshot({
     ...previous,
     schemaVersion: buildingProjectStateSnapshotSchemaVersion,
     buildings: [],
@@ -873,6 +923,15 @@ function assertProjectStateSnapshotRelations(
   const sectionById = new Map(
     snapshot.circuitSections.map((entry) => [entry.id, entry])
   );
+  const boardById = new Map(
+    snapshot.distributionBoards.map((entry) => [entry.id, entry])
+  );
+  const circuitListById = new Map(
+    snapshot.circuitLists.map((entry) => [entry.id, entry])
+  );
+  const circuitById = new Map(
+    snapshot.circuits.map((entry) => [entry.id, entry])
+  );
   const componentById = new Map(
     snapshot.distributionBoardComponents.map((entry) => [
       entry.id,
@@ -901,6 +960,47 @@ function assertProjectStateSnapshotRelations(
         "Snapshot distribution board uses a disabled supply type."
       );
     }
+    if (board.feedingDistributionBoardId === board.id) {
+      throw new Error("Snapshot distribution board cannot feed itself.");
+    }
+    if (board.feedingDistributionBoardId !== null) {
+      assertReference(
+        boardIds,
+        board.feedingDistributionBoardId,
+        "feeding distribution board"
+      );
+    }
+    if (board.feedingCircuitId !== null) {
+      if (board.feedingDistributionBoardId === null) {
+        throw new Error(
+          "Snapshot feeding circuit requires a feeding distribution board."
+        );
+      }
+      assertReference(circuitIds, board.feedingCircuitId, "feeding circuit");
+      const feedingCircuit = circuitById.get(board.feedingCircuitId);
+      const feedingList = feedingCircuit
+        ? circuitListById.get(feedingCircuit.circuitListId)
+        : undefined;
+      if (
+        !feedingList ||
+        feedingList.distributionBoardId !== board.feedingDistributionBoardId
+      ) {
+        throw new Error(
+          "Snapshot feeding circuit belongs to another distribution board."
+        );
+      }
+    }
+  }
+  for (const board of snapshot.distributionBoards) {
+    const visited = new Set<string>([board.id]);
+    let currentId = board.feedingDistributionBoardId;
+    while (currentId !== null) {
+      if (visited.has(currentId)) {
+        throw new Error("Snapshot distribution-board feeding graph contains a cycle.");
+      }
+      visited.add(currentId);
+      currentId = boardById.get(currentId)?.feedingDistributionBoardId ?? null;
+    }
   }
   for (const list of snapshot.circuitLists) {
     assertProjectOwnership(list.projectId, projectId, "circuit list");
diff --git a/src/domain/models/project-transfer.model.ts b/src/domain/models/project-transfer.model.ts
index 80b9d59..d68b29e 100644
--- a/src/domain/models/project-transfer.model.ts
+++ b/src/domain/models/project-transfer.model.ts
@@ -223,6 +223,14 @@ export function remapProjectState(
       ...board,
       id: requiredId(boardIds, board.id),
       projectId: targetProjectId,
+      feedingDistributionBoardId:
+        board.feedingDistributionBoardId === null
+          ? null
+          : requiredId(boardIds, board.feedingDistributionBoardId),
+      feedingCircuitId:
+        board.feedingCircuitId === null
+          ? null
+          : requiredId(circuitIds, board.feedingCircuitId),
       floorId:
         board.floorId === null
           ? null
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index e8a2289..a1cc7bc 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -195,6 +195,8 @@ export interface DistributionBoardDto extends DistributionBoardInfoDto {
   floorId: string | null;
   supplyType: DistributionBoardSupplyType | null;
   simultaneityFactor: number;
+  feedingDistributionBoardId: string | null;
+  feedingCircuitId: string | null;
 }
 
 export interface DocumentLogoMetadataDto {
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index 501ed01..5e814c9 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -372,7 +372,13 @@ export function updateDistributionBoard(
     floorId: string | null;
     supplyType: NonNullable<DistributionBoardDto["supplyType"]>;
     simultaneityFactor: number;
-  } & Partial<DistributionBoardInfoDto>,
+  } & Partial<DistributionBoardInfoDto> &
+    Partial<
+      Pick<
+        DistributionBoardDto,
+        "feedingDistributionBoardId" | "feedingCircuitId"
+      >
+    >,
   expectedRevision: number
 ) {
   return request<DistributionBoardCommandResultDto>(
diff --git a/src/server/controllers/distribution-board.controller.ts b/src/server/controllers/distribution-board.controller.ts
index 9ea713a..d2e9bb9 100644
--- a/src/server/controllers/distribution-board.controller.ts
+++ b/src/server/controllers/distribution-board.controller.ts
@@ -69,6 +69,8 @@ export async function createDistributionBoard(req: Request, res: Response) {
         location: null,
         fedFrom: null,
         remark: null,
+        feedingDistributionBoardId: null,
+        feedingCircuitId: null,
       },
     });
   } catch (error) {
@@ -98,6 +100,17 @@ export async function updateDistributionBoard(
       .filter((field) => parsed.data[field] !== undefined)
       .map((field) => [field, parsed.data[field]])
   );
+  const feedingPatch = {
+    ...(parsed.data.feedingDistributionBoardId === undefined
+      ? {}
+      : {
+          feedingDistributionBoardId:
+            parsed.data.feedingDistributionBoardId,
+        }),
+    ...(parsed.data.feedingCircuitId === undefined
+      ? {}
+      : { feedingCircuitId: parsed.data.feedingCircuitId }),
+  };
   try {
     const result = projectCommandService.executeUser({
       projectId,
@@ -110,6 +123,7 @@ export async function updateDistributionBoard(
           supplyType: parsed.data.supplyType,
           simultaneityFactor: parsed.data.simultaneityFactor,
           ...infoPatch,
+          ...feedingPatch,
         }
       ),
     });
diff --git a/src/shared/validation/project-structure.schemas.ts b/src/shared/validation/project-structure.schemas.ts
index b8655ba..ede5152 100644
--- a/src/shared/validation/project-structure.schemas.ts
+++ b/src/shared/validation/project-structure.schemas.ts
@@ -86,6 +86,8 @@ export const updateDistributionBoardSchema = z
     location: distributionBoardInfoValueSchema("location"),
     fedFrom: distributionBoardInfoValueSchema("fedFrom"),
     remark: distributionBoardInfoValueSchema("remark"),
+    feedingDistributionBoardId: z.string().trim().min(1).nullable().optional(),
+    feedingCircuitId: z.string().trim().min(1).nullable().optional(),
   })
   .strict();
 
diff --git a/tests/distribution-board-structure-project-command.repository.test.ts b/tests/distribution-board-structure-project-command.repository.test.ts
index f829edf..e6aff4b 100644
--- a/tests/distribution-board-structure-project-command.repository.test.ts
+++ b/tests/distribution-board-structure-project-command.repository.test.ts
@@ -491,6 +491,159 @@ describe("distribution-board structure project command", () => {
     }
   });
 
+  it("links a feeding board and circuit while preserving version-1 updates", () => {
+    const context = createTestDatabase();
+    try {
+      const repository =
+        new DistributionBoardStructureProjectCommandRepository(context.db);
+      const upstream = createDistributionBoardStructureSnapshot(
+        "project-1",
+        "NSHV",
+        { supplyType: "AV" }
+      );
+      const downstream = createDistributionBoardStructureSnapshot(
+        "project-1",
+        "UV EG",
+        { supplyType: "AV" }
+      );
+      repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createDistributionBoardInsertProjectCommand(upstream),
+      });
+      repository.execute({
+        projectId: "project-1",
+        expectedRevision: 1,
+        source: "user",
+        command: createDistributionBoardInsertProjectCommand(downstream),
+      });
+      context.db.insert(circuits).values([
+        {
+          id: "feed-circuit",
+          circuitListId: upstream.circuitList.id,
+          sectionId: upstream.sections[2]!.id,
+          equipmentIdentifier: "-3F1.1",
+          sortOrder: 10,
+        },
+        {
+          id: "downstream-circuit",
+          circuitListId: downstream.circuitList.id,
+          sectionId: downstream.sections[2]!.id,
+          equipmentIdentifier: "-3F1.1",
+          sortOrder: 10,
+        },
+      ]).run();
+
+      const linked = repository.executeUpdate({
+        projectId: "project-1",
+        expectedRevision: 2,
+        source: "user",
+        command: createDistributionBoardUpdateProjectCommand(
+          downstream.distributionBoard.id,
+          {
+            feedingDistributionBoardId: upstream.distributionBoard.id,
+            feedingCircuitId: "feed-circuit",
+          }
+        ),
+      });
+      assert.deepEqual(
+        context.db
+          .select({
+            feedingDistributionBoardId:
+              distributionBoards.feedingDistributionBoardId,
+            feedingCircuitId: distributionBoards.feedingCircuitId,
+          })
+          .from(distributionBoards)
+          .where(eq(distributionBoards.id, downstream.distributionBoard.id))
+          .get(),
+        {
+          feedingDistributionBoardId: upstream.distributionBoard.id,
+          feedingCircuitId: "feed-circuit",
+        }
+      );
+
+      repository.executeUpdate({
+        projectId: "project-1",
+        expectedRevision: 3,
+        source: "undo",
+        historyTargetChangeSetId: new ProjectHistoryRepository(
+          context.db
+        ).getNextCommand("project-1", "undo")?.changeSetId,
+        command: linked.inverse,
+      });
+      repository.executeUpdate({
+        projectId: "project-1",
+        expectedRevision: 4,
+        source: "user",
+        command: createDistributionBoardUpdateProjectCommand(
+          downstream.distributionBoard.id,
+          {
+            feedingDistributionBoardId: upstream.distributionBoard.id,
+            feedingCircuitId: null,
+          }
+        ),
+      });
+
+      assert.throws(
+        () => repository.executeUpdate({
+          projectId: "project-1",
+          expectedRevision: 5,
+          source: "user",
+          command: createDistributionBoardUpdateProjectCommand(
+            upstream.distributionBoard.id,
+            {
+              feedingDistributionBoardId: downstream.distributionBoard.id,
+              feedingCircuitId: null,
+            }
+          ),
+        }),
+        /Zyklus/
+      );
+      assert.throws(
+        () => repository.executeUpdate({
+          projectId: "project-1",
+          expectedRevision: 5,
+          source: "user",
+          command: createDistributionBoardUpdateProjectCommand(
+            downstream.distributionBoard.id,
+            {
+              feedingDistributionBoardId: upstream.distributionBoard.id,
+              feedingCircuitId: "downstream-circuit",
+            }
+          ),
+        }),
+        /gehört nicht zur gewählten Verteilung/
+      );
+
+      repository.executeUpdate({
+        projectId: "project-1",
+        expectedRevision: 5,
+        source: "user",
+        command: {
+          schemaVersion: 1,
+          type: "distribution-board.update",
+          payload: {
+            distributionBoardId: downstream.distributionBoard.id,
+            changes: [{ field: "boardNumber", value: "UV-01" }],
+          },
+        },
+      });
+      const afterLegacyUpdate = context.db
+        .select()
+        .from(distributionBoards)
+        .where(eq(distributionBoards.id, downstream.distributionBoard.id))
+        .get();
+      assert.equal(afterLegacyUpdate?.boardNumber, "UV-01");
+      assert.equal(
+        afterLegacyUpdate?.feedingDistributionBoardId,
+        upstream.distributionBoard.id
+      );
+    } finally {
+      context.close();
+    }
+  });
+
   it("sends distribution-board writes to the revision-safe API", async () => {
     const requests: Array<{ url: string; method: string; body: unknown }> = [];
     const originalFetch = globalThis.fetch;
diff --git a/tests/distribution-board-subtree.test.ts b/tests/distribution-board-subtree.test.ts
index 33d5318..6e48294 100644
--- a/tests/distribution-board-subtree.test.ts
+++ b/tests/distribution-board-subtree.test.ts
@@ -19,6 +19,8 @@ function createSnapshot(): DistributionBoardSubtreeSnapshot {
       floorId: "floor-1",
       supplyType: "AV",
       simultaneityFactor: 0.8,
+      feedingDistributionBoardId: "board-upstream",
+      feedingCircuitId: "circuit-upstream",
     },
     circuitList: {
       id: "list-1",
@@ -157,6 +159,11 @@ describe("distribution-board subtree snapshot", () => {
     assert.equal(clone.distributionBoard.id, "new-1");
     assert.equal(clone.circuitList.id, "new-1");
     assert.equal(clone.distributionBoard.name, "UV 1 Kopie");
+    assert.equal(
+      clone.distributionBoard.feedingDistributionBoardId,
+      "board-upstream"
+    );
+    assert.equal(clone.distributionBoard.feedingCircuitId, "circuit-upstream");
     assert.equal(clone.circuitList.name, "UV 1 Kopie Stromkreisliste");
     assert.equal(clone.sections[0].id, "new-2");
     assert.equal(clone.circuits[0].id, "new-3");
diff --git a/tests/print-view-migration.test.ts b/tests/print-view-migration.test.ts
index 19e4dcc..343de70 100644
--- a/tests/print-view-migration.test.ts
+++ b/tests/print-view-migration.test.ts
@@ -50,6 +50,8 @@ it("upgrades a populated pre-print database through the current schema without c
     for (const [key, value] of Object.entries(oldRoom)) assert.deepEqual(room[key], value);
     for (const field of ["site_address", "work_stage", "project_lead", "project_editor"]) assert.equal(project[field], null);
     for (const field of ["board_number", "location", "fed_from", "remark"]) assert.equal(board[field], null);
+    assert.equal(board.feeding_distribution_board_id, null);
+    assert.equal(board.feeding_circuit_id, null);
     assert.equal(floor.building_id, null);
     assert.equal(room.area_m2, null);
     assert.equal(context.sqlite.prepare("SELECT count(*) AS count FROM buildings").get()!.count, 0);
diff --git a/tests/project-snapshot.repository.test.ts b/tests/project-snapshot.repository.test.ts
index 7a02fec..bc4cd12 100644
--- a/tests/project-snapshot.repository.test.ts
+++ b/tests/project-snapshot.repository.test.ts
@@ -476,7 +476,14 @@ describe("project snapshot repository", () => {
         delete payload.project[field];
       }
       for (const board of payload.distributionBoards) {
-        for (const field of ["boardNumber", "location", "fedFrom", "remark"]) {
+        for (const field of [
+          "boardNumber",
+          "location",
+          "fedFrom",
+          "remark",
+          "feedingDistributionBoardId",
+          "feedingCircuitId",
+        ]) {
           delete board[field];
         }
       }
diff --git a/tests/project-state-snapshot.test.ts b/tests/project-state-snapshot.test.ts
index c067c19..aa2371b 100644
--- a/tests/project-state-snapshot.test.ts
+++ b/tests/project-state-snapshot.test.ts
@@ -6,12 +6,25 @@ import {
   projectStateSnapshotSchemaVersion,
   serializeProjectStateSnapshot,
 } from "../src/domain/models/project-state-snapshot.model.js";
+import { remapProjectState } from "../src/domain/models/project-transfer.model.js";
 import { createNamedProjectSnapshotSchema } from "../src/shared/validation/project-snapshot.schemas.js";
 
+/** Removes the fields introduced by snapshot schema version 9. */
+function withoutVersionNineFields<
+  T extends { distributionBoards: object[] },
+>(snapshot: T): T {
+  for (const board of snapshot.distributionBoards) {
+    delete (board as Record<string, unknown>).feedingDistributionBoardId;
+    delete (board as Record<string, unknown>).feedingCircuitId;
+  }
+  return snapshot;
+}
+
 /** Removes the fields introduced by snapshot schema version 7. */
 function withoutVersionSevenFields<
-  T extends { floors: object[] },
+  T extends { floors: object[]; distributionBoards: object[] },
 >(snapshot: T): T {
+  withoutVersionNineFields(snapshot);
   delete (snapshot as Record<string, unknown>).buildings;
   for (const floor of snapshot.floors) {
     delete (floor as Record<string, unknown>).buildingId;
@@ -117,6 +130,8 @@ function protectedSnapshot() {
         location: "Raum 003 Technik" as string | null,
         fedFrom: "HV 0.1" as string | null,
         remark: null as string | null,
+        feedingDistributionBoardId: null as string | null,
+        feedingCircuitId: null as string | null,
       },
     ],
     circuitLists: [
@@ -206,6 +221,96 @@ describe("project state snapshot model", () => {
     );
   });
 
+  it("upgrades snapshot version 8 with empty feeding references", () => {
+    const previous = withoutVersionNineFields(protectedSnapshot());
+    previous.schemaVersion = 8 as typeof previous.schemaVersion;
+
+    const upgraded = parseProjectStateSnapshot(previous);
+
+    assert.equal(upgraded.schemaVersion, projectStateSnapshotSchemaVersion);
+    assert.equal(
+      upgraded.distributionBoards[0]?.feedingDistributionBoardId,
+      null
+    );
+    assert.equal(upgraded.distributionBoards[0]?.feedingCircuitId, null);
+  });
+
+  it("validates logical feeding references and cycles", () => {
+    const linked = protectedSnapshot();
+    linked.distributionBoards.push({
+      id: "board-2",
+      projectId: "project-1",
+      name: "UV 2",
+      floorId: null,
+      supplyType: null,
+      simultaneityFactor: 1,
+      boardNumber: "UV 2.1",
+      location: null,
+      fedFrom: null,
+      remark: null,
+      feedingDistributionBoardId: "board-1",
+      feedingCircuitId: "circuit-1",
+    });
+    linked.circuitLists.push({
+      id: "list-2",
+      projectId: "project-1",
+      distributionBoardId: "board-2",
+      name: "UV 2 Stromkreisliste",
+    });
+    linked.circuitSections.push({
+      id: "section-2",
+      circuitListId: "list-2",
+      key: "three_phase",
+      displayName: "Dreiphasig 1",
+      prefix: "-3F1.",
+      sortOrder: 10,
+      category: "three_phase",
+      groupNumber: 1,
+    });
+    const parsed = parseProjectStateSnapshot(linked);
+    assert.equal(parsed.distributionBoards[1]?.feedingCircuitId, "circuit-1");
+    let nextId = 0;
+    const remapped = remapProjectState(
+      parsed,
+      "project-copy",
+      () => `copy-${++nextId}`
+    );
+    const remappedUpstream = remapped.distributionBoards.find(
+      (board) => board.name === "UV 1"
+    );
+    const remappedDownstream = remapped.distributionBoards.find(
+      (board) => board.name === "UV 2"
+    );
+    assert.ok(remappedUpstream);
+    assert.ok(remappedDownstream);
+    assert.equal(
+      remappedDownstream.feedingDistributionBoardId,
+      remappedUpstream.id
+    );
+    assert.notEqual(remappedDownstream.feedingCircuitId, "circuit-1");
+    assert.ok(
+      remapped.circuits.some(
+        (circuit) => circuit.id === remappedDownstream.feedingCircuitId
+      )
+    );
+
+    const missingBoard = structuredClone(linked);
+    missingBoard.distributionBoards[1]!.feedingDistributionBoardId = null;
+    assert.throws(
+      () => parseProjectStateSnapshot(missingBoard),
+      /requires a feeding distribution board/
+    );
+
+    const cycle = structuredClone(linked);
+    cycle.distributionBoards[0]!.feedingDistributionBoardId = "board-2";
+    cycle.distributionBoards[0]!.feedingCircuitId = null;
+    cycle.distributionBoards[1]!.feedingCircuitId = null;
+    assert.throws(
+      () => parseProjectStateSnapshot(cycle),
+      /contains a cycle/
+    );
+  });
+
   it("upgrades the supported baseline snapshot with a safe building default", () => {
     const baseline = withoutVersionSixFields(structuredClone(minimalSnapshot()));
     baseline.schemaVersion = 1 as typeof baseline.schemaVersion;

From 855a04e655ea833392cc521dc731fd653621c1b6 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 22:25:47 +0200
Subject: [PATCH 35/60] Protect referenced feeder structures from deletion

---
 ...ice-row-move-project-command.repository.ts |  4 ++
 ...roup-subtree-project-command.repository.ts |  6 ++
 ...it-structure-project-command.repository.ts |  3 +
 ...oard-feeding-deletion-guard.persistence.ts | 65 +++++++++++++++++++
 ...rd-structure-project-command.repository.ts |  3 +
 ...oard-subtree-project-command.repository.ts |  4 ++
 ...-new-circuit-project-command.repository.ts |  4 ++
 ...ow-move-project-command.repository.test.ts | 57 ++++++++++++++++
 ...subtree-project-command.repository.test.ts | 40 ++++++++++++
 ...ructure-project-command.repository.test.ts | 43 ++++++++++++
 ...ructure-project-command.repository.test.ts | 48 ++++++++++++++
 ...subtree-project-command.repository.test.ts | 37 +++++++++++
 ...ignment-project-command.repository.test.ts | 55 ++++++++++++++++
 13 files changed, 369 insertions(+)
 create mode 100644 src/db/repositories/distribution-board-feeding-deletion-guard.persistence.ts

diff --git a/src/db/repositories/circuit-device-row-move-project-command.repository.ts b/src/db/repositories/circuit-device-row-move-project-command.repository.ts
index 2c5bfc9..e1e3f5a 100644
--- a/src/db/repositories/circuit-device-row-move-project-command.repository.ts
+++ b/src/db/repositories/circuit-device-row-move-project-command.repository.ts
@@ -23,6 +23,7 @@ import { circuits } from "../schema/circuits.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
 import { updateDerivedCircuitVoltage } from "./project-voltage.persistence.js";
 import { resolveCircuitVoltage } from "./project-voltage.persistence.js";
+import { assertCircuitsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
 
 interface PersistedMoveRow {
   id: string;
@@ -171,6 +172,9 @@ export class CircuitDeviceRowMoveProjectCommandRepository
       projectId,
       destinationCircuitIds
     );
+    assertCircuitsAreNotReferencedAsFeeders(database, projectId, [
+      targetCircuit.id,
+    ]);
     const deleted = database
       .delete(circuits)
       .where(
diff --git a/src/db/repositories/circuit-group-subtree-project-command.repository.ts b/src/db/repositories/circuit-group-subtree-project-command.repository.ts
index 448cf99..9bf27a0 100644
--- a/src/db/repositories/circuit-group-subtree-project-command.repository.ts
+++ b/src/db/repositories/circuit-group-subtree-project-command.repository.ts
@@ -26,6 +26,7 @@ import { distributionBoardComponentProtectionDevices } from "../schema/distribut
 import { distributionBoardComponents } from "../schema/distribution-board-components.js";
 import { toCircuitDeviceRowInsertValues } from "./circuit-device-row-structure.persistence.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { assertCircuitsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
 
 export class CircuitGroupSubtreeProjectCommandRepository
   implements CircuitGroupSubtreeProjectCommandStore
@@ -65,6 +66,11 @@ export class CircuitGroupSubtreeProjectCommandRepository
           "Circuit-group subtree changed before deletion."
         );
       }
+      assertCircuitsAreNotReferencedAsFeeders(
+        database,
+        projectId,
+        current.circuits.map((entry) => entry.circuit.id)
+      );
       const deleted = database
         .delete(circuitSections)
         .where(eq(circuitSections.id, current.group.id))
diff --git a/src/db/repositories/circuit-structure-project-command.repository.ts b/src/db/repositories/circuit-structure-project-command.repository.ts
index 9b8941d..e7cfcb2 100644
--- a/src/db/repositories/circuit-structure-project-command.repository.ts
+++ b/src/db/repositories/circuit-structure-project-command.repository.ts
@@ -26,6 +26,7 @@ import {
   toCircuitDeviceRowSnapshot,
 } from "./circuit-device-row-structure.persistence.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { assertCircuitsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
 import { resolveCircuitVoltage } from "./project-voltage.persistence.js";
 import { assertEquipmentIdentifierAvailable } from "./equipment-identifier-uniqueness.persistence.js";
 
@@ -236,6 +237,8 @@ export class CircuitStructureProjectCommandRepository
       protectionDevice: protectionDevice ?? null,
     });
 
+    assertCircuitsAreNotReferencedAsFeeders(database, projectId, [circuit.id]);
+
     const result = database
       .delete(circuits)
       .where(
diff --git a/src/db/repositories/distribution-board-feeding-deletion-guard.persistence.ts b/src/db/repositories/distribution-board-feeding-deletion-guard.persistence.ts
new file mode 100644
index 0000000..679f31e
--- /dev/null
+++ b/src/db/repositories/distribution-board-feeding-deletion-guard.persistence.ts
@@ -0,0 +1,65 @@
+import { and, asc, eq, inArray } from "drizzle-orm";
+import type { AppDatabase } from "../database-context.js";
+import { distributionBoards } from "../schema/distribution-boards.js";
+
+export function assertBoardsAreNotReferencedAsFeeders(
+  database: AppDatabase,
+  projectId: string,
+  distributionBoardIds: string[]
+) {
+  if (distributionBoardIds.length === 0) return;
+  const dependent = database
+    .select({
+      name: distributionBoards.name,
+      boardNumber: distributionBoards.boardNumber,
+    })
+    .from(distributionBoards)
+    .where(
+      and(
+        eq(distributionBoards.projectId, projectId),
+        inArray(
+          distributionBoards.feedingDistributionBoardId,
+          [...new Set(distributionBoardIds)]
+        )
+      )
+    )
+    .orderBy(asc(distributionBoards.boardNumber), asc(distributionBoards.name))
+    .limit(1)
+    .get();
+  if (dependent) throwFeedingReferenceError(dependent);
+}
+
+export function assertCircuitsAreNotReferencedAsFeeders(
+  database: AppDatabase,
+  projectId: string,
+  circuitIds: string[]
+) {
+  if (circuitIds.length === 0) return;
+  const dependent = database
+    .select({
+      name: distributionBoards.name,
+      boardNumber: distributionBoards.boardNumber,
+    })
+    .from(distributionBoards)
+    .where(
+      and(
+        eq(distributionBoards.projectId, projectId),
+        inArray(
+          distributionBoards.feedingCircuitId,
+          [...new Set(circuitIds)]
+        )
+      )
+    )
+    .orderBy(asc(distributionBoards.boardNumber), asc(distributionBoards.name))
+    .limit(1)
+    .get();
+  if (dependent) throwFeedingReferenceError(dependent);
+}
+
+function throwFeedingReferenceError(dependent: {
+  name: string;
+  boardNumber: string | null;
+}): never {
+  const label = dependent.boardNumber ?? dependent.name;
+  throw new Error(`Speist ${label} – erst Einspeisung ändern.`);
+}
diff --git a/src/db/repositories/distribution-board-structure-project-command.repository.ts b/src/db/repositories/distribution-board-structure-project-command.repository.ts
index a4fba2b..9346df7 100644
--- a/src/db/repositories/distribution-board-structure-project-command.repository.ts
+++ b/src/db/repositories/distribution-board-structure-project-command.repository.ts
@@ -30,6 +30,7 @@ import { distributionBoards } from "../schema/distribution-boards.js";
 import { floors } from "../schema/floors.js";
 import { projects } from "../schema/projects.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { assertBoardsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
 
 export class DistributionBoardStructureProjectCommandRepository
   implements DistributionBoardStructureProjectCommandStore
@@ -248,6 +249,8 @@ export class DistributionBoardStructureProjectCommandRepository
       );
     }
 
+    assertBoardsAreNotReferencedAsFeeders(database, projectId, [board.id]);
+
     const deleted = database
       .delete(distributionBoards)
       .where(
diff --git a/src/db/repositories/distribution-board-subtree-project-command.repository.ts b/src/db/repositories/distribution-board-subtree-project-command.repository.ts
index 5d33b75..969c287 100644
--- a/src/db/repositories/distribution-board-subtree-project-command.repository.ts
+++ b/src/db/repositories/distribution-board-subtree-project-command.repository.ts
@@ -32,6 +32,7 @@ import { projects } from "../schema/projects.js";
 import { rooms } from "../schema/rooms.js";
 import { toCircuitDeviceRowInsertValues } from "./circuit-device-row-structure.persistence.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { assertBoardsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
 
 export class DistributionBoardSubtreeProjectCommandRepository
   implements DistributionBoardSubtreeProjectCommandStore
@@ -82,6 +83,9 @@ export class DistributionBoardSubtreeProjectCommandRepository
           "Distribution-board subtree changed before deletion."
         );
       }
+      assertBoardsAreNotReferencedAsFeeders(database, projectId, [
+        current.distributionBoard.id,
+      ]);
       const deleted = database
         .delete(distributionBoards)
         .where(
diff --git a/src/db/repositories/external-object-new-circuit-project-command.repository.ts b/src/db/repositories/external-object-new-circuit-project-command.repository.ts
index bea64ff..7667a28 100644
--- a/src/db/repositories/external-object-new-circuit-project-command.repository.ts
+++ b/src/db/repositories/external-object-new-circuit-project-command.repository.ts
@@ -33,6 +33,7 @@ import {
   snapshotsEqual,
 } from "./external-object-assignment.persistence.js";
 import { assertEquipmentIdentifierAvailable } from "./equipment-identifier-uniqueness.persistence.js";
+import { assertCircuitsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
 
 export class ExternalObjectNewCircuitProjectCommandRepository
   implements ExternalObjectNewCircuitProjectCommandStore
@@ -162,6 +163,9 @@ export class ExternalObjectNewCircuitProjectCommandRepository
       objects,
       "External object changed during new-circuit assignment."
     );
+    assertCircuitsAreNotReferencedAsFeeders(database, projectId, [
+      expectedCircuit.id,
+    ]);
     const deleted = database.delete(circuits).where(and(
       eq(circuits.id, expectedCircuit.id),
       eq(circuits.circuitListId, expectedCircuit.circuitListId)
diff --git a/tests/circuit-device-row-move-project-command.repository.test.ts b/tests/circuit-device-row-move-project-command.repository.test.ts
index 0569099..8975368 100644
--- a/tests/circuit-device-row-move-project-command.repository.test.ts
+++ b/tests/circuit-device-row-move-project-command.repository.test.ts
@@ -14,6 +14,7 @@ import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
 import { circuitProtectionDevices } from "../src/db/schema/circuit-protection-devices.js";
 import { circuitSections } from "../src/db/schema/circuit-sections.js";
 import { circuits } from "../src/db/schema/circuits.js";
+import { distributionBoards } from "../src/db/schema/distribution-boards.js";
 import { projectRevisions } from "../src/db/schema/project-revisions.js";
 import { projects } from "../src/db/schema/projects.js";
 import {
@@ -611,6 +612,62 @@ describe("circuit device-row move project-command repository", () => {
     }
   });
 
+  it("blocks undo from removing a generated circuit used as a feeder", () => {
+    const fixture = createTestDatabase();
+    try {
+      const store = new CircuitDeviceRowMoveProjectCommandRepository(
+        fixture.context.db
+      );
+      const targetCircuit = createMoveTargetSnapshot(fixture);
+      const command = createCircuitDeviceRowMoveWithNewCircuitProjectCommand(
+        "create",
+        targetCircuit,
+        [{
+          rowId: "row-1",
+          expectedCircuitId: "circuit-1",
+          expectedSortOrder: 10,
+          targetCircuitId: targetCircuit.id,
+          targetSortOrder: 10,
+        }]
+      );
+      const moved = store.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command,
+      });
+      const downstream = new DistributionBoardFixtureRepository(
+        fixture.context.db
+      ).createWithCircuitListAndDefaultSections("project-1", "UV-02");
+      fixture.context.db
+        .update(distributionBoards)
+        .set({
+          feedingDistributionBoardId: fixture.circuitListId,
+          feedingCircuitId: targetCircuit.id,
+        })
+        .where(eq(distributionBoards.id, downstream.id))
+        .run();
+
+      assert.throws(
+        () => store.execute({
+          projectId: "project-1",
+          expectedRevision: 1,
+          source: "undo",
+          historyTargetChangeSetId: moved.revision.changeSetId,
+          command: moved.inverse,
+        }),
+        /Speist UV-02 – erst Einspeisung ändern\./
+      );
+      assert.equal(getRow(fixture.context, "row-1")?.circuitId, targetCircuit.id);
+      assert.ok(
+        fixture.context.db.select().from(circuits)
+          .where(eq(circuits.id, targetCircuit.id)).get()
+      );
+    } finally {
+      fixture.context.close();
+    }
+  });
+
   it("rejects deletion when the created target changed outside history", () => {
     const fixture = createTestDatabase();
     try {
diff --git a/tests/circuit-group-subtree-project-command.repository.test.ts b/tests/circuit-group-subtree-project-command.repository.test.ts
index 05d7dcc..8494798 100644
--- a/tests/circuit-group-subtree-project-command.repository.test.ts
+++ b/tests/circuit-group-subtree-project-command.repository.test.ts
@@ -16,6 +16,7 @@ import { circuitSections } from "../src/db/schema/circuit-sections.js";
 import { circuits } from "../src/db/schema/circuits.js";
 import { distributionBoardComponentProtectionDevices } from "../src/db/schema/distribution-board-component-protection-devices.js";
 import { distributionBoardComponents } from "../src/db/schema/distribution-board-components.js";
+import { distributionBoards } from "../src/db/schema/distribution-boards.js";
 import { projectRevisions } from "../src/db/schema/project-revisions.js";
 import { projects } from "../src/db/schema/projects.js";
 import { createCircuitGroupDeleteSubtreeProjectCommand } from "../src/domain/models/circuit-group-subtree-project-command.model.js";
@@ -228,6 +229,45 @@ describe("circuit-group subtree project command", () => {
     }
   });
 
+  it("blocks deleting a group containing a feeding circuit", () => {
+    const context = createTestDatabase();
+    try {
+      const list = context.db.select().from(circuitLists).get()!;
+      const downstream = new DistributionBoardFixtureRepository(
+        context.db
+      ).createWithCircuitListAndDefaultSections("project-1", "Unterverteiler");
+      context.db
+        .update(distributionBoards)
+        .set({
+          feedingDistributionBoardId: list.distributionBoardId,
+          feedingCircuitId: "subtree-circuit",
+        })
+        .where(eq(distributionBoards.id, downstream.id))
+        .run();
+      const repository =
+        new CircuitGroupSubtreeProjectCommandRepository(context.db);
+      const groupId = context.db
+        .select()
+        .from(circuits)
+        .where(eq(circuits.id, "subtree-circuit"))
+        .get()!.sectionId;
+      const snapshot = repository.capture("project-1", groupId);
+
+      assert.throws(
+        () => repository.execute({
+          projectId: "project-1",
+          expectedRevision: 0,
+          source: "user",
+          command: createCircuitGroupDeleteSubtreeProjectCommand(snapshot),
+        }),
+        /Speist Unterverteiler – erst Einspeisung ändern\./
+      );
+      assert.deepEqual(repository.capture("project-1", groupId), snapshot);
+    } finally {
+      context.close();
+    }
+  });
+
   it("rolls back a cascaded deletion when history persistence fails", () => {
     const context = createTestDatabase();
     try {
diff --git a/tests/circuit-structure-project-command.repository.test.ts b/tests/circuit-structure-project-command.repository.test.ts
index 4c05554..8985ad0 100644
--- a/tests/circuit-structure-project-command.repository.test.ts
+++ b/tests/circuit-structure-project-command.repository.test.ts
@@ -14,6 +14,7 @@ import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
 import { circuitProtectionDevices } from "../src/db/schema/circuit-protection-devices.js";
 import { circuitSections } from "../src/db/schema/circuit-sections.js";
 import { circuits } from "../src/db/schema/circuits.js";
+import { distributionBoards } from "../src/db/schema/distribution-boards.js";
 import { projectDevices } from "../src/db/schema/project-devices.js";
 import { projectRevisions } from "../src/db/schema/project-revisions.js";
 import { projects } from "../src/db/schema/projects.js";
@@ -442,6 +443,48 @@ describe("circuit structure project-command repository", () => {
     }
   });
 
+  it("blocks deleting a circuit that feeds a distribution board", () => {
+    const fixture = createTestDatabase();
+    try {
+      const downstream = new DistributionBoardFixtureRepository(
+        fixture.context.db
+      ).createWithCircuitListAndDefaultSections("project-1", "UV Unterverteiler");
+      fixture.context.db
+        .update(distributionBoards)
+        .set({
+          boardNumber: "UV-02",
+          feedingDistributionBoardId: fixture.circuitListId,
+          feedingCircuitId: "circuit-existing",
+        })
+        .where(eq(distributionBoards.id, downstream.id))
+        .run();
+
+      const store = new CircuitStructureProjectCommandRepository(
+        fixture.context.db
+      );
+      assert.throws(
+        () =>
+          store.execute({
+            projectId: "project-1",
+            expectedRevision: 0,
+            source: "user",
+            command: createCircuitDeleteProjectCommand(
+              "circuit-existing",
+              fixture.circuitListId
+            ),
+          }),
+        /Speist UV-02 – erst Einspeisung ändern\./
+      );
+      assert.ok(getCircuit(fixture.context, "circuit-existing"));
+      assert.equal(
+        fixture.context.db.select().from(projectRevisions).all().length,
+        0
+      );
+    } finally {
+      fixture.context.close();
+    }
+  });
+
   it("rolls back insert and delete for late history failures", () => {
     const fixture = createTestDatabase();
     try {
diff --git a/tests/distribution-board-structure-project-command.repository.test.ts b/tests/distribution-board-structure-project-command.repository.test.ts
index e6aff4b..a02f005 100644
--- a/tests/distribution-board-structure-project-command.repository.test.ts
+++ b/tests/distribution-board-structure-project-command.repository.test.ts
@@ -219,6 +219,54 @@ describe("distribution-board structure project command", () => {
     }
   });
 
+  it("blocks undo from removing an empty board used as a feeder", () => {
+    const context = createTestDatabase();
+    try {
+      const repository =
+        new DistributionBoardStructureProjectCommandRepository(context.db);
+      const upstream = createDistributionBoardStructureSnapshot(
+        "project-1",
+        "NSHV"
+      );
+      const inserted = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createDistributionBoardInsertProjectCommand(upstream),
+      });
+      const downstream = createDistributionBoardStructureSnapshot(
+        "project-1",
+        "UV-01"
+      );
+      context.db.insert(distributionBoards).values({
+        ...downstream.distributionBoard,
+        boardNumber: "UV-01",
+        feedingDistributionBoardId: upstream.distributionBoard.id,
+      }).run();
+      context.db.insert(circuitLists).values(downstream.circuitList).run();
+      context.db.insert(circuitSections).values(downstream.sections).run();
+      context.db.insert(distributionBoardComponents)
+        .values(downstream.components).run();
+
+      assert.throws(
+        () => repository.execute({
+          projectId: "project-1",
+          expectedRevision: 1,
+          source: "undo",
+          historyTargetChangeSetId: inserted.revision.changeSetId,
+          command: inserted.inverse,
+        }),
+        /Speist UV-01 – erst Einspeisung ändern\./
+      );
+      assert.ok(
+        context.db.select().from(distributionBoards)
+          .where(eq(distributionBoards.id, upstream.distributionBoard.id)).get()
+      );
+    } finally {
+      context.close();
+    }
+  });
+
   it("allows only supply types enabled in the project", () => {
     const context = createTestDatabase();
     try {
diff --git a/tests/distribution-board-subtree-project-command.repository.test.ts b/tests/distribution-board-subtree-project-command.repository.test.ts
index 7975f2b..6508b9b 100644
--- a/tests/distribution-board-subtree-project-command.repository.test.ts
+++ b/tests/distribution-board-subtree-project-command.repository.test.ts
@@ -291,6 +291,43 @@ describe("distribution-board subtree project command", () => {
     }
   });
 
+  it("blocks deleting a board subtree that feeds another board", () => {
+    const context = createTestDatabase();
+    try {
+      const upstream = createPopulatedBoard(context);
+      const downstream = new DistributionBoardFixtureRepository(
+        context.db
+      ).createWithCircuitListAndDefaultSections("project-1", "Unterverteiler");
+      context.db
+        .update(distributionBoards)
+        .set({
+          boardNumber: "UV-03",
+          feedingDistributionBoardId: upstream.id,
+        })
+        .where(eq(distributionBoards.id, downstream.id))
+        .run();
+      const repository =
+        new DistributionBoardSubtreeProjectCommandRepository(context.db);
+      const snapshot = repository.capture("project-1", upstream.id);
+
+      assert.throws(
+        () =>
+          repository.execute({
+            projectId: "project-1",
+            expectedRevision: 0,
+            source: "user",
+            command:
+              createDistributionBoardDeleteSubtreeProjectCommand(snapshot),
+          }),
+        /Speist UV-03 – erst Einspeisung ändern\./
+      );
+      assert.deepEqual(repository.capture("project-1", upstream.id), snapshot);
+      assert.equal(context.db.select().from(projectRevisions).all().length, 0);
+    } finally {
+      context.close();
+    }
+  });
+
   it("rolls back a cascaded deletion when history persistence fails", () => {
     const context = createTestDatabase();
     try {
diff --git a/tests/external-object-row-assignment-project-command.repository.test.ts b/tests/external-object-row-assignment-project-command.repository.test.ts
index da8551e..35579eb 100644
--- a/tests/external-object-row-assignment-project-command.repository.test.ts
+++ b/tests/external-object-row-assignment-project-command.repository.test.ts
@@ -533,6 +533,61 @@ describe("external object new-circuit project command", () => {
     }
   });
 
+  it("blocks history removal when the generated circuit became a feeder", () => {
+    const context = createFixture(null);
+    try {
+      const object = objectSnapshot(null);
+      const circuit = newExternalCircuit(context.db);
+      const command = createExternalObjectNewCircuitProjectCommand(
+        externalObjectAssignToNewCircuitCommandType,
+        {
+          circuit,
+          objects: [{
+            expected: object,
+            target: { ...object, circuitDeviceRowId: "row-new" },
+          }],
+          confirmedConflictObjectIds: [],
+        }
+      );
+      const repository = new ExternalObjectNewCircuitProjectCommandRepository(context.db);
+      const inserted = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command,
+      });
+      context.db.insert(distributionBoards).values({
+        id: "board-2",
+        projectId: "project-1",
+        name: "Unterverteiler",
+        boardNumber: "UV-02",
+        feedingDistributionBoardId: "board-1",
+        feedingCircuitId: circuit.id,
+      }).run();
+
+      assert.throws(
+        () => repository.execute({
+          projectId: "project-1",
+          expectedRevision: 1,
+          source: "undo",
+          historyTargetChangeSetId: inserted.revision.changeSetId,
+          command: inserted.inverse,
+        }),
+        /Speist UV-02 – erst Einspeisung ändern\./
+      );
+      assert.ok(
+        context.db.select().from(circuits)
+          .where(eq(circuits.id, circuit.id)).get()
+      );
+      assert.equal(
+        context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId,
+        "row-new"
+      );
+    } finally {
+      context.close();
+    }
+  });
+
   it("rolls back the complete circuit subtree when history persistence fails", () => {
     const context = createFixture(null);
     try {

From dfeb0e3cb61b7bb420976ed36fcb29bbb2615be4 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 22:31:56 +0200
Subject: [PATCH 36/60] Add recursive distribution board load projection

---
 .../circuit-section.repository.ts             |  11 +-
 src/db/repositories/circuit.repository.ts     |  11 +-
 ...distribution-board-component.repository.ts |  12 +
 .../distribution-board-load-calculation.ts    | 217 +++++++++++
 src/domain/models/circuit-tree.model.ts       |  36 ++
 src/frontend/types.ts                         |  33 ++
 src/frontend/utils/api.ts                     |   7 +
 .../controllers/circuit-tree.controller.ts    | 366 ++++++++++++------
 src/server/routes/project.routes.ts           |   6 +-
 tests/circuit-tree.controller.test.ts         |  51 ++-
 ...istribution-board-load-calculation.test.ts |  89 +++++
 11 files changed, 701 insertions(+), 138 deletions(-)
 create mode 100644 src/domain/calculations/distribution-board-load-calculation.ts
 create mode 100644 tests/distribution-board-load-calculation.test.ts

diff --git a/src/db/repositories/circuit-section.repository.ts b/src/db/repositories/circuit-section.repository.ts
index d7817ec..79a3704 100644
--- a/src/db/repositories/circuit-section.repository.ts
+++ b/src/db/repositories/circuit-section.repository.ts
@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { and, asc, eq } from "drizzle-orm";
+import { and, asc, eq, inArray } from "drizzle-orm";
 import { defaultCircuitSectionDefinitions } from "../../domain/models/distribution-board-structure-project-command.model.js";
 import type { AppDatabase } from "../database-context.js";
 import { circuitSections } from "../schema/circuit-sections.js";
@@ -30,6 +30,15 @@ export class CircuitSectionRepository {
       .orderBy(asc(circuitSections.sortOrder));
   }
 
+  async listByCircuitLists(circuitListIds: string[]) {
+    if (circuitListIds.length === 0) return [];
+    return this.database
+      .select()
+      .from(circuitSections)
+      .where(inArray(circuitSections.circuitListId, circuitListIds))
+      .orderBy(asc(circuitSections.sortOrder), asc(circuitSections.id));
+  }
+
   async createDefaults(circuitListId: string) {
     const db = this.database;
     for (const entry of createDefaultCircuitSectionValues(circuitListId)) {
diff --git a/src/db/repositories/circuit.repository.ts b/src/db/repositories/circuit.repository.ts
index ecbaba0..7d40fa1 100644
--- a/src/db/repositories/circuit.repository.ts
+++ b/src/db/repositories/circuit.repository.ts
@@ -1,4 +1,4 @@
-import { asc, eq } from "drizzle-orm";
+import { asc, eq, inArray } from "drizzle-orm";
 import type { AppDatabase } from "../database-context.js";
 import { circuits } from "../schema/circuits.js";
 
@@ -14,6 +14,15 @@ export class CircuitRepository {
       .orderBy(asc(circuits.sortOrder), asc(circuits.equipmentIdentifier));
   }
 
+  async listByCircuitLists(circuitListIds: string[]) {
+    if (circuitListIds.length === 0) return [];
+    return this.database
+      .select()
+      .from(circuits)
+      .where(inArray(circuits.circuitListId, circuitListIds))
+      .orderBy(asc(circuits.sortOrder), asc(circuits.equipmentIdentifier));
+  }
+
   async listBySection(sectionId: string) {
     const db = this.database;
     return db
diff --git a/src/db/repositories/distribution-board-component.repository.ts b/src/db/repositories/distribution-board-component.repository.ts
index ab60603..eedb4af 100644
--- a/src/db/repositories/distribution-board-component.repository.ts
+++ b/src/db/repositories/distribution-board-component.repository.ts
@@ -19,6 +19,18 @@ export class DistributionBoardComponentRepository {
       );
   }
 
+  async listByCircuitLists(circuitListIds: string[]) {
+    if (circuitListIds.length === 0) return [];
+    return this.database
+      .select()
+      .from(distributionBoardComponents)
+      .where(inArray(distributionBoardComponents.circuitListId, circuitListIds))
+      .orderBy(
+        asc(distributionBoardComponents.sortOrder),
+        asc(distributionBoardComponents.id)
+      );
+  }
+
   async listProtectionByComponentIds(componentIds: string[]) {
     if (componentIds.length === 0) {
       return [];
diff --git a/src/domain/calculations/distribution-board-load-calculation.ts b/src/domain/calculations/distribution-board-load-calculation.ts
new file mode 100644
index 0000000..4c7bad6
--- /dev/null
+++ b/src/domain/calculations/distribution-board-load-calculation.ts
@@ -0,0 +1,217 @@
+export interface DistributionBoardLoadBoardInput {
+  id: string;
+  name: string;
+  boardNumber: string | null;
+  simultaneityFactor: number;
+  feedingDistributionBoardId: string | null;
+  feedingCircuitId: string | null;
+}
+
+export interface DistributionBoardLoadCircuitInput {
+  id: string;
+  distributionBoardId: string;
+  rows: Array<{
+    activePowerKw: number;
+    cosPhi: number | null;
+  }>;
+}
+
+export interface DownstreamDistributionBoardLoad {
+  distributionBoardId: string;
+  name: string;
+  boardNumber: string | null;
+  activePowerKw: number;
+  apparentPowerKva: number;
+  cosPhi: number;
+}
+
+export interface CalculatedCircuitLoad {
+  circuitId: string;
+  deviceActivePowerKw: number;
+  deviceApparentPowerKva: number;
+  activePowerKw: number;
+  apparentPowerKva: number;
+  cosPhi: number;
+  downstreamBoards: DownstreamDistributionBoardLoad[];
+}
+
+export interface CalculatedDistributionBoardLoad {
+  distributionBoardId: string;
+  activePowerBeforeSimultaneityKw: number;
+  apparentPowerBeforeSimultaneityKva: number;
+  demandActivePowerKw: number;
+  demandApparentPowerKva: number;
+  cosPhi: number;
+}
+
+export interface DistributionBoardLoadCalculation {
+  boards: Map<string, CalculatedDistributionBoardLoad>;
+  circuits: Map<string, CalculatedCircuitLoad>;
+}
+
+/**
+ * Calculates one project graph. A child board enters exactly one feeder
+ * circuit with its demand after the child's own board simultaneity factor.
+ * Board-only relations form a hierarchy but intentionally add no load.
+ */
+export function calculateDistributionBoardLoads(input: {
+  boards: DistributionBoardLoadBoardInput[];
+  circuits: DistributionBoardLoadCircuitInput[];
+}): DistributionBoardLoadCalculation {
+  const boardById = new Map(input.boards.map((board) => [board.id, board]));
+  const circuitById = new Map(input.circuits.map((circuit) => [circuit.id, circuit]));
+  const circuitsByBoardId = groupBy(
+    input.circuits,
+    (circuit) => circuit.distributionBoardId
+  );
+  const childrenByCircuitId = new Map<string, DistributionBoardLoadBoardInput[]>();
+  for (const board of input.boards) {
+    assertBoardInput(board, boardById, circuitById);
+    if (board.feedingCircuitId === null) continue;
+    const children = childrenByCircuitId.get(board.feedingCircuitId) ?? [];
+    children.push(board);
+    childrenByCircuitId.set(board.feedingCircuitId, children);
+  }
+
+  const boards = new Map<string, CalculatedDistributionBoardLoad>();
+  const circuits = new Map<string, CalculatedCircuitLoad>();
+  const activePath = new Set<string>();
+
+  const calculateBoard = (boardId: string): CalculatedDistributionBoardLoad => {
+    const cached = boards.get(boardId);
+    if (cached) return cached;
+    if (activePath.has(boardId)) {
+      throw new Error("Distribution-board feeding graph contains a cycle.");
+    }
+    const board = boardById.get(boardId);
+    if (!board) throw new Error("Distribution board is missing from load graph.");
+    activePath.add(boardId);
+
+    let activePowerBeforeSimultaneityKw = 0;
+    let apparentPowerBeforeSimultaneityKva = 0;
+    for (const circuit of circuitsByBoardId.get(boardId) ?? []) {
+      let deviceActivePowerKw = 0;
+      let deviceApparentPowerKva = 0;
+      for (const row of circuit.rows) {
+        assertNonNegativeFinite(row.activePowerKw, "row active power");
+        const cosPhi = row.cosPhi ?? 1;
+        if (!Number.isFinite(cosPhi) || cosPhi <= 0 || cosPhi > 1) {
+          throw new Error("Row cos phi must be greater than zero and at most one.");
+        }
+        deviceActivePowerKw += row.activePowerKw;
+        deviceApparentPowerKva += row.activePowerKw / cosPhi;
+      }
+      const downstreamBoards = (childrenByCircuitId.get(circuit.id) ?? [])
+        .map((child) => {
+          const childLoad = calculateBoard(child.id);
+          return {
+            distributionBoardId: child.id,
+            name: child.name,
+            boardNumber: child.boardNumber,
+            activePowerKw: childLoad.demandActivePowerKw,
+            apparentPowerKva: childLoad.demandApparentPowerKva,
+            cosPhi: effectiveCosPhi(
+              childLoad.demandActivePowerKw,
+              childLoad.demandApparentPowerKva
+            ),
+          };
+        });
+      const activePowerKw =
+        deviceActivePowerKw +
+        downstreamBoards.reduce((sum, child) => sum + child.activePowerKw, 0);
+      const apparentPowerKva =
+        deviceApparentPowerKva +
+        downstreamBoards.reduce((sum, child) => sum + child.apparentPowerKva, 0);
+      circuits.set(circuit.id, {
+        circuitId: circuit.id,
+        deviceActivePowerKw,
+        deviceApparentPowerKva,
+        activePowerKw,
+        apparentPowerKva,
+        cosPhi: effectiveCosPhi(activePowerKw, apparentPowerKva),
+        downstreamBoards,
+      });
+      activePowerBeforeSimultaneityKw += activePowerKw;
+      apparentPowerBeforeSimultaneityKva += apparentPowerKva;
+    }
+
+    activePath.delete(boardId);
+    const result = {
+      distributionBoardId: boardId,
+      activePowerBeforeSimultaneityKw,
+      apparentPowerBeforeSimultaneityKva,
+      demandActivePowerKw:
+        activePowerBeforeSimultaneityKw * board.simultaneityFactor,
+      demandApparentPowerKva:
+        apparentPowerBeforeSimultaneityKva * board.simultaneityFactor,
+      cosPhi: effectiveCosPhi(
+        activePowerBeforeSimultaneityKw,
+        apparentPowerBeforeSimultaneityKva
+      ),
+    };
+    boards.set(boardId, result);
+    return result;
+  };
+
+  for (const board of input.boards) calculateBoard(board.id);
+  return { boards, circuits };
+}
+
+function assertBoardInput(
+  board: DistributionBoardLoadBoardInput,
+  boardById: Map<string, DistributionBoardLoadBoardInput>,
+  circuitById: Map<string, DistributionBoardLoadCircuitInput>
+) {
+  if (
+    !Number.isFinite(board.simultaneityFactor) ||
+    board.simultaneityFactor < 0 ||
+    board.simultaneityFactor > 1
+  ) {
+    throw new Error("Board simultaneity factor must be between zero and one.");
+  }
+  if (board.feedingDistributionBoardId === board.id) {
+    throw new Error("Distribution board cannot feed itself.");
+  }
+  if (
+    board.feedingDistributionBoardId !== null &&
+    !boardById.has(board.feedingDistributionBoardId)
+  ) {
+    throw new Error("Feeding distribution board is missing from load graph.");
+  }
+  if (
+    board.feedingCircuitId !== null &&
+    board.feedingDistributionBoardId === null
+  ) {
+    throw new Error("Feeding circuit requires a feeding distribution board.");
+  }
+  if (
+    board.feedingCircuitId !== null &&
+    circuitById.get(board.feedingCircuitId)?.distributionBoardId !==
+      board.feedingDistributionBoardId
+  ) {
+    throw new Error("Feeding circuit belongs to another distribution board.");
+  }
+}
+
+function effectiveCosPhi(activePowerKw: number, apparentPowerKva: number) {
+  return activePowerKw > 0 && apparentPowerKva > 0
+    ? activePowerKw / apparentPowerKva
+    : 1;
+}
+
+function assertNonNegativeFinite(value: number, label: string) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative finite number.`);
+  }
+}
+
+function groupBy<T>(values: T[], keyOf: (value: T) => string) {
+  const groups = new Map<string, T[]>();
+  for (const value of values) {
+    const key = keyOf(value);
+    const group = groups.get(key) ?? [];
+    group.push(value);
+    groups.set(key, group);
+  }
+  return groups;
+}
diff --git a/src/domain/models/circuit-tree.model.ts b/src/domain/models/circuit-tree.model.ts
index 71fb743..2e1aa72 100644
--- a/src/domain/models/circuit-tree.model.ts
+++ b/src/domain/models/circuit-tree.model.ts
@@ -40,7 +40,10 @@ export interface CircuitTreeCircuit {
   isReserve: boolean;
   remark?: string;
   circuitTotalPower: number;
+  circuitApparentPower: number;
+  circuitCosPhi: number;
   deviceRows: CircuitTreeDeviceRow[];
+  downstreamBoardLoads: CircuitTreeDownstreamBoardLoad[];
   protectionDevice?: CircuitTreeProtectionDevice;
 }
 
@@ -59,6 +62,11 @@ export interface CircuitTreeSectionBlock {
 
 export interface CircuitTreeResponse {
   circuitListId: string;
+  distributionBoardId: string;
+  distributionBoardName: string;
+  distributionBoardNumber?: string;
+  distributionBoardSupplyType?: DistributionBoardSupplyType;
+  feedingReference?: CircuitTreeFeedingReference;
   currentRevision: number;
   singlePhaseVoltageV: number;
   threePhaseVoltageV: number;
@@ -70,7 +78,35 @@ export interface CircuitTreeResponse {
   footerComponents: CircuitTreeComponent[];
 }
 
+export interface CircuitTreeDownstreamBoardLoad {
+  distributionBoardId: string;
+  name: string;
+  boardNumber?: string;
+  supplyType?: DistributionBoardSupplyType;
+  activePowerKw: number;
+  apparentPowerKva: number;
+  cosPhi: number;
+}
+
+export interface CircuitTreeFeedingReference {
+  distributionBoardId: string;
+  distributionBoardName: string;
+  distributionBoardNumber?: string;
+  circuitId?: string;
+  circuitEquipmentIdentifier?: string;
+  circuitDisplayName?: string;
+  circuitCategory?: CircuitGroupCategory;
+}
+
+export interface ProjectCircuitTreesResponse {
+  currentRevision: number;
+  trees: CircuitTreeResponse[];
+}
+
 import type { CircuitGroupCategory } from "../../shared/constants/circuit-group.js";
+import type {
+  DistributionBoardSupplyType,
+} from "../../shared/constants/distribution-board.js";
 import type {
   DistributionBoardComponentPlacement,
   DistributionBoardComponentRole,
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index a1cc7bc..8a2dec4 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -444,7 +444,10 @@ export interface CircuitTreeCircuitDto {
   isReserve: boolean;
   remark?: string;
   circuitTotalPower: number;
+  circuitApparentPower: number;
+  circuitCosPhi: number;
   deviceRows: CircuitTreeDeviceRowDto[];
+  downstreamBoardLoads: CircuitTreeDownstreamBoardLoadDto[];
   protectionDevice?: CircuitTreeProtectionDeviceDto;
 }
 
@@ -463,6 +466,11 @@ export interface CircuitTreeSectionDto {
 
 export interface CircuitTreeResponseDto {
   circuitListId: string;
+  distributionBoardId: string;
+  distributionBoardName: string;
+  distributionBoardNumber?: string;
+  distributionBoardSupplyType?: DistributionBoardSupplyType;
+  feedingReference?: CircuitTreeFeedingReferenceDto;
   currentRevision: number;
   singlePhaseVoltageV: number;
   threePhaseVoltageV: number;
@@ -474,6 +482,31 @@ export interface CircuitTreeResponseDto {
   footerComponents: CircuitTreeComponentDto[];
 }
 
+export interface CircuitTreeDownstreamBoardLoadDto {
+  distributionBoardId: string;
+  name: string;
+  boardNumber?: string;
+  supplyType?: DistributionBoardSupplyType;
+  activePowerKw: number;
+  apparentPowerKva: number;
+  cosPhi: number;
+}
+
+export interface CircuitTreeFeedingReferenceDto {
+  distributionBoardId: string;
+  distributionBoardName: string;
+  distributionBoardNumber?: string;
+  circuitId?: string;
+  circuitEquipmentIdentifier?: string;
+  circuitDisplayName?: string;
+  circuitCategory?: CircuitGroupCategory;
+}
+
+export interface ProjectCircuitTreesResponseDto {
+  currentRevision: number;
+  trees: CircuitTreeResponseDto[];
+}
+
 export interface ExternalCircuitListObjectDto {
   id: string;
   ifcGuid: string;
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index 5e814c9..8473bfa 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -33,6 +33,7 @@ import type {
   ProjectDto,
   RoomDto,
   CircuitTreeResponseDto,
+  ProjectCircuitTreesResponseDto,
   ExternalCsvConfigurationSnapshotDto,
   ExternalCsvPreviewDto,
   ExternalInitialImportPlanDto,
@@ -529,6 +530,12 @@ export function getCircuitTree(projectId: string, circuitListId: string) {
   return request<CircuitTreeResponseDto>(`/api/projects/${projectId}/circuit-lists/${circuitListId}/tree`);
 }
 
+export function getProjectCircuitTrees(projectId: string) {
+  return request<ProjectCircuitTreesResponseDto>(
+    `/api/projects/${projectId}/circuit-trees`
+  );
+}
+
 export function insertDistributionBoardComponentCommand(
   projectId: string,
   expectedRevision: number,
diff --git a/src/server/controllers/circuit-tree.controller.ts b/src/server/controllers/circuit-tree.controller.ts
index b7c86bf..22b4a73 100644
--- a/src/server/controllers/circuit-tree.controller.ts
+++ b/src/server/controllers/circuit-tree.controller.ts
@@ -1,13 +1,11 @@
 import type { Request, Response } from "express";
-import {
-  applyDistributionBoardSimultaneityFactor,
-  calculateCircuitTotalPower,
-  calculateDistributionBoardTotalPower,
-  calculateRowTotalPower,
-  calculateSectionTotalPower,
-} from "../../domain/calculations/circuit-power-calculation.js";
-import type { CircuitTreeResponse } from "../../domain/models/circuit-tree.model.js";
-import type { CircuitTreeProtectionDevice } from "../../domain/models/circuit-tree.model.js";
+import { calculateDistributionBoardLoads } from "../../domain/calculations/distribution-board-load-calculation.js";
+import { calculateRowTotalPower } from "../../domain/calculations/circuit-power-calculation.js";
+import type {
+  CircuitTreeProtectionDevice,
+  CircuitTreeResponse,
+  ProjectCircuitTreesResponse,
+} from "../../domain/models/circuit-tree.model.js";
 import {
   circuitDeviceRowRepository,
   circuitListRepository,
@@ -20,9 +18,7 @@ import {
 } from "../composition/application-repositories.js";
 
 export function isMissingCircuitTreeSchemaError(error: unknown): boolean {
-  if (!(error instanceof Error)) {
-    return false;
-  }
+  if (!(error instanceof Error)) return false;
   return (
     error.message.includes("no such table: circuit_sections") ||
     error.message.includes("no such table: circuits") ||
@@ -37,70 +33,143 @@ export async function getCircuitTree(req: Request, res: Response) {
   if (typeof projectId !== "string" || typeof circuitListId !== "string") {
     return res.status(400).json({ error: "Invalid parameters" });
   }
-
   const list = await circuitListRepository.findById(projectId, circuitListId);
-  if (!list) {
-    return res.status(404).json({ error: "Circuit list not found" });
-  }
-  const project = await projectRepository.findById(projectId);
-  if (!project) {
-    return res.status(404).json({ error: "Project not found" });
-  }
-  const distributionBoard =
-    await distributionBoardRepository.findById(
-      projectId,
-      list.distributionBoardId
-    );
-  if (!distributionBoard) {
-    return res.status(404).json({
-      error: "Distribution board not found",
-    });
-  }
+  if (!list) return res.status(404).json({ error: "Circuit list not found" });
 
   try {
-    const sections = await circuitSectionRepository.listByCircuitList(circuitListId);
-    const circuits = await circuitRepository.listByCircuitList(circuitListId);
-    const rows = await circuitDeviceRowRepository.listByCircuitList(circuits.map((entry) => entry.id));
-    const components =
-      await distributionBoardComponentRepository.listByCircuitList(
-        circuitListId
-      );
-    const [circuitProtections, componentProtections] =
-      await Promise.all([
-        circuitProtectionDeviceRepository.listByCircuitIds(
-          circuits.map((entry) => entry.id)
-        ),
-        distributionBoardComponentRepository.listProtectionByComponentIds(
-          components.map((entry) => entry.id)
-        ),
-      ]);
-
-    const sectionById = new Map(sections.map((section) => [section.id, section]));
-    const rowsByCircuitId = new Map<string, typeof rows>();
-    const circuitProtectionById = new Map(
-      circuitProtections.map((entry) => [entry.circuitId, entry])
-    );
-    const componentProtectionById = new Map(
-      componentProtections.map((entry) => [entry.componentId, entry])
-    );
-    for (const row of rows) {
-      if (!rowsByCircuitId.has(row.circuitId)) {
-        rowsByCircuitId.set(row.circuitId, []);
-      }
-      rowsByCircuitId.get(row.circuitId)!.push(row);
+    const result = await buildProjectCircuitTrees(projectId);
+    if (!result) return res.status(404).json({ error: "Project not found" });
+    const tree = result.trees.find((entry) => entry.circuitListId === circuitListId);
+    if (!tree) {
+      return res.status(404).json({ error: "Distribution board not found" });
     }
+    return res.json(tree);
+  } catch (error) {
+    if (isMissingCircuitTreeSchemaError(error)) {
+      const project = await projectRepository.findById(projectId);
+      const board = await distributionBoardRepository.findById(
+        projectId,
+        list.distributionBoardId
+      );
+      if (!project || !board) {
+        return res.status(404).json({ error: "Project structure not found" });
+      }
+      return res.json(emptyCircuitTree(project, board, circuitListId));
+    }
+    throw error;
+  }
+}
 
+export async function getProjectCircuitTrees(req: Request, res: Response) {
+  const { projectId } = req.params;
+  if (typeof projectId !== "string") {
+    return res.status(400).json({ error: "Invalid parameters" });
+  }
+  try {
+    const result = await buildProjectCircuitTrees(projectId);
+    if (!result) return res.status(404).json({ error: "Project not found" });
+    return res.json(result);
+  } catch (error) {
+    if (isMissingCircuitTreeSchemaError(error)) {
+      const project = await projectRepository.findById(projectId);
+      if (!project) return res.status(404).json({ error: "Project not found" });
+      return res.json({ currentRevision: project.currentRevision, trees: [] });
+    }
+    throw error;
+  }
+}
+
+export async function buildProjectCircuitTrees(
+  projectId: string
+): Promise<ProjectCircuitTreesResponse | null> {
+  const project = await projectRepository.findById(projectId);
+  if (!project) return null;
+  const [lists, boards] = await Promise.all([
+    circuitListRepository.listByProject(projectId),
+    distributionBoardRepository.listByProject(projectId),
+  ]);
+  const listIds = lists.map((entry) => entry.id);
+  const [sections, circuits, components] = await Promise.all([
+    circuitSectionRepository.listByCircuitLists(listIds),
+    circuitRepository.listByCircuitLists(listIds),
+    distributionBoardComponentRepository.listByCircuitLists(listIds),
+  ]);
+  const [rows, circuitProtections, componentProtections] = await Promise.all([
+    circuitDeviceRowRepository.listByCircuitList(circuits.map((entry) => entry.id)),
+    circuitProtectionDeviceRepository.listByCircuitIds(circuits.map((entry) => entry.id)),
+    distributionBoardComponentRepository.listProtectionByComponentIds(
+      components.map((entry) => entry.id)
+    ),
+  ]);
+
+  const boardById = new Map(boards.map((board) => [board.id, board]));
+  const listById = new Map(lists.map((list) => [list.id, list]));
+  const sectionById = new Map(sections.map((section) => [section.id, section]));
+  const circuitById = new Map(circuits.map((circuit) => [circuit.id, circuit]));
+  const rowsByCircuitId = groupBy(rows, (row) => row.circuitId);
+  const sectionsByListId = groupBy(sections, (section) => section.circuitListId);
+  const circuitsByListId = groupBy(circuits, (circuit) => circuit.circuitListId);
+  const componentsByListId = groupBy(components, (component) => component.circuitListId);
+  const circuitProtectionById = new Map(
+    circuitProtections.map((entry) => [entry.circuitId, entry])
+  );
+  const componentProtectionById = new Map(
+    componentProtections.map((entry) => [entry.componentId, entry])
+  );
+
+  const loads = calculateDistributionBoardLoads({
+    boards: boards.map((board) => ({
+      id: board.id,
+      name: board.name,
+      boardNumber: board.boardNumber,
+      simultaneityFactor: board.simultaneityFactor,
+      feedingDistributionBoardId: board.feedingDistributionBoardId,
+      feedingCircuitId: board.feedingCircuitId,
+    })),
+    circuits: circuits.map((circuit) => {
+      const list = listById.get(circuit.circuitListId);
+      if (!list) throw new Error("Circuit list is missing from project tree.");
+      return {
+        id: circuit.id,
+        distributionBoardId: list.distributionBoardId,
+        rows: (rowsByCircuitId.get(circuit.id) ?? []).map((row) => ({
+          activePowerKw: calculateRowTotalPower(
+            row.quantity,
+            row.powerPerUnit,
+            row.simultaneityFactor
+          ),
+          cosPhi: row.cosPhi,
+        })),
+      };
+    }),
+  });
+
+  const trees = lists.map((list): CircuitTreeResponse => {
+    const board = boardById.get(list.distributionBoardId);
+    if (!board) throw new Error("Distribution board is missing from project tree.");
+    const boardLoad = loads.boards.get(board.id);
+    if (!boardLoad) throw new Error("Distribution-board load is missing.");
     const tree: CircuitTreeResponse = {
-      circuitListId,
+      circuitListId: list.id,
+      distributionBoardId: board.id,
+      distributionBoardName: board.name,
+      distributionBoardNumber: board.boardNumber ?? undefined,
+      distributionBoardSupplyType: board.supplyType ?? undefined,
+      feedingReference: resolveFeedingReference(
+        board,
+        boardById,
+        circuitById,
+        sectionById
+      ),
       currentRevision: project.currentRevision,
       singlePhaseVoltageV: project.singlePhaseVoltageV,
       threePhaseVoltageV: project.threePhaseVoltageV,
-      distributionBoardSimultaneityFactor:
-        distributionBoard.simultaneityFactor,
-      distributionBoardTotalPower: 0,
-      distributionBoardTotalPowerWithSimultaneityFactor: 0,
+      distributionBoardSimultaneityFactor: board.simultaneityFactor,
+      distributionBoardTotalPower: boardLoad.activePowerBeforeSimultaneityKw,
+      distributionBoardTotalPowerWithSimultaneityFactor:
+        boardLoad.demandActivePowerKw,
       headerComponents: [],
-      sections: sections.map((section) => ({
+      sections: (sectionsByListId.get(list.id) ?? []).map((section) => ({
         id: section.id,
         key: section.key,
         displayName: section.displayName,
@@ -115,9 +184,8 @@ export async function getCircuitTree(req: Request, res: Response) {
       footerComponents: [],
     };
     const sectionBlocks = new Map(tree.sections.map((section) => [section.id, section]));
-    for (const component of components) {
-      const protection =
-        componentProtectionById.get(component.id);
+    for (const component of componentsByListId.get(list.id) ?? []) {
+      const protection = componentProtectionById.get(component.id);
       const dto = {
         id: component.id,
         circuitListId: component.circuitListId,
@@ -127,24 +195,18 @@ export async function getCircuitTree(req: Request, res: Response) {
         role: component.role,
         placement: component.placement,
         sortOrder: component.sortOrder,
-        protectionDevice: protection
-          ? toProtectionDeviceDto(protection)
-          : undefined,
+        protectionDevice: protection ? toProtectionDeviceDto(protection) : undefined,
       };
-      if (component.placement === "header") {
-        tree.headerComponents.push(dto);
-      } else if (component.placement === "footer") {
-        tree.footerComponents.push(dto);
-      } else if (component.sectionId !== null) {
+      if (component.placement === "header") tree.headerComponents.push(dto);
+      else if (component.placement === "footer") tree.footerComponents.push(dto);
+      else if (component.sectionId !== null) {
         sectionBlocks.get(component.sectionId)?.components.push(dto);
       }
     }
 
-    for (const circuit of circuits) {
-      const section = sectionById.get(circuit.sectionId);
-      if (!section || section.circuitListId !== circuit.circuitListId) {
-        continue;
-      }
+    for (const circuit of circuitsByListId.get(list.id) ?? []) {
+      const block = sectionBlocks.get(circuit.sectionId);
+      if (!block) continue;
       const deviceRows = (rowsByCircuitId.get(circuit.id) ?? []).map((row) => ({
         id: row.id,
         linkedProjectDeviceId: row.linkedProjectDeviceId ?? undefined,
@@ -166,12 +228,16 @@ export async function getCircuitTree(req: Request, res: Response) {
         cosPhi: row.cosPhi ?? undefined,
         remark: row.remark ?? undefined,
         overriddenFields: row.overriddenFields ?? undefined,
-        rowTotalPower: calculateRowTotalPower(row.quantity, row.powerPerUnit, row.simultaneityFactor),
+        rowTotalPower: calculateRowTotalPower(
+          row.quantity,
+          row.powerPerUnit,
+          row.simultaneityFactor
+        ),
       }));
-      const circuitTotalPower = calculateCircuitTotalPower(deviceRows);
+      const circuitLoad = loads.circuits.get(circuit.id);
+      if (!circuitLoad) throw new Error("Circuit load is missing.");
       const protection = circuitProtectionById.get(circuit.id);
-
-      sectionBlocks.get(section.id)?.circuits.push({
+      block.circuits.push({
         id: circuit.id,
         circuitListId: circuit.circuitListId,
         sectionId: circuit.sectionId,
@@ -188,48 +254,89 @@ export async function getCircuitTree(req: Request, res: Response) {
         status: circuit.status ?? undefined,
         isReserve: Boolean(circuit.isReserve),
         remark: circuit.remark ?? undefined,
-        circuitTotalPower,
+        circuitTotalPower: circuitLoad.activePowerKw,
+        circuitApparentPower: circuitLoad.apparentPowerKva,
+        circuitCosPhi: circuitLoad.cosPhi,
         deviceRows,
-        protectionDevice: protection
-          ? toProtectionDeviceDto(protection)
-          : undefined,
+        downstreamBoardLoads: circuitLoad.downstreamBoards
+          .map((load) => ({
+            distributionBoardId: load.distributionBoardId,
+            name: load.name,
+            boardNumber: load.boardNumber ?? undefined,
+            supplyType: boardById.get(load.distributionBoardId)?.supplyType ?? undefined,
+            activePowerKw: load.activePowerKw,
+            apparentPowerKva: load.apparentPowerKva,
+            cosPhi: load.cosPhi,
+          }))
+          .sort((left, right) =>
+            (left.boardNumber ?? left.name).localeCompare(
+              right.boardNumber ?? right.name,
+              "de"
+            )
+          ),
+        protectionDevice: protection ? toProtectionDeviceDto(protection) : undefined,
       });
     }
-
     for (const section of tree.sections) {
-      section.sectionTotalPower = calculateSectionTotalPower(
-        section.circuits
+      section.sectionTotalPower = section.circuits.reduce(
+        (sum, circuit) => sum + circuit.circuitTotalPower,
+        0
       );
     }
-    tree.distributionBoardTotalPower =
-      calculateDistributionBoardTotalPower(tree.sections);
-    tree.distributionBoardTotalPowerWithSimultaneityFactor =
-      applyDistributionBoardSimultaneityFactor(
-        tree.distributionBoardTotalPower,
-        tree.distributionBoardSimultaneityFactor
-      );
+    return tree;
+  });
 
-    return res.json(tree);
-  } catch (error) {
-    if (isMissingCircuitTreeSchemaError(error)) {
-      return res.json({
-        circuitListId,
-        currentRevision: project.currentRevision,
-        singlePhaseVoltageV: project.singlePhaseVoltageV,
-        threePhaseVoltageV: project.threePhaseVoltageV,
-        distributionBoardSimultaneityFactor:
-          distributionBoard.simultaneityFactor,
-        distributionBoardTotalPower: 0,
-        distributionBoardTotalPowerWithSimultaneityFactor: 0,
-        headerComponents: [],
-        sections: [],
-        footerComponents: [],
-        warning:
-          "Circuit-first tables are not available yet. Run database migrations (including 0008_circuit_first_model).",
-      });
-    }
-    throw error;
-  }
+  return { currentRevision: project.currentRevision, trees };
+}
+
+function resolveFeedingReference(
+  board: Awaited<ReturnType<typeof distributionBoardRepository.listByProject>>[number],
+  boardById: Map<string, Awaited<ReturnType<typeof distributionBoardRepository.listByProject>>[number]>,
+  circuitById: Map<string, Awaited<ReturnType<typeof circuitRepository.listByCircuitLists>>[number]>,
+  sectionById: Map<string, Awaited<ReturnType<typeof circuitSectionRepository.listByCircuitLists>>[number]>
+) {
+  if (board.feedingDistributionBoardId === null) return undefined;
+  const feedingBoard = boardById.get(board.feedingDistributionBoardId);
+  if (!feedingBoard) throw new Error("Feeding distribution board is missing.");
+  const feedingCircuit = board.feedingCircuitId === null
+    ? undefined
+    : circuitById.get(board.feedingCircuitId);
+  return {
+    distributionBoardId: feedingBoard.id,
+    distributionBoardName: feedingBoard.name,
+    distributionBoardNumber: feedingBoard.boardNumber ?? undefined,
+    circuitId: feedingCircuit?.id,
+    circuitEquipmentIdentifier: feedingCircuit?.equipmentIdentifier,
+    circuitDisplayName: feedingCircuit?.displayName ?? undefined,
+    circuitCategory: feedingCircuit
+      ? sectionById.get(feedingCircuit.sectionId)?.category ?? undefined
+      : undefined,
+  };
+}
+
+function emptyCircuitTree(
+  project: NonNullable<Awaited<ReturnType<typeof projectRepository.findById>>>,
+  board: NonNullable<Awaited<ReturnType<typeof distributionBoardRepository.findById>>>,
+  circuitListId: string
+): CircuitTreeResponse & { warning: string } {
+  return {
+    circuitListId,
+    distributionBoardId: board.id,
+    distributionBoardName: board.name,
+    distributionBoardNumber: board.boardNumber ?? undefined,
+    distributionBoardSupplyType: board.supplyType ?? undefined,
+    currentRevision: project.currentRevision,
+    singlePhaseVoltageV: project.singlePhaseVoltageV,
+    threePhaseVoltageV: project.threePhaseVoltageV,
+    distributionBoardSimultaneityFactor: board.simultaneityFactor,
+    distributionBoardTotalPower: 0,
+    distributionBoardTotalPowerWithSimultaneityFactor: 0,
+    headerComponents: [],
+    sections: [],
+    footerComponents: [],
+    warning:
+      "Circuit-first tables are not available yet. Run database migrations (including 0008_circuit_first_model).",
+  };
 }
 
 function toProtectionDeviceDto(value: {
@@ -243,11 +350,20 @@ function toProtectionDeviceDto(value: {
   return {
     type: value.type,
     ratedCurrentA: value.ratedCurrentA,
-    fuseUtilizationCategory:
-      value.fuseUtilizationCategory ?? undefined,
+    fuseUtilizationCategory: value.fuseUtilizationCategory ?? undefined,
     tripCharacteristic: value.tripCharacteristic ?? undefined,
     rcdType: value.rcdType ?? undefined,
-    ratedResidualCurrentMa:
-      value.ratedResidualCurrentMa ?? undefined,
+    ratedResidualCurrentMa: value.ratedResidualCurrentMa ?? undefined,
   };
 }
+
+function groupBy<T>(values: T[], keyOf: (value: T) => string) {
+  const groups = new Map<string, T[]>();
+  for (const value of values) {
+    const key = keyOf(value);
+    const group = groups.get(key) ?? [];
+    group.push(value);
+    groups.set(key, group);
+  }
+  return groups;
+}
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index 529def2..927223e 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -29,7 +29,10 @@ import {
   listEstimateBalances,
   updateEstimateBalance,
 } from "../controllers/estimate-balance.controller.js";
-import { getCircuitTree } from "../controllers/circuit-tree.controller.js";
+import {
+  getCircuitTree,
+  getProjectCircuitTrees,
+} from "../controllers/circuit-tree.controller.js";
 import { getNextCircuitIdentifier } from "../controllers/circuit.controller.js";
 import {
   getProjectHistory,
@@ -109,6 +112,7 @@ projectRouter.delete(
   deleteDistributionBoard
 );
 projectRouter.get("/:projectId/circuit-lists", listCircuitListsByProject);
+projectRouter.get("/:projectId/circuit-trees", getProjectCircuitTrees);
 projectRouter.get("/:projectId/circuit-lists/:circuitListId/tree", getCircuitTree);
 projectRouter.get(
   "/:projectId/circuit-sections/:sectionId/next-identifier",
diff --git a/tests/circuit-tree.controller.test.ts b/tests/circuit-tree.controller.test.ts
index 7fcf884..ea20da2 100644
--- a/tests/circuit-tree.controller.test.ts
+++ b/tests/circuit-tree.controller.test.ts
@@ -38,13 +38,15 @@ describe("circuit tree controller", () => {
   it("returns header, grouped and footer components with both protection layers", async () => {
     const originals = {
       findList: circuitListRepository.findById,
+      listLists: circuitListRepository.listByProject,
       findProject: projectRepository.findById,
       findBoard: distributionBoardRepository.findById,
-      listSections: circuitSectionRepository.listByCircuitList,
-      listCircuits: circuitRepository.listByCircuitList,
+      listBoards: distributionBoardRepository.listByProject,
+      listSections: circuitSectionRepository.listByCircuitLists,
+      listCircuits: circuitRepository.listByCircuitLists,
       listRows: circuitDeviceRowRepository.listByCircuitList,
       listComponents:
-        distributionBoardComponentRepository.listByCircuitList,
+        distributionBoardComponentRepository.listByCircuitLists,
       listComponentProtection:
         distributionBoardComponentRepository.listProtectionByComponentIds,
       listCircuitProtection:
@@ -57,6 +59,13 @@ describe("circuit tree controller", () => {
         distributionBoardId: "board-1",
         name: "UV-01",
       }) as never;
+    circuitListRepository.listByProject = async () =>
+      [{
+        id: "list-1",
+        projectId: "project-1",
+        distributionBoardId: "board-1",
+        name: "UV-01",
+      }] as never;
     projectRepository.findById = async () =>
       ({
         id: "project-1",
@@ -66,8 +75,19 @@ describe("circuit tree controller", () => {
         threePhaseVoltageV: 400,
       }) as never;
     distributionBoardRepository.findById = async () =>
-      ({ id: "board-1", simultaneityFactor: 0.8 }) as never;
-    circuitSectionRepository.listByCircuitList = async () =>
+      ({ id: "board-1", name: "UV-01", simultaneityFactor: 0.8 }) as never;
+    distributionBoardRepository.listByProject = async () =>
+      [{
+        id: "board-1",
+        projectId: "project-1",
+        name: "UV-01",
+        boardNumber: "UV-01",
+        supplyType: "AV",
+        simultaneityFactor: 0.8,
+        feedingDistributionBoardId: null,
+        feedingCircuitId: null,
+      }] as never;
+    circuitSectionRepository.listByCircuitLists = async () =>
       [
         {
           id: "group-1",
@@ -80,7 +100,7 @@ describe("circuit tree controller", () => {
           groupNumber: 1,
         },
       ] as never;
-    circuitRepository.listByCircuitList = async () =>
+    circuitRepository.listByCircuitLists = async () =>
       [
         {
           id: "circuit-1",
@@ -90,10 +110,19 @@ describe("circuit tree controller", () => {
           displayName: "Licht",
           sortOrder: 10,
           isReserve: 0,
+          cableType: null,
+          cableCrossSection: null,
+          cableLength: null,
+          rcdAssignment: null,
+          terminalDesignation: null,
+          voltage: 230,
+          controlRequirement: null,
+          status: null,
+          remark: null,
         },
       ] as never;
     circuitDeviceRowRepository.listByCircuitList = async () => [];
-    distributionBoardComponentRepository.listByCircuitList =
+    distributionBoardComponentRepository.listByCircuitLists =
       async () =>
         [
           {
@@ -170,13 +199,15 @@ describe("circuit tree controller", () => {
       );
     } finally {
       circuitListRepository.findById = originals.findList;
+      circuitListRepository.listByProject = originals.listLists;
       projectRepository.findById = originals.findProject;
       distributionBoardRepository.findById = originals.findBoard;
-      circuitSectionRepository.listByCircuitList =
+      distributionBoardRepository.listByProject = originals.listBoards;
+      circuitSectionRepository.listByCircuitLists =
         originals.listSections;
-      circuitRepository.listByCircuitList = originals.listCircuits;
+      circuitRepository.listByCircuitLists = originals.listCircuits;
       circuitDeviceRowRepository.listByCircuitList = originals.listRows;
-      distributionBoardComponentRepository.listByCircuitList =
+      distributionBoardComponentRepository.listByCircuitLists =
         originals.listComponents;
       distributionBoardComponentRepository.listProtectionByComponentIds =
         originals.listComponentProtection;
diff --git a/tests/distribution-board-load-calculation.test.ts b/tests/distribution-board-load-calculation.test.ts
new file mode 100644
index 0000000..f6c9a95
--- /dev/null
+++ b/tests/distribution-board-load-calculation.test.ts
@@ -0,0 +1,89 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { calculateDistributionBoardLoads } from "../src/domain/calculations/distribution-board-load-calculation.js";
+
+const board = (
+  id: string,
+  simultaneityFactor: number,
+  feedingDistributionBoardId: string | null = null,
+  feedingCircuitId: string | null = null
+) => ({
+  id,
+  name: id,
+  boardNumber: id.toUpperCase(),
+  simultaneityFactor,
+  feedingDistributionBoardId,
+  feedingCircuitId,
+});
+
+describe("distribution-board load calculation", () => {
+  it("rolls recursive demand into the selected feeder circuit exactly once", () => {
+    const result = calculateDistributionBoardLoads({
+      boards: [
+        board("nshv", 0.8),
+        board("uv1", 0.5, "nshv", "nshv-out"),
+        board("uv2", 0.25, "uv1", "uv1-out"),
+      ],
+      circuits: [
+        { id: "nshv-out", distributionBoardId: "nshv", rows: [{ activePowerKw: 2, cosPhi: 1 }] },
+        { id: "uv1-out", distributionBoardId: "uv1", rows: [{ activePowerKw: 4, cosPhi: 0.8 }] },
+        { id: "uv2-load", distributionBoardId: "uv2", rows: [{ activePowerKw: 8, cosPhi: 0.8 }] },
+      ],
+    });
+
+    assert.deepEqual(result.boards.get("uv2"), {
+      distributionBoardId: "uv2",
+      activePowerBeforeSimultaneityKw: 8,
+      apparentPowerBeforeSimultaneityKva: 10,
+      demandActivePowerKw: 2,
+      demandApparentPowerKva: 2.5,
+      cosPhi: 0.8,
+    });
+    assert.equal(result.circuits.get("uv1-out")?.activePowerKw, 6);
+    assert.equal(result.boards.get("uv1")?.demandActivePowerKw, 3);
+    assert.equal(result.circuits.get("nshv-out")?.activePowerKw, 5);
+    assert.equal(result.boards.get("nshv")?.demandActivePowerKw, 4);
+    assert.equal(result.circuits.get("nshv-out")?.downstreamBoards.length, 1);
+  });
+
+  it("combines apparent power for multiple child boards on one circuit", () => {
+    const result = calculateDistributionBoardLoads({
+      boards: [board("main", 1), board("a", 1, "main", "out"), board("b", 1, "main", "out")],
+      circuits: [
+        { id: "out", distributionBoardId: "main", rows: [] },
+        { id: "a-load", distributionBoardId: "a", rows: [{ activePowerKw: 2, cosPhi: 0.5 }] },
+        { id: "b-load", distributionBoardId: "b", rows: [{ activePowerKw: 2, cosPhi: 1 }] },
+      ],
+    });
+    const feeder = result.circuits.get("out")!;
+    assert.equal(feeder.activePowerKw, 4);
+    assert.equal(feeder.apparentPowerKva, 6);
+    assert.equal(feeder.cosPhi, 2 / 3);
+    assert.deepEqual(feeder.downstreamBoards.map((entry) => entry.distributionBoardId), ["a", "b"]);
+  });
+
+  it("keeps a board-only hierarchy relation out of load rollup", () => {
+    const result = calculateDistributionBoardLoads({
+      boards: [board("main", 1), board("child", 1, "main", null)],
+      circuits: [
+        { id: "main-load", distributionBoardId: "main", rows: [{ activePowerKw: 1, cosPhi: 1 }] },
+        { id: "child-load", distributionBoardId: "child", rows: [{ activePowerKw: 5, cosPhi: 1 }] },
+      ],
+    });
+    assert.equal(result.boards.get("main")?.demandActivePowerKw, 1);
+    assert.equal(result.boards.get("child")?.demandActivePowerKw, 5);
+  });
+
+  it("rejects cycles defensively", () => {
+    assert.throws(
+      () => calculateDistributionBoardLoads({
+        boards: [board("a", 1, "b", "b-out"), board("b", 1, "a", "a-out")],
+        circuits: [
+          { id: "a-out", distributionBoardId: "a", rows: [] },
+          { id: "b-out", distributionBoardId: "b", rows: [] },
+        ],
+      }),
+      /cycle/
+    );
+  });
+});

From 042a05087698cf0cc7cf310a4137e5db075d6224 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Sun, 27 Sep 2026 22:37:04 +0200
Subject: [PATCH 37/60] Show logical feeder loads in project and circuit views

---
 src/app/globals.css                           |  10 ++
 src/app/projects/[projectId]/page.tsx         | 162 +++++++++++++++++-
 src/domain/models/circuit-tree.model.ts       |   1 +
 .../components/cable-sizing-defaults.ts       |   3 +
 .../components/circuit-tree-editor.tsx        |  25 ++-
 .../distribution-board-info-card.tsx          |   6 +-
 src/frontend/types.ts                         |   1 +
 src/frontend/utils/circuit-grid-model.ts      |   2 +
 src/frontend/utils/circuit-grid-projection.ts |  45 ++++-
 .../controllers/circuit-tree.controller.ts    |  12 +-
 tests/cable-sizing-calculation.test.ts        |  22 +++
 tests/circuit-grid-projection.test.ts         |  41 +++++
 12 files changed, 319 insertions(+), 11 deletions(-)

diff --git a/src/app/globals.css b/src/app/globals.css
index de46d37..d14431b 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -1541,6 +1541,16 @@ a.kpi:hover {
   color: var(--text-faint);
 }
 
+.tree-grid .downstream-board-load-row td {
+  background: var(--panel-bg-subtle);
+  color: var(--text-muted);
+  font-style: italic;
+}
+
+.tree-grid .downstream-board-load-row td:nth-child(2) {
+  padding-left: 1.5rem;
+}
+
 .tree-grid .empty-circuit-row td {
   background: var(--panel-bg-subtle);
 }
diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index ed03cd9..4a99cf0 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -56,6 +56,7 @@ import {
   disconnectProjectDeviceRows,
   exportProjectTransfer,
   getProject,
+  getProjectCircuitTrees,
   getProjectDeviceSyncPreview,
   listBuildings,
   listCircuitLists,
@@ -73,6 +74,7 @@ import {
 import type {
   BuildingDto,
   CircuitListDto,
+  CircuitTreeResponseDto,
   CreateRoomInput,
   CreateProjectDeviceInput,
   DistributionBoardDto,
@@ -151,6 +153,7 @@ export default function ProjectDetailPage() {
   const [project, setProject] = useState<ProjectDto | null>(null);
   const [boards, setBoards] = useState<DistributionBoardDto[]>([]);
   const [circuitLists, setCircuitLists] = useState<CircuitListDto[]>([]);
+  const [circuitTrees, setCircuitTrees] = useState<CircuitTreeResponseDto[]>([]);
   const [buildings, setBuildings] = useState<BuildingDto[]>([]);
   const [floors, setFloors] = useState<FloorDto[]>([]);
   const [rooms, setRooms] = useState<RoomDto[]>([]);
@@ -170,6 +173,8 @@ export default function ProjectDetailPage() {
     setEditingBoardSimultaneityFactor,
   ] = useState("1");
   const [editingBoardCopyName, setEditingBoardCopyName] = useState("");
+  const [editingFeedingBoardId, setEditingFeedingBoardId] = useState("");
+  const [editingFeedingCircuitId, setEditingFeedingCircuitId] = useState("");
   const [editingBoardInfo, setEditingBoardInfo] =
     useState<DistributionBoardInfoDraft>(
       toDistributionBoardInfoDraft({
@@ -209,6 +214,7 @@ export default function ProjectDetailPage() {
       getProject(projectId),
       listDistributionBoards(projectId),
       listCircuitLists(projectId),
+      getProjectCircuitTrees(projectId),
       listBuildings(projectId),
       listFloors(projectId),
       listRooms(projectId),
@@ -219,6 +225,7 @@ export default function ProjectDetailPage() {
         currentProject,
         distributionBoards,
         loadedCircuitLists,
+        loadedCircuitTrees,
         loadedBuildings,
         loadedFloors,
         loadedRooms,
@@ -228,6 +235,7 @@ export default function ProjectDetailPage() {
         setProject(currentProject);
         setBoards(distributionBoards);
         setCircuitLists(loadedCircuitLists);
+        setCircuitTrees(loadedCircuitTrees.trees);
         setBuildings(loadedBuildings);
         setFloors(loadedFloors);
         setRooms(loadedRooms);
@@ -310,6 +318,48 @@ export default function ProjectDetailPage() {
     () => new Map(circuitLists.map((circuitList) => [circuitList.distributionBoardId, circuitList])),
     [circuitLists]
   );
+  const circuitTreeByBoardId = useMemo(
+    () => new Map(circuitTrees.map((tree) => [tree.distributionBoardId, tree])),
+    [circuitTrees]
+  );
+  const feedingBoardOptions = useMemo(() => {
+    if (!editingBoard) return [];
+    const boardById = new Map(boards.map((board) => [board.id, board]));
+    return boards.filter((candidate) => {
+      if (candidate.id === editingBoard.id) return false;
+      const visited = new Set<string>();
+      let current: DistributionBoardDto | undefined = candidate;
+      while (current && current.feedingDistributionBoardId && !visited.has(current.id)) {
+        if (current.feedingDistributionBoardId === editingBoard.id) return false;
+        visited.add(current.id);
+        current = boardById.get(current.feedingDistributionBoardId);
+      }
+      return true;
+    });
+  }, [boards, editingBoard]);
+  const selectedFeedingTree = editingFeedingBoardId
+    ? circuitTreeByBoardId.get(editingFeedingBoardId)
+    : undefined;
+  const selectedFeedingCircuits = useMemo(
+    () =>
+      selectedFeedingTree?.sections.flatMap((section) =>
+        section.circuits.map((circuit) => ({ circuit, section }))
+      ) ?? [],
+    [selectedFeedingTree]
+  );
+  const selectedFeedingCircuit = selectedFeedingCircuits.find(
+    ({ circuit }) => circuit.id === editingFeedingCircuitId
+  );
+  const selectedFeedingBoard = boards.find(
+    (board) => board.id === editingFeedingBoardId
+  );
+  const selectedFeedingCircuitUseCount = editingFeedingCircuitId
+    ? boards.filter(
+        (board) =>
+          board.id !== editingBoard?.id &&
+          board.feedingCircuitId === editingFeedingCircuitId
+      ).length
+    : 0;
   const enabledBoardSupplyTypes =
     project?.enabledDistributionBoardSupplyTypes ?? [];
   const usedBoardSupplyTypes = useMemo(
@@ -329,6 +379,21 @@ export default function ProjectDetailPage() {
     [boards]
   );
 
+  function formatBoardFeedingReference(board: DistributionBoardDto) {
+    if (!board.feedingDistributionBoardId) return board.fedFrom ?? "–";
+    const feedingBoard = boards.find(
+      (candidate) => candidate.id === board.feedingDistributionBoardId
+    );
+    if (!feedingBoard) return "Unbekannte Verteilung";
+    const boardLabel = feedingBoard.boardNumber ?? feedingBoard.name;
+    if (!board.feedingCircuitId) return boardLabel;
+    const circuit = circuitTreeByBoardId
+      .get(feedingBoard.id)
+      ?.sections.flatMap((section) => section.circuits)
+      .find((candidate) => candidate.id === board.feedingCircuitId);
+    return `${boardLabel}${circuit?.equipmentIdentifier ?? ""}`;
+  }
+
   function applyProjectRevision(currentRevision: number) {
     setProject((current) =>
       current ? { ...current, currentRevision } : current
@@ -358,6 +423,7 @@ export default function ProjectDetailPage() {
       ]);
       setCircuitLists(await listCircuitLists(projectId));
       applyProjectRevision(result.history.currentRevision);
+      setCircuitTrees((await getProjectCircuitTrees(projectId)).trees);
       setBoardName("");
       setBoardFloorId("");
       setBoardSupplyType(
@@ -488,6 +554,8 @@ export default function ProjectDetailPage() {
     );
     setEditingBoardCopyName(`${board.name} Kopie`);
     setEditingBoardInfo(toDistributionBoardInfoDraft(board));
+    setEditingFeedingBoardId(board.feedingDistributionBoardId ?? "");
+    setEditingFeedingCircuitId(board.feedingCircuitId ?? "");
   }
 
   function openBoardCreator() {
@@ -523,6 +591,8 @@ export default function ProjectDetailPage() {
           floorId: editingBoardFloorId || null,
           supplyType: editingBoardSupplyType,
           simultaneityFactor,
+          feedingDistributionBoardId: editingFeedingBoardId || null,
+          feedingCircuitId: editingFeedingCircuitId || null,
           ...fromDistributionBoardInfoDraft(editingBoardInfo),
         },
         project.currentRevision
@@ -535,6 +605,7 @@ export default function ProjectDetailPage() {
         )
       );
       applyProjectRevision(result.history.currentRevision);
+      setCircuitTrees((await getProjectCircuitTrees(projectId)).trees);
       setEditingBoard(null);
     } catch (err) {
       setError(
@@ -590,6 +661,7 @@ export default function ProjectDetailPage() {
         result.circuitList,
       ]);
       applyProjectRevision(result.history.currentRevision);
+      setCircuitTrees((await getProjectCircuitTrees(projectId)).trees);
       setEditingBoard(null);
     } catch (err) {
       setError(
@@ -633,6 +705,7 @@ export default function ProjectDetailPage() {
         )
       );
       applyProjectRevision(result.history.currentRevision);
+      setCircuitTrees((await getProjectCircuitTrees(projectId)).trees);
       setEditingBoard(null);
     } catch (err) {
       setError(
@@ -989,6 +1062,7 @@ export default function ProjectDetailPage() {
                     <th>Örtlichkeit</th>
                     <th>Etage</th>
                     <th>Netzart</th>
+                    <th>Gespeist von</th>
                     <th>GZF</th>
                     <th className="text-end">Aktionen</th>
                   </tr>
@@ -1015,6 +1089,7 @@ export default function ProjectDetailPage() {
                               ]
                             : "Nicht festgelegt"}
                         </td>
+                        <td>{formatBoardFeedingReference(board)}</td>
                         <td>
                           {board.simultaneityFactor.toLocaleString(
                             "de-DE",
@@ -1392,7 +1467,7 @@ export default function ProjectDetailPage() {
 
       {editingBoard ? (
         <FormModal
-          description={`${editingBoard.name}: Etagenzuordnung, Netzart und Gleichzeitigkeitsfaktor ändern.`}
+          description={`${editingBoard.name}: Etagenzuordnung, Netzart, Einspeisung und Gleichzeitigkeitsfaktor ändern.`}
           isSaving={isSaving}
           onClose={() => setEditingBoard(null)}
           onSubmit={handleUpdateBoard}
@@ -1479,6 +1554,91 @@ export default function ProjectDetailPage() {
               </div>
             </div>
           </div>
+          <section className="card mt-4" aria-labelledby="feeding-reference-heading">
+            <div className="card-header" id="feeding-reference-heading">
+              Logische Einspeisung
+            </div>
+            <div className="card-body row g-3">
+              <div className="col-12 col-md-6">
+                <label className="form-label" htmlFor="feeding-distribution-board">
+                  Speisende Verteilung
+                </label>
+                <select
+                  className="form-select"
+                  id="feeding-distribution-board"
+                  onChange={(event) => {
+                    setEditingFeedingBoardId(event.target.value);
+                    setEditingFeedingCircuitId("");
+                  }}
+                  value={editingFeedingBoardId}
+                >
+                  <option value="">Keine Projektverteilung</option>
+                  {feedingBoardOptions.map((board) => (
+                    <option key={board.id} value={board.id}>
+                      {board.boardNumber ?? board.name}
+                    </option>
+                  ))}
+                </select>
+              </div>
+              <div className="col-12 col-md-6">
+                <label className="form-label" htmlFor="feeding-circuit">
+                  Speisender Abgang
+                </label>
+                <select
+                  className="form-select"
+                  disabled={!editingFeedingBoardId}
+                  id="feeding-circuit"
+                  onChange={(event) => setEditingFeedingCircuitId(event.target.value)}
+                  value={editingFeedingCircuitId}
+                >
+                  <option value="">Nur Verteilung bekannt</option>
+                  {selectedFeedingCircuits.map(({ circuit }) => (
+                    <option key={circuit.id} value={circuit.id}>
+                      {circuit.equipmentIdentifier}
+                      {circuit.displayName ? ` · ${circuit.displayName}` : ""}
+                    </option>
+                  ))}
+                </select>
+              </div>
+              {editingFeedingBoardId && !editingFeedingCircuitId ? (
+                <div className="col-12">
+                  <div className="alert alert-warning mb-0 py-2">
+                    Ohne speisenden Abgang wird die Hierarchie angezeigt, die
+                    Leistung dieser Verteilung aber keinem Stromkreis zugerechnet.
+                  </div>
+                </div>
+              ) : null}
+              {selectedFeedingBoard?.supplyType &&
+              editingBoardSupplyType !== selectedFeedingBoard.supplyType ? (
+                <div className="col-12">
+                  <div className="alert alert-warning mb-0 py-2">
+                    Die Netzarten weichen ab: {selectedFeedingBoard.supplyType}
+                    {" → "}{editingBoardSupplyType}. Bitte Umschaltung und
+                    Versorgungskonzept prüfen.
+                  </div>
+                </div>
+              ) : null}
+              {selectedFeedingCircuit &&
+              selectedFeedingCircuit.section.category !== "three_phase" ? (
+                <div className="col-12">
+                  <div className="alert alert-warning mb-0 py-2">
+                    Der gewählte Abgang ist 1-phasig. Bitte prüfen, ob diese
+                    Einspeisung für die Unterverteilung geeignet ist.
+                  </div>
+                </div>
+              ) : null}
+              {selectedFeedingCircuitUseCount > 0 ? (
+                <div className="col-12">
+                  <div className="alert alert-info mb-0 py-2">
+                    Dieser Abgang speist bereits {selectedFeedingCircuitUseCount}
+                    {selectedFeedingCircuitUseCount === 1
+                      ? " weitere Verteilung."
+                      : " weitere Verteilungen."}
+                  </div>
+                </div>
+              ) : null}
+            </div>
+          </section>
           <div className="mt-4">
             <DistributionBoardInfoCard
               draft={editingBoardInfo}
diff --git a/src/domain/models/circuit-tree.model.ts b/src/domain/models/circuit-tree.model.ts
index 2e1aa72..00a0c2d 100644
--- a/src/domain/models/circuit-tree.model.ts
+++ b/src/domain/models/circuit-tree.model.ts
@@ -90,6 +90,7 @@ export interface CircuitTreeDownstreamBoardLoad {
 
 export interface CircuitTreeFeedingReference {
   distributionBoardId: string;
+  circuitListId: string;
   distributionBoardName: string;
   distributionBoardNumber?: string;
   circuitId?: string;
diff --git a/src/frontend/components/cable-sizing-defaults.ts b/src/frontend/components/cable-sizing-defaults.ts
index ae4c7a4..069c575 100644
--- a/src/frontend/components/cable-sizing-defaults.ts
+++ b/src/frontend/components/cable-sizing-defaults.ts
@@ -22,6 +22,9 @@ export function deriveCircuitPhase(
  * Rows without cos φ count as 1; a circuit without load yields 1.
  */
 export function deriveCircuitCosPhi(circuit: CircuitTreeCircuitDto): number {
+  if (Number.isFinite(circuit.circuitCosPhi) && circuit.circuitCosPhi > 0) {
+    return Math.round(circuit.circuitCosPhi * 100) / 100;
+  }
   let activePowerKw = 0;
   let apparentPowerKva = 0;
   for (const row of circuit.deviceRows) {
diff --git a/src/frontend/components/circuit-tree-editor.tsx b/src/frontend/components/circuit-tree-editor.tsx
index e8a2f23..bac08ce 100644
--- a/src/frontend/components/circuit-tree-editor.tsx
+++ b/src/frontend/components/circuit-tree-editor.tsx
@@ -1,5 +1,6 @@
 "use client";
 
+import Link from "next/link";
 import { DragEvent, KeyboardEvent, useEffect, useMemo, useRef, useState } from "react";
 import {
   ArrowDown,
@@ -3293,6 +3294,23 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
           threePhaseVoltageV={data.threePhaseVoltageV}
         />
       ) : null}
+      {data.feedingReference ? (
+        <div className="alert alert-info py-2" role="status">
+          Gespeist von{" "}
+          <Link
+            href={`/projects/${projectId}/circuit-lists/${
+              data.feedingReference.circuitListId
+            }/tree-edit`}
+          >
+            {data.feedingReference.distributionBoardNumber ??
+              data.feedingReference.distributionBoardName}
+            {data.feedingReference.circuitEquipmentIdentifier ?? ""}
+          </Link>
+          {data.feedingReference.circuitId
+            ? null
+            : " (speisender Stromkreis noch nicht festgelegt)"}
+        </div>
+      ) : null}
       <div className="editor-toolbar">
         <IconButton
           disabled={!historyState || historyState.undoDepth === 0 || historyBusy || isSaving}
@@ -4062,6 +4080,8 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                       ? "summary-row"
                       : row.rowType === "deviceRow"
                         ? "device-row"
+                        : row.rowType === "downstreamBoardLoad"
+                          ? "downstream-board-load-row"
                         : row.rowType === "reserveCircuit"
                           ? "empty-circuit-row"
                           : row.rowType === "placeholder"
@@ -4667,7 +4687,10 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                         : ""
                     }`}
                   >
-                    {row.circuit && row.rowType !== "deviceRow" ? (
+                    {row.circuit &&
+                    (row.rowType === "circuitCompact" ||
+                      row.rowType === "circuitSummary" ||
+                      row.rowType === "reserveCircuit") ? (
                       <>
                         <IconButton
                           disabled={isSaving}
diff --git a/src/frontend/components/distribution-board-info-card.tsx b/src/frontend/components/distribution-board-info-card.tsx
index f2523f4..dcc4188 100644
--- a/src/frontend/components/distribution-board-info-card.tsx
+++ b/src/frontend/components/distribution-board-info-card.tsx
@@ -13,7 +13,7 @@ export type DistributionBoardInfoDraft = Record<DistributionBoardInfoField, stri
 const placeholders: Record<DistributionBoardInfoField, string> = {
   boardNumber: "z. B. UV 1.1",
   location: "z. B. Raum 003 Technik",
-  fedFrom: "z. B. HV 0.1 oder HAK / Zähleranlage",
+  fedFrom: "z. B. HAK, Zähleranlage, Trafo oder NEA",
   remark: "",
 };
 
@@ -98,8 +98,8 @@ export function DistributionBoardInfoCard({
             )}
             {field === "fedFrom" ? (
               <div className="form-text">
-                Vorerst Freitext. Die logische Verknüpfung mit dem
-                speisenden Verteiler folgt.
+                Für externe Einspeisungen oder ergänzende Hinweise. Eine
+                speisende Projektverteilung wird oben logisch verknüpft.
               </div>
             ) : null}
           </div>
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 8a2dec4..572182b 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -494,6 +494,7 @@ export interface CircuitTreeDownstreamBoardLoadDto {
 
 export interface CircuitTreeFeedingReferenceDto {
   distributionBoardId: string;
+  circuitListId: string;
   distributionBoardName: string;
   distributionBoardNumber?: string;
   circuitId?: string;
diff --git a/src/frontend/utils/circuit-grid-model.ts b/src/frontend/utils/circuit-grid-model.ts
index ba4be98..faa4a11 100644
--- a/src/frontend/utils/circuit-grid-model.ts
+++ b/src/frontend/utils/circuit-grid-model.ts
@@ -44,6 +44,7 @@ export type RowType =
   | "circuitCompact"
   | "circuitSummary"
   | "deviceRow"
+  | "downstreamBoardLoad"
   | "reserveCircuit"
   | "placeholder"
   | "footerComponent";
@@ -614,6 +615,7 @@ export function getCellKind(rowType: RowType, key: CellKey): CellKind {
     return "readonly";
   }
   if (rowType === "deviceRow") return deviceFieldKeys.has(key) ? "deviceField" : "readonly";
+  if (rowType === "downstreamBoardLoad") return "readonly";
   if (rowType === "circuitSummary") return circuitFieldKeys.has(key) ? "circuitField" : "readonly";
   if (rowType === "reserveCircuit" || rowType === "circuitCompact") {
     if (deviceFieldKeys.has(key)) return "deviceField";
diff --git a/src/frontend/utils/circuit-grid-projection.ts b/src/frontend/utils/circuit-grid-projection.ts
index fb2a846..a9b11de 100644
--- a/src/frontend/utils/circuit-grid-projection.ts
+++ b/src/frontend/utils/circuit-grid-projection.ts
@@ -2,6 +2,7 @@ import type {
   CircuitTreeCircuitDto,
   CircuitTreeComponentDto,
   CircuitTreeDeviceRowDto,
+  CircuitTreeDownstreamBoardLoadDto,
   CircuitTreeSectionDto,
 } from "../types.js";
 import { buildCircuitStructureProjection } from "./circuit-structure-projection";
@@ -45,6 +46,7 @@ export interface VisibleGridRow {
   circuit?: CircuitTreeCircuitDto;
   device?: CircuitTreeDeviceRowDto;
   component?: CircuitTreeComponentDto;
+  downstreamBoardLoad?: CircuitTreeDownstreamBoardLoadDto;
   cells: VisibleGridCell[];
 }
 
@@ -126,13 +128,16 @@ function makeVisibleGridRow(
   rowType: RowType,
   sectionId: string,
   circuit?: CircuitTreeCircuitDto,
-  device?: CircuitTreeDeviceRowDto
+  device?: CircuitTreeDeviceRowDto,
+  downstreamBoardLoad?: CircuitTreeDownstreamBoardLoadDto
 ): VisibleGridRow {
   const rowKey =
     rowType === "placeholder"
       ? `placeholder:${sectionId}`
       : rowType === "deviceRow" && device
         ? `device:${device.id}`
+        : rowType === "downstreamBoardLoad" && downstreamBoardLoad
+          ? `downstream-board:${circuit?.id}:${downstreamBoardLoad.distributionBoardId}`
         : `${rowType}:${circuit?.id ?? sectionId}`;
 
   const cells = allColumns.map((column): VisibleGridCell => {
@@ -140,7 +145,17 @@ function makeVisibleGridRow(
     const editable = kind === "circuitField" || kind === "deviceField";
     let value: GridValue;
 
-    if (rowType === "placeholder") {
+    if (rowType === "downstreamBoardLoad" && downstreamBoardLoad) {
+      value = column.key === "displayName"
+        ? `Unterverteilung ${downstreamBoardLoad.boardNumber ?? downstreamBoardLoad.name}`
+        : column.key === "rowTotalPower"
+          ? downstreamBoardLoad.activePowerKw
+          : column.key === "cosPhi"
+            ? downstreamBoardLoad.cosPhi
+            : column.key === "remark"
+              ? "Automatisch aus der verknüpften Verteilung"
+              : undefined;
+    } else if (rowType === "placeholder") {
       value = column.key === "equipmentIdentifier" ? "-frei-" : undefined;
     } else if (kind === "deviceField" && device) {
       value = getDeviceValue(device, column.key);
@@ -166,7 +181,15 @@ function makeVisibleGridRow(
     return { cellKey: column.key, editable, kind, value };
   });
 
-  return { rowKey, rowType, sectionId, circuit, device, cells };
+  return {
+    rowKey,
+    rowType,
+    sectionId,
+    circuit,
+    device,
+    downstreamBoardLoad,
+    cells,
+  };
 }
 
 export function buildVisibleGridRowsWithStructure(
@@ -221,15 +244,27 @@ export function buildVisibleGridRowsWithStructure(
     }
     if (row.rowType === "circuitBlock") {
       const circuit = row.circuit;
-      if (circuit.deviceRows.length === 0) {
+      const downstreamLoads = circuit.downstreamBoardLoads ?? [];
+      if (circuit.deviceRows.length === 0 && downstreamLoads.length === 0) {
         rows.push(makeVisibleGridRow("reserveCircuit", section.id, circuit));
-      } else if (circuit.deviceRows.length === 1) {
+      } else if (circuit.deviceRows.length === 1 && downstreamLoads.length === 0) {
         rows.push(makeVisibleGridRow("circuitCompact", section.id, circuit, circuit.deviceRows[0]));
       } else {
         rows.push(makeVisibleGridRow("circuitSummary", section.id, circuit));
         for (const device of circuit.deviceRows) {
           rows.push(makeVisibleGridRow("deviceRow", section.id, circuit, device));
         }
+        for (const load of downstreamLoads) {
+          rows.push(
+            makeVisibleGridRow(
+              "downstreamBoardLoad",
+              section.id,
+              circuit,
+              undefined,
+              load
+            )
+          );
+        }
       }
       continue;
     }
diff --git a/src/server/controllers/circuit-tree.controller.ts b/src/server/controllers/circuit-tree.controller.ts
index 22b4a73..17ac134 100644
--- a/src/server/controllers/circuit-tree.controller.ts
+++ b/src/server/controllers/circuit-tree.controller.ts
@@ -104,6 +104,9 @@ export async function buildProjectCircuitTrees(
 
   const boardById = new Map(boards.map((board) => [board.id, board]));
   const listById = new Map(lists.map((list) => [list.id, list]));
+  const listByBoardId = new Map(
+    lists.map((list) => [list.distributionBoardId, list])
+  );
   const sectionById = new Map(sections.map((section) => [section.id, section]));
   const circuitById = new Map(circuits.map((circuit) => [circuit.id, circuit]));
   const rowsByCircuitId = groupBy(rows, (row) => row.circuitId);
@@ -158,6 +161,7 @@ export async function buildProjectCircuitTrees(
       feedingReference: resolveFeedingReference(
         board,
         boardById,
+        listByBoardId,
         circuitById,
         sectionById
       ),
@@ -252,7 +256,9 @@ export async function buildProjectCircuitTrees(
         voltage: circuit.voltage ?? undefined,
         controlRequirement: circuit.controlRequirement ?? undefined,
         status: circuit.status ?? undefined,
-        isReserve: Boolean(circuit.isReserve),
+        isReserve:
+          Boolean(circuit.isReserve) &&
+          circuitLoad.downstreamBoards.length === 0,
         remark: circuit.remark ?? undefined,
         circuitTotalPower: circuitLoad.activePowerKw,
         circuitApparentPower: circuitLoad.apparentPowerKva,
@@ -292,17 +298,21 @@ export async function buildProjectCircuitTrees(
 function resolveFeedingReference(
   board: Awaited<ReturnType<typeof distributionBoardRepository.listByProject>>[number],
   boardById: Map<string, Awaited<ReturnType<typeof distributionBoardRepository.listByProject>>[number]>,
+  listByBoardId: Map<string, Awaited<ReturnType<typeof circuitListRepository.listByProject>>[number]>,
   circuitById: Map<string, Awaited<ReturnType<typeof circuitRepository.listByCircuitLists>>[number]>,
   sectionById: Map<string, Awaited<ReturnType<typeof circuitSectionRepository.listByCircuitLists>>[number]>
 ) {
   if (board.feedingDistributionBoardId === null) return undefined;
   const feedingBoard = boardById.get(board.feedingDistributionBoardId);
   if (!feedingBoard) throw new Error("Feeding distribution board is missing.");
+  const feedingList = listByBoardId.get(feedingBoard.id);
+  if (!feedingList) throw new Error("Feeding circuit list is missing.");
   const feedingCircuit = board.feedingCircuitId === null
     ? undefined
     : circuitById.get(board.feedingCircuitId);
   return {
     distributionBoardId: feedingBoard.id,
+    circuitListId: feedingList.id,
     distributionBoardName: feedingBoard.name,
     distributionBoardNumber: feedingBoard.boardNumber ?? undefined,
     circuitId: feedingCircuit?.id,
diff --git a/tests/cable-sizing-calculation.test.ts b/tests/cable-sizing-calculation.test.ts
index 39cfbb1..53d81a1 100644
--- a/tests/cable-sizing-calculation.test.ts
+++ b/tests/cable-sizing-calculation.test.ts
@@ -267,6 +267,15 @@ describe("cable sizing defaults from the circuit", () => {
     sortOrder: 1,
     isReserve: rows.length === 0,
     circuitTotalPower: rows.reduce((sum, row) => sum + row.power, 0),
+    circuitApparentPower: rows.reduce(
+      (sum, row) => sum + row.power / (row.cosPhi ?? 1),
+      0
+    ),
+    circuitCosPhi: rows.length
+      ? rows.reduce((sum, row) => sum + row.power, 0) /
+        rows.reduce((sum, row) => sum + row.power / (row.cosPhi ?? 1), 0)
+      : 1,
+    downstreamBoardLoads: [],
     deviceRows: rows.map((row, index) => ({
       id: `row-${index}`,
       sortOrder: index,
@@ -288,6 +297,19 @@ describe("cable sizing defaults from the circuit", () => {
     assert.equal(deriveCircuitCosPhi(circuit([])), 1);
   });
 
+  it("uses the projected cos φ including downstream boards", () => {
+    const feeder = circuit([{ power: 1, cosPhi: 1 }]);
+    feeder.circuitCosPhi = 0.67;
+    feeder.downstreamBoardLoads = [{
+      distributionBoardId: "uv-2",
+      name: "UV 2",
+      activePowerKw: 3,
+      apparentPowerKva: 5,
+      cosPhi: 0.6,
+    }];
+    assert.equal(deriveCircuitCosPhi(feeder), 0.67);
+  });
+
   it("derives the phase from the group category or three-phase rows", () => {
     assert.equal(deriveCircuitPhase(circuit([{ power: 1, phaseType: "single_phase" }]), "single_phase"), 1);
     assert.equal(deriveCircuitPhase(circuit([{ power: 1, phaseType: "three_phase" }]), "single_phase"), 3);
diff --git a/tests/circuit-grid-projection.test.ts b/tests/circuit-grid-projection.test.ts
index 952e3d6..1a16913 100644
--- a/tests/circuit-grid-projection.test.ts
+++ b/tests/circuit-grid-projection.test.ts
@@ -47,7 +47,10 @@ function makeCircuit(
     sortOrder,
     isReserve: deviceRows.length === 0,
     circuitTotalPower: deviceRows.reduce((total, row) => total + row.rowTotalPower, 0),
+    circuitApparentPower: deviceRows.reduce((total, row) => total + row.rowTotalPower, 0),
+    circuitCosPhi: 1,
     deviceRows,
+    downstreamBoardLoads: [],
   };
 }
 
@@ -176,6 +179,44 @@ describe("circuit grid projection", () => {
     );
   });
 
+  it("renders linked downstream boards as separate read-only rows", () => {
+    const feeder = {
+      ...reserveCircuit,
+      isReserve: false,
+      circuitTotalPower: 4,
+      circuitApparentPower: 5,
+      circuitCosPhi: 0.8,
+      downstreamBoardLoads: [{
+        distributionBoardId: "board-child",
+        name: "Unterverteilung",
+        boardNumber: "UV-02",
+        activePowerKw: 4,
+        apparentPowerKva: 5,
+        cosPhi: 0.8,
+      }],
+    };
+    const rows = buildVisibleGridRowsWithStructure(
+      [{ ...sections[0], circuits: [feeder] }],
+      { headerComponents: [], footerComponents: [] }
+    );
+    assert.deepEqual(rows.map((row) => row.rowType), [
+      "section",
+      "circuitSummary",
+      "downstreamBoardLoad",
+      "placeholder",
+    ]);
+    const loadRow = rows[2];
+    assert.equal(
+      loadRow.cells.find((cell) => cell.cellKey === "displayName")?.value,
+      "Unterverteilung UV-02"
+    );
+    assert.equal(
+      loadRow.cells.find((cell) => cell.cellKey === "rowTotalPower")?.value,
+      4
+    );
+    assert.equal(loadRow.cells.every((cell) => !cell.editable), true);
+  });
+
   it("shows circuit protection once on each visible circuit row", () => {
     const protectedSections = sections.map((section) => ({
       ...section,

From c56cfb30ada12f7ab0801c2bfbb540925573d80c Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Mon, 28 Sep 2026 19:51:47 +0200
Subject: [PATCH 38/60] Add login-required user management (admin/user roles,
 Config->Benutzer)

No self-signup: admins create every account in Config -> Benutzer with a
typed start password; a forced password change gates first use. Session-
cookie auth protects all /api/* routes; /api/users additionally requires
the admin role. See docs/authentication.md.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 AGENTS.md                                     |   11 +
 compose.dev.yaml                              |    6 +-
 compose.yaml                                  |   11 +-
 docs/README.md                                |    2 +
 docs/authentication.md                        |   61 +
 src/app/config/benutzer/page.tsx              |  325 ++
 src/app/config/konto/page.tsx                 |  103 +
 src/app/config/layout.tsx                     |   51 +
 src/app/config/page.tsx                       |    5 +
 src/app/globals.css                           |  113 +
 src/app/layout.tsx                            |    8 +-
 src/db/migrations/0012_lively_turbo.sql       |   13 +
 src/db/migrations/meta/0012_snapshot.json     | 3017 +++++++++++++++++
 src/db/migrations/meta/_journal.json          |    7 +
 src/db/repositories/user.repository.ts        |   87 +
 src/db/schema/users.ts                        |   27 +
 src/domain/services/user.service.ts           |  104 +
 src/frontend/components/AuthProvider.tsx      |   61 +
 src/frontend/components/LoginGate.tsx         |  179 +
 src/frontend/components/Sidebar.tsx           |   25 +
 src/frontend/utils/auth-api.ts                |   86 +
 src/server/auth/auth-config.ts                |   44 +
 src/server/auth/auth.middleware.ts            |  111 +
 src/server/auth/cookie.ts                     |   15 +
 src/server/auth/password.ts                   |   63 +
 src/server/auth/sessions.ts                   |   55 +
 .../composition/application-repositories.ts   |    2 +
 src/server/composition/auth.ts                |    8 +
 src/server/controllers/auth.controller.ts     |   88 +
 src/server/controllers/user.controller.ts     |  103 +
 src/server/index.ts                           |   88 +-
 src/server/routes/auth.routes.ts              |   16 +
 src/server/routes/user.routes.ts              |   16 +
 src/shared/constants/user-roles.ts            |    7 +
 src/shared/validation/auth.schemas.ts         |   15 +
 src/shared/validation/user.schemas.ts         |   33 +
 36 files changed, 4928 insertions(+), 38 deletions(-)
 create mode 100644 docs/authentication.md
 create mode 100644 src/app/config/benutzer/page.tsx
 create mode 100644 src/app/config/konto/page.tsx
 create mode 100644 src/app/config/layout.tsx
 create mode 100644 src/app/config/page.tsx
 create mode 100644 src/db/migrations/0012_lively_turbo.sql
 create mode 100644 src/db/migrations/meta/0012_snapshot.json
 create mode 100644 src/db/repositories/user.repository.ts
 create mode 100644 src/db/schema/users.ts
 create mode 100644 src/domain/services/user.service.ts
 create mode 100644 src/frontend/components/AuthProvider.tsx
 create mode 100644 src/frontend/components/LoginGate.tsx
 create mode 100644 src/frontend/utils/auth-api.ts
 create mode 100644 src/server/auth/auth-config.ts
 create mode 100644 src/server/auth/auth.middleware.ts
 create mode 100644 src/server/auth/cookie.ts
 create mode 100644 src/server/auth/password.ts
 create mode 100644 src/server/auth/sessions.ts
 create mode 100644 src/server/composition/auth.ts
 create mode 100644 src/server/controllers/auth.controller.ts
 create mode 100644 src/server/controllers/user.controller.ts
 create mode 100644 src/server/routes/auth.routes.ts
 create mode 100644 src/server/routes/user.routes.ts
 create mode 100644 src/shared/constants/user-roles.ts
 create mode 100644 src/shared/validation/auth.schemas.ts
 create mode 100644 src/shared/validation/user.schemas.ts

diff --git a/AGENTS.md b/AGENTS.md
index 8312d55..5c70f07 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -36,6 +36,13 @@ It must support circuits, device rows, project devices, drag-and-drop restructur
 - General Circuit, CircuitDeviceRow, CircuitList and DistributionBoard
   repositories expose only active reads. Runtime writes belong in typed command
   repositories; direct integration fixtures belong under `tests/support`.
+- Authentication: session-cookie login with two fixed roles (`admin`, `user`),
+  no self-signup. `src/server/auth/*` (password hashing, sessions, Express
+  middleware), `src/domain/services/user.service.ts`,
+  `src/db/repositories/user.repository.ts`. Every `/api/*` route requires a
+  signed-in user (`src/server/index.ts`); `/api/users/*` additionally
+  requires `admin`. Frontend gate: `AuthProvider` + `LoginGate`
+  (`src/app/layout.tsx`). See `docs/authentication.md` for the full picture.
 
 The supported runtime model is Circuit-First. The former Consumer UI, API,
 tables and upgrade tooling are removed; do not reintroduce them.
@@ -704,6 +711,10 @@ for the early-phase power balance by DIN 276 cost group (see
 - logical feed link between distribution boards (`fedFrom` stays free text
   until the project owner decides whether it references a board, a feeding
   circuit or both) and the resulting hierarchical power summation
+- configurable role/rights matrix instead of the fixed `admin`/`user` roles
+- account lockout after failed login attempts
+- email/one-time-link password provisioning, OIDC/Entra login
+- linking user accounts to a personnel/employee master table
 
 Do not implement these while working on an unrelated phase.
 
diff --git a/compose.dev.yaml b/compose.dev.yaml
index b9c64b4..2c362bc 100644
--- a/compose.dev.yaml
+++ b/compose.dev.yaml
@@ -35,8 +35,10 @@ services:
       PORT: "3000"
       CHOKIDAR_USEPOLLING: "true"
       LOG_LEVEL: "${LOG_LEVEL:-debug}"
-    # Nur auf dem Loopback: nichts davon ist authentifiziert, die API darf
-    # nicht aus dem LAN erreichbar sein.
+      AUTH_BOOTSTRAP_USERNAME: "${AUTH_BOOTSTRAP_USERNAME:-}"
+      AUTH_BOOTSTRAP_PASSWORT: "${AUTH_BOOTSTRAP_PASSWORT:-}"
+      AUTH_SESSION_HOURS: "${AUTH_SESSION_HOURS:-12}"
+    # Nur auf dem Loopback: die API darf nicht aus dem LAN erreichbar sein.
     ports:
       - "127.0.0.1:3000:3000"
     # Kein memswap_limit wie im Server-Stack: beim Entwickeln ist Swap als
diff --git a/compose.yaml b/compose.yaml
index 3438f90..bab8c3d 100644
--- a/compose.yaml
+++ b/compose.yaml
@@ -45,8 +45,15 @@ services:
       NODE_ENV: production
       PORT: "3000"
       LOG_LEVEL: "${LOG_LEVEL:-info}"
-    # Nicht auf dem Host veroeffentlicht: die API hat keine Authentifizierung
-    # und wird ueber den Next.js-Rewrite im Web-Dienst erreicht.
+      # AUTH_BOOTSTRAP_* legen nur den allerersten Admin an (solange die
+      # users-Tabelle leer ist) und gehoeren in eine lokale, nicht versionierte
+      # .env - siehe docs/AUTH.md.
+      AUTH_BOOTSTRAP_USERNAME: "${AUTH_BOOTSTRAP_USERNAME:-}"
+      AUTH_BOOTSTRAP_PASSWORT: "${AUTH_BOOTSTRAP_PASSWORT:-}"
+      AUTH_SESSION_HOURS: "${AUTH_SESSION_HOURS:-12}"
+      COOKIE_SECURE: "${COOKIE_SECURE:-false}"
+    # Nicht auf dem Host veroeffentlicht: die API wird ueber den
+    # Next.js-Rewrite im Web-Dienst erreicht.
     expose:
       - "3000"
     # Harte Obergrenze statt unbegrenztem Wachstum. memswap_limit == mem_limit
diff --git a/docs/README.md b/docs/README.md
index 01b5588..3569b42 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -23,6 +23,8 @@ ausdrücklich getrennt und dürfen nicht als bereits implementiert verstanden we
   bewusst noch nicht implementierte oder begrenzte Funktionen
 - [Leitungsberechnung](cable-sizing-module.md) – optionales Rechenmodul,
   Rechenweg, Datenbasis und Prüfnachweis der Tabellen
+- [Anmeldung und Benutzerverwaltung](authentication.md) – Rollen, Ablauf beim
+  Anlegen eines Zugangs, Sessions, Bootstrap-Admin
 
 ## Entwicklung und Betrieb
 
diff --git a/docs/authentication.md b/docs/authentication.md
new file mode 100644
index 0000000..3d197cf
--- /dev/null
+++ b/docs/authentication.md
@@ -0,0 +1,61 @@
+# Anmeldung und Benutzerverwaltung
+
+Die Leistungsbilanz verlangt eine Anmeldung. Es gibt kein Self-Signup: jeder
+Zugang wird von einem Administrator über **Config → Benutzer** angelegt.
+
+## Rollen
+
+Es gibt genau zwei Rollen (`src/shared/constants/user-roles.ts`):
+
+- **admin** – wie `user`, zusätzlich Zugriff auf den Config-Bereich
+  (Benutzerverwaltung, eigenes Konto)
+- **user** – volle Nutzung der Leistungsbilanz (Projekte, Stromkreislisten,
+  Grobbilanz, …), kein Zugriff auf Config
+
+Es gibt (bewusst, siehe unten) keine konfigurierbare Rechte-Matrix und keine
+Verknüpfung mit einer Mitarbeiter-/Personen-Stammdatentabelle.
+
+## Ablauf beim Anlegen eines Zugangs
+
+1. Ein Administrator öffnet Config → Benutzer und legt einen neuen Zugang mit
+   Anmeldename, Name, Rolle und einem **Startpasswort** an, das er selbst
+   eintippt.
+2. Der Zugang startet mit `mustChangePassword = true`.
+3. Beim ersten Anmelden zeigt die Oberfläche statt der App ein Formular, das
+   ein eigenes Passwort verlangt, bevor es weitergeht.
+4. "Passwort zurücksetzen" (ebenfalls in Config → Benutzer) setzt ein neues
+   Startpasswort und `mustChangePassword` wieder auf `true` – z. B. wenn
+   jemand sein Passwort vergessen hat.
+
+## Technischer Aufbau
+
+- **Datenmodell:** Tabelle `users` (`src/db/schema/users.ts`) –
+  `username`, `passwordHash` (scrypt, `src/server/auth/password.ts`), `name`,
+  `role`, `active`, `mustChangePassword`.
+- **Sessions:** In-Memory-Store (`src/server/auth/sessions.ts`), Cookie
+  `lb_session`, sliding expiry (`AUTH_SESSION_HOURS`, Standard 12h). Ein
+  Neustart der API beendet alle Sessions – für einen Single-Container-Dienst
+  ein akzeptabler Kompromiss gegenüber einer persistierten Session-Tabelle.
+- **Middleware:** `src/server/auth/auth.middleware.ts` schützt `/api/*`
+  (außer `/api/auth/login`, `/api/auth/status`, `/api/auth/logout`) und
+  erzwingt den Passwortwechsel, solange `mustChangePassword` gesetzt ist.
+  `/api/users/*` verlangt zusätzlich die Rolle `admin`.
+- **Frontend:** `AuthProvider` lädt `/api/auth/me`; `LoginGate`
+  (`src/app/layout.tsx`) zeigt Login- bzw. Passwortformular, solange nicht
+  angemeldet bzw. `mustChangePassword` gesetzt ist, sonst die App.
+
+## Bootstrap-Admin
+
+`AUTH_BOOTSTRAP_USERNAME` / `AUTH_BOOTSTRAP_PASSWORT` (Env-Variablen, siehe
+`compose.yaml`) legen beim ersten Start einen Admin an – **nur falls die
+`users`-Tabelle noch komplett leer ist**. Danach werden diese Variablen
+ignoriert; jeder weitere Zugang entsteht über Config → Benutzer. Die Werte
+gehören in eine lokale, nicht versionierte `.env` auf dem Deploy-Host, nicht
+in `compose.yaml` selbst.
+
+## Bewusst nicht umgesetzt (Stand jetzt)
+
+- Konfigurierbare Rechte-Matrix statt fixer `admin`/`user`-Rollen
+- Konten-Sperre nach Fehlversuchen
+- E-Mail-/Einmal-Link-Passwortvergabe, OIDC/Entra-Anmeldung
+- Verknüpfung von Zugängen mit einer Mitarbeiter-Stammdatentabelle
diff --git a/src/app/config/benutzer/page.tsx b/src/app/config/benutzer/page.tsx
new file mode 100644
index 0000000..134890d
--- /dev/null
+++ b/src/app/config/benutzer/page.tsx
@@ -0,0 +1,325 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { userApi, type UserDto, type UserRole } from "../../../frontend/utils/auth-api";
+import { useAuth } from "../../../frontend/components/AuthProvider";
+import { USER_ROLES, USER_ROLE_LABEL } from "../../../shared/constants/user-roles";
+
+const zeitpunkt = new Intl.DateTimeFormat("de-DE", {
+  dateStyle: "short",
+  timeStyle: "short",
+});
+
+export default function BenutzerPage() {
+  const { user: currentUser } = useAuth();
+  const [users, setUsers] = useState<UserDto[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [busyUserId, setBusyUserId] = useState<string | null>(null);
+  const [resetPasswordFor, setResetPasswordFor] = useState<UserDto | null>(null);
+
+  const load = useCallback(async () => {
+    setLoading(true);
+    try {
+      const rows = await userApi.list();
+      setUsers(rows);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Benutzer konnten nicht geladen werden.");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  async function withBusy(userId: string, action: () => Promise<void>) {
+    setBusyUserId(userId);
+    setError(null);
+    try {
+      await action();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Aktion fehlgeschlagen.");
+    } finally {
+      setBusyUserId(null);
+    }
+  }
+
+  async function changeRole(item: UserDto, role: UserRole) {
+    await withBusy(item.id, async () => {
+      const updated = await userApi.update(item.id, { role });
+      setUsers((list) => list.map((row) => (row.id === updated.id ? updated : row)));
+    });
+  }
+
+  async function toggleActive(item: UserDto) {
+    await withBusy(item.id, async () => {
+      const updated = await userApi.update(item.id, { active: !item.active });
+      setUsers((list) => list.map((row) => (row.id === updated.id ? updated : row)));
+    });
+  }
+
+  return (
+    <div className="card" style={{ padding: "1.5rem" }}>
+      <div className="page-header" style={{ marginTop: 0 }}>
+        <h2 className="h5" style={{ margin: 0 }}>
+          Benutzer
+        </h2>
+      </div>
+      <p className="text-body-secondary" style={{ marginBottom: "1rem" }}>
+        Es gibt kein Self-Signup: Jeder Zugang wird hier bewusst von einem
+        Administrator angelegt. Das Startpasswort wird direkt eingetragen; die
+        Person muss es beim ersten Anmelden durch ein eigenes ersetzen.
+      </p>
+
+      <NeuerBenutzerFormular
+        onCreated={(created) => {
+          setUsers((list) => [...list, created]);
+        }}
+      />
+
+      {error && <p className="text-danger">{error}</p>}
+      {loading && <p>Lädt…</p>}
+
+      {!loading && users.length > 0 && (
+        <table className="table" style={{ marginTop: "1.5rem" }}>
+          <thead>
+            <tr>
+              <th>Name</th>
+              <th>Anmeldename</th>
+              <th>Rolle</th>
+              <th>Aktiv</th>
+              <th>Status</th>
+              <th>Angelegt</th>
+              <th>Aktionen</th>
+            </tr>
+          </thead>
+          <tbody>
+            {users.map((item) => {
+              const isSelf = item.id === currentUser?.id;
+              const busy = busyUserId === item.id;
+              return (
+                <tr key={item.id}>
+                  <td>{item.name}</td>
+                  <td>{item.username}</td>
+                  <td>
+                    <select
+                      className="form-select form-select-sm"
+                      value={item.role}
+                      disabled={busy || isSelf}
+                      title={isSelf ? "Der eigene Zugang kann hier nicht geändert werden." : undefined}
+                      onChange={(event) => void changeRole(item, event.target.value as UserRole)}
+                    >
+                      {USER_ROLES.map((role) => (
+                        <option key={role} value={role}>
+                          {USER_ROLE_LABEL[role]}
+                        </option>
+                      ))}
+                    </select>
+                  </td>
+                  <td>
+                    <input
+                      type="checkbox"
+                      checked={item.active}
+                      disabled={busy || isSelf}
+                      title={isSelf ? "Der eigene Zugang kann hier nicht geändert werden." : undefined}
+                      onChange={() => void toggleActive(item)}
+                    />
+                  </td>
+                  <td>{item.mustChangePassword ? "Muss Passwort setzen" : "In Ordnung"}</td>
+                  <td>{zeitpunkt.format(new Date(item.createdAt))}</td>
+                  <td>
+                    <button
+                      type="button"
+                      className="btn btn-outline-primary btn-sm"
+                      disabled={busy}
+                      onClick={() => setResetPasswordFor(item)}
+                    >
+                      Passwort zurücksetzen
+                    </button>
+                  </td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </table>
+      )}
+
+      {!loading && users.length === 0 && <p>Noch keine Benutzer angelegt.</p>}
+
+      {resetPasswordFor && (
+        <PasswortZuruecksetzenDialog
+          item={resetPasswordFor}
+          onClose={() => setResetPasswordFor(null)}
+          onDone={(updated) => {
+            setUsers((list) => list.map((row) => (row.id === updated.id ? updated : row)));
+            setResetPasswordFor(null);
+          }}
+        />
+      )}
+    </div>
+  );
+}
+
+function NeuerBenutzerFormular({ onCreated }: { onCreated: (created: UserDto) => void }) {
+  const [username, setUsername] = useState("");
+  const [name, setName] = useState("");
+  const [role, setRole] = useState<UserRole>("user");
+  const [initialPassword, setInitialPassword] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [submitting, setSubmitting] = useState(false);
+
+  async function handleSubmit(event: React.FormEvent) {
+    event.preventDefault();
+    setSubmitting(true);
+    setError(null);
+    try {
+      const created = await userApi.create({ username, name, role, initialPassword });
+      onCreated(created);
+      setUsername("");
+      setName("");
+      setRole("user");
+      setInitialPassword("");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Benutzer konnte nicht angelegt werden.");
+    } finally {
+      setSubmitting(false);
+    }
+  }
+
+  return (
+    <form
+      onSubmit={handleSubmit}
+      className="row g-2 align-items-end"
+      style={{ borderBottom: "1px solid rgba(0,0,0,0.1)", paddingBottom: "1rem" }}
+    >
+      <div className="col-sm-3">
+        <label className="form-label" htmlFor="new-user-username">
+          Anmeldename
+        </label>
+        <input
+          id="new-user-username"
+          className="form-control form-control-sm"
+          value={username}
+          onChange={(event) => setUsername(event.target.value)}
+          required
+        />
+      </div>
+      <div className="col-sm-3">
+        <label className="form-label" htmlFor="new-user-name">
+          Name
+        </label>
+        <input
+          id="new-user-name"
+          className="form-control form-control-sm"
+          value={name}
+          onChange={(event) => setName(event.target.value)}
+          required
+        />
+      </div>
+      <div className="col-sm-2">
+        <label className="form-label" htmlFor="new-user-role">
+          Rolle
+        </label>
+        <select
+          id="new-user-role"
+          className="form-select form-select-sm"
+          value={role}
+          onChange={(event) => setRole(event.target.value as UserRole)}
+        >
+          {USER_ROLES.map((r) => (
+            <option key={r} value={r}>
+              {USER_ROLE_LABEL[r]}
+            </option>
+          ))}
+        </select>
+      </div>
+      <div className="col-sm-3">
+        <label className="form-label" htmlFor="new-user-password">
+          Startpasswort
+        </label>
+        <input
+          id="new-user-password"
+          type="text"
+          className="form-control form-control-sm"
+          value={initialPassword}
+          onChange={(event) => setInitialPassword(event.target.value)}
+          minLength={8}
+          required
+        />
+      </div>
+      <div className="col-sm-1">
+        <button type="submit" className="btn btn-primary btn-sm w-100" disabled={submitting}>
+          {submitting ? "…" : "Anlegen"}
+        </button>
+      </div>
+      {error && (
+        <div className="col-12">
+          <p className="text-danger mb-0">{error}</p>
+        </div>
+      )}
+    </form>
+  );
+}
+
+function PasswortZuruecksetzenDialog({
+  item,
+  onClose,
+  onDone,
+}: {
+  item: UserDto;
+  onClose: () => void;
+  onDone: (updated: UserDto) => void;
+}) {
+  const [newPassword, setNewPassword] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [submitting, setSubmitting] = useState(false);
+
+  async function handleSubmit(event: React.FormEvent) {
+    event.preventDefault();
+    setSubmitting(true);
+    setError(null);
+    try {
+      const updated = await userApi.resetPassword(item.id, newPassword);
+      onDone(updated);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Passwort konnte nicht zurückgesetzt werden.");
+    } finally {
+      setSubmitting(false);
+    }
+  }
+
+  return (
+    <div className="modal-backdrop-inline">
+      <form className="card" style={{ maxWidth: 360, padding: "1.5rem" }} onSubmit={handleSubmit}>
+        <h3 className="h6">Passwort zurücksetzen für {item.name}</h3>
+        <div className="mb-3">
+          <label className="form-label" htmlFor="reset-password">
+            Neues Startpasswort
+          </label>
+          <input
+            id="reset-password"
+            type="text"
+            className="form-control"
+            value={newPassword}
+            onChange={(event) => setNewPassword(event.target.value)}
+            minLength={8}
+            autoFocus
+            required
+          />
+        </div>
+        {error && <p className="text-danger">{error}</p>}
+        <div className="d-flex gap-2">
+          <button type="submit" className="btn btn-primary" disabled={submitting}>
+            {submitting ? "Speichert…" : "Zurücksetzen"}
+          </button>
+          <button type="button" className="btn btn-outline-secondary" onClick={onClose}>
+            Abbrechen
+          </button>
+        </div>
+      </form>
+    </div>
+  );
+}
diff --git a/src/app/config/konto/page.tsx b/src/app/config/konto/page.tsx
new file mode 100644
index 0000000..2b58ee7
--- /dev/null
+++ b/src/app/config/konto/page.tsx
@@ -0,0 +1,103 @@
+"use client";
+
+import { useState } from "react";
+import { authApi } from "../../../frontend/utils/auth-api";
+import { useAuth } from "../../../frontend/components/AuthProvider";
+import { USER_ROLE_LABEL } from "../../../shared/constants/user-roles";
+
+export default function KontoPage() {
+  const { user } = useAuth();
+  const [currentPassword, setCurrentPassword] = useState("");
+  const [newPassword, setNewPassword] = useState("");
+  const [newPasswordRepeat, setNewPasswordRepeat] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [success, setSuccess] = useState(false);
+  const [submitting, setSubmitting] = useState(false);
+
+  async function handleSubmit(event: React.FormEvent) {
+    event.preventDefault();
+    if (newPassword !== newPasswordRepeat) {
+      setError("Die beiden neuen Passwörter stimmen nicht überein.");
+      return;
+    }
+    setSubmitting(true);
+    setError(null);
+    setSuccess(false);
+    try {
+      await authApi.changePassword(currentPassword, newPassword);
+      setCurrentPassword("");
+      setNewPassword("");
+      setNewPasswordRepeat("");
+      setSuccess(true);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Passwort konnte nicht geändert werden.");
+    } finally {
+      setSubmitting(false);
+    }
+  }
+
+  return (
+    <div className="card" style={{ maxWidth: 480, padding: "1.5rem" }}>
+      <h2 className="h5">Konto</h2>
+      {user && (
+        <p className="text-body-secondary">
+          Angemeldet als <strong>{user.name}</strong> ({user.username}) ·{" "}
+          {USER_ROLE_LABEL[user.role]}
+        </p>
+      )}
+
+      <h3 className="h6 mt-4">Passwort ändern</h3>
+      <form onSubmit={handleSubmit}>
+        <div className="mb-3">
+          <label className="form-label" htmlFor="konto-current-password">
+            Aktuelles Passwort
+          </label>
+          <input
+            id="konto-current-password"
+            type="password"
+            className="form-control"
+            value={currentPassword}
+            onChange={(event) => setCurrentPassword(event.target.value)}
+            autoComplete="current-password"
+            required
+          />
+        </div>
+        <div className="mb-3">
+          <label className="form-label" htmlFor="konto-new-password">
+            Neues Passwort
+          </label>
+          <input
+            id="konto-new-password"
+            type="password"
+            className="form-control"
+            value={newPassword}
+            onChange={(event) => setNewPassword(event.target.value)}
+            autoComplete="new-password"
+            minLength={8}
+            required
+          />
+        </div>
+        <div className="mb-3">
+          <label className="form-label" htmlFor="konto-new-password-repeat">
+            Neues Passwort wiederholen
+          </label>
+          <input
+            id="konto-new-password-repeat"
+            type="password"
+            className="form-control"
+            value={newPasswordRepeat}
+            onChange={(event) => setNewPasswordRepeat(event.target.value)}
+            autoComplete="new-password"
+            minLength={8}
+            required
+          />
+        </div>
+        {error && <p className="text-danger">{error}</p>}
+        {success && <p className="text-success">Passwort wurde geändert.</p>}
+        <button type="submit" className="btn btn-primary" disabled={submitting}>
+          {submitting ? "Speichert…" : "Passwort ändern"}
+        </button>
+      </form>
+    </div>
+  );
+}
diff --git a/src/app/config/layout.tsx b/src/app/config/layout.tsx
new file mode 100644
index 0000000..1356d78
--- /dev/null
+++ b/src/app/config/layout.tsx
@@ -0,0 +1,51 @@
+"use client";
+
+import Link from "next/link";
+import { usePathname, useRouter } from "next/navigation";
+import { useEffect } from "react";
+import { useAuth } from "../../frontend/components/AuthProvider";
+
+const CONFIG_TABS = [
+  { href: "/config/benutzer", label: "Benutzer" },
+  { href: "/config/konto", label: "Konto" },
+] as const;
+
+export default function ConfigLayout({ children }: { children: React.ReactNode }) {
+  const pathname = usePathname();
+  const router = useRouter();
+  const { status, isAdmin } = useAuth();
+
+  useEffect(() => {
+    // LoginGate already guarantees a signed-in user with a set password by
+    // the time this layout renders; only the role still needs checking.
+    if (status === "signed-in" && !isAdmin) {
+      router.replace("/");
+    }
+  }, [status, isAdmin, router]);
+
+  if (status !== "signed-in" || !isAdmin) {
+    return null;
+  }
+
+  return (
+    <div className="container-fluid py-4">
+      <div className="page-header">
+        <h1>Config</h1>
+      </div>
+
+      <nav className="config-tabs">
+        {CONFIG_TABS.map((tab) => (
+          <Link
+            key={tab.href}
+            href={tab.href}
+            className={pathname?.startsWith(tab.href) ? "config-tab active" : "config-tab"}
+          >
+            {tab.label}
+          </Link>
+        ))}
+      </nav>
+
+      {children}
+    </div>
+  );
+}
diff --git a/src/app/config/page.tsx b/src/app/config/page.tsx
new file mode 100644
index 0000000..7897dc7
--- /dev/null
+++ b/src/app/config/page.tsx
@@ -0,0 +1,5 @@
+import { redirect } from "next/navigation";
+
+export default function ConfigPage() {
+  redirect("/config/benutzer");
+}
diff --git a/src/app/globals.css b/src/app/globals.css
index de46d37..f670173 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -2716,3 +2716,116 @@ button.structure-entry-main:focus-visible {
     justify-content: center;
   }
 }
+
+/* ── Anmeldung (Sidebar-Config-Link, Identität, Login-Gate) ─────────── */
+
+.sidebar-nav-bottom {
+  flex: 0 0 auto;
+  border-top: 1px solid rgba(255, 255, 255, 0.12);
+}
+
+.sidebar-identity {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  padding: 8px 14px 10px;
+}
+
+.sidebar-identity-label {
+  font-size: 0.66rem;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  color: rgba(199, 214, 224, 0.7);
+}
+
+.sidebar-identity-name {
+  font-size: 0.88rem;
+  font-weight: 600;
+  color: #fff;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.sidebar-logout {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  margin-top: 8px;
+  padding: 8px 14px;
+  border-radius: 8px;
+  color: #c7d6e0;
+  font-size: 0.85rem;
+  font-weight: 500;
+  border: 1px solid rgba(255, 255, 255, 0.16);
+  background: transparent;
+  width: 100%;
+  cursor: pointer;
+}
+
+.sidebar-logout:hover {
+  background: rgba(255, 255, 255, 0.1);
+  color: #fff;
+}
+
+.sidebar-collapsed .sidebar-identity {
+  display: none;
+}
+
+.login-gate-screen {
+  min-height: 100vh;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: var(--space-md);
+  background: linear-gradient(
+    160deg,
+    var(--color-primary-deep) 0%,
+    var(--color-primary-dark) 45%,
+    var(--color-primary) 100%
+  );
+}
+
+.login-gate-card {
+  width: 100%;
+  max-width: 360px;
+  padding: 28px 26px;
+}
+
+.config-tabs {
+  display: flex;
+  gap: 4px;
+  border-bottom: 1px solid var(--color-border, rgba(0, 0, 0, 0.12));
+  margin-bottom: var(--space-md);
+}
+
+.config-tab {
+  padding: 8px 16px;
+  border-radius: 6px 6px 0 0;
+  color: inherit;
+  text-decoration: none;
+  font-size: 0.9rem;
+  font-weight: 500;
+  opacity: 0.7;
+}
+
+.config-tab:hover {
+  opacity: 1;
+  text-decoration: none;
+}
+
+.config-tab.active {
+  opacity: 1;
+  box-shadow: inset 0 -2px 0 var(--color-primary);
+}
+
+.modal-backdrop-inline {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.45);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1050;
+}
diff --git a/src/app/layout.tsx b/src/app/layout.tsx
index cd2407b..c830c99 100644
--- a/src/app/layout.tsx
+++ b/src/app/layout.tsx
@@ -3,6 +3,8 @@ import Script from "next/script";
 import "bootstrap/dist/css/bootstrap.min.css";
 import "./globals.css";
 import { AppShell } from "../frontend/components/AppShell";
+import { AuthProvider } from "../frontend/components/AuthProvider";
+import { LoginGate } from "../frontend/components/LoginGate";
 
 export const metadata: Metadata = {
   title: "Leistungsbilanz",
@@ -36,7 +38,11 @@ export default function RootLayout({ children }: Readonly<{ children: React.Reac
         <Script id="theme-init" strategy="beforeInteractive">
           {THEME_INIT_SCRIPT}
         </Script>
-        <AppShell>{children}</AppShell>
+        <AuthProvider>
+          <LoginGate>
+            <AppShell>{children}</AppShell>
+          </LoginGate>
+        </AuthProvider>
       </body>
     </html>
   );
diff --git a/src/db/migrations/0012_lively_turbo.sql b/src/db/migrations/0012_lively_turbo.sql
new file mode 100644
index 0000000..6c07010
--- /dev/null
+++ b/src/db/migrations/0012_lively_turbo.sql
@@ -0,0 +1,13 @@
+CREATE TABLE `users` (
+	`id` text PRIMARY KEY NOT NULL,
+	`username` text NOT NULL,
+	`password_hash` text NOT NULL,
+	`name` text NOT NULL,
+	`role` text DEFAULT 'user' NOT NULL,
+	`active` integer DEFAULT true NOT NULL,
+	`must_change_password` integer DEFAULT true NOT NULL,
+	`created_at` integer DEFAULT (unixepoch()) NOT NULL,
+	`updated_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `users_username_unique` ON `users` (`username`);
\ No newline at end of file
diff --git a/src/db/migrations/meta/0012_snapshot.json b/src/db/migrations/meta/0012_snapshot.json
new file mode 100644
index 0000000..ed30f77
--- /dev/null
+++ b/src/db/migrations/meta/0012_snapshot.json
@@ -0,0 +1,3017 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "7c6307b6-2516-445c-a088-c8ad746b9fde",
+  "prevId": "63f27b3a-7378-462d-8119-b67d67903dbb",
+  "tables": {
+    "buildings": {
+      "name": "buildings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "buildings_project_id_projects_id_fk": {
+          "name": "buildings_project_id_projects_id_fk",
+          "tableFrom": "buildings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_device_rows": {
+      "name": "circuit_device_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "level": {
+          "name": "level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number_snapshot": {
+          "name": "room_number_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_name_snapshot": {
+          "name": "room_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "manual_quantity": {
+          "name": "manual_quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_device_rows_circuit_id_idx": {
+          "name": "circuit_device_rows_circuit_id_idx",
+          "columns": [
+            "circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "circuit_device_rows_circuit_id_circuits_id_fk": {
+          "name": "circuit_device_rows_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_linked_project_device_id_project_devices_id_fk": {
+          "name": "circuit_device_rows_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_room_id_rooms_id_fk": {
+          "name": "circuit_device_rows_room_id_rooms_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_list_equipment_identifiers": {
+      "name": "circuit_list_equipment_identifiers",
+      "columns": {
+        "owner_type": {
+          "name": "owner_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_list_equipment_identifiers_owner_unique": {
+          "name": "circuit_list_equipment_identifiers_owner_unique",
+          "columns": [
+            "owner_type",
+            "owner_id"
+          ],
+          "isUnique": true
+        },
+        "circuit_list_equipment_identifiers_list_identifier_unique": {
+          "name": "circuit_list_equipment_identifiers_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_list_equipment_identifiers",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_lists": {
+      "name": "circuit_lists",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_lists_distribution_board_id_unique": {
+          "name": "circuit_lists_distribution_board_id_unique",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_lists_project_id_projects_id_fk": {
+          "name": "circuit_lists_project_id_projects_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_lists_distribution_board_id_distribution_boards_id_fk": {
+          "name": "circuit_lists_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_protection_devices": {
+      "name": "circuit_protection_devices",
+      "columns": {
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "circuit_protection_devices_circuit_id_circuits_id_fk": {
+          "name": "circuit_protection_devices_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_protection_devices",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_sections": {
+      "name": "circuit_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "group_number": {
+          "name": "group_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_sections_list_key_unique": {
+          "name": "circuit_sections_list_key_unique",
+          "columns": [
+            "circuit_list_id",
+            "key"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_prefix_unique": {
+          "name": "circuit_sections_list_prefix_unique",
+          "columns": [
+            "circuit_list_id",
+            "prefix"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_category_group_unique": {
+          "name": "circuit_sections_list_category_group_unique",
+          "columns": [
+            "circuit_list_id",
+            "category",
+            "group_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_sections_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_sections_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_sections",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuits": {
+      "name": "circuits",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "cable_type": {
+          "name": "cable_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_cross_section": {
+          "name": "cable_cross_section",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_length": {
+          "name": "cable_length",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_assignment": {
+          "name": "rcd_assignment",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_designation": {
+          "name": "terminal_designation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage": {
+          "name": "voltage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "control_requirement": {
+          "name": "control_requirement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_reserve": {
+          "name": "is_reserve",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuits_section_id_idx": {
+          "name": "circuits_section_id_idx",
+          "columns": [
+            "section_id"
+          ],
+          "isUnique": false
+        },
+        "circuits_list_equipment_identifier_unique": {
+          "name": "circuits_list_equipment_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuits_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuits_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuits_section_id_circuit_sections_id_fk": {
+          "name": "circuits_section_id_circuit_sections_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_component_protection_devices": {
+      "name": "distribution_board_component_protection_devices",
+      "columns": {
+        "component_id": {
+          "name": "component_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk": {
+          "name": "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk",
+          "tableFrom": "distribution_board_component_protection_devices",
+          "tableTo": "distribution_board_components",
+          "columnsFrom": [
+            "component_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_components": {
+      "name": "distribution_board_components",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "placement": {
+          "name": "placement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "distribution_board_components_list_identifier_unique": {
+          "name": "distribution_board_components_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        },
+        "distribution_board_components_section_role_unique": {
+          "name": "distribution_board_components_section_role_unique",
+          "columns": [
+            "section_id",
+            "role"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "distribution_board_components_circuit_list_id_circuit_lists_id_fk": {
+          "name": "distribution_board_components_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_board_components_section_id_circuit_sections_id_fk": {
+          "name": "distribution_board_components_section_id_circuit_sections_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_boards": {
+      "name": "distribution_boards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "supply_type": {
+          "name": "supply_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "board_number": {
+          "name": "board_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "location": {
+          "name": "location",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fed_from": {
+          "name": "fed_from",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_boards_project_id_projects_id_fk": {
+          "name": "distribution_boards_project_id_projects_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_floor_id_floors_id_fk": {
+          "name": "distribution_boards_floor_id_floors_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_assets": {
+      "name": "document_branding_assets",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_settings": {
+      "name": "document_branding_settings",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_balances": {
+      "name": "estimate_balances",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "date_iso": {
+          "name": "date_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "reserve_av_percent": {
+          "name": "reserve_av_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "reserve_sv_percent": {
+          "name": "reserve_sv_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_balances_project_id_idx": {
+          "name": "estimate_balances_project_id_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_balances_project_id_projects_id_fk": {
+          "name": "estimate_balances_project_id_projects_id_fk",
+          "tableFrom": "estimate_balances",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_groups": {
+      "name": "estimate_groups",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "balance_id": {
+          "name": "balance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "editor": {
+          "name": "editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_groups_balance_id_idx": {
+          "name": "estimate_groups_balance_id_idx",
+          "columns": [
+            "balance_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_groups_balance_id_estimate_balances_id_fk": {
+          "name": "estimate_groups_balance_id_estimate_balances_id_fk",
+          "tableFrom": "estimate_groups",
+          "tableTo": "estimate_balances",
+          "columnsFrom": [
+            "balance_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_rows": {
+      "name": "estimate_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "supply": {
+          "name": "supply",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "unit": {
+          "name": "unit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'piece'"
+        },
+        "connection": {
+          "name": "connection",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_per_unit_w": {
+          "name": "power_per_unit_w",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "safety_supply": {
+          "name": "safety_supply",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "estimate_rows_group_id_idx": {
+          "name": "estimate_rows_group_id_idx",
+          "columns": [
+            "group_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_rows_group_id_estimate_groups_id_fk": {
+          "name": "estimate_rows_group_id_estimate_groups_id_fk",
+          "tableFrom": "estimate_rows",
+          "tableTo": "estimate_groups",
+          "columnsFrom": [
+            "group_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_csv_configurations": {
+      "name": "external_csv_configurations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration": {
+          "name": "configuration",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_csv_configurations_project_id_unique": {
+          "name": "external_csv_configurations_project_id_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_csv_configurations_project_id_projects_id_fk": {
+          "name": "external_csv_configurations_project_id_projects_id_fk",
+          "tableFrom": "external_csv_configurations",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_import_batches": {
+      "name": "external_import_batches",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "import_kind": {
+          "name": "import_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "imported_at_iso": {
+          "name": "imported_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "applied_project_revision": {
+          "name": "applied_project_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_version": {
+          "name": "configuration_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_snapshot": {
+          "name": "configuration_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "original_bytes": {
+          "name": "original_bytes",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "document": {
+          "name": "document",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_import_batches_project_revision_idx": {
+          "name": "external_import_batches_project_revision_idx",
+          "columns": [
+            "project_id",
+            "applied_project_revision"
+          ],
+          "isUnique": false
+        },
+        "external_import_batches_source_imported_idx": {
+          "name": "external_import_batches_source_imported_idx",
+          "columns": [
+            "source_id",
+            "imported_at_iso"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_import_batches_project_id_projects_id_fk": {
+          "name": "external_import_batches_project_id_projects_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_import_batches_source_id_external_model_sources_id_fk": {
+          "name": "external_import_batches_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_objects": {
+      "name": "external_model_objects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ifc_guid": {
+          "name": "ifc_guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen_import_batch_id": {
+          "name": "last_seen_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_accepted_import_batch_id": {
+          "name": "last_accepted_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "accepted_source_values": {
+          "name": "accepted_source_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "planning_values": {
+          "name": "planning_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "external_room_mapping_id": {
+          "name": "external_room_mapping_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "circuit_device_row_id": {
+          "name": "circuit_device_row_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "presence_status": {
+          "name": "presence_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'present'"
+        }
+      },
+      "indexes": {
+        "external_model_objects_source_ifc_guid_unique": {
+          "name": "external_model_objects_source_ifc_guid_unique",
+          "columns": [
+            "source_id",
+            "ifc_guid"
+          ],
+          "isUnique": true
+        },
+        "external_model_objects_project_presence_idx": {
+          "name": "external_model_objects_project_presence_idx",
+          "columns": [
+            "project_id",
+            "presence_status"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_distribution_board_idx": {
+          "name": "external_model_objects_distribution_board_idx",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_circuit_device_row_idx": {
+          "name": "external_model_objects_circuit_device_row_idx",
+          "columns": [
+            "circuit_device_row_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_model_objects_project_id_projects_id_fk": {
+          "name": "external_model_objects_project_id_projects_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_source_id_external_model_sources_id_fk": {
+          "name": "external_model_objects_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_seen_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_accepted_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk": {
+          "name": "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_room_mappings",
+          "columnsFrom": [
+            "external_room_mapping_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_model_objects_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_linked_project_device_id_project_devices_id_fk": {
+          "name": "external_model_objects_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk": {
+          "name": "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "circuit_device_rows",
+          "columnsFrom": [
+            "circuit_device_row_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_sources": {
+      "name": "external_model_sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_type": {
+          "name": "source_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'revit_csv'"
+        }
+      },
+      "indexes": {
+        "external_model_sources_project_type_unique": {
+          "name": "external_model_sources_project_type_unique",
+          "columns": [
+            "project_id",
+            "source_type"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_sources_project_id_projects_id_fk": {
+          "name": "external_model_sources_project_id_projects_id_fk",
+          "tableFrom": "external_model_sources",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_room_mappings": {
+      "name": "external_room_mappings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "normalized_source_room_key": {
+          "name": "normalized_source_room_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_floor_name": {
+          "name": "source_floor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_room_number": {
+          "name": "source_room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_room_name": {
+          "name": "source_room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_distribution_board_id": {
+          "name": "default_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_room_mappings_source_key_unique": {
+          "name": "external_room_mappings_source_key_unique",
+          "columns": [
+            "source_id",
+            "normalized_source_room_key"
+          ],
+          "isUnique": true
+        },
+        "external_room_mappings_project_room_idx": {
+          "name": "external_room_mappings_project_room_idx",
+          "columns": [
+            "project_id",
+            "room_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_room_mappings_project_id_projects_id_fk": {
+          "name": "external_room_mappings_project_id_projects_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_source_id_external_model_sources_id_fk": {
+          "name": "external_room_mappings_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_room_id_rooms_id_fk": {
+          "name": "external_room_mappings_room_id_rooms_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "default_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "floors": {
+      "name": "floors",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "building_id": {
+          "name": "building_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "floors_project_id_projects_id_fk": {
+          "name": "floors_project_id_projects_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "floors_building_id_buildings_id_fk": {
+          "name": "floors_building_id_buildings_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "buildings",
+          "columnsFrom": [
+            "building_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "global_devices": {
+      "name": "global_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "installed_power_per_unit_kw": {
+          "name": "installed_power_per_unit_kw",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "demand_factor": {
+          "name": "demand_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase_count": {
+          "name": "phase_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_factor": {
+          "name": "power_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_change_sets": {
+      "name": "project_change_sets",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_revision_id": {
+          "name": "project_revision_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "command_type": {
+          "name": "command_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_schema_version": {
+          "name": "payload_schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "forward_payload_json": {
+          "name": "forward_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "inverse_payload_json": {
+          "name": "inverse_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_change_sets_revision_unique": {
+          "name": "project_change_sets_revision_unique",
+          "columns": [
+            "project_revision_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_change_sets_project_revision_id_project_revisions_id_fk": {
+          "name": "project_change_sets_project_revision_id_project_revisions_id_fk",
+          "tableFrom": "project_change_sets",
+          "tableTo": "project_revisions",
+          "columnsFrom": [
+            "project_revision_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_devices": {
+      "name": "project_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'single_phase'"
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "project_devices_project_id_projects_id_fk": {
+          "name": "project_devices_project_id_projects_id_fk",
+          "tableFrom": "project_devices",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_history_stack_entries": {
+      "name": "project_history_stack_entries",
+      "columns": {
+        "change_set_id": {
+          "name": "change_set_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stack": {
+          "name": "stack",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_history_stack_entries_position_unique": {
+          "name": "project_history_stack_entries_position_unique",
+          "columns": [
+            "project_id",
+            "stack",
+            "position"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_history_stack_entries_change_set_id_project_change_sets_id_fk": {
+          "name": "project_history_stack_entries_change_set_id_project_change_sets_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "project_change_sets",
+          "columnsFrom": [
+            "change_set_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "project_history_stack_entries_project_id_projects_id_fk": {
+          "name": "project_history_stack_entries_project_id_projects_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "project_history_stack_entries_stack_check": {
+          "name": "project_history_stack_entries_stack_check",
+          "value": "\"project_history_stack_entries\".\"stack\" in ('undo', 'redo')"
+        }
+      }
+    },
+    "project_revisions": {
+      "name": "project_revisions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision_number": {
+          "name": "revision_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_revisions_project_number_unique": {
+          "name": "project_revisions_project_number_unique",
+          "columns": [
+            "project_id",
+            "revision_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_revisions_project_id_projects_id_fk": {
+          "name": "project_revisions_project_id_projects_id_fk",
+          "tableFrom": "project_revisions",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_snapshots": {
+      "name": "project_snapshots",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_revision": {
+          "name": "source_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_version": {
+          "name": "schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'named'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "payload_json": {
+          "name": "payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_sha256": {
+          "name": "payload_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_by_actor_id": {
+          "name": "created_by_actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_snapshots_project_created_idx": {
+          "name": "project_snapshots_project_created_idx",
+          "columns": [
+            "project_id",
+            "created_at_iso"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_kind_revision_idx": {
+          "name": "project_snapshots_project_kind_revision_idx",
+          "columns": [
+            "project_id",
+            "kind",
+            "source_revision"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_name_unique": {
+          "name": "project_snapshots_project_name_unique",
+          "columns": [
+            "project_id",
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_snapshots_project_id_projects_id_fk": {
+          "name": "project_snapshots_project_id_projects_id_fk",
+          "tableFrom": "project_snapshots",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "internal_project_number": {
+          "name": "internal_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_project_number": {
+          "name": "external_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "building_owner": {
+          "name": "building_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_public_building": {
+          "name": "is_public_building",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "single_phase_voltage_v": {
+          "name": "single_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 230
+        },
+        "three_phase_voltage_v": {
+          "name": "three_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 400
+        },
+        "enabled_distribution_board_supply_types": {
+          "name": "enabled_distribution_board_supply_types",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'[\"AV\",\"SV\",\"EV\",\"USV\",\"MSR\",\"SiBe\"]'"
+        },
+        "site_address": {
+          "name": "site_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_lead": {
+          "name": "project_lead",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_editor": {
+          "name": "project_editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "current_revision": {
+          "name": "current_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "rooms": {
+      "name": "rooms",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number": {
+          "name": "room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_name": {
+          "name": "room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "area_m2": {
+          "name": "area_m2",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rooms_project_id_projects_id_fk": {
+          "name": "rooms_project_id_projects_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rooms_floor_id_floors_id_fk": {
+          "name": "rooms_floor_id_floors_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "users": {
+      "name": "users",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'user'"
+        },
+        "active": {
+          "name": "active",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "must_change_password": {
+          "name": "must_change_password",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {
+        "users_username_unique": {
+          "name": "users_username_unique",
+          "columns": [
+            "username"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index 90c3bd0..ddde03a 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -85,6 +85,13 @@
       "when": 1790531351492,
       "tag": "0011_glossy_norman_osborn",
       "breakpoints": true
+    },
+    {
+      "idx": 12,
+      "version": "6",
+      "when": 1790617581434,
+      "tag": "0012_lively_turbo",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/db/repositories/user.repository.ts b/src/db/repositories/user.repository.ts
new file mode 100644
index 0000000..071fc33
--- /dev/null
+++ b/src/db/repositories/user.repository.ts
@@ -0,0 +1,87 @@
+import crypto from "node:crypto";
+import { asc, eq } from "drizzle-orm";
+import type { AppDatabase } from "../database-context.js";
+import { users } from "../schema/users.js";
+import type { UserRole } from "../../shared/constants/user-roles.js";
+
+export interface CreateUserRow {
+  username: string;
+  name: string;
+  role: UserRole;
+  passwordHash: string;
+}
+
+export class UserRepository {
+  constructor(private readonly database: AppDatabase) {}
+
+  async list() {
+    const db = this.database;
+    return db.select().from(users).orderBy(asc(users.name));
+  }
+
+  async count() {
+    const db = this.database;
+    const rows = await db.select({ id: users.id }).from(users).limit(1);
+    return rows.length;
+  }
+
+  async findById(userId: string) {
+    const db = this.database;
+    const [row] = await db.select().from(users).where(eq(users.id, userId)).limit(1);
+    return row ?? null;
+  }
+
+  async findByUsername(username: string) {
+    const db = this.database;
+    const [row] = await db
+      .select()
+      .from(users)
+      .where(eq(users.username, username.trim().toLowerCase()))
+      .limit(1);
+    return row ?? null;
+  }
+
+  async create(input: CreateUserRow) {
+    const db = this.database;
+    const id = crypto.randomUUID();
+    await db.insert(users).values({
+      id,
+      username: input.username.trim().toLowerCase(),
+      name: input.name,
+      role: input.role,
+      passwordHash: input.passwordHash,
+      active: true,
+      mustChangePassword: true,
+    });
+    return this.findById(id);
+  }
+
+  async updateRoleAndActive(
+    userId: string,
+    patch: { role?: UserRole; active?: boolean }
+  ) {
+    const db = this.database;
+    await db
+      .update(users)
+      .set({
+        ...(patch.role !== undefined ? { role: patch.role } : {}),
+        ...(patch.active !== undefined ? { active: patch.active } : {}),
+        updatedAt: new Date(),
+      })
+      .where(eq(users.id, userId));
+    return this.findById(userId);
+  }
+
+  async setPassword(
+    userId: string,
+    passwordHash: string,
+    mustChangePassword: boolean
+  ) {
+    const db = this.database;
+    await db
+      .update(users)
+      .set({ passwordHash, mustChangePassword, updatedAt: new Date() })
+      .where(eq(users.id, userId));
+    return this.findById(userId);
+  }
+}
diff --git a/src/db/schema/users.ts b/src/db/schema/users.ts
new file mode 100644
index 0000000..825b5e1
--- /dev/null
+++ b/src/db/schema/users.ts
@@ -0,0 +1,27 @@
+import { sql } from "drizzle-orm";
+import { integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+
+export const users = sqliteTable(
+  "users",
+  {
+    id: text("id").primaryKey(),
+    username: text("username").notNull(),
+    passwordHash: text("password_hash").notNull(),
+    name: text("name").notNull(),
+    role: text("role").notNull().default("user"),
+    active: integer("active", { mode: "boolean" }).notNull().default(true),
+    mustChangePassword: integer("must_change_password", { mode: "boolean" })
+      .notNull()
+      .default(true),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+    updatedAt: integer("updated_at", { mode: "timestamp" })
+      .notNull()
+      .default(sql`(unixepoch())`),
+  },
+  (table) => [uniqueIndex("users_username_unique").on(table.username)]
+);
+
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
diff --git a/src/domain/services/user.service.ts b/src/domain/services/user.service.ts
new file mode 100644
index 0000000..55720c1
--- /dev/null
+++ b/src/domain/services/user.service.ts
@@ -0,0 +1,104 @@
+import type { UserRepository } from "../../db/repositories/user.repository.js";
+import { hashPassword, verifyPassword } from "../../server/auth/password.js";
+import type { UserRole } from "../../shared/constants/user-roles.js";
+import type { AuthConfig } from "../../server/auth/auth-config.js";
+import { createLogger } from "../../shared/logging/logger.js";
+
+const logger = createLogger("user-service");
+
+export class InvalidCredentialsError extends Error {
+  constructor() {
+    super("Anmeldung fehlgeschlagen.");
+  }
+}
+
+export class UsernameTakenError extends Error {
+  constructor() {
+    super("Dieser Anmeldename ist bereits vergeben.");
+  }
+}
+
+export class WrongPasswordError extends Error {
+  constructor() {
+    super("Das aktuelle Passwort ist falsch.");
+  }
+}
+
+export class UserService {
+  constructor(
+    private readonly repository: UserRepository,
+    private readonly authConfig: AuthConfig
+  ) {}
+
+  /**
+   * Creates the bootstrap admin from env vars, but only while the users
+   * table is still completely empty. After the first account exists, every
+   * further account is created through Config -> Benutzer, and the bootstrap
+   * env vars are ignored - that's the whole point of them being a one-time
+   * escape hatch instead of a standing backdoor.
+   */
+  async ensureBootstrapAdmin(): Promise<void> {
+    if (!this.authConfig.bootstrap) return;
+    const existingCount = await this.repository.count();
+    if (existingCount > 0) return;
+    const passwordHash = await hashPassword(this.authConfig.bootstrap.password);
+    await this.repository.create({
+      username: this.authConfig.bootstrap.username,
+      name: "Administrator",
+      role: "admin",
+      passwordHash,
+    });
+    logger.info("bootstrap admin created", {
+      username: this.authConfig.bootstrap.username,
+    });
+  }
+
+  async authenticate(username: string, password: string) {
+    const user = await this.repository.findByUsername(username);
+    // Always hash something, even for an unknown user: otherwise the
+    // response time would leak which usernames exist.
+    const passwordHash = user?.passwordHash ?? (await hashPassword("placeholder"));
+    const passwordMatches = await verifyPassword(password, passwordHash);
+    if (!user || !user.active || !passwordMatches) {
+      throw new InvalidCredentialsError();
+    }
+    return user;
+  }
+
+  async createUser(input: {
+    username: string;
+    name: string;
+    role: UserRole;
+    initialPassword: string;
+  }) {
+    const existing = await this.repository.findByUsername(input.username);
+    if (existing) throw new UsernameTakenError();
+    const passwordHash = await hashPassword(input.initialPassword);
+    return this.repository.create({
+      username: input.username,
+      name: input.name,
+      role: input.role,
+      passwordHash,
+    });
+  }
+
+  async updateRoleAndActive(userId: string, patch: { role?: UserRole; active?: boolean }) {
+    return this.repository.updateRoleAndActive(userId, patch);
+  }
+
+  /** Admin-triggered reset with a new start password; forces a change on next login. */
+  async resetPassword(userId: string, newPassword: string) {
+    const passwordHash = await hashPassword(newPassword);
+    return this.repository.setPassword(userId, passwordHash, true);
+  }
+
+  /** Self-service change by the signed-in user; clears mustChangePassword. */
+  async changeOwnPassword(userId: string, currentPassword: string, newPassword: string) {
+    const user = await this.repository.findById(userId);
+    if (!user) throw new WrongPasswordError();
+    const currentMatches = await verifyPassword(currentPassword, user.passwordHash);
+    if (!currentMatches) throw new WrongPasswordError();
+    const passwordHash = await hashPassword(newPassword);
+    return this.repository.setPassword(userId, passwordHash, false);
+  }
+}
diff --git a/src/frontend/components/AuthProvider.tsx b/src/frontend/components/AuthProvider.tsx
new file mode 100644
index 0000000..02ab833
--- /dev/null
+++ b/src/frontend/components/AuthProvider.tsx
@@ -0,0 +1,61 @@
+"use client";
+
+import { createContext, useCallback, useContext, useEffect, useState } from "react";
+import { authApi, type AuthUserDto } from "../utils/auth-api";
+
+type AuthStatus = "loading" | "signed-in" | "signed-out";
+
+interface AuthContextValue {
+  status: AuthStatus;
+  user: AuthUserDto | undefined;
+  isAdmin: boolean;
+  reload: () => Promise<void>;
+  logout: () => Promise<void>;
+}
+
+const AuthContext = createContext<AuthContextValue | null>(null);
+
+export function AuthProvider({ children }: { children: React.ReactNode }) {
+  const [status, setStatus] = useState<AuthStatus>("loading");
+  const [user, setUser] = useState<AuthUserDto | undefined>(undefined);
+
+  const reload = useCallback(async () => {
+    try {
+      const current = await authApi.me();
+      setUser(current);
+      setStatus("signed-in");
+    } catch {
+      setUser(undefined);
+      setStatus("signed-out");
+    }
+  }, []);
+
+  useEffect(() => {
+    void reload();
+  }, [reload]);
+
+  async function logout() {
+    try {
+      await authApi.logout();
+    } finally {
+      setUser(undefined);
+      setStatus("signed-out");
+    }
+  }
+
+  return (
+    <AuthContext.Provider
+      value={{ status, user, isAdmin: user?.role === "admin", reload, logout }}
+    >
+      {children}
+    </AuthContext.Provider>
+  );
+}
+
+export function useAuth(): AuthContextValue {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error("useAuth must be used within an AuthProvider");
+  }
+  return context;
+}
diff --git a/src/frontend/components/LoginGate.tsx b/src/frontend/components/LoginGate.tsx
new file mode 100644
index 0000000..23a2aeb
--- /dev/null
+++ b/src/frontend/components/LoginGate.tsx
@@ -0,0 +1,179 @@
+"use client";
+
+import { useState } from "react";
+import { authApi } from "../utils/auth-api";
+import { useAuth } from "./AuthProvider";
+
+export function LoginGate({ children }: { children: React.ReactNode }) {
+  const { status, user, reload } = useAuth();
+
+  if (status === "loading") {
+    return (
+      <div className="login-gate-screen">
+        <p>Lädt…</p>
+      </div>
+    );
+  }
+
+  if (status === "signed-out") {
+    return (
+      <div className="login-gate-screen">
+        <LoginForm onSignedIn={reload} />
+      </div>
+    );
+  }
+
+  if (user?.mustChangePassword) {
+    return (
+      <div className="login-gate-screen">
+        <ForcedPasswordChangeForm onChanged={reload} />
+      </div>
+    );
+  }
+
+  return <>{children}</>;
+}
+
+function LoginForm({ onSignedIn }: { onSignedIn: () => Promise<void> }) {
+  const [username, setUsername] = useState("");
+  const [password, setPassword] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [submitting, setSubmitting] = useState(false);
+
+  async function handleSubmit(event: React.FormEvent) {
+    event.preventDefault();
+    setSubmitting(true);
+    setError(null);
+    try {
+      await authApi.login(username, password);
+      await onSignedIn();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Anmeldung fehlgeschlagen.");
+    } finally {
+      setSubmitting(false);
+    }
+  }
+
+  return (
+    <form className="login-gate-card card" onSubmit={handleSubmit}>
+      <h1 className="h4 mb-3">Leistungsbilanz</h1>
+      <div className="mb-3">
+        <label className="form-label" htmlFor="login-username">
+          Anmeldename
+        </label>
+        <input
+          id="login-username"
+          className="form-control"
+          value={username}
+          onChange={(event) => setUsername(event.target.value)}
+          autoFocus
+          autoComplete="username"
+          required
+        />
+      </div>
+      <div className="mb-3">
+        <label className="form-label" htmlFor="login-password">
+          Passwort
+        </label>
+        <input
+          id="login-password"
+          type="password"
+          className="form-control"
+          value={password}
+          onChange={(event) => setPassword(event.target.value)}
+          autoComplete="current-password"
+          required
+        />
+      </div>
+      {error && <p className="text-danger">{error}</p>}
+      <button type="submit" className="btn btn-primary" disabled={submitting}>
+        {submitting ? "Meldet an…" : "Anmelden"}
+      </button>
+    </form>
+  );
+}
+
+function ForcedPasswordChangeForm({ onChanged }: { onChanged: () => Promise<void> }) {
+  const [currentPassword, setCurrentPassword] = useState("");
+  const [newPassword, setNewPassword] = useState("");
+  const [newPasswordRepeat, setNewPasswordRepeat] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [submitting, setSubmitting] = useState(false);
+
+  async function handleSubmit(event: React.FormEvent) {
+    event.preventDefault();
+    if (newPassword !== newPasswordRepeat) {
+      setError("Die beiden neuen Passwörter stimmen nicht überein.");
+      return;
+    }
+    setSubmitting(true);
+    setError(null);
+    try {
+      await authApi.changePassword(currentPassword, newPassword);
+      await onChanged();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Passwort konnte nicht geändert werden.");
+    } finally {
+      setSubmitting(false);
+    }
+  }
+
+  return (
+    <form className="login-gate-card card" onSubmit={handleSubmit}>
+      <h1 className="h4 mb-3">Neues Passwort setzen</h1>
+      <p className="text-body-secondary">
+        Dieser Zugang wurde mit einem Startpasswort angelegt. Bitte vor der
+        weiteren Nutzung ein eigenes Passwort vergeben.
+      </p>
+      <div className="mb-3">
+        <label className="form-label" htmlFor="force-current-password">
+          Aktuelles (Start-)Passwort
+        </label>
+        <input
+          id="force-current-password"
+          type="password"
+          className="form-control"
+          value={currentPassword}
+          onChange={(event) => setCurrentPassword(event.target.value)}
+          autoComplete="current-password"
+          autoFocus
+          required
+        />
+      </div>
+      <div className="mb-3">
+        <label className="form-label" htmlFor="force-new-password">
+          Neues Passwort
+        </label>
+        <input
+          id="force-new-password"
+          type="password"
+          className="form-control"
+          value={newPassword}
+          onChange={(event) => setNewPassword(event.target.value)}
+          autoComplete="new-password"
+          minLength={8}
+          required
+        />
+      </div>
+      <div className="mb-3">
+        <label className="form-label" htmlFor="force-new-password-repeat">
+          Neues Passwort wiederholen
+        </label>
+        <input
+          id="force-new-password-repeat"
+          type="password"
+          className="form-control"
+          value={newPasswordRepeat}
+          onChange={(event) => setNewPasswordRepeat(event.target.value)}
+          autoComplete="new-password"
+          minLength={8}
+          required
+        />
+      </div>
+      {error && <p className="text-danger">{error}</p>}
+      <button type="submit" className="btn btn-primary" disabled={submitting}>
+        {submitting ? "Speichert…" : "Passwort setzen"}
+      </button>
+    </form>
+  );
+}
diff --git a/src/frontend/components/Sidebar.tsx b/src/frontend/components/Sidebar.tsx
index 395cd7c..bb8aecd 100644
--- a/src/frontend/components/Sidebar.tsx
+++ b/src/frontend/components/Sidebar.tsx
@@ -6,6 +6,7 @@ import { useEffect, useState } from "react";
 import { listProjects } from "../utils/api";
 import type { ProjectDto } from "../types";
 import { ThemeToggle } from "./ThemeToggle";
+import { useAuth } from "./AuthProvider";
 
 // Anchors on the project overview page (/projects/[id]).
 const PROJECT_SECTIONS = [
@@ -30,6 +31,7 @@ interface SidebarProps {
 
 export function Sidebar({ isCollapsed, onToggleCollapsed }: SidebarProps) {
   const pathname = usePathname();
+  const { user, isAdmin, logout } = useAuth();
   const projectMatch = pathname?.match(PROJECT_PATH_PATTERN);
   const activeProjectId = projectMatch ? projectMatch[1] : null;
   const projectSubPath = projectMatch?.[2] ?? "";
@@ -179,8 +181,31 @@ export function Sidebar({ isCollapsed, onToggleCollapsed }: SidebarProps) {
           </>
         )}
       </nav>
+      {isAdmin && (
+        <nav className="sidebar-nav sidebar-nav-bottom">
+          <Link
+            href="/config"
+            className={pathname?.startsWith("/config") ? "sidebar-link active" : "sidebar-link"}
+            title="Config"
+          >
+            <span className="sidebar-icon">⚙</span>
+            <span className="sidebar-label">Config</span>
+          </Link>
+        </nav>
+      )}
       <div className="sidebar-footer">
+        {user && !isCollapsed && (
+          <div className="sidebar-identity" title={`Angemeldet als ${user.name}`}>
+            <span className="sidebar-identity-label">Angemeldet als</span>
+            <span className="sidebar-identity-name">{user.name}</span>
+          </div>
+        )}
         <ThemeToggle />
+        {user && (
+          <button type="button" className="sidebar-logout" onClick={() => void logout()}>
+            {isCollapsed ? "⏻" : "Abmelden"}
+          </button>
+        )}
       </div>
     </aside>
   );
diff --git a/src/frontend/utils/auth-api.ts b/src/frontend/utils/auth-api.ts
new file mode 100644
index 0000000..f7057f9
--- /dev/null
+++ b/src/frontend/utils/auth-api.ts
@@ -0,0 +1,86 @@
+// Small, self-contained fetch helper for the auth/user endpoints - kept
+// separate from the large domain api.ts so this feature doesn't have to
+// touch that file's shared `request()` internals.
+
+export type UserRole = "admin" | "user";
+
+export interface AuthStatusDto {
+  signedIn: boolean;
+  mustChangePassword: boolean;
+}
+
+export interface AuthUserDto {
+  id: string;
+  username: string;
+  name: string;
+  role: UserRole;
+  mustChangePassword: boolean;
+}
+
+export interface UserDto {
+  id: string;
+  username: string;
+  name: string;
+  role: UserRole;
+  active: boolean;
+  mustChangePassword: boolean;
+  createdAt: string;
+}
+
+export class AuthApiError extends Error {
+  constructor(
+    message: string,
+    public readonly status: number
+  ) {
+    super(message);
+  }
+}
+
+async function request<T>(url: string, init?: RequestInit): Promise<T> {
+  const response = await fetch(url, {
+    ...init,
+    headers: { "Content-Type": "application/json", ...init?.headers },
+    cache: "no-store",
+  });
+  if (!response.ok) {
+    let message = `Anfrage fehlgeschlagen (Status ${response.status})`;
+    try {
+      const body = (await response.json()) as { error?: unknown };
+      if (typeof body.error === "string") message = body.error;
+    } catch {
+      // Keep the generic message for non-JSON error responses.
+    }
+    throw new AuthApiError(message, response.status);
+  }
+  if (response.status === 204) return undefined as T;
+  return response.json() as Promise<T>;
+}
+
+export const authApi = {
+  status: () => request<AuthStatusDto>("/api/auth/status"),
+  login: (username: string, password: string) =>
+    request<AuthStatusDto>("/api/auth/login", {
+      method: "POST",
+      body: JSON.stringify({ username, password }),
+    }),
+  me: () => request<AuthUserDto>("/api/auth/me"),
+  changePassword: (currentPassword: string, newPassword: string) =>
+    request<{ changed: true }>("/api/auth/change-password", {
+      method: "POST",
+      body: JSON.stringify({ currentPassword, newPassword }),
+    }),
+  logout: () => request<{ signedOut: true }>("/api/auth/logout", { method: "POST" }),
+};
+
+export const userApi = {
+  list: () => request<UserDto[]>("/api/users"),
+  create: (input: { username: string; name: string; role: UserRole; initialPassword: string }) =>
+    request<UserDto>("/api/users", { method: "POST", body: JSON.stringify(input) }),
+  update: (userId: string, patch: { role?: UserRole; active?: boolean }) =>
+    request<UserDto>(`/api/users/${userId}`, { method: "PATCH", body: JSON.stringify(patch) }),
+  resetPassword: (userId: string, newPassword: string) =>
+    request<UserDto>(`/api/users/${userId}/reset-password`, {
+      method: "POST",
+      body: JSON.stringify({ newPassword }),
+    }),
+};
diff --git a/src/server/auth/auth-config.ts b/src/server/auth/auth-config.ts
new file mode 100644
index 0000000..d2157f4
--- /dev/null
+++ b/src/server/auth/auth-config.ts
@@ -0,0 +1,44 @@
+export const SESSION_COOKIE = "lb_session";
+
+const DEFAULT_SESSION_HOURS = 12;
+
+export interface AuthConfig {
+  sessionTtlMs: number;
+  cookieSecure: boolean;
+  /**
+   * Only used to create the very first admin when the users table is still
+   * empty - after that, every account is created through Config -> Benutzer.
+   * Unset means: no bootstrap account, the table must already have an admin.
+   */
+  bootstrap: { username: string; password: string } | null;
+}
+
+export class AuthConfigError extends Error {}
+
+export function readAuthConfig(env: NodeJS.ProcessEnv = process.env): AuthConfig {
+  const hours = Number(env.AUTH_SESSION_HOURS ?? DEFAULT_SESSION_HOURS);
+  if (!Number.isFinite(hours) || hours <= 0) {
+    throw new AuthConfigError("AUTH_SESSION_HOURS must be a positive number.");
+  }
+
+  const bootstrapUsername = (env.AUTH_BOOTSTRAP_USERNAME ?? "").trim().toLowerCase();
+  const bootstrapPassword = env.AUTH_BOOTSTRAP_PASSWORT ?? "";
+  if (Boolean(bootstrapUsername) !== Boolean(bootstrapPassword)) {
+    throw new AuthConfigError(
+      "AUTH_BOOTSTRAP_USERNAME and AUTH_BOOTSTRAP_PASSWORT belong together - set both or neither."
+    );
+  }
+  if (bootstrapPassword && bootstrapPassword.length < 12) {
+    throw new AuthConfigError(
+      "AUTH_BOOTSTRAP_PASSWORT must be at least 12 characters long."
+    );
+  }
+
+  return {
+    sessionTtlMs: hours * 60 * 60 * 1000,
+    cookieSecure: (env.COOKIE_SECURE ?? "").trim().toLowerCase() === "true",
+    bootstrap: bootstrapUsername
+      ? { username: bootstrapUsername, password: bootstrapPassword }
+      : null,
+  };
+}
diff --git a/src/server/auth/auth.middleware.ts b/src/server/auth/auth.middleware.ts
new file mode 100644
index 0000000..53a1767
--- /dev/null
+++ b/src/server/auth/auth.middleware.ts
@@ -0,0 +1,111 @@
+import type { NextFunction, Request, RequestHandler, Response } from "express";
+import { SESSION_COOKIE, type AuthConfig } from "./auth-config.js";
+import { readCookie } from "./cookie.js";
+import type { SessionStore } from "./sessions.js";
+import type { UserRepository } from "../../db/repositories/user.repository.js";
+import type { UserRole } from "../../shared/constants/user-roles.js";
+
+export interface AuthUser {
+  id: string;
+  username: string;
+  name: string;
+  role: UserRole;
+  mustChangePassword: boolean;
+}
+
+declare global {
+  namespace Express {
+    interface Request {
+      authUser?: AuthUser;
+    }
+  }
+}
+
+export function sessionIdFromRequest(req: {
+  headers: { cookie?: string | undefined };
+}): string | undefined {
+  return readCookie(req.headers.cookie, SESSION_COOKIE);
+}
+
+export async function identityFromRequest(
+  req: { headers: { cookie?: string | undefined } },
+  sessions: SessionStore,
+  users: UserRepository,
+  slideExpiry = true
+): Promise<AuthUser | undefined> {
+  const session = sessions.get(sessionIdFromRequest(req), slideExpiry);
+  if (!session) return undefined;
+  const user = await users.findById(session.userId);
+  if (!user || !user.active) return undefined;
+  return {
+    id: user.id,
+    username: user.username,
+    name: user.name,
+    role: user.role as UserRole,
+    mustChangePassword: user.mustChangePassword,
+  };
+}
+
+export function cookieOptions(authConfig: AuthConfig) {
+  return {
+    httpOnly: true,
+    sameSite: "lax" as const,
+    secure: authConfig.cookieSecure,
+    path: "/",
+    maxAge: authConfig.sessionTtlMs,
+  };
+}
+
+/** Protects /api. Only the login route and the status check stay reachable without a session. */
+export function createAuthGuard(
+  authConfig: AuthConfig,
+  sessions: SessionStore,
+  users: UserRepository,
+  openPaths: readonly string[] = ["/auth/login", "/auth/status", "/auth/logout"]
+): RequestHandler {
+  return (req: Request, res: Response, next: NextFunction) => {
+    if (openPaths.includes(req.path)) {
+      next();
+      return;
+    }
+    identityFromRequest(req, sessions, users)
+      .then((identity) => {
+        if (!identity) {
+          res.status(401).json({ error: "Nicht angemeldet." });
+          return;
+        }
+        req.authUser = identity;
+        const sessionId = sessionIdFromRequest(req);
+        if (sessionId) {
+          res.cookie(SESSION_COOKIE, sessionId, cookieOptions(authConfig));
+        }
+        next();
+      })
+      .catch(next);
+  };
+}
+
+/** Blocks everything except logout and the password change while a start password is still in use. */
+export function requirePasswordChanged(): RequestHandler {
+  const allowed = new Set(["/auth/me", "/auth/change-password", "/auth/logout"]);
+  return (req: Request, res: Response, next: NextFunction) => {
+    if (!req.authUser?.mustChangePassword || allowed.has(req.path)) {
+      next();
+      return;
+    }
+    res.status(403).json({
+      error: "Bitte zuerst ein eigenes Passwort setzen.",
+      mustChangePassword: true,
+    });
+  };
+}
+
+export function requireRole(role: UserRole): RequestHandler {
+  return (req: Request, res: Response, next: NextFunction) => {
+    if (req.authUser?.role !== role) {
+      res.status(403).json({ error: "Keine Berechtigung für diese Aktion." });
+      return;
+    }
+    next();
+  };
+}
diff --git a/src/server/auth/cookie.ts b/src/server/auth/cookie.ts
new file mode 100644
index 0000000..0204ca3
--- /dev/null
+++ b/src/server/auth/cookie.ts
@@ -0,0 +1,15 @@
+/** Reads one cookie value from a raw "Cookie" request header. No cookie-parser dependency needed for a single cookie. */
+export function readCookie(
+  header: string | undefined,
+  name: string
+): string | undefined {
+  if (!header) return undefined;
+  for (const part of header.split(";")) {
+    const separatorIndex = part.indexOf("=");
+    if (separatorIndex === -1) continue;
+    const key = part.slice(0, separatorIndex).trim();
+    if (key !== name) continue;
+    return decodeURIComponent(part.slice(separatorIndex + 1).trim());
+  }
+  return undefined;
+}
diff --git a/src/server/auth/password.ts b/src/server/auth/password.ts
new file mode 100644
index 0000000..96814e1
--- /dev/null
+++ b/src/server/auth/password.ts
@@ -0,0 +1,63 @@
+import { randomBytes, scrypt, timingSafeEqual, type ScryptOptions } from "node:crypto";
+
+const SCRYPT_N = 16384;
+const SCRYPT_R = 8;
+const SCRYPT_P = 1;
+const KEY_LENGTH = 64;
+
+// A hand-rolled wrapper instead of util.promisify(scrypt): promisify only
+// resolves to scrypt's 3-argument overload, so the 4-argument form used for
+// verification (with explicit N/r/p) doesn't type-check through it.
+function scryptAsync(
+  password: string,
+  salt: Buffer,
+  keyLength: number,
+  options?: ScryptOptions
+): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const callback = (error: Error | null, derivedKey: Buffer) => {
+      if (error) reject(error);
+      else resolve(derivedKey);
+    };
+    if (options) {
+      scrypt(password, salt, keyLength, options, callback);
+    } else {
+      scrypt(password, salt, keyLength, callback);
+    }
+  });
+}
+
+// Format: scrypt$N$r$p$saltHex$hashHex - the parameters travel with the
+// hash so they can be tuned later without invalidating existing rows.
+export async function hashPassword(password: string): Promise<string> {
+  const salt = randomBytes(16);
+  const derivedKey = await scryptAsync(password, salt, KEY_LENGTH);
+  return [
+    "scrypt",
+    SCRYPT_N,
+    SCRYPT_R,
+    SCRYPT_P,
+    salt.toString("hex"),
+    derivedKey.toString("hex"),
+  ].join("$");
+}
+
+export async function verifyPassword(
+  password: string,
+  storedHash: string
+): Promise<boolean> {
+  const parts = storedHash.split("$");
+  if (parts.length !== 6 || parts[0] !== "scrypt") return false;
+  const [, nRaw, rRaw, pRaw, saltHex, hashHex] = parts;
+  const n = Number(nRaw);
+  const r = Number(rRaw);
+  const p = Number(pRaw);
+  if (!Number.isFinite(n) || !Number.isFinite(r) || !Number.isFinite(p)) {
+    return false;
+  }
+  const salt = Buffer.from(saltHex, "hex");
+  const expected = Buffer.from(hashHex, "hex");
+  const derivedKey = await scryptAsync(password, salt, expected.length, { N: n, r, p });
+  if (derivedKey.length !== expected.length) return false;
+  return timingSafeEqual(derivedKey, expected);
+}
diff --git a/src/server/auth/sessions.ts b/src/server/auth/sessions.ts
new file mode 100644
index 0000000..501f4c4
--- /dev/null
+++ b/src/server/auth/sessions.ts
@@ -0,0 +1,55 @@
+import { randomUUID } from "node:crypto";
+
+interface Session {
+  id: string;
+  userId: string;
+  expiresAt: number;
+}
+
+/**
+ * In-memory session store. The API runs as a single container/process, so a
+ * restart clearing every session is an acceptable trade-off for the
+ * simplicity of not needing a persisted session table.
+ */
+export class SessionStore {
+  private readonly sessions = new Map<string, Session>();
+
+  constructor(private readonly ttlMs: number) {}
+
+  create(userId: string): Session {
+    const session: Session = {
+      id: randomUUID(),
+      userId,
+      expiresAt: Date.now() + this.ttlMs,
+    };
+    this.sessions.set(session.id, session);
+    return session;
+  }
+
+  /** Returns the session and slides its expiry forward, or undefined if gone/expired. */
+  get(sessionId: string | undefined, slideExpiry = true): Session | undefined {
+    if (!sessionId) return undefined;
+    const session = this.sessions.get(sessionId);
+    if (!session) return undefined;
+    if (session.expiresAt < Date.now()) {
+      this.sessions.delete(sessionId);
+      return undefined;
+    }
+    if (slideExpiry) session.expiresAt = Date.now() + this.ttlMs;
+    return session;
+  }
+
+  destroy(sessionId: string | undefined): void {
+    if (!sessionId) return;
+    this.sessions.delete(sessionId);
+  }
+
+  /** Ends every other session for a user, e.g. after a password change. */
+  destroyAllForUser(userId: string, exceptSessionId?: string): void {
+    for (const [id, session] of this.sessions) {
+      if (session.userId === userId && id !== exceptSessionId) {
+        this.sessions.delete(id);
+      }
+    }
+  }
+}
diff --git a/src/server/composition/application-repositories.ts b/src/server/composition/application-repositories.ts
index 66fdd92..846a0da 100644
--- a/src/server/composition/application-repositories.ts
+++ b/src/server/composition/application-repositories.ts
@@ -16,6 +16,7 @@ import { RoomRepository } from "../../db/repositories/room.repository.js";
 import { ExternalCsvConfigurationRepository } from "../../db/repositories/external-csv-configuration.repository.js";
 import { ExternalModelStateRepository } from "../../db/repositories/external-model-state.repository.js";
 import { DocumentBrandingRepository } from "../../db/repositories/document-branding.repository.js";
+import { UserRepository } from "../../db/repositories/user.repository.js";
 
 export const circuitDeviceRowRepository =
   new CircuitDeviceRowRepository(db);
@@ -39,3 +40,4 @@ export const externalCsvConfigurationRepository =
   new ExternalCsvConfigurationRepository(db);
 export const externalModelStateRepository = new ExternalModelStateRepository(db);
 export const documentBrandingRepository = new DocumentBrandingRepository(db);
+export const userRepository = new UserRepository(db);
diff --git a/src/server/composition/auth.ts b/src/server/composition/auth.ts
new file mode 100644
index 0000000..751f324
--- /dev/null
+++ b/src/server/composition/auth.ts
@@ -0,0 +1,8 @@
+import { readAuthConfig } from "../auth/auth-config.js";
+import { SessionStore } from "../auth/sessions.js";
+import { UserService } from "../../domain/services/user.service.js";
+import { userRepository } from "./application-repositories.js";
+
+export const authConfig = readAuthConfig();
+export const sessionStore = new SessionStore(authConfig.sessionTtlMs);
+export const userService = new UserService(userRepository, authConfig);
diff --git a/src/server/controllers/auth.controller.ts b/src/server/controllers/auth.controller.ts
new file mode 100644
index 0000000..9dabee5
--- /dev/null
+++ b/src/server/controllers/auth.controller.ts
@@ -0,0 +1,88 @@
+import type { Request, Response } from "express";
+import { changePasswordSchema, loginSchema } from "../../shared/validation/auth.schemas.js";
+import { InvalidCredentialsError, WrongPasswordError } from "../../domain/services/user.service.js";
+import { authConfig, sessionStore, userService } from "../composition/auth.js";
+import {
+  cookieOptions,
+  identityFromRequest,
+  sessionIdFromRequest,
+} from "../auth/auth.middleware.js";
+import { SESSION_COOKIE } from "../auth/auth-config.js";
+import { userRepository } from "../composition/application-repositories.js";
+
+export async function getAuthStatus(req: Request, res: Response) {
+  const identity = await identityFromRequest(req, sessionStore, userRepository);
+  const sessionId = sessionIdFromRequest(req);
+  if (identity && sessionId) {
+    res.cookie(SESSION_COOKIE, sessionId, cookieOptions(authConfig));
+  }
+  res.json({
+    signedIn: Boolean(identity),
+    mustChangePassword: identity?.mustChangePassword ?? false,
+  });
+}
+
+export async function login(req: Request, res: Response) {
+  const parsed = loginSchema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(401).json({ error: "Anmeldung fehlgeschlagen." });
+    return;
+  }
+  try {
+    const user = await userService.authenticate(parsed.data.username, parsed.data.password);
+    const session = sessionStore.create(user.id);
+    res.cookie(SESSION_COOKIE, session.id, cookieOptions(authConfig));
+    res.json({ signedIn: true, mustChangePassword: user.mustChangePassword });
+  } catch (error) {
+    if (error instanceof InvalidCredentialsError) {
+      res.status(401).json({ error: error.message });
+      return;
+    }
+    throw error;
+  }
+}
+
+export function getMe(req: Request, res: Response) {
+  const identity = req.authUser;
+  if (!identity) {
+    res.status(401).json({ error: "Nicht angemeldet." });
+    return;
+  }
+  res.json(identity);
+}
+
+export async function changePassword(req: Request, res: Response) {
+  const identity = req.authUser;
+  if (!identity) {
+    res.status(401).json({ error: "Nicht angemeldet." });
+    return;
+  }
+  const parsed = changePasswordSchema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(400).json({ error: parsed.error.flatten() });
+    return;
+  }
+  try {
+    await userService.changeOwnPassword(
+      identity.id,
+      parsed.data.currentPassword,
+      parsed.data.newPassword
+    );
+  } catch (error) {
+    if (error instanceof WrongPasswordError) {
+      res.status(400).json({ error: error.message });
+      return;
+    }
+    throw error;
+  }
+  // A password change invalidates every other session of this account; the
+  // current one stays so the change doesn't log the user out themselves.
+  sessionStore.destroyAllForUser(identity.id, sessionIdFromRequest(req));
+  res.json({ changed: true });
+}
+
+export function logout(req: Request, res: Response) {
+  sessionStore.destroy(sessionIdFromRequest(req));
+  res.clearCookie(SESSION_COOKIE, { ...cookieOptions(authConfig), maxAge: undefined });
+  res.json({ signedOut: true });
+}
diff --git a/src/server/controllers/user.controller.ts b/src/server/controllers/user.controller.ts
new file mode 100644
index 0000000..0ad3cbc
--- /dev/null
+++ b/src/server/controllers/user.controller.ts
@@ -0,0 +1,103 @@
+import type { Request, Response } from "express";
+import {
+  createUserSchema,
+  resetPasswordSchema,
+  updateUserSchema,
+} from "../../shared/validation/user.schemas.js";
+import { UsernameTakenError } from "../../domain/services/user.service.js";
+import { userService } from "../composition/auth.js";
+import { userRepository } from "../composition/application-repositories.js";
+
+// The password hash never leaves this layer.
+function toDto(user: {
+  id: string;
+  username: string;
+  name: string;
+  role: string;
+  active: boolean;
+  mustChangePassword: boolean;
+  createdAt: Date;
+}) {
+  return {
+    id: user.id,
+    username: user.username,
+    name: user.name,
+    role: user.role,
+    active: user.active,
+    mustChangePassword: user.mustChangePassword,
+    createdAt: user.createdAt,
+  };
+}
+
+export async function listUsers(_req: Request, res: Response) {
+  const rows = await userRepository.list();
+  res.json(rows.map(toDto));
+}
+
+export async function createUser(req: Request, res: Response) {
+  const parsed = createUserSchema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(400).json({ error: parsed.error.flatten() });
+    return;
+  }
+  try {
+    const created = await userService.createUser(parsed.data);
+    if (!created) {
+      res.status(500).json({ error: "Benutzer konnte nicht angelegt werden." });
+      return;
+    }
+    res.status(201).json(toDto(created));
+  } catch (error) {
+    if (error instanceof UsernameTakenError) {
+      res.status(409).json({ error: error.message });
+      return;
+    }
+    throw error;
+  }
+}
+
+export async function updateUser(req: Request, res: Response) {
+  const { userId } = req.params;
+  if (typeof userId !== "string") {
+    res.status(400).json({ error: "Invalid userId" });
+    return;
+  }
+  const parsed = updateUserSchema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(400).json({ error: parsed.error.flatten() });
+    return;
+  }
+  // The signed-in admin can't lock themselves out by deactivating or
+  // demoting their own account through this endpoint.
+  if (userId === req.authUser?.id) {
+    res.status(400).json({ error: "Der eigene Zugang kann hier nicht geändert werden." });
+    return;
+  }
+  const existing = await userRepository.findById(userId);
+  if (!existing) {
+    res.status(404).json({ error: "Benutzer nicht gefunden." });
+    return;
+  }
+  const updated = await userService.updateRoleAndActive(userId, parsed.data);
+  res.json(updated ? toDto(updated) : null);
+}
+
+export async function resetUserPassword(req: Request, res: Response) {
+  const { userId } = req.params;
+  if (typeof userId !== "string") {
+    res.status(400).json({ error: "Invalid userId" });
+    return;
+  }
+  const parsed = resetPasswordSchema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(400).json({ error: parsed.error.flatten() });
+    return;
+  }
+  const existing = await userRepository.findById(userId);
+  if (!existing) {
+    res.status(404).json({ error: "Benutzer nicht gefunden." });
+    return;
+  }
+  const updated = await userService.resetPassword(userId, parsed.data.newPassword);
+  res.json(updated ? toDto(updated) : null);
+}
diff --git a/src/server/index.ts b/src/server/index.ts
index 7cad7e3..868de79 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -4,7 +4,12 @@ import { projectDeviceRouter } from "./routes/project-device.routes.js";
 import { documentBrandingRouter } from "./routes/document-branding.routes.js";
 import { projectRouter } from "./routes/project.routes.js";
 import { cableSizingRouter } from "./routes/cable-sizing.routes.js";
+import { authRouter } from "./routes/auth.routes.js";
+import { userRouter } from "./routes/user.routes.js";
 import { errorMiddleware } from "./middleware/error.middleware.js";
+import { createAuthGuard, requirePasswordChanged } from "./auth/auth.middleware.js";
+import { authConfig, sessionStore, userService } from "./composition/auth.js";
+import { userRepository } from "./composition/application-repositories.js";
 import { createLogger, toErrorMeta } from "../shared/logging/logger.js";
 import { closeDefaultDatabase } from "../db/client.js";
 
@@ -50,6 +55,15 @@ app.get("/health", (_req, res) => {
   res.json({ ok: true });
 });
 
+// Everything below /api requires a signed-in, active user, except
+// /auth/login, /auth/status and /auth/logout (see createAuthGuard's
+// openPaths). authRouter is mounted AFTER the guard (not before) so that
+// /auth/me and /auth/change-password still get req.authUser populated by it.
+app.use("/api", createAuthGuard(authConfig, sessionStore, userRepository));
+app.use("/api", requirePasswordChanged());
+
+app.use("/api/auth", authRouter);
+app.use("/api/users", userRouter);
 app.use("/api/cable-sizing", cableSizingRouter);
 app.use("/api/projects", projectRouter);
 app.use("/api/global-devices", globalDeviceRouter);
@@ -77,40 +91,48 @@ setInterval(() => {
   });
 }, heartbeatIntervalMs).unref();
 
-const server = app.listen(port, () => {
-  logger.info("server started", { port });
-});
-
-let shuttingDown = false;
-
-function shutdown(signal: NodeJS.Signals): void {
-  if (shuttingDown) return;
-  shuttingDown = true;
-  logger.info("shutting down", { signal });
-
-  // Falls ein Request haengt oder ein Socket nicht freigegeben wird, soll der
-  // Prozess trotzdem enden, statt auf das SIGKILL des Containers zu warten.
-  const forceExit = setTimeout(() => {
-    logger.error("shutdown timed out, forcing exit");
+userService
+  .ensureBootstrapAdmin()
+  .catch((error) => {
+    logger.error("bootstrap admin setup failed", toErrorMeta(error));
     process.exit(1);
-  }, shutdownTimeoutMs);
-  forceExit.unref();
+  })
+  .then(() => {
+    const server = app.listen(port, () => {
+      logger.info("server started", { port });
+    });
 
-  server.close((error) => {
-    if (error) logger.error("http server close failed", toErrorMeta(error));
-    try {
-      closeDefaultDatabase();
-    } catch (closeError) {
-      logger.error("database close failed", toErrorMeta(closeError));
+    let shuttingDown = false;
+
+    function shutdown(signal: NodeJS.Signals): void {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      logger.info("shutting down", { signal });
+
+      // Falls ein Request haengt oder ein Socket nicht freigegeben wird, soll der
+      // Prozess trotzdem enden, statt auf das SIGKILL des Containers zu warten.
+      const forceExit = setTimeout(() => {
+        logger.error("shutdown timed out, forcing exit");
+        process.exit(1);
+      }, shutdownTimeoutMs);
+      forceExit.unref();
+
+      server.close((error) => {
+        if (error) logger.error("http server close failed", toErrorMeta(error));
+        try {
+          closeDefaultDatabase();
+        } catch (closeError) {
+          logger.error("database close failed", toErrorMeta(closeError));
+        }
+        logger.info("shutdown complete");
+        process.exit(error ? 1 : 0);
+      });
+
+      // Ohne das warten offene Keep-Alive-Verbindungen (z. B. die des
+      // Next.js-Servers) den Timeout oben aus; laufende Requests laufen weiter.
+      server.closeIdleConnections();
     }
-    logger.info("shutdown complete");
-    process.exit(error ? 1 : 0);
+
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
   });
-
-  // Ohne das warten offene Keep-Alive-Verbindungen (z. B. die des
-  // Next.js-Servers) den Timeout oben aus; laufende Requests laufen weiter.
-  server.closeIdleConnections();
-}
-
-process.on("SIGTERM", shutdown);
-process.on("SIGINT", shutdown);
diff --git a/src/server/routes/auth.routes.ts b/src/server/routes/auth.routes.ts
new file mode 100644
index 0000000..ee1cdd1
--- /dev/null
+++ b/src/server/routes/auth.routes.ts
@@ -0,0 +1,16 @@
+import { Router } from "express";
+import {
+  changePassword,
+  getAuthStatus,
+  getMe,
+  login,
+  logout,
+} from "../controllers/auth.controller.js";
+
+export const authRouter = Router();
+
+authRouter.get("/status", getAuthStatus);
+authRouter.post("/login", login);
+authRouter.get("/me", getMe);
+authRouter.post("/change-password", changePassword);
+authRouter.post("/logout", logout);
diff --git a/src/server/routes/user.routes.ts b/src/server/routes/user.routes.ts
new file mode 100644
index 0000000..a34699c
--- /dev/null
+++ b/src/server/routes/user.routes.ts
@@ -0,0 +1,16 @@
+import { Router } from "express";
+import { requireRole } from "../auth/auth.middleware.js";
+import {
+  createUser,
+  listUsers,
+  resetUserPassword,
+  updateUser,
+} from "../controllers/user.controller.js";
+
+export const userRouter = Router();
+
+userRouter.use(requireRole("admin"));
+userRouter.get("/", listUsers);
+userRouter.post("/", createUser);
+userRouter.patch("/:userId", updateUser);
+userRouter.post("/:userId/reset-password", resetUserPassword);
diff --git a/src/shared/constants/user-roles.ts b/src/shared/constants/user-roles.ts
new file mode 100644
index 0000000..f123d5f
--- /dev/null
+++ b/src/shared/constants/user-roles.ts
@@ -0,0 +1,7 @@
+export const USER_ROLES = ["admin", "user"] as const;
+export type UserRole = (typeof USER_ROLES)[number];
+
+export const USER_ROLE_LABEL: Record<UserRole, string> = {
+  admin: "Administrator",
+  user: "Benutzer",
+};
diff --git a/src/shared/validation/auth.schemas.ts b/src/shared/validation/auth.schemas.ts
new file mode 100644
index 0000000..544b052
--- /dev/null
+++ b/src/shared/validation/auth.schemas.ts
@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+export const loginSchema = z
+  .object({
+    username: z.string().trim().min(1),
+    password: z.string().min(1),
+  })
+  .strict();
+
+export const changePasswordSchema = z
+  .object({
+    currentPassword: z.string().min(1),
+    newPassword: z.string().min(8).max(200),
+  })
+  .strict();
diff --git a/src/shared/validation/user.schemas.ts b/src/shared/validation/user.schemas.ts
new file mode 100644
index 0000000..ceb8961
--- /dev/null
+++ b/src/shared/validation/user.schemas.ts
@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { USER_ROLES } from "../constants/user-roles.js";
+
+const MIN_PASSWORD_LENGTH = 8;
+
+export const createUserSchema = z
+  .object({
+    username: z.string().trim().min(1).max(200),
+    name: z.string().trim().min(1).max(200),
+    role: z.enum(USER_ROLES),
+    initialPassword: z.string().min(MIN_PASSWORD_LENGTH).max(200),
+  })
+  .strict();
+
+export const updateUserSchema = z
+  .object({
+    role: z.enum(USER_ROLES).optional(),
+    active: z.boolean().optional(),
+  })
+  .strict()
+  .refine((value) => value.role !== undefined || value.active !== undefined, {
+    message: "Nothing to update.",
+  });
+
+export const resetPasswordSchema = z
+  .object({
+    newPassword: z.string().min(MIN_PASSWORD_LENGTH).max(200),
+  })
+  .strict();
+
+export type CreateUserInput = z.infer<typeof createUserSchema>;
+export type UpdateUserInput = z.infer<typeof updateUserSchema>;
+export type ResetPasswordInput = z.infer<typeof resetPasswordSchema>;

From 8d2948cdb1efdee5e28a72b65ea9b45b9a281c72 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Mon, 28 Sep 2026 20:32:20 +0200
Subject: [PATCH 39/60] Match sidebar bottom layout to the Wochenplanung
 reference (theme toggle + Abmelden in one row)

Square icon-only theme toggle sits next to the Abmelden button in a shared
row, collapsing to just the toggle when the sidebar is collapsed - same
arrangement as pm-app's Sidebar.tsx.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 src/app/globals.css                     | 31 ++++++++++++++++++-------
 src/frontend/components/Sidebar.tsx     | 17 +++++++++-----
 src/frontend/components/ThemeToggle.tsx |  9 +++----
 3 files changed, 38 insertions(+), 19 deletions(-)

diff --git a/src/app/globals.css b/src/app/globals.css
index f670173..fec2745 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -323,23 +323,24 @@ a {
 }
 
 .sidebar-footer {
-  padding: 12px;
+  padding-top: 12px;
   border-top: 1px solid rgba(255, 255, 255, 0.12);
 }
 
+/* Square and icon-only so it fits next to Abmelden in .sidebar-bottom-row. */
 .sidebar-theme-toggle {
   display: flex;
   align-items: center;
-  gap: 10px;
-  padding: 10px 14px;
+  justify-content: center;
+  flex: 0 0 auto;
+  width: 36px;
+  height: 36px;
+  padding: 0;
   border-radius: 8px;
   color: #c7d6e0;
   font-size: 0.92rem;
-  font-weight: 500;
   border: 1px solid rgba(255, 255, 255, 0.16);
   background: rgba(255, 255, 255, 0.06);
-  width: 100%;
-  text-align: left;
   cursor: pointer;
 }
 
@@ -2747,12 +2748,20 @@ button.structure-entry-main:focus-visible {
   white-space: nowrap;
 }
 
+/* Toggle (square) and Abmelden (fills the rest) share one row. */
+.sidebar-bottom-row {
+  display: flex;
+  align-items: stretch;
+  gap: 8px;
+  padding: 0 14px 12px;
+}
+
 .sidebar-logout {
   display: flex;
   align-items: center;
   justify-content: center;
-  gap: 8px;
-  margin-top: 8px;
+  flex: 1 1 auto;
+  min-width: 0;
   padding: 8px 14px;
   border-radius: 8px;
   color: #c7d6e0;
@@ -2760,7 +2769,6 @@ button.structure-entry-main:focus-visible {
   font-weight: 500;
   border: 1px solid rgba(255, 255, 255, 0.16);
   background: transparent;
-  width: 100%;
   cursor: pointer;
 }
 
@@ -2773,6 +2781,11 @@ button.structure-entry-main:focus-visible {
   display: none;
 }
 
+.sidebar-collapsed .sidebar-bottom-row {
+  justify-content: center;
+  padding-inline: 0;
+}
+
 .login-gate-screen {
   min-height: 100vh;
   display: flex;
diff --git a/src/frontend/components/Sidebar.tsx b/src/frontend/components/Sidebar.tsx
index bb8aecd..5130d5d 100644
--- a/src/frontend/components/Sidebar.tsx
+++ b/src/frontend/components/Sidebar.tsx
@@ -200,12 +200,17 @@ export function Sidebar({ isCollapsed, onToggleCollapsed }: SidebarProps) {
             <span className="sidebar-identity-name">{user.name}</span>
           </div>
         )}
-        <ThemeToggle />
-        {user && (
-          <button type="button" className="sidebar-logout" onClick={() => void logout()}>
-            {isCollapsed ? "⏻" : "Abmelden"}
-          </button>
-        )}
+        {/* Toggle and Abmelden share one row: the toggle stays a fixed-size
+            square, Abmelden takes the rest of the width. Collapsed, only
+            the square toggle remains (centered). */}
+        <div className="sidebar-bottom-row">
+          <ThemeToggle />
+          {user && !isCollapsed && (
+            <button type="button" className="sidebar-logout" onClick={() => void logout()}>
+              Abmelden
+            </button>
+          )}
+        </div>
       </div>
     </aside>
   );
diff --git a/src/frontend/components/ThemeToggle.tsx b/src/frontend/components/ThemeToggle.tsx
index 355e0e2..2073a5e 100644
--- a/src/frontend/components/ThemeToggle.tsx
+++ b/src/frontend/components/ThemeToggle.tsx
@@ -48,16 +48,17 @@ export function ThemeToggle() {
   }
 
   return (
+    // Square, icon-only: it shares a row with the Abmelden button, so there
+    // is no room for a text label. The label moves to title/aria-label.
     <button
       aria-pressed={theme === "dark"}
       className="sidebar-theme-toggle"
       onClick={toggleTheme}
+      title={theme === "dark" ? "Hellmodus" : "Dunkelmodus"}
+      aria-label={theme === "dark" ? "Hellmodus einschalten" : "Dunkelmodus einschalten"}
       type="button"
     >
-      <span className="sidebar-icon" aria-hidden="true">
-        {theme === "dark" ? "☀" : "☾"}
-      </span>
-      {theme === "dark" ? "Hellmodus" : "Dunkelmodus"}
+      <span aria-hidden="true">{theme === "dark" ? "☀" : "☾"}</span>
     </button>
   );
 }

From b74b495fabbf80476215bbcf8a9047d5e04bc5c6 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Mon, 28 Sep 2026 20:57:58 +0200
Subject: [PATCH 40/60] Update print view and documentation for logical feeds

---
 AGENTS.md                                     | 51 +++++++----
 docs/circuit-list-editor-api.md               | 31 +++++--
 docs/circuit-list-editor-known-limitations.md | 11 ++-
 docs/current-architecture.md                  | 20 ++++-
 docs/print-view.md                            | 52 ++++++-----
 docs/spec/08-current-product-backlog.md       |  5 +-
 src/app/projects/[projectId]/print/page.tsx   | 31 ++++---
 src/frontend/print/print-document-model.ts    | 87 ++++++++++---------
 src/frontend/print/print-document.tsx         | 63 +++++++++-----
 tests/print-document-model.test.ts            | 85 +++++++++++++-----
 10 files changed, 278 insertions(+), 158 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 8312d55..9ef5b87 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -52,7 +52,8 @@ See `docs/current-architecture.md` for the complete module and request flow.
 - Device rows inside a circuit do not have their own equipment identifiers.
 - Protection and cable data belong to the circuit, not to individual devices.
 - Device-level values include quantity, power per unit, simultaneity factor, cosPhi, room data, cost group and category.
-- Circuit total power is the sum of all device rows in that circuit.
+- Circuit total power is the sum of all device rows in that circuit plus the
+  read-only loads of logically linked downstream boards on that feeder circuit.
 - Existing equipment identifiers must never be changed automatically.
 - Renumbering is always an explicit user action.
 
@@ -284,16 +285,19 @@ not change the project revision or undo/redo stacks. Restoring a server-stored
 snapshot verifies its checksum and the current-state hash, replaces supported
 project data atomically and records a new `restore` revision with a complete
 inverse command. Restore can therefore be undone and redone after a restart.
-Current snapshot schema version 8 additionally stores the optional net room
-area `rooms[].areaM2` (see `docs/building-structure.md`); versions 1 to 7 are
-upgraded with `areaM2 = null`. Version 7 stores the project buildings and
+Current snapshot schema version 9 additionally stores
+`feedingDistributionBoardId` and `feedingCircuitId` on distribution boards;
+versions 1 to 8 are upgraded with both references set to `null`. Version 8
+stores the optional net room area `rooms[].areaM2` (see
+`docs/building-structure.md`); versions 1 to 7 are upgraded with
+`areaM2 = null`. Version 7 stores the project buildings and
 `floors[].buildingId`; versions 1 to 6 are upgraded with no buildings and
 `buildingId = null`. Version 6 stores the
 distribution-board info fields `boardNumber`, `location`, `fedFrom` and
 `remark` and the project cover fields `siteAddress`, `workStage`,
 `projectLead` and `projectEditor`; all older supported versions are upgraded
 with `null` for these fields.
-Stored named and automatic snapshots of every supported version (1 to 8)
+Stored named and automatic snapshots of every supported version (1 to 9)
 remain restorable; they are upgraded while parsing. Version 5 stores
 the manual quantity share of every CircuitDeviceRow. Version 4 snapshots are upgraded with
 `manualQuantity = quantity`; they already contain the complete confirmed
@@ -309,7 +313,7 @@ project graph.
 Project-wide Revit CSV configuration uses
 `external-csv-configuration.update`. Its complete expected/target snapshot is
 persisted through the shared project-command transaction, so create, update,
-delete, Undo and Redo are revision-safe. Snapshot schema 5-8, restore and portable
+delete, Undo and Redo are revision-safe. Snapshot schema 5-9, restore and portable
 project duplication preserve the configuration; duplication remaps its internal
 id and project link.
 The project page exposes the Revit CSV modal. It edits the complete
@@ -323,7 +327,7 @@ immutable import batches with original bytes plus the classified cell matrix,
 normalized source-room mappings and external objects unique by
 `(sourceId, ifcGuid)`. Source values, planning values and overrides are separate.
 The general external-model repository is read-only; runtime writes belong only
-to typed command adapters. Snapshot/restore and portable project transfer schema versions 5-8
+to typed command adapters. Snapshot/restore and portable project transfer schema versions 5-9
 capture the complete external state and remap every internal UUID and link while
 preserving IFCGUIDs, source values, original bytes and the classified matrix.
 Import batches additionally store the monotonic project CSV configuration
@@ -463,22 +467,34 @@ snapshot contains the group, optional component protections, complete circuits,
 circuit protections and all device-row link/override metadata. Delete
 re-captures and compares the subtree before cascading; restore preserves every
 UUID in foreign-key-safe order.
-The circuit-tree read model exposes fixed `headerComponents`, group-owned
+The project-wide circuit-tree read model exposes fixed `headerComponents`, group-owned
 `components`, `footerComponents`, optional group category/number and optional
 one-to-one protection DTOs for circuits and group components. These are
 the only supported circuit-protection source; no flat compatibility fields remain.
+It resolves logical board feeds once for the complete project and adds each
+downstream board's demand after its own board simultaneity factor to the chosen
+feeding circuit as a read-only virtual row. Recursive chains and several boards
+on one circuit are supported. A board-only link affects hierarchy but adds no
+load until a feeding circuit is selected.
 Distribution-board floor assignment and a project-enabled supply type use
 `distribution-board.update`; both values are snapshot/export fields and one
 persistent undo step.
-The same command (still schema version 1, additively extended) carries the
+The same command uses schema version 2 for the logical
+`feedingDistributionBoardId` and optional matching `feedingCircuitId` together
+with the existing fields. Version-1 history commands remain executable and do
+not change logical feed references. The command rejects self-links, cycles and
+circuits from another board. The
 board info-card fields `boardNumber`, `location`, `fedFrom` and `remark`
 (migration `0007`). They are nullable, trimmed planner values; the PUT route
 only includes submitted info fields in the command and its inverse. An empty
 board with info values is no longer an unchanged setup, so history deletion of
 it is rejected like a changed simultaneity factor. Populated-subtree commands
 stored before these fields existed are normalized to `null` values
-(`normalizeDistributionBoardSubtreeSnapshot`). `fedFrom` is deliberately free
-text: the logical link to the feeding board/circuit is an open design decision.
+(`normalizeDistributionBoardSubtreeSnapshot`). `fedFrom` remains free text for
+external feeds and notes; project-board feeds use the two UUID references.
+Deleting a referenced board or feeding circuit is blocked in every direct,
+subtree and history-only removal path. Board copies retain their incoming feed,
+and project duplication remaps both references.
 These fields are intended to be prefillable from Revit parameters later, but
 only through the Phase 14 rules (preview, explicit confirmation, no silent
 overwrite).
@@ -521,9 +537,10 @@ Required operations:
   `<thead>` so it repeats on printed pages. PDF export uses the browser print
   dialog; page size, margins and "Seite x von y" come from injected named
   `@page` rules (`lb-portrait`, `lb-landscape`).
-- The board hierarchy and "Σ inkl. unterlagert" in the overview are
-  PRELIMINARY (text match of `fedFrom` against board number/name, plain sum,
-  no upstream simultaneity factor). Replace this once the feed link is modeled.
+- The board hierarchy follows logical board ids. The overview shows power
+  before board GZF and demand including linked downstream boards; it does not
+  add a second cumulative column. Board plans render downstream-board loads as
+  read-only rows. `fedFrom` groups only external root feeds.
 - Colors/fonts follow the kbp corporate design (`--pd-*` variables in
   `print-document.css`). Empty cover values are shown as
   "[ergänzen]"; the Planstände editor column shows the project's current
@@ -701,9 +718,9 @@ for the early-phase power balance by DIN 276 cost group (see
 - full electrical sizing
 - multi-user/PostgreSQL operation
 - supported production deployment
-- logical feed link between distribution boards (`fedFrom` stays free text
-  until the project owner decides whether it references a board, a feeding
-  circuit or both) and the resulting hierarchical power summation
+- second/replacement board feeds, including changeover semantics for SV/SiBe
+- Revit prefill proposals for logical board feeds through the Phase 14 preview
+  and explicit-confirmation workflow
 
 Do not implement these while working on an unrelated phase.
 
diff --git a/docs/circuit-list-editor-api.md b/docs/circuit-list-editor-api.md
index c9cd2b7..a8173f5 100644
--- a/docs/circuit-list-editor-api.md
+++ b/docs/circuit-list-editor-api.md
@@ -67,10 +67,13 @@ Prüfsumme; Ersetzen übernimmt die Grobbilanzen atomar und mit Undo/Redo,
 Duplizieren vergibt neue IDs. Transferformat 1 bleibt ohne Grobbilanzen
 importierbar.
 
-Das aktuelle Projekt-Snapshot-Schema 8 enthält außerdem die optionale
-Netto-Raumfläche `rooms[].areaM2`. Snapshot-Versionen 1–7 werden dafür mit
+Das aktuelle Projekt-Snapshot-Schema 9 enthält die logischen Einspeisungsverweise
+der Verteilungen; Versionen 1–8 werden mit leeren Verweisen hochgestuft. Schema 8
+enthält außerdem die optionale Netto-Raumfläche `rooms[].areaM2`.
+Snapshot-Versionen 1–7 werden dafür mit
 `areaM2 = null` hochgestuft. Restore, Export und Import erhalten vorhandene
-Flächen; eine eigene Transferformat-Version ist nicht nötig, weil Format 2 den
+Flächen und Einspeisungsverweise; beim Duplizieren werden Board- und Circuit-IDs
+neu zugeordnet. Eine eigene Transferformat-Version ist nicht nötig, weil Format 2 den
 versionierten Projektsnapshot einbettet.
 
 The public dispatcher supports the Circuit and CircuitDeviceRow commands
@@ -254,23 +257,30 @@ commands. Endpoints, payloads and calculation rules: `docs/estimate-balance.md`.
   - stale revisions return `409 PROJECT_REVISION_CONFLICT`
 - `PUT /projects/:projectId/distribution-boards/:distributionBoardId`
   - body:
-    `{ "floorId": null, "supplyType": "AV", "simultaneityFactor": 1, "expectedRevision": 13 }`
+    `{ "floorId": null, "supplyType": "AV", "simultaneityFactor": 1, "feedingDistributionBoardId": "board_hv", "feedingCircuitId": "circuit_out", "expectedRevision": 13 }`
   - optional info-card fields: `boardNumber` (max. 50), `location`,
     `fedFrom` (max. 200 each) and `remark` (max. 2000); strings are trimmed
     and an empty string is stored as `null`
-  - executes `distribution-board.update`; all submitted values, including the
+  - `feedingDistributionBoardId` and `feedingCircuitId` are optional nullable
+    fields. A feeding circuit requires a feeding board and must belong to it;
+    self-links and cycles are rejected. A board-only link creates hierarchy
+    without assigning its load to an upstream circuit.
+  - executes `distribution-board.update` schema version 2; all submitted values, including the
     submitted info fields, are restored together by persistent Undo/Redo
-  - `fedFrom` is free text until the logical feed link is modeled
+  - `fedFrom` remains free text for external feeds such as HAK, metering,
+    transformer or generator and for supplementary notes
 - `POST /projects/:projectId/distribution-boards/:distributionBoardId/copy`
   - body: `{ "name": "UV-02 Kopie", "expectedRevision": 14 }`
   - duplicates the complete distribution-board subtree with new owning UUIDs
-    while preserving project-device and room links
+    while preserving project-device, room and incoming feeding links
   - response includes the new `distributionBoard`, its `circuitList`, the
     revision and current history state
 - `DELETE /projects/:projectId/distribution-boards/:distributionBoardId`
   - body: `{ "expectedRevision": 15 }`
   - removes the complete, exactly captured distribution-board subtree in one
     transaction
+  - rejects deletion while another board references this board or one of its
+    circuits as a feeder; circuit and populated-group deletion use the same guard
   - response includes `distributionBoardId`, the revision and current history
     state
 - Copy and deletion use `distribution-board.insert-subtree` and
@@ -327,12 +337,17 @@ commands. Endpoints, payloads and calculation rules: `docs/estimate-balance.md`.
 
 ### Tree Endpoint
 
+- `GET /projects/:projectId/circuit-trees`
+  - returns all circuit trees for one project from one project-wide read and is
+    used by the print view and feeding-board selection
 - `GET /projects/:projectId/circuit-lists/:circuitListId/tree`
 - Purpose: returns fixed header components, grouped sections with optional
   protection components, complete circuit/device-row blocks and auxiliary
   footer components. Circuit and component protection devices use their
   separate one-to-one DTOs. Calculated row, circuit, section and board totals
-  remain included.
+  remain included. Circuit totals contain the demand of linked downstream
+  boards. `downstreamBoardLoads` exposes those contributions as read-only rows;
+  `feedingReference` resolves the current board/circuit labels by id.
 
 Response sketch:
 
diff --git a/docs/circuit-list-editor-known-limitations.md b/docs/circuit-list-editor-known-limitations.md
index 78bb44e..fdc463a 100644
--- a/docs/circuit-list-editor-known-limitations.md
+++ b/docs/circuit-list-editor-known-limitations.md
@@ -33,10 +33,13 @@
 - Protection and cable values are planner-owned manual selections. The later
   sizing/warning engine does not yet validate them against load, length or
   voltage-drop rules.
-- Distribution-board `fedFrom` is free text. The print overview derives its
-  supply structure and "Σ inkl. unterlagert" only from exact text matches with
-  board numbers/names and adds values without an upstream simultaneity factor
-  (see `docs/print-view.md`).
+- One logical incoming feed per distribution board is supported. A second or
+  replacement feed with changeover semantics (for example SV/SiBe) is still a
+  follow-up. `fedFrom` remains the free-text field for external sources and
+  supplementary notes. Revit does not yet propose logical feed links.
+- A logical link without a selected feeding circuit appears in the hierarchy,
+  but deliberately contributes no load to an upstream circuit until the planner
+  selects that circuit (see `docs/print-view.md`).
 - The print view uses a kbp corporate design derived from logo and
   presentation material. Snapshots do not record an editor, so the cover's
   Planstände list shows the project's current editor for every entry. On screen, long
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 332b6a9..920002d 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -468,8 +468,22 @@ Derselbe Befehl versioniert die Felder der Verteiler-Infokarte
 (`boardNumber`, `location`, `fedFrom`, `remark`, Migration `0007`). Die
 Infokarte liegt im Bearbeiten-Dialog der Verteilung; die Werte sind lokale
 Planungswerte und sollen später über den Revit-Abgleich nur nach Vorschau und
-ausdrücklicher Bestätigung vorbelegt werden. `fedFrom` ist vorerst Freitext.
-Snapshot-Schema 8 enthält zusätzlich die optionale Netto-Raumfläche
+ausdrücklicher Bestätigung vorbelegt werden. `fedFrom` bleibt Freitext für
+externe Einspeisungen und Hinweise.
+`distribution-board.update` verwendet Schema-Version 2 für die optionalen
+logischen Verweise `feedingDistributionBoardId` und `feedingCircuitId`.
+Version-1-Befehle aus der Historie bleiben ausführbar und verändern diese
+Verweise nicht. Der speisende Stromkreis muss zur speisenden Verteilung gehören;
+Selbstverweise und Zyklen werden abgelehnt. Löschbefehle für referenzierte
+Verteilungen und Stromkreise, einschließlich Unterbaum- und Undo-Pfaden, werden
+vor der Datenbankänderung fachlich gesperrt.
+Die projektweite Circuit-Tree-Projektion berechnet rekursiv die Lasten aller
+Verteilungen. Die Leistung einer Unterverteilung nach ihrem eigenen
+Verteiler-GZF wird als virtuelle, schreibgeschützte Zeile genau dem gewählten
+Abgang zugerechnet. Eine Verknüpfung ohne Stromkreis bildet nur die Hierarchie.
+Snapshot-Schema 9 enthält die beiden Einspeisungsverweise; Versionen 1–8 werden
+mit `null` hochgestuft. Restore und Projektduplizierung erhalten beziehungsweise
+remappen die Verweise. Snapshot-Schema 8 enthält zusätzlich die optionale Netto-Raumfläche
 `rooms[].areaM2`; Versionen 1–7 werden dafür mit `null` hochgestuft.
 Snapshot-Schema 7 enthält die Gebäude und die Gebäudezuordnung der Etagen;
 ältere Versionen werden ohne Gebäude hochgestuft.
@@ -580,7 +594,7 @@ Oberfläche: `/projects/:projectId/grobbilanz`. Details:
   `toLowerCase()` gegen das vollständige Register der Stromkreisliste und wird
   von jedem Anlage-/Umbenennungspfad für Stromkreise und Verteilerkomponenten
   aufgerufen, auch dort, wo zuvor kein Vorab-Check existierte. Snapshot- und
-  Transfer-Integration verwenden aktuell Snapshot-Schema 8. Persistente
+  Transfer-Integration verwenden aktuell Snapshot-Schema 9. Persistente
   Insert/Delete/Update-Commands für veränderliche Verteilerkomponenten,
   Gruppen einschließlich befüllter Unterbäume sowie vollständige
   Gruppensortierung sind integriert. Der Editor zeigt die geschützte Struktur
diff --git a/docs/print-view.md b/docs/print-view.md
index eba91ed..a843030 100644
--- a/docs/print-view.md
+++ b/docs/print-view.md
@@ -5,8 +5,9 @@ Die Aktionen für Büroangaben und Logo speichern dagegen globale Einstellungen.
 Projekt- und Verteilerangaben werden in den jeweiligen Bearbeitungsdialogen
 über Projektbefehle mit Undo/Redo gepflegt.
 
-Beim Laden werden die Projektrevisionen aller Stromkreislisten und ein
-abschließend erneut gelesener Projektstand verglichen. Ändert sich das Projekt
+Beim Laden werden alle Stromkreislisten in einer projektweiten Abfrage gelesen;
+deren Projektrevision und ein abschließend erneut gelesener Projektstand werden
+verglichen. Ändert sich das Projekt
 währenddessen, wird statt eines gemischten Datenstands eine Aufforderung zum
 Neuladen angezeigt. Eine bereits geladene Seitenansicht aktualisiert sich nicht
 automatisch bei späteren Änderungen in einem anderen Tab.
@@ -31,12 +32,14 @@ automatisch bei späteren Änderungen in einem anderen Tab.
    erscheinen als orangefarbenes „[ergänzen]“.
 2. **Verteilerübersicht (quer)** – Versorgungsstruktur und Tabelle je
    Verteiler mit Stromkreisanzahl, P<sub>inst</sub> (Anzahl × Leistung je
-   Stück), P<sub>Geräte</sub> (mit Geräte-GZF), Verteiler-GZF,
-   P<sub>gl</sub>, I<sub>B</sub> und „Σ inkl. unterlagert“.
+   Stück, nur lokale Geräte), Leistung vor Verteiler-GZF einschließlich
+   gespeister Unterverteilungen, Verteiler-GZF, P<sub>gl</sub> einschließlich
+   Unterverteilungen und I<sub>B</sub>. Die Hierarchie folgt den logischen IDs.
 3. **Verteilerpläne (quer, je Verteiler)** – Titelleiste mit
    Verteilernummer, Bezeichnung, Örtlichkeit, Netzart, „Gespeist von“ und
    P<sub>gl</sub>; darunter Kopfkomponenten, Gruppen, Stromkreise
-   (mehrzeilige mit Sammelzeile und eingerückten Gerätezeilen),
+   (mehrzeilige mit Sammelzeile, eingerückten Gerätezeilen und
+   schreibgeschützten Unterverteilungszeilen),
    Gruppensummen und Verteilersumme. Fehlende Kabelangaben sind als „offen“
    markiert. Die Titelleiste steht im Tabellenkopf und wiederholt sich beim
    Drucken auf Folgeseiten.
@@ -46,19 +49,25 @@ Seitenformat, Ränder und „Seite x von y“ kommen beim Drucken aus benannten
 einfügt. Die Bildschirmansicht zeigt Blätter in Papiergröße; die exakte
 Seitenaufteilung langer Verteilerpläne entsteht erst beim Drucken.
 
-## Vorläufige Punkte
+## Berechnung und offene Punkte
 
-- **Einspeisung / Hierarchie:** `fedFrom` ist Freitext. Die Übersicht ordnet
-  einen Verteiler nur dann unter, wenn der Text eindeutig der Nummer oder
-  Bezeichnung eines anderen Verteilers entspricht (ohne Beachtung von
-  Groß-/Kleinschreibung und äußeren Leerzeichen). Mehrdeutige Treffer bleiben
-  ohne Zuordnung; „Σ inkl. unterlagert“ ist
-  eine einfache Summe ohne übergeordneten GZF. Die fachliche Verknüpfung
-  (Verteiler und/oder speisender Stromkreis) und die Summierungslogik sind
-  offen.
-- **I<sub>B</sub>** ist ein symmetrischer Drehstromwert
-  S / (√3 · U<sub>3~</sub>) mit S aus P / cos φ je Gerätezeile
-  (fehlendes cos φ = 1) und Verteiler-GZF.
+- **Einspeisung / Hierarchie:** `feedingDistributionBoardId` bestimmt die
+  Hierarchie. Ist zusätzlich `feedingCircuitId` gesetzt, fließt die Leistung
+  der Unterverteilung nach deren eigenem Verteiler-GZF als virtuelle Last in
+  genau diesen Abgang ein. Ketten werden rekursiv berechnet; mehrere
+  Unterverteilungen an einem Abgang sind erlaubt. Ohne Abgang bleibt es bei der
+  Hierarchie ohne Leistungsaufschlag. `fedFrom` bezeichnet nur externe Quellen
+  oder ergänzende Hinweise.
+- **Keine Doppelzählung:** Die Abgangs- und Verteilersummen enthalten die
+  Unterverteilungsleistung bereits. Deshalb gibt es keine zusätzliche Spalte
+  „Σ inkl. unterlagert“. Die Summenzeile verwendet für hierarchische Leistungen
+  nur Wurzelverteilungen; P<sub>inst</sub> summiert weiterhin die lokalen Geräte.
+- **I<sub>B</sub>:** S entsteht aus Σ(P / cos φ) für Geräte und den wirksamen
+  cos φ der Unterverteilungen, jeweils mit dem fachlich zugehörigen GZF. Bei
+  einem 1-phasigen speisenden Abgang gilt I = S / U<sub>1~</sub>, sonst
+  I = S / (√3 · U<sub>3~</sub>). Für externe oder nur bis zur Verteilung
+  bekannte Einspeisungen bleibt die bisherige Darstellung als symmetrischer
+  Drehstromwert bestehen.
 - **Corporate Design:** Farben (`--pd-*` in
   `src/frontend/print/print-document.css`) und Schrift (Arial) sind aus Logo
   und kbp-Präsentationsmaterial abgeleitet und werden durch die offizielle
@@ -118,10 +127,11 @@ ihren Wert.
 
 ## Bestehende Datenbanken
 
-Vor dem Anwenden der additiven Migrationen `0007` und `0008` eine verifizierte
+Vor dem Anwenden der additiven Migrationen einschließlich `0012` eine verifizierte
 Datenbanksicherung mit `npm run db:backup` erstellen. Die neuen Projekt- und
 Verteilerfelder bleiben bei bestehenden Datensätzen zunächst leer (`null`).
-Snapshot-Schema 6 enthält beide Feldgruppen; die unterstützten Versionen 1–5
-werden beim Lesen hochgestuft. Restore und Projektkopie erhalten die neuen
-Angaben. Globale Büroangaben und Logo gehören zur Datenbanksicherung, nicht
+Snapshot-Schema 9 enthält zusätzlich die logischen Einspeisungsverweise; die
+unterstützten Versionen 1–8 werden mit leeren Verweisen hochgestuft. Restore und
+Projektkopie erhalten beziehungsweise remappen die neuen Angaben. Globale
+Büroangaben und Logo gehören zur Datenbanksicherung, nicht
 zum logischen Projektsnapshot oder Projekttransfer.
diff --git a/docs/spec/08-current-product-backlog.md b/docs/spec/08-current-product-backlog.md
index d31eecc..c0a2720 100644
--- a/docs/spec/08-current-product-backlog.md
+++ b/docs/spec/08-current-product-backlog.md
@@ -149,9 +149,10 @@ The pre-release cleanup established the following compatibility boundary:
 - [x] Rough power balance for LPH 2/3 by cost group, including the comparison
   with the detailed balance and the explicit copy of one row as a
   ProjectDevice.
+- [x] Logical distribution-board feed link with an optional feeding circuit,
+  recursive load rollup and deletion guards (#3).
 
-Open follow-ups (Gitea issues): logical feed link between distribution boards
-(#3), bill of quantities export (#5), area-based loads in W/m² for
+Open follow-ups (Gitea issues): bill of quantities export (#5), area-based loads in W/m² for
 ProjectDevices and device rows (#20).
 
 ## Recommended Sequence
diff --git a/src/app/projects/[projectId]/print/page.tsx b/src/app/projects/[projectId]/print/page.tsx
index dcbe7b2..7762875 100644
--- a/src/app/projects/[projectId]/print/page.tsx
+++ b/src/app/projects/[projectId]/print/page.tsx
@@ -7,10 +7,9 @@ import "../../../../frontend/print/print-document.css";
 import {
   deleteDocumentLogo,
   documentLogoUrl,
-  getCircuitTree,
+  getProjectCircuitTrees,
   getDocumentBranding,
   getProject,
-  listCircuitLists,
   listDistributionBoards,
   listFloors,
   listProjectSnapshots,
@@ -31,7 +30,7 @@ import {
 import { PrintDocument } from "../../../../frontend/print/print-document";
 import {
   assertPrintRevisionConsistency,
-  buildPreliminaryBoardHierarchy,
+  buildBoardHierarchy,
   summarizePrintBoard,
   type PrintBoardSummary,
 } from "../../../../frontend/print/print-document-model";
@@ -89,17 +88,20 @@ export default function ProjectPrintPage() {
     }
     let cancelled = false;
     async function load() {
-      const [project, boards, circuitLists, floors, snapshots, branding] =
+      const [project, boards, projectTrees, floors, snapshots, branding] =
         await Promise.all([
           getProject(projectId),
           listDistributionBoards(projectId),
-          listCircuitLists(projectId),
+          getProjectCircuitTrees(projectId),
           listFloors(projectId),
           listProjectSnapshots(projectId),
           getDocumentBranding(),
         ]);
       const floorNameById = new Map(floors.map((floor) => [floor.id, floor.name]));
-      const summaries = await Promise.all(
+      const treeByBoardId = new Map(
+        projectTrees.trees.map((tree) => [tree.distributionBoardId, tree])
+      );
+      const summaries =
         [...boards]
           .sort(
             (left, right) =>
@@ -107,20 +109,17 @@ export default function ProjectPrintPage() {
               boardSortCollator.compare(left.name, right.name)
           )
           .flatMap((board) => {
-            const circuitList = circuitLists.find(
-              (list) => list.distributionBoardId === board.id
-            );
-            return circuitList ? [{ board, circuitList }] : [];
+            const tree = treeByBoardId.get(board.id);
+            return tree ? [{ board, tree }] : [];
           })
-          .map(async ({ board, circuitList }) =>
+          .map(({ board, tree }) =>
             summarizePrintBoard({
               board,
-              circuitListId: circuitList.id,
-              tree: await getCircuitTree(projectId, circuitList.id),
+              circuitListId: tree.circuitListId,
+              tree,
               floorName: board.floorId ? floorNameById.get(board.floorId) ?? null : null,
             })
-          )
-      );
+          );
       const finalProject = await getProject(projectId);
       assertPrintRevisionConsistency(project.currentRevision, summaries, finalProject.currentRevision);
       if (cancelled) {
@@ -148,7 +147,7 @@ export default function ProjectPrintPage() {
   }, [projectId]);
 
   const entries = useMemo(
-    () => (data ? buildPreliminaryBoardHierarchy(data.summaries) : []),
+    () => (data ? buildBoardHierarchy(data.summaries) : []),
     [data]
   );
   const stand = useMemo(
diff --git a/src/frontend/print/print-document-model.ts b/src/frontend/print/print-document-model.ts
index abe08fe..d3e4724 100644
--- a/src/frontend/print/print-document-model.ts
+++ b/src/frontend/print/print-document-model.ts
@@ -19,14 +19,14 @@ export interface PrintBoardSummary {
   circuitCount: number;
   /** Σ quantity × power per unit, without any simultaneity factor. */
   installedPowerKw: number;
-  /** Σ row totals, i.e. with the device-row simultaneity factors. */
-  devicePowerKw: number;
+  /** Device-row demand plus downstream-board demand before this board's GZF. */
+  powerBeforeBoardSimultaneityKw: number;
   simultaneityFactor: number;
-  /** Device power with the board simultaneity factor applied. */
+  /** Total active power with this board's simultaneity factor applied. */
   demandPowerKw: number;
   /**
-   * Symmetrical three-phase design current from the apparent power
-   * S = Σ(row total / cos φ) × board GZF. A missing cos φ counts as 1.
+   * Design current from the apparent power including downstream boards.
+   * The selected feeder circuit determines whether one or three phases apply.
    */
   designCurrentA: number;
 }
@@ -46,8 +46,13 @@ export function summarizePrintBoard(input: {
       circuitCount += 1;
       for (const row of circuit.deviceRows) {
         installedPowerKw += row.quantity * row.powerPerUnit;
-        apparentPowerKva += row.rowTotalPower / (row.cosPhi || 1);
       }
+      apparentPowerKva +=
+        circuit.circuitApparentPower ??
+        circuit.deviceRows.reduce(
+          (sum, row) => sum + row.rowTotalPower / (row.cosPhi || 1),
+          0
+        );
     }
   }
   const simultaneityFactor = tree.distributionBoardSimultaneityFactor;
@@ -55,12 +60,13 @@ export function summarizePrintBoard(input: {
     ...input,
     circuitCount,
     installedPowerKw,
-    devicePowerKw: tree.distributionBoardTotalPower,
+    powerBeforeBoardSimultaneityKw: tree.distributionBoardTotalPower,
     simultaneityFactor,
     demandPowerKw: tree.distributionBoardTotalPowerWithSimultaneityFactor,
-    designCurrentA:
-      (apparentPowerKva * simultaneityFactor * 1000) /
-      (Math.sqrt(3) * tree.threePhaseVoltageV),
+    designCurrentA: calculateDesignCurrent(
+      apparentPowerKva * simultaneityFactor,
+      tree
+    ),
   };
 }
 
@@ -68,8 +74,6 @@ export interface PrintBoardHierarchyEntry {
   summary: PrintBoardSummary;
   depth: number;
   parentBoardId: string | null;
-  /** Own demand plus the plain sum of all resolved downstream boards. */
-  cumulatedDemandPowerKw: number;
 }
 
 export function assertPrintRevisionConsistency(
@@ -82,31 +86,21 @@ export function assertPrintRevisionConsistency(
   }
 }
 
-/**
- * PRELIMINARY: `fedFrom` is free text until the logical feed link is
- * decided. A board is shown below another board only when its `fedFrom`
- * text equals that board's number or name (case-insensitive). The
- * cumulated value is a plain sum without an upstream simultaneity factor.
- * Unresolved texts and cycles keep a board at the top level.
- */
-export function buildPreliminaryBoardHierarchy(
+export function buildBoardHierarchy(
   summaries: PrintBoardSummary[]
 ): PrintBoardHierarchyEntry[] {
-  const normalize = (value: string | null) =>
-    value?.trim().toLocaleLowerCase("de") || null;
+  const summaryById = new Map(
+    summaries.map((summary) => [summary.board.id, summary])
+  );
   const parentById = new Map<string, string | null>();
   for (const summary of summaries) {
-    const fedFrom = normalize(summary.board.fedFrom);
-    const candidates = fedFrom
-      ? summaries.filter(
-          (candidate) =>
-            candidate !== summary &&
-            (normalize(candidate.board.boardNumber) === fedFrom ||
-              normalize(candidate.board.name) === fedFrom)
-        )
-      : [];
-    const parent = candidates.length === 1 ? candidates[0] : undefined;
-    parentById.set(summary.board.id, parent?.board.id ?? null);
+    const parentId = summary.board.feedingDistributionBoardId;
+    parentById.set(
+      summary.board.id,
+      parentId && parentId !== summary.board.id && summaryById.has(parentId)
+        ? parentId
+        : null
+    );
   }
   for (const summary of summaries) {
     const visited = new Set<string>([summary.board.id]);
@@ -125,20 +119,12 @@ export function buildPreliminaryBoardHierarchy(
     summaries.filter(
       (summary) => parentById.get(summary.board.id) === boardId
     );
-  const cumulated = (summary: PrintBoardSummary): number =>
-    summary.demandPowerKw +
-    childrenOf(summary.board.id).reduce(
-      (sum, child) => sum + cumulated(child),
-      0
-    );
-
   const entries: PrintBoardHierarchyEntry[] = [];
   const walk = (summary: PrintBoardSummary, depth: number) => {
     entries.push({
       summary,
       depth,
       parentBoardId: parentById.get(summary.board.id) ?? null,
-      cumulatedDemandPowerKw: cumulated(summary),
     });
     childrenOf(summary.board.id).forEach((child) => walk(child, depth + 1));
   };
@@ -146,6 +132,25 @@ export function buildPreliminaryBoardHierarchy(
   return entries;
 }
 
+export function formatFeedingReference(summary: PrintBoardSummary): string {
+  const reference = summary.tree.feedingReference;
+  if (!reference) return summary.board.fedFrom ?? "–";
+  return `${
+    reference.distributionBoardNumber ?? reference.distributionBoardName
+  }${reference.circuitEquipmentIdentifier ?? ""}`;
+}
+
+function calculateDesignCurrent(
+  apparentPowerKva: number,
+  tree: CircuitTreeResponseDto
+) {
+  const category = tree.feedingReference?.circuitCategory;
+  return category === "lighting" || category === "single_phase"
+    ? (apparentPowerKva * 1000) / tree.singlePhaseVoltageV
+    : (apparentPowerKva * 1000) /
+        (Math.sqrt(3) * tree.threePhaseVoltageV);
+}
+
 const kilowattFormat = new Intl.NumberFormat("de-DE", {
   minimumFractionDigits: 2,
   maximumFractionDigits: 2,
diff --git a/src/frontend/print/print-document.tsx b/src/frontend/print/print-document.tsx
index c39b4ba..5a0152b 100644
--- a/src/frontend/print/print-document.tsx
+++ b/src/frontend/print/print-document.tsx
@@ -13,6 +13,7 @@ import {
   formatCircuitCable,
   formatCurrent,
   formatFactor,
+  formatFeedingReference,
   formatKilowatt,
   formatProtectionDevice,
   formatUnitPower,
@@ -269,8 +270,8 @@ function OverviewSheet({
   stand: string;
 }) {
   const roots = entries.filter((entry) => entry.parentBoardId === null);
-  // Top-level boards whose "fed from" text names no other board are grouped
-  // below that text as an external feed (e.g. "HAK / Zähleranlage").
+  // Root boards may still carry an external feed description such as
+  // "HAK / Zähleranlage"; logical board links determine the actual tree.
   const feedGroups = new Map<string, PrintBoardHierarchyEntry[]>();
   for (const root of roots) {
     const feed = root.summary.board.fedFrom ?? "";
@@ -320,11 +321,10 @@ function OverviewSheet({
                 <th>Nr.</th><th>Bezeichnung</th><th>Örtlichkeit</th><th>Etage</th><th>Netz</th><th>Gespeist von</th>
                 <th className="pd-r">SK</th>
                 <th className="pd-r">P<sub>inst</sub><br />[kW]</th>
-                <th className="pd-r">P<sub>Geräte</sub><br />[kW]</th>
+                <th className="pd-r">P vor Vert.-GZF<br />[kW]</th>
                 <th className="pd-r">GZF<br />Vert.</th>
-                <th className="pd-r">P<sub>gl</sub><br />[kW]</th>
+                <th className="pd-r">P<sub>gl</sub> inkl. UV<br />[kW]</th>
                 <th className="pd-r">I<sub>B</sub><br />[A]</th>
-                <th className="pd-r">Σ inkl.<br />unterlagert [kW]</th>
               </tr>
             </thead>
             <tbody>
@@ -340,41 +340,45 @@ function OverviewSheet({
                     <td>{board.location ?? "–"}</td>
                     <td>{entry.summary.floorName ?? "–"}</td>
                     <td>{board.supplyType ?? "–"}</td>
-                    <td>{board.fedFrom ?? "–"}</td>
+                    <td>{formatFeedingReference(entry.summary)}</td>
                     <td className="pd-r">{entry.summary.circuitCount}</td>
                     <td className="pd-r">{formatKilowatt(entry.summary.installedPowerKw)}</td>
-                    <td className="pd-r">{formatKilowatt(entry.summary.devicePowerKw)}</td>
+                    <td className="pd-r">{formatKilowatt(entry.summary.powerBeforeBoardSimultaneityKw)}</td>
                     <td className="pd-r">{formatFactor(entry.summary.simultaneityFactor)}</td>
                     <td className="pd-r"><strong>{formatKilowatt(entry.summary.demandPowerKw)}</strong></td>
                     <td className="pd-r">{formatCurrent(entry.summary.designCurrentA)}</td>
-                    <td className="pd-r">{formatKilowatt(entry.cumulatedDemandPowerKw)}</td>
                   </tr>
                 );
               })}
             </tbody>
             <tfoot>
               <tr>
-                <td colSpan={7}>Summe aller Verteiler (ohne übergeordneten GZF)</td>
+                <td colSpan={7}>Summe der Einspeisungen</td>
                 <td className="pd-r">{formatKilowatt(sum((entry) => entry.summary.installedPowerKw))}</td>
-                <td className="pd-r">{formatKilowatt(sum((entry) => entry.summary.devicePowerKw))}</td>
-                <td />
-                <td className="pd-r">{formatKilowatt(sum((entry) => entry.summary.demandPowerKw))}</td>
+                <td className="pd-r">{formatKilowatt(sum((entry) =>
+                  entry.parentBoardId === null
+                    ? entry.summary.powerBeforeBoardSimultaneityKw
+                    : 0
+                ))}</td>
                 <td />
+                <td className="pd-r">{formatKilowatt(sum((entry) =>
+                  entry.parentBoardId === null ? entry.summary.demandPowerKw : 0
+                ))}</td>
                 <td />
               </tr>
             </tfoot>
           </table>
           <p className="pd-note">
-            <strong>Vorläufig:</strong> „Gespeist von“ ist noch ein Freitextfeld. Struktur und
-            „Σ inkl. unterlagert“ werden nur über eindeutig passende Verteilernummern bzw.
-            -bezeichnungen zugeordnet und einfach addiert (kein übergeordneter GZF).
-            Mehrdeutige Angaben bleiben ohne Zuordnung. Die fachliche
-            Verknüpfung und Summierung folgt.
+            Die Struktur folgt den logischen Verknüpfungen. Eine Unterverteilung
+            wird im gewählten Abgang mit ihrer Leistung nach eigenem
+            Verteiler-GZF berücksichtigt. Ohne gewählten Abgang erscheint sie
+            nur in der Hierarchie.
           </p>
           <p className="pd-legend">
-            P<sub>inst</sub> = Anzahl × Leistung je Stück · P<sub>Geräte</sub> = mit Geräte-GZF ·
-            P<sub>gl</sub> = mit Verteiler-GZF · I<sub>B</sub> = S / (√3 · {project.threePhaseVoltageV} V),
-            S aus cos φ je Gerätezeile
+            P<sub>inst</sub> = lokale Geräte ohne GZF · P vor Vert.-GZF =
+            Geräte-GZF einschließlich gespeister Unterverteilungen · P<sub>gl</sub> =
+            zusätzlich mit Verteiler-GZF · I<sub>B</sub> aus S und der Phasenart
+            des speisenden Abgangs
           </p>
         </div>
       </div>
@@ -404,6 +408,7 @@ function ComponentRow({ component }: { component: CircuitTreeComponentDto }) {
 
 function CircuitRows({ circuit }: { circuit: CircuitTreeCircuitDto }) {
   const rows = circuit.deviceRows;
+  const downstreamBoards = circuit.downstreamBoardLoads ?? [];
   const circuitCells = (
     <>
       <td>{formatProtectionDevice(circuit.protectionDevice) ?? <Open />}</td>
@@ -414,7 +419,7 @@ function CircuitRows({ circuit }: { circuit: CircuitTreeCircuitDto }) {
       <td>{circuit.remark ?? ""}</td>
     </>
   );
-  if (rows.length === 0) {
+  if (rows.length === 0 && downstreamBoards.length === 0) {
     return (
       <tr className="pd-circuit pd-reserve">
         <td className="pd-bmk">{circuit.equipmentIdentifier}</td>
@@ -426,7 +431,7 @@ function CircuitRows({ circuit }: { circuit: CircuitTreeCircuitDto }) {
       </tr>
     );
   }
-  if (rows.length === 1) {
+  if (rows.length === 1 && downstreamBoards.length === 0) {
     const row = rows[0];
     const title = circuit.displayName ?? row.displayName;
     return (
@@ -468,6 +473,16 @@ function CircuitRows({ circuit }: { circuit: CircuitTreeCircuitDto }) {
           <td colSpan={4} />
         </tr>
       ))}
+      {downstreamBoards.map((load) => (
+        <tr className="pd-device" key={`downstream:${load.distributionBoardId}`}>
+          <td />
+          <td>Unterverteilung {load.boardNumber ?? load.name}</td>
+          <td>–</td>
+          <td /><td /><td />
+          <td className="pd-r">{formatKilowatt(load.activePowerKw)}</td>
+          <td colSpan={4}>Automatisch aus der verknüpften Verteilung</td>
+        </tr>
+      ))}
     </>
   );
 }
@@ -501,7 +516,7 @@ function BoardPlanSheet({
                 rows={[
                   ["Örtlichkeit", [board.location, summary.floorName].filter(Boolean).join(" · ") || "–"],
                   ["Netzart", board.supplyType ?? "–"],
-                  ["Gespeist von", board.fedFrom ?? "–"],
+                  ["Gespeist von", formatFeedingReference(summary)],
                   [
                     <>P<sub>gl</sub></>,
                     <>
@@ -542,7 +557,7 @@ function BoardPlanSheet({
             <td colSpan={5}>
               Summe Verteiler (P<sub>inst</sub> {formatKilowatt(summary.installedPowerKw)} kW)
             </td>
-            <td className="pd-r">{formatKilowatt(summary.devicePowerKw)}</td>
+            <td className="pd-r">{formatKilowatt(summary.powerBeforeBoardSimultaneityKw)}</td>
             <td colSpan={4} />
           </tr>
           <tr>
diff --git a/tests/print-document-model.test.ts b/tests/print-document-model.test.ts
index 80a5200..ba91c3e 100644
--- a/tests/print-document-model.test.ts
+++ b/tests/print-document-model.test.ts
@@ -2,7 +2,8 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import {
   assertPrintRevisionConsistency,
-  buildPreliminaryBoardHierarchy,
+  buildBoardHierarchy,
+  formatFeedingReference,
   formatCircuitCable,
   formatProtectionDevice,
   summarizePrintBoard,
@@ -27,6 +28,8 @@ function board(
     location: null,
     fedFrom: null,
     remark: null,
+    feedingDistributionBoardId: null,
+    feedingCircuitId: null,
     ...info,
   };
 }
@@ -52,6 +55,8 @@ function tree(
   const total = deviceRows.reduce((sum, row) => sum + row.rowTotalPower, 0);
   return {
     circuitListId: "list",
+    distributionBoardId: "board",
+    distributionBoardName: "Board",
     currentRevision: 1,
     singlePhaseVoltageV: 230,
     threePhaseVoltageV: 400,
@@ -79,7 +84,13 @@ function tree(
             sortOrder: 1,
             isReserve: false,
             circuitTotalPower: total,
+            circuitApparentPower: deviceRows.reduce(
+              (sum, row) => sum + row.rowTotalPower / (row.cosPhi || 1),
+              0
+            ),
+            circuitCosPhi: 1,
             deviceRows,
+            downstreamBoardLoads: [],
           },
         ],
       },
@@ -117,16 +128,15 @@ describe("print document model", () => {
     assert.equal(formatCircuitCable(circuit), null);
   });
 
-  it("does not guess a parent when feed text matches more than one board", () => {
+  it("does not derive hierarchy from the external free text", () => {
     const summaries = [
       summary("a", { boardNumber: "HV" }, 2),
       summary("b", { name: "HV" }, 3),
       summary("uv", { fedFrom: " hv " }, 1),
     ];
     for (const ordered of [summaries, [...summaries].reverse()]) {
-      const entries = buildPreliminaryBoardHierarchy(ordered);
+      const entries = buildBoardHierarchy(ordered);
       assert.ok(entries.every((entry) => entry.parentBoardId === null));
-      assert.equal(entries.reduce((sum, entry) => sum + entry.cumulatedDemandPowerKw, 0), 6);
     }
   });
 
@@ -145,17 +155,39 @@ describe("print document model", () => {
     });
     assert.equal(result.circuitCount, 1);
     assert.equal(result.installedPowerKw, 14);
-    assert.equal(result.devicePowerKw, 10);
+    assert.equal(result.powerBeforeBoardSimultaneityKw, 10);
     assert.equal(result.demandPowerKw, 5);
     // S = (4 / 0.8 + 6 / 1) × 0.5 = 5.5 kVA → I = 5500 / (√3 · 400)
     assert.ok(Math.abs(result.designCurrentA - 5500 / (Math.sqrt(3) * 400)) < 1e-9);
   });
 
-  it("nests boards by matching free-text feed and sums downstream demand", () => {
-    const entries = buildPreliminaryBoardHierarchy([
+  it("uses the selected one-phase feeder circuit for the design current", () => {
+    const inputTree = tree([
+      { quantity: 1, powerPerUnit: 2.3, simultaneityFactor: 1, cosPhi: 1 },
+    ]);
+    inputTree.feedingReference = {
+      distributionBoardId: "hv",
+      circuitListId: "hv-list",
+      distributionBoardName: "Hauptverteilung",
+      distributionBoardNumber: "NSHV",
+      circuitId: "out",
+      circuitEquipmentIdentifier: "-2F1.1",
+      circuitCategory: "single_phase",
+    };
+    const result = summarizePrintBoard({
+      board: board("uv"),
+      circuitListId: "uv",
+      floorName: null,
+      tree: inputTree,
+    });
+    assert.ok(Math.abs(result.designCurrentA - 10) < 1e-9);
+  });
+
+  it("nests boards by their logical feeding references", () => {
+    const entries = buildBoardHierarchy([
       summary("hv", { boardNumber: "HV 0.1", fedFrom: "HAK" }, 10),
-      summary("uv-a", { boardNumber: "UV 1.1", fedFrom: " hv 0.1 " }, 4),
-      summary("uv-b", { boardNumber: "UV 1.2", fedFrom: "UV 1.1" }, 2),
+      summary("uv-a", { boardNumber: "UV 1.1", feedingDistributionBoardId: "hv" }, 4),
+      summary("uv-b", { boardNumber: "UV 1.2", feedingDistributionBoardId: "uv-a" }, 2),
       summary("uv-c", { name: "UV-C", fedFrom: "unbekannt" }, 1),
     ]);
     assert.deepEqual(
@@ -163,28 +195,37 @@ describe("print document model", () => {
         entry.summary.board.id,
         entry.depth,
         entry.parentBoardId,
-        entry.cumulatedDemandPowerKw,
       ]),
       [
-        ["hv", 0, null, 16],
-        ["uv-a", 1, "hv", 6],
-        ["uv-b", 2, "uv-a", 2],
-        ["uv-c", 0, null, 1],
+        ["hv", 0, null],
+        ["uv-a", 1, "hv"],
+        ["uv-b", 2, "uv-a"],
+        ["uv-c", 0, null],
       ]
     );
   });
 
-  it("keeps boards with cyclic feed texts at the top level", () => {
-    const entries = buildPreliminaryBoardHierarchy([
-      summary("a", { boardNumber: "A", fedFrom: "B" }, 1),
-      summary("b", { boardNumber: "B", fedFrom: "A" }, 1),
+  it("keeps malformed cyclic logical links visible at the top level", () => {
+    const entries = buildBoardHierarchy([
+      summary("a", { boardNumber: "A", feedingDistributionBoardId: "b" }, 1),
+      summary("b", { boardNumber: "B", feedingDistributionBoardId: "a" }, 1),
     ]);
     assert.equal(entries.length, 2);
     assert.ok(entries.some((entry) => entry.parentBoardId === null));
-    assert.equal(
-      entries.reduce((sum, entry) => sum + (entry.depth === 0 ? entry.cumulatedDemandPowerKw : 0), 0),
-      2
-    );
+  });
+
+  it("formats the resolved feeding board and circuit instead of free text", () => {
+    const value = summary("uv", { fedFrom: "Alttext" }, 1);
+    value.tree.feedingReference = {
+      distributionBoardId: "hv",
+      circuitListId: "hv-list",
+      distributionBoardName: "Hauptverteilung",
+      distributionBoardNumber: "NSHV",
+      circuitId: "out",
+      circuitEquipmentIdentifier: "-3F1.1",
+      circuitCategory: "three_phase",
+    };
+    assert.equal(formatFeedingReference(value), "NSHV-3F1.1");
   });
 
   it("formats protection devices for the plan table", () => {

From 5073d9342a287ec6d961f53b5178b7ca344ef3f2 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Mon, 28 Sep 2026 21:30:30 +0200
Subject: [PATCH 41/60] Harden authentication and put filter toggle and fields
 in one row

Security: per-username login throttling, constant-time unknown-user check,
Sec-Fetch-Site CSRF guard for writes, session rotation on login and
password change, absolute session lifetime, sessions ended on reset and
deactivation, last-admin protection, input length caps, ASCII usernames,
clickjacking headers. Covered by tests/authentication.test.ts.

Filter panel: toggle, fields and count share one row to save space.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 compose.yaml                              |   1 +
 docs/authentication.md                    |  28 ++-
 next.config.mjs                           |  16 ++
 src/app/globals.css                       |  21 +-
 src/domain/services/user.service.ts       |  67 +++++-
 src/frontend/components/filter-panel.tsx  |  47 ++--
 src/server/auth/auth-config.ts            |  23 +-
 src/server/auth/auth.middleware.ts        |  48 +++-
 src/server/auth/cookie.ts                 |   7 +-
 src/server/auth/login-throttle.ts         |  53 +++++
 src/server/auth/sessions.ts               |  60 ++++-
 src/server/composition/auth.ts            |   5 +-
 src/server/controllers/auth.controller.ts |  47 ++--
 src/server/controllers/user.controller.ts |  32 ++-
 src/server/index.ts                       |   8 +-
 src/shared/validation/auth.schemas.ts     |  13 +-
 src/shared/validation/user.schemas.ts     |  23 +-
 tests/authentication.test.ts              | 265 ++++++++++++++++++++++
 18 files changed, 683 insertions(+), 81 deletions(-)
 create mode 100644 src/server/auth/login-throttle.ts
 create mode 100644 tests/authentication.test.ts

diff --git a/compose.yaml b/compose.yaml
index bab8c3d..2a2eecd 100644
--- a/compose.yaml
+++ b/compose.yaml
@@ -51,6 +51,7 @@ services:
       AUTH_BOOTSTRAP_USERNAME: "${AUTH_BOOTSTRAP_USERNAME:-}"
       AUTH_BOOTSTRAP_PASSWORT: "${AUTH_BOOTSTRAP_PASSWORT:-}"
       AUTH_SESSION_HOURS: "${AUTH_SESSION_HOURS:-12}"
+      AUTH_SESSION_MAX_DAYS: "${AUTH_SESSION_MAX_DAYS:-7}"
       COOKIE_SECURE: "${COOKIE_SECURE:-false}"
     # Nicht auf dem Host veroeffentlicht: die API wird ueber den
     # Next.js-Rewrite im Web-Dienst erreicht.
diff --git a/docs/authentication.md b/docs/authentication.md
index 3d197cf..13a9f72 100644
--- a/docs/authentication.md
+++ b/docs/authentication.md
@@ -33,7 +33,8 @@ Verknüpfung mit einer Mitarbeiter-/Personen-Stammdatentabelle.
   `username`, `passwordHash` (scrypt, `src/server/auth/password.ts`), `name`,
   `role`, `active`, `mustChangePassword`.
 - **Sessions:** In-Memory-Store (`src/server/auth/sessions.ts`), Cookie
-  `lb_session`, sliding expiry (`AUTH_SESSION_HOURS`, Standard 12h). Ein
+  `lb_session`, sliding expiry (`AUTH_SESSION_HOURS`, Standard 12h) mit
+  absoluter Obergrenze (`AUTH_SESSION_MAX_DAYS`, Standard 7). Ein
   Neustart der API beendet alle Sessions – für einen Single-Container-Dienst
   ein akzeptabler Kompromiss gegenüber einer persistierten Session-Tabelle.
 - **Middleware:** `src/server/auth/auth.middleware.ts` schützt `/api/*`
@@ -44,6 +45,28 @@ Verknüpfung mit einer Mitarbeiter-/Personen-Stammdatentabelle.
   (`src/app/layout.tsx`) zeigt Login- bzw. Passwortformular, solange nicht
   angemeldet bzw. `mustChangePassword` gesetzt ist, sonst die App.
 
+## Schutzmechanismen
+
+| Angriff | Schutz |
+|---|---|
+| Passwort-Raten (online) | `LoginThrottle`: 5 Fehlversuche je Anmeldename in 15 min → HTTP 429 bis das Fenster abläuft. Schlüssel ist der Name, nicht die IP (alle Anfragen kommen über den Next-Rewrite mit derselben Quell-IP). |
+| Passwort-Raten (offline, DB-Diebstahl) | scrypt (N=16384, r=8, p=1), eigenes Salt je Hash |
+| Nutzernamen ausspähen (Timing) | Unbekannte Namen werden gegen einen festen Dummy-Hash geprüft – immer genau ein scrypt-Lauf; einheitliche Fehlermeldung |
+| CSRF | SameSite=Lax **plus** `requireSameOriginForWrites`: schreibende Anfragen nur mit `Sec-Fetch-Site: same-origin`. Nötig, weil andere Dienste auf demselben Host (andere Ports) als „same-site“ gelten |
+| Session-Fixation | Neue Session-ID bei jedem Login und nach jedem Passwortwechsel |
+| Gestohlenes Cookie | httpOnly; gleitende Laufzeit (`AUTH_SESSION_HOURS`, 12 h) **und** harte Obergrenze (`AUTH_SESSION_MAX_DAYS`, 7 Tage) |
+| Kompromittiertes Konto | Passwort-Reset und Deaktivieren beenden sofort alle Sessions des Kontos; Passwortwechsel beendet alle anderen |
+| Aussperren | Der letzte aktive Admin kann weder herabgestuft noch deaktiviert werden; eigener Zugang ist in der Liste gesperrt |
+| Rechteausweitung / Mass Assignment | Rolle kommt aus der DB, nie aus der Anfrage; zod-Schemas mit `.strict()` |
+| DoS über riesige Passwörter | Längengrenzen (Name 100, Passwort 200 Zeichen) vor scrypt |
+| Look-alike-Namen | Anmeldename nur `a-z 0-9 . _ @ -`, klein geschrieben |
+| Clickjacking | `X-Frame-Options: SAMEORIGIN`, `frame-ancestors 'self'` (next.config.mjs) |
+| Speicherwachstum | Max. 20 Sessions je Nutzer, periodisches Aufräumen abgelaufener Sessions, Throttle-Tabelle begrenzt |
+
+**Nicht durch Code lösbar:** Ohne TLS gehen Passwort und Session-Cookie im
+Klartext durchs Netz. Für Zugriff außerhalb des LANs HTTPS über einen
+Reverse-Proxy vorschalten und `COOKIE_SECURE=true` setzen.
+
 ## Bootstrap-Admin
 
 `AUTH_BOOTSTRAP_USERNAME` / `AUTH_BOOTSTRAP_PASSWORT` (Env-Variablen, siehe
@@ -56,6 +79,7 @@ in `compose.yaml` selbst.
 ## Bewusst nicht umgesetzt (Stand jetzt)
 
 - Konfigurierbare Rechte-Matrix statt fixer `admin`/`user`-Rollen
-- Konten-Sperre nach Fehlversuchen
+- Dauerhafte Konten-Sperre nach Fehlversuchen (es gibt nur die zeitlich
+  begrenzte Drosselung, siehe oben)
 - E-Mail-/Einmal-Link-Passwortvergabe, OIDC/Entra-Anmeldung
 - Verknüpfung von Zugängen mit einer Mitarbeiter-Stammdatentabelle
diff --git a/next.config.mjs b/next.config.mjs
index e0610b9..a6cb01e 100644
--- a/next.config.mjs
+++ b/next.config.mjs
@@ -11,6 +11,22 @@ const nextConfig = {
   typescript: {
     tsconfigPath: "./tsconfig.next.json",
   },
+  poweredByHeader: false,
+  // Clickjacking: the Config pages hold admin actions, so no foreign page
+  // may frame the app. Same-origin framing stays allowed.
+  async headers() {
+    return [
+      {
+        source: "/:path*",
+        headers: [
+          { key: "X-Frame-Options", value: "SAMEORIGIN" },
+          { key: "Content-Security-Policy", value: "frame-ancestors 'self'" },
+          { key: "X-Content-Type-Options", value: "nosniff" },
+          { key: "Referrer-Policy", value: "same-origin" },
+        ],
+      },
+    ];
+  },
   async rewrites() {
     return [
       {
diff --git a/src/app/globals.css b/src/app/globals.css
index fec2745..0f1a642 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -452,13 +452,25 @@ a {
   background: var(--color-bg);
 }
 
-.filter-panel-header {
+.filter-panel-row {
   display: flex;
   align-items: center;
   gap: 10px;
 }
 
-.filter-panel-header .filter-panel-toggle {
+/* Expanded: the fields carry a label above their input, so toggle and
+   count sit on the input line (bottom) instead of the label line. */
+.filter-panel-row-expanded {
+  align-items: flex-end;
+}
+
+.filter-panel-row-expanded .filter-panel-toggle,
+.filter-panel-row-expanded .filter-panel-count {
+  margin-bottom: calc((2.1rem - 24px) / 2);
+}
+
+.filter-panel-row .filter-panel-toggle {
+  flex: 0 0 auto;
   width: 24px;
   height: 24px;
   padding: 0;
@@ -468,7 +480,7 @@ a {
   color: var(--color-ink-soft);
 }
 
-.filter-panel-header .filter-panel-toggle:hover {
+.filter-panel-row .filter-panel-toggle:hover {
   background: var(--color-surface);
 }
 
@@ -503,10 +515,11 @@ a {
 
 .filter-bar {
   display: flex;
+  flex: 1 1 auto;
+  min-width: 0;
   flex-wrap: wrap;
   align-items: flex-end;
   gap: var(--space-sm) var(--space-md);
-  margin-top: 0.5rem;
 }
 
 .filter-bar-field,
diff --git a/src/domain/services/user.service.ts b/src/domain/services/user.service.ts
index 55720c1..0968d02 100644
--- a/src/domain/services/user.service.ts
+++ b/src/domain/services/user.service.ts
@@ -24,7 +24,29 @@ export class WrongPasswordError extends Error {
   }
 }
 
+export class PasswordUnchangedError extends Error {
+  constructor() {
+    super("Das neue Passwort muss sich vom bisherigen unterscheiden.");
+  }
+}
+
+export class LastAdminError extends Error {
+  constructor() {
+    super("Es muss mindestens ein aktiver Administrator bleiben.");
+  }
+}
+
+function isUniqueConstraintError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    (error as { code?: unknown }).code === "SQLITE_CONSTRAINT_UNIQUE"
+  );
+}
+
 export class UserService {
+  private dummyHash: Promise<string> | null = null;
+
   constructor(
     private readonly repository: UserRepository,
     private readonly authConfig: AuthConfig
@@ -38,6 +60,9 @@ export class UserService {
    * escape hatch instead of a standing backdoor.
    */
   async ensureBootstrapAdmin(): Promise<void> {
+    // Warm the dummy hash at startup so even the first unknown-user login
+    // costs one scrypt run, not two.
+    await this.getDummyHash();
     if (!this.authConfig.bootstrap) return;
     const existingCount = await this.repository.count();
     if (existingCount > 0) return;
@@ -55,9 +80,10 @@ export class UserService {
 
   async authenticate(username: string, password: string) {
     const user = await this.repository.findByUsername(username);
-    // Always hash something, even for an unknown user: otherwise the
-    // response time would leak which usernames exist.
-    const passwordHash = user?.passwordHash ?? (await hashPassword("placeholder"));
+    // Unknown users are verified against a fixed dummy hash: exactly one
+    // scrypt run either way, so response time doesn't reveal which usernames
+    // exist.
+    const passwordHash = user?.passwordHash ?? (await this.getDummyHash());
     const passwordMatches = await verifyPassword(password, passwordHash);
     if (!user || !user.active || !passwordMatches) {
       throw new InvalidCredentialsError();
@@ -74,15 +100,32 @@ export class UserService {
     const existing = await this.repository.findByUsername(input.username);
     if (existing) throw new UsernameTakenError();
     const passwordHash = await hashPassword(input.initialPassword);
-    return this.repository.create({
-      username: input.username,
-      name: input.name,
-      role: input.role,
-      passwordHash,
-    });
+    try {
+      return await this.repository.create({
+        username: input.username,
+        name: input.name,
+        role: input.role,
+        passwordHash,
+      });
+    } catch (error) {
+      // Two admins creating the same name at once: the unique index decides.
+      if (isUniqueConstraintError(error)) throw new UsernameTakenError();
+      throw error;
+    }
   }
 
   async updateRoleAndActive(userId: string, patch: { role?: UserRole; active?: boolean }) {
+    const removesAdmin = patch.role === "user" || patch.active === false;
+    if (removesAdmin) {
+      const target = await this.repository.findById(userId);
+      const targetIsActiveAdmin = target?.role === "admin" && target.active;
+      if (targetIsActiveAdmin) {
+        const activeAdmins = (await this.repository.list()).filter(
+          (user) => user.role === "admin" && user.active
+        );
+        if (activeAdmins.length <= 1) throw new LastAdminError();
+      }
+    }
     return this.repository.updateRoleAndActive(userId, patch);
   }
 
@@ -98,7 +141,13 @@ export class UserService {
     if (!user) throw new WrongPasswordError();
     const currentMatches = await verifyPassword(currentPassword, user.passwordHash);
     if (!currentMatches) throw new WrongPasswordError();
+    if (newPassword === currentPassword) throw new PasswordUnchangedError();
     const passwordHash = await hashPassword(newPassword);
     return this.repository.setPassword(userId, passwordHash, false);
   }
+
+  private getDummyHash(): Promise<string> {
+    this.dummyHash ??= hashPassword("dummy-password-for-constant-time-login");
+    return this.dummyHash;
+  }
 }
diff --git a/src/frontend/components/filter-panel.tsx b/src/frontend/components/filter-panel.tsx
index afa1fde..9c9923b 100644
--- a/src/frontend/components/filter-panel.tsx
+++ b/src/frontend/components/filter-panel.tsx
@@ -55,9 +55,15 @@ export function CollapsibleFilterPanel({
     writeCollapsed(storageKey, next);
   }
 
+  // One row: toggle, then either the "Filter" label (collapsed) or the filter
+  // fields themselves (expanded), and the count at the right edge.
   return (
     <div className="filter-panel">
-      <div className="filter-panel-header">
+      <div
+        className={
+          isCollapsed ? "filter-panel-row" : "filter-panel-row filter-panel-row-expanded"
+        }
+      >
         <IconButton
           ariaControls={barId}
           ariaExpanded={!isCollapsed}
@@ -66,29 +72,30 @@ export function CollapsibleFilterPanel({
           label={isCollapsed ? "Filter einblenden" : "Filter ausblenden"}
           onClick={toggleCollapsed}
         />
-        <span className="filter-panel-label">Filter</span>
-        {isCollapsed && isFilterActive ? (
-          <span className="filter-panel-badge">Filter aktiv</span>
-        ) : null}
+        {isCollapsed ? (
+          <>
+            <span className="filter-panel-label">Filter</span>
+            {isFilterActive ? <span className="filter-panel-badge">Filter aktiv</span> : null}
+          </>
+        ) : (
+          <div className="filter-bar" id={barId}>
+            {children}
+            {isFilterActive ? (
+              <IconButton
+                className="filter-bar-reset"
+                icon={FilterX}
+                label="Zurücksetzen"
+                onClick={onReset}
+                showLabel
+                title="Alle Filter zurücksetzen"
+              />
+            ) : null}
+          </div>
+        )}
         <span aria-live="polite" className="filter-panel-count">
           {visibleCount} von {totalCount}
         </span>
       </div>
-      {isCollapsed ? null : (
-        <div className="filter-bar" id={barId}>
-          {children}
-          {isFilterActive ? (
-            <IconButton
-              className="filter-bar-reset"
-              icon={FilterX}
-              label="Zurücksetzen"
-              onClick={onReset}
-              showLabel
-              title="Alle Filter zurücksetzen"
-            />
-          ) : null}
-        </div>
-      )}
     </div>
   );
 }
diff --git a/src/server/auth/auth-config.ts b/src/server/auth/auth-config.ts
index d2157f4..c4c3b44 100644
--- a/src/server/auth/auth-config.ts
+++ b/src/server/auth/auth-config.ts
@@ -1,9 +1,13 @@
 export const SESSION_COOKIE = "lb_session";
 
 const DEFAULT_SESSION_HOURS = 12;
+const DEFAULT_SESSION_MAX_DAYS = 7;
 
 export interface AuthConfig {
+  /** Idle timeout; slides forward on activity. */
   sessionTtlMs: number;
+  /** Hard upper bound for a session, regardless of activity. */
+  sessionMaxAgeMs: number;
   cookieSecure: boolean;
   /**
    * Only used to create the very first admin when the users table is still
@@ -15,11 +19,21 @@ export interface AuthConfig {
 
 export class AuthConfigError extends Error {}
 
-export function readAuthConfig(env: NodeJS.ProcessEnv = process.env): AuthConfig {
-  const hours = Number(env.AUTH_SESSION_HOURS ?? DEFAULT_SESSION_HOURS);
-  if (!Number.isFinite(hours) || hours <= 0) {
-    throw new AuthConfigError("AUTH_SESSION_HOURS must be a positive number.");
+function positiveNumber(raw: string | undefined, fallback: number, name: string): number {
+  const value = Number(raw ?? fallback);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new AuthConfigError(`${name} must be a positive number.`);
   }
+  return value;
+}
+
+export function readAuthConfig(env: NodeJS.ProcessEnv = process.env): AuthConfig {
+  const hours = positiveNumber(env.AUTH_SESSION_HOURS, DEFAULT_SESSION_HOURS, "AUTH_SESSION_HOURS");
+  const maxDays = positiveNumber(
+    env.AUTH_SESSION_MAX_DAYS,
+    DEFAULT_SESSION_MAX_DAYS,
+    "AUTH_SESSION_MAX_DAYS"
+  );
 
   const bootstrapUsername = (env.AUTH_BOOTSTRAP_USERNAME ?? "").trim().toLowerCase();
   const bootstrapPassword = env.AUTH_BOOTSTRAP_PASSWORT ?? "";
@@ -36,6 +50,7 @@ export function readAuthConfig(env: NodeJS.ProcessEnv = process.env): AuthConfig
 
   return {
     sessionTtlMs: hours * 60 * 60 * 1000,
+    sessionMaxAgeMs: maxDays * 24 * 60 * 60 * 1000,
     cookieSecure: (env.COOKIE_SECURE ?? "").trim().toLowerCase() === "true",
     bootstrap: bootstrapUsername
       ? { username: bootstrapUsername, password: bootstrapPassword }
diff --git a/src/server/auth/auth.middleware.ts b/src/server/auth/auth.middleware.ts
index 53a1767..ce65bfb 100644
--- a/src/server/auth/auth.middleware.ts
+++ b/src/server/auth/auth.middleware.ts
@@ -46,17 +46,55 @@ export async function identityFromRequest(
   };
 }
 
-export function cookieOptions(authConfig: AuthConfig) {
+export function cookieOptions(authConfig: AuthConfig, maxAgeMs: number) {
   return {
     httpOnly: true,
     sameSite: "lax" as const,
     secure: authConfig.cookieSecure,
     path: "/",
-    maxAge: authConfig.sessionTtlMs,
+    maxAge: maxAgeMs,
   };
 }
 
-/** Protects /api. Only the login route and the status check stay reachable without a session. */
+/** Sets the session cookie with the same remaining lifetime the server uses. */
+export function setSessionCookie(
+  res: Response,
+  authConfig: AuthConfig,
+  sessions: SessionStore,
+  sessionId: string
+): void {
+  const session = sessions.get(sessionId, false);
+  if (!session) return;
+  res.cookie(SESSION_COOKIE, sessionId, cookieOptions(authConfig, sessions.remainingMs(session)));
+}
+
+const SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+
+/**
+ * CSRF defense for cookie-authenticated writes.
+ *
+ * SameSite=Lax alone is not enough here: every other service on the same
+ * host (other ports of the same IP) counts as "same-site" and would get the
+ * cookie attached. Browsers send Sec-Fetch-Site on every request, so a write
+ * is only accepted from the app's own origin. Clients without the header
+ * (curl, scripts) carry no ambient browser cookie and are not a CSRF vector.
+ */
+export function requireSameOriginForWrites(): RequestHandler {
+  return (req: Request, res: Response, next: NextFunction) => {
+    if (SAFE_METHODS.has(req.method)) {
+      next();
+      return;
+    }
+    const fetchSite = req.headers["sec-fetch-site"];
+    if (fetchSite === undefined || fetchSite === "same-origin" || fetchSite === "none") {
+      next();
+      return;
+    }
+    res.status(403).json({ error: "Anfrage von fremder Herkunft abgelehnt." });
+  };
+}
+
+/** Protects /api. Only login, status and logout stay reachable without a session. */
 export function createAuthGuard(
   authConfig: AuthConfig,
   sessions: SessionStore,
@@ -76,9 +114,7 @@ export function createAuthGuard(
         }
         req.authUser = identity;
         const sessionId = sessionIdFromRequest(req);
-        if (sessionId) {
-          res.cookie(SESSION_COOKIE, sessionId, cookieOptions(authConfig));
-        }
+        if (sessionId) setSessionCookie(res, authConfig, sessions, sessionId);
         next();
       })
       .catch(next);
diff --git a/src/server/auth/cookie.ts b/src/server/auth/cookie.ts
index 0204ca3..344ff65 100644
--- a/src/server/auth/cookie.ts
+++ b/src/server/auth/cookie.ts
@@ -9,7 +9,12 @@ export function readCookie(
     if (separatorIndex === -1) continue;
     const key = part.slice(0, separatorIndex).trim();
     if (key !== name) continue;
-    return decodeURIComponent(part.slice(separatorIndex + 1).trim());
+    // A malformed value must read as "no session", not throw into a 500.
+    try {
+      return decodeURIComponent(part.slice(separatorIndex + 1).trim());
+    } catch {
+      return undefined;
+    }
   }
   return undefined;
 }
diff --git a/src/server/auth/login-throttle.ts b/src/server/auth/login-throttle.ts
new file mode 100644
index 0000000..d81719b
--- /dev/null
+++ b/src/server/auth/login-throttle.ts
@@ -0,0 +1,53 @@
+/**
+ * Slows down online password guessing per username.
+ *
+ * Keyed by username, not by client IP: every request reaches the API through
+ * the Next.js rewrite, so the socket address is always the web container.
+ * The trade-off is that someone who knows a username can keep that account
+ * temporarily throttled; the block lifts by itself after the window, so it is
+ * a nuisance, not a lockout.
+ */
+export class LoginThrottle {
+  private readonly failures = new Map<string, number[]>();
+
+  constructor(
+    private readonly maxFailures = 5,
+    private readonly windowMs = 15 * 60 * 1000,
+    private readonly maxTrackedKeys = 10_000,
+    private readonly now: () => number = Date.now
+  ) {}
+
+  /** Milliseconds until another attempt is allowed; 0 = allowed now. */
+  retryAfterMs(username: string): number {
+    const recent = this.recentFailures(this.key(username));
+    if (recent.length < this.maxFailures) return 0;
+    return Math.max(0, recent[0] + this.windowMs - this.now());
+  }
+
+  recordFailure(username: string): void {
+    const key = this.key(username);
+    const recent = this.recentFailures(key);
+    recent.push(this.now());
+    if (!this.failures.has(key) && this.failures.size >= this.maxTrackedKeys) {
+      // Bound memory under a flood of random usernames: drop the oldest key.
+      const oldestKey = this.failures.keys().next().value;
+      if (oldestKey !== undefined) this.failures.delete(oldestKey);
+    }
+    this.failures.set(key, recent);
+  }
+
+  recordSuccess(username: string): void {
+    this.failures.delete(this.key(username));
+  }
+
+  private recentFailures(key: string): number[] {
+    const cutoff = this.now() - this.windowMs;
+    const recent = (this.failures.get(key) ?? []).filter((time) => time > cutoff);
+    if (recent.length === 0) this.failures.delete(key);
+    return recent;
+  }
+
+  private key(username: string): string {
+    return username.trim().toLowerCase();
+  }
+}
diff --git a/src/server/auth/sessions.ts b/src/server/auth/sessions.ts
index 501f4c4..9ee1fe0 100644
--- a/src/server/auth/sessions.ts
+++ b/src/server/auth/sessions.ts
@@ -3,24 +3,50 @@ import { randomUUID } from "node:crypto";
 interface Session {
   id: string;
   userId: string;
+  createdAt: number;
   expiresAt: number;
 }
 
+const MAX_SESSIONS_PER_USER = 20;
+const SWEEP_INTERVAL_MS = 10 * 60 * 1000;
+
 /**
  * In-memory session store. The API runs as a single container/process, so a
  * restart clearing every session is an acceptable trade-off for the
  * simplicity of not needing a persisted session table.
+ *
+ * Sessions slide forward on activity (`idleTtlMs`) but never outlive
+ * `absoluteTtlMs` - otherwise a stolen cookie could be kept alive forever.
  */
 export class SessionStore {
   private readonly sessions = new Map<string, Session>();
 
-  constructor(private readonly ttlMs: number) {}
+  constructor(
+    private readonly idleTtlMs: number,
+    private readonly absoluteTtlMs: number,
+    private readonly now: () => number = Date.now
+  ) {}
+
+  /** Removes expired sessions; unreferenced ones would otherwise pile up. */
+  startSweeping(): void {
+    setInterval(() => this.sweep(), SWEEP_INTERVAL_MS).unref();
+  }
+
+  sweep(): void {
+    const now = this.now();
+    for (const [id, session] of this.sessions) {
+      if (this.isExpired(session, now)) this.sessions.delete(id);
+    }
+  }
 
   create(userId: string): Session {
+    this.enforcePerUserLimit(userId);
+    const now = this.now();
     const session: Session = {
       id: randomUUID(),
       userId,
-      expiresAt: Date.now() + this.ttlMs,
+      createdAt: now,
+      expiresAt: Math.min(now + this.idleTtlMs, now + this.absoluteTtlMs),
     };
     this.sessions.set(session.id, session);
     return session;
@@ -31,20 +57,28 @@ export class SessionStore {
     if (!sessionId) return undefined;
     const session = this.sessions.get(sessionId);
     if (!session) return undefined;
-    if (session.expiresAt < Date.now()) {
+    const now = this.now();
+    if (this.isExpired(session, now)) {
       this.sessions.delete(sessionId);
       return undefined;
     }
-    if (slideExpiry) session.expiresAt = Date.now() + this.ttlMs;
+    if (slideExpiry) {
+      session.expiresAt = Math.min(now + this.idleTtlMs, session.createdAt + this.absoluteTtlMs);
+    }
     return session;
   }
 
+  /** Remaining lifetime, used as cookie max-age so browser and server agree. */
+  remainingMs(session: Session): number {
+    return Math.max(0, session.expiresAt - this.now());
+  }
+
   destroy(sessionId: string | undefined): void {
     if (!sessionId) return;
     this.sessions.delete(sessionId);
   }
 
-  /** Ends every other session for a user, e.g. after a password change. */
+  /** Ends every session of a user, optionally except one (e.g. the caller's own). */
   destroyAllForUser(userId: string, exceptSessionId?: string): void {
     for (const [id, session] of this.sessions) {
       if (session.userId === userId && id !== exceptSessionId) {
@@ -52,4 +86,20 @@ export class SessionStore {
       }
     }
   }
+
+  private isExpired(session: Session, now: number): boolean {
+    return session.expiresAt <= now || session.createdAt + this.absoluteTtlMs <= now;
+  }
+
+  // Oldest sessions go first, so a legitimate user logging in on a new
+  // device is never refused - only memory growth is bounded.
+  private enforcePerUserLimit(userId: string): void {
+    const own = [...this.sessions.values()]
+      .filter((session) => session.userId === userId)
+      .sort((a, b) => a.createdAt - b.createdAt);
+    while (own.length >= MAX_SESSIONS_PER_USER) {
+      const oldest = own.shift();
+      if (oldest) this.sessions.delete(oldest.id);
+    }
+  }
 }
diff --git a/src/server/composition/auth.ts b/src/server/composition/auth.ts
index 751f324..1b5ce09 100644
--- a/src/server/composition/auth.ts
+++ b/src/server/composition/auth.ts
@@ -1,8 +1,11 @@
 import { readAuthConfig } from "../auth/auth-config.js";
+import { LoginThrottle } from "../auth/login-throttle.js";
 import { SessionStore } from "../auth/sessions.js";
 import { UserService } from "../../domain/services/user.service.js";
 import { userRepository } from "./application-repositories.js";
 
 export const authConfig = readAuthConfig();
-export const sessionStore = new SessionStore(authConfig.sessionTtlMs);
+export const sessionStore = new SessionStore(authConfig.sessionTtlMs, authConfig.sessionMaxAgeMs);
+sessionStore.startSweeping();
+export const loginThrottle = new LoginThrottle();
 export const userService = new UserService(userRepository, authConfig);
diff --git a/src/server/controllers/auth.controller.ts b/src/server/controllers/auth.controller.ts
index 9dabee5..5eaf699 100644
--- a/src/server/controllers/auth.controller.ts
+++ b/src/server/controllers/auth.controller.ts
@@ -1,11 +1,16 @@
 import type { Request, Response } from "express";
 import { changePasswordSchema, loginSchema } from "../../shared/validation/auth.schemas.js";
-import { InvalidCredentialsError, WrongPasswordError } from "../../domain/services/user.service.js";
-import { authConfig, sessionStore, userService } from "../composition/auth.js";
+import {
+  InvalidCredentialsError,
+  PasswordUnchangedError,
+  WrongPasswordError,
+} from "../../domain/services/user.service.js";
+import { authConfig, loginThrottle, sessionStore, userService } from "../composition/auth.js";
 import {
   cookieOptions,
   identityFromRequest,
   sessionIdFromRequest,
+  setSessionCookie,
 } from "../auth/auth.middleware.js";
 import { SESSION_COOKIE } from "../auth/auth-config.js";
 import { userRepository } from "../composition/application-repositories.js";
@@ -13,9 +18,7 @@ import { userRepository } from "../composition/application-repositories.js";
 export async function getAuthStatus(req: Request, res: Response) {
   const identity = await identityFromRequest(req, sessionStore, userRepository);
   const sessionId = sessionIdFromRequest(req);
-  if (identity && sessionId) {
-    res.cookie(SESSION_COOKIE, sessionId, cookieOptions(authConfig));
-  }
+  if (identity && sessionId) setSessionCookie(res, authConfig, sessionStore, sessionId);
   res.json({
     signedIn: Boolean(identity),
     mustChangePassword: identity?.mustChangePassword ?? false,
@@ -28,13 +31,29 @@ export async function login(req: Request, res: Response) {
     res.status(401).json({ error: "Anmeldung fehlgeschlagen." });
     return;
   }
+  const { username, password } = parsed.data;
+
+  const retryAfterMs = loginThrottle.retryAfterMs(username);
+  if (retryAfterMs > 0) {
+    res.setHeader("Retry-After", Math.ceil(retryAfterMs / 1000).toString());
+    res.status(429).json({
+      error: "Zu viele Fehlversuche. Bitte in einigen Minuten erneut versuchen.",
+    });
+    return;
+  }
+
   try {
-    const user = await userService.authenticate(parsed.data.username, parsed.data.password);
+    const user = await userService.authenticate(username, password);
+    loginThrottle.recordSuccess(username);
+    // A fresh session id on every login: an id planted before login
+    // (session fixation) never becomes authenticated.
+    sessionStore.destroy(sessionIdFromRequest(req));
     const session = sessionStore.create(user.id);
-    res.cookie(SESSION_COOKIE, session.id, cookieOptions(authConfig));
+    setSessionCookie(res, authConfig, sessionStore, session.id);
     res.json({ signedIn: true, mustChangePassword: user.mustChangePassword });
   } catch (error) {
     if (error instanceof InvalidCredentialsError) {
+      loginThrottle.recordFailure(username);
       res.status(401).json({ error: error.message });
       return;
     }
@@ -59,7 +78,7 @@ export async function changePassword(req: Request, res: Response) {
   }
   const parsed = changePasswordSchema.safeParse(req.body);
   if (!parsed.success) {
-    res.status(400).json({ error: parsed.error.flatten() });
+    res.status(400).json({ error: "Das neue Passwort muss 8 bis 200 Zeichen lang sein." });
     return;
   }
   try {
@@ -69,20 +88,22 @@ export async function changePassword(req: Request, res: Response) {
       parsed.data.newPassword
     );
   } catch (error) {
-    if (error instanceof WrongPasswordError) {
+    if (error instanceof WrongPasswordError || error instanceof PasswordUnchangedError) {
       res.status(400).json({ error: error.message });
       return;
     }
     throw error;
   }
-  // A password change invalidates every other session of this account; the
-  // current one stays so the change doesn't log the user out themselves.
-  sessionStore.destroyAllForUser(identity.id, sessionIdFromRequest(req));
+  // Every session of this account ends - including the current one, which is
+  // replaced by a fresh id so the user stays signed in on this device only.
+  sessionStore.destroyAllForUser(identity.id);
+  const session = sessionStore.create(identity.id);
+  setSessionCookie(res, authConfig, sessionStore, session.id);
   res.json({ changed: true });
 }
 
 export function logout(req: Request, res: Response) {
   sessionStore.destroy(sessionIdFromRequest(req));
-  res.clearCookie(SESSION_COOKIE, { ...cookieOptions(authConfig), maxAge: undefined });
+  res.clearCookie(SESSION_COOKIE, { ...cookieOptions(authConfig, 0), maxAge: undefined });
   res.json({ signedOut: true });
 }
diff --git a/src/server/controllers/user.controller.ts b/src/server/controllers/user.controller.ts
index 0ad3cbc..bdf8d0f 100644
--- a/src/server/controllers/user.controller.ts
+++ b/src/server/controllers/user.controller.ts
@@ -1,11 +1,12 @@
 import type { Request, Response } from "express";
+import type { ZodError } from "zod";
 import {
   createUserSchema,
   resetPasswordSchema,
   updateUserSchema,
 } from "../../shared/validation/user.schemas.js";
-import { UsernameTakenError } from "../../domain/services/user.service.js";
-import { userService } from "../composition/auth.js";
+import { LastAdminError, UsernameTakenError } from "../../domain/services/user.service.js";
+import { sessionStore, userService } from "../composition/auth.js";
 import { userRepository } from "../composition/application-repositories.js";
 
 // The password hash never leaves this layer.
@@ -29,6 +30,10 @@ function toDto(user: {
   };
 }
 
+function firstIssue(error: ZodError): string {
+  return error.issues[0]?.message ?? "Ungültige Eingabe.";
+}
+
 export async function listUsers(_req: Request, res: Response) {
   const rows = await userRepository.list();
   res.json(rows.map(toDto));
@@ -37,7 +42,7 @@ export async function listUsers(_req: Request, res: Response) {
 export async function createUser(req: Request, res: Response) {
   const parsed = createUserSchema.safeParse(req.body);
   if (!parsed.success) {
-    res.status(400).json({ error: parsed.error.flatten() });
+    res.status(400).json({ error: firstIssue(parsed.error) });
     return;
   }
   try {
@@ -64,7 +69,7 @@ export async function updateUser(req: Request, res: Response) {
   }
   const parsed = updateUserSchema.safeParse(req.body);
   if (!parsed.success) {
-    res.status(400).json({ error: parsed.error.flatten() });
+    res.status(400).json({ error: firstIssue(parsed.error) });
     return;
   }
   // The signed-in admin can't lock themselves out by deactivating or
@@ -78,8 +83,18 @@ export async function updateUser(req: Request, res: Response) {
     res.status(404).json({ error: "Benutzer nicht gefunden." });
     return;
   }
-  const updated = await userService.updateRoleAndActive(userId, parsed.data);
-  res.json(updated ? toDto(updated) : null);
+  try {
+    const updated = await userService.updateRoleAndActive(userId, parsed.data);
+    // Deactivation takes effect immediately, not just at the next login.
+    if (parsed.data.active === false) sessionStore.destroyAllForUser(userId);
+    res.json(updated ? toDto(updated) : null);
+  } catch (error) {
+    if (error instanceof LastAdminError) {
+      res.status(400).json({ error: error.message });
+      return;
+    }
+    throw error;
+  }
 }
 
 export async function resetUserPassword(req: Request, res: Response) {
@@ -90,7 +105,7 @@ export async function resetUserPassword(req: Request, res: Response) {
   }
   const parsed = resetPasswordSchema.safeParse(req.body);
   if (!parsed.success) {
-    res.status(400).json({ error: parsed.error.flatten() });
+    res.status(400).json({ error: firstIssue(parsed.error) });
     return;
   }
   const existing = await userRepository.findById(userId);
@@ -99,5 +114,8 @@ export async function resetUserPassword(req: Request, res: Response) {
     return;
   }
   const updated = await userService.resetPassword(userId, parsed.data.newPassword);
+  // A reset is usually a response to a suspected compromise: every open
+  // session of that account ends now.
+  sessionStore.destroyAllForUser(userId);
   res.json(updated ? toDto(updated) : null);
 }
diff --git a/src/server/index.ts b/src/server/index.ts
index 868de79..9a65ce0 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -7,7 +7,11 @@ import { cableSizingRouter } from "./routes/cable-sizing.routes.js";
 import { authRouter } from "./routes/auth.routes.js";
 import { userRouter } from "./routes/user.routes.js";
 import { errorMiddleware } from "./middleware/error.middleware.js";
-import { createAuthGuard, requirePasswordChanged } from "./auth/auth.middleware.js";
+import {
+  createAuthGuard,
+  requirePasswordChanged,
+  requireSameOriginForWrites,
+} from "./auth/auth.middleware.js";
 import { authConfig, sessionStore, userService } from "./composition/auth.js";
 import { userRepository } from "./composition/application-repositories.js";
 import { createLogger, toErrorMeta } from "../shared/logging/logger.js";
@@ -19,6 +23,7 @@ const port = Number(process.env.PORT || 3000);
 const heartbeatIntervalMs = 5 * 60 * 1000;
 const shutdownTimeoutMs = 15 * 1000;
 
+app.disable("x-powered-by");
 app.use(express.json({ limit: "25mb" }));
 
 app.use((req, res, next) => {
@@ -59,6 +64,7 @@ app.get("/health", (_req, res) => {
 // /auth/login, /auth/status and /auth/logout (see createAuthGuard's
 // openPaths). authRouter is mounted AFTER the guard (not before) so that
 // /auth/me and /auth/change-password still get req.authUser populated by it.
+app.use("/api", requireSameOriginForWrites());
 app.use("/api", createAuthGuard(authConfig, sessionStore, userRepository));
 app.use("/api", requirePasswordChanged());
 
diff --git a/src/shared/validation/auth.schemas.ts b/src/shared/validation/auth.schemas.ts
index 544b052..7d95eec 100644
--- a/src/shared/validation/auth.schemas.ts
+++ b/src/shared/validation/auth.schemas.ts
@@ -1,15 +1,20 @@
 import { z } from "zod";
 
+// Upper bounds keep a huge request body from being fed into scrypt.
+export const MAX_USERNAME_LENGTH = 100;
+export const MAX_PASSWORD_LENGTH = 200;
+export const MIN_PASSWORD_LENGTH = 8;
+
 export const loginSchema = z
   .object({
-    username: z.string().trim().min(1),
-    password: z.string().min(1),
+    username: z.string().trim().min(1).max(MAX_USERNAME_LENGTH),
+    password: z.string().min(1).max(MAX_PASSWORD_LENGTH),
   })
   .strict();
 
 export const changePasswordSchema = z
   .object({
-    currentPassword: z.string().min(1),
-    newPassword: z.string().min(8).max(200),
+    currentPassword: z.string().min(1).max(MAX_PASSWORD_LENGTH),
+    newPassword: z.string().min(MIN_PASSWORD_LENGTH).max(MAX_PASSWORD_LENGTH),
   })
   .strict();
diff --git a/src/shared/validation/user.schemas.ts b/src/shared/validation/user.schemas.ts
index ceb8961..cec4c5f 100644
--- a/src/shared/validation/user.schemas.ts
+++ b/src/shared/validation/user.schemas.ts
@@ -1,14 +1,29 @@
 import { z } from "zod";
 import { USER_ROLES } from "../constants/user-roles.js";
+import {
+  MAX_PASSWORD_LENGTH,
+  MAX_USERNAME_LENGTH,
+  MIN_PASSWORD_LENGTH,
+} from "./auth.schemas.js";
 
-const MIN_PASSWORD_LENGTH = 8;
+// ASCII only: rules out look-alike Unicode names ("admіn" with a Cyrillic i)
+// and invisible whitespace. E-mail addresses fit this pattern.
+const USERNAME_PATTERN = /^[a-z0-9._@-]+$/;
 
 export const createUserSchema = z
   .object({
-    username: z.string().trim().min(1).max(200),
+    username: z
+      .string()
+      .trim()
+      .toLowerCase()
+      .min(1)
+      .max(MAX_USERNAME_LENGTH)
+      .regex(USERNAME_PATTERN, {
+        message: "Anmeldename: nur a-z, 0-9 sowie . _ @ - erlaubt.",
+      }),
     name: z.string().trim().min(1).max(200),
     role: z.enum(USER_ROLES),
-    initialPassword: z.string().min(MIN_PASSWORD_LENGTH).max(200),
+    initialPassword: z.string().min(MIN_PASSWORD_LENGTH).max(MAX_PASSWORD_LENGTH),
   })
   .strict();
 
@@ -24,7 +39,7 @@ export const updateUserSchema = z
 
 export const resetPasswordSchema = z
   .object({
-    newPassword: z.string().min(MIN_PASSWORD_LENGTH).max(200),
+    newPassword: z.string().min(MIN_PASSWORD_LENGTH).max(MAX_PASSWORD_LENGTH),
   })
   .strict();
 
diff --git a/tests/authentication.test.ts b/tests/authentication.test.ts
new file mode 100644
index 0000000..e634716
--- /dev/null
+++ b/tests/authentication.test.ts
@@ -0,0 +1,265 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { Request, Response } from "express";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { UserRepository } from "../src/db/repositories/user.repository.js";
+import {
+  InvalidCredentialsError,
+  LastAdminError,
+  PasswordUnchangedError,
+  UserService,
+  UsernameTakenError,
+  WrongPasswordError,
+} from "../src/domain/services/user.service.js";
+import { hashPassword, verifyPassword } from "../src/server/auth/password.js";
+import { SessionStore } from "../src/server/auth/sessions.js";
+import { LoginThrottle } from "../src/server/auth/login-throttle.js";
+import { readCookie } from "../src/server/auth/cookie.js";
+import { requireSameOriginForWrites } from "../src/server/auth/auth.middleware.js";
+import type { AuthConfig } from "../src/server/auth/auth-config.js";
+import { createUserSchema } from "../src/shared/validation/user.schemas.js";
+import { loginSchema } from "../src/shared/validation/auth.schemas.js";
+
+const HOUR = 60 * 60 * 1000;
+
+function createUserService() {
+  const context = createDatabaseContext(":memory:");
+  migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+  const repository = new UserRepository(context.db);
+  const config: AuthConfig = {
+    sessionTtlMs: 12 * HOUR,
+    sessionMaxAgeMs: 7 * 24 * HOUR,
+    cookieSecure: false,
+    bootstrap: { username: "admin", password: "bootstrap-password-123" },
+  };
+  return { repository, service: new UserService(repository, config) };
+}
+
+describe("password hashing", () => {
+  it("verifies the right password and rejects a wrong one", async () => {
+    const hash = await hashPassword("richtiges-passwort");
+    assert.match(hash, /^scrypt\$16384\$8\$1\$[0-9a-f]{32}\$[0-9a-f]{128}$/);
+    assert.equal(await verifyPassword("richtiges-passwort", hash), true);
+    assert.equal(await verifyPassword("falsches-passwort", hash), false);
+  });
+
+  it("uses a fresh salt per hash", async () => {
+    assert.notEqual(await hashPassword("gleich"), await hashPassword("gleich"));
+  });
+
+  it("rejects malformed stored hashes instead of throwing", async () => {
+    assert.equal(await verifyPassword("x", "not-a-hash"), false);
+    assert.equal(await verifyPassword("x", "scrypt$a$b$c$00$00"), false);
+  });
+});
+
+describe("session store", () => {
+  it("expires idle sessions and slides on activity", () => {
+    let now = 0;
+    const store = new SessionStore(1 * HOUR, 24 * HOUR, () => now);
+    const session = store.create("user-1");
+    now = 50 * 60 * 1000;
+    assert.ok(store.get(session.id));
+    now += 50 * 60 * 1000;
+    assert.ok(store.get(session.id), "activity must have extended the idle window");
+    now += 2 * HOUR;
+    assert.equal(store.get(session.id), undefined);
+  });
+
+  it("never outlives the absolute lifetime, even when constantly used", () => {
+    let now = 0;
+    const store = new SessionStore(1 * HOUR, 3 * HOUR, () => now);
+    const session = store.create("user-1");
+    for (let step = 0; step < 5; step += 1) {
+      now += 30 * 60 * 1000;
+      store.get(session.id);
+    }
+    now = 3 * HOUR;
+    assert.equal(store.get(session.id), undefined);
+  });
+
+  it("ends all sessions of a user except an optional one", () => {
+    const store = new SessionStore(HOUR, 24 * HOUR);
+    const first = store.create("user-1");
+    const second = store.create("user-1");
+    const other = store.create("user-2");
+    store.destroyAllForUser("user-1", second.id);
+    assert.equal(store.get(first.id), undefined);
+    assert.ok(store.get(second.id));
+    assert.ok(store.get(other.id));
+  });
+
+  it("bounds the number of sessions per user by dropping the oldest", () => {
+    let now = 0;
+    const store = new SessionStore(HOUR, 24 * HOUR, () => now);
+    const oldest = store.create("user-1");
+    for (let index = 0; index < 20; index += 1) {
+      now += 1;
+      store.create("user-1");
+    }
+    assert.equal(store.get(oldest.id), undefined);
+  });
+});
+
+describe("login throttle", () => {
+  it("blocks a username after repeated failures and releases it after the window", () => {
+    let now = 0;
+    const throttle = new LoginThrottle(3, 15 * 60 * 1000, 100, () => now);
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      assert.equal(throttle.retryAfterMs("Admin"), 0);
+      throttle.recordFailure("admin ");
+    }
+    assert.ok(throttle.retryAfterMs("ADMIN") > 0, "normalized usernames share a counter");
+    assert.equal(throttle.retryAfterMs("someone-else"), 0);
+    now = 15 * 60 * 1000 + 1;
+    assert.equal(throttle.retryAfterMs("admin"), 0);
+  });
+
+  it("resets the counter after a successful login", () => {
+    const throttle = new LoginThrottle(2);
+    throttle.recordFailure("admin");
+    throttle.recordSuccess("admin");
+    throttle.recordFailure("admin");
+    assert.equal(throttle.retryAfterMs("admin"), 0);
+  });
+});
+
+describe("cookie parsing", () => {
+  it("reads the session cookie and ignores malformed encodings", () => {
+    assert.equal(readCookie("a=1; lb_session=abc; b=2", "lb_session"), "abc");
+    assert.equal(readCookie("lb_session=%E0%A4%A", "lb_session"), undefined);
+    assert.equal(readCookie(undefined, "lb_session"), undefined);
+  });
+});
+
+describe("same-origin guard for writes", () => {
+  function run(method: string, fetchSite?: string) {
+    let status: number | undefined;
+    let passed = false;
+    const req = {
+      method,
+      headers: fetchSite ? { "sec-fetch-site": fetchSite } : {},
+    } as unknown as Request;
+    const res = {
+      status(code: number) {
+        status = code;
+        return this;
+      },
+      json() {
+        return this;
+      },
+    } as unknown as Response;
+    requireSameOriginForWrites()(req, res, () => {
+      passed = true;
+    });
+    return { passed, status };
+  }
+
+  it("lets reads and same-origin writes through", () => {
+    assert.equal(run("GET", "cross-site").passed, true);
+    assert.equal(run("POST", "same-origin").passed, true);
+    assert.equal(run("POST").passed, true, "non-browser clients carry no ambient cookie");
+  });
+
+  it("rejects writes from other sites and other ports of the same host", () => {
+    assert.deepEqual(run("POST", "cross-site"), { passed: false, status: 403 });
+    assert.deepEqual(run("PATCH", "same-site"), { passed: false, status: 403 });
+    assert.deepEqual(run("DELETE", "same-site"), { passed: false, status: 403 });
+  });
+});
+
+describe("input validation", () => {
+  it("rejects look-alike and whitespace usernames and normalizes case", () => {
+    const base = { name: "Test", role: "user", initialPassword: "start-passwort" };
+    assert.equal(createUserSchema.safeParse({ ...base, username: "admіn" }).success, false);
+    assert.equal(createUserSchema.safeParse({ ...base, username: "ad min" }).success, false);
+    const parsed = createUserSchema.parse({ ...base, username: " Max.Muster@Firma.de " });
+    assert.equal(parsed.username, "max.muster@firma.de");
+  });
+
+  it("caps login input length so huge bodies never reach scrypt", () => {
+    assert.equal(
+      loginSchema.safeParse({ username: "admin", password: "x".repeat(201) }).success,
+      false
+    );
+  });
+});
+
+describe("user service", () => {
+  it("creates the bootstrap admin only while the table is empty", async () => {
+    const { repository, service } = createUserService();
+    await service.ensureBootstrapAdmin();
+    await service.ensureBootstrapAdmin();
+    const users = await repository.list();
+    assert.equal(users.length, 1);
+    assert.equal(users[0].role, "admin");
+    assert.equal(users[0].mustChangePassword, true);
+  });
+
+  it("rejects unknown users, wrong passwords and deactivated accounts alike", async () => {
+    const { service } = createUserService();
+    const user = await service.createUser({
+      username: "max",
+      name: "Max",
+      role: "user",
+      initialPassword: "start-passwort",
+    });
+    assert.ok(user);
+    await assert.rejects(service.authenticate("niemand", "egal"), InvalidCredentialsError);
+    await assert.rejects(service.authenticate("max", "falsch"), InvalidCredentialsError);
+    assert.equal((await service.authenticate("MAX", "start-passwort")).id, user.id);
+    await service.updateRoleAndActive(user.id, { active: false });
+    await assert.rejects(service.authenticate("max", "start-passwort"), InvalidCredentialsError);
+  });
+
+  it("refuses duplicate usernames", async () => {
+    const { service } = createUserService();
+    const input = { username: "max", name: "Max", role: "user" as const, initialPassword: "start-passwort" };
+    await service.createUser(input);
+    await assert.rejects(service.createUser(input), UsernameTakenError);
+  });
+
+  it("never removes the last active admin", async () => {
+    const { repository, service } = createUserService();
+    await service.ensureBootstrapAdmin();
+    const [admin] = await repository.list();
+    await assert.rejects(service.updateRoleAndActive(admin.id, { role: "user" }), LastAdminError);
+    await assert.rejects(service.updateRoleAndActive(admin.id, { active: false }), LastAdminError);
+
+    const second = await service.createUser({
+      username: "zweiter",
+      name: "Zweiter",
+      role: "admin",
+      initialPassword: "start-passwort",
+    });
+    assert.ok(second);
+    await service.updateRoleAndActive(admin.id, { role: "user" });
+    await assert.rejects(service.updateRoleAndActive(second.id, { active: false }), LastAdminError);
+  });
+
+  it("requires the current password and a different new one", async () => {
+    const { service } = createUserService();
+    const user = await service.createUser({
+      username: "max",
+      name: "Max",
+      role: "user",
+      initialPassword: "start-passwort",
+    });
+    assert.ok(user);
+    await assert.rejects(
+      service.changeOwnPassword(user.id, "falsch", "neues-passwort"),
+      WrongPasswordError
+    );
+    await assert.rejects(
+      service.changeOwnPassword(user.id, "start-passwort", "start-passwort"),
+      PasswordUnchangedError
+    );
+    const changed = await service.changeOwnPassword(user.id, "start-passwort", "neues-passwort");
+    assert.equal(changed?.mustChangePassword, false);
+
+    const reset = await service.resetPassword(user.id, "admin-vergeben");
+    assert.equal(reset?.mustChangePassword, true);
+  });
+});

From 728132e52a2cdf230a0a86a65d57da5f03e454c1 Mon Sep 17 00:00:00 2001
From: Grovy311 <christ.janssen@outlook.de>
Date: Mon, 28 Sep 2026 21:47:30 +0200
Subject: [PATCH 42/60] Warn at startup when no user exists and no bootstrap
 admin is configured

Also document that Sec-Fetch-Site is only sent over HTTPS, so plain-HTTP
LAN access relies on SameSite=Lax alone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/authentication.md              | 1 +
 src/domain/services/user.service.ts | 7 ++++++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/docs/authentication.md b/docs/authentication.md
index 13a9f72..15729aa 100644
--- a/docs/authentication.md
+++ b/docs/authentication.md
@@ -53,6 +53,7 @@ Verknüpfung mit einer Mitarbeiter-/Personen-Stammdatentabelle.
 | Passwort-Raten (offline, DB-Diebstahl) | scrypt (N=16384, r=8, p=1), eigenes Salt je Hash |
 | Nutzernamen ausspähen (Timing) | Unbekannte Namen werden gegen einen festen Dummy-Hash geprüft – immer genau ein scrypt-Lauf; einheitliche Fehlermeldung |
 | CSRF | SameSite=Lax **plus** `requireSameOriginForWrites`: schreibende Anfragen nur mit `Sec-Fetch-Site: same-origin`. Nötig, weil andere Dienste auf demselben Host (andere Ports) als „same-site“ gelten |
+| CSRF über reines HTTP | Browser senden `Sec-Fetch-Site` nur an HTTPS-Adressen. Beim Zugriff per `http://…` im LAN greift deshalb nur SameSite=Lax (schützt gegen fremde Domains, nicht gegen andere Ports desselben Hosts). |
 | Session-Fixation | Neue Session-ID bei jedem Login und nach jedem Passwortwechsel |
 | Gestohlenes Cookie | httpOnly; gleitende Laufzeit (`AUTH_SESSION_HOURS`, 12 h) **und** harte Obergrenze (`AUTH_SESSION_MAX_DAYS`, 7 Tage) |
 | Kompromittiertes Konto | Passwort-Reset und Deaktivieren beenden sofort alle Sessions des Kontos; Passwortwechsel beendet alle anderen |
diff --git a/src/domain/services/user.service.ts b/src/domain/services/user.service.ts
index 0968d02..1a3c27c 100644
--- a/src/domain/services/user.service.ts
+++ b/src/domain/services/user.service.ts
@@ -63,9 +63,14 @@ export class UserService {
     // Warm the dummy hash at startup so even the first unknown-user login
     // costs one scrypt run, not two.
     await this.getDummyHash();
-    if (!this.authConfig.bootstrap) return;
     const existingCount = await this.repository.count();
     if (existingCount > 0) return;
+    if (!this.authConfig.bootstrap) {
+      logger.warn(
+        "no users exist and AUTH_BOOTSTRAP_USERNAME/AUTH_BOOTSTRAP_PASSWORT are not set - nobody can sign in"
+      );
+      return;
+    }
     const passwordHash = await hashPassword(this.authConfig.bootstrap.password);
     await this.repository.create({
       username: this.authConfig.bootstrap.username,

From ade21fe386eb0f8da3464391874d13e41f087a80 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Mon, 28 Sep 2026 22:14:30 +0200
Subject: [PATCH 43/60] Create feeder circuits while linking boards

---
 src/app/projects/[projectId]/page.tsx         | 198 +++++++++++++--
 ...it-structure-project-command.repository.ts |   8 +-
 ...rd-structure-project-command.repository.ts |  98 +++++++
 ...rd-feeder-circuit-project-command.model.ts | 132 ++++++++++
 ...n-board-structure-project-command.store.ts |  12 +
 .../services/project-command.service.ts       |  13 +
 src/frontend/utils/api.ts                     |  59 ++++-
 .../distribution-board-feeder-circuit.ts      |  68 +++++
 src/frontend/utils/project-version-history.ts |   4 +
 ...circuit-project-command.repository.test.ts | 240 ++++++++++++++++++
 .../distribution-board-feeder-circuit.test.ts | 168 ++++++++++++
 11 files changed, 960 insertions(+), 40 deletions(-)
 create mode 100644 src/domain/models/distribution-board-feeder-circuit-project-command.model.ts
 create mode 100644 src/frontend/utils/distribution-board-feeder-circuit.ts
 create mode 100644 tests/distribution-board-feeder-circuit-project-command.repository.test.ts
 create mode 100644 tests/distribution-board-feeder-circuit.test.ts

diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index 4a99cf0..37813c1 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -47,6 +47,7 @@ import {
 import {
   copyGlobalDeviceToProject,
   copyDistributionBoard,
+  createFeederCircuitAndUpdateDistributionBoard,
   copyProjectDeviceToGlobal,
   createDistributionBoard,
   createProjectDevice,
@@ -71,6 +72,12 @@ import {
   updateProjectDevice,
   updateProjectSettings,
 } from "../../../frontend/utils/api";
+import { createClientId } from "../../../frontend/utils/client-id";
+import {
+  buildFeederCircuitSnapshot,
+  getDefaultFeederCircuitSection,
+  getNextFeederCircuitIdentifier,
+} from "../../../frontend/utils/distribution-board-feeder-circuit";
 import type {
   BuildingDto,
   CircuitListDto,
@@ -146,6 +153,7 @@ const boardFilterCollapsedStorageKey =
   "leistungsbilanz:overview-filter-collapsed:distribution-boards";
 const projectDeviceFilterCollapsedStorageKey =
   "leistungsbilanz:overview-filter-collapsed:project-devices";
+const createFeederCircuitSelectValue = "__create_feeder_circuit__";
 
 export default function ProjectDetailPage() {
   const params = useParams<{ projectId: string }>();
@@ -175,6 +183,12 @@ export default function ProjectDetailPage() {
   const [editingBoardCopyName, setEditingBoardCopyName] = useState("");
   const [editingFeedingBoardId, setEditingFeedingBoardId] = useState("");
   const [editingFeedingCircuitId, setEditingFeedingCircuitId] = useState("");
+  const [isCreatingFeederCircuit, setIsCreatingFeederCircuit] =
+    useState(false);
+  const [editingFeederCircuitSectionId, setEditingFeederCircuitSectionId] =
+    useState("");
+  const [editingFeederCircuitDisplayName, setEditingFeederCircuitDisplayName] =
+    useState("");
   const [editingBoardInfo, setEditingBoardInfo] =
     useState<DistributionBoardInfoDraft>(
       toDistributionBoardInfoDraft({
@@ -350,6 +364,21 @@ export default function ProjectDetailPage() {
   const selectedFeedingCircuit = selectedFeedingCircuits.find(
     ({ circuit }) => circuit.id === editingFeedingCircuitId
   );
+  const feederCircuitSections =
+    selectedFeedingTree?.sections.filter(
+      (section) => section.category !== undefined
+    ) ?? [];
+  const selectedNewFeederCircuitSection = feederCircuitSections.find(
+    (section) => section.id === editingFeederCircuitSectionId
+  );
+  const newFeederCircuitIdentifier = selectedNewFeederCircuitSection
+    ? getNextFeederCircuitIdentifier(selectedNewFeederCircuitSection)
+    : null;
+  const selectedFeedingCircuitCategory =
+    selectedFeedingCircuit?.section.category ??
+    (isCreatingFeederCircuit
+      ? selectedNewFeederCircuitSection?.category
+      : undefined);
   const selectedFeedingBoard = boards.find(
     (board) => board.id === editingFeedingBoardId
   );
@@ -556,6 +585,9 @@ export default function ProjectDetailPage() {
     setEditingBoardInfo(toDistributionBoardInfoDraft(board));
     setEditingFeedingBoardId(board.feedingDistributionBoardId ?? "");
     setEditingFeedingCircuitId(board.feedingCircuitId ?? "");
+    setIsCreatingFeederCircuit(false);
+    setEditingFeederCircuitSectionId("");
+    setEditingFeederCircuitDisplayName("");
   }
 
   function openBoardCreator() {
@@ -584,28 +616,56 @@ export default function ProjectDetailPage() {
     setIsSaving(true);
     setError(null);
     try {
-      const result = await updateDistributionBoard(
-        projectId,
-        editingBoard.id,
-        {
-          floorId: editingBoardFloorId || null,
-          supplyType: editingBoardSupplyType,
-          simultaneityFactor,
-          feedingDistributionBoardId: editingFeedingBoardId || null,
-          feedingCircuitId: editingFeedingCircuitId || null,
-          ...fromDistributionBoardInfoDraft(editingBoardInfo),
-        },
-        project.currentRevision
-      );
-      setBoards((current) =>
-        current.map((board) =>
-          board.id === result.distributionBoard.id
-            ? result.distributionBoard
-            : board
-        )
-      );
+      const boardInput = {
+        floorId: editingBoardFloorId || null,
+        supplyType: editingBoardSupplyType,
+        simultaneityFactor,
+        feedingDistributionBoardId: editingFeedingBoardId || null,
+        feedingCircuitId: editingFeedingCircuitId || null,
+        ...fromDistributionBoardInfoDraft(editingBoardInfo),
+      };
+      let result;
+      if (isCreatingFeederCircuit) {
+        if (!editingFeedingBoardId || !selectedFeedingTree) {
+          throw new Error("Bitte eine speisende Verteilung wählen.");
+        }
+        if (!selectedNewFeederCircuitSection) {
+          throw new Error(
+            "Bitte eine Stromkreisgruppe für den neuen Abgang wählen."
+          );
+        }
+        const circuit = buildFeederCircuitSnapshot({
+          id: createClientId(),
+          tree: selectedFeedingTree,
+          sectionId: selectedNewFeederCircuitSection.id,
+          displayName: editingFeederCircuitDisplayName,
+        });
+        result = await createFeederCircuitAndUpdateDistributionBoard(
+          projectId,
+          editingBoard.id,
+          {
+            ...boardInput,
+            feedingDistributionBoardId: editingFeedingBoardId,
+            feedingCircuitId: circuit.id,
+          },
+          circuit,
+          project.currentRevision
+        );
+      } else {
+        result = await updateDistributionBoard(
+          projectId,
+          editingBoard.id,
+          boardInput,
+          project.currentRevision
+        );
+      }
       applyProjectRevision(result.history.currentRevision);
-      setCircuitTrees((await getProjectCircuitTrees(projectId)).trees);
+      const [updatedBoards, updatedTrees] = await Promise.all([
+        listDistributionBoards(projectId),
+        getProjectCircuitTrees(projectId),
+      ]);
+      setBoards(updatedBoards);
+      setCircuitTrees(updatedTrees.trees);
       setEditingBoard(null);
     } catch (err) {
       setError(
@@ -1567,8 +1627,16 @@ export default function ProjectDetailPage() {
                   className="form-select"
                   id="feeding-distribution-board"
                   onChange={(event) => {
-                    setEditingFeedingBoardId(event.target.value);
+                    const boardId = event.target.value;
+                    setEditingFeedingBoardId(boardId);
                     setEditingFeedingCircuitId("");
+                    setIsCreatingFeederCircuit(false);
+                    setEditingFeederCircuitSectionId(
+                      getDefaultFeederCircuitSection(
+                        circuitTreeByBoardId.get(boardId)
+                      )?.id ?? ""
+                    );
+                    setEditingFeederCircuitDisplayName("");
                   }}
                   value={editingFeedingBoardId}
                 >
@@ -1588,10 +1656,31 @@ export default function ProjectDetailPage() {
                   className="form-select"
                   disabled={!editingFeedingBoardId}
                   id="feeding-circuit"
-                  onChange={(event) => setEditingFeedingCircuitId(event.target.value)}
-                  value={editingFeedingCircuitId}
+                  onChange={(event) => {
+                    if (event.target.value === createFeederCircuitSelectValue) {
+                      setEditingFeedingCircuitId("");
+                      setIsCreatingFeederCircuit(true);
+                      setEditingFeederCircuitSectionId(
+                        (current) =>
+                          current ||
+                          getDefaultFeederCircuitSection(selectedFeedingTree)?.id ||
+                          ""
+                      );
+                      return;
+                    }
+                    setIsCreatingFeederCircuit(false);
+                    setEditingFeedingCircuitId(event.target.value);
+                  }}
+                  value={
+                    isCreatingFeederCircuit
+                      ? createFeederCircuitSelectValue
+                      : editingFeedingCircuitId
+                  }
                 >
                   <option value="">Nur Verteilung bekannt</option>
+                  <option value={createFeederCircuitSelectValue}>
+                    + Neuen Einspeiseabgang anlegen …
+                  </option>
                   {selectedFeedingCircuits.map(({ circuit }) => (
                     <option key={circuit.id} value={circuit.id}>
                       {circuit.equipmentIdentifier}
@@ -1600,7 +1689,62 @@ export default function ProjectDetailPage() {
                   ))}
                 </select>
               </div>
-              {editingFeedingBoardId && !editingFeedingCircuitId ? (
+              {isCreatingFeederCircuit ? (
+                <div className="col-12">
+                  <div className="border rounded p-3">
+                    <div className="row g-3">
+                      <div className="col-12 col-md-6">
+                        <label className="form-label" htmlFor="new-feeder-circuit-section">
+                          Stromkreisgruppe
+                        </label>
+                        <select
+                          className="form-select"
+                          id="new-feeder-circuit-section"
+                          onChange={(event) =>
+                            setEditingFeederCircuitSectionId(event.target.value)
+                          }
+                          required
+                          value={editingFeederCircuitSectionId}
+                        >
+                          {feederCircuitSections.map((section) => (
+                            <option key={section.id} value={section.id}>
+                              {section.displayName}
+                            </option>
+                          ))}
+                        </select>
+                        <div className="form-text">
+                          Vorgesehenes BMK: {newFeederCircuitIdentifier ?? "–"}
+                        </div>
+                      </div>
+                      <div className="col-12 col-md-6">
+                        <label className="form-label" htmlFor="new-feeder-circuit-name">
+                          Abgangsbezeichnung (optional)
+                        </label>
+                        <input
+                          className="form-control"
+                          id="new-feeder-circuit-name"
+                          onChange={(event) =>
+                            setEditingFeederCircuitDisplayName(event.target.value)
+                          }
+                          placeholder="z. B. Steigetrasse Ost"
+                          value={editingFeederCircuitDisplayName}
+                        />
+                        <div className="form-text">
+                          Ohne Zusatzbezeichnung wird der Name der gespeisten
+                          Verteilung angezeigt.
+                        </div>
+                      </div>
+                    </div>
+                    <div className="form-text mt-2">
+                      Der Abgang wird erst beim Speichern angelegt und gemeinsam
+                      mit dieser Verteilung verknüpft. Es entsteht keine Gerätezeile.
+                    </div>
+                  </div>
+                </div>
+              ) : null}
+              {editingFeedingBoardId &&
+              !editingFeedingCircuitId &&
+              !isCreatingFeederCircuit ? (
                 <div className="col-12">
                   <div className="alert alert-warning mb-0 py-2">
                     Ohne speisenden Abgang wird die Hierarchie angezeigt, die
@@ -1618,8 +1762,8 @@ export default function ProjectDetailPage() {
                   </div>
                 </div>
               ) : null}
-              {selectedFeedingCircuit &&
-              selectedFeedingCircuit.section.category !== "three_phase" ? (
+              {selectedFeedingCircuitCategory !== undefined &&
+              selectedFeedingCircuitCategory !== "three_phase" ? (
                 <div className="col-12">
                   <div className="alert alert-warning mb-0 py-2">
                     Der gewählte Abgang ist 1-phasig. Bitte prüfen, ob diese
diff --git a/src/db/repositories/circuit-structure-project-command.repository.ts b/src/db/repositories/circuit-structure-project-command.repository.ts
index e7cfcb2..4841616 100644
--- a/src/db/repositories/circuit-structure-project-command.repository.ts
+++ b/src/db/repositories/circuit-structure-project-command.repository.ts
@@ -40,7 +40,7 @@ export class CircuitStructureProjectCommandRepository
       this.database,
       input,
       (tx) =>
-        this.applyCommand(
+        this.applyInTransaction(
           tx,
           input.projectId,
           input.source,
@@ -49,7 +49,11 @@ export class CircuitStructureProjectCommandRepository
     );
   }
 
-  private applyCommand(
+  /**
+   * Applies the circuit write inside an already-owned project transaction.
+   * Composite project commands use this without creating a second revision.
+   */
+  applyInTransaction(
     database: AppDatabase,
     projectId: string,
     source: ExecuteCircuitStructureCommandInput["source"],
diff --git a/src/db/repositories/distribution-board-structure-project-command.repository.ts b/src/db/repositories/distribution-board-structure-project-command.repository.ts
index 9346df7..115705b 100644
--- a/src/db/repositories/distribution-board-structure-project-command.repository.ts
+++ b/src/db/repositories/distribution-board-structure-project-command.repository.ts
@@ -1,4 +1,5 @@
 import { and, asc, eq, inArray } from "drizzle-orm";
+import { isDeepStrictEqual } from "node:util";
 import {
   assertDistributionBoardDeleteProjectCommand,
   assertDistributionBoardInsertProjectCommand,
@@ -17,6 +18,20 @@ import {
   type DistributionBoardUpdateProjectCommand,
   type DistributionBoardUpdateValues,
 } from "../../domain/models/distribution-board-project-command.model.js";
+import {
+  assertDistributionBoardFeederCircuitProjectCommand,
+  createDistributionBoardCreateFeederCircuitProjectCommand,
+  createDistributionBoardRemoveFeederCircuitProjectCommand,
+  distributionBoardCreateFeederCircuitCommandType,
+  distributionBoardRemoveFeederCircuitCommandType,
+  type DistributionBoardFeederCircuitProjectCommand,
+} from "../../domain/models/distribution-board-feeder-circuit-project-command.model.js";
+import {
+  circuitDeleteCommandType,
+  circuitInsertCommandType,
+  createCircuitDeleteProjectCommand,
+  createCircuitInsertProjectCommand,
+} from "../../domain/models/circuit-structure-project-command.model.js";
 import type {
   DistributionBoardStructureProjectCommandStore,
   ExecuteDistributionBoardStructureCommandInput,
@@ -31,6 +46,7 @@ import { floors } from "../schema/floors.js";
 import { projects } from "../schema/projects.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
 import { assertBoardsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
+import { CircuitStructureProjectCommandRepository } from "./circuit-structure-project-command.repository.js";
 
 export class DistributionBoardStructureProjectCommandRepository
   implements DistributionBoardStructureProjectCommandStore
@@ -62,6 +78,30 @@ export class DistributionBoardStructureProjectCommandRepository
     );
   }
 
+  executeFeederCircuit(
+    input: Omit<
+      ExecuteDistributionBoardStructureCommandInput,
+      "command"
+    > & {
+      command: DistributionBoardFeederCircuitProjectCommand;
+    }
+  ) {
+    assertDistributionBoardFeederCircuitProjectCommand(input.command);
+    if (
+      input.source === "user" &&
+      input.command.type === distributionBoardRemoveFeederCircuitCommandType
+    ) {
+      throw new Error(
+        "Generated feeder circuits may only be removed through project history."
+      );
+    }
+    return executeProjectCommandTransaction(
+      this.database,
+      input,
+      (tx) => this.applyFeederCircuitCommand(tx, input)
+    );
+  }
+
   private applyCommand(
     database: AppDatabase,
     projectId: string,
@@ -367,6 +407,64 @@ export class DistributionBoardStructureProjectCommandRepository
     return inverse;
   }
 
+  private applyFeederCircuitCommand(
+    database: AppDatabase,
+    input: Omit<
+      ExecuteDistributionBoardStructureCommandInput,
+      "command"
+    > & {
+      command: DistributionBoardFeederCircuitProjectCommand;
+    }
+  ): DistributionBoardFeederCircuitProjectCommand {
+    const circuitRepository =
+      new CircuitStructureProjectCommandRepository(database);
+    const { circuit, boardUpdate } = input.command.payload;
+    if (
+      input.command.type === distributionBoardCreateFeederCircuitCommandType
+    ) {
+      const circuitInverse = circuitRepository.applyInTransaction(
+        database,
+        input.projectId,
+        input.source,
+        createCircuitInsertProjectCommand(circuit)
+      );
+      if (circuitInverse.type !== circuitDeleteCommandType) {
+        throw new Error("Created feeder circuit returned an invalid inverse.");
+      }
+      const boardInverse = this.update(database, {
+        ...input,
+        command: boardUpdate,
+      });
+      return createDistributionBoardRemoveFeederCircuitProjectCommand(
+        circuit,
+        boardInverse
+      );
+    }
+
+    const boardInverse = this.update(database, {
+      ...input,
+      command: boardUpdate,
+    });
+    const circuitInverse = circuitRepository.applyInTransaction(
+      database,
+      input.projectId,
+      input.source,
+      createCircuitDeleteProjectCommand(circuit.id, circuit.circuitListId)
+    );
+    if (
+      circuitInverse.type !== circuitInsertCommandType ||
+      !isDeepStrictEqual(circuitInverse.payload.circuit, circuit)
+    ) {
+      throw new Error(
+        "Generated feeder circuit changed before history removal."
+      );
+    }
+    return createDistributionBoardCreateFeederCircuitProjectCommand(
+      circuit,
+      boardInverse
+    );
+  }
+
   private assertFeedingReference(
     database: AppDatabase,
     projectId: string,
diff --git a/src/domain/models/distribution-board-feeder-circuit-project-command.model.ts b/src/domain/models/distribution-board-feeder-circuit-project-command.model.ts
new file mode 100644
index 0000000..a1fc035
--- /dev/null
+++ b/src/domain/models/distribution-board-feeder-circuit-project-command.model.ts
@@ -0,0 +1,132 @@
+import {
+  assertCircuitInsertProjectCommand,
+  circuitInsertCommandType,
+  circuitStructureCommandSchemaVersion,
+  type CircuitSnapshot,
+} from "./circuit-structure-project-command.model.js";
+import {
+  assertDistributionBoardUpdateProjectCommand,
+  type DistributionBoardUpdateProjectCommand,
+} from "./distribution-board-project-command.model.js";
+import type { SerializedProjectCommand } from "./project-command.model.js";
+
+export const distributionBoardCreateFeederCircuitCommandType =
+  "distribution-board.create-feeder-circuit" as const;
+export const distributionBoardRemoveFeederCircuitCommandType =
+  "distribution-board.remove-feeder-circuit" as const;
+export const distributionBoardFeederCircuitCommandSchemaVersion = 1 as const;
+
+export interface DistributionBoardFeederCircuitCommandPayload {
+  circuit: CircuitSnapshot;
+  boardUpdate: DistributionBoardUpdateProjectCommand;
+}
+
+export interface DistributionBoardCreateFeederCircuitProjectCommand
+  extends SerializedProjectCommand<DistributionBoardFeederCircuitCommandPayload> {
+  schemaVersion: typeof distributionBoardFeederCircuitCommandSchemaVersion;
+  type: typeof distributionBoardCreateFeederCircuitCommandType;
+}
+
+export interface DistributionBoardRemoveFeederCircuitProjectCommand
+  extends SerializedProjectCommand<DistributionBoardFeederCircuitCommandPayload> {
+  schemaVersion: typeof distributionBoardFeederCircuitCommandSchemaVersion;
+  type: typeof distributionBoardRemoveFeederCircuitCommandType;
+}
+
+export type DistributionBoardFeederCircuitProjectCommand =
+  | DistributionBoardCreateFeederCircuitProjectCommand
+  | DistributionBoardRemoveFeederCircuitProjectCommand;
+
+export function createDistributionBoardCreateFeederCircuitProjectCommand(
+  circuit: CircuitSnapshot,
+  boardUpdate: DistributionBoardUpdateProjectCommand
+): DistributionBoardCreateFeederCircuitProjectCommand {
+  const command: DistributionBoardCreateFeederCircuitProjectCommand = {
+    schemaVersion: distributionBoardFeederCircuitCommandSchemaVersion,
+    type: distributionBoardCreateFeederCircuitCommandType,
+    payload: { circuit, boardUpdate },
+  };
+  assertDistributionBoardFeederCircuitProjectCommand(command);
+  return command;
+}
+
+export function createDistributionBoardRemoveFeederCircuitProjectCommand(
+  circuit: CircuitSnapshot,
+  boardUpdate: DistributionBoardUpdateProjectCommand
+): DistributionBoardRemoveFeederCircuitProjectCommand {
+  const command: DistributionBoardRemoveFeederCircuitProjectCommand = {
+    schemaVersion: distributionBoardFeederCircuitCommandSchemaVersion,
+    type: distributionBoardRemoveFeederCircuitCommandType,
+    payload: { circuit, boardUpdate },
+  };
+  assertDistributionBoardFeederCircuitProjectCommand(command);
+  return command;
+}
+
+export function assertDistributionBoardFeederCircuitProjectCommand(
+  command: SerializedProjectCommand<unknown>
+): asserts command is DistributionBoardFeederCircuitProjectCommand {
+  if (
+    command.schemaVersion !==
+      distributionBoardFeederCircuitCommandSchemaVersion ||
+    (command.type !== distributionBoardCreateFeederCircuitCommandType &&
+      command.type !== distributionBoardRemoveFeederCircuitCommandType) ||
+    !isPlainObject(command.payload)
+  ) {
+    throw new Error("Unsupported distribution-board feeder-circuit command.");
+  }
+
+  const { circuit, boardUpdate } = command.payload;
+  if (!isPlainObject(boardUpdate)) {
+    throw new Error("Feeder-circuit command requires a board update.");
+  }
+  assertCircuitInsertProjectCommand({
+    schemaVersion: circuitStructureCommandSchemaVersion,
+    type: circuitInsertCommandType,
+    payload: { circuit },
+  });
+  const boardUpdateCommand =
+    boardUpdate as unknown as SerializedProjectCommand<unknown>;
+  assertDistributionBoardUpdateProjectCommand(boardUpdateCommand);
+
+  const typedCircuit = circuit as CircuitSnapshot;
+  const typedBoardUpdate: DistributionBoardUpdateProjectCommand =
+    boardUpdateCommand;
+  if (typedCircuit.deviceRows.length !== 0 || !typedCircuit.isReserve) {
+    throw new Error(
+      "A generated feeder circuit must be empty before the board load is linked."
+    );
+  }
+  const feedingBoard = getChangeValue(
+    typedBoardUpdate,
+    "feedingDistributionBoardId"
+  );
+  const feedingCircuit = getChangeValue(
+    typedBoardUpdate,
+    "feedingCircuitId"
+  );
+  if (feedingBoard === undefined || feedingCircuit === undefined) {
+    throw new Error(
+      "Feeder-circuit commands must update both logical feeding references."
+    );
+  }
+  if (
+    command.type === distributionBoardCreateFeederCircuitCommandType &&
+    (typeof feedingBoard !== "string" || feedingCircuit !== typedCircuit.id)
+  ) {
+    throw new Error(
+      "The created feeder circuit must be linked by the distribution-board update."
+    );
+  }
+}
+
+function getChangeValue(
+  command: DistributionBoardUpdateProjectCommand,
+  field: "feedingDistributionBoardId" | "feedingCircuitId"
+) {
+  return command.payload.changes.find((change) => change.field === field)?.value;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
diff --git a/src/domain/ports/distribution-board-structure-project-command.store.ts b/src/domain/ports/distribution-board-structure-project-command.store.ts
index f0cb5c9..6dd8d8f 100644
--- a/src/domain/ports/distribution-board-structure-project-command.store.ts
+++ b/src/domain/ports/distribution-board-structure-project-command.store.ts
@@ -1,5 +1,6 @@
 import type { DistributionBoardStructureProjectCommand } from "../models/distribution-board-structure-project-command.model.js";
 import type { DistributionBoardUpdateProjectCommand } from "../models/distribution-board-project-command.model.js";
+import type { DistributionBoardFeederCircuitProjectCommand } from "../models/distribution-board-feeder-circuit-project-command.model.js";
 import type {
   AppendedProjectRevision,
   ProjectRevisionSource,
@@ -35,4 +36,15 @@ export interface DistributionBoardStructureProjectCommandStore {
     revision: AppendedProjectRevision;
     inverse: DistributionBoardUpdateProjectCommand;
   };
+  executeFeederCircuit(
+    input: Omit<
+      ExecuteDistributionBoardStructureCommandInput,
+      "command"
+    > & {
+      command: DistributionBoardFeederCircuitProjectCommand;
+    }
+  ): {
+    revision: AppendedProjectRevision;
+    inverse: DistributionBoardFeederCircuitProjectCommand;
+  };
 }
diff --git a/src/domain/services/project-command.service.ts b/src/domain/services/project-command.service.ts
index cf1f740..35dd9e8 100644
--- a/src/domain/services/project-command.service.ts
+++ b/src/domain/services/project-command.service.ts
@@ -45,6 +45,11 @@ import {
   assertDistributionBoardUpdateProjectCommand,
   distributionBoardUpdateCommandType,
 } from "../models/distribution-board-project-command.model.js";
+import {
+  assertDistributionBoardFeederCircuitProjectCommand,
+  distributionBoardCreateFeederCircuitCommandType,
+  distributionBoardRemoveFeederCircuitCommandType,
+} from "../models/distribution-board-feeder-circuit-project-command.model.js";
 import {
   assertDistributionBoardComponentDeleteProjectCommand,
   assertDistributionBoardComponentInsertProjectCommand,
@@ -418,6 +423,14 @@ export class ProjectCommandService implements ProjectCommandExecutor {
           command: input.command,
         }).revision;
       }
+      case distributionBoardCreateFeederCircuitCommandType:
+      case distributionBoardRemoveFeederCircuitCommandType: {
+        assertDistributionBoardFeederCircuitProjectCommand(input.command);
+        return this.distributionBoardStructureStore.executeFeederCircuit({
+          ...input,
+          command: input.command,
+        }).revision;
+      }
       case distributionBoardComponentInsertCommandType: {
         assertDistributionBoardComponentInsertProjectCommand(
           input.command
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index 8473bfa..8f5a878 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -366,20 +366,22 @@ export function createDistributionBoard(
   );
 }
 
+export type UpdateDistributionBoardInput = {
+  floorId: string | null;
+  supplyType: NonNullable<DistributionBoardDto["supplyType"]>;
+  simultaneityFactor: number;
+} & Partial<DistributionBoardInfoDto> &
+  Partial<
+    Pick<
+      DistributionBoardDto,
+      "feedingDistributionBoardId" | "feedingCircuitId"
+    >
+  >;
+
 export function updateDistributionBoard(
   projectId: string,
   distributionBoardId: string,
-  input: {
-    floorId: string | null;
-    supplyType: NonNullable<DistributionBoardDto["supplyType"]>;
-    simultaneityFactor: number;
-  } & Partial<DistributionBoardInfoDto> &
-    Partial<
-      Pick<
-        DistributionBoardDto,
-        "feedingDistributionBoardId" | "feedingCircuitId"
-      >
-    >,
+  input: UpdateDistributionBoardInput,
   expectedRevision: number
 ) {
   return request<DistributionBoardCommandResultDto>(
@@ -391,6 +393,41 @@ export function updateDistributionBoard(
   );
 }
 
+export function createFeederCircuitAndUpdateDistributionBoard(
+  projectId: string,
+  distributionBoardId: string,
+  input: UpdateDistributionBoardInput & {
+    feedingDistributionBoardId: string;
+    feedingCircuitId: string;
+  },
+  circuit: CircuitSnapshot,
+  expectedRevision: number
+) {
+  return executeProjectCommand(
+    projectId,
+    expectedRevision,
+    {
+      schemaVersion: 1,
+      type: "distribution-board.create-feeder-circuit",
+      payload: {
+        circuit,
+        boardUpdate: {
+          schemaVersion: 2,
+          type: "distribution-board.update",
+          payload: {
+            distributionBoardId,
+            changes: Object.entries(input).map(([field, value]) => ({
+              field,
+              value,
+            })),
+          },
+        },
+      },
+    },
+    "Einspeiseabgang anlegen und Verteilung verknüpfen"
+  );
+}
+
 export const documentLogoUrl = "/api/document-branding/logo";
 
 export function getDocumentBranding() {
diff --git a/src/frontend/utils/distribution-board-feeder-circuit.ts b/src/frontend/utils/distribution-board-feeder-circuit.ts
new file mode 100644
index 0000000..c2c7f43
--- /dev/null
+++ b/src/frontend/utils/distribution-board-feeder-circuit.ts
@@ -0,0 +1,68 @@
+import type { CircuitSnapshot } from "../../domain/models/circuit-structure-project-command.model.js";
+import type {
+  CircuitTreeResponseDto,
+  CircuitTreeSectionDto,
+} from "../types";
+import { buildCircuitInsertSnapshot } from "./circuit-structure-command";
+
+export function getDefaultFeederCircuitSection(
+  tree: CircuitTreeResponseDto | undefined
+) {
+  if (!tree) return undefined;
+  return (
+    tree.sections.find((section) => section.category === "three_phase") ??
+    tree.sections.find((section) => section.category !== undefined)
+  );
+}
+
+export function getNextFeederCircuitIdentifier(
+  section: CircuitTreeSectionDto
+) {
+  let highestSuffix = 0;
+  for (const circuit of section.circuits) {
+    if (!circuit.equipmentIdentifier.startsWith(section.prefix)) continue;
+    const suffix = circuit.equipmentIdentifier.slice(section.prefix.length);
+    if (!/^\d+$/.test(suffix)) continue;
+    highestSuffix = Math.max(highestSuffix, Number(suffix));
+  }
+  return `${section.prefix}${highestSuffix + 1}`;
+}
+
+export function buildFeederCircuitSnapshot(input: {
+  id: string;
+  tree: CircuitTreeResponseDto;
+  sectionId: string;
+  displayName: string;
+}): CircuitSnapshot {
+  const section = input.tree.sections.find(
+    (candidate) => candidate.id === input.sectionId
+  );
+  if (!section || !section.category) {
+    throw new Error("Die gewählte Stromkreisgruppe ist nicht verfügbar.");
+  }
+  const snapshot = buildCircuitInsertSnapshot({
+    id: input.id,
+    circuitListId: input.tree.circuitListId,
+    category: section.category,
+    deviceRows: [],
+    values: {
+      sectionId: section.id,
+      equipmentIdentifier: getNextFeederCircuitIdentifier(section),
+      displayName: input.displayName.trim() || undefined,
+      sortOrder:
+        section.circuits.length === 0
+          ? 10
+          : Math.max(...section.circuits.map((circuit) => circuit.sortOrder)) +
+            10,
+      voltage:
+        section.category === "three_phase"
+          ? input.tree.threePhaseVoltageV
+          : input.tree.singlePhaseVoltageV,
+      isReserve: true,
+    },
+  });
+  // A distribution-board feeder is not a generic final circuit. Its protection
+  // must be selected from the calculated load and cable, so no 16 A group
+  // default is persisted here.
+  return { ...snapshot, protectionDevice: null };
+}
diff --git a/src/frontend/utils/project-version-history.ts b/src/frontend/utils/project-version-history.ts
index 146cda8..eb195d0 100644
--- a/src/frontend/utils/project-version-history.ts
+++ b/src/frontend/utils/project-version-history.ts
@@ -32,6 +32,10 @@ const commandTypeLabels: Record<string, string> = {
   "project.update-settings": "Projekteinstellungen bearbeitet",
   "distribution-board.insert": "Verteilung angelegt",
   "distribution-board.update": "Verteilung bearbeitet",
+  "distribution-board.create-feeder-circuit":
+    "Einspeiseabgang angelegt und verknüpft",
+  "distribution-board.remove-feeder-circuit":
+    "Einspeiseabgang und Verknüpfung entfernt",
   "distribution-board.delete": "Verteilung entfernt",
   "distribution-board.insert-subtree": "Verteilung vollständig eingefügt",
   "distribution-board.delete-subtree": "Verteilung vollständig entfernt",
diff --git a/tests/distribution-board-feeder-circuit-project-command.repository.test.ts b/tests/distribution-board-feeder-circuit-project-command.repository.test.ts
new file mode 100644
index 0000000..d4d2c26
--- /dev/null
+++ b/tests/distribution-board-feeder-circuit-project-command.repository.test.ts
@@ -0,0 +1,240 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { eq } from "drizzle-orm";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import {
+  createDatabaseContext,
+  type DatabaseContext,
+} from "../src/db/database-context.js";
+import { DistributionBoardStructureProjectCommandRepository } from "../src/db/repositories/distribution-board-structure-project-command.repository.js";
+import { ProjectHistoryRepository } from "../src/db/repositories/project-history.repository.js";
+import { circuits } from "../src/db/schema/circuits.js";
+import { distributionBoards } from "../src/db/schema/distribution-boards.js";
+import { projects } from "../src/db/schema/projects.js";
+import {
+  assertDistributionBoardFeederCircuitProjectCommand,
+  createDistributionBoardCreateFeederCircuitProjectCommand,
+} from "../src/domain/models/distribution-board-feeder-circuit-project-command.model.js";
+import { createDistributionBoardUpdateProjectCommand } from "../src/domain/models/distribution-board-project-command.model.js";
+import {
+  createDistributionBoardInsertProjectCommand,
+  createDistributionBoardStructureSnapshot,
+} from "../src/domain/models/distribution-board-structure-project-command.model.js";
+import { buildCircuitInsertSnapshot } from "../src/frontend/utils/circuit-structure-command.js";
+
+function createTestDatabase(): DatabaseContext {
+  const context = createDatabaseContext(":memory:");
+  migrate(context.db, {
+    migrationsFolder: path.resolve("src", "db", "migrations"),
+  });
+  context.db
+    .insert(projects)
+    .values({ id: "project-1", name: "Test project" })
+    .run();
+  return context;
+}
+
+function setupBoards(
+  context: DatabaseContext,
+  repository: DistributionBoardStructureProjectCommandRepository
+) {
+  const source = createDistributionBoardStructureSnapshot(
+    "project-1",
+    "NSHV"
+  );
+  const downstream = createDistributionBoardStructureSnapshot(
+    "project-1",
+    "UV EG"
+  );
+  repository.execute({
+    projectId: "project-1",
+    expectedRevision: 0,
+    source: "user",
+    command: createDistributionBoardInsertProjectCommand(source),
+  });
+  repository.execute({
+    projectId: "project-1",
+    expectedRevision: 1,
+    source: "user",
+    command: createDistributionBoardInsertProjectCommand(downstream),
+  });
+  const section = source.sections.find(
+    (candidate) => candidate.key === "three_phase"
+  )!;
+  const circuit = {
+    ...buildCircuitInsertSnapshot({
+      id: "feeder-circuit",
+      circuitListId: source.circuitList.id,
+      category: "three_phase",
+      deviceRows: [],
+      values: {
+        sectionId: section.id,
+        equipmentIdentifier: `${section.prefix}1`,
+        displayName: undefined,
+        sortOrder: 10,
+        voltage: 400,
+        isReserve: true,
+      },
+    }),
+    protectionDevice: null,
+  };
+  const boardUpdate = createDistributionBoardUpdateProjectCommand(
+    downstream.distributionBoard.id,
+    {
+      feedingDistributionBoardId: source.distributionBoard.id,
+      feedingCircuitId: circuit.id,
+    }
+  );
+  const command =
+    createDistributionBoardCreateFeederCircuitProjectCommand(
+      circuit,
+      boardUpdate
+    );
+  return { source, downstream, circuit, command };
+}
+
+describe("distribution-board feeder-circuit project command", () => {
+  it("creates and links one feeder atomically and supports undo and redo", () => {
+    const context = createTestDatabase();
+    try {
+      const repository =
+        new DistributionBoardStructureProjectCommandRepository(context.db);
+      const history = new ProjectHistoryRepository(context.db);
+      const { source, downstream, circuit, command } = setupBoards(
+        context,
+        repository
+      );
+
+      repository.executeFeederCircuit({
+        projectId: "project-1",
+        expectedRevision: 2,
+        source: "user",
+        command,
+      });
+      assert.ok(
+        context.db
+          .select()
+          .from(circuits)
+          .where(eq(circuits.id, circuit.id))
+          .get()
+      );
+      assert.deepEqual(
+        context.db
+          .select({
+            boardId: distributionBoards.feedingDistributionBoardId,
+            circuitId: distributionBoards.feedingCircuitId,
+          })
+          .from(distributionBoards)
+          .where(eq(distributionBoards.id, downstream.distributionBoard.id))
+          .get(),
+        {
+          boardId: source.distributionBoard.id,
+          circuitId: circuit.id,
+        }
+      );
+
+      const undo = history.getNextCommand("project-1", "undo");
+      assert.ok(undo);
+      assertDistributionBoardFeederCircuitProjectCommand(undo.command);
+      repository.executeFeederCircuit({
+        projectId: "project-1",
+        expectedRevision: 3,
+        source: "undo",
+        historyTargetChangeSetId: undo.changeSetId,
+        command: undo.command,
+      });
+      assert.equal(
+        context.db
+          .select()
+          .from(circuits)
+          .where(eq(circuits.id, circuit.id))
+          .get(),
+        undefined
+      );
+      assert.deepEqual(
+        context.db
+          .select({
+            boardId: distributionBoards.feedingDistributionBoardId,
+            circuitId: distributionBoards.feedingCircuitId,
+          })
+          .from(distributionBoards)
+          .where(eq(distributionBoards.id, downstream.distributionBoard.id))
+          .get(),
+        { boardId: null, circuitId: null }
+      );
+
+      const redo = history.getNextCommand("project-1", "redo");
+      assert.ok(redo);
+      assertDistributionBoardFeederCircuitProjectCommand(redo.command);
+      repository.executeFeederCircuit({
+        projectId: "project-1",
+        expectedRevision: 4,
+        source: "redo",
+        historyTargetChangeSetId: redo.changeSetId,
+        command: redo.command,
+      });
+      assert.equal(
+        context.db
+          .select({ equipmentIdentifier: circuits.equipmentIdentifier })
+          .from(circuits)
+          .where(eq(circuits.id, circuit.id))
+          .get()?.equipmentIdentifier,
+        circuit.equipmentIdentifier
+      );
+    } finally {
+      context.close();
+    }
+  });
+
+  it("rolls back unlinking when the generated circuit changed before undo", () => {
+    const context = createTestDatabase();
+    try {
+      const repository =
+        new DistributionBoardStructureProjectCommandRepository(context.db);
+      const history = new ProjectHistoryRepository(context.db);
+      const { downstream, circuit, command } = setupBoards(context, repository);
+      repository.executeFeederCircuit({
+        projectId: "project-1",
+        expectedRevision: 2,
+        source: "user",
+        command,
+      });
+      context.db
+        .update(circuits)
+        .set({ displayName: "Außerhalb der Historie geändert" })
+        .where(eq(circuits.id, circuit.id))
+        .run();
+
+      const undo = history.getNextCommand("project-1", "undo");
+      assert.ok(undo);
+      assertDistributionBoardFeederCircuitProjectCommand(undo.command);
+      assert.throws(
+        () =>
+          repository.executeFeederCircuit({
+            projectId: "project-1",
+            expectedRevision: 3,
+            source: "undo",
+            historyTargetChangeSetId: undo.changeSetId,
+            command: undo.command,
+          }),
+        /changed before history removal/
+      );
+      const board = context.db
+        .select()
+        .from(distributionBoards)
+        .where(eq(distributionBoards.id, downstream.distributionBoard.id))
+        .get();
+      assert.equal(board?.feedingCircuitId, circuit.id);
+      assert.ok(
+        context.db
+          .select()
+          .from(circuits)
+          .where(eq(circuits.id, circuit.id))
+          .get()
+      );
+    } finally {
+      context.close();
+    }
+  });
+});
diff --git a/tests/distribution-board-feeder-circuit.test.ts b/tests/distribution-board-feeder-circuit.test.ts
new file mode 100644
index 0000000..fb143da
--- /dev/null
+++ b/tests/distribution-board-feeder-circuit.test.ts
@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  buildFeederCircuitSnapshot,
+  getDefaultFeederCircuitSection,
+  getNextFeederCircuitIdentifier,
+} from "../src/frontend/utils/distribution-board-feeder-circuit.js";
+import type { CircuitTreeResponseDto } from "../src/frontend/types.js";
+import { createFeederCircuitAndUpdateDistributionBoard } from "../src/frontend/utils/api.js";
+
+function tree(): CircuitTreeResponseDto {
+  return {
+    circuitListId: "list-main",
+    distributionBoardId: "board-main",
+    distributionBoardName: "NSHV",
+    currentRevision: 2,
+    singlePhaseVoltageV: 230,
+    threePhaseVoltageV: 400,
+    distributionBoardSimultaneityFactor: 1,
+    distributionBoardTotalPower: 0,
+    distributionBoardTotalPowerWithSimultaneityFactor: 0,
+    headerComponents: [],
+    footerComponents: [],
+    sections: [
+      {
+        id: "single",
+        key: "single_phase",
+        category: "single_phase",
+        groupNumber: 1,
+        displayName: "1-phasig 1",
+        prefix: "-2F1.",
+        sortOrder: 10,
+        sectionTotalPower: 0,
+        components: [],
+        circuits: [],
+      },
+      {
+        id: "three",
+        key: "three_phase",
+        category: "three_phase",
+        groupNumber: 1,
+        displayName: "3-phasig 1",
+        prefix: "-3F1.",
+        sortOrder: 20,
+        sectionTotalPower: 0,
+        components: [],
+        circuits: [
+          {
+            id: "existing-2",
+            circuitListId: "list-main",
+            sectionId: "three",
+            equipmentIdentifier: "-3F1.2",
+            sortOrder: 10,
+            isReserve: true,
+            circuitTotalPower: 0,
+            circuitApparentPower: 0,
+            circuitCosPhi: 1,
+            deviceRows: [],
+            downstreamBoardLoads: [],
+          },
+          {
+            id: "existing-5",
+            circuitListId: "list-main",
+            sectionId: "three",
+            equipmentIdentifier: "-3F1.5",
+            sortOrder: 30,
+            isReserve: true,
+            circuitTotalPower: 0,
+            circuitApparentPower: 0,
+            circuitCosPhi: 1,
+            deviceRows: [],
+            downstreamBoardLoads: [],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+describe("distribution-board feeder circuit planning", () => {
+  it("prefers a three-phase section and does not fill BMK gaps", () => {
+    const input = tree();
+    const section = getDefaultFeederCircuitSection(input)!;
+    assert.equal(section.id, "three");
+    assert.equal(getNextFeederCircuitIdentifier(section), "-3F1.6");
+  });
+
+  it("builds an empty circuit with stable id, optional name and defaults", () => {
+    const input = tree();
+    const snapshot = buildFeederCircuitSnapshot({
+      id: "new-feeder",
+      tree: input,
+      sectionId: "three",
+      displayName: "  ",
+    });
+    assert.equal(snapshot.id, "new-feeder");
+    assert.equal(snapshot.equipmentIdentifier, "-3F1.6");
+    assert.equal(snapshot.displayName, null);
+    assert.equal(snapshot.sortOrder, 40);
+    assert.equal(snapshot.voltage, 400);
+    assert.equal(snapshot.isReserve, true);
+    assert.deepEqual(snapshot.deviceRows, []);
+    assert.equal(snapshot.protectionDevice, null);
+  });
+
+  it("sends circuit creation and board linking as one project command", async () => {
+    const input = tree();
+    const circuit = buildFeederCircuitSnapshot({
+      id: "new-feeder",
+      tree: input,
+      sectionId: "three",
+      displayName: "",
+    });
+    const requests: Array<{ url: string; method: string; body: any }> = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (request, init) => {
+      requests.push({
+        url: String(request),
+        method: init?.method ?? "GET",
+        body: JSON.parse(String(init?.body)),
+      });
+      return new Response(JSON.stringify({}), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    };
+    try {
+      await createFeederCircuitAndUpdateDistributionBoard(
+        "project-1",
+        "board-child",
+        {
+          floorId: null,
+          supplyType: "AV",
+          simultaneityFactor: 0.8,
+          feedingDistributionBoardId: "board-main",
+          feedingCircuitId: circuit.id,
+        },
+        circuit,
+        7
+      );
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+    assert.equal(requests.length, 1);
+    assert.equal(requests[0].url, "/api/projects/project-1/commands");
+    assert.equal(requests[0].method, "POST");
+    assert.equal(requests[0].body.expectedRevision, 7);
+    assert.equal(
+      requests[0].body.command.type,
+      "distribution-board.create-feeder-circuit"
+    );
+    assert.equal(requests[0].body.command.payload.circuit.id, "new-feeder");
+    assert.deepEqual(
+      requests[0].body.command.payload.boardUpdate.payload.changes
+        .filter((change: { field: string }) =>
+          change.field.startsWith("feeding")
+        )
+        .map((change: { field: string; value: unknown }) => [
+          change.field,
+          change.value,
+        ]),
+      [
+        ["feedingDistributionBoardId", "board-main"],
+        ["feedingCircuitId", "new-feeder"],
+      ]
+    );
+  });
+});

From 9165b8238c2ed67228ee0af9db5556fdf77e434c Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Mon, 28 Sep 2026 22:14:39 +0200
Subject: [PATCH 44/60] Compact single-board feeder circuit rows

---
 AGENTS.md                                     | 11 ++++
 docs/circuit-list-editor-api.md               | 11 +++-
 docs/current-architecture.md                  | 15 +++++
 docs/print-view.md                            |  5 +-
 src/app/globals.css                           |  4 ++
 .../components/circuit-tree-editor.tsx        | 16 +++++-
 src/frontend/print/print-document.tsx         | 19 +++++++
 src/frontend/utils/circuit-grid-model.ts      |  6 +-
 src/frontend/utils/circuit-grid-projection.ts | 47 ++++++++++++++-
 tests/circuit-grid-model.test.ts              |  4 +-
 tests/circuit-grid-projection.test.ts         | 57 +++++++++++++++++--
 11 files changed, 181 insertions(+), 14 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 9ef5b87..93e5108 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -476,6 +476,17 @@ downstream board's demand after its own board simultaneity factor to the chosen
 feeding circuit as a read-only virtual row. Recursive chains and several boards
 on one circuit are supported. A board-only link affects hierarchy but adds no
 load until a feeding circuit is selected.
+The distribution-board dialog can create one empty feeder circuit and link it
+in the same `distribution-board.create-feeder-circuit` project command. Its
+history inverse restores the complete previous board update before removing
+only the unchanged generated circuit; Redo reuses its UUID and BMK. No
+CircuitDeviceRow is created. The three-phase group is suggested, the optional
+circuit display name stays empty by default, and protection remains open for
+planner sizing. A circuit with exactly one downstream board and no device rows
+is rendered as one compact row using the live board number/name; several
+downstream boards or additional devices retain summary and child rows. Editing
+the name or remark of an empty reserve circuit changes the circuit itself and
+does not implicitly create a device row.
 Distribution-board floor assignment and a project-enabled supply type use
 `distribution-board.update`; both values are snapshot/export fields and one
 persistent undo step.
diff --git a/docs/circuit-list-editor-api.md b/docs/circuit-list-editor-api.md
index a8173f5..de724aa 100644
--- a/docs/circuit-list-editor-api.md
+++ b/docs/circuit-list-editor-api.md
@@ -269,6 +269,13 @@ commands. Endpoints, payloads and calculation rules: `docs/estimate-balance.md`.
     submitted info fields, are restored together by persistent Undo/Redo
   - `fedFrom` remains free text for external feeds such as HAK, metering,
     transformer or generator and for supplementary notes
+- The project-command endpoint additionally accepts
+  `distribution-board.create-feeder-circuit` with an empty complete circuit
+  snapshot and an embedded version-2 `distribution-board.update`. Both writes
+  are one transaction, revision and Undo step. The generated circuit has no
+  device row; Redo keeps its UUID and BMK. The history-only inverse
+  `distribution-board.remove-feeder-circuit` restores the previous board values
+  and removes only the unchanged circuit.
 - `POST /projects/:projectId/distribution-boards/:distributionBoardId/copy`
   - body: `{ "name": "UV-02 Kopie", "expectedRevision": 14 }`
   - duplicates the complete distribution-board subtree with new owning UUIDs
@@ -346,7 +353,9 @@ commands. Endpoints, payloads and calculation rules: `docs/estimate-balance.md`.
   footer components. Circuit and component protection devices use their
   separate one-to-one DTOs. Calculated row, circuit, section and board totals
   remain included. Circuit totals contain the demand of linked downstream
-  boards. `downstreamBoardLoads` exposes those contributions as read-only rows;
+  boards. `downstreamBoardLoads` exposes those contributions as read-only
+  values; the grid combines exactly one downstream board without device rows
+  into the circuit row and keeps child rows for mixed or multiple loads.
   `feedingReference` resolves the current board/circuit labels by id.
 
 Response sketch:
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 920002d..71b7feb 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -477,6 +477,21 @@ Verweise nicht. Der speisende Stromkreis muss zur speisenden Verteilung gehören
 Selbstverweise und Zyklen werden abgelehnt. Löschbefehle für referenzierte
 Verteilungen und Stromkreise, einschließlich Unterbaum- und Undo-Pfaden, werden
 vor der Datenbankänderung fachlich gesperrt.
+Im Bearbeiten-Dialog kann nach Auswahl der speisenden Verteilung direkt ein
+neuer Einspeiseabgang geplant werden. Die Oberfläche schlägt die dreiphasige
+Gruppe und das nächste BMK vor. Der Befehl
+`distribution-board.create-feeder-circuit` legt den leeren Stromkreis an und
+wendet die vollständige Verteilungsänderung in derselben Transaktion und
+Revision an; es entsteht keine Gerätezeile. Schutz und Leitung bleiben bewusst
+offen, weil sie aus Last und Verlegebedingungen geplant werden müssen. Undo
+stellt zuerst die vorherigen Verteilungswerte wieder her und entfernt danach
+nur den unveränderten erzeugten Stromkreis; Redo verwendet UUID und BMK erneut.
+Bei genau einer gespeisten Unterverteilung ohne Gerätezeilen projiziert das
+Grid nur eine kompakte Stromkreiszeile mit dem über die ID aufgelösten
+Verteilernamen. Erst mehrere Unterverteilungen oder zusätzliche Geräte erzeugen
+Sammel- und Unterzeilen. Anzeigename und Bemerkung eines leeren
+Reservestromkreises gehören zum Stromkreis und erzeugen beim Bearbeiten keine
+Gerätezeile.
 Die projektweite Circuit-Tree-Projektion berechnet rekursiv die Lasten aller
 Verteilungen. Die Leistung einer Unterverteilung nach ihrem eigenen
 Verteiler-GZF wird als virtuelle, schreibgeschützte Zeile genau dem gewählten
diff --git a/docs/print-view.md b/docs/print-view.md
index a843030..ecc00e2 100644
--- a/docs/print-view.md
+++ b/docs/print-view.md
@@ -38,8 +38,9 @@ automatisch bei späteren Änderungen in einem anderen Tab.
 3. **Verteilerpläne (quer, je Verteiler)** – Titelleiste mit
    Verteilernummer, Bezeichnung, Örtlichkeit, Netzart, „Gespeist von“ und
    P<sub>gl</sub>; darunter Kopfkomponenten, Gruppen, Stromkreise
-   (mehrzeilige mit Sammelzeile, eingerückten Gerätezeilen und
-   schreibgeschützten Unterverteilungszeilen),
+   (reine 1:1-Einspeiseabgänge kompakt in einer Zeile; sonst mehrzeilig mit
+   Sammelzeile, eingerückten Gerätezeilen und schreibgeschützten
+   Unterverteilungszeilen),
    Gruppensummen und Verteilersumme. Fehlende Kabelangaben sind als „offen“
    markiert. Die Titelleiste steht im Tabellenkopf und wiederholt sich beim
    Drucken auf Folgeseiten.
diff --git a/src/app/globals.css b/src/app/globals.css
index d14431b..88df3e9 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -1537,6 +1537,10 @@ a.kpi:hover {
   background: var(--panel-bg-subtle);
 }
 
+.tree-grid .feeder-circuit-row td:nth-child(2) {
+  font-weight: 600;
+}
+
 .tree-grid .device-row td:first-child {
   color: var(--text-faint);
 }
diff --git a/src/frontend/components/circuit-tree-editor.tsx b/src/frontend/components/circuit-tree-editor.tsx
index bac08ce..f75b64e 100644
--- a/src/frontend/components/circuit-tree-editor.tsx
+++ b/src/frontend/components/circuit-tree-editor.tsx
@@ -1766,7 +1766,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     const currentDisplay =
       mode === "replaceWithTypedChar" && cell.cellKey !== "phaseType"
         ? typedChar ?? ""
-        : String(visibleCell.value ?? "");
+        : String(visibleCell.editValue ?? visibleCell.value ?? "");
     focusTokenRef.current += 1;
     setEditingCell({
       ...cell,
@@ -4077,7 +4077,9 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                   key={row.rowKey}
                   className={`${
                     row.rowType === "circuitSummary"
-                      ? "summary-row"
+                      ? row.downstreamBoardLoad
+                        ? "feeder-circuit-row"
+                        : "summary-row"
                       : row.rowType === "deviceRow"
                         ? "device-row"
                         : row.rowType === "downstreamBoardLoad"
@@ -4708,11 +4710,19 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                           tabIndex={-1}
                         />
                         <IconButton
-                          disabled={isSaving}
+                          disabled={
+                            isSaving ||
+                            (row.circuit.downstreamBoardLoads?.length ?? 0) > 0
+                          }
                           icon={Trash2}
                           label="Stromkreis löschen"
                           onClick={() => void handleDeleteCircuit(row.circuit!.id)}
                           tabIndex={-1}
+                          title={
+                            (row.circuit.downstreamBoardLoads?.length ?? 0) > 0
+                              ? "Speist eine Unterverteilung – zuerst deren Einspeisung ändern"
+                              : undefined
+                          }
                           variant="danger"
                         />
                       </>
diff --git a/src/frontend/print/print-document.tsx b/src/frontend/print/print-document.tsx
index 5a0152b..a13d7e1 100644
--- a/src/frontend/print/print-document.tsx
+++ b/src/frontend/print/print-document.tsx
@@ -431,6 +431,25 @@ function CircuitRows({ circuit }: { circuit: CircuitTreeCircuitDto }) {
       </tr>
     );
   }
+  if (rows.length === 0 && downstreamBoards.length === 1) {
+    const boardLabel =
+      downstreamBoards[0].boardNumber ?? downstreamBoards[0].name;
+    return (
+      <tr className="pd-circuit">
+        <td className="pd-bmk">{circuit.equipmentIdentifier}</td>
+        <td>
+          {boardLabel}
+          {circuit.displayName ? (
+            <span className="pd-sub"> · {circuit.displayName}</span>
+          ) : null}
+        </td>
+        <td>–</td>
+        <td /><td /><td />
+        <td className="pd-r"><strong>{formatKilowatt(circuit.circuitTotalPower)}</strong></td>
+        {circuitCells}
+      </tr>
+    );
+  }
   if (rows.length === 1 && downstreamBoards.length === 0) {
     const row = rows[0];
     const title = circuit.displayName ?? row.displayName;
diff --git a/src/frontend/utils/circuit-grid-model.ts b/src/frontend/utils/circuit-grid-model.ts
index faa4a11..fafeca4 100644
--- a/src/frontend/utils/circuit-grid-model.ts
+++ b/src/frontend/utils/circuit-grid-model.ts
@@ -617,7 +617,11 @@ export function getCellKind(rowType: RowType, key: CellKey): CellKind {
   if (rowType === "deviceRow") return deviceFieldKeys.has(key) ? "deviceField" : "readonly";
   if (rowType === "downstreamBoardLoad") return "readonly";
   if (rowType === "circuitSummary") return circuitFieldKeys.has(key) ? "circuitField" : "readonly";
-  if (rowType === "reserveCircuit" || rowType === "circuitCompact") {
+  if (rowType === "reserveCircuit") {
+    if (circuitFieldKeys.has(key)) return "circuitField";
+    if (deviceFieldKeys.has(key)) return "deviceField";
+  }
+  if (rowType === "circuitCompact") {
     if (deviceFieldKeys.has(key)) return "deviceField";
     if (circuitFieldKeys.has(key)) return "circuitField";
   }
diff --git a/src/frontend/utils/circuit-grid-projection.ts b/src/frontend/utils/circuit-grid-projection.ts
index a9b11de..30e5ecf 100644
--- a/src/frontend/utils/circuit-grid-projection.ts
+++ b/src/frontend/utils/circuit-grid-projection.ts
@@ -37,6 +37,8 @@ export interface VisibleGridCell {
   editable: boolean;
   kind: CellKind;
   value: GridValue;
+  /** Separate persisted value when the displayed value is derived. */
+  editValue?: GridValue;
 }
 
 export interface VisibleGridRow {
@@ -144,6 +146,7 @@ function makeVisibleGridRow(
     const kind = getCellKind(rowType, column.key);
     const editable = kind === "circuitField" || kind === "deviceField";
     let value: GridValue;
+    let editValue: GridValue | undefined;
 
     if (rowType === "downstreamBoardLoad" && downstreamBoardLoad) {
       value = column.key === "displayName"
@@ -155,6 +158,35 @@ function makeVisibleGridRow(
             : column.key === "remark"
               ? "Automatisch aus der verknüpften Verteilung"
               : undefined;
+    } else if (
+      rowType === "circuitSummary" &&
+      circuit &&
+      downstreamBoardLoad &&
+      circuit.deviceRows.length === 0
+    ) {
+      if (column.key === "displayName") {
+        const boardLabel =
+          downstreamBoardLoad.boardNumber ?? downstreamBoardLoad.name;
+        value = circuit.displayName
+          ? `${boardLabel} · ${circuit.displayName}`
+          : boardLabel;
+        editValue = circuit.displayName ?? "";
+      } else if (column.key === "cosPhi") {
+        value = circuit.circuitCosPhi;
+      } else if (
+        kind === "computed" &&
+        circuitOnlyColumns.has(column.key)
+      ) {
+        value = getCircuitValue(circuit, column.key);
+      } else if (kind === "circuitField") {
+        value = getCircuitValue(circuit, column.key);
+      } else if (column.key === "rowTotalPower") {
+        value = circuit.circuitTotalPower;
+      } else if (column.key === "circuitTotalPower") {
+        value = circuit.circuitTotalPower;
+      } else if (column.key === "voltage") {
+        value = circuit.voltage;
+      }
     } else if (rowType === "placeholder") {
       value = column.key === "equipmentIdentifier" ? "-frei-" : undefined;
     } else if (kind === "deviceField" && device) {
@@ -178,7 +210,7 @@ function makeVisibleGridRow(
       value = circuit.voltage;
     }
 
-    return { cellKey: column.key, editable, kind, value };
+    return { cellKey: column.key, editable, kind, value, editValue };
   });
 
   return {
@@ -247,6 +279,19 @@ export function buildVisibleGridRowsWithStructure(
       const downstreamLoads = circuit.downstreamBoardLoads ?? [];
       if (circuit.deviceRows.length === 0 && downstreamLoads.length === 0) {
         rows.push(makeVisibleGridRow("reserveCircuit", section.id, circuit));
+      } else if (
+        circuit.deviceRows.length === 0 &&
+        downstreamLoads.length === 1
+      ) {
+        rows.push(
+          makeVisibleGridRow(
+            "circuitSummary",
+            section.id,
+            circuit,
+            undefined,
+            downstreamLoads[0]
+          )
+        );
       } else if (circuit.deviceRows.length === 1 && downstreamLoads.length === 0) {
         rows.push(makeVisibleGridRow("circuitCompact", section.id, circuit, circuit.deviceRows[0]));
       } else {
diff --git a/tests/circuit-grid-model.test.ts b/tests/circuit-grid-model.test.ts
index 641a770..475d781 100644
--- a/tests/circuit-grid-model.test.ts
+++ b/tests/circuit-grid-model.test.ts
@@ -133,7 +133,9 @@ describe("circuit grid model", () => {
     assert.equal(getCellKind("circuitCompact", "equipmentIdentifier"), "circuitField");
     assert.equal(getCellKind("circuitSummary", "displayName"), "circuitField");
     assert.equal(getCellKind("deviceRow", "displayName"), "deviceField");
-    assert.equal(getCellKind("reserveCircuit", "remark"), "deviceField");
+    assert.equal(getCellKind("reserveCircuit", "displayName"), "circuitField");
+    assert.equal(getCellKind("reserveCircuit", "remark"), "circuitField");
+    assert.equal(getCellKind("reserveCircuit", "powerPerUnit"), "deviceField");
     assert.equal(getCellKind("placeholder", "displayName"), "deviceField");
     assert.equal(getCellKind("deviceRow", "equipmentIdentifier"), "readonly");
     assert.equal(getCellKind("circuitSummary", "controlRequirement"), "circuitField");
diff --git a/tests/circuit-grid-projection.test.ts b/tests/circuit-grid-projection.test.ts
index 1a16913..6551aee 100644
--- a/tests/circuit-grid-projection.test.ts
+++ b/tests/circuit-grid-projection.test.ts
@@ -179,9 +179,10 @@ describe("circuit grid projection", () => {
     );
   });
 
-  it("renders linked downstream boards as separate read-only rows", () => {
+  it("renders one linked downstream board as one compact editable circuit row", () => {
     const feeder = {
       ...reserveCircuit,
+      displayName: undefined,
       isReserve: false,
       circuitTotalPower: 4,
       circuitApparentPower: 5,
@@ -202,19 +203,65 @@ describe("circuit grid projection", () => {
     assert.deepEqual(rows.map((row) => row.rowType), [
       "section",
       "circuitSummary",
-      "downstreamBoardLoad",
       "placeholder",
     ]);
-    const loadRow = rows[2];
+    const loadRow = rows[1];
     assert.equal(
       loadRow.cells.find((cell) => cell.cellKey === "displayName")?.value,
-      "Unterverteilung UV-02"
+      "UV-02"
+    );
+    assert.equal(
+      loadRow.cells.find((cell) => cell.cellKey === "displayName")?.editValue,
+      ""
     );
     assert.equal(
       loadRow.cells.find((cell) => cell.cellKey === "rowTotalPower")?.value,
       4
     );
-    assert.equal(loadRow.cells.every((cell) => !cell.editable), true);
+    assert.equal(
+      loadRow.cells.find((cell) => cell.cellKey === "displayName")?.kind,
+      "circuitField"
+    );
+  });
+
+  it("keeps separate read-only rows for several linked downstream boards", () => {
+    const feeder = {
+      ...reserveCircuit,
+      isReserve: false,
+      circuitTotalPower: 6,
+      circuitApparentPower: 7,
+      circuitCosPhi: 6 / 7,
+      downstreamBoardLoads: [
+        {
+          distributionBoardId: "board-a",
+          name: "Unterverteilung A",
+          boardNumber: "UV-A",
+          activePowerKw: 4,
+          apparentPowerKva: 5,
+          cosPhi: 0.8,
+        },
+        {
+          distributionBoardId: "board-b",
+          name: "Unterverteilung B",
+          boardNumber: "UV-B",
+          activePowerKw: 2,
+          apparentPowerKva: 2,
+          cosPhi: 1,
+        },
+      ],
+    };
+    const rows = buildVisibleGridRowsWithStructure(
+      [{ ...sections[0], circuits: [feeder] }],
+      { headerComponents: [], footerComponents: [] }
+    );
+    assert.deepEqual(rows.map((row) => row.rowType), [
+      "section",
+      "circuitSummary",
+      "downstreamBoardLoad",
+      "downstreamBoardLoad",
+      "placeholder",
+    ]);
+    assert.equal(rows[2].cells.every((cell) => !cell.editable), true);
   });
 
   it("shows circuit protection once on each visible circuit row", () => {

From 847f4e9493c1c6fb55d63c7728d176c781592f0a Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Mon, 28 Sep 2026 22:42:03 +0200
Subject: [PATCH 45/60] Harden user management integration

---
 src/app/config/layout.tsx                   | 27 +++----
 src/app/config/page.tsx                     |  4 +-
 src/db/repositories/user.repository.ts      | 84 ++++++++++++++-------
 src/db/schema/users.ts                      |  3 +-
 src/domain/ports/user.store.ts              | 40 ++++++++++
 src/domain/services/user.service.ts         | 64 ++++++++--------
 src/frontend/components/Sidebar.tsx         | 24 +++---
 src/frontend/components/cable-sizing-api.ts |  9 ++-
 src/frontend/utils/api.ts                   |  5 ++
 src/frontend/utils/auth-api.ts              | 11 ++-
 src/frontend/utils/config-access.ts         | 25 ++++++
 src/server/auth/auth.middleware.ts          | 23 ++++--
 src/server/auth/password.ts                 | 44 +++++++++--
 src/server/composition/auth.ts              |  7 +-
 src/shared/constants/request-security.ts    |  2 +
 tests/authentication.test.ts                | 67 ++++++++++++++--
 tests/config-access.test.ts                 | 26 +++++++
 tests/write-request-headers.test.ts         | 40 ++++++++++
 18 files changed, 394 insertions(+), 111 deletions(-)
 create mode 100644 src/domain/ports/user.store.ts
 create mode 100644 src/frontend/utils/config-access.ts
 create mode 100644 src/shared/constants/request-security.ts
 create mode 100644 tests/config-access.test.ts
 create mode 100644 tests/write-request-headers.test.ts

diff --git a/src/app/config/layout.tsx b/src/app/config/layout.tsx
index 1356d78..72d9b6d 100644
--- a/src/app/config/layout.tsx
+++ b/src/app/config/layout.tsx
@@ -4,26 +4,27 @@ import Link from "next/link";
 import { usePathname, useRouter } from "next/navigation";
 import { useEffect } from "react";
 import { useAuth } from "../../frontend/components/AuthProvider";
-
-const CONFIG_TABS = [
-  { href: "/config/benutzer", label: "Benutzer" },
-  { href: "/config/konto", label: "Konto" },
-] as const;
+import {
+  getConfigRedirect,
+  getConfigTabs,
+} from "../../frontend/utils/config-access";
 
 export default function ConfigLayout({ children }: { children: React.ReactNode }) {
   const pathname = usePathname();
   const router = useRouter();
   const { status, isAdmin } = useAuth();
+  const tabs = getConfigTabs(isAdmin);
+  const redirectTarget = getConfigRedirect(pathname, isAdmin);
 
   useEffect(() => {
-    // LoginGate already guarantees a signed-in user with a set password by
-    // the time this layout renders; only the role still needs checking.
-    if (status === "signed-in" && !isAdmin) {
-      router.replace("/");
-    }
-  }, [status, isAdmin, router]);
+    if (status !== "signed-in") return;
+    if (redirectTarget) router.replace(redirectTarget);
+  }, [status, redirectTarget, router]);
 
-  if (status !== "signed-in" || !isAdmin) {
+  if (
+    status !== "signed-in" ||
+    redirectTarget !== null
+  ) {
     return null;
   }
 
@@ -34,7 +35,7 @@ export default function ConfigLayout({ children }: { children: React.ReactNode }
       </div>
 
       <nav className="config-tabs">
-        {CONFIG_TABS.map((tab) => (
+        {tabs.map((tab) => (
           <Link
             key={tab.href}
             href={tab.href}
diff --git a/src/app/config/page.tsx b/src/app/config/page.tsx
index 7897dc7..3c9d8fd 100644
--- a/src/app/config/page.tsx
+++ b/src/app/config/page.tsx
@@ -1,5 +1,3 @@
-import { redirect } from "next/navigation";
-
 export default function ConfigPage() {
-  redirect("/config/benutzer");
+  return null;
 }
diff --git a/src/db/repositories/user.repository.ts b/src/db/repositories/user.repository.ts
index 071fc33..1fd55c7 100644
--- a/src/db/repositories/user.repository.ts
+++ b/src/db/repositories/user.repository.ts
@@ -1,17 +1,24 @@
 import crypto from "node:crypto";
-import { asc, eq } from "drizzle-orm";
+import { and, asc, eq } from "drizzle-orm";
 import type { AppDatabase } from "../database-context.js";
 import { users } from "../schema/users.js";
+import {
+  LastActiveAdminStoreError,
+  UsernameAlreadyExistsStoreError,
+  type CreateUserAccount,
+  type UserStore,
+} from "../../domain/ports/user.store.js";
 import type { UserRole } from "../../shared/constants/user-roles.js";
 
-export interface CreateUserRow {
-  username: string;
-  name: string;
-  role: UserRole;
-  passwordHash: string;
+function isUniqueConstraintError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    (error as { code?: unknown }).code === "SQLITE_CONSTRAINT_UNIQUE"
+  );
 }
 
-export class UserRepository {
+export class UserRepository implements UserStore {
   constructor(private readonly database: AppDatabase) {}
 
   async list() {
@@ -41,18 +48,23 @@ export class UserRepository {
     return row ?? null;
   }
 
-  async create(input: CreateUserRow) {
+  async create(input: CreateUserAccount) {
     const db = this.database;
     const id = crypto.randomUUID();
-    await db.insert(users).values({
-      id,
-      username: input.username.trim().toLowerCase(),
-      name: input.name,
-      role: input.role,
-      passwordHash: input.passwordHash,
-      active: true,
-      mustChangePassword: true,
-    });
+    try {
+      await db.insert(users).values({
+        id,
+        username: input.username.trim().toLowerCase(),
+        name: input.name,
+        role: input.role,
+        passwordHash: input.passwordHash,
+        active: true,
+        mustChangePassword: true,
+      });
+    } catch (error) {
+      if (isUniqueConstraintError(error)) throw new UsernameAlreadyExistsStoreError();
+      throw error;
+    }
     return this.findById(id);
   }
 
@@ -60,16 +72,34 @@ export class UserRepository {
     userId: string,
     patch: { role?: UserRole; active?: boolean }
   ) {
-    const db = this.database;
-    await db
-      .update(users)
-      .set({
-        ...(patch.role !== undefined ? { role: patch.role } : {}),
-        ...(patch.active !== undefined ? { active: patch.active } : {}),
-        updatedAt: new Date(),
-      })
-      .where(eq(users.id, userId));
-    return this.findById(userId);
+    return this.database.transaction((tx) => {
+      const [target] = tx.select().from(users).where(eq(users.id, userId)).limit(1).all();
+      if (!target) return null;
+
+      const removesActiveAdmin =
+        target.role === "admin" &&
+        target.active &&
+        (patch.role === "user" || patch.active === false);
+      if (removesActiveAdmin) {
+        const activeAdmins = tx
+          .select({ id: users.id })
+          .from(users)
+          .where(and(eq(users.role, "admin"), eq(users.active, true)))
+          .limit(2)
+          .all();
+        if (activeAdmins.length <= 1) throw new LastActiveAdminStoreError();
+      }
+
+      tx.update(users)
+        .set({
+          ...(patch.role !== undefined ? { role: patch.role } : {}),
+          ...(patch.active !== undefined ? { active: patch.active } : {}),
+          updatedAt: new Date(),
+        })
+        .where(eq(users.id, userId))
+        .run();
+      return tx.select().from(users).where(eq(users.id, userId)).limit(1).all()[0] ?? null;
+    });
   }
 
   async setPassword(
diff --git a/src/db/schema/users.ts b/src/db/schema/users.ts
index 825b5e1..7105fb4 100644
--- a/src/db/schema/users.ts
+++ b/src/db/schema/users.ts
@@ -1,5 +1,6 @@
 import { sql } from "drizzle-orm";
 import { integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import type { UserRole } from "../../shared/constants/user-roles.js";
 
 export const users = sqliteTable(
   "users",
@@ -8,7 +9,7 @@ export const users = sqliteTable(
     username: text("username").notNull(),
     passwordHash: text("password_hash").notNull(),
     name: text("name").notNull(),
-    role: text("role").notNull().default("user"),
+    role: text("role").$type<UserRole>().notNull().default("user"),
     active: integer("active", { mode: "boolean" }).notNull().default(true),
     mustChangePassword: integer("must_change_password", { mode: "boolean" })
       .notNull()
diff --git a/src/domain/ports/user.store.ts b/src/domain/ports/user.store.ts
new file mode 100644
index 0000000..9b80023
--- /dev/null
+++ b/src/domain/ports/user.store.ts
@@ -0,0 +1,40 @@
+import type { UserRole } from "../../shared/constants/user-roles.js";
+
+export interface UserAccount {
+  id: string;
+  username: string;
+  passwordHash: string;
+  name: string;
+  role: UserRole;
+  active: boolean;
+  mustChangePassword: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface CreateUserAccount {
+  username: string;
+  name: string;
+  role: UserRole;
+  passwordHash: string;
+}
+
+export class UsernameAlreadyExistsStoreError extends Error {}
+export class LastActiveAdminStoreError extends Error {}
+
+export interface UserStore {
+  list(): Promise<UserAccount[]>;
+  count(): Promise<number>;
+  findById(userId: string): Promise<UserAccount | null>;
+  findByUsername(username: string): Promise<UserAccount | null>;
+  create(input: CreateUserAccount): Promise<UserAccount | null>;
+  updateRoleAndActive(
+    userId: string,
+    patch: { role?: UserRole; active?: boolean }
+  ): Promise<UserAccount | null>;
+  setPassword(
+    userId: string,
+    passwordHash: string,
+    mustChangePassword: boolean
+  ): Promise<UserAccount | null>;
+}
diff --git a/src/domain/services/user.service.ts b/src/domain/services/user.service.ts
index 1a3c27c..7ea2f0b 100644
--- a/src/domain/services/user.service.ts
+++ b/src/domain/services/user.service.ts
@@ -1,8 +1,10 @@
-import type { UserRepository } from "../../db/repositories/user.repository.js";
-import { hashPassword, verifyPassword } from "../../server/auth/password.js";
 import type { UserRole } from "../../shared/constants/user-roles.js";
-import type { AuthConfig } from "../../server/auth/auth-config.js";
 import { createLogger } from "../../shared/logging/logger.js";
+import {
+  LastActiveAdminStoreError,
+  UsernameAlreadyExistsStoreError,
+  type UserStore,
+} from "../ports/user.store.js";
 
 const logger = createLogger("user-service");
 
@@ -36,20 +38,22 @@ export class LastAdminError extends Error {
   }
 }
 
-function isUniqueConstraintError(error: unknown): boolean {
-  return (
-    error instanceof Error &&
-    "code" in error &&
-    (error as { code?: unknown }).code === "SQLITE_CONSTRAINT_UNIQUE"
-  );
+export interface PasswordHasher {
+  hash(password: string): Promise<string>;
+  verify(password: string, storedHash: string): Promise<boolean>;
+}
+
+export interface UserServiceOptions {
+  bootstrap: { username: string; password: string } | null;
 }
 
 export class UserService {
   private dummyHash: Promise<string> | null = null;
 
   constructor(
-    private readonly repository: UserRepository,
-    private readonly authConfig: AuthConfig
+    private readonly repository: UserStore,
+    private readonly options: UserServiceOptions,
+    private readonly passwords: PasswordHasher
   ) {}
 
   /**
@@ -65,21 +69,21 @@ export class UserService {
     await this.getDummyHash();
     const existingCount = await this.repository.count();
     if (existingCount > 0) return;
-    if (!this.authConfig.bootstrap) {
+    if (!this.options.bootstrap) {
       logger.warn(
         "no users exist and AUTH_BOOTSTRAP_USERNAME/AUTH_BOOTSTRAP_PASSWORT are not set - nobody can sign in"
       );
       return;
     }
-    const passwordHash = await hashPassword(this.authConfig.bootstrap.password);
+    const passwordHash = await this.passwords.hash(this.options.bootstrap.password);
     await this.repository.create({
-      username: this.authConfig.bootstrap.username,
+      username: this.options.bootstrap.username,
       name: "Administrator",
       role: "admin",
       passwordHash,
     });
     logger.info("bootstrap admin created", {
-      username: this.authConfig.bootstrap.username,
+      username: this.options.bootstrap.username,
     });
   }
 
@@ -89,7 +93,7 @@ export class UserService {
     // scrypt run either way, so response time doesn't reveal which usernames
     // exist.
     const passwordHash = user?.passwordHash ?? (await this.getDummyHash());
-    const passwordMatches = await verifyPassword(password, passwordHash);
+    const passwordMatches = await this.passwords.verify(password, passwordHash);
     if (!user || !user.active || !passwordMatches) {
       throw new InvalidCredentialsError();
     }
@@ -104,7 +108,7 @@ export class UserService {
   }) {
     const existing = await this.repository.findByUsername(input.username);
     if (existing) throw new UsernameTakenError();
-    const passwordHash = await hashPassword(input.initialPassword);
+    const passwordHash = await this.passwords.hash(input.initialPassword);
     try {
       return await this.repository.create({
         username: input.username,
@@ -114,29 +118,23 @@ export class UserService {
       });
     } catch (error) {
       // Two admins creating the same name at once: the unique index decides.
-      if (isUniqueConstraintError(error)) throw new UsernameTakenError();
+      if (error instanceof UsernameAlreadyExistsStoreError) throw new UsernameTakenError();
       throw error;
     }
   }
 
   async updateRoleAndActive(userId: string, patch: { role?: UserRole; active?: boolean }) {
-    const removesAdmin = patch.role === "user" || patch.active === false;
-    if (removesAdmin) {
-      const target = await this.repository.findById(userId);
-      const targetIsActiveAdmin = target?.role === "admin" && target.active;
-      if (targetIsActiveAdmin) {
-        const activeAdmins = (await this.repository.list()).filter(
-          (user) => user.role === "admin" && user.active
-        );
-        if (activeAdmins.length <= 1) throw new LastAdminError();
-      }
+    try {
+      return await this.repository.updateRoleAndActive(userId, patch);
+    } catch (error) {
+      if (error instanceof LastActiveAdminStoreError) throw new LastAdminError();
+      throw error;
     }
-    return this.repository.updateRoleAndActive(userId, patch);
   }
 
   /** Admin-triggered reset with a new start password; forces a change on next login. */
   async resetPassword(userId: string, newPassword: string) {
-    const passwordHash = await hashPassword(newPassword);
+    const passwordHash = await this.passwords.hash(newPassword);
     return this.repository.setPassword(userId, passwordHash, true);
   }
 
@@ -144,15 +142,15 @@ export class UserService {
   async changeOwnPassword(userId: string, currentPassword: string, newPassword: string) {
     const user = await this.repository.findById(userId);
     if (!user) throw new WrongPasswordError();
-    const currentMatches = await verifyPassword(currentPassword, user.passwordHash);
+    const currentMatches = await this.passwords.verify(currentPassword, user.passwordHash);
     if (!currentMatches) throw new WrongPasswordError();
     if (newPassword === currentPassword) throw new PasswordUnchangedError();
-    const passwordHash = await hashPassword(newPassword);
+    const passwordHash = await this.passwords.hash(newPassword);
     return this.repository.setPassword(userId, passwordHash, false);
   }
 
   private getDummyHash(): Promise<string> {
-    this.dummyHash ??= hashPassword("dummy-password-for-constant-time-login");
+    this.dummyHash ??= this.passwords.hash("dummy-password-for-constant-time-login");
     return this.dummyHash;
   }
 }
diff --git a/src/frontend/components/Sidebar.tsx b/src/frontend/components/Sidebar.tsx
index 5130d5d..e99b493 100644
--- a/src/frontend/components/Sidebar.tsx
+++ b/src/frontend/components/Sidebar.tsx
@@ -7,6 +7,7 @@ import { listProjects } from "../utils/api";
 import type { ProjectDto } from "../types";
 import { ThemeToggle } from "./ThemeToggle";
 import { useAuth } from "./AuthProvider";
+import { getConfigEntry } from "../utils/config-access";
 
 // Anchors on the project overview page (/projects/[id]).
 const PROJECT_SECTIONS = [
@@ -32,6 +33,7 @@ interface SidebarProps {
 export function Sidebar({ isCollapsed, onToggleCollapsed }: SidebarProps) {
   const pathname = usePathname();
   const { user, isAdmin, logout } = useAuth();
+  const configEntry = getConfigEntry(isAdmin);
   const projectMatch = pathname?.match(PROJECT_PATH_PATTERN);
   const activeProjectId = projectMatch ? projectMatch[1] : null;
   const projectSubPath = projectMatch?.[2] ?? "";
@@ -181,18 +183,16 @@ export function Sidebar({ isCollapsed, onToggleCollapsed }: SidebarProps) {
           </>
         )}
       </nav>
-      {isAdmin && (
-        <nav className="sidebar-nav sidebar-nav-bottom">
-          <Link
-            href="/config"
-            className={pathname?.startsWith("/config") ? "sidebar-link active" : "sidebar-link"}
-            title="Config"
-          >
-            <span className="sidebar-icon">⚙</span>
-            <span className="sidebar-label">Config</span>
-          </Link>
-        </nav>
-      )}
+      <nav className="sidebar-nav sidebar-nav-bottom">
+        <Link
+          href={configEntry.href}
+          className={pathname?.startsWith("/config") ? "sidebar-link active" : "sidebar-link"}
+          title={configEntry.label}
+        >
+          <span className="sidebar-icon">⚙</span>
+          <span className="sidebar-label">{configEntry.label}</span>
+        </Link>
+      </nav>
       <div className="sidebar-footer">
         {user && !isCollapsed && (
           <div className="sidebar-identity" title={`Angemeldet als ${user.name}`}>
diff --git a/src/frontend/components/cable-sizing-api.ts b/src/frontend/components/cable-sizing-api.ts
index 28530d2..73582b5 100644
--- a/src/frontend/components/cable-sizing-api.ts
+++ b/src/frontend/components/cable-sizing-api.ts
@@ -6,6 +6,10 @@ import type {
   CableSizingInput,
   CableSizingResult,
 } from "../../cable-sizing/domain/cable-sizing-calculation";
+import {
+  WRITE_REQUEST_HEADER_NAME,
+  WRITE_REQUEST_HEADER_VALUE,
+} from "../../shared/constants/request-security";
 
 export interface CalculateCableSizingResponse {
   result: CableSizingResult;
@@ -17,7 +21,10 @@ export async function calculateCableSizing(
 ): Promise<CalculateCableSizingResponse> {
   const response = await fetch("/api/cable-sizing/calculate", {
     method: "POST",
-    headers: { "Content-Type": "application/json" },
+    headers: {
+      "Content-Type": "application/json",
+      [WRITE_REQUEST_HEADER_NAME]: WRITE_REQUEST_HEADER_VALUE,
+    },
     body: JSON.stringify(input),
     cache: "no-store",
   });
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index 8f5a878..5256195 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -1,3 +1,7 @@
+import {
+  WRITE_REQUEST_HEADER_NAME,
+  WRITE_REQUEST_HEADER_VALUE,
+} from "../../shared/constants/request-security";
 import type {
   BuildingDto,
   CircuitListDto,
@@ -122,6 +126,7 @@ async function request<T>(url: string, init?: RequestInit): Promise<T> {
     ...init,
     headers: {
       "Content-Type": "application/json",
+      [WRITE_REQUEST_HEADER_NAME]: WRITE_REQUEST_HEADER_VALUE,
       ...init?.headers,
     },
     cache: "no-store",
diff --git a/src/frontend/utils/auth-api.ts b/src/frontend/utils/auth-api.ts
index f7057f9..a6f12b3 100644
--- a/src/frontend/utils/auth-api.ts
+++ b/src/frontend/utils/auth-api.ts
@@ -1,3 +1,8 @@
+import {
+  WRITE_REQUEST_HEADER_NAME,
+  WRITE_REQUEST_HEADER_VALUE,
+} from "../../shared/constants/request-security";
+
 // Small, self-contained fetch helper for the auth/user endpoints - kept
 // separate from the large domain api.ts so this feature doesn't have to
 // touch that file's shared `request()` internals.
@@ -39,7 +44,11 @@ export class AuthApiError extends Error {
 async function request<T>(url: string, init?: RequestInit): Promise<T> {
   const response = await fetch(url, {
     ...init,
-    headers: { "Content-Type": "application/json", ...init?.headers },
+    headers: {
+      "Content-Type": "application/json",
+      [WRITE_REQUEST_HEADER_NAME]: WRITE_REQUEST_HEADER_VALUE,
+      ...init?.headers,
+    },
     cache: "no-store",
   });
   if (!response.ok) {
diff --git a/src/frontend/utils/config-access.ts b/src/frontend/utils/config-access.ts
new file mode 100644
index 0000000..86dd2a2
--- /dev/null
+++ b/src/frontend/utils/config-access.ts
@@ -0,0 +1,25 @@
+export interface ConfigNavigationEntry {
+  href: string;
+  label: string;
+}
+
+const ACCOUNT_ENTRY = { href: "/config/konto", label: "Konto" } as const;
+const USERS_ENTRY = { href: "/config/benutzer", label: "Benutzer" } as const;
+
+export function getConfigTabs(isAdmin: boolean): ConfigNavigationEntry[] {
+  return isAdmin ? [USERS_ENTRY, ACCOUNT_ENTRY] : [ACCOUNT_ENTRY];
+}
+
+export function getConfigEntry(isAdmin: boolean): ConfigNavigationEntry {
+  return isAdmin ? { href: USERS_ENTRY.href, label: "Config" } : ACCOUNT_ENTRY;
+}
+
+export function getConfigRedirect(pathname: string | null, isAdmin: boolean): string | null {
+  if (pathname === "/config") {
+    return isAdmin ? USERS_ENTRY.href : ACCOUNT_ENTRY.href;
+  }
+  if (!isAdmin && pathname?.startsWith(USERS_ENTRY.href)) {
+    return ACCOUNT_ENTRY.href;
+  }
+  return null;
+}
diff --git a/src/server/auth/auth.middleware.ts b/src/server/auth/auth.middleware.ts
index ce65bfb..bafae03 100644
--- a/src/server/auth/auth.middleware.ts
+++ b/src/server/auth/auth.middleware.ts
@@ -2,8 +2,12 @@ import type { NextFunction, Request, RequestHandler, Response } from "express";
 import { SESSION_COOKIE, type AuthConfig } from "./auth-config.js";
 import { readCookie } from "./cookie.js";
 import type { SessionStore } from "./sessions.js";
-import type { UserRepository } from "../../db/repositories/user.repository.js";
+import type { UserStore } from "../../domain/ports/user.store.js";
 import type { UserRole } from "../../shared/constants/user-roles.js";
+import {
+  WRITE_REQUEST_HEADER_NAME,
+  WRITE_REQUEST_HEADER_VALUE,
+} from "../../shared/constants/request-security.js";
 
 export interface AuthUser {
   id: string;
@@ -30,7 +34,7 @@ export function sessionIdFromRequest(req: {
 export async function identityFromRequest(
   req: { headers: { cookie?: string | undefined } },
   sessions: SessionStore,
-  users: UserRepository,
+  users: Pick<UserStore, "findById">,
   slideExpiry = true
 ): Promise<AuthUser | undefined> {
   const session = sessions.get(sessionIdFromRequest(req), slideExpiry);
@@ -74,10 +78,11 @@ const SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
  * CSRF defense for cookie-authenticated writes.
  *
  * SameSite=Lax alone is not enough here: every other service on the same
- * host (other ports of the same IP) counts as "same-site" and would get the
- * cookie attached. Browsers send Sec-Fetch-Site on every request, so a write
- * is only accepted from the app's own origin. Clients without the header
- * (curl, scripts) carry no ambient browser cookie and are not a CSRF vector.
+ * host (other ports of the same IP) counts as "same-site" and may receive the
+ * cookie. Fetch Metadata is also not guaranteed on plain HTTP in the LAN.
+ * Every write therefore needs an application header that HTML forms cannot
+ * set; a cross-origin fetch would require a CORS preflight, which the API does
+ * not permit. Sec-Fetch-Site remains an additional browser-side check.
  */
 export function requireSameOriginForWrites(): RequestHandler {
   return (req: Request, res: Response, next: NextFunction) => {
@@ -85,6 +90,10 @@ export function requireSameOriginForWrites(): RequestHandler {
       next();
       return;
     }
+    if (req.get(WRITE_REQUEST_HEADER_NAME) !== WRITE_REQUEST_HEADER_VALUE) {
+      res.status(403).json({ error: "Schreibzugriff ohne gültigen Anwendungsnachweis abgelehnt." });
+      return;
+    }
     const fetchSite = req.headers["sec-fetch-site"];
     if (fetchSite === undefined || fetchSite === "same-origin" || fetchSite === "none") {
       next();
@@ -98,7 +107,7 @@ export function requireSameOriginForWrites(): RequestHandler {
 export function createAuthGuard(
   authConfig: AuthConfig,
   sessions: SessionStore,
-  users: UserRepository,
+  users: Pick<UserStore, "findById">,
   openPaths: readonly string[] = ["/auth/login", "/auth/status", "/auth/logout"]
 ): RequestHandler {
   return (req: Request, res: Response, next: NextFunction) => {
diff --git a/src/server/auth/password.ts b/src/server/auth/password.ts
index 96814e1..97132af 100644
--- a/src/server/auth/password.ts
+++ b/src/server/auth/password.ts
@@ -4,6 +4,12 @@ const SCRYPT_N = 16384;
 const SCRYPT_R = 8;
 const SCRYPT_P = 1;
 const KEY_LENGTH = 64;
+const SALT_LENGTH = 16;
+const MAX_SCRYPT_MEMORY = 64 * 1024 * 1024;
+const MIN_SCRYPT_N = 1 << 14;
+const MAX_SCRYPT_N = 1 << 16;
+const MAX_SCRYPT_R = 16;
+const MAX_SCRYPT_P = 8;
 
 // A hand-rolled wrapper instead of util.promisify(scrypt): promisify only
 // resolves to scrypt's 3-argument overload, so the 4-argument form used for
@@ -30,8 +36,13 @@ function scryptAsync(
 // Format: scrypt$N$r$p$saltHex$hashHex - the parameters travel with the
 // hash so they can be tuned later without invalidating existing rows.
 export async function hashPassword(password: string): Promise<string> {
-  const salt = randomBytes(16);
-  const derivedKey = await scryptAsync(password, salt, KEY_LENGTH);
+  const salt = randomBytes(SALT_LENGTH);
+  const derivedKey = await scryptAsync(password, salt, KEY_LENGTH, {
+    N: SCRYPT_N,
+    r: SCRYPT_R,
+    p: SCRYPT_P,
+    maxmem: MAX_SCRYPT_MEMORY,
+  });
   return [
     "scrypt",
     SCRYPT_N,
@@ -52,12 +63,33 @@ export async function verifyPassword(
   const n = Number(nRaw);
   const r = Number(rRaw);
   const p = Number(pRaw);
-  if (!Number.isFinite(n) || !Number.isFinite(r) || !Number.isFinite(p)) {
+  if (
+    !Number.isSafeInteger(n) ||
+    n < MIN_SCRYPT_N ||
+    n > MAX_SCRYPT_N ||
+    (n & (n - 1)) !== 0 ||
+    !Number.isSafeInteger(r) ||
+    r < 1 ||
+    r > MAX_SCRYPT_R ||
+    !Number.isSafeInteger(p) ||
+    p < 1 ||
+    p > MAX_SCRYPT_P ||
+    !/^[0-9a-f]{32}$/i.test(saltHex) ||
+    !/^[0-9a-f]{128}$/i.test(hashHex)
+  ) {
     return false;
   }
   const salt = Buffer.from(saltHex, "hex");
   const expected = Buffer.from(hashHex, "hex");
-  const derivedKey = await scryptAsync(password, salt, expected.length, { N: n, r, p });
-  if (derivedKey.length !== expected.length) return false;
-  return timingSafeEqual(derivedKey, expected);
+  try {
+    const derivedKey = await scryptAsync(password, salt, expected.length, {
+      N: n,
+      r,
+      p,
+      maxmem: MAX_SCRYPT_MEMORY,
+    });
+    return timingSafeEqual(derivedKey, expected);
+  } catch {
+    return false;
+  }
 }
diff --git a/src/server/composition/auth.ts b/src/server/composition/auth.ts
index 1b5ce09..07b822b 100644
--- a/src/server/composition/auth.ts
+++ b/src/server/composition/auth.ts
@@ -3,9 +3,14 @@ import { LoginThrottle } from "../auth/login-throttle.js";
 import { SessionStore } from "../auth/sessions.js";
 import { UserService } from "../../domain/services/user.service.js";
 import { userRepository } from "./application-repositories.js";
+import { hashPassword, verifyPassword } from "../auth/password.js";
 
 export const authConfig = readAuthConfig();
 export const sessionStore = new SessionStore(authConfig.sessionTtlMs, authConfig.sessionMaxAgeMs);
 sessionStore.startSweeping();
 export const loginThrottle = new LoginThrottle();
-export const userService = new UserService(userRepository, authConfig);
+export const userService = new UserService(
+  userRepository,
+  { bootstrap: authConfig.bootstrap },
+  { hash: hashPassword, verify: verifyPassword }
+);
diff --git a/src/shared/constants/request-security.ts b/src/shared/constants/request-security.ts
new file mode 100644
index 0000000..f89ce10
--- /dev/null
+++ b/src/shared/constants/request-security.ts
@@ -0,0 +1,2 @@
+export const WRITE_REQUEST_HEADER_NAME = "X-Leistungsbilanz-Request";
+export const WRITE_REQUEST_HEADER_VALUE = "1";
diff --git a/tests/authentication.test.ts b/tests/authentication.test.ts
index e634716..e5c431d 100644
--- a/tests/authentication.test.ts
+++ b/tests/authentication.test.ts
@@ -21,6 +21,10 @@ import { requireSameOriginForWrites } from "../src/server/auth/auth.middleware.j
 import type { AuthConfig } from "../src/server/auth/auth-config.js";
 import { createUserSchema } from "../src/shared/validation/user.schemas.js";
 import { loginSchema } from "../src/shared/validation/auth.schemas.js";
+import {
+  WRITE_REQUEST_HEADER_NAME,
+  WRITE_REQUEST_HEADER_VALUE,
+} from "../src/shared/constants/request-security.js";
 
 const HOUR = 60 * 60 * 1000;
 
@@ -34,7 +38,14 @@ function createUserService() {
     cookieSecure: false,
     bootstrap: { username: "admin", password: "bootstrap-password-123" },
   };
-  return { repository, service: new UserService(repository, config) };
+  return {
+    repository,
+    service: new UserService(
+      repository,
+      { bootstrap: config.bootstrap },
+      { hash: hashPassword, verify: verifyPassword }
+    ),
+  };
 }
 
 describe("password hashing", () => {
@@ -52,6 +63,17 @@ describe("password hashing", () => {
   it("rejects malformed stored hashes instead of throwing", async () => {
     assert.equal(await verifyPassword("x", "not-a-hash"), false);
     assert.equal(await verifyPassword("x", "scrypt$a$b$c$00$00"), false);
+    assert.equal(
+      await verifyPassword(
+        "x",
+        `scrypt$1073741824$8$1$${"00".repeat(16)}$${"00".repeat(64)}`
+      ),
+      false
+    );
+    assert.equal(
+      await verifyPassword("x", `scrypt$16384$8$1$00$${"00".repeat(64)}`),
+      false
+    );
   });
 });
 
@@ -135,12 +157,20 @@ describe("cookie parsing", () => {
 });
 
 describe("same-origin guard for writes", () => {
-  function run(method: string, fetchSite?: string) {
+  function run(method: string, fetchSite?: string, includeApplicationHeader = true) {
     let status: number | undefined;
     let passed = false;
     const req = {
       method,
-      headers: fetchSite ? { "sec-fetch-site": fetchSite } : {},
+      headers: {
+        ...(fetchSite ? { "sec-fetch-site": fetchSite } : {}),
+        ...(includeApplicationHeader
+          ? { [WRITE_REQUEST_HEADER_NAME.toLowerCase()]: WRITE_REQUEST_HEADER_VALUE }
+          : {}),
+      },
+      get(name: string) {
+        return this.headers[name.toLowerCase() as keyof typeof this.headers];
+      },
     } as unknown as Request;
     const res = {
       status(code: number) {
@@ -158,12 +188,13 @@ describe("same-origin guard for writes", () => {
   }
 
   it("lets reads and same-origin writes through", () => {
-    assert.equal(run("GET", "cross-site").passed, true);
+    assert.equal(run("GET", "cross-site", false).passed, true);
     assert.equal(run("POST", "same-origin").passed, true);
-    assert.equal(run("POST").passed, true, "non-browser clients carry no ambient cookie");
+    assert.equal(run("POST").passed, true, "scripts can send the explicit application header");
   });
 
-  it("rejects writes from other sites and other ports of the same host", () => {
+  it("rejects writes without the application header or from another origin", () => {
+    assert.deepEqual(run("POST", undefined, false), { passed: false, status: 403 });
     assert.deepEqual(run("POST", "cross-site"), { passed: false, status: 403 });
     assert.deepEqual(run("PATCH", "same-site"), { passed: false, status: 403 });
     assert.deepEqual(run("DELETE", "same-site"), { passed: false, status: 403 });
@@ -239,6 +270,30 @@ describe("user service", () => {
     await assert.rejects(service.updateRoleAndActive(second.id, { active: false }), LastAdminError);
   });
 
+  it("preserves one active admin across concurrent updates", async () => {
+    const { repository, service } = createUserService();
+    await service.ensureBootstrapAdmin();
+    const second = await service.createUser({
+      username: "zweiter-admin",
+      name: "Zweiter Admin",
+      role: "admin",
+      initialPassword: "start-passwort",
+    });
+    assert.ok(second);
+    const [first] = (await repository.list()).filter((user) => user.username === "admin");
+
+    const results = await Promise.allSettled([
+      service.updateRoleAndActive(first.id, { role: "user" }),
+      service.updateRoleAndActive(second.id, { role: "user" }),
+    ]);
+    assert.equal(results.filter((result) => result.status === "fulfilled").length, 1);
+    assert.equal(results.filter((result) => result.status === "rejected").length, 1);
+    const activeAdmins = (await repository.list()).filter(
+      (user) => user.role === "admin" && user.active
+    );
+    assert.equal(activeAdmins.length, 1);
+  });
+
   it("requires the current password and a different new one", async () => {
     const { service } = createUserService();
     const user = await service.createUser({
diff --git a/tests/config-access.test.ts b/tests/config-access.test.ts
new file mode 100644
index 0000000..3fdc83d
--- /dev/null
+++ b/tests/config-access.test.ts
@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  getConfigEntry,
+  getConfigRedirect,
+  getConfigTabs,
+} from "../src/frontend/utils/config-access.js";
+
+describe("config access", () => {
+  it("offers account settings to every signed-in user", () => {
+    assert.deepEqual(getConfigEntry(false), { href: "/config/konto", label: "Konto" });
+    assert.deepEqual(getConfigTabs(false), [{ href: "/config/konto", label: "Konto" }]);
+    assert.equal(getConfigRedirect("/config", false), "/config/konto");
+    assert.equal(getConfigRedirect("/config/konto", false), null);
+  });
+
+  it("keeps user administration admin-only", () => {
+    assert.equal(getConfigRedirect("/config/benutzer", false), "/config/konto");
+    assert.deepEqual(getConfigTabs(true), [
+      { href: "/config/benutzer", label: "Benutzer" },
+      { href: "/config/konto", label: "Konto" },
+    ]);
+    assert.deepEqual(getConfigEntry(true), { href: "/config/benutzer", label: "Config" });
+    assert.equal(getConfigRedirect("/config/benutzer", true), null);
+  });
+});
diff --git a/tests/write-request-headers.test.ts b/tests/write-request-headers.test.ts
new file mode 100644
index 0000000..c78a277
--- /dev/null
+++ b/tests/write-request-headers.test.ts
@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { authApi } from "../src/frontend/utils/auth-api.js";
+import { createProject } from "../src/frontend/utils/api.js";
+import { calculateCableSizing } from "../src/frontend/components/cable-sizing-api.js";
+import type { CableSizingInput } from "../src/cable-sizing/domain/cable-sizing-calculation.js";
+import {
+  WRITE_REQUEST_HEADER_NAME,
+  WRITE_REQUEST_HEADER_VALUE,
+} from "../src/shared/constants/request-security.js";
+
+describe("write request clients", () => {
+  it("send the application header from every frontend API client", async () => {
+    const originalFetch = globalThis.fetch;
+    const requests: RequestInit[] = [];
+    globalThis.fetch = async (_input, init) => {
+      requests.push(init ?? {});
+      return new Response(JSON.stringify({}), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    };
+
+    try {
+      await authApi.login("admin", "start-passwort");
+      await createProject("Testprojekt");
+      await calculateCableSizing({} as CableSizingInput);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+
+    assert.equal(requests.length, 3);
+    for (const request of requests) {
+      assert.equal(
+        new Headers(request.headers).get(WRITE_REQUEST_HEADER_NAME),
+        WRITE_REQUEST_HEADER_VALUE
+      );
+    }
+  });
+});

From 3670f02ccdec07dacac7b475ea328dd72dad670a Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Mon, 28 Sep 2026 22:42:11 +0200
Subject: [PATCH 46/60] Document authenticated deployment

---
 .env.example                 |  7 +++++++
 .gitignore                   |  3 +++
 AGENTS.md                    |  5 ++++-
 README.md                    | 21 ++++++++++++++++----
 compose.dev.yaml             |  2 ++
 compose.yaml                 |  2 +-
 docs/authentication.md       | 25 ++++++++++++++++++------
 docs/current-architecture.md | 14 +++++++++++++
 docs/deployment.md           | 38 ++++++++++++++++++++++++++++--------
 9 files changed, 97 insertions(+), 20 deletions(-)
 create mode 100644 .env.example

diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..46fa42a
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,7 @@
+# Nur beim ersten Start mit leerer Benutzertabelle erforderlich.
+AUTH_BOOTSTRAP_USERNAME=
+AUTH_BOOTSTRAP_PASSWORT=
+AUTH_SESSION_HOURS=12
+AUTH_SESSION_MAX_DAYS=7
+# Hinter HTTPS true, bei direktem HTTP-Zugriff im LAN false.
+COOKIE_SECURE=false
diff --git a/.gitignore b/.gitignore
index a6e1ff5..b237969 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,9 @@
 node_modules/
 dist/
 .next/
+.env
+.env.*
+!.env.example
 # Streuprodukt von tsc; drizzle-kit liest drizzle.config.ts.
 /drizzle.config.js
 data/*.db
diff --git a/AGENTS.md b/AGENTS.md
index 65b5fab..b01e6b5 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -42,7 +42,10 @@ It must support circuits, device rows, project devices, drag-and-drop restructur
   `src/db/repositories/user.repository.ts`. Every `/api/*` route requires a
   signed-in user (`src/server/index.ts`); `/api/users/*` additionally
   requires `admin`. Frontend gate: `AuthProvider` + `LoginGate`
-  (`src/app/layout.tsx`). See `docs/authentication.md` for the full picture.
+  (`src/app/layout.tsx`). Every unsafe API request also requires the explicit
+  `X-Leistungsbilanz-Request: 1` application header, including over plain HTTP.
+  Account settings are available to every signed-in user; user administration
+  remains admin-only. See `docs/authentication.md` for the full picture.
 
 The supported runtime model is Circuit-First. The former Consumer UI, API,
 tables and upgrade tooling are removed; do not reintroduce them.
diff --git a/README.md b/README.md
index b01ae85..f64ae04 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,9 @@ Gerätezeilen und wiederverwendbare Projektgeräte fachlich getrennt behandelt.
 Das Projekt befindet sich in aktiver Entwicklung. Für SQLite stehen ein
 Docker-Server-Stack mit gebautem Anwendungscode und ein separater
 Entwicklungsstack bereit. Ein vollständig unterstütztes Produktionsdeployment
-und Mehrbenutzerbetrieb fehlen weiterhin. Revit-CSV-Konfiguration, Vorschau
+für mehrere gleichzeitig arbeitende Prozesse und ein vollständig unterstütztes
+Produktionsdeployment fehlen weiterhin. Anmeldung und zwei feste Rollen sind
+vorhanden. Revit-CSV-Konfiguration, Vorschau
 und bestätigter Erstimport sind implementiert; die Editoroberfläche zur
 Objektzuordnung, Folgeimporte und Rückexport stehen noch aus. Die weitere
 Revit-Arbeit ist zurückgestellt und erfolgt später über den CSV-Export/-Import
@@ -60,6 +62,8 @@ Voraussetzungen:
 ```powershell
 git clone <repository-url>
 Set-Location leistungsbilanz-ts
+$env:AUTH_BOOTSTRAP_USERNAME = "admin"
+$env:AUTH_BOOTSTRAP_PASSWORT = "<eigenes Startpasswort mit mindestens 12 Zeichen>"
 docker compose up --build --detach
 ```
 
@@ -68,9 +72,15 @@ Danach:
 - Frontend: <http://localhost:3001>
 - API-Healthcheck: <http://localhost:3001/health> (über den Next.js-Rewrite)
 
-Die Express-API ist nicht mehr auf dem Host veröffentlicht. Sie hat keine
-Authentifizierung und ist nur innerhalb des Compose-Netzes erreichbar; der
-Zugriff läuft über den Rewrite im Web-Dienst.
+Beim ersten Start erzeugen diese beiden Variablen genau einen Administrator,
+solange die Benutzertabelle noch leer ist. Danach werden sie ignoriert. Für
+einen dauerhaften Serverbetrieb gehören die Werte in eine nicht versionierte
+`.env` neben `compose.yaml`; Details stehen unter
+[Anmeldung und Benutzerverwaltung](docs/authentication.md).
+
+Die Express-API ist nicht auf dem Host veröffentlicht. Sämtliche fachlichen
+API-Routen verlangen eine gültige Anmeldung; der Zugriff läuft über den
+Rewrite im Web-Dienst.
 
 Der API-Container führt ausstehende Migrationen und die Schemaprüfung beim Start
 automatisch aus. Die SQLite-Datei liegt auf dem Host unter
@@ -116,6 +126,8 @@ Voraussetzungen:
 npm ci
 npm run db:migrate
 npm run db:verify:circuit-schema
+$env:AUTH_BOOTSTRAP_USERNAME = "admin"
+$env:AUTH_BOOTSTRAP_PASSWORT = "<eigenes Startpasswort mit mindestens 12 Zeichen>"
 npm run dev:api
 ```
 
@@ -162,6 +174,7 @@ vor der Baseline werden nicht unterstützt.
 - [Gebäudestruktur und Raumflächen](docs/building-structure.md)
 - [Grobe Leistungsbilanz](docs/estimate-balance.md)
 - [Leitungsberechnung](docs/cable-sizing-module.md)
+- [Anmeldung und Benutzerverwaltung](docs/authentication.md)
 - [Entwicklungs- und Contributor-Workflow](docs/development-workflow.md)
 - [Bekannte Einschränkungen](docs/circuit-list-editor-known-limitations.md)
 - [Roadmap](docs/spec/07-implementation-phases-todo.md)
diff --git a/compose.dev.yaml b/compose.dev.yaml
index 2c362bc..f49e9e6 100644
--- a/compose.dev.yaml
+++ b/compose.dev.yaml
@@ -38,6 +38,8 @@ services:
       AUTH_BOOTSTRAP_USERNAME: "${AUTH_BOOTSTRAP_USERNAME:-}"
       AUTH_BOOTSTRAP_PASSWORT: "${AUTH_BOOTSTRAP_PASSWORT:-}"
       AUTH_SESSION_HOURS: "${AUTH_SESSION_HOURS:-12}"
+      AUTH_SESSION_MAX_DAYS: "${AUTH_SESSION_MAX_DAYS:-7}"
+      COOKIE_SECURE: "${COOKIE_SECURE:-false}"
     # Nur auf dem Loopback: die API darf nicht aus dem LAN erreichbar sein.
     ports:
       - "127.0.0.1:3000:3000"
diff --git a/compose.yaml b/compose.yaml
index 2a2eecd..1de9104 100644
--- a/compose.yaml
+++ b/compose.yaml
@@ -47,7 +47,7 @@ services:
       LOG_LEVEL: "${LOG_LEVEL:-info}"
       # AUTH_BOOTSTRAP_* legen nur den allerersten Admin an (solange die
       # users-Tabelle leer ist) und gehoeren in eine lokale, nicht versionierte
-      # .env - siehe docs/AUTH.md.
+      # .env - siehe docs/authentication.md.
       AUTH_BOOTSTRAP_USERNAME: "${AUTH_BOOTSTRAP_USERNAME:-}"
       AUTH_BOOTSTRAP_PASSWORT: "${AUTH_BOOTSTRAP_PASSWORT:-}"
       AUTH_SESSION_HOURS: "${AUTH_SESSION_HOURS:-12}"
diff --git a/docs/authentication.md b/docs/authentication.md
index 15729aa..32039cf 100644
--- a/docs/authentication.md
+++ b/docs/authentication.md
@@ -7,10 +7,9 @@ Zugang wird von einem Administrator über **Config → Benutzer** angelegt.
 
 Es gibt genau zwei Rollen (`src/shared/constants/user-roles.ts`):
 
-- **admin** – wie `user`, zusätzlich Zugriff auf den Config-Bereich
-  (Benutzerverwaltung, eigenes Konto)
+- **admin** – wie `user`, zusätzlich Zugriff auf **Config → Benutzer**
 - **user** – volle Nutzung der Leistungsbilanz (Projekte, Stromkreislisten,
-  Grobbilanz, …), kein Zugriff auf Config
+  Grobbilanz, …) und Zugriff auf das eigene Konto, keine Benutzerverwaltung
 
 Es gibt (bewusst, siehe unten) keine konfigurierbare Rechte-Matrix und keine
 Verknüpfung mit einer Mitarbeiter-/Personen-Stammdatentabelle.
@@ -44,6 +43,8 @@ Verknüpfung mit einer Mitarbeiter-/Personen-Stammdatentabelle.
 - **Frontend:** `AuthProvider` lädt `/api/auth/me`; `LoginGate`
   (`src/app/layout.tsx`) zeigt Login- bzw. Passwortformular, solange nicht
   angemeldet bzw. `mustChangePassword` gesetzt ist, sonst die App.
+  **Konto** ist für jede angemeldete Person erreichbar; **Benutzer** nur für
+  Administratoren.
 
 ## Schutzmechanismen
 
@@ -52,12 +53,12 @@ Verknüpfung mit einer Mitarbeiter-/Personen-Stammdatentabelle.
 | Passwort-Raten (online) | `LoginThrottle`: 5 Fehlversuche je Anmeldename in 15 min → HTTP 429 bis das Fenster abläuft. Schlüssel ist der Name, nicht die IP (alle Anfragen kommen über den Next-Rewrite mit derselben Quell-IP). |
 | Passwort-Raten (offline, DB-Diebstahl) | scrypt (N=16384, r=8, p=1), eigenes Salt je Hash |
 | Nutzernamen ausspähen (Timing) | Unbekannte Namen werden gegen einen festen Dummy-Hash geprüft – immer genau ein scrypt-Lauf; einheitliche Fehlermeldung |
-| CSRF | SameSite=Lax **plus** `requireSameOriginForWrites`: schreibende Anfragen nur mit `Sec-Fetch-Site: same-origin`. Nötig, weil andere Dienste auf demselben Host (andere Ports) als „same-site“ gelten |
-| CSRF über reines HTTP | Browser senden `Sec-Fetch-Site` nur an HTTPS-Adressen. Beim Zugriff per `http://…` im LAN greift deshalb nur SameSite=Lax (schützt gegen fremde Domains, nicht gegen andere Ports desselben Hosts). |
+| CSRF | SameSite=Lax **plus** `requireSameOriginForWrites`: jeder Schreibzugriff braucht `X-Leistungsbilanz-Request: 1`; fremde HTML-Formulare können den Header nicht setzen und ein fremder Fetch scheitert an der notwendigen CORS-Preflight-Anfrage. Ein vorhandener `Sec-Fetch-Site`-Header wird zusätzlich geprüft. |
+| CSRF über reines HTTP | Der eigene Anwendungsheader gilt auch dann, wenn Browser im HTTP-LAN keinen `Sec-Fetch-Site`-Header senden. Skripte und manuelle API-Aufrufe müssen ihn bei `POST`, `PUT`, `PATCH` und `DELETE` ausdrücklich mitsenden. |
 | Session-Fixation | Neue Session-ID bei jedem Login und nach jedem Passwortwechsel |
 | Gestohlenes Cookie | httpOnly; gleitende Laufzeit (`AUTH_SESSION_HOURS`, 12 h) **und** harte Obergrenze (`AUTH_SESSION_MAX_DAYS`, 7 Tage) |
 | Kompromittiertes Konto | Passwort-Reset und Deaktivieren beenden sofort alle Sessions des Kontos; Passwortwechsel beendet alle anderen |
-| Aussperren | Der letzte aktive Admin kann weder herabgestuft noch deaktiviert werden; eigener Zugang ist in der Liste gesperrt |
+| Aussperren | Der letzte aktive Admin kann weder herabgestuft noch deaktiviert werden; Prüfung und Änderung laufen atomar in einer SQLite-Transaktion. Der eigene Zugang ist in der Liste gesperrt. |
 | Rechteausweitung / Mass Assignment | Rolle kommt aus der DB, nie aus der Anfrage; zod-Schemas mit `.strict()` |
 | DoS über riesige Passwörter | Längengrenzen (Name 100, Passwort 200 Zeichen) vor scrypt |
 | Look-alike-Namen | Anmeldename nur `a-z 0-9 . _ @ -`, klein geschrieben |
@@ -77,6 +78,18 @@ ignoriert; jeder weitere Zugang entsteht über Config → Benutzer. Die Werte
 gehören in eine lokale, nicht versionierte `.env` auf dem Deploy-Host, nicht
 in `compose.yaml` selbst.
 
+```dotenv
+AUTH_BOOTSTRAP_USERNAME=admin
+AUTH_BOOTSTRAP_PASSWORT=<eigenes Startpasswort mit mindestens 12 Zeichen>
+AUTH_SESSION_HOURS=12
+AUTH_SESSION_MAX_DAYS=7
+COOKIE_SECURE=false
+```
+
+Bei Zugriff über HTTPS muss `COOKIE_SECURE=true` gesetzt werden. Bei direktem
+HTTP-Zugriff im LAN bleibt es `false`, da der Browser das Session-Cookie sonst
+nicht speichert.
+
 ## Bewusst nicht umgesetzt (Stand jetzt)
 
 - Konfigurierbare Rechte-Matrix statt fixer `admin`/`user`-Rollen
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 71b7feb..20c7ccd 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -33,6 +33,15 @@ mit Hot Reload. Das Frontend leitet `/api/*` über `API_INTERNAL_URL` an die API
 weiter; beim gebauten Stand wird das Ziel zur Build-Zeit festgelegt. Die
 Datenbank liegt über einen Host-Mount außerhalb des Containers.
 
+Vor allen fachlichen `/api/*`-Routen liegt die Cookie-basierte Anmeldung aus
+`src/server/auth`. Nur Login, Status und Logout sind ohne Session erreichbar.
+Schreibzugriffe verlangen zusätzlich den Anwendungsheader
+`X-Leistungsbilanz-Request: 1`, damit der Schutz auch beim HTTP-Zugriff im LAN
+ohne Fetch-Metadata-Header greift. `/api/users/*` ist Administratoren
+vorbehalten. Konten sind globale Betriebsdaten und gehören nicht zu
+Projektkommandos, Snapshots oder Projekttransfers. Sessions liegen im Speicher
+des einzelnen API-Prozesses und enden bei dessen Neustart.
+
 Neue IDs für Stromkreise, Gerätezeilen, Gruppen und Verteilerkomponenten erzeugt
 der Editor über `src/frontend/utils/client-id.ts` (`createClientId`). Die
 Hilfsfunktion nutzt `crypto.randomUUID()`, sofern verfügbar, andernfalls
@@ -57,6 +66,11 @@ vor dem Command und bleiben über Undo/Redo unverändert.
 - `src/frontend/components/circuit-grid-*.ts` – reine Grid-Projektion,
   Zellbesitz, Einfügen und Sicherheitsregeln
 - `src/frontend/utils/api.ts` – typisierte Frontend-API-Aufrufe
+- `src/frontend/components/AuthProvider.tsx` und `LoginGate.tsx` – Anmeldung
+  und erzwungener Wechsel eines Startpassworts
+- `src/server/auth/` – Passwort-Hashing, Sessions und Zugriffsschutz
+- `src/domain/services/user.service.ts` und `src/domain/ports/user.store.ts` –
+  kontobezogene Regeln und schmale Persistenzgrenze
 - `src/server/index.ts` und `src/server/routes/` – API-Komposition
 - `src/domain/services/` – fachliche Command- und Synchronisierungsregeln
 - `src/server/composition/` – Verdrahtung fachlicher Services mit konkreten
diff --git a/docs/deployment.md b/docs/deployment.md
index 0b5baba..89c99a3 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -16,10 +16,10 @@ und macOS keine inotify-Events durchreichen; das kostet dauerhaft CPU, auch
 ohne Benutzeraktivität. Dieser Stack gehört deshalb nur auf einen
 Entwicklungsrechner.
 
-Beide Stacks enthalten weder TLS, Authentifizierung, einen vorgeschalteten
-Reverse Proxy noch ein zentral betriebenes Datenbanksystem. Die oben genannten
-Container-Schutzmaßnahmen ersetzen diese Funktionen nicht. Der Stack darf
-deshalb nicht öffentlich erreichbar gemacht werden.
+Beide Stacks enthalten Anmeldung mit festen Rollen, aber weder TLS, einen
+vorgeschalteten Reverse Proxy noch ein zentral betriebenes Datenbanksystem.
+Passwörter und Session-Cookies werden bei reinem HTTP unverschlüsselt
+übertragen. Der Stack darf deshalb nicht öffentlich erreichbar gemacht werden.
 
 ## Topologie
 
@@ -29,9 +29,10 @@ deshalb nicht öffentlich erreichbar gemacht werden.
 | Express API | 3000 | nicht veröffentlicht (Server) / `127.0.0.1:3000` (Dev) | `GET /health` | `./data:/app/data` |
 | SQLite | Datei | – | Integritäts-/FK-Prüfung via Backup und Skript | `data/leistungsbilanz.db` |
 
-Die Express-API wird im Server-Stack nicht mehr auf dem Host veröffentlicht
-(`expose` statt `ports`). Sie hat keine Authentifizierung; jeder, der sie
-erreicht, kann jedes Projekt lesen und ändern. Erreichbar ist sie nur aus dem
+Die Express-API wird im Server-Stack nicht auf dem Host veröffentlicht
+(`expose` statt `ports`). Alle fachlichen API-Routen verlangen eine aktive
+Session; Schreibzugriffe zusätzlich den Anwendungsheader
+`X-Leistungsbilanz-Request: 1`. Erreichbar ist die API nur aus dem
 Compose-Netz, praktisch also über den Next.js-Rewrite. Im Entwicklungs-Stack
 hängen beide Ports am Loopback und sind nicht aus dem LAN erreichbar.
 
@@ -72,6 +73,26 @@ Verwendete Umgebungsvariablen:
   JSON-Loggers (`error`, `warn`, `info`, `verbose`, `debug`), Standard `info`.
   Setzbar über eine `.env`-Datei neben `compose.yaml` oder
   `LOG_LEVEL=verbose docker compose up`.
+- `AUTH_BOOTSTRAP_USERNAME` und `AUTH_BOOTSTRAP_PASSWORT` – erzeugen nur bei
+  leerer Benutzertabelle den ersten Administrator; das Startpasswort hat
+  mindestens 12 Zeichen.
+- `AUTH_SESSION_HOURS` – Inaktivitätsgrenze einer Session, Standard 12 Stunden.
+- `AUTH_SESSION_MAX_DAYS` – absolute Session-Laufzeit, Standard 7 Tage.
+- `COOKIE_SECURE` – hinter HTTPS `true`; beim direkten HTTP-Zugriff im LAN
+  `false`, da Browser das Cookie sonst nicht speichern.
+
+Vor dem ersten Start müssen mindestens die Bootstrap-Werte in einer lokalen,
+nicht versionierten `.env` neben `compose.yaml` gesetzt werden:
+
+```dotenv
+AUTH_BOOTSTRAP_USERNAME=admin
+AUTH_BOOTSTRAP_PASSWORT=<eigenes Startpasswort mit mindestens 12 Zeichen>
+```
+
+Nach dem ersten erfolgreichen Start werden diese Werte ignoriert, solange
+mindestens ein Benutzer existiert. Weitere Zugänge legt ein Administrator in
+**Config → Benutzer** an. Details stehen in
+[Anmeldung und Benutzerverwaltung](authentication.md).
 
 Beim API-Start laufen zuerst die Migrationen und die Schemaprüfung
 (`scripts/run-migrations.js` und `scripts/db-verify-circuit-schema.js`, im
@@ -137,7 +158,8 @@ bleibt `sh` der Vordergrundprozess, und `SIGTERM` erreicht Node nie.
 Vor einer produktiven Installation werden mindestens benötigt:
 
 - TLS-Termination und Reverse Proxy
-- Authentifizierung, Autorisierung und Benutzer-/Rollenmodell
+- zentraler Identitätsanbieter oder eine feinere Rechte-Matrix, falls die zwei
+  festen Rollen später nicht ausreichen
 - definierte Secrets- und Konfigurationsverwaltung
 - persistenter, gesicherter Datenbankbetrieb
 - kontrollierter einmaliger Migrationsschritt vor dem API-Rollout

From cf022b250f882d97bc897b0be4ce5329d29d8e91 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Mon, 28 Sep 2026 22:46:32 +0200
Subject: [PATCH 47/60] Format project device power values on project page

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/app/projects/[projectId]/page.tsx | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index 37813c1..ec99d54 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -73,6 +73,7 @@ import {
   updateProjectSettings,
 } from "../../../frontend/utils/api";
 import { createClientId } from "../../../frontend/utils/client-id";
+import { formatValue } from "../../../frontend/utils/circuit-grid-model";
 import {
   buildFeederCircuitSnapshot,
   getDefaultFeederCircuitSection,
@@ -1294,10 +1295,11 @@ export default function ProjectDetailPage() {
                     ) : null}
                   </td>
                   <td>
-                    {device.totalPower} kW
+                    {formatValue(device.totalPower, "rowTotalPower")} kW
                     <div className="small text-secondary">
-                      {device.quantity} × {device.powerPerUnit} kW · GZF{" "}
-                      {device.simultaneityFactor}
+                      {formatValue(device.quantity, "quantity")} ×{" "}
+                      {formatValue(device.powerPerUnit, "powerPerUnit")} kW · GZF{" "}
+                      {formatValue(device.simultaneityFactor, "simultaneityFactor")}
                     </div>
                   </td>
                   <td>{device.costGroup ?? "-"}</td>

From ae318a51ac05baadf606a8ec3865df2674376ada Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Tue, 29 Sep 2026 21:57:40 +0200
Subject: [PATCH 48/60] Audit Linear Excel integration

---
 docs/spec/revit-excel-r0-audit.md | 521 ++++++++++++++++++++++++++++++
 1 file changed, 521 insertions(+)
 create mode 100644 docs/spec/revit-excel-r0-audit.md

diff --git a/docs/spec/revit-excel-r0-audit.md b/docs/spec/revit-excel-r0-audit.md
new file mode 100644
index 0000000..721e402
--- /dev/null
+++ b/docs/spec/revit-excel-r0-audit.md
@@ -0,0 +1,521 @@
+# R0 – Audit der Linear-Excel-Anbindung
+
+Stand: 29.09.2026. Geprüfter Code: `cf022b2`.
+
+**Status: R0 abgeschlossen, Freigabe für R1–R10 ausstehend.** Dieser Bericht
+ist ein Umsetzungsvorschlag, kein Nachweis einer bereits implementierten
+Excel-Anbindung. Der neue Nutzerauftrag ersetzt die CSV-/IfcGUID-Vorgaben und
+die alte Phasenliste 14.0–14.6. R1 bereinigt die bestehenden Dokumente; R0
+ändert weder Laufzeitcode noch Datenbank noch Oberfläche.
+
+## 1. Geprüfter Bestand und Keep/Change/Remove
+
+Gelesene Grundlagen: `AGENTS.md`, `docs/current-architecture.md`,
+`docs/project-history-and-external-model-architecture.md`,
+`docs/spec/revit-csv-integration-requirements.md` und
+`docs/spec/revit-csv-phase-14-audit-and-plan.md`. Der alte Plan widerspricht
+sich bereits intern: Sein Status nennt die Erstübernahme noch nicht vorhanden,
+während Implementierung und Tests sie nachweisen. Alte Erledigt-Markierungen
+werden deshalb nicht übernommen.
+
+| Bereich / Codebeleg | Entscheidung | Begründung und Änderung |
+| --- | --- | --- |
+| `src/db/repositories/project-command-transaction.persistence.ts` | Keep | Eine Grenze für Fachänderung, Inverse, Revision und History; auch automatische Snapshots bleiben darin. |
+| `src/db/repositories/external-model-state.repository.ts`, `src/db/schema/external-*.ts` | Change | Quelle, Batches, Raum-Mappings und Objekte wiederverwenden; neue Identität, Konfiguration und typisierte Matrix. Schlanke Objekt-Reads von großen Batch-Blobs trennen. |
+| `src/domain/models/external-initial-import-project-command.model.ts`, zugehöriger Store | Change | Vollständiger erwarteter/Zielzustand und Row-freier Import bleiben; Worksharing-ID, Gerätearten und atomare Regelübernahme ergänzen. |
+| `src/external-model/application/external-initial-import-plan.ts`, `external-initial-import-target.ts` | Change | Raumvorschläge, Kataloge, vollständige Entscheidungen und stabile UUIDs behalten. Objektentscheidungen und Gerätearten ergänzen. |
+| `src/db/repositories/external-object-assignment.persistence.ts` und drei Zuordnungs-Stores | Change | Mengeninvariante und exakte Inversen behalten; Geräteart, effektiven Verteiler, Anwesenheit und Übernahme der Row-Werte beim Lösen ergänzen. |
+| `CircuitDeviceRow.manualQuantity`, bestehende Mengenprüfungen | Keep | `quantity = manualQuantity + Summe(externer effektiver Mengen)`; Mehrfachsteckdosen bleiben unteilbar. |
+| `src/external-model/application/external-circuit-list-objects.ts` | Change | Listen-/Projektprüfung behalten; vollständige Planungswerte, Geräteart, effektiver Verteiler, Status und Row-Anzahlen liefern. |
+| `src/domain/models/project-state-snapshot.model.ts`, Snapshot-Persistenz und Transfer | Change | Schema 10; historische CSV-Zustände ausdrücklich ablehnen; alle neuen internen Referenzen remappen. |
+| `src/external-model/csv/*`, CSV-Preview, CSV-Validierungen und Controller | Remove/replace | XLSX ersetzt CSV vollständig; kein zweiter aktiver Transportpfad. |
+| `src/frontend/components/revit-csv-modal.tsx`, Einbindung auf Projektseite | Remove/replace | Eigene Revit-Seite; Einstellungen nur im Modal, Import in eigenem Wizard. |
+| `src/frontend/components/Sidebar.tsx`, `src/frontend/utils/api.ts`, `src/frontend/types.ts` | Change | Route `revit`, neue DTOs und Endpunkte, CSV-Imports entfernen. |
+| `src/frontend/components/circuit-tree-editor.tsx`, Grid-Drop-/Projektionsmodule | Change | Separater externer Drag-Payload; Row-, Circuit- und Freiplatz-Ziele bewusst unterscheiden. Bestehende Grid-Bedienung behalten. |
+| Raum-/ProjectDevice-Formulare und Commands | Keep | Sichtbar vorbelegte, ausdrücklich bestätigte Anlage als eigener Undo-Schritt. |
+| `scripts/verify-revit-reference-csv.ts`, Transporttests | Replace | Pfadargument für lokalen XLSX-Prüfer; ausschließlich synthetische Workbooks in Tests. |
+
+### Konkrete Lücken gegenüber dem Auftrag
+
+- `external-model-contracts.ts` importiert heute CSV-Verträge. Die neutralen
+  Konfigurations-/Matrixverträge gehören künftig in `external-model/domain`;
+  nur `external-model/xlsx` darf ExcelJS kennen.
+- `ifc_guid` ist derzeit NOT NULL und je Quelle eindeutig; Matching,
+  Snapshots, DTOs und Commands setzen diese Identität voraus.
+- `internalDeviceType` ist derzeit ein freier String in Planungswerten.
+  Es gibt keinen Geräteart-Katalog mit stabilen IDs und Standardwerten.
+- Der Erstimport setzt den ProjectDevice-Link, verwendet im Target aber
+  weiterhin `suggestedPlanningValues`. Die neue Priorität ProjectDevice vor
+  Geräteart muss ausdrücklich implementiert werden; ein Link allein genügt
+  nicht. Revit-Leistung wird künftig nicht automatisch zum Planungswert.
+- Der Import-Target setzt `distributionBoardId = null`; die Raumvorgabe liegt
+  separat im Mapping. Projektion und Zuordnungsprüfung vergleichen heute
+  direkt das Objektfeld. Eine zentrale Auflösung des effektiven Verteilers
+  fehlt und ist vor der Editor-Nutzung erforderlich.
+- Die bisherige Row-Zuordnung darf laut Validator am Objekt ausschließlich
+  `circuitDeviceRowId` ändern; der Store schreibt auch nur dieses Feld.
+  Lösen mit aktuellen Row-Planungswerten benötigt eine neue Command-Version.
+- Die Kompatibilitätsprüfung vergleicht Raum, Kategorie, Auswahlkenner und
+  Planungswerte, aber keine stabile Geräteart. Unterschiedliche Gerätearten
+  dürfen nicht versehentlich in dieselbe Row aggregiert werden.
+- Rows speichern `powerPerUnit` in **kW**, externe Planung
+  `powerPerUnitW` in **W**. Eine zentrale bidirektionale Konvertierung ist
+  nötig; Exportleistung darf nicht um Faktor 1000 falsch sein.
+- Externe FKs auf Row, ProjectDevice, Raum-Mapping und Verteiler verwenden
+  teilweise `ON DELETE SET NULL`. Bestehende allgemeine Löschpfade sichern
+  externe Objektübergänge nicht durchgängig in ihren Inversen. Auch
+  Unterbaum-/History-Löschungen müssen abgesichert werden.
+- Ein Editor-Drawer, projektweite Objekttabelle, Exportnachweis und
+  ausführbarer Folgeimport fehlen. `follow_up` als vorhandener Enumwert ist
+  kein implementierter Folgeimport.
+- Konfigurationsversionen steigen heute nur bei normalen Updates gegenüber
+  dem aktuellen Wert; Undo setzt alte Versionen zurück. Für eine tatsächlich
+  monotone Generation muss diese Semantik korrigiert werden.
+- XLSX-Parsing ist asynchron. Das heutige erneute synchrone CSV-Parsing
+  innerhalb der SQLite-Transaktion darf nicht einfach durch `await` ersetzt
+  werden.
+
+## 2. Prüfung der lokalen Musterdatei
+
+`docs/spec/kbp-Stromkreis.xlsx` wurde ausschließlich lesend auf ZIP-/OOXML-
+Ebene untersucht; keine Inhalte wurden hochgeladen oder in Fixtures kopiert.
+Die Datei ist unversioniert und darf nicht committed werden.
+
+| Befund | Ergebnis |
+| --- | --- |
+| Dateigröße / entpackte ZIP-Einträge | 56.765 / 337.740 Bytes |
+| Arbeitsblätter / Blattnamenlänge | 1 / 31 Zeichen |
+| Zellbereich | A1:O490 |
+| Kopfzeile / Leerzeile / Objekte / Abschluss | 1 / 2 / 3–489 / 490 |
+| Objektidentitäten | 487 syntaktisch passende Worksharing-IDs, keine Duplikate |
+| Kopfzeilenkommentare | 14, zu den 14 Spalten nach der ID-Spalte |
+| Fehlende Raumangaben | 67 Objekte ohne Raumnummer und Raumname |
+| IfcGUID-Duplikate | 2 Gruppen nichtleerer doppelter Werte |
+| Formeln | Keine; synthetische Tests dafür erforderlich |
+| Spaltendefinitionen | 16, obwohl nur 15 Datenspalten vorhanden sind |
+
+Das beobachtete Profil aus dem Auftrag wird damit bestätigt. Zusätzliche
+Spaltenformatdefinitionen dürfen beim Export nicht auf die gemappten Spalten
+gekürzt werden. Das Muster enthält die neuen getrennten Stromkreisfelder und
+die Bezeichnung noch nicht. Fehlende Rückgabespalten werden angezeigt; sie
+dürfen nicht ohne Linear-Parameterbindung erfunden werden.
+
+Nicht nachgewiesen: erfolgreicher Rückimport in Linear, dessen genaue
+Auswertung der Kommentar-/VML-Metadaten und der ExcelJS-Roundtrip. R2 prüft
+die Struktur, R8/R10 benötigen zusätzlich einen realen Linear-Abnahmelauf.
+
+## 3. Bibliothek, Adapter und Uploadgrenzen
+
+**Vorschlag: genau eine neue direkte Abhängigkeit `exceljs`.** Seine
+öffentliche API unterstützt XLSX, Zellnotizen, Formate, Spaltenbreiten und
+typisierte Werte. Das passt zum beobachteten klassischen Kommentarformat.
+Version und transitive Abhängigkeiten werden in R2 festgeschrieben und
+geprüft. Die veröffentlichte Version ist laut Paketregister 4.4.0; eine
+aktuelle Releasepflege ist damit nicht bewiesen. Dies ist ein ausdrückliches
+Wartungsrisiko, kein als erfüllt abgehakter Bibliotheksnachweis.
+
+Quellen, am 29.09.2026 geprüft:
+[ExcelJS-Projekt](https://github.com/exceljs/exceljs),
+[offizielle Paketdokumentation](https://www.npmjs.com/package/exceljs).
+Keine Bibliothek wird in R0 installiert. R2 muss vor Integration Kommentar-
+Roundtrip, Node-24-Verträglichkeit und Abhängigkeitsrisiken prüfen; bei einem
+Blocker wird die Bibliotheksentscheidung neu vorgelegt.
+
+Vorgeschlagene Grenzen, zentral konfiguriert und synthetisch getestet:
+
+- ausschließlich `.xlsx`, passender OOXML-Inhalt und ZIP-Signatur; kein
+  `.xlsm`, verschlüsseltes Archiv, VBA, ActiveX oder externe Workbook-Links;
+- maximal 10 MiB Upload, 100 MiB tatsächlich entpackte Daten, 2.000 ZIP-
+  Einträge, 50.000 Zeilen, 256 Spalten und 2 Millionen materialisierte Zellen;
+- genau ein Arbeitsblatt; keine Formelausführung, kein Nachladen von URLs;
+- ZIP-Vorprüfung vor ExcelJS: Verzeichniseinträge, doppelte Pfade,
+  Kompressionsverfahren und tatsächliche entpackte Bytezahl prüfen.
+  Zentralverzeichnisangaben allein schützen nicht vor manipulierten Archiven.
+  Begrenzte Dekompression mit Node-Bordmitteln, keine zweite direkte Library;
+- Parser in begrenztem Worker mit Zeit-/Speichergrenze; Abbruch ohne DB-
+  Schreibvorgang. API-Body-Limit auf Uploadgrenze einschließlich Base64-
+  Overhead abstimmen, statt global beliebige Requestgrößen zuzulassen.
+
+Neutrale Matrix: Blattname, Kopfzeilen-/Startpositionen, Spaltenmetadaten
+(Index, Name, Kommentartext, erkannter Parametertyp/Einheit), geordnete
+Zeilen mit Originalzeilennummer und Klasse sowie Zellen als diskriminierte
+Union `string | number | boolean | empty`. Formeltext und Cache-Status sind
+optionale Transportmetadaten; fachlich zählt nur der gecachte skalare Wert.
+Fehlender Cache oder Fehlerwert erzeugt einen Hinweis bzw. bei Pflichtfeldern
+einen Blocker. Originalbytes bleiben unverändert gespeichert.
+
+Fehlende ID bei sonstigen Objektdaten blockiert; Leer-/eindeutige Summenzeilen
+werden ignoriert. Nicht passende nichtleere IDs blockieren ebenfalls.
+Worksharing-ID bleibt als Quelltext erhalten, Matching ist exakt; ungültige
+Leerzeichen/uneindeutige Schreibweisen werden gemeldet statt still korrigiert.
+IfcGUID wird optional gespeichert, doppelte Werte sind nur Hinweise.
+Numerische Projektion rundet Leistung auf 0,01 W, nicht die gespeicherte
+Quellzelle. Mengen aus `socketCount` müssen positive ganze Zahlen sein.
+
+Rückgabe lädt eine Kopie der Originalbytes, bewahrt den Bereich oberhalb der
+ersten Datenzeile samt Kommentaren, Formatierung und Spaltenbreiten und
+ersetzt den Datenbereich durch gewählte Objektzeilen in Originalreihenfolge.
+Alle Spalten bleiben enthalten; Summenzeilen entfallen. Unveränderte Zellen
+behalten ihre importierten Werte und Typen. Formeln in Objektzeilen werden
+als gecachte Werte ausgegeben, damit Zeilenauswahl keine falschen relativen
+Bezüge erzeugt; dies wird vor Export als Hinweis ausgewiesen. Keine Formeln
+werden berechnet. Roundtrip bedeutet strukturelle/semantische Gleichheit,
+nicht identische ZIP-Bytes.
+
+## 4. Konfigurationsschema
+
+Neuer neutraler Vertrag `ExternalModelConfiguration`, Schema-Version 1:
+
+```ts
+{
+  schemaVersion: 1,
+  layout: {
+    headerRow: 1, firstDataRow: 3, firstDataColumn: 1,
+    idColumn: "Worksharing-ID"
+  },
+  circuitMode: "combined" | "separate",
+  columns: {
+    worksharingId: string, familyAndType: string,
+    ifcGuid: string | null, roomNumber: string | null,
+    roomName: string | null, selectionMarker: string | null,
+    socketCount: string | null, sourceRemark: string | null,
+    circuitCombined: string | null, boardName: string | null,
+    circuitIdentifier: string | null, designation: string | null,
+    electricalPowerW: string | null, voltageV: string | null,
+    currentA: string | null
+  },
+  deviceTypes: [{
+    id: UUID, name: string,
+    category: "lighting" | "single_phase" | "three_phase",
+    defaults: {
+      powerPerUnitW: number | null, simultaneityFactor: number | null,
+      cosPhi: number | null, costGroup: string | null
+    }
+  }],
+  familyTypeRules: [{
+    id: UUID, exactFamilyAndType: string, deviceTypeId: UUID,
+    quantityRule: "one" | "socketCount"
+  }]
+}
+```
+
+Zeilen/Spalten sind intern 1-basiert; UI stellt Spalten als A, B, … dar.
+`layout.idColumn` und `columns.worksharingId` werden gemeinsam gesetzt und
+müssen übereinstimmen. Jede gemappte Kopfzeile muss eindeutig auflösbar sein;
+doppelte Ausgabebelegungen werden abgelehnt. Freie Eingabe bleibt zulässig,
+aber ein nicht existierender Name erzeugt vor Import/Export einen konkreten
+Fehler. Erkennung und Vorbelegung nutzen die exakten Standardnamen aus dem
+Auftrag. Unbekannte Spalten bleiben ohne Mapping erhalten.
+
+Geräteart-IDs sind interne UUIDs, keine Namen als Relationsschlüssel. Regeln
+sind exakt und je Familien-/Typtext eindeutig; jede importierte Familie muss
+eine Geräteart haben. Gerätearten und Regeln werden als ein versioniertes
+Konfigurationsaggregat gespeichert. Keine zusätzliche Gerätearttabelle ist
+für diesen Umfang nötig; Validatoren erzwingen referenzielle Integrität.
+Referenzierte Gerätearten können nicht kommentarlos entfernt werden.
+
+Startwerte: je Feld ProjectDevice vor Geräteart vor leer. Anzeigename:
+Auswahlkenner, sonst Geräteartname, sonst Familie/Typ. Quellleistung bleibt
+Quelle; eine Übernahme geschieht nur als sichtbare Planungsentscheidung.
+Fehlender GZF bleibt vor Zuordnung leer; verlangt der Row-Vertrag einen Wert,
+wird `1` sichtbar vorgeschlagen und ausdrücklich bestätigt. Geräteart-
+Änderungen schreiben keine vorhandenen Objekt-Overrides oder Rows um.
+
+## 5. Konkretes Persistenzschema
+
+Bestehende UUID-/Projekt-FKs und Eigentumsprüfungen werden beibehalten.
+`JSON` bezeichnet validierten JSON-Text in SQLite, nicht ExcelJS-Objekte.
+
+| Tabelle | Zielspalten / Constraints |
+| --- | --- |
+| `external_model_configurations` (ersetzt CSV-Tabelle) | `id TEXT PK`, `project_id TEXT NOT NULL UNIQUE FK projects`, `configuration_version INTEGER NOT NULL CHECK > 0`, `configuration JSON NOT NULL`. Enthält obiges vollständiges Aggregat. |
+| `external_model_sources` | `id`, `project_id UNIQUE`, `name`, `source_type = revit_xlsx`. Genau eine implizite Quelle je Projekt. |
+| `external_import_batches` | Bestehende IDs, Importart, Zeit, Dateiname, SHA-256, `applied_project_revision`, `configuration_version`, `configuration_snapshot JSON`, `original_bytes BLOB`, `document JSON`; Matrix jetzt typisiert und transportneutral. Unveränderlich innerhalb des aktiven Zustands; Undo/Restore darf ganze Batches entfernen/wiederherstellen. |
+| `external_room_mappings` | Vorhandene Felder einschließlich normalisiertem Quellraumschlüssel, `room_id`, `default_distribution_board_id`; UNIQUE `(source_id, normalized_source_room_key)` bleibt. |
+| `external_model_objects` | Bestehende interne IDs/Links; neu `worksharing_id TEXT NOT NULL`, UNIQUE `(source_id, worksharing_id)`; `ifc_guid TEXT NULL`, ohne Unique; `device_type_id TEXT NOT NULL` als validierter Verweis in das Konfigurationsaggregat. |
+| Objektzustand | `accepted_source_values JSON` mit rohen typisierten Werten für Raum, Familie/Typ, Marker, Menge, Bemerkung und alle Rückgabefelder; `planning_values JSON` mit Anzeigename, Kategorie, Anschlussart, effektiver Menge, Einzelleistung W, nullable GZF/cosPhi/Kostengruppe/Bemerkung; `overridden_fields JSON`; bisherige Batch-/Raum-/Board-/ProjectDevice-/Row-Verweise und `presence_status` bleiben. |
+| `external_export_batches` (neu) | `id TEXT PK`, `project_id FK`, `project_revision INTEGER`, `import_batch_id TEXT`, `exported_at_iso TEXT`, `file_name TEXT`, `sha256 TEXT`, `configuration_version INTEGER`, `scope TEXT`, `object_count INTEGER`. Append-only Audit-Store. |
+
+`import_batch_id` des Exportnachweises ist absichtlich eine historische UUID
+ohne löschenden FK: Undo eines Imports oder Snapshot-Restore darf den Nachweis
+nicht entfernen. Exportnachweise liegen außerhalb rücksetzbarer Fachsnapshots
+und werden beim Projektduplikat nicht als dort erfolgte Exporte ausgegeben.
+Sie bleiben beim Originalprojekt erhalten; diese Abgrenzung wird in R1
+dokumentiert. Importbatches selbst gehören vollständig zu Snapshot/Transfer.
+
+Indices: bisherige Projekt-/Presence-, Board- und Row-Indices behalten;
+zusätzlich `(project_id, device_type_id)`, `external_room_mapping_id`,
+`linked_project_device_id`, Export `(project_id, exported_at_iso)`.
+Cross-Project-Links und Geräteart-Verweise prüft jeder Command in der
+Transaktion; bloße Existenz eines UUID-FK genügt nicht.
+
+Effektiver Verteiler: ein gemeinsamer Resolver verwendet bei verknüpften
+Objekten die Row/Circuit-Verteilung, sonst die Objektabweichung, sonst die
+Raumvorgabe. `distributionBoardId = null` bedeutet Raumvorgabe verwenden;
+bei fehlender Vorgabe ist das Objekt ohne Verteiler. Room-/Board-
+Sammeländerungen prüfen alle betroffenen Row-Links und lehnen inkonsistente
+Umbuchungen ab, bis diese ausdrücklich gelöst/verschoben sind.
+
+Planungswerte bleiben von Quellwerten getrennt. Nach Row-Zuordnung sind
+Objekt-Planungswerte eingefrorene Startwerte; Anzeige, Abweichung und Export
+verwenden die Row. Beim Lösen werden aktuelle Row-Werte einschließlich
+Einheitenkonvertierung in die Objektplanung übernommen und als explizite
+Overrides markiert. Effektive Objektmenge wird nicht durch die Row-Gesamtmenge
+ersetzt. Die Row und ihr manueller Anteil bleiben erhalten.
+
+## 6. Commands und Transaktionsgrenze
+
+Alle öffentlichen Fach-Writes verlangen `expectedRevision`, Anmeldung und
+`X-Leistungsbilanz-Request: 1`. `expectedRevision` gehört wie bisher zum
+Ausführungsumschlag. Jede Transition enthält vollständige erwartete/Ziel-
+Snapshots der betroffenen Datensätze, keine ungesicherten Teilpatches.
+
+| Command | Payload-Skizze und Gegenrichtung |
+| --- | --- |
+| `external-model-configuration.update` v1 | `{ expected, target }` einschließlich Layout, Mapping, Gerätearten und Regeln. Inverse tauscht Fachinhalt; Versionsgeneration siehe unten. |
+| `external-import.apply-initial` v2 | `{ expectedConfiguration, targetConfiguration, expected, target }`. Quelle, Batch, Mapping, Objekte und neue Regeln zusammen; Inverse stellt leeren externen und vorherigen Konfigurationsinhalt wieder her. Keine Rows. |
+| `external-import.apply-follow-up` v1 | `{ configuration: transition, batch: transition, roomMappings: transitions, objects: transitions, rows: quantityTransitions, decisions }`; Server erzeugt deterministischen Diff und alle UUIDs. Inverse tauscht alle betroffenen Zustände. |
+| `external-model-object.update-planning` v1 | `{ objects: transitions }`; nur ungebundene Objekte; geänderte Felder in Overrides. Einzel-/Sammelbearbeitung identischer Regeln. |
+| `external-model-object.update-distribution-board` v1 | `{ objects: transitions }`; explizite Objektabweichung, Projekt-/Row-Konsistenz. |
+| `external-model-room-mapping.update` v1 | `{ mappings: transitions }`; interner Raum/Standardverteiler; betroffene Objekt-/Row-Konsistenz mitprüfen. |
+| `external-model-object.update-project-device-link` v1 | `{ objects: transitions, confirmedPlanningFields }`; keine Vorlagenänderung; neue Startwerte nur für ausdrücklich bestätigte Felder. Gebundene Objekte werden über ihre Row bearbeitet. |
+| `external-object.update-row-assignment` v2 | `{ rows: transitions, objects: transitions, confirmedConflictObjectIds }`; Linkwechsel, materialisierte Mengen, beim Lösen aktuelle Row-Planungswerte; vollständige Inverse. |
+| `external-object.assign-to-new-row` v2 | Bestehender vollständiger Row-/Objekt-/Reserveplan mit neuen Objektverträgen; history-only Inverse entfernt nur exakt unveränderte Erzeugnisse. |
+| `external-object.assign-to-new-circuit` v2 | Bestehender Circuit-/Protection-/Row-/Objektplan; BMK einmal planen und festschreiben, gleiche UUIDs bei Redo. |
+| `external-model-object.delete-missing` v1 | `{ objects: transitionsToNull, rows: quantityTransitions }`; ausschließlich ausdrücklich bestätigte weiterhin fehlende Objekte, kein Row-/Circuit-Löschen; Inverse stellt IDs, Links und Mengen wieder her. |
+
+Bestehende `project-device.insert`, Room-/Floor-Commands bleiben eigenständige
+Undo-Schritte. Familien-/Geräteartentscheidungen im Wizard sind lokale
+Entwürfe und werden erst mit dem Import atomar persistiert. Nach separater
+Kataloganlage aktualisiert der Wizard die Projektrevision und plant neu,
+ohne lokale Entscheidungen zu verlieren.
+
+Konfigurationsgeneration: `configurationVersion` erhält bei jedem
+Konfigurationswechsel einschließlich Undo/Redo/Restore die neu entstehende
+Projektrevision. Sie ist damit strikt steigend, aber nicht lückenlos.
+Historienbefehle vergleichen den erwarteten Fachinhalt und die aktuelle
+Projektversion; die administrative Generation wird serverseitig neu erzeugt.
+Die Inverse restauriert alle Fachwerte exakt, nicht einen alten Zählerstand.
+Importbatches behalten ihre ursprüngliche Generation und ihren Snapshot.
+Ein Restore/Projekttransfer erhält diese Herkunft; die aktive Konfiguration
+wird an die Revision des Zielprojekts gebunden. Prüfen: Änderung → Undo →
+anderer Zweig darf niemals denselben Vorschau-Token wieder gültig machen.
+
+XLSX wird vor der synchronen SQLite-Transaktion in einer serverinternen
+Vorbereitung geparst. Apply überträgt Bytes erneut; Hash, Matrix und
+Entscheidungen werden erneut validiert. Im Store werden Revision,
+Konfigurationsinhalt/-generation, erwartete Objekte, Links und vollständiger
+vorbereiteter Plan atomar geprüft. Vorbereitete Daten sind keine vom Client
+behauptete Validierung: Generic-Command-Requests dürfen Importcommands nicht
+an dieser serverseitigen Vorbereitung vorbeischleusen. Undo/Redo benutzen
+denselben Prüfdienst für persistierte Bytes vor der Transaktion. Keine
+asynchronen Callbacks in `better-sqlite3`-Transaktionen.
+
+Allgemeine Row-/Circuit-/Gruppen-/Board-/Raum-/ProjectDevice-Löschungen
+erhalten Guards, solange externe Referenzen betroffen sind. Nutzer lösen die
+Referenzen zuvor ausdrücklich über die passenden Commands. Guards gelten
+auch in Unterbaum- und History-only-Pfaden. Dadurch werden vorhandene
+Commands nicht unbemerkt zu unvollständigen externen Löschcommands.
+
+## 7. Migration, Snapshot 10, History und Transfer
+
+Neue additive Migration nach `0013_users` (voraussichtlich `0014`, Nummer
+beim Beginn von R3 erneut prüfen). Bestehende SQL-/Metadateien unverändert.
+
+1. Vor R3-Anwendung API-Schreibzugriffe stoppen und `npm run db:backup`
+   ausführen; verifiziertes Backup samt Wiederherstellungsmöglichkeit sichern.
+   R0 verändert keine DB und benötigt daher kein Migrationsbackup.
+2. Vorhandene externe CSV-Entwicklungsdaten dürfen gemäß Auftrag verworfen
+   werden. Zuerst je verknüpfter Row `quantity = manual_quantity` setzen;
+   sonst bliebe nach Entfernen der externen Objekte eine Phantomlast.
+   Rows, Circuits, manuelle Anteile, UUIDs und BMKs bleiben bestehen.
+3. Externe Objekte → Mappings → Batches → Quellen → CSV-Konfiguration in
+   FK-sicherer Reihenfolge entfernen. Tabellen gezielt neu aufbauen, wo
+   SQLite NOT-NULL-/Unique-Änderungen dies erfordern. Neue Zieltabellen und
+   Indices erstellen. Keine leeren Worksharing-IDs als Backfill erfinden.
+4. Generiertes SQL und Drizzle-Metadaten prüfen; saubere und bestehende
+   Test-DBs migrieren; FK-/Integritätsprüfung und Mengenabgleich ausführen.
+   Der Reset ist eine dokumentierte einmalige Entwicklungsmigration,
+   kein stiller Laufzeit-Import.
+5. Alte Revisionsdaten nicht umschreiben, keine CSV-History heimlich
+   überspringen. An der Ausführungsgrenze alte CSV-Konfigurationscommands,
+   Initial-/Zuordnungscommands v1 einschließlich ihrer History-Inversen und
+   Restores mit CSV-Inhalt vor jedem Write ablehnen.
+
+Fehlermeldung für History:
+„Dieser Verlaufsschritt verwendet die frühere CSV-/IfcGUID-Anbindung und
+kann mit der Excel-Anbindung nicht ausgeführt werden.“
+Der History-Status sollte den blockierten obersten Schritt samt Grund zeigen;
+keine automatisch geleerten Stacks und keine Änderung bei Ablehnung. Frühere
+allgemeine Commands können nach dem Reset zusätzlich an ihren exakten
+Vorbedingungen scheitern; das bleibt eine sichere, sichtbare Ablehnung.
+
+Snapshot v10 enthält aktive Excel-Konfiguration, Gerätearten/Regeln, Quelle,
+alle Batches mit Originalbytes/Matrix, Raum-Mappings, Objekte und Links.
+Upgrade v1–9: bestehende nicht-externe Upgrader erhalten. Nur wenn
+`externalCsvConfiguration` fehlt/null ist **und** der externe Zustand leer
+ist, verlustfrei auf v10 heben. Auch eine gespeicherte CSV-Konfiguration
+allein zählt als nicht leerer CSV-Zustand und wird nicht still verworfen.
+Snapshot-Checksumme am gespeicherten Original vor Upgrade prüfen.
+
+Fehlermeldung:
+„Dieser Projektstand enthält Daten der früheren CSV-/IfcGUID-Anbindung.
+Eine automatische Übernahme in die Excel-Anbindung ist nicht möglich.
+Bitte verwenden Sie einen Projektstand ohne CSV-Daten.“
+
+Der aktuelle portable Transfer ist bereits **Format 2** (Grobbilanzen),
+nicht Format 1 wie im alten Audit. Envelope 2 und dessen Format-1-Lesepfad
+bleiben; enthaltenes Projektzustandsschema wird 10. Duplizieren remappt
+Projekt-, Konfigurations-, Geräteart-, Regel-, Quellen-, Batch-, Mapping-,
+Objekt-UUIDs und alle internen Links, auch in Konfigurationssnapshots der
+Batches. Worksharing-IDs, optionale IfcGUIDs und Originalbytes bleiben
+unverändert. Grobbilanzen und globale Office-/Auth-Daten behalten ihre
+bisherige Abgrenzung. Exportnachweise werden nicht als neue Projektexporte
+dupliziert.
+
+## 8. Read-Modelle, Oberfläche und Rückgabe
+
+Vorgeschlagene API-Basis `/api/projects/:projectId/revit`:
+`configuration` (GET/PUT), `profile/preview` (POST, zustandslos),
+`initial-import/plan|apply`, `follow-up-import/plan|apply` (POST),
+`status` und `objects` (GET), `return-workbook` (POST mit Export-Audit).
+Der bestehende listenbezogene External-Objects-GET bleibt erhalten.
+Objektmutationen verwenden den vorhandenen Project-Command-Endpunkt mit
+neuen typisierten Verträgen. CSV-Endpunkte werden entfernt, keine Aliasse.
+
+Export verwendet `expectedRevision` für einen konsistent gelesenen Stand;
+die Datei-Erzeugung erfolgt außerhalb des kurzen Read-Snapshots. Danach
+separater append-only Audit-Write, ohne Projektrevision oder Undo-Schritt.
+Bei Auditfehler kein Erfolg/download; ein Eintrag belegt Dateierzeugung,
+nicht einen tatsächlich abgeschlossenen Browserdownload.
+
+Die Revit-Seite zeigt Status, Aktionen und eine paginierte Objekttabelle
+(Vorschlag: 100 Zeilen pro Seite). Filter-/Sortierzustand, UUID-Auswahl und
+Sammelaktionen sind unabhängig vom DOM. „Alle gefilterten“ verwendet eine
+explizit aufgelöste Auswahl zur bekannten Revision; keine Mutation anhand
+eines inzwischen veränderten Filters. Große Auswahlmengen werden nicht in
+getrennte Undo-Schritte aufgeteilt. Kein vollständiges Batch-Blob im DTO.
+
+Einstellungen verwenden Musterdatei-Erkennung mit editierbaren Positionen,
+Feld-Dropdowns/freier Eingabe und Kommentar-Typ-/Einheitenanzeige. Regeln
+entstehen im Wizard und sind auf der Seite einklappbar nachbearbeitbar.
+Fehlende Raumangaben bleiben zulässig, Board-Zuordnung ist auch ohne Raum
+möglich. ProjectDevice-Zuordnung bleibt optional.
+
+Rechter Editor-Drawer: nur vorhandene, ungebundene konfliktfreie Objekte des
+effektiven Verteilers. Gruppierung nach internem Raum, Auswahlkenner,
+Geräteart-ID, Kategorie und identischen Planungswerten; unterschiedliche
+ProjectDevice-Links bleiben ebenfalls getrennt, da eine Row nur einen Link
+haben kann. Effektive Einzelmengen sind kein Gleichheitsfeld: Einfach- und
+Mehrfachsteckdosen sollen gemeinsam gruppierbar sein. Anzeige enthält
+Mengensumme und Objektanzahl. Fachlich heterogene Auswahl darf nicht
+willkürlich auf eine einzelne Row zusammenfallen; Konfliktanzeige verlangt
+eine kompatible Auswahl. Row-Indikator öffnet Objekte und explizites Lösen.
+
+Eine Funktion `getRevitBoardName(board)` liefert ausschließlich `board.name`.
+Gemeinsam: Name + unverändertes `equipmentIdentifier`, ohne Separator.
+Getrennt: Name und BMK in eigene Parameter. Ohne Circuit bleiben beide
+Stromkreiswerte leer, auch wenn ein Planungsverteiler bekannt ist.
+
+Exportprojektion und Abweichungsanzeige teilen dieselbe reine Funktion:
+Row-Anzeigename/-Leistung bei Link, sonst Objektplanung; Objektleistung in W
+= effektive Menge × Einzelleistung (Row-kW vorher × 1000), ohne GZF.
+Spannung vom Circuit, sonst Projektstandard passend zur Kategorie.
+Strom aus Objektleistung, U, cosPhi und Phasenart; Drehstrom mit Faktor √3,
+auf 0,01 A. Fehlende/ungültige Werte ergeben leer plus Hinweis. Nullleistung
+bleibt bei gültigem Nenner numerisch 0. Kein still angenommenes cosPhi.
+Abweichungsvergleich normalisiert Zahlpräzision, Leere und skalare Typen
+gegen den **zuletzt importierten**, nicht den zuletzt exportierten Stand.
+
+Umfang: alle im letzten Batch vorhandenen Objekte / abweichende / explizite
+Auswahl. Fehlende Objekte haben keine aktuelle Originalzeile und werden
+nicht künstlich wieder eingefügt. Alle Spalten bleiben, nicht ausgegebene
+Parameter behalten importierte Werte. Fehlende benötigte Zielspalten bzw.
+Linear-Bindungen blockieren die betreffende Exportkonfiguration mit Hinweis
+auf einen neuen vollständigen Linear-Export. Dateiname gemäß Auftrag mit
+bereinigtem Projektnamen und Tagesdatum.
+
+Folgeimport matcht ausschließlich Worksharing-ID. Ein neuer Batch speichert
+immer den vollständigen letzten Quellstand. Unveränderte Objekte werden
+nicht allein zum Fortschreiben von `lastSeenImportBatchId` neu geschrieben;
+aktuelle Sichtbarkeit/Quellwerte kommen aus Batch/Matrix. Akzeptierte
+Planungsgrundlage und letzte importierte Beobachtung sind getrennt.
+Raum-/Familien-/Marker-/Mengenänderungen brauchen Entscheidungen. Bei
+unvereinbarer Row-Zuordnung blockiert die Übernahme bis zum ausdrücklichen
+Lösen/Umordnen, statt Rows automatisch zu erzeugen. Übernommene Mengen
+ändern alle betroffenen Row-Summen im selben Importcommand. Fehlend setzt
+nur den Status, erhält vorerst Link und Menge. Rückgabefeld-Abweichungen
+sind Hinweise, keine Übernahmeentscheidungen. Ein völlig unveränderter
+Folgeimport erzeugt einen nachvollziehbaren Batch, aber keine unnötigen
+Objekt-/Row-Updates.
+
+## 9. Pakete, Verifikation und Risiken
+
+R0 liefert nur diesen Bericht und einen eigenen Commit. R1–R10 starten erst
+nach Freigabe; keine Fortschreibung der alten 14.0–14.6-Liste.
+
+| Paket | Arbeit und entscheidende Abnahme |
+| --- | --- |
+| R1 | Neue Excel-Anforderungen und R0–R10-Plan; alte Dokumente archivieren/auf Verweise kürzen; AGENTS, Architektur, History-Doku, Phase-14-Abschnitt, LLM-Kontext und alle Links nachziehen. Referenzdatei gezielt ignorieren. |
+| R2 | XLSX-Adapter und lokaler Referenzprüfer mit Pfadargument. Synthetischer Roundtrip für Kommentare, Blattname, Spaltenbreiten, Typen, Header-/Startpositionen, unbekannte Spalten, Auswahl und Summenausschluss; ZIP-/Formelgrenzen. Keine DB-Änderung. |
+| R3 | Neue Konfiguration/Identität, additive Migration, Snapshot 10, Transfer und History-Ablehnungen; Backend-CSV entfernen. Parser-Vorbereitung von synchroner Transaktion trennen. |
+| R4 | Revit-Seite, Navigation, Einstellungen; Projektseitenmodal und dessen CSV-Frontend-Verträge entfernen. |
+| R5 | Erstimport mit atomaren Regeln, Geräten, Raum-/Board- und Objektentscheidungen; ProjectDevice-Vorbelegung nach Priorität; ein Import-Undo-Schritt. |
+| R6 | Objekt-Reads, Paging/Filter, Sammel-Commands und Overrides; verwandte Lösch-/Referenzguards vollständig absichern. |
+| R7 | Gruppierung, Drag-and-drop, Row-Indikatoren und Lösen inklusive aktueller Row-Werte; drei Drop-Ziele und Reload/Undo/Redo. |
+| R8 | Drei Exportumfänge, gemeinsame Abweichungsprojektion, typisierte Rückgabe, append-only Nachweis und Linear-Strukturabnahme. |
+| R9 | Kontrollierter Folgeimport, fehlende Objekte, explizites Löschen, mengenwirksame Entscheidungen und atomare Inverse. |
+| R10 | Vollständige synthetische Ende-zu-Ende-Kette einschließlich Neustart, Snapshot/Restore und Duplikat; mehrere Tausend Objekte; Doku auf ausgelieferten Stand. |
+
+Die temporäre Grenze zwischen R3 und R4 wird ausdrücklich behandelt:
+Buildfähige, nicht aktive Kompatibilitätstypen für das alte Modal dürfen bis
+R4 bestehen, aber kein aktiver CSV-Backendpfad. Veraltete Projektaktion bis
+zur neuen Seite deaktivieren/entfernen, keinen funktionslosen Upload anbieten.
+Die Dokumentation darf Zwischenstände nicht als fertigen Workflow ausweisen.
+
+Pflicht je R1–R10: fokussierte Tests, `npm test`, `npm run build:api`,
+`npm run build:web`, `npm run typecheck:scripts`,
+`npx tsc --noEmit -p tsconfig.next.json`, je ein knapper imperativer Commit.
+R0: 31 vorhandene Tests aus sechs Dateien erfolgreich ausgeführt:
+`external-model-foundation`, `external-initial-import-plan`,
+`external-initial-import-project-command.repository`,
+`external-object-row-assignment-project-command.repository`,
+`external-circuit-list-objects`,
+`external-csv-configuration-project-command.repository` (je `.test.ts`).
+Diese decken vorhandene Commit-/Rollback-, Undo-/Redo-, Snapshot-/Transfer-
+Grundlagen ab, nicht die neue Excel-Funktion. Der erste Start scheiterte an
+Sandbox-`spawn EPERM`; derselbe Lauf außerhalb der Sandbox bestand.
+Vollständige Builds/Tests sind für diesen reinen R0-Bericht nicht ausgeführt.
+
+Zusätzlich erforderliche neue Prüfungen:
+
+- Migration mit externen Row-Anteilen; keine Phantomlast und unveränderte BMKs.
+- v1–9 ohne CSV verlustfrei, mit CSV klare Ablehnung; alte Command-Inversen
+  und alte Restore-Payloads ebenfalls ohne Teilwrites ablehnen.
+- Config-Änderung/Undo/Neuzweig invalidiert alte Pläne; Apply mit anderem
+  Dateiinhalt, fehlenden Entscheidungen oder fremden UUIDs rollt vollständig
+  zurück. Später Historyfehler rollt auch Regeln, Links und Mengen zurück.
+- Gebundene Row ändern → Export → Lösen → Undo/Redo behält fachliche Werte.
+- Mehrfachsteckdosen: unterschiedliche effektive Mengen, identische
+  Einzelwerte, richtige Gruppierung und objektweise Rückgabeleistung.
+- Löschen über alle Unterbaum-/History-Pfade kann externe FKs nicht still
+  nullen. Fremde Verteilungen/Räume/Kategorien und Gerätearten blockieren.
+- Export-Audit scheitert: keine fachliche Revision; SHA-256 entspricht exakt
+  den gelieferten Bytes. Snapshot/Restore entfernt keine Exportnachweise.
+- 5.000/10.000 synthetische Objekte: Parserzeit, Peak-Speicher, Payloadgröße,
+  Command-/Snapshot-Dauer und UI-Reaktionszeit messen; höchstens eine
+  paginierte Seite im DOM, stabile Auswahl über Seitenwechsel.
+
+Wesentliche Restrisiken: Linear-Kommentarbindung ist nur anhand des
+Exports beobachtet; ExcelJS-Releasepflege und Roundtrip sind in R2 zu
+belegen. Große Originaldateien vervielfachen sich in History/Snapshots;
+Limits und Messungen müssen reale Speichergrößen berücksichtigen. Die
+CSV-Entwicklungsbereinigung ist absichtlich verlustbehaftet, aber auf den
+externen Zustand begrenzt und nur nach verifiziertem Backup zulässig.
+Fehlende Zielparameter im Muster verlangen einen neuen vollständigen
+Linear-Export, keine geratenen GUID-Kommentare.
+
+**Freigabepunkt:** Der Nutzerauftrag verlangt wörtlich
+„R0. Audit (danach stoppen und Freigabe abwarten)“.
+Mit Freigabe dieses Vorschlags beginnt R1; R0 selbst autorisiert keine
+Installation, Migration oder Implementierung von R1–R10.

From d4803a18d28b7dd929a76c1638e49756bb3129e5 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Tue, 29 Sep 2026 22:28:16 +0200
Subject: [PATCH 49/60] Document Linear Excel integration

---
 .gitignore                                    |    1 +
 AGENTS.md                                     |  184 +--
 README.md                                     |   19 +-
 docs/README.md                                |   15 +-
 docs/building-structure.md                    |    4 +-
 docs/circuit-list-editor-known-limitations.md |    7 +-
 docs/current-architecture.md                  |   38 +-
 ...history-and-external-model-architecture.md |   45 +-
 docs/revit-requirements-llm-context.md        |  282 +---
 docs/spec/07-implementation-phases-todo.md    |   48 +-
 docs/spec/08-current-product-backlog.md       |    8 +-
 .../revit-csv-integration-requirements.md     | 1390 +----------------
 .../spec/revit-csv-phase-14-audit-and-plan.md |  410 +----
 .../revit-excel-integration-requirements.md   |  463 ++++++
 docs/spec/revit-excel-phase-14-plan.md        |  173 ++
 docs/spec/revit-excel-r0-audit.md             |  161 +-
 16 files changed, 932 insertions(+), 2316 deletions(-)
 create mode 100644 docs/spec/revit-excel-integration-requirements.md
 create mode 100644 docs/spec/revit-excel-phase-14-plan.md

diff --git a/.gitignore b/.gitignore
index b237969..911c16f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,4 @@ dist/
 data/*.db
 data/backups/*.db
 .codex/*.log
+/docs/spec/kbp-Stromkreis.xlsx
diff --git a/AGENTS.md b/AGENTS.md
index b01e6b5..7c0a120 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -320,29 +320,21 @@ supported versions contain circuit-group identity, distribution-board components
 separate circuit/component protection records. Portable duplicate imports
 remap component ids and protection-owner references together with the existing
 project graph.
-Project-wide Revit CSV configuration uses
-`external-csv-configuration.update`. Its complete expected/target snapshot is
-persisted through the shared project-command transaction, so create, update,
-delete, Undo and Redo are revision-safe. Snapshot schema 5-9, restore and portable
-project duplication preserve the configuration; duplication remaps its internal
-id and project link.
-The project page exposes the Revit CSV modal. It edits the complete
-transport/column/family-rule configuration through the revision-safe endpoint,
-requests a stateless preview and then shows the Phase 14.2 initial-import
-decisions. Preview responses include all mapped objects, while the UI renders
-only the first 25. No preview or plan creates external objects, rows, revisions
-or server-side drafts.
-Phase 14.2 migration `0003` provides one implicit Revit CSV source per project,
-immutable import batches with original bytes plus the classified cell matrix,
-normalized source-room mappings and external objects unique by
-`(sourceId, ifcGuid)`. Source values, planning values and overrides are separate.
-The general external-model repository is read-only; runtime writes belong only
-to typed command adapters. Snapshot/restore and portable project transfer schema versions 5-9
-capture the complete external state and remap every internal UUID and link while
-preserving IFCGUIDs, source values, original bytes and the classified matrix.
-Import batches additionally store the monotonic project CSV configuration
-version introduced by additive migration `0004`; it is distinct from the CSV
-configuration JSON schema version.
+The current runtime still contains the legacy Revit-CSV/IfcGUID foundation:
+project configuration, preview, confirmed initial import, external objects and
+the three row-assignment commands. It remains the audited starting point, not
+the Phase-14 target. Do not extend its CSV transport or IFCGUID identity model.
+The approved cutover is Linear XLSX with exact case-sensitive Worksharing-ID
+identity. See `docs/spec/revit-excel-integration-requirements.md` and
+`docs/spec/revit-excel-phase-14-plan.md`.
+
+During R1/R2 no database or runtime schema changes are made. R3 will replace
+the legacy configuration and transport additively, reject non-empty legacy CSV
+snapshot/history state with a German error, and introduce snapshot schema 10.
+The target configuration has no independent version counter; `expectedRevision`
+invalidates stale plans, and each import batch stores a configuration copy.
+Only the newest import batch retains workbook bytes and the full matrix; older
+batches retain date, filename, SHA-256 and object count.
 Phase 14.3 migration `0005` adds `CircuitDeviceRow.manualQuantity`, backfills
 existing rows from `quantity` and keeps `quantity` as the materialized total.
 Normal manual row inserts and quantity edits update both values together.
@@ -363,37 +355,12 @@ protection and its external object links. Its history-only inverse requires the
 complete unchanged circuit snapshot and exact link set. Redo never recalculates
 the BMK. All three external assignment stores share
 `external-object-assignment.persistence.ts` for compatibility and link safety.
-The read-only
+The current read-only
 `GET /api/projects/:projectId/circuit-lists/:circuitListId/external-objects`
-projection resolves the board through the owned CircuitList and returns only
-that board's compact external objects, unassigned first. It exposes no original
-CSV bytes or command payloads and returns an empty list before optional import.
-Confirmed initial state is written only through
-`external-import.apply-initial`. The command rechecks configuration version,
-original-byte SHA-256, parsed matrix, complete IFCGUID/source values, explicit
-planning overrides and internal project links in the shared transaction. It
-never creates or links a CircuitDeviceRow. Its exact inverse removes the whole
-unchanged external state, and Redo restores the same UUIDs and bytes.
-`POST /api/projects/:projectId/external-csv/initial-import/plan` is a stateless
-read path for the first wizard stage. It rejects projects with an existing
-external source and returns source-room groups, exact room-number suggestions,
-exact family/type groups, projected object values, issue counts and the current
-floor/room/board/ProjectDevice catalogs. It creates no draft, revision or
-domain row. The wide modal renders these groups and catalogs as explicit
-decisions and identifies exact, ambiguous and new room matches. Missing rooms
-and ProjectDevices are created through the reused project forms with mapped
-Revit values as visible defaults. Each catalog creation remains its own project
-command; the wizard adds and selects the result without discarding its plan.
-The dedicated
-`POST /api/projects/:projectId/external-csv/initial-import/apply` endpoint
-retransmits and replans the file against the expected hash, configuration
-version and project revision. It requires one explicit decision per source-room
-and exact family/type group, blocks unclassified families, creates all stable
-external UUIDs server-side and invokes `external-import.apply-initial`.
-Room/default-board and optional ProjectDevice links are supported; CSV circuit
-values remain source-only and every `circuitDeviceRowId` remains null. The UI
-blocks unclassified families, requires a final confirmation and applies the
-whole import as one persistent Undo/Redo step.
+projection resolves the board through the owned CircuitList and returns compact
+legacy external objects. The target Revit page will load one compact project
+list and filter/sort it client-side in a virtualized table, without server
+pagination or batch blobs in the DTO.
 The central revision boundary creates an automatic logical snapshot after each
 25 new revisions and retains only the newest 12 automatic snapshots per
 project. Named snapshots are never removed by this retention policy.
@@ -575,70 +542,58 @@ Required operations:
   Uploads are PNG/JPEG/SVG up to 2 MB with a content signature check; the logo
   is served with `nosniff` and a restrictive CSP.
 
-## Revit / CSV External Model Work
+## Revit / Linear Excel External Model Work
 
-Status: further Revit work (editor assignment UI, follow-up import, return
-export) is deferred and will be tackled later. When it resumes, the exchange
-stays CSV-based and uses the CSV export/import of the Linear plugin in Revit.
-The internal Revit/CAD steering committee prefers this over manipulating the
-model directly through Dynamo. Do not start Dynamo, Revit API or JSON
-transport work. The Linear CSV layout is not yet known: check a sample export
-against the existing project CSV configuration before changing the parser.
-Earlier Dynamo considerations are archived in
-`docs/archive/revit-dynamo-leistungsbilanz-integration-konzept.md`; the
-removed diagnostic scripts remain reachable through the git tag
-`archive/dynamo-vorueberlegungen`.
+Phase 14 is active and follows
+`docs/spec/revit-excel-integration-requirements.md` plus
+`docs/spec/revit-excel-phase-14-plan.md`. The old CSV requirements and phases
+14.0–14.6 are superseded. Dynamo, Revit API and JSON transport remain excluded.
 
-When explicitly working on Phase 14, use
-`docs/spec/revit-csv-integration-requirements.md` as the detailed source of
-truth together with the current architecture documents.
+Critical target rules:
 
-Critical rules:
+- Exchange uses only `.xlsx` files produced and consumed by the Linear plugin.
+- Revit integration remains optional. Import never creates a CircuitDeviceRow,
+  Circuit or equipment identifier.
+- Worksharing-ID is the external key and is compared exactly and
+  case-sensitively. It stays separate from internal UUIDs and circuit BMKs.
+  IfcGUID is optional redundancy, never a key, and duplicate values are only a
+  warning.
+- A row without Worksharing-ID is suspicious only when `Familie und Typ` is
+  populated. Show a warning and skip it; do not block. Other ID-less rows,
+  including the sample summary in column B, are skipped silently.
+- Source, planning and override values remain separate. Existing ProjectDevices
+  remain canonical and are never silently changed.
+- Multi-socket objects remain indivisible. Row quantity stays
+  `manualQuantity + sum(effectiveQuantity)`.
+- The project configuration has no independent version counter. Preview and
+  apply use `expectedRevision`; import batches store a configuration copy.
+- Apply retransmits and parses the workbook. Undo/Redo never reads Excel; they
+  apply only stored before/after states.
+- Only the newest import batch retains original bytes and the full matrix;
+  older batches retain date, filename, SHA-256 and object count.
+- The Revit object table loads one compact list, filters/sorts in the client and
+  renders it virtually; do not add server pagination.
+- Linked objects always follow their row's distribution board. Changing a
+  room's default board affects only unassigned objects and is not blocked.
+- Deleting a row, circuit or group warns that X Revit objects become unassigned,
+  detaches them in the same command and restores links on Undo. Only deletion
+  of referenced rooms and distribution boards is blocked.
+- Missing optional return columns for designation, power, voltage or current
+  produce warnings and are skipped. Only missing circuit columns for the
+  selected combined/separate mode block export.
+- Missing GZF defaults visibly to 1 without separate confirmation.
+- R2 must generate a changed return workbook from the local sample. The user
+  tests it in Linear before R3. If Linear rejects it, propose direct OOXML
+  modification of the original workbook before starting R3.
+- All confirmed writes use typed project commands with `expectedRevision`,
+  complete inverse data and the shared project-command transaction boundary.
+- Do not add automatic circuit planning, Revit circuit adoption, multi-source
+  management, partial imports, PostgreSQL, background jobs or new permissions.
 
-- Revit integration is optional. Do not make imported external data mandatory
-  for projects, rooms, project devices, circuits or device rows.
-- Parse imports into staging first. Never write CSV rows directly into circuits
-  or device rows.
-- Keep external object identity separate from internal UUIDs and circuit BMKs.
-  `IfcGUID` identifies the external Revit object and must never replace an
-  internal UUID or `equipmentIdentifier`.
-- One imported Revit object may exist without a `CircuitDeviceRow`.
-  Import, room assignment, distribution-board assignment, classification and
-  ProjectDevice linking do not create a row.
-- Create or change a `CircuitDeviceRow` only after an explicit user action in
-  the circuit-list editor.
-- Several external objects may link to one `CircuitDeviceRow`, while every
-  external object remains individually traceable for follow-up imports and
-  object-specific export.
-- Multi-socket Revit objects are indivisible. Their effective quantity may be
-  greater than one, but one external object must never be split across circuits.
-- Existing ProjectDevices are canonical project templates and must not be
-  overwritten from Revit values. When creating a new ProjectDevice, mapped
-  Revit values may prefill the creation form.
-- Store imported source values separately from local planning values and local
-  overrides. Imports never silently overwrite local values.
-- Repeated imports match deterministically by project/source and `IfcGUID`.
-  New, changed, missing and conflicting objects require preview and explicit
-  user decisions.
-- The first implementation assumes one complete Revit model export per project.
-  Do not add visible multi-source, linked-model or partial-import management.
-- CSV configuration is project-scoped. Preserve title, header, blank, subtotal
-  and unknown rows and columns for the return export.
-- Treat rows without `IfcGUID` as passthrough when they contain no object data.
-  Do not report Revit subtotal rows as missing-identity objects.
-- Apply each confirmed import diff through a typed project command with
-  `expectedRevision`, complete inverse data and the shared project command
-  transaction boundary.
-- External-model state must be added to logical project snapshots and portable
-  project transfer when it becomes part of the supported runtime.
-- Keep CSV parsing/serialization in a transport adapter. Domain services must
-  not depend on CSV syntax, React, `better-sqlite3` or concrete repositories.
-- Do not implement automatic circuit planning, Dynamo/API exchange,
-  PostgreSQL, background jobs or permissions as part of the initial CSV phase.
-
-Before implementation, audit the current ProjectDevice, CircuitDeviceRow,
-command, snapshot, transfer and editor drag-and-drop paths. Propose concrete
-domain objects and commands before adding migrations.
+The real sample `docs/spec/kbp-Stromkreis.xlsx` contains project data. It is
+gitignored and must never be embedded in tests or committed. Use synthetic
+workbooks for automated tests and accept the real file only as an explicit
+local path in the reference checker.
 
 ## Cable Sizing Module
 
@@ -733,9 +688,6 @@ for the early-phase power balance by DIN 276 cost group (see
 
 ## Current Deferred Work
 
-- Revit/CSV/IFCGUID round-trip (deferred; later via Linear plugin CSV, never
-  Dynamo), except when Phase 14 is explicitly requested and
-  `docs/spec/revit-csv-integration-requirements.md` is being followed
 - full electrical sizing
 - multi-user/PostgreSQL operation
 - supported production deployment
diff --git a/README.md b/README.md
index f64ae04..3490332 100644
--- a/README.md
+++ b/README.md
@@ -9,11 +9,12 @@ Docker-Server-Stack mit gebautem Anwendungscode und ein separater
 Entwicklungsstack bereit. Ein vollständig unterstütztes Produktionsdeployment
 für mehrere gleichzeitig arbeitende Prozesse und ein vollständig unterstütztes
 Produktionsdeployment fehlen weiterhin. Anmeldung und zwei feste Rollen sind
-vorhanden. Revit-CSV-Konfiguration, Vorschau
-und bestätigter Erstimport sind implementiert; die Editoroberfläche zur
-Objektzuordnung, Folgeimporte und Rückexport stehen noch aus. Die weitere
-Revit-Arbeit ist zurückgestellt und erfolgt später über den CSV-Export/-Import
-des Linear-Plugins in Revit.
+vorhanden. Die bisherige Revit-CSV-/IfcGUID-Grundlage mit Vorschau und
+bestätigtem Erstimport ist noch im Code vorhanden. Der freigegebene
+Phase-14-Plan ersetzt sie schrittweise durch den XLSX-Austausch des
+Linear-Plugins mit Worksharing-ID als externem Schlüssel. R0 ist abgeschlossen;
+R1 aktualisiert die Dokumentation. Editorzuordnung, Folgeimport und Rückexport
+sind noch nicht als neuer Excel-Pfad ausgeliefert.
 
 ## Unterstützter Arbeitsablauf
 
@@ -40,9 +41,9 @@ des Linear-Plugins in Revit.
 - grobe Leistungsbilanzen für LPH 2/3 nach Kostengruppen führen, mit der
   detaillierten Bilanz vergleichen und einzelne Zeilen als Projektgerät
   übernehmen
-- Revit-CSV-Dateien konfigurieren, prüfen und nach expliziter Zuordnung von
-  Räumen, Verteilungen und Projektgeräten erstmals importieren; dabei entstehen
-  noch keine Stromkreise oder Gerätezeilen
+- den vorhandenen Legacy-Revit-CSV-Erstimport verwenden; der Zielpfad über
+  Linear-XLSX, eigene Revit-Seite, Editorzuordnung, Rückgabe und Folgeimport
+  wird gemäß Phase-14-Plan umgesetzt
 
 ## Technik
 
@@ -177,6 +178,8 @@ vor der Baseline werden nicht unterstützt.
 - [Anmeldung und Benutzerverwaltung](docs/authentication.md)
 - [Entwicklungs- und Contributor-Workflow](docs/development-workflow.md)
 - [Bekannte Einschränkungen](docs/circuit-list-editor-known-limitations.md)
+- [Revit-Integration über Linear-Excel](docs/spec/revit-excel-integration-requirements.md)
+- [Phase-14-Plan R0–R10](docs/spec/revit-excel-phase-14-plan.md)
 - [Roadmap](docs/spec/07-implementation-phases-todo.md)
 
 Für LLM-gestützte Änderungen enthält [AGENTS.md](AGENTS.md) die verbindlichen
diff --git a/docs/README.md b/docs/README.md
index 3569b42..90c5fc3 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -31,13 +31,18 @@ ausdrücklich getrennt und dürfen nicht als bereits implementiert verstanden we
 - [Entwicklungs- und Contributor-Workflow](development-workflow.md)
 - [Deployment und Betrieb](deployment.md)
 
-## Zukunftsarchitektur
+## Aktive Revit-Umstellung
 
 - [Projektversionen und externer Modellaustausch](project-history-and-external-model-architecture.md)
-- [LLM-Kontext für die Revit-Anforderungsplanung](revit-requirements-llm-context.md)
-- [Revit-CSV-Anforderungen](spec/revit-csv-integration-requirements.md) –
-  zurückgestellt; später über den CSV-Export/-Import des Linear-Plugins
-- [Phase-14-Audit und Implementierungsplan](spec/revit-csv-phase-14-audit-and-plan.md)
+- [Revit-Integration über Linear-Excel](spec/revit-excel-integration-requirements.md) –
+  verbindliche Anforderungen für XLSX und Worksharing-ID
+- [Phase-14-Plan R0–R10](spec/revit-excel-phase-14-plan.md) – Status,
+  Paketgrenzen und Linear-Freigabepunkt nach R2
+- [R0-Bestandsaudit](spec/revit-excel-r0-audit.md)
+- [LLM-Kontext für Phase 14](revit-requirements-llm-context.md)
+
+## Zukunftsarchitektur
+
 - [Zukünftige Dimensionierung](spec/06-future-sizing-and-calculations.md)
 - [Roadmap und Phasen](spec/07-implementation-phases-todo.md)
 - [Aktueller Produkt-Backlog](spec/08-current-product-backlog.md)
diff --git a/docs/building-structure.md b/docs/building-structure.md
index 21059b4..9db2c91 100644
--- a/docs/building-structure.md
+++ b/docs/building-structure.md
@@ -101,8 +101,8 @@ bleiben.
 ## Offen
 
 - Revit: Eine Übernahme des Gebäudes aus Revit ist derzeit nicht geplant. Die
-  Revit-Arbeit ist insgesamt zurückgestellt und läuft später über die
-  Linear-CSV; das Modell steht einer späteren CSV-Zuordnung nicht im Weg.
+  aktive Phase 14 verwendet Linear-XLSX; das Modell steht der expliziten
+  Raumzuordnung im Importwizard nicht im Weg.
 - Raumflächen werden derzeit ausschließlich manuell gepflegt. Ein späterer
   Revit-Abgleich muss die Phase-14-Regeln mit externem Modellzustand, Vorschau
   und ausdrücklicher Bestätigung einhalten.
diff --git a/docs/circuit-list-editor-known-limitations.md b/docs/circuit-list-editor-known-limitations.md
index fdc463a..ee2d470 100644
--- a/docs/circuit-list-editor-known-limitations.md
+++ b/docs/circuit-list-editor-known-limitations.md
@@ -9,9 +9,10 @@
 - Named and automatic logical project snapshots can be listed and restored
   through the project page with persistent Undo/Redo. Automatic snapshots are
   created every 25 revisions and only their newest 12 entries are retained.
-- Further Revit work is deferred; it will later use the CSV export/import of
-  the Linear plugin in Revit, not Dynamo.
-- The Revit/CSV foundation and confirmed initial import are implemented.
+- The current Revit/CSV foundation and confirmed initial import are a legacy
+  starting point. The active Phase-14 plan replaces them with the Linear XLSX
+  exchange and exact Worksharing-ID identity.
+  R2 must pass a real Linear return-import check before database cutover in R3.
   Existing-row assignment, move and detach plus creation of an external-only
   row in an existing or newly created circuit have atomic persistent commands.
   Their API planning and editor UI, follow-up import, conflict review and return
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 20c7ccd..8993974 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -640,11 +640,15 @@ PostgreSQL ist bewusst nicht implementiert. Die Domainregeln und
 Transaktionsgrenzen sollen portabel bleiben; Schema und Betriebsmodell benötigen
 bei einem späteren Wechsel trotzdem einen eigenen PostgreSQL-Adapter.
 
-## Revit-CSV-Grundlage
+## Revit-Anbindung: Legacy-Ausgangslage und freigegebener Excel-Cutover
 
-**Zurückgestellt:** Die weitere Revit-Arbeit wird später angegangen, dann
-über den CSV-Export/-Import des Linear-Plugins in Revit statt über Dynamo.
-Details: [Revit-CSV-Anforderungen, Abschnitt 1](spec/revit-csv-integration-requirements.md).
+Der nachfolgende Abschnitt beschreibt den am Ende von R1 noch vorhandenen
+Legacy-Laufzeitpfad. Er verwendet CSV und IfcGUID und ist die geprüfte
+Ausgangslage für den schrittweisen Cutover; er darf nicht erweitert werden.
+Das verbindliche Ziel ist der XLSX-Austausch des Linear-Plugins mit exakter,
+case-sensitiver Worksharing-ID. Details:
+[Excel-Anforderungen](spec/revit-excel-integration-requirements.md) und
+[R0–R10-Plan](spec/revit-excel-phase-14-plan.md).
 
 Der reine Adapter unter `src/external-model/csv` validiert die projektweite
 Transport- und Mappingkonfiguration und parst UTF-8-CSV verlustarm in eine
@@ -774,11 +778,33 @@ Die Kataloganlage ist jeweils ein eigener Projekt-Command; der Wizard übernimmt
 den neuen Datensatz anschließend in seinen lokalen Auswahlkatalog und markiert
 ihn für die betroffene Gruppe.
 
+### Freigegebener Zielpfad ab R2
+
+R2 ersetzt zunächst nur den Transportadapter und endet mit einem realen
+Linear-Rückimporttest. R3 bleibt bis zu dessen Freigabe gesperrt. Scheitert der
+ExcelJS-Roundtrip, wird vor R3 ein Adapter vorgeschlagen, der die Original-XLSX
+direkt auf OOXML-Ebene ändert.
+
+Der Zielzustand verwendet Worksharing-ID als exakten, case-sensitiven externen
+Schlüssel; IfcGUID bleibt optional. Die Konfiguration hat keinen eigenen
+Versionszähler. `expectedRevision` bindet Vorschau und Apply, Importbatches
+speichern eine Konfigurationskopie. Nur der letzte Batch hält Workbook und
+Matrix vollständig, ältere Batches nur Metadaten. Apply parst die erneut
+übertragene Datei, Undo/Redo arbeitet nur auf persistierten Zuständen.
+
+Die eigene Route `/projects/:projectId/revit` lädt eine kompakte Objektliste
+einmal und stellt sie clientseitig gefiltert, sortiert und virtualisiert dar.
+Verknüpfte Objekte folgen dem Verteiler ihrer Row. Row-, Circuit- und
+Gruppenlöschungen lösen externe Links nach Warnung im selben Command; Undo
+stellt sie wieder her. Raum- und Verteilerlöschungen bleiben bei externen
+Referenzen gesperrt.
+
 ## Noch nicht unterstützt
 
 - Mehrbenutzerbetrieb und Konfliktauflösung
-- Editor-Oberfläche für die vorhandene Zuordnungslogik, Folgeimport und
-  strukturtreuer Revit-Rückexport
+- Linear-XLSX-Transport, eigene Revit-Seite, Editor-Oberfläche für die
+  Zuordnungslogik, Folgeimport und strukturtreuer Revit-Rückexport; Umsetzung
+  folgt dem R0–R10-Plan
 - vollständige elektrische Dimensionierung
 - Produktionsdeployment
 
diff --git a/docs/project-history-and-external-model-architecture.md b/docs/project-history-and-external-model-architecture.md
index f8ed263..91b82ca 100644
--- a/docs/project-history-and-external-model-architecture.md
+++ b/docs/project-history-and-external-model-architecture.md
@@ -9,7 +9,8 @@ This document records architectural direction for future work. It is not a final
 - persist undo/redo across page reloads and application restarts
 - provide a project-wide version history with named restore points
 - preserve an auditable sequence of user, import, migration and restore operations
-- support future Revit/CSV round-trips using stable IFCGUID-based links
+- support the Revit/Linear-XLSX round-trip using stable, exact
+  Worksharing-ID-based external identity
 - keep the persistence boundary replaceable so PostgreSQL can be adopted later
 
 ## Separate Concerns
@@ -111,11 +112,12 @@ Implemented automatic-snapshot policy:
 - automatic capture and retention run inside the same transaction as the
   triggering project revision
 
-## Revit / CSV / IFCGUID Round-Trip Direction
+## Revit / Linear Excel Round-Trip Direction
 
-**Deferred:** further Revit work will be tackled later, then through the
-CSV export/import of the Linear plugin in Revit instead of Dynamo. Details:
-[Revit-CSV requirements, section 1](spec/revit-csv-integration-requirements.md).
+Phase 14 is active and follows the
+[Linear-Excel requirements](spec/revit-excel-integration-requirements.md) and
+[R0–R10 plan](spec/revit-excel-phase-14-plan.md). The existing CSV/IFCGUID
+runtime is a legacy starting point for the cutover, not the target model.
 
 External model exchange should use explicit staging and link entities instead of writing imported rows directly into circuits.
 
@@ -124,9 +126,12 @@ Conceptual entities:
 - `ExternalModelSource`
   - identifies a Revit/IFC model or another external source within a project
 - `ExternalImportBatch`
-  - file name, checksum, import time, format/version and processing status
+  - file name, checksum, import time, object count and processing status
+  - only the latest batch keeps original workbook bytes, matrix and the
+    configuration copy; older batches keep date, filename, checksum and count
 - `ExternalModelObject`
-  - stable IFCGUID and optional Revit element identifiers
+  - exact case-sensitive Worksharing-ID as external identity
+  - optional IfcGUID as non-unique source redundancy
   - source attributes and last-seen import batch
 - `ExternalObjectLink`
   - explicit relationship to a project device, circuit device row or another future domain entity
@@ -137,13 +142,27 @@ Conceptual entities:
 
 Required behavior:
 
-- IFCGUID uniqueness is scoped to project and external model source.
+- Worksharing-ID uniqueness is scoped to the external source and uses exact,
+  case-sensitive comparison. IfcGUID is not a matching key.
 - Parsing writes to staging first.
 - Users preview additions, changes, missing objects and conflicts before applying them.
 - Applying an import creates one project revision and one auditable change set.
 - Imported source values and locally assigned planning values remain distinguishable.
-- Export retains IFCGUID and source identifiers so Revit parameters can be matched deterministically.
-- Missing objects and duplicate/conflicting identifiers are reported, never silently reassigned.
+- Export retains Worksharing-ID so Linear can match rows deterministically.
+- Missing objects and duplicate/conflicting Worksharing-IDs are reported,
+  never silently reassigned.
+
+The project configuration has no separate revision counter. Stateless plans
+and apply requests bind to `expectedRevision`; every applied import batch holds
+its configuration copy. Apply reparses the retransmitted workbook. Undo and
+Redo operate only on persisted complete before/after states and never parse an
+Excel file.
+
+Deleting a linked row, circuit or group detaches affected Revit objects in the
+same typed command after an explicit warning; its inverse restores all links.
+Only deleting referenced rooms and distribution boards is blocked. Linked
+objects always derive their board from their row, while a room default-board
+change affects only unassigned objects.
 
 ## SQLite and PostgreSQL Direction
 
@@ -292,7 +311,8 @@ Remaining constraints before completing project version history:
   boundary; extend it whenever further project mutations are introduced
 - project creation remains initialization at revision zero, while global device
   templates remain outside any single project history
-- do not model IFCGUID as an overloaded circuit equipment identifier
+- do not model Worksharing-ID or IfcGUID as an overloaded circuit equipment
+  identifier or an internal relation id
 - keep database backup/restore checks separate from project history tests
 
 ## Deferred Decisions
@@ -300,5 +320,6 @@ Remaining constraints before completing project version history:
 - whether large snapshot payloads remain in PostgreSQL or move to object storage
 - branch visualization after undo followed by new edits
 - user/role model and actor attribution
-- supported Revit CSV dialects and parameter mapping UI
+- Linear-XLSX compatibility beyond the observed sample and any future
+  project-independent mapping profiles
 - PostgreSQL deployment topology and migration date
diff --git a/docs/revit-requirements-llm-context.md b/docs/revit-requirements-llm-context.md
index cf10324..3782150 100644
--- a/docs/revit-requirements-llm-context.md
+++ b/docs/revit-requirements-llm-context.md
@@ -1,273 +1,15 @@
-# Kontext für die Revit-Anforderungsplanung
+# LLM-Kontext für die Revit-Integration
 
-**Zurückgestellt:** Die weitere Revit-Arbeit wird später angegangen, dann
-über den CSV-Export/-Import des Linear-Plugins in Revit statt über Dynamo.
-Details: [Revit-CSV-Anforderungen, Abschnitt 1](spec/revit-csv-integration-requirements.md).
+Die frühere offene Revit-/CSV-Anforderungsplanung ist abgeschlossen und
+abgelöst. Für Arbeiten an Phase 14 sind vollständig zu lesen:
 
-## Zweck dieser Datei
+- [Revit-Integration über Linear-Excel](spec/revit-excel-integration-requirements.md)
+- [R0–R10-Plan](spec/revit-excel-phase-14-plan.md)
+- [R0-Bestandsaudit](spec/revit-excel-r0-audit.md)
+- [Aktuelle Systemarchitektur](current-architecture.md)
+- [Projekt-History und externer Modellzustand](project-history-and-external-model-architecture.md)
 
-Diese Datei ist eine kompakte Übergabe an ein anderes LLM. Sie soll dabei
-helfen, gemeinsam mit dem Anwender die fachlichen und technischen Anforderungen
-für einen zukünftigen Revit-Datenaustausch zu klären.
-
-Die Revit-Schnittstelle ist **noch nicht implementiert**. Das LLM soll zunächst
-den tatsächlichen Arbeitsablauf erfragen, Unklarheiten sichtbar machen und
-daraus eine neue, überprüfbare Arbeitsanweisung erstellen. Es soll weder ein
-Dateiformat noch ein Datenbankschema oder eine UI ungefragt festlegen.
-
-## Produkt und fachliches Modell
-
-Leistungsbilanz ist eine Webanwendung für die elektrische Ausführungsplanung.
-Ihr Kern ist ein tabellenähnlicher Stromkreislisten-Editor für Verteilungen.
-
-Das unterstützte Laufzeitmodell ist:
-
-```text
-Project
-├── Floor
-│   └── Room
-├── ProjectDevice
-└── DistributionBoard
-    └── CircuitList
-        └── CircuitSection
-            └── Circuit
-                └── CircuitDeviceRow
-```
-
-Wichtige fachliche Grenzen:
-
-- Ein `Circuit` ist nicht dasselbe wie eine Gerätezeile.
-- Ein Stromkreis kann null, eine oder mehrere `CircuitDeviceRow` enthalten.
-- BMK (`equipmentIdentifier`), Schutz- und Kabeldaten gehören zum Stromkreis.
-- Menge, Einzelleistung, Gleichzeitigkeitsfaktor, cosPhi, Raum, Kostengruppe
-  und Kategorie gehören zur Gerätezeile.
-- Ein `ProjectDevice` ist eine wiederverwendbare, projektbezogene Vorlage.
-- Eine Gerätezeile kann mit einem Projektgerät verknüpft sein, behält aber
-  lokale Werte und ausdrücklich erfasste Abweichungen.
-- Änderungen eines Projektgeräts überschreiben verknüpfte Zeilen niemals
-  automatisch. Eine Synchronisierung benötigt Vorschau und Benutzerauswahl.
-- Manuelle, nicht mit einem Projektgerät verknüpfte Gerätezeilen sind regulär
-  erlaubt.
-- Bestehende BMKs und stabile UUIDs dürfen nicht automatisch verändert werden.
-- Neunummerierung ist immer eine ausdrückliche Benutzeraktion.
-- `IFCGUID` darf nicht als BMK oder als Ersatz für eine interne UUID verwendet
-  werden.
-
-Für einen späteren Revit-Austausch besonders relevante Daten sind:
-
-- Projekt: Name, interne/externe Projektnummer, Bauherr, Beschreibung,
-  Kennzeichnung als öffentliches Gebäude und Projektspannungen.
-- Geschoss und Raum: interne UUID, Name beziehungsweise Raumnummer und
-  Raumname.
-- Verteilung: interne UUID, Name, Etage, Netzart und Gleichzeitigkeitsfaktor.
-- Stromkreis: interne UUID, BMK, Anzeigename, Bereich, Schutz-, Kabel-,
-  Spannungs-, Steuerungs-, Status- und Bemerkungsdaten.
-- Gerätezeile: interne UUID, optionale Projektgeräteverknüpfung, Name,
-  Anzeigename, Phasenart, Anschlussart, Kostengruppe, Kategorie, Geschoss,
-  Raum, Menge, Einzelleistung, Gleichzeitigkeitsfaktor, cosPhi und Bemerkung.
-- Projektgerät: interne UUID sowie die wiederverwendbaren Gerätewerte.
-
-Die Phasenart ist fachlich `1-phasig` oder `3-phasig`. Die Spannung wird daraus
-und aus den Projekteinstellungen abgeleitet; freie Sonderspannungen sind im
-aktuellen Produkt nicht vorgesehen.
-
-## Aktuelle technische Architektur
-
-- Frontend: Next.js App Router, React und TypeScript unter `src/app` und
-  `src/frontend`.
-- API: Express und Zod unter `src/server`.
-- Fachregeln und typisierte Commands: `src/domain`.
-- Persistenz: SQLite, Drizzle und Repository-Adapter unter `src/db`.
-- Laufzeitkomposition konkreter Repositories:
-  `src/server/composition`.
-- Lokaler Betrieb: Browser/Next.js auf Port 3001, Express-API auf Port 3000,
-  SQLite-Datei unter `data/leistungsbilanz.db`.
-- Docker Compose wird für die lokale Entwicklung unterstützt.
-- PostgreSQL und Mehrbenutzerbetrieb sind noch nicht umgesetzt.
-
-Der zentrale Editor liegt unter:
-
-```text
-src/app/projects/[projectId]/circuit-lists/[circuitListId]/tree-edit/page.tsx
-src/frontend/components/circuit-tree-editor.tsx
-```
-
-Frontend-Aktionen werden als validierte API-Commands ausgeführt. Fachregeln
-liegen in Domain-Services; konkrete SQLite-Zugriffe bleiben in
-Persistenzadaptern. Neue Revit-Fachlogik darf deshalb nicht direkt von
-`better-sqlite3`, React-Komponenten oder globalen Datenbankinstanzen abhängen.
-
-## Revisionen, Undo/Redo und Sicherungspunkte
-
-Alle normalen projektbezogenen Änderungen laufen über eine gemeinsame
-Command- und Transaktionsgrenze:
-
-```text
-Fachänderung + inverses Kommando + Revision + Undo/Redo-Übergang
-```
-
-Diese Bestandteile werden atomar geschrieben oder vollständig zurückgerollt.
-Jedes Projekt besitzt eine monoton steigende `currentRevision`. Schreibbefehle
-geben die erwartete Revision mit, damit veraltete Clients keine neueren
-Änderungen überschreiben.
-
-Undo/Redo ist projektweit persistent und funktioniert nach Reload oder
-Anwendungsneustart. Zusätzlich gibt es:
-
-- eine unveränderliche Revisions-Timeline;
-- benannte und automatische logische Projektsnapshots;
-- wiederherstellbare Snapshots mit Prüfsumme;
-- einen portablen, versionierten JSON-Projekttransfer.
-
-Ein angewendeter Revit-Import muss später dieselbe Integritätsgrenze verwenden:
-Die bestätigten Änderungen sollen als ein nachvollziehbarer Projekt-Command
-beziehungsweise als ein fachlich definierter Änderungssatz atomar,
-revisioniert und rückgängig machbar sein.
-
-## Klare Abgrenzung zum vorhandenen JSON-Projekttransfer
-
-Der vorhandene JSON-Export/-Import überträgt den vollständigen internen
-Projektzustand. Er dient Sicherung, Wiederherstellung und Duplizierung eines
-Projekts innerhalb von Leistungsbilanz.
-
-Dieser Projekttransfer ist **kein** Revit-Austauschformat. Er enthält interne
-Strukturen und UUIDs und soll nicht ohne bewusste Entscheidung als Grundlage
-für CSV-Dateien oder Revit-Parameter verwendet werden.
-
-Der zukünftige Revit-Workflow soll dagegen externe Modellobjekte anhand stabiler
-externer Identitäten wiedererkennen, ausgewählte Planungswerte zuordnen und
-Ergebnisse so exportieren, dass Revit sie wieder den richtigen Objekten
-zuweisen kann.
-
-## Bereits vereinbarte Leitplanken für den externen Modellaustausch
-
-Diese Punkte gelten als Architekturvorgaben, noch nicht als fertiges
-Implementierungsdesign:
-
-- Ein Import schreibt niemals ungeprüft direkt in Stromkreise oder
-  Gerätezeilen.
-- Eingelesene Daten landen zuerst in einem Staging-/Vorschaubereich.
-- Vor der Übernahme werden neue, geänderte, fehlende, doppelte und
-  widersprüchliche Objekte angezeigt.
-- Wiederholte Importe müssen Objekte deterministisch anhand der externen Quelle
-  und einer stabilen Identität, voraussichtlich IFCGUID, erkennen.
-- Die Eindeutigkeit einer IFCGUID ist mindestens auf Projekt und externe
-  Modellquelle begrenzt; die genaue Quellendefinition ist noch zu klären.
-- Importierte Quellwerte und lokal in Leistungsbilanz geplante Werte müssen
-  unterscheidbar bleiben.
-- Lokale Planungswerte dürfen niemals still überschrieben werden.
-- Verknüpfungen zwischen externen Objekten und internen Fachobjekten müssen
-  ausdrücklich modelliert werden.
-- Fehlende oder widersprüchliche Identitäten werden gemeldet und niemals
-  automatisch einem anderen Objekt zugeordnet.
-- Ein Export bewahrt IFCGUID und erforderliche Quellidentitäten, damit Revit
-  die Werte deterministisch zurückschreiben kann.
-- Ein Export bezieht sich auf eine bekannte Projektrevision.
-- Große Datenmengen allein erzwingen noch keinen Wechsel von SQLite zu
-  PostgreSQL. PostgreSQL wird relevant bei Mehrbenutzerbetrieb, zentralem
-  Serverbetrieb oder unabhängigen Hintergrundjobs.
-
-Als mögliche, aber noch nicht beschlossene Konzepte wurden bisher genannt:
-
-- `ExternalModelSource`
-- `ExternalImportBatch`
-- `ExternalModelObject`
-- `ExternalObjectLink`
-- `ExternalParameterMapping`
-- `ExternalExportBatch`
-
-Diese Namen beschreiben Verantwortlichkeiten. Das andere LLM darf sie
-hinterfragen und verbessern, soll sie aber nicht als bereits vorhandene
-Tabellen behandeln.
-
-## Auftrag an das andere LLM
-
-Erarbeite die Anforderungen dialogorientiert mit dem Anwender. Beginne mit dem
-realen Ablauf in Revit und kläre danach schrittweise mindestens:
-
-1. Welche Revit-Objekte beziehungsweise Kategorien werden exportiert?
-2. Wie entsteht die Ausgangsdatei in Revit und wie sieht sie technisch aus
-   (CSV-Dialekt, Trennzeichen, Encoding, Dezimalformat, Kopfzeilen,
-   Revit-Versionen)?
-3. Welche Identitäten stehen zur Verfügung: IFCGUID, Revit `ElementId`,
-   Typ-ID, Modell-/Dateikennung oder weitere Schlüssel?
-4. Wie werden Hauptmodell, Teilmodelle, verknüpfte Modelle, Modellkopien und
-   aktualisierte Revit-Dateien unterschieden?
-5. Welche Parameter kommen aus Revit und welche Werte werden ausschließlich in
-   Leistungsbilanz geplant?
-6. Welche internen Ziele können externe Objekte erhalten: Projektgerät,
-   Gerätezeile, Stromkreis, Raum, Verteilung oder weitere Entitäten?
-7. Werden externe Objekte einzeln oder gesammelt einem Stromkreis,
-   Projektgerät, Raum oder einer Verteilung zugeordnet?
-8. Welche Werte sollen nach Revit zurückgeschrieben werden, in welchen
-   Einheiten und unter welchen Revit-Parameternamen?
-9. Muss die ursprüngliche Datei einschließlich unbekannter Spalten,
-   Zeilenreihenfolge und Formatierung erhalten werden, oder darf eine neue
-   Rückgabedatei erzeugt werden?
-10. Wie sollen Spalten-/Parametermappings erstellt, gespeichert,
-    wiederverwendet und zwischen Projekten geteilt werden?
-11. Was gilt bei erneutem Import für neue, geänderte, gelöschte, verschobene,
-    doppelte oder nicht mehr sichtbare Revit-Objekte?
-12. Wer gewinnt bei Konflikten zwischen neuem Revit-Wert und lokaler Änderung?
-    Welche Konflikte dürfen automatisch gelöst werden und welche benötigen
-    eine Auswahl?
-13. Welche Vorschau, Filter, Sammelaktionen und Bestätigungen benötigt der
-    Anwender vor der Übernahme?
-14. Welche fachlichen Validierungen und Pflichtfelder müssen eine Übernahme
-    verhindern oder nur eine Warnung erzeugen?
-15. Welche Dateigrößen, Objektzahlen und Laufzeiten sind realistisch?
-16. Müssen Import und Export synchron im Browser laufen oder werden später
-    Hintergrundjobs benötigt?
-17. Welche Informationen müssen für Nachvollziehbarkeit, Undo/Redo,
-    Versionshistorie und Support gespeichert werden?
-18. Welche konkreten End-to-End-Beispiele und Fehlerfälle dienen als
-    Abnahmekriterien?
-
-Stelle Rückfragen in kleinen, zusammenhängenden Blöcken. Unterscheide in deinen
-Notizen ausdrücklich:
-
-- vom Anwender bestätigte Anforderungen;
-- sinnvolle Vorschläge;
-- offene Entscheidungen;
-- technische Folgerungen;
-- bewusst nicht betrachtete spätere Ausbaustufen.
-
-## Erwartetes Ergebnis der Anforderungsrunde
-
-Erstelle am Ende eine neue Arbeitsanweisung für das implementierende LLM. Sie
-soll mindestens enthalten:
-
-- Ziel, Umfang und ausdrücklich ausgeschlossene Funktionen;
-- vollständigen Anwenderworkflow für Erstimport, Zuordnung, Folgeimport und
-  Rückexport;
-- vereinbartes Dateiformat mit einem anonymisierten Beispiel;
-- Feld- und Einheitenmapping einschließlich Richtung und Datenhoheit;
-- Identitäts-, Matching- und Quellmodell;
-- Regeln für neue, geänderte, fehlende und doppelte Objekte;
-- Konflikt-, Validierungs- und Freigaberegeln;
-- UI-Ablauf für Staging, Vorschau, Zuordnung und Bestätigung;
-- Anforderungen an Revision, Atomarität, Undo/Redo und Audit;
-- vorgeschlagene Modul- und Persistenzgrenzen, ohne bestehende
-  Architekturregeln zu umgehen;
-- schrittweise Implementierungsphasen mit überprüfbaren Abnahmekriterien;
-- offene Punkte, die vor dem jeweiligen Implementierungsschritt geklärt werden
-  müssen.
-
-Die Arbeitsanweisung soll noch keinen Code enthalten. Sie muss klar markieren,
-welche Entscheidungen der Anwender tatsächlich getroffen hat und welche Teile
-nur Architekturvorschläge des LLM sind.
-
-## Weiterführende Projektdokumente
-
-- `AGENTS.md` – verbindliche Domänen- und Implementierungsregeln
-- `docs/current-architecture.md` – vollständiger aktueller Laufzeit- und
-  Command-Pfad
-- `docs/project-history-and-external-model-architecture.md` – bisherige
-  Zukunftsrichtung für Versionierung, externes Modell und PostgreSQL
-- `docs/spec/01-domain-context.md` – fachlicher Kontext
-- `docs/spec/03-data-model-concept.md` – Datenmodellkonzept
-- `docs/spec/05-linked-devices-and-sync.md` – Regeln für Projektgeräte und
-  kontrollierte Synchronisierung
-- `docs/spec/07-implementation-phases-todo.md` – Roadmap, insbesondere Phase 14
-- `docs/circuit-list-editor-known-limitations.md` – noch nicht implementierte
-  Funktionen
+Bei Widersprüchen gilt das Anforderungsdokument. CSV, IfcGUID als Schlüssel,
+Dynamo, Revit-API und JSON-Transport sind keine Zielpfade. Der derzeit noch im
+Code vorhandene CSV-Stand ist ausschließlich die in R1 dokumentierte
+Legacy-Ausgangslage für den schrittweisen Cutover.
diff --git a/docs/spec/07-implementation-phases-todo.md b/docs/spec/07-implementation-phases-todo.md
index f36d60d..0043ef2 100644
--- a/docs/spec/07-implementation-phases-todo.md
+++ b/docs/spec/07-implementation-phases-todo.md
@@ -532,36 +532,34 @@ Acceptance criteria:
 
 ## Phase 14: External Model Round-Trip
 
-**Zurückgestellt:** Die weitere Revit-Arbeit wird später angegangen, dann
-über den CSV-Export/-Import des Linear-Plugins in Revit statt über Dynamo.
-Details: [Revit-CSV-Anforderungen, Abschnitt 1](revit-csv-integration-requirements.md).
+Status: R0 ist mit Korrekturen freigegeben; R1 stellt die Dokumentation auf
+Linear-XLSX und Worksharing-ID um. Die frühere CSV-Planung 14.0–14.6 ist
+abgelöst und wird nicht fortgeschrieben.
 
-Status: Phase 14.2 (persistente externe Objekte und bestätigter Erstimport) ist
-implementiert. Editor-Zuordnung, Rückexport und Folgeimport folgen. Siehe
-[Phase-14-Audit und Implementierungsplan](revit-csv-phase-14-audit-and-plan.md)
-und die verbindlichen
-[Revit-CSV-Anforderungen](revit-csv-integration-requirements.md).
+Verbindliche Quellen:
 
-Goal:
+- [Revit-Integration über Linear-Excel](revit-excel-integration-requirements.md)
+- [R0–R10-Plan](revit-excel-phase-14-plan.md)
+- [R0-Bestandsaudit](revit-excel-r0-audit.md)
 
-Exchange model objects and planning parameters with Revit through CSV (Linear plugin export/import).
+Die Umsetzung erfolgt ausschließlich in den Paketen R0–R10. R2 endet mit
+einer aus der realen Musterdatei erzeugten Rückgabedatei. Der Nutzer muss sie
+erfolgreich in Linear importieren, bevor R3 beginnt. Bei einem Fehlschlag wird
+zuvor eine direkte OOXML-Änderung des Originalworkbooks als Alternative
+vorgelegt.
 
-Tasks:
+Kernabnahme der Phase:
 
-- model external sources, import batches and stable IFCGUID objects
-- stage and validate imports before applying them
-- show additions, changes, missing objects and conflicts
-- link external objects explicitly to project-domain entities
-- apply an import as one auditable project revision
-- configure inbound and outbound parameter mappings
-- export against a known project revision while preserving IFCGUID
-
-Acceptance criteria:
-
-- repeated imports match objects deterministically by source and IFCGUID
-- imports never silently overwrite local planning values
-- users approve the diff before it changes the project
-- exported data can be assigned back to the correct Revit objects
+- Worksharing-ID ist der exakte, case-sensitive externe Schlüssel;
+- XLSX-Kopfkommentare, Struktur, Formate und unbekannte Spalten bleiben beim
+  Rückexport erhalten;
+- Import erzeugt keine Rows und überschreibt keine lokale Planung still;
+- Zuordnung, Löschung, Folgeimport und Undo/Redo sind atomar und nach Neustart
+  reproduzierbar;
+- Undo/Redo liest keine Excel-Datei;
+- nur der letzte Importbatch enthält Workbook und Matrix vollständig;
+- mehrere Tausend Objekte bleiben über eine clientseitig gefilterte,
+  virtualisierte Liste bedienbar.
 
 PostgreSQL should be introduced when shared multi-user operation, background jobs or operational scale justify it. External-object count alone does not require an immediate migration.
 
diff --git a/docs/spec/08-current-product-backlog.md b/docs/spec/08-current-product-backlog.md
index c0a2720..6d1eae4 100644
--- a/docs/spec/08-current-product-backlog.md
+++ b/docs/spec/08-current-product-backlog.md
@@ -162,7 +162,7 @@ ProjectDevices and device rows (#20).
 3. [x] Snapshot-to-revision descriptions and history presentation.
 4. [x] Distribution-board power summary and project column layout.
 
-The Revit/CSV/IFCGUID round-trip follows the distribution-board component
-foundation as a separate jointly planned phase and must not be inferred from
-these tasks. It is currently deferred and will later use the CSV
-export/import of the Linear plugin in Revit, not Dynamo.
+The Revit/Linear-XLSX round-trip is now the separately planned active Phase 14.
+It uses exact Worksharing-ID identity and must not be inferred from these
+unrelated backlog tasks. See
+[the R0–R10 plan](revit-excel-phase-14-plan.md).
diff --git a/docs/spec/revit-csv-integration-requirements.md b/docs/spec/revit-csv-integration-requirements.md
index 4ce65ee..7889566 100644
--- a/docs/spec/revit-csv-integration-requirements.md
+++ b/docs/spec/revit-csv-integration-requirements.md
@@ -1,1386 +1,8 @@
-# Revit-CSV-Integration – Anforderungen und Implementierungsanweisung
+# Abgelöst: Revit-CSV-Anforderungen
 
-## 1. Status und Verbindlichkeit
+Diese CSV-/IfcGUID-Spezifikation ist seit 29.09.2026 abgelöst. Die verbindliche
+Quelle ist [Revit-Integration über Linear-Excel](revit-excel-integration-requirements.md).
 
-> **Zurückgestellt (September 2026).** Die weitere Revit-Arbeit
-> (Editor-Oberfläche zur Objektzuordnung, Folgeimport, Rückexport) wird später
-> angegangen. Wenn sie wieder aufgenommen wird, bleibt der Austausch
-> CSV-basiert: Export und Import laufen über das Linear-Plugin in Revit. Das
-> entspricht der Vorgabe des internen Revit/CAD-Lenkungskreises, weil dabei
-> nicht direkt per Dynamo im Modell gearbeitet wird. Eine Dynamo- oder
-> API-Anbindung ist nicht vorgesehen; die früheren Vorüberlegungen liegen unter
-> [docs/archive](../archive/revit-dynamo-leistungsbilanz-integration-konzept.md).
-> Der Aufbau der Linear-CSV ist noch offen. Vor der Wiederaufnahme wird ein
-> Musterexport gegen die bestehende projektweite CSV-Konfiguration und den
-> Parser geprüft; erst danach wird entschieden, was anzupassen ist. Die bereits
-> umgesetzten Schritte bleiben unverändert nutzbar.
-
-Dieses Dokument ist die verbindliche fachliche und technische Arbeitsgrundlage für **Phase 14: External Model Round-Trip**.
-
-Es unterscheidet ausdrücklich zwischen:
-
-- **Bestätigte Anforderung:** vom Anwender festgelegtes Verhalten.
-- **Bestehende Architekturvorgabe:** bereits geltende Regel des Projekts.
-- **Implementierungsvorschlag:** empfohlene technische Aufteilung, noch kein unveränderliches Datenbankschema.
-- **Offene Entscheidung:** darf erst in der jeweils genannten Phase konkretisiert werden.
-
-Codex darf aus diesem Dokument kein vollständiges Event-Sourcing, keine PostgreSQL-Migration, keine automatische Stromkreisplanung und keine direkte Dynamo-Anbindung ableiten.
-
-Vor Implementierungsbeginn sind insbesondere zu lesen:
-
-- `AGENTS.md`
-- `docs/current-architecture.md`
-- `docs/spec/03-data-model-concept.md`
-- `docs/spec/05-linked-devices-and-sync.md`
-- `docs/project-history-and-external-model-architecture.md`
-- `docs/spec/07-implementation-phases-todo.md`
-- `docs/circuit-list-editor-known-limitations.md`
-
-## 2. Ziel
-
-Die Anwendung soll Revit-Objekte der Kategorie **Elektroinstallation** über eine CSV-Datei einlesen, dauerhaft anhand ihrer `IfcGUID` erkennen und mit der manuellen Elektroplanung in Leistungsbilanz verbinden.
-
-Der Workflow soll insbesondere vermeiden, dass Stromkreiskennzeichnungen und Leistungen für jedes Revit-Objekt händisch nachgetragen werden müssen.
-
-Der Nutzer soll:
-
-1. Revit-Objekte importieren,
-2. Räume aus dem Import anlegen oder vorhandenen Räumen zuordnen,
-3. Räume und einzelne Objekte Verteilungen zuordnen,
-4. Objekte klassifizieren und optional mit `ProjectDevice`-Vorlagen verknüpfen,
-5. noch nicht verschaltete Objekte im Stromkreislisteneditor manuell Stromkreisen und Gerätezeilen zuweisen,
-6. Stromkreiskennzeichnung und Leistung in eine strukturgleiche Rückgabe-CSV schreiben,
-7. denselben vollständigen Modellstand später erneut importieren und Änderungen kontrolliert abgleichen.
-
-## 3. Grundlegende Produktgrenzen
-
-### 3.1 Revit bleibt optional
-
-**Bestätigte Anforderung**
-
-Leistungsbilanz muss vollständig ohne Revit-Integration nutzbar bleiben.
-
-- Projekte, Ebenen, Räume, Verteilungen, Projektgeräte, Stromkreise und Gerätezeilen bleiben manuell anlegbar.
-- Ein Projekt darf ausschließlich manuelle Daten, ausschließlich verknüpfte Revit-Daten oder eine Mischung enthalten.
-- Revit ist nur für die Existenz und die Quellattribute der tatsächlich verknüpften Modellobjekte führend.
-- Revit ist nicht die alleinige Quelle des gesamten Leistungsbilanzprojekts.
-
-### 3.2 Circuit-First-Modell bleibt unverändert
-
-**Bestehende Architekturvorgabe**
-
-```text
-Project
-├── Floor
-│   └── Room
-├── ProjectDevice
-└── DistributionBoard
-    └── CircuitList
-        └── CircuitSection
-            └── Circuit
-                └── CircuitDeviceRow
-```
-
-- Ein `Circuit` ist nicht dasselbe wie eine `CircuitDeviceRow`.
-- BMK, Schutz- und Kabeldaten gehören zum Stromkreis.
-- Menge, Leistung, Gleichzeitigkeitsfaktor, cosPhi, Raum, Kostengruppe und Kategorie gehören zur Gerätezeile.
-- Ein importiertes Revit-Objekt darf vor seiner Stromkreiszuordnung eigenständig existieren.
-- Der Import legt nicht automatisch Stromkreise oder Gerätezeilen an.
-
-### 3.3 Stable IDs und BMK
-
-**Bestehende Architekturvorgabe**
-
-- `IfcGUID` ersetzt niemals eine interne UUID.
-- `IfcGUID` wird niemals als Stromkreis-BMK verwendet.
-- Bestehende interne UUIDs und BMKs dürfen nicht automatisch geändert werden.
-- Neunummerierung bleibt eine ausdrückliche Benutzeraktion.
-- Import, Sortierung, Verschieben und Folgeabgleich führen nicht automatisch zu einer Neunummerierung.
-
-## 4. Umfang der ersten Ausbaustufe
-
-### 4.1 Enthalten
-
-**Bestätigte Anforderungen**
-
-- projektweite CSV- und Mappingkonfiguration;
-- Import vollständiger CSV-Dateien;
-- Import von Revit-Objekten der Kategorie `Elektroinstallation`;
-- deterministische Identifikation über `IfcGUID`;
-- Import beziehungsweise Verknüpfung von Räumen;
-- manuelle Verknüpfung von Räumen mit Ebenen;
-- manuelle Anlage der Verteilungen;
-- Standardverteilung je Raum und abweichende Verteilung je Objekt;
-- exakte Klassifizierung über den CSV-Wert `Familie und Typ`;
-- konfigurierbare Behandlung von Einzel- und Mehrfachsteckdosen;
-- optionale Verknüpfung importierter Objekte mit vorhandenen `ProjectDevice`-Vorlagen;
-- Erstellen neuer `ProjectDevice`-Vorlagen aus ausgewählten Importobjekten;
-- lokale Planungswerte und Abweichungen bereits vor der Stromkreiszuordnung;
-- projektweites Import-, Staging- und Abgleichs-UI;
-- Bereich für unzugeordnete externe Objekte im Stromkreislisteneditor;
-- manuelle Zuordnung zu bestehenden Gerätezeilen, bestehenden Stromkreisen oder neuen Stromkreisen;
-- Rückexport von vollständiger Stromkreiskennzeichnung und elektrischer Leistung;
-- Erhaltung der ursprünglichen CSV-Struktur;
-- kontrollierter Folgeimport mit Einzel- und Sammelentscheidungen;
-- atomare, revisionierte und rückgängig machbare Übernahmen.
-
-### 4.2 Ausdrücklich nicht enthalten
-
-**Bestätigte Anforderungen**
-
-- automatische Stromkreisbildung in der ersten Ausbaustufe;
-- automatische Übernahme späterer Stromkreisvorschläge;
-- Import von Verteilungen aus Revit;
-- Import einer separaten MEP-Raumliste;
-- Teilimporte einzelner Ansichten oder Geschosse;
-- Verwaltung mehrerer sichtbarer Modellquellen;
-- direkte Dynamo- oder API-Synchronisation;
-- PostgreSQL- oder Mehrbenutzerbetrieb;
-- automatische Reservekreisbildung;
-- automatische elektrische Dimensionierung;
-- automatische Konfliktentscheidung;
-- automatische Freigabe oder Wiederverwendung leer gewordener Stromkreisnummern;
-- Platzhalter, Teiltextsuche oder reguläre Ausdrücke in der ersten Familie-und-Typ-Klassifizierung.
-
-## 5. Begriffe
-
-### 5.1 Externes Modellobjekt
-
-Ein importiertes Revit-Exemplar mit eigener `IfcGUID`.
-
-Es ist weder automatisch ein `ProjectDevice` noch automatisch eine `CircuitDeviceRow`.
-
-### 5.2 Quellwert
-
-Ein Wert, der aus der zuletzt akzeptierten Revit-CSV stammt.
-
-Beispiele:
-
-- Revit-Raumnummer;
-- Revit-Raumname;
-- Familie und Typ;
-- CAx-Auswahlkenner;
-- vorhandene Stromkreiskennzeichnung;
-- vorhandene elektrische Leistung.
-
-### 5.3 Lokaler Planungswert
-
-Ein in Leistungsbilanz bestätigter beziehungsweise bearbeiteter Wert.
-
-Lokale Planungswerte dürfen durch Importe niemals still überschrieben werden.
-
-### 5.4 Wirksame Menge
-
-Die fachliche Menge, die für Gerätezeile, Leistungsberechnung und Steckdosenbegrenzung zählt.
-
-Beispiel:
-
-```text
-2 Doppelsteckdosen + 2 Einzelsteckdosen
-= 4 Revit-Objekte
-= 6 physische Steckdosen
-= wirksame Menge 6
-```
-
-## 6. Revit-CSV-Vertrag
-
-### 6.1 Konfigurierbare Transporteigenschaften
-
-**Bestätigte Anforderung**
-
-Die Konfiguration gilt projektweit und muss über eine GUI bearbeitbar sein.
-
-Mindestens konfigurierbar:
-
-- Encoding;
-- Trennzeichen;
-- Dezimaltrennzeichen;
-- Zahlenformat;
-- Einheit und Umrechnungsregel für Leistung;
-- Spaltenname für `IfcGUID`;
-- Spaltenname für Raumnummer;
-- Spaltenname für Raumname;
-- Spaltenname für `Familie und Typ`;
-- Spaltenname für `CAx_Auswahlkenner`;
-- Spaltenname für Stromkreiskennzeichnung;
-- Spaltenname für elektrische Leistung;
-- Spaltenname für den Mengenparameter einer Mehrfachsteckdose;
-- weitere Quellspalten-zu-internen-Feld-Mappings.
-
-Erste Standardwerte:
-
-```text
-Encoding: UTF-8
-Trennzeichen: ;
-Leistung in Revit: W
-```
-
-### 6.2 Tatsächlich beobachtetes CSV-Profil
-
-Die bereitgestellte Referenzdatei besitzt:
-
-```text
-Encoding: UTF-8 mit BOM
-Zeilenende: CRLF
-Trennzeichen: Semikolon
-Quotierung: alle Felder in doppelten Anführungszeichen
-Zeile 1: Titel-/Metadatenzeile
-Zeile 2: Kopfzeile mit 12 Spalten
-Zeile 3: vollständig leere Zeile
-Objektzeilen mit IfcGUID: 897
-Summen-/Gruppierungszeilen ohne IfcGUID: 211
-Nichtleere doppelte IfcGUIDs: keine
-```
-
-Beispiel einer nicht als Objekt zu importierenden Summenzeile:
-
-```text
-"UV_AV_DG_01-1F1: 8";"";"";"";"";"";"";"";"";"";"";""
-```
-
-Die Implementierung darf daher nicht annehmen, dass:
-
-- die Kopfzeile immer die erste Dateizeile ist;
-- jede Zeile nach der Kopfzeile ein Objekt ist;
-- jede fehlende `IfcGUID` automatisch ein fehlerhaftes Objekt darstellt.
-
-### 6.3 Erkennen der Kopfzeile
-
-**Implementierungsvorschlag**
-
-Die Kopfzeile wird anhand der projektweit konfigurierten erforderlichen Spaltennamen gesucht.
-
-- Genau eine passende Kopfzeile: verwenden.
-- Keine passende Kopfzeile: Import blockieren.
-- Mehrere passende Kopfzeilen: Import blockieren und Auswahl beziehungsweise Konfiguration verlangen.
-- Zeilen vor und nach der Kopfzeile bleiben als Transportbestandteil erhalten.
-
-### 6.4 Zeilenklassen
-
-**Implementierungsvorschlag**
-
-Jede CSV-Zeile wird genau einer Klasse zugeordnet:
-
-1. `metadata`  
-   Zeile vor der Kopfzeile oder sonstige nicht tabellarische Metadaten.
-
-2. `header`  
-   Erkannte Kopfzeile.
-
-3. `passthrough`  
-   Leer-, Summen-, Gruppierungs- oder sonstige Zeile ohne externe Objektidentität, die nicht wie ein unvollständiges Objekt wirkt.
-
-4. `object`  
-   Zeile mit nichtleerer, syntaktisch akzeptierter `IfcGUID`.
-
-5. `suspect-object`  
-   Zeile ohne `IfcGUID`, aber mit befüllten objekttragenden Feldern wie Raum, Familie und Typ oder Auswahlkenner.
-
-`passthrough`-Zeilen werden unverändert erhalten und erzeugen keine externen Objekte.
-
-`suspect-object`-Zeilen werden als Konflikt angezeigt und nicht automatisch verworfen.
-
-### 6.5 Strukturtreuer Rückexport
-
-**Bestätigte Anforderung**
-
-Der Rückexport basiert auf der zuletzt akzeptierten vollständigen CSV und muss erhalten:
-
-- identische Anzahl und Reihenfolge der Zeilen;
-- identische Anzahl und Reihenfolge der Spalten;
-- Titel-, Leer-, Summen- und sonstige Passthrough-Zeilen;
-- unbekannte beziehungsweise nicht gemappte Spalten;
-- unveränderte Werte in nicht zu schreibenden Zellen;
-- `IfcGUID` jeder Objektzeile;
-- vorhandene Transportmerkmale, soweit technisch zuverlässig erkennbar.
-
-Mindestens zu erhalten sind:
-
-```text
-BOM-Status
-Encoding
-Zeilenende
-Trennzeichen
-Spaltenreihenfolge
-Zeilenreihenfolge
-Titelzeilen
-Leerzeilen
-Summenzeilen
-```
-
-Nur explizit als Ausgangsparameter gemappte Zellen von erkannten Objektzeilen dürfen ergänzt oder überschrieben werden.
-
-Eine vollständig neu zusammengestellte Tabelle mit nur den fachlich verwendeten Spalten ist unzulässig.
-
-### 6.6 Anonymisiertes Beispiel
-
-```csv
-"Projekt-Export";"";"";"";""
-"Stromkreis";"Raumnummer";"Raumname";"Familie und Typ";"Auswahlkenner";"Leistung";"IfcGUID"
-"";"";"";"";"";"";""
-"UV_AV_01-2F1";"01/101";"Technik";"Steckdose: Doppelsteckdose";"Arbeitsplatz";"";"0AbCdEfGhIjKlMnOpQrStu"
-"UV_AV_01-2F1: 2";"";"";"";"";"";""
-```
-
-Die letzte Zeile ist eine Passthrough-Summenzeile, kein externes Modellobjekt.
-
-## 7. Identität und Matching
-
-### 7.1 Externe Identität
-
-**Bestätigte Anforderung**
-
-- `IfcGUID` ist der stabile Schlüssel für ein Revit-Objekt.
-- Ein Objekt bleibt auch bei geänderten Quellwerten über seine `IfcGUID` bekannt.
-- Doppelte nichtleere `IfcGUIDs` innerhalb eines Imports sind ein blockierender Konflikt.
-- Eine fehlende `IfcGUID` in einer echten Objektzeile verhindert die automatische Verknüpfung.
-
-### 7.2 Quellmodell
-
-**Bestätigte Anforderung plus Architekturfolgerung**
-
-Für die erste Ausbaustufe gibt es pro Leistungsbilanzprojekt genau einen vollständigen Revit-Modellstrom.
-
-Die technische Architektur darf trotzdem eine implizite externe Quelle vorsehen, damit `IfcGUID` nicht global oder projektübergreifend eindeutig sein muss.
-
-Empfohlene Semantik:
-
-```text
-Project
-└── implicit ExternalModelSource
-    └── ExternalModelObject identified by IfcGUID
-```
-
-Es gibt in der ersten Ausbaustufe keine sichtbare Verwaltung von Hauptmodellen, Teilmodellen oder verknüpften Modellen.
-
-### 7.3 Interne Identität
-
-Jedes externe Objekt erhält zusätzlich eine stabile interne UUID.
-
-Diese UUID wird für interne Relationen, Commands, Snapshots und Undo/Redo verwendet.
-
-## 8. Datenhoheit
-
-### 8.1 Revit-geführt
-
-Revit ist zunächst führend für:
-
-- Existenz des externen Objekts;
-- `IfcGUID`;
-- Familie und Typ;
-- Revit-Raumnummer und Revit-Raumname als Quellwerte;
-- CAx-Auswahlkenner als Quellwert;
-- sonstige ausschließlich aus Revit importierte Attribute.
-
-### 8.2 Leistungsbilanz-geführt
-
-Leistungsbilanz ist nach Bestätigung führend für:
-
-- interne Raum- und Ebenenverknüpfung;
-- Standard- und Objektverteilung;
-- Klassifizierung;
-- `ProjectDevice`-Verknüpfung;
-- lokale Planungswerte;
-- Stromkreiszuordnung;
-- `CircuitDeviceRow`-Zuordnung;
-- Stromkreis-BMK;
-- elektrische Planungsleistung;
-- GZF, cosPhi, Kostengruppe, Kategorie und weitere lokale Gerätewerte.
-
-### 8.3 Konfliktregel
-
-Kein Folgeimport darf lokale Planungswerte automatisch überschreiben.
-
-Der Nutzer entscheidet je Konflikt oder per Sammelaktion zwischen:
-
-- Revit-Änderung übernehmen;
-- lokalen Wert beibehalten;
-- manuell einen dritten Wert festlegen.
-
-## 9. Projektweite Revit-Konfiguration
-
-### 9.1 Mapping
-
-Die Projektkonfiguration muss die CSV-Spalten auf interne Bedeutungen abbilden.
-
-Der CAx-Auswahlkenner muss mindestens als sichtbarer, filterbarer und gruppierbarer Wert verfügbar sein. Er kann als Vorschlag für einen Anzeigenamen verwendet werden.
-
-### 9.2 Familie-und-Typ-Regeln
-
-**Bestätigte Anforderung**
-
-In der ersten Ausbaustufe gilt ausschließlich exakter Textvergleich.
-
-Eine Regel kann mindestens festlegen:
-
-- exakter CSV-Wert `Familie und Typ`;
-- interner Gerätetyp beziehungsweise fachliche Kategorie;
-- Anschlussart;
-- ProjectDevice-Kategorie `lighting`, `single_phase` oder `three_phase`;
-- Mengenregel:
-  - feste Menge `1`;
-  - Menge aus gemappter CSV-Spalte;
-- optional vorgeschlagener Anzeigename beziehungsweise Mappingquelle.
-
-Mehrere unterschiedliche Revit-Familien und -Typen dürfen demselben internen Gerätetyp zugeordnet werden.
-
-Beispiele:
-
-```text
-_E_CAx Steckdose_AP: Steckdose Aufputz
-→ interner Gerätetyp Steckdose
-→ single_phase
-→ Menge 1
-```
-
-```text
-_E_CAx Mehrfachsteckdose: Doppelsteckdose
-→ interner Gerätetyp Steckdose
-→ single_phase
-→ Menge aus konfigurierter Anzahl-Spalte
-```
-
-### 9.3 Zugriff
-
-Der Konfigurationsbereich ist zunächst für alle Nutzer zugänglich, da noch kein Rollen- oder Rechtesystem existiert.
-
-## 10. Externes Objekt und Planungszustand
-
-### 10.1 Notwendige fachliche Informationen
-
-**Implementierungsvorschlag, kein finales Schema**
-
-Ein persistiertes externes Objekt benötigt mindestens:
-
-- interne UUID;
-- Projekt- und implizite Quellenzugehörigkeit;
-- `IfcGUID`;
-- Referenz auf die aktuelle beziehungsweise zuletzt akzeptierte Quellzeile;
-- importierte Quellwerte;
-- zuletzt akzeptierte Quellwerte für den Folgeabgleich;
-- verknüpften internen Raum, optional;
-- Standardverteilung des Raums;
-- abweichende Objektverteilung, optional;
-- Klassifizierung;
-- wirksame Menge;
-- lokale Planungswerte;
-- lokale Override-Metadaten;
-- optionales `linkedProjectDeviceId`;
-- optionalen Link zu einer `CircuitDeviceRow`;
-- letzten Sichtbarkeits-/Importstatus;
-- letzten gesehenen Importbatch;
-- Konfliktstatus.
-
-### 10.2 Kein automatischer Row-Lebenszyklus
-
-Folgende Aktionen erzeugen keine `CircuitDeviceRow`:
-
-- CSV einlesen;
-- Raum zuordnen;
-- Verteilung zuordnen;
-- klassifizieren;
-- ProjectDevice verknüpfen;
-- lokale Planungswerte bearbeiten.
-
-Eine Gerätezeile entsteht ausschließlich durch ausdrückliche Zuordnung im Stromkreislisteneditor.
-
-## 11. ProjectDevice-Verknüpfung
-
-### 11.1 Vorhandenes ProjectDevice
-
-Importierte Objekte dürfen mit einem vorhandenen `ProjectDevice` verknüpft werden.
-
-Das vorhandene `ProjectDevice` wird durch Revit-Werte niemals automatisch verändert.
-
-Die bestehende Regel bleibt verbindlich:
-
-- `ProjectDevice` ist die kanonische Projektvorlage;
-- lokale Werte und Overrides bleiben möglich;
-- Änderungen am ProjectDevice werden nie still synchronisiert;
-- Synchronisierung benötigt Vorschau und Auswahl.
-
-### 11.2 Neues ProjectDevice aus Importobjekten
-
-**Bestätigte Anforderung**
-
-Der Nutzer darf im Importwizard ein neues `ProjectDevice` erstellen.
-
-Das Erstellformular darf anhand der gemappten Werte der ausgewählten Revit-Objekte vorausgefüllt werden.
-
-Mögliche Vorbelegungen:
-
-- `name`;
-- `displayName`;
-- Kategorie;
-- Anschlussart;
-- Kostengruppe;
-- Einzelleistung;
-- Gleichzeitigkeitsfaktor;
-- cosPhi;
-- Bemerkung.
-
-Die Kategorie des ProjectDevices bestimmt gemäß bestehendem Modell die Phasenart. Es darf kein paralleles, widersprüchliches Phasenmodell eingeführt werden.
-
-Bei einer Mehrfachauswahl mit unterschiedlichen Quellwerten muss die UI Abweichungen anzeigen. Sie darf nicht willkürlich einen Wert wählen.
-
-### 11.3 Lokale Werte vor der Stromkreiszuordnung
-
-Importierte Objekte dürfen bereits vor der Stromkreiszuordnung lokale Planungswerte und lokale Abweichungen vom verknüpften ProjectDevice besitzen.
-
-Beim späteren Erzeugen einer Gerätezeile werden diese bestätigten Objektplanungswerte als Ausgangswerte verwendet.
-
-## 12. Erstimport-Workflow
-
-### 12.1 Öffnen und Konfiguration
-
-1. Nutzer öffnet die projektweite Revit-Integration.
-2. Falls keine gültige Mappingkonfiguration existiert, wird zuerst die Konfiguration geöffnet.
-3. Nutzer lädt eine vollständige CSV hoch.
-4. Parser erkennt Transportparameter und Kopfzeile.
-5. Datei wird ohne fachliche Projektschreibvorgänge geparst und validiert.
-
-### 12.2 Vorschau
-
-Die Vorschau zeigt mindestens:
-
-- Anzahl erkannter Objektzeilen;
-- Anzahl Passthrough-Zeilen;
-- Anzahl verdächtiger Objektzeilen;
-- fehlende und doppelte `IfcGUIDs`;
-- unbekannte Familie-und-Typ-Werte;
-- neue und bereits bekannte Räume;
-- vorhandene Stromkreiswerte;
-- nicht parsebare Leistungen oder Mengen.
-
-### 12.3 Raumwizard
-
-Räume werden aus den importierten Objektzeilen abgeleitet.
-
-Der Nutzer kann:
-
-- einen neuen internen Raum anlegen;
-- einen importierten Raum mit einem vorhandenen internen Raum verknüpfen;
-- mehrere Räume sortiert nach Raumnummer bearbeiten;
-- Räume einer Ebene zuordnen.
-
-Die Raumnummer ist zunächst das primäre Matchingmerkmal.
-
-Eine eigene Revit-Raum-GUID ist nicht erforderlich.
-
-### 12.4 Verteilungen
-
-Verteilungen werden manuell angelegt.
-
-Der Nutzer kann:
-
-- einem Raum eine Standardverteilung zuweisen;
-- mehrere Räume gesammelt einer Verteilung zuweisen;
-- einzelne Objekte abweichend einer anderen Verteilung zuweisen;
-- Objekte ohne MEP-Raum manuell einer Verteilung zuweisen.
-
-Neue Objekte eines bereits bekannten Raums erhalten die bestehende Standardverteilung als Vorschlag.
-
-### 12.5 Klassifizierung und ProjectDevices
-
-Der Nutzer kann:
-
-- Objekte nach Raum, Familie und Typ, CAx-Auswahlkenner und Status filtern;
-- Familie-und-Typ-Werte klassifizieren;
-- mehrere Objekte mit einem vorhandenen ProjectDevice verknüpfen;
-- unmittelbar ein neues ProjectDevice erstellen;
-- lokale Werte bearbeiten.
-
-### 12.6 Bereits gefüllte Stromkreiskennzeichnung
-
-Enthält eine Objektzeile bereits eine Stromkreiskennzeichnung, muss der Wizard fragen, wie sie behandelt wird.
-
-Möglichkeiten:
-
-- vorhandenen Wert nur als Quellwert behalten;
-- vorhandene Zuordnung übernehmen;
-- vorhandenen Wert ignorieren.
-
-Eine Übernahme ist nur zulässig, wenn:
-
-- die Präfix-Verteilung eindeutig vorhanden ist;
-- die Zuordnung zur Raum- beziehungsweise Objektverteilung passt oder ausdrücklich bestätigt wird;
-- der Stromkreis eindeutig vorhanden oder bewusst anzulegen ist;
-- keine widersprüchliche Zuordnung entsteht.
-
-Keine Variante darf still gewählt werden.
-
-### 12.7 Übernahme
-
-Die bestätigte Erstübernahme schreibt mindestens:
-
-- Importbatch;
-- vollständige Transportgrundlage für den Rückexport;
-- externe Objekte;
-- Quellwerte;
-- Raum- und Verteilungslinks;
-- Klassifizierungen;
-- ProjectDevice-Links;
-- lokale Planungswerte;
-- Konfliktentscheidungen.
-
-Die Übernahme ist ein atomarer Projekt-Command mit `expectedRevision`.
-
-Sie erzeugt genau eine Projektrevision und einen Undo-Schritt.
-
-Nach erfolgreicher Übernahme erscheinen ausreichend klassifizierte, einer Verteilung zugeordnete und noch nicht verschaltete Objekte im Stromkreislisteneditor.
-
-## 13. UI 1 – Import-, Staging- und Abgleichswizard
-
-### 13.1 Pflichtfunktionen
-
-- sortierbare tabellarische Darstellung für mehrere Tausend Objekte;
-- Volltextsuche;
-- Filter nach Raum, Raumname, Familie und Typ, CAx-Auswahlkenner, Verteilung, ProjectDevice, Stromkreis und Status;
-- Mehrfachauswahl;
-- Shift-Bereichsauswahl;
-- Auswahl aller gefilterten Treffer;
-- Auswahl vollständiger Räume oder Gruppen;
-- Sammelzuordnung zu Raum, Ebene, Verteilung, Klassifizierung und ProjectDevice;
-- Erstellen eines ProjectDevices;
-- Bearbeiten lokaler Planungswerte;
-- Vergleich Quellwert gegen lokalen Wert;
-- Konfliktentscheidungen einzeln und gesammelt;
-- Vorschau des Änderungssatzes vor Übernahme.
-
-### 13.2 Sichtbare Objektinformationen
-
-Mindestens:
-
-- `IfcGUID`;
-- Familie und Typ;
-- CAx-Auswahlkenner;
-- Revit-Raumnummer und Raumname;
-- interner Raum und Ebene;
-- Standardverteilung;
-- tatsächliche Objektverteilung;
-- Klassifizierung;
-- wirksame Menge;
-- verknüpftes ProjectDevice;
-- lokaler Anzeigename;
-- lokale Leistung;
-- zugeordneter Stromkreis;
-- zugeordnete CircuitDeviceRow;
-- Import- und Konfliktstatus.
-
-### 13.3 Statusfilter
-
-Mindestens:
-
-- neu;
-- bekannt und unverändert;
-- geändert;
-- Raum geändert;
-- im vollständigen Folgeimport nicht enthalten;
-- ohne Raum;
-- ohne Verteilung;
-- ohne Klassifizierung;
-- ohne ProjectDevice;
-- ohne Stromkreis;
-- vollständig zugeordnet;
-- konfliktbehaftet.
-
-`Ohne ProjectDevice` ist kein Fehler.
-
-## 14. UI 2 – Unzugeordnete Objekte im Stromkreislisteneditor
-
-### 14.1 Sichtbarkeit
-
-Der Editor zeigt einen separaten Bereich beziehungsweise Drawer mit Objekten, die:
-
-- der aktuellen Verteilung zugeordnet sind;
-- noch mit keiner `CircuitDeviceRow` verknüpft sind;
-- ausreichend klassifiziert sind;
-- keinen blockierenden Konflikt besitzen.
-
-### 14.2 Darstellung und Filter
-
-Mindestens sichtbar:
-
-- Raum;
-- Familie und Typ;
-- CAx-Auswahlkenner;
-- interner Gerätetyp;
-- ProjectDevice;
-- wirksame Menge;
-- Einzelleistung;
-- Objektgesamtleistung;
-- Kategorie beziehungsweise Phasenart;
-- Anschlussart;
-- Status.
-
-Filter und Mehrfachauswahl müssen auch hier für große Mengen geeignet sein.
-
-### 14.3 Drag-and-drop-Semantik
-
-**Bestätigte Anforderung**
-
-Der Drop-Zielbereich bestimmt die fachliche Aktion.
-
-#### Drop auf bestehende CircuitDeviceRow
-
-- ausgewählte externe Objekte werden mit genau dieser Zeile verknüpft;
-- Menge und Gesamtleistung werden neu berechnet;
-- die Anwendung wählt niemals selbst eine andere passende Zeile.
-
-#### Drop auf bestehenden Circuit
-
-- in diesem Stromkreis wird eine neue CircuitDeviceRow angelegt;
-- dies gilt auch, wenn bereits eine ähnliche Zeile vorhanden ist.
-
-#### Drop auf freien Zielbereich für neuen Circuit
-
-- ein neuer Circuit wird über den bestehenden Circuit-Insert-/Move-Mechanismus angelegt;
-- mindestens eine neue CircuitDeviceRow wird erzeugt;
-- BMK-Erzeugung folgt den bestehenden expliziten Regeln des Editors;
-- keine Nachbarstromkreise werden neu nummeriert.
-
-Die gesamte jeweilige Aktion einschließlich externer Links, Mengenänderung, Circuit-/Row-Erzeugung, Revision und History-Transition ist atomar.
-
-### 14.4 Keine automatische Zusammenführung
-
-Gleiche Eigenschaften dürfen Hinweise und Vorschläge erzeugen.
-
-Die Anwendung darf externe Objekte aber nicht ohne Benutzeraktion automatisch:
-
-- zusammenführen;
-- einer bestehenden Gerätezeile hinzufügen;
-- in einen Stromkreis verschieben;
-- auf mehrere Gerätezeilen verteilen.
-
-## 15. Gerätezeilen, Aggregation und Mehrfachsteckdosen
-
-### 15.1 Einzelobjekte bleiben erhalten
-
-Jedes Revit-Objekt bleibt intern separat anhand seiner `IfcGUID` nachvollziehbar, auch wenn mehrere Objekte in einer Gerätezeile aggregiert dargestellt werden.
-
-### 15.2 Mehrfachsteckdose
-
-**Bestätigte Anforderungen**
-
-- Eine Mehrfachsteckdose ist ein Revit-Objekt.
-- Ihr Mengenparameter enthält die Anzahl physischer Schukosteckdosen.
-- Eine Doppelsteckdose zählt als zwei Steckdosen.
-- Das Objekt ist unteilbar und darf nicht auf mehrere Stromkreise verteilt werden.
-- Die Leistung wird je physischer Steckdose angesetzt.
-- Die Objektgesamtleistung ist `wirksame Menge × powerPerUnit`.
-
-### 15.3 Gerätezeilenmenge
-
-Die Menge einer CircuitDeviceRow ist die Summe der wirksamen Mengen aller mit ihr verknüpften externen Objekte plus gegebenenfalls manuell geführter Anteile, sofern das vorhandene Datenmodell dies eindeutig unterscheiden kann.
-
-Beispiel:
-
-```text
-2 Doppelsteckdosen + 2 Einzelsteckdosen
-→ 4 ExternalModelObjects
-→ CircuitDeviceRow.quantity = 6
-```
-
-### 15.4 Getrennte Gerätezeilen
-
-**Bestätigte Anforderungen**
-
-Unterschiedliche Räume werden in getrennten Gerätezeilen dargestellt.
-
-Unterschiedliche CAx-Auswahlkenner werden in getrennten Gerätezeilen dargestellt.
-
-Beispiel:
-
-```text
-Circuit UV_AV_01-2F1
-- Raum 01/101: 4 × Arbeitsplatzsteckdose
-- Raum 01/101: 2 × Mediensteckdose
-- Raum 01/102: 1 × Arbeitsplatzsteckdose
-```
-
-Der Nutzer darf trotz gleicher Werte bewusst mehrere getrennte Gerätezeilen erzeugen.
-
-### 15.5 Raumübergreifende Stromkreise
-
-Raumübergreifende Stromkreise bleiben manuell zulässig und werden über mehrere Gerätezeilen übersichtlich dargestellt.
-
-Die spätere automatische Stromkreisvorschlagsfunktion darf nur raumbezogene Vorschläge erzeugen.
-
-## 16. Folgeimport
-
-### 16.1 Annahme
-
-Jeder Folgeimport enthält erneut den vollständigen relevanten Modellstand der Kategorie `Elektroinstallation`.
-
-Teilimporte sind in der ersten Ausbaustufe nicht zulässig beziehungsweise werden nicht als Löschgrundlage verwendet.
-
-### 16.2 Vergleichszustände
-
-Mindestens zu erkennen:
-
-- bekannte `IfcGUID`, unveränderte Quellwerte;
-- neue `IfcGUID`;
-- bekannte `IfcGUID` mit geänderten Quellwerten;
-- geänderter Revit-Raum;
-- geänderte Stromkreiskennzeichnung;
-- geänderte Leistung;
-- zuvor bekannte `IfcGUID` fehlt;
-- doppelte `IfcGUID`;
-- verdächtige Objektzeile ohne `IfcGUID`.
-
-### 16.3 Fehlende Objekte
-
-Fehlt eine bekannte `IfcGUID`, wird das Objekt nur als `nicht mehr im aktuellen vollständigen Export enthalten` markiert.
-
-Es wird nicht automatisch:
-
-- gelöscht;
-- aus seiner Gerätezeile entfernt;
-- aus seinem Stromkreis entfernt;
-- von seinem ProjectDevice getrennt.
-
-Erst nach ausdrücklicher Bestätigung wird das externe Objekt entfernt beziehungsweise als gelöscht übernommen.
-
-Danach:
-
-- wird sein Link zur CircuitDeviceRow entfernt;
-- werden Menge und Leistung der Zeile neu berechnet;
-- bleibt ein dadurch leer gewordener Circuit bestehen;
-- wird seine BMK nicht automatisch freigegeben oder neu vergeben.
-
-### 16.4 Raumänderung
-
-Eine Raumänderung wird anhand derselben `IfcGUID` erkannt und als Konflikt angezeigt.
-
-Sie wird nicht automatisch übernommen.
-
-### 16.5 Alle Änderungen sind nutzergesteuert
-
-Der Nutzer kann Konflikte:
-
-- einzeln behandeln;
-- gruppiert behandeln;
-- Revit-Werte übernehmen;
-- lokale Werte behalten;
-- manuell überschreiben.
-
-Die bestätigte Übernahme eines Folgeimports ist ein atomarer Projekt-Command und eine Projektrevision.
-
-## 17. Rückexport
-
-### 17.1 Grundlage
-
-Der Export verwendet den zuletzt akzeptierten vollständigen Importbatch und eine bekannte aktuelle Projektrevision.
-
-Ein Export verändert die Projektrevision nicht.
-
-### 17.2 Stromkreiskennzeichnung
-
-Für jedes einem Stromkreis zugeordnete externe Objekt wird geschrieben:
-
-```text
-<Verteilername beziehungsweise Verteiler-BMK><Stromkreis-BMK>
-```
-
-Beispiel:
-
-```text
-UV_AV_DG_01-2F1
-```
-
-Die genaue Trennlogik folgt dem tatsächlich im Projekt verwendeten Verteilerpräfix und Stromkreis-BMK; es darf kein zweites unabhängiges Nummerierungssystem eingeführt werden.
-
-### 17.3 Leistung
-
-Die Rückgabe erfolgt in Watt.
-
-Für eine Mehrfachsteckdose wird die objektbezogene Gesamtleistung geschrieben:
-
-```text
-Objektleistung = wirksame Menge des Revit-Objekts × powerPerUnit
-```
-
-Bei normalen Einzelobjekten ist die wirksame Menge `1`.
-
-### 17.4 Objektbezogene Ausgabe
-
-Sind mehrere Revit-Objekte mit einer gemeinsamen CircuitDeviceRow verknüpft:
-
-- erhält jedes Objekt seine eigene ursprüngliche CSV-Zeile;
-- erhält jedes Objekt dieselbe Stromkreiskennzeichnung;
-- erhält jedes Objekt seine eigene Objektgesamtleistung;
-- bleibt seine `IfcGUID` unverändert.
-
-### 17.5 Exportnachweis
-
-**Implementierungsvorschlag**
-
-Ein Exportbatch speichert mindestens:
-
-- Projekt-ID;
-- Projektrevision;
-- zugrunde liegenden Importbatch;
-- Zeitstempel;
-- Dateiname;
-- Prüfsumme;
-- verwendete Mappingkonfiguration beziehungsweise deren Version.
-
-Dies ist Auditmetadaten und kein Ersatz für die Projekt-Revisionshistorie.
-
-## 18. Validierungen
-
-### 18.1 Blockierende Fehler
-
-Mindestens:
-
-- CSV kann mit der Konfiguration nicht geparst werden;
-- erforderliche Kopfzeile ist nicht eindeutig;
-- erforderliche Spalte fehlt;
-- doppelte nichtleere `IfcGUID` unter Objektzeilen;
-- ungültige oder nicht serialisierbare Projektwerte;
-- stale `expectedRevision`;
-- Verknüpfung zu einem anderen Projekt;
-- Drop-Ziel gehört nicht zur zugeordneten Verteilung beziehungsweise Liste;
-- Mehrfachsteckdose würde intern auf mehrere Stromkreise aufgeteilt;
-- atomare Command-Vorbedingungen stimmen nicht mehr.
-
-### 18.2 Warnungen beziehungsweise aufzulösende Konflikte
-
-Mindestens:
-
-- unbekannter Familie-und-Typ-Wert;
-- Objekt ohne Raum;
-- Raumänderung;
-- bestehende abweichende Stromkreiskennzeichnung;
-- abweichende Revit-Leistung;
-- Objekt im Folgeimport nicht enthalten;
-- ausgewählte Objekte besitzen unterschiedliche lokale Planungswerte;
-- vorhandene Stromkreiszuordnung passt nicht zur Verteilung;
-- verdächtige Objektzeile ohne `IfcGUID`.
-
-## 19. Revision, Undo/Redo und Audit
-
-### 19.1 Gemeinsame Transaktionsgrenze
-
-**Bestehende Architekturvorgabe**
-
-Alle bestätigten projektbezogenen Änderungen laufen über:
-
-```text
-domain mutation
-+ inverse command
-+ project revision
-+ undo/redo transition
-```
-
-Sie werden gemeinsam über die bestehende Projekt-Command-Transaktionsgrenze committed oder vollständig zurückgerollt.
-
-Neue Revit-Fachlogik darf nicht direkt von React, `better-sqlite3`, globalen Datenbankinstanzen oder konkreten SQLite-Repositories abhängen.
-
-### 19.2 Neue logische Commands
-
-**Implementierungsvorschlag**
-
-Mindestens getrennte Command-Verantwortlichkeiten:
-
-- Revit-Projektkonfiguration ändern;
-- akzeptierten Erstimport anwenden;
-- akzeptierten Folgeimport anwenden;
-- externe Objektplanungswerte ändern;
-- externe Objekte mit ProjectDevices verknüpfen oder trennen;
-- externe Objekte einer bestehenden CircuitDeviceRow zuweisen;
-- externe Objekte als neue CircuitDeviceRow einem Circuit zuweisen;
-- externe Objekte mit neuem Circuit und neuer Row zuweisen;
-- externe Objektzuordnung aus einer Row lösen;
-- externes Objekt nach bestätigtem Fehlen löschen.
-
-Die konkreten Command-Namen und Payloads sind beim Implementierungsaudit festzulegen.
-
-### 19.3 Undo
-
-Undo muss insbesondere wiederherstellen:
-
-- externe Objekte und Quellstände;
-- Raum-, Verteilungs- und ProjectDevice-Links;
-- lokale Planungswerte und Overrides;
-- CircuitDeviceRow-Verknüpfungen;
-- Mengen und Leistungen;
-- erzeugte Row- und Circuit-UUIDs;
-- Importstatus.
-
-Undo darf keine BMKs neu berechnen.
-
-## 20. Snapshots und portabler Projekttransfer
-
-**Bestehende Architekturfolgerung**
-
-Sobald die Revit-Integration unterstützt wird, gehört ihr bestätigter Projektzustand zum vollständigen logischen Projektzustand.
-
-Snapshot- und JSON-Transfer-Schema müssen deshalb nach einem bewussten Schema-Versionswechsel mindestens erhalten:
-
-- projektweite Revit-Konfiguration;
-- Mappingregeln;
-- Familie-und-Typ-Regeln;
-- externe Objekte;
-- Quell- und Planungswerte;
-- Raum-, Verteilungs-, ProjectDevice- und CircuitDeviceRow-Links;
-- relevante Importbatch-Grundlagen für den Rückexport;
-- Konflikt- und Sichtbarkeitsstatus.
-
-Beim Duplizieren eines Projekts:
-
-- werden alle internen UUIDs remapped;
-- bleiben externe `IfcGUIDs` als Quellidentitäten erhalten;
-- werden interne Links auf die remappten Projektobjekte aktualisiert.
-
-Vorhandene Snapshot-Migrationen dürfen nicht still verändert werden. Es ist eine additive neue Schema-Version erforderlich.
-
-## 21. Modul- und Persistenzgrenzen
-
-### 21.1 Verbindliche Grenzen
-
-- Parsing und Serialisierung sind keine React-Aufgabe.
-- CSV-Dialektlogik ist kein Bestandteil von Circuit-Domain-Services.
-- Domain-Services kennen keine konkreten SQLite-Repositories.
-- Controller importieren keinen globalen Datenbankclient.
-- Writes erfolgen ausschließlich über typisierte Commands.
-- Reads verwenden schmale, fachlich benannte Repositories.
-- Server-Komposition erzeugt und injiziert konkrete Adapter.
-- SQLite bleibt der unterstützte Adapter.
-- PostgreSQL wird nicht in dieser Phase eingeführt.
-
-### 21.2 Empfohlene Verantwortlichkeiten
-
-**Implementierungsvorschlag**
-
-```text
-CSV transport adapter
-- dialect detection
-- header and row classification
-- lossless-enough matrix preservation
-- mapped value parsing
-- return serialization
-
-External model domain
-- identity and matching
-- source versus planning values
-- conflict calculation
-- object lifecycle
-- aggregation invariants
-
-Application services / commands
-- import preview
-- first import apply
-- follow import apply
-- link and unlink operations
-- export projection
-
-Persistence adapters
-- project configuration
-- import/export batches
-- external objects
-- links and accepted source state
-
-Frontend
-- project configuration UI
-- staging wizard
-- unassigned-object editor drawer
-```
-
-Die Namen sind Verantwortlichkeiten, keine vorab beschlossenen Tabellen- oder Ordnernamen.
-
-## 22. Performanceanforderungen
-
-**Bestätigte Anforderung**
-
-Das UI muss mehrere Tausend Objektzeilen praktisch bearbeitbar machen.
-
-Mindestens:
-
-- keine vollständige DOM-Darstellung aller Zeilen, falls dies die Bedienbarkeit beeinträchtigt;
-- server- oder clientseitige effiziente Sortierung und Filterung;
-- stabile Mehrfachauswahl;
-- Sammelaktionen auf gefilterte Treffer;
-- keine fachliche Änderung beim bloßen Filtern und Sortieren;
-- keine automatische Neunummerierung;
-- Import und Export dürfen zunächst synchron laufen, solange reale Projektdateien zuverlässig verarbeitet werden.
-
-Die Referenzdatei mit rund 900 Objektzeilen und über 1.100 Gesamtzeilen ist als Mindest-Integrationstest zu verwenden.
-
-## 23. Implementierungsphasen
-
-### Phase 14.0 – Audit und Verträge
-
-Ziel:
-
-- aktuelle ProjectDevice-, Row-, Command-, Snapshot- und Editorpfade prüfen;
-- konkretes Datenmodell und Command-Schnittstellen vorschlagen;
-- keine Implementierung vor Freigabe des Auditberichts.
-
-Lieferung:
-
-- Keep/Refactor/Add-Liste;
-- vorgeschlagene Domainobjekte;
-- vorgeschlagene Commands;
-- Snapshot-/Transfer-Auswirkungen;
-- Risiken bei Row-Mengen und lokalen Objektwerten.
-
-Abnahme:
-
-- keine bestehende Architekturregel wird umgangen;
-- offene Punkte sind klar als solche markiert.
-
-### Phase 14.1 – CSV-Konfiguration und Parser
-
-Ziel:
-
-- projektweite Mappingkonfiguration;
-- Parser und Serializer für das beobachtete CSV-Profil;
-- reine Vorschau ohne Projektschreibvorgang.
-
-Abnahme:
-
-- Referenzdatei wird mit 897 Objektzeilen und 211 Passthrough-Summenzeilen erkannt;
-- Titel-, Leer- und Summenzeilen bleiben erhalten;
-- nichtleere `IfcGUIDs` sind eindeutig;
-- Rückserialisierung ohne fachliche Änderungen erhält Struktur und Zellenwerte;
-- Parser besitzt fokussierte Tests für BOM, CRLF, Semikolon, Quotierung und Kopfzeile in Zeile 2.
-
-### Phase 14.2 – Externe Objekte und Erstimport
-
-Ziel:
-
-- persistente externe Objekte;
-- Raum-, Ebenen-, Verteilungs-, Klassifizierungs- und ProjectDevice-Verknüpfung;
-- atomare Importübernahme.
-
-Abnahme:
-
-- Import erzeugt keine CircuitDeviceRow;
-- Raum- und Verteilungszuordnung kann gespeichert werden;
-- neues ProjectDevice kann vorausgefüllt erstellt werden;
-- vorhandenes ProjectDevice wird nicht durch Revit-Werte verändert;
-- Import ist ein Undo-Schritt;
-- Undo entfernt den vollständigen bestätigten Importzustand.
-
-### Phase 14.3 – Stromkreislisteneditor
-
-Ziel:
-
-- unzugeordnete externe Objekte je Verteilung;
-- Drag-and-drop zu Row, Circuit oder neuem Circuit;
-- Aggregation und Mehrfachsteckdosen.
-
-Abnahme:
-
-- Drop auf Row ergänzt genau diese Row;
-- Drop auf Circuit erzeugt eine neue Row;
-- Drop auf neuen Zielbereich erzeugt Circuit und Row atomar;
-- 2 Doppel- plus 2 Einzelsteckdosen ergeben Menge 6;
-- keine Mehrfachsteckdose kann geteilt werden;
-- verschiedene Räume und Auswahlkenner bleiben in getrennten Rows;
-- Undo stellt externe Links, Mengen, Row-/Circuit-UUIDs und BMKs exakt wieder her.
-
-### Phase 14.4 – Rückexport
-
-Ziel:
-
-- strukturtreue Revit-Rückgabe-CSV.
-
-Abnahme:
-
-- Zeilen- und Spaltenzahl sowie Reihenfolge entsprechen der Ausgangsdatei;
-- unbekannte Spalten und Passthrough-Zeilen bleiben erhalten;
-- Stromkreis und Leistung werden ausschließlich in gemappte Objektzellen geschrieben;
-- jedes Objekt behält seine `IfcGUID`;
-- Mehrfachsteckdosen erhalten ihre Objektgesamtleistung in Watt;
-- Export referenziert eine bekannte Projektrevision.
-
-### Phase 14.5 – Folgeimport und Konflikte
-
-Ziel:
-
-- additions, changes, missing objects and conflicts;
-- Einzel- und Sammelentscheidungen.
-
-Abnahme:
-
-- neue Objekte werden erkannt;
-- Raumänderungen werden konfliktbehaftet angezeigt;
-- fehlende Objekte werden nicht automatisch entfernt;
-- lokale Werte werden nicht automatisch überschrieben;
-- bestätigte Änderungen sind ein atomarer Undo-Schritt;
-- unveränderte Objekte erzeugen keine unnötigen Domainänderungen.
-
-### Phase 14.6 – Snapshot, Transfer und Härtung
-
-Ziel:
-
-- vollständige Projektportabilität;
-- Performance und End-to-End-Tests.
-
-Abnahme:
-
-- Snapshot/Restore erhält sämtliche externe Links und Exportgrundlagen;
-- Projektduplikat remapped interne UUIDs und behält `IfcGUIDs`;
-- Undo/Redo funktioniert nach Reload;
-- Referenz-CSV durchläuft Erstimport, Row-Zuordnung, Export, Folgeimport und Restore;
-- vollständige Test- und Build-Suite läuft erfolgreich.
-
-## 24. End-to-End-Abnahmeszenarien
-
-### Szenario A – Gemischte Steckdosen
-
-Aus Revit:
-
-```text
-Raum 01/101
-- 2 Doppelsteckdosen, jeweils Menge 2
-- 2 Einzelsteckdosen, jeweils Menge 1
-- gleicher CAx-Auswahlkenner
-```
-
-Erwartung:
-
-- 4 externe Objekte;
-- wirksame Menge 6;
-- Nutzer zieht alle Objekte auf eine neue Row;
-- Row zeigt `6 × Steckdose`;
-- alle vier CSV-Zeilen erhalten denselben Stromkreis;
-- Doppelsteckdosen erhalten jeweils `2 × powerPerUnit` als Objektleistung;
-- Einzelsteckdosen erhalten jeweils `1 × powerPerUnit`.
-
-### Szenario B – Gleiches ProjectDevice in mehreren Räumen
-
-Aus Revit:
-
-- gleicher Leuchtentyp in drei Technikräumen.
-
-Erwartung:
-
-- Nutzer wählt alle Leuchten raumübergreifend;
-- erstellt ein neues, aus Revit-Werten vorausgefülltes ProjectDevice;
-- alle Objekte werden damit verknüpft;
-- es wird noch keine CircuitDeviceRow erzeugt;
-- später entstehen je Raum getrennte Rows, sofern die Objekte verschiedenen Räumen zugeordnet werden.
-
-### Szenario C – Raumübergreifender Putzsteckdosenstromkreis
-
-- mehrere Räume mit jeweils wenigen Putzsteckdosen;
-- Nutzer ordnet sie manuell demselben Circuit zu;
-- pro Raum entsteht eine getrennte Row;
-- alle Objekte erhalten dieselbe Stromkreiskennzeichnung.
-
-### Szenario D – Folgeimport mit Raumänderung
-
-- bekannte `IfcGUID`;
-- Revit-Raumnummer ist geändert.
-
-Erwartung:
-
-- Objekt wird nicht neu angelegt;
-- Raumänderung wird als Konflikt angezeigt;
-- bestehende interne Raum-, Verteilungs- und Stromkreiszuordnung bleibt unverändert;
-- Nutzer kann die Änderung einzeln oder gesammelt übernehmen.
-
-### Szenario E – Fehlendes Objekt
-
-- eine zuvor bekannte `IfcGUID` fehlt im vollständigen Folgeimport.
-
-Erwartung:
-
-- Objekt wird als fehlend markiert;
-- Row-Menge und Leistung bleiben zunächst unverändert;
-- erst bestätigte Löschung entfernt Link und Mengenanteil;
-- Circuit bleibt auch bei leerer Row beziehungsweise nach Row-Entfernung bestehen;
-- BMK wird nicht automatisch wiederverwendet.
-
-### Szenario F – Bestehende Stromkreiskennzeichnung beim Erstimport
-
-- Revit-Zeile enthält bereits `UV_AV_01-2F3`.
-
-Erwartung:
-
-- Wizard zeigt den Wert;
-- Nutzer kann Quellwert behalten, Zuordnung übernehmen oder ignorieren;
-- keine Option wird automatisch gewählt;
-- unpassende Verteilung oder fehlender Circuit erzeugt Konflikt beziehungsweise bewusste Anlageentscheidung.
-
-### Szenario G – CSV-Passthrough
-
-- Titelzeile;
-- Kopfzeile in Zeile 2;
-- Leerzeile;
-- Objektzeilen;
-- Summenzeile ohne `IfcGUID`.
-
-Erwartung:
-
-- nur Objektzeilen erzeugen externe Objekte;
-- Summenzeile erzeugt keine Fehlermeldung;
-- Rückexport enthält alle Zeilen an derselben Position.
-
-## 25. Noch offene, phasengebundene Entscheidungen
-
-Diese Punkte blockieren die Erstellung dieser Spezifikation nicht.
-
-### Vor Phase 14.2 zu entscheiden
-
-- konkrete Benennung der neuen Domainobjekte und Tabellen;
-- ob Importentwürfe vor der endgültigen Übernahme serverseitig gespeichert werden;
-- genaue Versionierung der Mappingkonfiguration;
-- genaue Speicherung der Original-CSV: vollständige Rohdatei, logische Zellmatrix oder Kombination.
-
-### Vor Phase 14.3 zu entscheiden
-
-- visuelle Position des Objekt-Drawers;
-- Verhalten einer Mehrfachauswahl mit widersprüchlichen Planungswerten;
-- Warnungsdialog bei fachlich unpassender Row;
-- Verhalten, wenn eine Row manuelle Mengenanteile und externe Objekte kombiniert;
-- genaue UI für das Lösen einer einzelnen externen Objektverknüpfung aus einer aggregierten Row.
-
-### Vor Phase 14.4 zu entscheiden
-
-- exaktes Revit-Zahlenformat für Dezimalwerte;
-- genaue Formatierung von Wattwerten, zum Beispiel `1000 W` oder `1000`;
-- Umgang mit Objekten ohne Stromkreis beim Rückexport: leeres Feld oder unveränderter Quellwert;
-- Dateinamenschema der Rückgabe.
-
-### Spätere Ausbaustufen
-
-- automatische raumbezogene Stromkreisvorschläge;
-- projektübergreifend wiederverwendbare Mappingprofile;
-- Teilmodelle und mehrere externe Quellen;
-- Dynamo/API/JSON-Transportadapter (nicht vorgesehen, siehe Abschnitt 1);
-- Rollen und Berechtigungen;
-- Hintergrundjobs;
-- PostgreSQL.
-
-## 26. Arbeitsweise für Codex
-
-Vor jeder Phase:
-
-1. relevante bestehende Module auditieren;
-2. angeben, was erhalten, erweitert oder ersetzt wird;
-3. betroffene Commands, Snapshots und Transferformate nennen;
-4. Migration und Rückwärtsverträglichkeit erläutern;
-5. fokussierte Tests festlegen.
-
-Während der Implementierung:
-
-- kleine reviewbare Arbeitspakete;
-- keine fachlichen Writes außerhalb der Command-Grenze;
-- keine automatische BMK-Änderung;
-- keine stillen Revit- oder ProjectDevice-Synchronisationen;
-- keine ungefragte PostgreSQL- oder Dynamo-Implementierung;
-- keine Kopplung von Domainlogik an CSV, React oder SQLite.
-
-Nach jedem Arbeitspaket:
-
-- fokussierte Tests;
-- `npm test`;
-- `npm run build:api`;
-- `npm run build:web`;
-- `npm run typecheck:scripts`;
-- `npx tsc --noEmit -p tsconfig.next.json`;
-- Dokumentation des neuen unterstützten Laufzeitpfads aktualisieren.
+Der historische Inhalt bleibt im Git-Verlauf bis einschließlich Commit
+`ae318a5` erhalten. Er darf nicht mehr als Implementierungsanweisung oder
+Statusquelle verwendet werden.
diff --git a/docs/spec/revit-csv-phase-14-audit-and-plan.md b/docs/spec/revit-csv-phase-14-audit-and-plan.md
index a4c21e4..2d116b2 100644
--- a/docs/spec/revit-csv-phase-14-audit-and-plan.md
+++ b/docs/spec/revit-csv-phase-14-audit-and-plan.md
@@ -1,406 +1,8 @@
-# Phase 14: Audit- und Implementierungsplan für die Revit-CSV-Anbindung
+# Abgelöst: alter Phase-14-CSV-Plan
 
-## Status
+Die Phasen 14.0–14.6 und ihre Erledigt-Markierungen sind abgelöst. Für die
+Umstellung auf Linear-Excel gelten der [R0–R10-Plan](revit-excel-phase-14-plan.md)
+und die [neuen Anforderungen](revit-excel-integration-requirements.md).
 
-**Zurückgestellt:** Die weitere Revit-Arbeit wird später angegangen, dann
-über den CSV-Export/-Import des Linear-Plugins in Revit statt über Dynamo.
-Details: [Revit-CSV-Anforderungen, Abschnitt 1](revit-csv-integration-requirements.md).
-
-Phase 14.0 ist abgeschlossen und freigegeben. Dieses Dokument beschreibt den
-gegen den aktuellen Code geprüften Zielzuschnitt. Phase 14.1 ist abgeschlossen.
-Phase 14.2 hat mit den externen Domänenverträgen, Identitätsregeln und dem
-additiven Persistenzschema begonnen; eine bestätigte Importübernahme existiert
-noch nicht.
-
-Fachliche Quelle bleibt
-[Revit-CSV-Integration – Anforderungen und Implementierungsanweisung](revit-csv-integration-requirements.md).
-Dieses Dokument konkretisiert dafür Namen, Modulgrenzen, Persistenz und die
-Reihenfolge kleiner Arbeitspakete.
-
-## Ergebnis des Bestandsaudits
-
-### Beibehalten
-
-- Das Circuit-First-Modell bleibt unverändert: Ein `Circuit` besitzt null bis
-  viele `CircuitDeviceRow`-Datensätze.
-- `ProjectDevice` bleibt die kanonische projektweite Vorlage. Ein Import darf
-  diese Datensätze weder erzeugen noch ändern, solange der Nutzer dies nicht
-  ausdrücklich bestätigt.
-- `CircuitDeviceRow.linkedProjectDeviceId` bleibt die optionale Verbindung
-  zwischen einer Gerätezeile und genau einer Projektgerätevorlage.
-- Die bestehenden getrennten Drag-and-drop-Pfade für Projektgeräte,
-  Gerätezeilen und Stromkreise bleiben bestehen. Externe Objekte erhalten einen
-  vierten, fachlich eigenen Pfad.
-- Alle bestätigten Änderungen verwenden typisierte Commands mit
-  `expectedRevision`, vollständiger Gegenrichtung und
-  `project-command-transaction.persistence.ts` als gemeinsamer
-  Transaktionsgrenze.
-- Snapshot-Erfassung, Restore und Projektduplikat bleiben explizite Adapter mit
-  fester Fremdschlüsselreihenfolge und UUID-Remapping.
-- SQLite und die heutige Server-Komposition bleiben der einzige unterstützte
-  Laufzeitadapter.
-
-### Erweitern oder gezielt refaktorieren
-
-- `ProjectStateSnapshot` und der portable Projekttransfer werden additiv um den
-  bestätigten externen Projektzustand erweitert. Bereits veröffentlichte
-  Snapshot-Versionen werden nicht verändert.
-- Der Command-Dispatcher erhält schmale Stores für externe Konfiguration,
-  Importübernahme, Objektplanung und Row-Zuordnung. Controller erhalten keine
-  konkreten SQLite-Abhängigkeiten.
-- Der Stromkreislisteneditor erhält später einen separaten Drawer für
-  unzugeordnete externe Objekte. Die bestehende Projektgeräteauswahl wird nicht
-  dafür zweckentfremdet.
-- Vor der ersten externen Row-Zuordnung wird die Mengenhoheit einer
-  `CircuitDeviceRow` explizit gemacht; Details stehen unter „Mengenmodell“.
-
-### Hinzufügen
-
-- verlustarmer CSV-Transportadapter außerhalb von React und Circuit-Domain;
-- projektweite, versionierte Revit-CSV-Konfiguration;
-- eine zunächst implizite externe Modellquelle je Projekt;
-- Importbatches einschließlich Originaltransport und akzeptiertem
-  Konfigurationsstand;
-- persistente externe Objekte mit `IfcGUID`, getrennten Quell- und
-  Planungswerten und einzelnem Lebenszyklus;
-- Quellraum-Mappings auf interne Räume und Standardverteilungen;
-- explizite Verknüpfungen zu `ProjectDevice`, `CircuitDeviceRow` und optionaler
-  abweichender Verteilung;
-- Vorschau-, Konflikt- und Exportprojektionen als reine Anwendungsservices;
-- fokussierte Parser-, Command-, Transaktions-, Snapshot-, Transfer- und
-  End-to-End-Tests.
-
-### Entfernen
-
-Es existiert kein unterstützter Revit-Laufzeitpfad. Deshalb wird in Phase 14
-kein bestehender Fachpfad entfernt und keine Legacy-Kompatibilität eingeführt.
-
-## Vorgeschlagenes Domänenmodell
-
-Die Namen sind ab Phase 14.1 verbindliche Arbeitsnamen. Tabellen verwenden die
-jeweilige englische Pluralform in `snake_case`.
-
-### `ExternalModelSource`
-
-- stabile interne UUID;
-- `projectId`;
-- technischer Name und Quelltyp `revit_csv`;
-- der zuletzt bestätigte Importbatch wird aus der geordneten Batchhistorie
-  abgeleitet und nicht als redundanter Zeiger gespeichert.
-
-In der ersten Ausbaustufe wird genau eine Quelle je Projekt automatisch
-angelegt. Es gibt bewusst keine sichtbare Mehrquellenverwaltung. Die
-Eindeutigkeit eines externen Objekts ist trotzdem von Anfang an
-`(sourceId, ifcGuid)`.
-
-### `ExternalCsvConfiguration`
-
-- stabile UUID und `projectId` mit genau einer aktiven Konfiguration;
-- Konfigurationsschema-Version;
-- CSV-Dialekt: Encoding, BOM, Trennzeichen, Zeilenende, Quote-Zeichen,
-  Dezimalformat und Kopfzeilenerkennung;
-- exakte Spaltenzuordnung;
-- geordnete, exakte Familie-und-Typ-Regeln;
-- monotoner Konfigurationsstand.
-
-Eine Änderung ersetzt den vollständigen erwarteten Konfigurationssnapshot in
-einem Command. Jeder bestätigte Importbatch speichert zusätzlich den dabei
-verwendeten Konfigurationssnapshot. Damit bleiben ältere Importe erklärbar,
-ohne eine zweite veränderbare Historientabelle einzuführen.
-
-### `ExternalImportBatch`
-
-- stabile UUID, `projectId`, `sourceId`, Importart und Zeitstempel;
-- Dateiname, SHA-256 und zugehörige Projektrevision;
-- verwendete monotone Konfigurationsversion und vollständiger
-  Konfigurationssnapshot;
-- Originaldatei als Bytes;
-- verlustarme logische Zellmatrix mit Zeilenklassen und Dialektmetadaten.
-
-Die Kombination aus Originalbytes und Matrix ist bewusst gewählt: Die Bytes
-belegen den unveränderten Eingang, die Matrix erlaubt einen gezielten
-Rückexport einzelner gemappter Objektzellen, ohne unbekannte Spalten,
-Titelzeilen, Leerzeilen oder Summenzeilen neu zu interpretieren.
-
-### `ExternalRoomMapping`
-
-- stabile UUID, `sourceId` und normalisierter Quellraumschlüssel;
-- Quellgeschoss-, Raumnummer- und Raumname-Snapshot;
-- optionales `roomId`;
-- optionale `defaultDistributionBoardId`.
-
-Das Mapping bleibt Teil der optionalen externen Integration. Dadurch erhält
-das allgemeine Raummodell keine Revit-spezifische Pflichtbeziehung.
-
-### `ExternalModelObject`
-
-- stabile interne UUID, `projectId`, `sourceId` und unveränderte `ifcGuid`;
-- letzter gesehener und letzter akzeptierter Importbatch;
-- akzeptierte Quellwerte getrennt als strukturierter Snapshot;
-- lokale Planungswerte für Anzeigename, Kategorie, Anschlussart, wirksame
-  Menge, Leistung je Einheit, Gleichzeitigkeitsfaktor, `cosPhi`, Kostengruppe
-  und Bemerkung;
-- explizite Override-Metadaten;
-- optionales `externalRoomMappingId`;
-- optionale abweichende `distributionBoardId`;
-- optionales `linkedProjectDeviceId`;
-- optionales `circuitDeviceRowId`;
-- Anwesenheitsstatus für bestätigte fehlende Objekte.
-
-Die n:1-Beziehung entsteht durch `circuitDeviceRowId` am Einzelobjekt: Viele
-einzeln nachverfolgbare IFC-Objekte dürfen genau einer Gerätezeile zugeordnet
-sein. Eine Mehrfachsteckdose bleibt ein einzelnes Objekt und trägt ihre
-wirksame Menge größer eins.
-
-Konflikte werden soweit möglich aus akzeptiertem Quellstand, neuem
-Vorschaustand und lokalen Overrides berechnet. Nur ein vom Nutzer bestätigter
-Anwesenheits- oder Planungszustand wird persistiert.
-
-## Mengenmodell der Gerätezeile
-
-Die heutige `CircuitDeviceRow.quantity` unterscheidet nicht zwischen manueller
-Menge und verknüpften IFC-Objekten. Ohne Erweiterung könnte das Lösen eines
-Objekts manuelle Mengen löschen oder doppelt zählen.
-
-Vor Phase 14.3 wird deshalb `manualQuantity` ergänzt:
-
-```text
-quantity = manualQuantity
-         + Summe(effectiveQuantity aller verknüpften ExternalModelObjects)
-```
-
-- Bei der Migration erhält jede bestehende Row
-  `manualQuantity = quantity`; ihr Ergebnis bleibt unverändert.
-- Eine ausschließlich aus externen Objekten erstellte Row startet mit
-  `manualQuantity = 0`.
-- `quantity` bleibt zunächst der materialisierte Gesamtwert für bestehende
-  Berechnungen, Filter und Exporte und wird im selben Command aktualisiert.
-- Ein externes Objekt wird nie geteilt und kann höchstens einer Row zugeordnet
-  sein.
-- Objekte dürfen nur aggregiert werden, wenn die rowbestimmenden lokalen Werte
-  übereinstimmen. Widersprüchliche Werte werden in der ersten Ausbaustufe nicht
-  automatisch vereinheitlicht, sondern benötigen getrennte Rows oder eine
-  ausdrückliche Nutzerentscheidung.
-- Eine bestehende Row mit manueller Menge darf externe Objekte aufnehmen; beim
-  Lösen bleibt der manuelle Anteil erhalten.
-
-Für die UI vor Phase 14.3 bleibt noch festzulegen, ob eine nach dem Lösen leere
-Row stehen bleibt oder nach gesonderter Bestätigung gelöscht wird. Ein stiller
-Row-Lebenszyklus ist ausgeschlossen.
-
-## Command-Schnittstellen
-
-Alle Payloads tragen `schemaVersion: 1`, vollständige erwartete und gewünschte
-Snapshots und werden mit der aktuellen Projektrevision geplant. Große
-Importcommands dürfen umfangreich sein; sie müssen für Redo deterministisch
-bleiben und dürfen spätere Quellstände nicht erneut auswerten.
-
-- `external-csv-configuration.update`: vollständige projektweite
-  Konfiguration ändern.
-- `external-import.apply-initial`: Quelle, Batch, Raum-Mappings, externe
-  Objekte und bestätigte Links atomar einfügen.
-- `external-import.apply-follow-up`: neuen Batch und die vollständigen
-  erwarteten/gewünschten Änderungen bestehender, neuer und fehlender Objekte
-  atomar übernehmen.
-- `external-model-object.update-planning`: lokale Werte und Overrides eines
-  oder mehrerer Objekte ändern.
-- `external-model-object.update-project-device-link`: ProjectDevice-Links
-  explizit setzen oder lösen, ohne das ProjectDevice zu verändern.
-- `external-object.update-row-assignment`: Ein oder mehrere Objekte einer
-  bestehenden Row zuweisen, zwischen bestehenden Rows verschieben oder lösen
-  und alle betroffenen materialisierten Mengen atomar aktualisieren.
-- `external-object.assign-to-new-row`: stabile neue Row einfügen,
-  Objekte verknüpfen und gegebenenfalls den Reserve-Status aktualisieren.
-- `external-object.assign-to-new-circuit`: stabilen Circuit samt Schutz,
-  Row und Objektlinks in einem Schritt einfügen. Das geplante BMK wird im
-  Command gespeichert und bei Redo nicht neu berechnet.
-- `external-model-object.delete-missing`: nur ausdrücklich bestätigte,
-  weiterhin unveränderte fehlende Objekte löschen.
-
-Die Erzeugung eines neuen `ProjectDevice` verwendet weiterhin den vorhandenen
-`project-device.insert`-Command. Revit-Werte füllen lediglich das sichtbare
-Formular vor; erst dessen Bestätigung erzeugt die Vorlage. CSV-Vorschau und
-Rückexport sind reine Leseoperationen. Append-only Exportnachweise verändern
-keine Projektrevision und laufen über einen eigenen Audit-Store.
-
-## Snapshot-, Transfer- und Migrationsfolgen
-
-- Phase 14.1 führt Migration `0002` für die Konfiguration ein und erhöht das
-  Project-State-Snapshot-Schema additiv von 2 auf 3. Der Upgrader von Version 2
-  ergänzt `externalCsvConfiguration = null`.
-- Phase 14.2 führt Migration `0003` für Quelle, Batches, Raum-Mappings und
-  Objekte ein und erhöht das Snapshot-Schema von 3 auf 4. Der Upgrader ergänzt
-  leere externe Collections.
-- Phase 14.3 führt die additive Row-Spalte `manual_quantity` ein. Bestehende
-  Werte werden einmalig aus `quantity` übernommen.
-- Snapshot-Capture und Restore erhalten Konfiguration, Quelle, bestätigte
-  Batches, Raum-Mappings und Objekte in expliziter FK-Reihenfolge.
-- Beim Projektduplikat werden alle neuen internen UUIDs und internen Links
-  remappt. `IfcGUID`, Quellwerte, Transportmatrix und unbekannte CSV-Inhalte
-  bleiben unverändert.
-- Der Transfer-Envelope kann Version 1 bleiben; die enthaltene
-  Project-State-Schema-Version wird additiv erhöht.
-- Vorhandene Migrationen und Snapshot-Upgrader werden nicht editiert.
-
-## Implementierungsfolge
-
-### 14.1 – CSV-Konfiguration und reine Vorschau
-
-1. Transport-Domainverträge, Dialekt- und Mappingvalidatoren sowie kleine
-   synthetische Fixtures ergänzen. **Erledigt.**
-2. Zustandsfreien Parser und Serializer mit Round-trip-Tests für UTF-8-BOM,
-   CRLF, Semikolon, vollständige Quotierung, Kopfzeile in Zeile 2 sowie
-   Titel-, Leer-, Objekt- und Passthrough-Zeilen implementieren. **Erledigt für
-   synthetische Testdaten; die Referenzdatei steht noch aus.**
-3. Konfiguration über Migration, Snapshot v3, Transfer und den Command
-   `external-csv-configuration.update` persistieren. **Erledigt.**
-4. Vorschau-Endpunkt und deutschen Projekt-Wizard ergänzen. **Erledigt:**
-   Konfigurations-Read/Write- und zustandsfreier Vorschau-Endpunkt sowie das
-   deutsche Konfigurations-/Vorschaumodal. Der Server speichert keinen Entwurf: Bei
-   Bestätigung wird die Datei erneut übertragen, erneut geparst und ihr Hash
-   gegen die Vorschau geprüft.
-
-**Phase 14.1 ist damit technisch abgeschlossen.** Die fachliche GUI-Abnahme
-erfolgt vor Beginn der persistenten externen Objekte aus Phase 14.2.
-
-Abnahme: fokussierte Tests, vollständige Tests und alle vorgeschriebenen
-Build-/Typecheck-Schritte. Die lokal bereitgestellte Referenz-CSV wird mit
-`npm run revit:verify-reference` auf 897 Objektzeilen, 211 nichtleere
-Passthrough-Summenzeilen und einen bytegleichen Round-trip geprüft. Da die
-Referenzdatei reale Modelldaten enthalten kann, wird sie nicht automatisch in
-einen Commit aufgenommen.
-
-### 14.2 – Persistente Objekte und Erstimport
-
-1. Schema, Repositories und reine Identitäts-/Matchingregeln ergänzen.
-   **Erledigt:** Migration `0003`, vollständiger externer Read-State sowie
-   exaktes IFCGUID-, Raum- und Familie-und-Typ-Matching sind vorhanden. Es gibt
-   weiterhin keinen Import-Write außerhalb eines Commands.
-2. Snapshot v4, Restore und Projektduplikat samt UUID-Remapping ergänzen.
-   **Erledigt:** Version 3 wird mit leerem externem Zustand hochgestuft;
-   Capture, Restore, Undo/Redo und beide Transfermodi erhalten Originalbytes,
-   Matrix und sämtliche internen Links. Duplikate remappen alle internen UUIDs,
-   lassen IFCGUID und Quelltransport jedoch unverändert.
-3. Erstimport-Command mit echten SQLite-Commit-/Rollback-Tests ergänzen.
-   **Erledigt:** `external-import.apply-initial` wechselt ausschließlich
-   zwischen leerem und vollständig bestätigtem externem Zustand. Er prüft
-   Konfigurationsversion, Original-Hash, erneut geparste Matrix, vollständige
-   IFCGUID-Menge, Quellwerte, explizite Overrides und projektinterne Links.
-   Der Command verbietet CircuitDeviceRow-Links, ist ein atomarer Undo-Schritt
-   und verwendet für Redo dieselben UUIDs und Bytes. Migration `0004` ergänzt
-   die zuvor noch fehlende monotone Konfigurationsversion am Batch; `0003`
-   bleibt unverändert.
-4. Raum-, Verteilungs-, Klassifizierungs- und ProjectDevice-Schritte im Wizard
-   ergänzen; der Import selbst erzeugt keine CircuitDeviceRow. **Erledigt:**
-   Der zustandsfreie Planungs-Endpunkt liefert gruppierte Quellräume mit
-   exaktem Raumnummernvorschlag, Familie-und-Typ-Gruppen, Objektvorschläge,
-   Warnungszahlen sowie vorhandene Ebenen, Räume, Verteilungen und
-   ProjectDevices. Er blockiert nach einem bereits bestätigten Erstimport und
-   schreibt weder Entwurf noch Projektzustand. Der dedizierte
-   Endpunkt verlangt denselben Datei-Hash und Konfigurationsstand wie die
-   Planung, vollständige Entscheidungen für alle Quellräume und exakten
-   Familie-und-Typ-Gruppen und baut daraus serverseitig stabile UUIDs. Nicht
-   klassifizierte Familien blockieren. Raum-/Standardverteiler- und optionale
-   ProjectDevice-Links werden bestätigt, Stromkreis- und Row-Links bleiben
-   ausgeschlossen. Das breite Projektmodal zeigt Raumtreffer und Warnungen,
-   bietet die vorhandenen Raum-, Verteiler- und ProjectDevice-Kataloge an und
-   verlangt vor der atomaren Übernahme eine ausdrückliche Bestätigung. Fehlende
-   Räume und ProjectDevices lassen sich über die regulären, vorausgefüllten
-   Projektformulare anlegen und werden danach unmittelbar ausgewählt. Diese
-   Kataloganlagen bleiben eigenständige, rückgängig machbare Projektrevisionen.
-
-Vor Beginn werden die oben vorgeschlagenen Namen, die erneute Dateiübertragung
-statt serverseitiger Entwürfe, die Konfigurationsversionierung und die
-Kombination aus Originalbytes und Matrix als Entscheidungen bestätigt.
-
-### 14.3 – Editor und explizite Zuordnung
-
-1. `manualQuantity` und Mengeninvarianten migrieren und testen.
-   **Erledigt:** Migration `0005` übernimmt für jede bestehende Gerätezeile
-   `manualQuantity = quantity`. Neue normale Zeilen und Mengenänderungen führen
-   beide Werte gemeinsam; Snapshot/Transfer v5 erhält den Anteil und stuft v4
-   verlustfrei hoch. Die reine Mengenregel validiert den materialisierten Wert
-   als manuellen Anteil plus Summe der unteilbaren externen Objektmengen.
-2. Commands für vorhandene Row, neue Row, neuen Circuit und Lösen ergänzen.
-   **Teilweise erledigt:** `external-object.update-row-assignment` deckt
-   Zuweisung zu vorhandenen Rows, Verschieben zwischen vorhandenen Rows und
-   Lösen ab. Der Command prüft Projekt, Verteilung, Gruppenkategorie, Raum,
-   Selektionskennzeichen und Planungswerte, verlangt für bestätigbare
-   Planungsabweichungen eine explizite Objektliste und aktualisiert Links und
-   Gesamtmengen in einer SQLite-Transaktion. Seine exakte Gegenrichtung ist
-   dauerhaft Undo/Redo-fähig. Beim Lösen bleibt die Row mit ihrem manuellen
-   Mengenanteil bestehen. `external-object.assign-to-new-row` ergänzt die
-   Zuordnung ungebundener Objekte als neue Row in einem vorhandenen Circuit.
-   Diese Row erhält eine stabile ID und `manualQuantity = 0`; ihr historischer
-   Gegenbefehl entfernt sie nur, solange Row und Objektlinks vollständig
-   unverändert sind. Ein direktes Löschen über diesen internen Gegenbefehl ist
-   als Nutzeraktion gesperrt. `external-object.assign-to-new-circuit` schließt
-   den dritten Zielpfad: Ein serverseitig vorgeplanter Circuit mit festem BMK,
-   Standardschutz und genau einer externen Row wird gemeinsam mit den
-   Objektlinks eingefügt. Seine Historiengegenrichtung prüft den vollständigen
-   Circuit-Snapshot und die exakte Linkmenge, bevor sie den Teilbaum entfernt.
-   BMK und UUIDs bleiben bei Redo unverändert. Damit ist die persistente
-   Command-Grundlage dieses Schritts abgeschlossen; API-Planung und UI folgen.
-3. Verteilungsbezogenen Drawer, Filter und Vorschau der Mengenwirkung ergänzen.
-   **Begonnen:** Die reine Read-Projektion und der projekt-/listenbezogene
-   GET-Endpunkt liefern ausschließlich Objekte des zugehörigen Verteilers,
-   unzugeordnete Objekte zuerst, einschließlich Quellraum, Selektionsmarker,
-   Planungswerten und aktuellem Row-Link. API-Client und DTOs sind vorhanden;
-   Drawer, Filter und Mengenwirkung folgen.
-4. Einzel- und Mehrfach-Drag-and-drop samt Warnungen, Undo/Redo und Reload
-   testen.
-
-Vor Beginn werden Drawerposition, Verhalten widersprüchlicher Mehrfachauswahl,
-Warnungsdialoge und der Lebenszyklus leerer Rows festgelegt.
-
-### 14.4 – Strukturtreuer Rückexport
-
-1. Exportprojektion gegen eine bekannte Projektrevision ergänzen.
-2. Nur gemappte Objektzellen in einer Kopie der akzeptierten Matrix ersetzen.
-3. Dialekt, Reihenfolge, unbekannte Zellen und Passthrough-Zeilen erhalten.
-4. Download und append-only Exportnachweis ergänzen.
-
-Zahlenformat, leere Stromkreiswerte und Dateiname werden vorher fachlich
-festgelegt.
-
-### 14.5 – Folgeimport und Konflikte
-
-1. Deterministischen Diff nach `(sourceId, ifcGuid)` ergänzen.
-2. Neu, geändert, unverändert, fehlend und konfliktbehaftet projizieren.
-3. Einzel- und Sammelentscheidungen im Wizard ergänzen.
-4. Akzeptierten Diff als einen atomaren Command mit vollständigem Undo/Redo
-   übernehmen.
-
-### 14.6 – Härtung und End-to-End-Abnahme
-
-1. Alle Szenarien A bis G der verbindlichen Spezifikation automatisieren.
-2. Referenzdatei über Vorschau, Erstimport, Zuordnung, Export, Folgeimport,
-   Snapshot/Restore und Projektduplikat prüfen.
-3. Abfrageindizes und große Payloads mit mehreren tausend Objekten messen.
-4. Architektur-, API-, Betriebs- und Nutzerdokumentation auf den tatsächlich
-   ausgelieferten Stand nachziehen.
-
-## Risiken und Schutzmaßnahmen
-
-- **Mengenverlust:** `manualQuantity` trennt manuelle und externe Anteile;
-  Commands ändern Links und materialisierte Menge gemeinsam.
-- **Stilles Überschreiben:** Quellwerte, lokale Werte und Overrides sind
-  getrennt; jede Übernahme benötigt eine Nutzerentscheidung.
-- **ProjectDevice-Verfälschung:** Links ändern niemals die kanonische Vorlage;
-  deren bestehende Commands bleiben alleinige Schreibgrenze.
-- **Nicht reproduzierbarer Export:** Jeder Batch hält Originalbytes, Matrix,
-  Dialekt, Konfiguration, Hash und Projektrevision.
-- **Sehr große Undo-Payloads:** Importcommands speichern vollständige
-  erwartete/Zielzustände. Größe und Transaktionsdauer werden in 14.2 gemessen,
-  nicht durch indirekte oder nachträglich neu berechnete Payloads optimiert.
-- **BMK-Drift:** Neue BMKs werden einmal bei der Planung berechnet und im
-  Command gespeichert; Import, Sortierung und Redo nummerieren nie implizit.
-- **Vertrauliche Referenzdaten:** Der Referenzprüfer läuft lokal gegen die
-  bereitgestellte CSV. Vor einer Aufnahme dieser Datei in Git ist gesondert zu
-  klären, ob sie ausreichend anonymisiert und zur Weitergabe freigegeben ist.
-
-## Freigabepunkt
-
-Mit der Freigabe dieses Audits beginnt Arbeitspaket 14.1.1: reine
-Transportverträge, Validatoren und synthetische CSV-Fixtures. Dieses Paket
-ändert weder Datenbank noch GUI und führt keine Projektschreibvorgänge aus.
+Der historische Inhalt bleibt im Git-Verlauf bis einschließlich Commit
+`ae318a5` erhalten und darf nicht fortgeschrieben werden.
diff --git a/docs/spec/revit-excel-integration-requirements.md b/docs/spec/revit-excel-integration-requirements.md
new file mode 100644
index 0000000..ff580ec
--- /dev/null
+++ b/docs/spec/revit-excel-integration-requirements.md
@@ -0,0 +1,463 @@
+# Revit-Integration über Linear-Excel – verbindliche Anforderungen
+
+Stand: 29.09.2026. Dieses Dokument ist die fachliche und technische
+Arbeitsgrundlage für die neue Phase 14. Es ersetzt die frühere CSV-/IfcGUID-
+Spezifikation. Der Umsetzungsstand steht im
+[R0–R10-Plan](revit-excel-phase-14-plan.md); der geprüfte Ausgangszustand im
+[R0-Audit](revit-excel-r0-audit.md).
+
+## 1. Ziel und Grenzen
+
+Der Austausch mit Revit erfolgt ausschließlich über den XLSX-Export/-Import
+des Linear-Plugins. Eine vollständige Revit-Bauteilliste wird importiert, in
+Leistungsbilanz geplant und mit gleichem Tabellenaufbau an Linear
+zurückgegeben. Linear ordnet enthaltene Zeilen anhand der Worksharing-ID zu.
+
+Nicht Teil dieser Phase sind Dynamo, Revit-API, JSON-Transport, automatische
+Stromkreisbildung, Übernahme vorhandener Revit-Stromkreiswerte,
+Teilimporte, mehrere Modellquellen, PostgreSQL und neue Rollen/Rechte.
+
+Die Integration bleibt optional. Manuelle Projekte, Räume, ProjectDevices,
+Stromkreise und Gerätezeilen funktionieren ohne externes Modell. Der
+Circuit-First-Aufbau, stabile interne UUIDs und BMKs, ausdrückliche
+Neunummerierung sowie die gemeinsame Project-Command-Transaktionsgrenze
+bleiben unverändert.
+
+## 2. Verbindliche fachliche Regeln
+
+- Import erzeugt keine `CircuitDeviceRow`, keinen `Circuit` und kein BMK.
+- Quellwerte, lokale Planungswerte und Overrides bleiben getrennt.
+- Ein Folgeimport überschreibt keine lokale Planung still.
+- Fehlende Objekte werden markiert und erst nach ausdrücklicher Bestätigung
+  entfernt.
+- Mehrfachsteckdosen sind unteilbare externe Objekte. Ihre wirksame Menge kann
+  größer als eins sein.
+- Die Row-Menge ist
+  `manualQuantity + Summe(effectiveQuantity der verknüpften Objekte)`.
+- Nach einer Row-Zuordnung ist die `CircuitDeviceRow` die Planungsebene für
+  alle verknüpften Objekte.
+- Bestehende ProjectDevices bleiben kanonische Vorlagen und werden durch
+  Importe nie verändert.
+- Sortieren, Filtern, Importieren, Zuordnen und Verschieben nummeriert keine
+  Stromkreise automatisch neu.
+
+## 3. Linear-XLSX-Profil
+
+Die lokale Referenzdatei `docs/spec/kbp-Stromkreis.xlsx` enthält vertrauliche
+Projektdaten. Sie wird nicht committed und nicht in Tests eingebettet. Tests
+erzeugen synthetische Workbooks. Der lokale Referenzprüfer erhält den Pfad als
+Argument.
+
+Beobachtetes Profil:
+
+- genau ein Arbeitsblatt; Blattname nach Excel-Regel maximal 31 Zeichen;
+- Kopfzeile in Zeile 1, Zeile 2 leer, Daten ab Zeile 3, erste Datenspalte A;
+- Spalte A `Worksharing-ID` im Format `<GUID>-<8 Hex>`;
+- Parameterbindungen stehen als klassische Excel-Kommentare in den übrigen
+  Kopfzellen;
+- Zahlen sind typisierte Excel-Zahlen; importierte Werte bleiben unverändert,
+  fachlich verwendete Leistung wird auf 0,01 W projiziert;
+- Objektzeilen dürfen keinen MEP-Raum besitzen;
+- eine Schluss-/Summenzeile ohne ID kann vorkommen und wird weder importiert
+  noch zurückgegeben.
+
+Die Referenzdatei enthält 487 Objektzeilen, eindeutige Worksharing-IDs und
+keine doppelten nichtleeren IfcGUIDs bei exaktem, case-sensitivem Vergleich.
+Ihre Summenzeile steht in Spalte B (`CAx_Auswahlkenner`), während
+`Familie und Typ` leer ist.
+
+### Zeilen ohne Worksharing-ID
+
+Nur eine Zeile ohne Worksharing-ID, aber mit befülltem Feld
+`Familie und Typ`, gilt als verdächtige Objektzeile. Sie erzeugt einen Hinweis
+und wird übersprungen; sie blockiert den Import nicht. Andere Zeilen ohne ID,
+einschließlich einer nur in Spalte B befüllten Summenzeile, werden ohne Hinweis
+übersprungen. Eine Objektzeile ist für den Import eine Zeile mit nichtleerer
+Worksharing-ID.
+
+Worksharing-ID und IfcGUID werden stets exakt, ordinal und mit
+Groß-/Kleinschreibung verglichen. Es findet kein Trimmen, Normalisieren oder
+Case-Folding für die Identität statt. Eine nichtleere Worksharing-ID mit
+unerlaubten äußeren Leerzeichen oder falschem Format blockiert. Doppelte
+Worksharing-IDs blockieren. IfcGUID ist optional, kein Schlüssel und darf
+doppelt vorkommen; Duplikate erzeugen lediglich einen Hinweis.
+
+## 4. Upload und Transportadapter
+
+Der Server akzeptiert ausschließlich Dateien mit Endung `.xlsx` bis 10 MiB.
+`.xls` und `.xlsm` werden abgelehnt. Parsing findet serverseitig statt. Nach
+dem Einlesen gelten feste Zeilen-, Spalten- und Zellgrenzen, die in R2 anhand
+synthetischer Grenztests festgelegt und zentral definiert werden. Es gibt in
+dieser Phase keinen eigenen ZIP-Prüfer und keinen Parser-Worker.
+
+Der Adapter unter `src/external-model/xlsx` liest eine transportneutrale
+Zellmatrix. Eine Zelle ist `string`, `number`, `boolean` oder `empty`.
+Zusätzlich werden Blattname, Originalzeilennummer, Kopfzeilenkommentare,
+Spaltenbreiten und die für Hinweise nötigen Formelmetadaten erfasst.
+Domain-Services kennen weder ExcelJS noch XLSX, React oder SQLite.
+
+Formeln werden niemals ausgeführt. Ist ein gecachter skalarer Wert vorhanden,
+wird er verwendet und als Hinweis ausgewiesen. Fehlt er oder ist er ein
+Fehlerwert, bleibt das Feld leer; bei der Worksharing-ID oder einem anderen
+Pflichtfeld blockiert dies die betreffende Objektzeile beziehungsweise den
+Import.
+
+Genau eine gepflegte Bibliothek wird ergänzt. Vorgesehen ist `exceljs`, sofern
+R2 die Node-24-Verträglichkeit und den Roundtrip von Kopfkommentaren,
+Blattname, Spaltenbreiten, Formaten und Zelltypen bestätigt.
+
+## 5. Projektkonfiguration
+
+Die Konfiguration ist projektweit, revisionssicher und besitzt keine eigene
+Versionszählung. Jeder Plan und jedes Apply tragen `expectedRevision`.
+Da die Projektrevision auch bei Undo/Redo strikt steigt, wird ein alter Plan
+automatisch ungültig. Jeder Importbatch speichert eine vollständige Kopie der
+beim Import verwendeten Konfiguration.
+
+Das Einstellungsmodal auf der Revit-Seite erkennt aus einer zustandslos
+hochgeladenen Musterdatei Kopfzeile, erste Datenzeile und erste Datenspalte.
+Diese Werte bleiben editierbar; Standard ist 1 / 3 / A. Es gibt nur ein Feld
+für die Identitätsspalte: `columns.worksharingId`. Ein separates
+`layout.idColumn` existiert nicht.
+
+Zielvertrag:
+
+```ts
+interface ExternalModelConfiguration {
+  schemaVersion: 1;
+  layout: {
+    headerRow: number;
+    firstDataRow: number;
+    firstDataColumn: number;
+  };
+  circuitMode: "combined" | "separate";
+  columns: {
+    worksharingId: string;
+    ifcGuid: string | null;
+    roomNumber: string | null;
+    roomName: string | null;
+    familyAndType: string;
+    selectionMarker: string | null;
+    socketCount: string | null;
+    sourceRemark: string | null;
+    circuitCombined: string | null;
+    boardName: string | null;
+    circuitIdentifier: string | null;
+    designation: string | null;
+    electricalPowerW: string | null;
+    voltageV: string | null;
+    currentA: string | null;
+  };
+  deviceTypes: DeviceTypeConfiguration[];
+  familyTypeRules: FamilyTypeRule[];
+}
+```
+
+Standardzuordnung:
+
+| Schlüssel | Bedeutung | Standardspalte |
+| --- | --- | --- |
+| `worksharingId` | externe Identität, Pflicht | `Worksharing-ID` |
+| `ifcGuid` | optionale Redundanz | `IfcGUID` |
+| `roomNumber` | Raumnummer | `MEP-Raum: Nummer` |
+| `roomName` | Raumname | `MEP-Raum: Name` |
+| `familyAndType` | Familie und Typ, Pflicht | `Familie und Typ` |
+| `selectionMarker` | CAx-Auswahlkenner | `CAx_Auswahlkenner` |
+| `socketCount` | Anzahl Einzelsteckdosen | `CAX_AnzahlObjekte` |
+| `sourceRemark` | Anmerkung | `CAx_Anmerkung` |
+| `circuitCombined` | Stromkreis gesamt | `kbp_Stromkreisnummer` |
+| `boardName` | Verteiler | `kbp-E-Verteiler` |
+| `circuitIdentifier` | Stromkreis-BMK | `kbp-E-Stromkreis` |
+| `designation` | Bezeichnung | `kbp-E-Bezeichnung` |
+| `electricalPowerW` | elektrische Leistung [W] | `kbp-E-Elektrische Leistung` |
+| `voltageV` | Spannung [V] | `kbp-E-Spannung` |
+| `currentA` | Stromstärke [A] | `kbp-E-Stromstärke` |
+
+`worksharingId` und `familyAndType` sind Pflichtmappings. Im Modus
+`combined` ist `circuitCombined` für den Rückexport Pflicht; im Modus
+`separate` sind `boardName` und `circuitIdentifier` Pflicht. Fehlende optionale
+Rückgabespalten `designation`, `electricalPowerW`, `voltageV` und `currentA`
+werden mit Hinweis übersprungen und blockieren den Export nicht.
+
+Jedes interne Feld besitzt im Modal ein Dropdown aus den Kopfzellen und eine
+freie Eingabe. Exakte kbp-Standardnamen werden vorbelegt. Typ und Einheit aus
+dem Linear-Kommentar werden angezeigt. Nicht gemappte Spalten bleiben beim
+Rückexport unverändert.
+
+## 6. Gerätearten und Familie-und-Typ-Regeln
+
+Eine Geräteart besitzt stabile interne UUID, Name, Kategorie
+`lighting | single_phase | three_phase` sowie optionale Standardwerte für
+Leistung je Einheit in W, GZF, cosPhi und Kostengruppe. Jede exakte
+`Familie und Typ`-Regel verweist auf genau eine Geräteart und verwendet die
+Mengenregel `1` oder `socketCount`.
+
+Mehrere Revit-Familien dürfen auf dieselbe Geräteart zeigen. Jedes Revit-
+Objekt bleibt trotzdem einzeln über seine Worksharing-ID nachverfolgbar.
+Unbekannte Familien müssen im Importwizard zugeordnet oder über eine neue
+Geräteart klassifiziert werden; andernfalls blockiert Apply.
+
+Planungsstartwerte folgen dieser Reihenfolge:
+
+1. ausdrücklich verknüpftes ProjectDevice;
+2. Geräteart-Standard;
+3. leer.
+
+Der Anzeigename wird aus CAx-Auswahlkenner, dann Geräteartname, dann
+`Familie und Typ` vorgeschlagen. Ein fehlender GZF wird mit `1` vorbelegt,
+ohne zusätzliche Bestätigung. Standardwerte sind Startwerte, keine dauerhafte
+Synchronisierung.
+
+## 7. Persistenter externer Zustand
+
+Pro Projekt existiert genau eine implizite Revit-XLSX-Quelle. Ein externes
+Objekt besitzt eine interne UUID und ist je `(sourceId, worksharingId)`
+eindeutig. `worksharingId` ist NOT NULL; `ifcGuid` ist nullable und nicht
+eindeutig. Interne Relationen verwenden ausschließlich interne UUIDs.
+
+Gespeichert werden:
+
+- akzeptierte Quellwerte einschließlich aller Rückgabefelder;
+- lokale Planungswerte und Override-Felder;
+- Geräteart;
+- optionales Raum-Mapping, abweichender Verteiler, ProjectDevice und
+  `CircuitDeviceRow`;
+- Anwesenheitsstatus und Verweis auf den zuletzt relevanten Import;
+- effektive Menge als fachlicher Wert des unteilbaren Objekts.
+
+Der effektive Verteiler eines verknüpften Objekts ist immer der Verteiler
+seiner Row. Für ein unzugeordnetes Objekt gilt zuerst die explizite
+Objektabweichung, danach der Standardverteiler seines Raum-Mappings. Ändert
+sich der Standardverteiler eines Raums, betrifft das nur unzugeordnete
+Objekte; verknüpfte Objekte bleiben über ihre Row unverändert und die Änderung
+wird deshalb nicht gesperrt.
+
+## 8. Importbatch-Aufbewahrung, Snapshot und Transfer
+
+Der aktive Projektzustand enthält den letzten Importbatch vollständig:
+Originalbytes, klassifizierte Matrix, Dateiname, SHA-256, Zeitpunkt,
+Objektzahl, Importart, Projektrevision und Konfigurationskopie. Ältere Batches
+werden zu Metadaten reduziert: Datum, Dateiname, SHA-256 und Objektzahl.
+Sie enthalten keine Originalbytes, Matrix oder Konfigurationskopie mehr.
+
+Snapshot-Schema 10 und portabler Projekttransfer übernehmen genau diese
+Aufteilung. Beim Duplizieren werden alle internen UUIDs und Links remapped;
+Worksharing-IDs, optionale IfcGUIDs, Quellwerte und das letzte Workbook bleiben
+unverändert.
+
+Versionen 1–9 ohne externe CSV-Daten werden verlustfrei auf Version 10
+hochgestuft. Enthält ein alter Stand eine CSV-Konfiguration oder einen nicht
+leeren CSV-Zustand, wird er mit klarer deutscher Fehlermeldung abgelehnt.
+Alte CSV-History-Commands werden ebenfalls vor jedem Write abgelehnt und nie
+stillschweigend übersprungen.
+
+## 9. Erstimport
+
+Der Ablauf ist Upload → zustandslose Vorschau/Planung → erneute
+Dateiübertragung bei Apply. Apply prüft SHA-256, `expectedRevision`,
+Konfigurationskopie, Matrix und sämtliche Entscheidungen erneut. Nur Apply
+liest die Excel-Datei erneut ein.
+
+Undo und Redo lesen keine Excel-Datei und parsen keine gespeicherten Bytes.
+Sie arbeiten ausschließlich auf den im Command gespeicherten vollständigen
+Vorher-/Nachher-Zuständen. Dadurch bleiben sie nach Neustart deterministisch
+und unabhängig vom Parser.
+
+Der Wizard umfasst:
+
+1. Vorschau mit Objektzahl, übersprungenen und verdächtigen Zeilen,
+   doppelten Worksharing-IDs, doppelten IfcGUID-Hinweisen, unbekannten
+   Familien, nicht lesbaren Zahlen und Formeln;
+2. Räume anlegen oder vorhandenen Räumen/Ebenen zuordnen;
+3. Standardverteiler je Raum, Sammelzuordnung, Objektabweichungen und Objekte
+   ohne Raum;
+4. Familien exakt Gerätearten und einer Mengenregel zuordnen;
+5. optional vorhandene oder neu angelegte ProjectDevices verknüpfen;
+6. Zusammenfassung und ausdrückliche Bestätigung.
+
+Die Übernahme ist ein atomarer Command und ein Undo-Schritt. Im Import
+entstehen keine Rows. Neu angelegte Räume und ProjectDevices verwenden ihre
+vorhandenen Commands und bleiben eigene Undo-Schritte.
+
+## 10. Objektplanung und Revit-Seite
+
+Route: `/projects/:projectId/revit`, erreichbar aus der Projektnavigation.
+Der Revit-Button und das CSV-Modal auf der Projektübersicht entfallen.
+
+Die Seite besitzt:
+
+- Statuskarte mit letztem Import, Objektzahl, ohne Verteiler, ohne
+  Stromkreis, fehlend und Abweichung zu Revit;
+- Aktionen `Import`, `Rückgabe-Excel`, `Einstellungen`;
+- einklappbare Geräteart-/Familienregel-Übersicht;
+- kompakte Objekttabelle mit Suche, Spaltenfiltern, Sortierung,
+  Mehrfachauswahl und Sammelzuordnung für Verteiler, ProjectDevice und
+  Planungswerte.
+
+Die kompakte Liste wird einmal geladen, vollständig im Client gefiltert und
+sortiert und virtualisiert dargestellt. Es gibt keine Server-Pagination.
+Originalbytes, Matrix und Command-Payloads gehören nicht in dieses DTO.
+
+Vor Row-Zuordnung lassen sich Leistung je Einheit, GZF, cosPhi,
+Kostengruppe, Anzeigename und Bemerkung einzeln oder gesammelt ändern.
+Geänderte Felder werden Overrides. Nach Row-Zuordnung werden diese Werte im
+Grid an der Row bearbeitet. Beim ausdrücklichen Lösen erhält das Objekt die
+aktuellen Row-Werte als Planungswerte und entsprechende Overrides.
+
+## 11. Editor-Zuordnung und Löschen
+
+Der rechte, überlagernde Editorbereich zeigt unzugeordnete konfliktfreie
+Objekte des aktuellen Verteilers. Gruppierungsschlüssel sind interner Raum,
+Auswahlkenner, Geräteart, Kategorie, identische Planungswerte und kompatibler
+ProjectDevice-Link. Die Anzeige nennt Summe der wirksamen Mengen und Zahl der
+externen Objekte. Gruppen sind aufklappbar; Einzel- und Mehrfachauswahl sowie
+Filter bleiben möglich.
+
+Drag-and-drop:
+
+- auf vorhandene Row: genau diese Row;
+- auf Circuit: neue Row mit `manualQuantity = 0`;
+- auf freien Bereich: neuer Circuit, Schutz und Row in einem Command.
+
+Neue IDs und BMK werden einmal geplant; Redo rechnet sie nicht neu. Neue Rows
+übernehmen den bestätigten Gruppenzustand und die Summe der effektiven Mengen.
+An Rows zeigt ein Hinweis die Zahl verknüpfter Revit-Objekte; einzelne Objekte
+können ausdrücklich gelöst werden.
+
+Wird eine Row, ein Circuit oder eine Gruppe mit verknüpften Revit-Objekten
+gelöscht, zeigt die UI vor Bestätigung:
+`X Revit-Objekte werden wieder unzugeordnet`. Derselbe Löschcommand löst die
+Objekte, entfernt die Struktur und speichert alle Links in seiner Inversen.
+Undo stellt Struktur und Links exakt wieder her. Diese Löschungen werden nicht
+gesperrt.
+
+Das Löschen eines Verteilers oder Raums mit referenzierten externen Objekten
+bleibt gesperrt. Der Nutzer muss die Verknüpfungen beziehungsweise Zuordnungen
+zuvor ausdrücklich ändern. Die Regel gilt auch für Unterbaum- und History-
+Pfade.
+
+## 12. Rückgabe-Excel
+
+Der Export ist eine Leseoperation ohne Projektrevision. Ein append-only
+Nachweis speichert Projektrevision, zugrunde liegenden letzten Import,
+Zeitpunkt, Dateiname, SHA-256, Konfigurationskopie beziehungsweise ihren Hash
+und Objektzahl.
+
+Umfang:
+
+- alle im letzten Import vorhandenen Objekte (Standard);
+- nur Objekte mit Abweichung zum zuletzt importierten Revit-Wert;
+- Auswahl aus der Objekttabelle.
+
+Die Rückgabe basiert auf einer Kopie des zuletzt importierten Workbooks.
+Zeilen oberhalb der ersten Datenzeile, Kopfkommentare, Formate,
+Spaltenbreiten, Blattname und Spaltenreihenfolge bleiben erhalten. Danach
+folgen nur die gewählten Objektzeilen in ihrer Originalreihenfolge. Alle
+Spalten bleiben enthalten; Summenzeilen entfallen.
+
+Stromkreiswerte:
+
+- `combined`: `DistributionBoard.name + Circuit.equipmentIdentifier`, ohne
+  Trennzeichen;
+- `separate`: Verteilername und unverändertes BMK in getrennten Spalten;
+- ohne Circuit: Stromkreisfeld beziehungsweise beide Felder leer.
+
+Die Wahl des Verteilerwerts liegt in genau einer Funktion und verwendet
+zunächst `DistributionBoard.name`.
+
+Weitere Rückgabewerte:
+
+- Bezeichnung = Row-`displayName`, ohne Row Planungs-Anzeigename;
+- Leistung [W] = effektive Menge × Einzelleistung, ohne GZF;
+- Spannung = Circuit-Spannung, sonst Projektstandard der Kategorie;
+- Strom = `P / (U × cosPhi)` beziehungsweise
+  `P / (sqrt(3) × U × cosPhi)`, auf 0,01 A;
+- nicht berechenbar = leere Zelle plus Hinweis.
+
+Zahlen werden als Excel-Zahlen geschrieben. Fehlende optionale Zielspalten
+werden mit Hinweis ausgelassen. Nur fehlende Stromkreisspalten des gewählten
+Modus blockieren. Dateiname:
+`<Projektname>_Revit-Rueckgabe_<YYYY-MM-DD>.xlsx`.
+
+## 13. Verbindliche R2-Abnahme mit Linear
+
+R2 endet mit einer Rückgabedatei, die aus der lokalen realen Musterdatei
+erzeugt wurde und einige klar identifizierbare Rückgabewerte verändert. Diese
+Datei wird nicht committed. Der Nutzer testet sie in Linear. R3 darf erst nach
+erfolgreichem Linear-Rückimport beginnen.
+
+Scheitert der Linear-Import, wird vor R3 eine Alternative zur Freigabe
+vorgelegt: Die Original-XLSX wird direkt auf OOXML-Ebene kopiert und nur die
+erforderlichen Zellwerte/-typen sowie Zeilenbereiche angepasst. Die
+Alternative bleibt hinter demselben transportneutralen Adaptervertrag.
+
+## 14. Folgeimport
+
+Jeder Import ist eine vollständige Projektbauteilliste. Matching erfolgt
+ausschließlich über exakt und case-sensitiv verglichene Worksharing-ID.
+
+- neu: Wizard-Schritte nur für neue Objekte und unbekannte Familien;
+- geänderte Quellwerte: Einzel- oder Sammelentscheidung;
+- akzeptierte Mengenänderung: verknüpfte Row-Menge im selben Command;
+- fehlend: markieren, Link und Menge zunächst beibehalten;
+- Löschen: erst nach gesonderter Bestätigung;
+- abweichende Rückgabefelder: Hinweis `in Revit noch nicht aktualisiert`,
+  keine Übernahmeentscheidung.
+
+`external-import.apply-follow-up` ist atomar und ein Undo-Schritt.
+Unveränderte Objekte erzeugen keine unnötigen Objekt- oder Row-Änderungen.
+Der neue vollständige Batch wird letzter Batch; der zuvor letzte Batch wird
+auf Metadaten reduziert.
+
+## 15. Commands, Persistenz und Sicherheit
+
+Projektbezogene Writes verwenden typisierte Commands mit vollständiger
+Gegenrichtung, `expectedRevision`, Anmeldung, CSRF-Header und
+`project-command-transaction.persistence.ts`. Dazu gehören mindestens:
+
+- `external-model-configuration.update`;
+- `external-import.apply-initial`;
+- `external-import.apply-follow-up`;
+- `external-model-object.update-planning`;
+- `external-model-object.update-distribution-board`;
+- `external-model-room-mapping.update`;
+- `external-model-object.update-project-device-link`;
+- `external-object.update-row-assignment`;
+- `external-object.assign-to-new-row`;
+- `external-object.assign-to-new-circuit`;
+- `external-model-object.delete-missing`;
+- die erweiterten Row-/Circuit-/Gruppen-Löschcommands mit Objekt-Link-
+  Transitionen.
+
+Die Konfiguration selbst ist Teil der erwarteten/gewünschten Snapshots, aber
+hat keinen eigenen monotonen Zähler. Importbatches halten eine unveränderliche
+Konfigurationskopie. Preview/Plan sind zustandslos. Apply überträgt und parst
+die Datei erneut; Undo/Redo führt nur gespeicherte Zustandsübergänge aus.
+
+Neue Migrationen sind additiv. Vor Anwendung wird die Datenbank gesichert und
+das generierte SQL geprüft. Da nur Entwicklungsdaten existieren, darf die
+Migration alte externe CSV-Daten verwerfen. Vor dem Löschen externer Objekte
+werden betroffene Row-Mengen auf `manualQuantity` zurückgesetzt. Der Verlust
+des alten externen Entwicklungszustands wird dokumentiert.
+
+## 16. Abnahme und Leistung
+
+Die Oberfläche muss mehrere Tausend Objekte flüssig bedienen. R10 misst
+Import, Command-/Snapshot-Größe, Speicherbedarf und Client-Interaktion mit
+synthetischen großen Workbooks. Die virtualisierte Tabelle rendert nur den
+sichtbaren Ausschnitt, während Filterung, Sortierung und Auswahl auf der einmal
+geladenen kompakten Liste arbeiten.
+
+Jedes Paket R1–R10 führt fokussierte Tests sowie aus:
+
+```text
+npm test
+npm run build:api
+npm run build:web
+npm run typecheck:scripts
+npx tsc --noEmit -p tsconfig.next.json
+```
+
+Jedes Paket erhält einen eigenen knappen imperativen Commit. Die konkrete
+Paketfolge und ihre Freigabepunkte stehen im
+[R0–R10-Plan](revit-excel-phase-14-plan.md).
diff --git a/docs/spec/revit-excel-phase-14-plan.md b/docs/spec/revit-excel-phase-14-plan.md
new file mode 100644
index 0000000..46b4fba
--- /dev/null
+++ b/docs/spec/revit-excel-phase-14-plan.md
@@ -0,0 +1,173 @@
+# Phase 14 neu – Plan für die Linear-Excel-Anbindung
+
+Verbindliche Fachgrundlage:
+[Revit-Integration über Linear-Excel](revit-excel-integration-requirements.md).
+Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
+
+## Status
+
+| Paket | Status | Ergebnis / Freigabepunkt |
+| --- | --- | --- |
+| R0 | abgeschlossen und freigegeben | Bestandsaudit, Zielmodell, Migration und Risiken; Freigabekorrekturen in R1 eingearbeitet. |
+| R1 | abgeschlossen | Anforderungen, Plan und Architektur auf Excel/Worksharing-ID umgestellt; alle Pflichtprüfungen bestanden. |
+| R2 | offen | XLSX-Adapter, Parser, synthetische Fixtures, lokaler Referenzprüfer und reale Rückgabedatei. Danach zwingende Linear-Abnahme durch den Nutzer. |
+| R3 | gesperrt bis R2-Abnahme | Konfiguration, Identität, Migration, Snapshot 10, Transfer und Backend-CSV-Entfernung. |
+| R4 | offen | Revit-Seite, Navigation, Einstellungen, altes Projektseitenmodal entfernen. |
+| R5 | offen | Erstimportwizard mit Gerätearten, Familienregeln und optionalen ProjectDevices. |
+| R6 | offen | Virtualisierte Objekttabelle und Sammelzuordnungen. |
+| R7 | offen | Editorbereich, Gruppierung, Drag-and-drop, Lösen und integrierte Löschübergänge. |
+| R8 | offen | Rückgabe-Excel und append-only Exportnachweis. |
+| R9 | offen | Vollständiger Folgeimport nach Worksharing-ID. |
+| R10 | offen | Ende-zu-Ende-Härtung, große Datenmengen und Abschlussdokumentation. |
+
+## R0 – Audit
+
+Ergebnis: [R0-Audit](revit-excel-r0-audit.md). Die Freigabe vom 29.09.2026
+enthält 13 Korrekturen. Bei Abweichungen zwischen dem historischen Audit und
+der aktuellen Anforderung gilt das neue Anforderungsdokument.
+
+## R1 – Dokumentation
+
+Lieferumfang:
+
+- neues verbindliches Excel-Anforderungsdokument;
+- dieser R0–R10-Plan;
+- alte CSV-Anforderungen und alter Plan als kurze Ablösungshinweise;
+- LLM-Kontext auf die neue Quelle der Wahrheit kürzen;
+- `AGENTS.md`, aktuelle Architektur, History-/External-Model-Architektur,
+  Roadmap, README, Dokumentationsindex und bekannte Einschränkungen anpassen;
+- reale Musterdatei per `.gitignore` vom Commit ausschließen;
+- alle internen Links auf die neuen Dokumente umstellen.
+
+Keine Laufzeit-, Schema- oder UI-Änderung. Abnahme: keine aktive Dokumentation
+nennt CSV/IfcGUID als künftigen Transport beziehungsweise Schlüssel; der
+aktuell noch vorhandene Legacy-Code bleibt als solcher klar benannt.
+
+## R2 – XLSX-Transportadapter
+
+Dateien/Module: neues `src/external-model/xlsx`, synthetische Testfixtures und
+ein auf XLSX umgestellter Referenzprüfer mit Dateipfadargument. Eine neue
+direkte Bibliothek (`exceljs`, vorbehaltlich der Tests), keine DB-Änderung.
+
+Abnahme:
+
+- Kopfzeilenkommentare, Blattname, Spaltenbreiten, Formate und Zelltypen
+  überleben einen strukturellen Roundtrip;
+- erste Datenzeile/-spalte und Mappings funktionieren ohne separates
+  `layout.idColumn`;
+- Worksharing-ID/IfcGUID werden exakt und case-sensitiv behandelt;
+- Zeile ohne ID und ohne `Familie und Typ` wird übersprungen, die Muster-
+  Summenzeile B490 blockiert nicht;
+- Zeile ohne ID mit `Familie und Typ` erzeugt Hinweis und wird übersprungen;
+- maximal 10 MiB, nur `.xlsx`, Zeilen-/Spaltengrenzen nach dem Einlesen;
+- keine Formelausführung;
+- lokale Referenzprüfung bestätigt 487 Objekte und keine ID-Duplikate;
+- aus der realen Musterdatei entsteht lokal eine nicht versionierte
+  Rückgabedatei mit einigen geänderten Werten.
+
+Danach stoppt die Arbeit. Der Nutzer testet diese Datei in Linear. Erst sein
+erfolgreicher Rückimport gibt R3 frei. Scheitert er, wird vor R3 ein konkreter
+OOXML-Patchadapter vorgeschlagen, der das Originalworkbook direkt ändert.
+
+## R3 – Datenmodell und Backend-Cutover
+
+- Konfiguration ohne eigene Versionszählung;
+- `worksharing_id NOT NULL`, Unique je Quelle; `ifc_guid` nullable ohne Unique;
+- additive Migration nach vorherigem DB-Backup; alte externe Entwicklungsdaten
+  verwerfen und Row-Mengen vorher auf `manualQuantity` zurücksetzen;
+- Batch-Aufbewahrung: nur letzter Batch vollständig, ältere nur Metadaten;
+- Snapshot 10, Restore und Transfer; alte CSV-Zustände/History klar ablehnen;
+- Backend-CSV-Parser, Endpunkte und Verträge entfernen;
+- Apply parst erneut; Undo/Redo verwenden ausschließlich gespeicherte
+  Vorher-/Nachher-Zustände.
+
+Risiken: Migration mit verknüpften Row-Mengen, alte History-Spitzen und
+vollständiges UUID-Remapping. Pflicht: echte SQLite-Commit-/Rollback-Tests.
+
+## R4 – Revit-Seite und Einstellungen
+
+- Route `/projects/:projectId/revit` und Navigationseintrag;
+- Status-/Aktionsgrundgerüst;
+- Einstellungsmodal mit Musterdateierkennung, Layout und Feldzuordnung;
+- Stromkreismodus `combined | separate`;
+- Projektseiten-Button und `revit-csv-modal.tsx` entfernen;
+- nur deutsche UI-Texte und bestehende Icon-/Kartenregeln.
+
+## R5 – Erstimport
+
+- Vorschau und Plan mit erneuter Dateiübertragung beim Apply;
+- Räume, Verteiler, Gerätearten, exakte Familienregeln und optionale
+  ProjectDevices;
+- fehlender GZF als sichtbarer Startwert `1`, ohne Zusatzbestätigung;
+- Warn-/Überspringregel für ID-lose Zeilen;
+- ein atomarer Importcommand, keine Row-/Circuit-Erzeugung;
+- Undo/Redo aus Commandzuständen ohne Workbook-Parsing.
+
+## R6 – Objekttabelle und Sammelaktionen
+
+- kompakte Objektliste einmal laden;
+- clientseitig suchen, filtern und sortieren;
+- virtualisierte Darstellung ohne Server-Pagination;
+- stabile Mehrfachauswahl und Sammelaktionen für Verteiler, ProjectDevice und
+  Objektplanungswerte;
+- Standardverteileränderung wirkt nur auf unzugeordnete Objekte; verknüpfte
+  Objekte folgen unverändert ihrer Row.
+
+## R7 – Stromkreislisteneditor
+
+- gruppierter rechter Revit-Bereich mit Anzahl-Badge;
+- Drop auf Row, Circuit oder freien Bereich über vorhandene, angepasste
+  Commands;
+- Row-Indikator, Objektanzeige und Lösen mit Übernahme aktueller Row-Werte;
+- Row-/Circuit-/Gruppen-Löschcommands lösen verknüpfte Objekte atomar und
+  zeigen `X Revit-Objekte werden wieder unzugeordnet`;
+- Undo stellt Objektlinks exakt wieder her;
+- nur Raum-/Verteilerlöschung mit externen Referenzen bleibt gesperrt.
+
+## R8 – Rückgabe-Excel
+
+- alle / abweichende / ausgewählte Objekte;
+- zuletzt importiertes Workbook als strukturelle Grundlage;
+- Stromkreisfelder des gewählten Modus sind Pflicht;
+- fehlende optionale Bezeichnung-/Leistung-/Spannung-/Stromspalten nur als
+  Hinweis überspringen;
+- typisierte Zahlen, gemeinsame Export-/Abweichungsprojektion;
+- append-only Exportnachweis ohne Projektrevision.
+
+R8 baut auf der in R2 durch Linear bestätigten Transportstrategie auf.
+
+## R9 – Folgeimport
+
+- exaktes, case-sensitives Matching nach Worksharing-ID;
+- neu, geändert, unverändert, fehlend und Rückgabefeldabweichungen;
+- Entscheidungen nur für fachliche Quelländerungen;
+- akzeptierte Mengenänderungen und Row-Summen atomar;
+- fehlende Objekte nicht automatisch lösen oder löschen;
+- neuer letzter Vollbatch, vorheriger Batch auf Metadaten reduzieren;
+- ein persistenter Undo-Schritt ohne Excel-Parsing bei Undo/Redo.
+
+## R10 – Härtung
+
+Ende-zu-Ende-Test:
+
+```text
+Import → Objektplanung → Row-Zuordnung → Rückgabe → Folgeimport
+       → Snapshot/Restore → Projektduplikat → Undo/Redo nach Neustart
+```
+
+Zusätzlich: mehrere Tausend synthetische Objekte, virtualisierte UI,
+Speicher-/Payload-/Transaktionsmessungen, Löschwarnungen samt Link-Inversen,
+alte CSV-Ablehnungen und Dokumentation auf den ausgelieferten Stand.
+
+## Pflichtprüfungen je Paket R1–R10
+
+```text
+fokussierte Tests
+npm test
+npm run build:api
+npm run build:web
+npm run typecheck:scripts
+npx tsc --noEmit -p tsconfig.next.json
+```
+
+Jedes Paket wird mit einer knappen imperativen Commit-Message abgeschlossen.
diff --git a/docs/spec/revit-excel-r0-audit.md b/docs/spec/revit-excel-r0-audit.md
index 721e402..84acc5a 100644
--- a/docs/spec/revit-excel-r0-audit.md
+++ b/docs/spec/revit-excel-r0-audit.md
@@ -2,12 +2,17 @@
 
 Stand: 29.09.2026. Geprüfter Code: `cf022b2`.
 
-**Status: R0 abgeschlossen, Freigabe für R1–R10 ausstehend.** Dieser Bericht
+**Status: R0 abgeschlossen und mit Korrekturen für R1 freigegeben.** Dieser Bericht
 ist ein Umsetzungsvorschlag, kein Nachweis einer bereits implementierten
 Excel-Anbindung. Der neue Nutzerauftrag ersetzt die CSV-/IfcGUID-Vorgaben und
 die alte Phasenliste 14.0–14.6. R1 bereinigt die bestehenden Dokumente; R0
 ändert weder Laufzeitcode noch Datenbank noch Oberfläche.
 
+Die 13 Freigabekorrekturen vom 29.09.2026 sind in den
+[verbindlichen Anforderungen](revit-excel-integration-requirements.md) und im
+[R0–R10-Plan](revit-excel-phase-14-plan.md) eingearbeitet. Bei Abweichungen
+gelten diese beiden R1-Dokumente.
+
 ## 1. Geprüfter Bestand und Keep/Change/Remove
 
 Gelesene Grundlagen: `AGENTS.md`, `docs/current-architecture.md`,
@@ -90,7 +95,7 @@ Die Datei ist unversioniert und darf nicht committed werden.
 | Objektidentitäten | 487 syntaktisch passende Worksharing-IDs, keine Duplikate |
 | Kopfzeilenkommentare | 14, zu den 14 Spalten nach der ID-Spalte |
 | Fehlende Raumangaben | 67 Objekte ohne Raumnummer und Raumname |
-| IfcGUID-Duplikate | 2 Gruppen nichtleerer doppelter Werte |
+| IfcGUID-Duplikate | Keine bei exaktem, case-sensitivem Vergleich |
 | Formeln | Keine; synthetische Tests dafür erforderlich |
 | Spaltendefinitionen | 16, obwohl nur 15 Datenspalten vorhanden sind |
 
@@ -100,9 +105,15 @@ gekürzt werden. Das Muster enthält die neuen getrennten Stromkreisfelder und
 die Bezeichnung noch nicht. Fehlende Rückgabespalten werden angezeigt; sie
 dürfen nicht ohne Linear-Parameterbindung erfunden werden.
 
+Die frühere Angabe von zwei IfcGUID-Duplikatgruppen war falsch: PowerShells
+standardmäßiges Gruppieren verglich ohne Beachtung der Groß-/Kleinschreibung.
+Ein erneuter ordinaler, case-sensitiver Vergleich ergab keine Duplikate. Die
+Summenzeile hat nur in B490 einen Wert; `Familie und Typ` ist leer.
+
 Nicht nachgewiesen: erfolgreicher Rückimport in Linear, dessen genaue
-Auswertung der Kommentar-/VML-Metadaten und der ExcelJS-Roundtrip. R2 prüft
-die Struktur, R8/R10 benötigen zusätzlich einen realen Linear-Abnahmelauf.
+Auswertung der Kommentar-/VML-Metadaten und der ExcelJS-Roundtrip. R2 endet
+deshalb mit einer aus der Musterdatei erzeugten Rückgabedatei und einem
+verbindlichen Linear-Test durch den Nutzer vor R3.
 
 ## 3. Bibliothek, Adapter und Uploadgrenzen
 
@@ -123,18 +134,12 @@ Blocker wird die Bibliotheksentscheidung neu vorgelegt.
 
 Vorgeschlagene Grenzen, zentral konfiguriert und synthetisch getestet:
 
-- ausschließlich `.xlsx`, passender OOXML-Inhalt und ZIP-Signatur; kein
-  `.xlsm`, verschlüsseltes Archiv, VBA, ActiveX oder externe Workbook-Links;
-- maximal 10 MiB Upload, 100 MiB tatsächlich entpackte Daten, 2.000 ZIP-
-  Einträge, 50.000 Zeilen, 256 Spalten und 2 Millionen materialisierte Zellen;
-- genau ein Arbeitsblatt; keine Formelausführung, kein Nachladen von URLs;
-- ZIP-Vorprüfung vor ExcelJS: Verzeichniseinträge, doppelte Pfade,
-  Kompressionsverfahren und tatsächliche entpackte Bytezahl prüfen.
-  Zentralverzeichnisangaben allein schützen nicht vor manipulierten Archiven.
-  Begrenzte Dekompression mit Node-Bordmitteln, keine zweite direkte Library;
-- Parser in begrenztem Worker mit Zeit-/Speichergrenze; Abbruch ohne DB-
-  Schreibvorgang. API-Body-Limit auf Uploadgrenze einschließlich Base64-
-  Overhead abstimmen, statt global beliebige Requestgrößen zuzulassen.
+- ausschließlich `.xlsx`, kein `.xls` oder `.xlsm`;
+- maximal 10 MiB Upload;
+- genau ein Arbeitsblatt und keine Formelausführung;
+- feste Zeilen-, Spalten- und Zellgrenzen nach dem Einlesen.
+
+Es gibt keinen eigenen ZIP-Prüfer und keinen Parser-Worker.
 
 Neutrale Matrix: Blattname, Kopfzeilen-/Startpositionen, Spaltenmetadaten
 (Index, Name, Kommentartext, erkannter Parametertyp/Einheit), geordnete
@@ -144,11 +149,14 @@ optionale Transportmetadaten; fachlich zählt nur der gecachte skalare Wert.
 Fehlender Cache oder Fehlerwert erzeugt einen Hinweis bzw. bei Pflichtfeldern
 einen Blocker. Originalbytes bleiben unverändert gespeichert.
 
-Fehlende ID bei sonstigen Objektdaten blockiert; Leer-/eindeutige Summenzeilen
-werden ignoriert. Nicht passende nichtleere IDs blockieren ebenfalls.
-Worksharing-ID bleibt als Quelltext erhalten, Matching ist exakt; ungültige
-Leerzeichen/uneindeutige Schreibweisen werden gemeldet statt still korrigiert.
-IfcGUID wird optional gespeichert, doppelte Werte sind nur Hinweise.
+Eine Zeile ohne Worksharing-ID ist nur verdächtig, wenn `Familie und Typ`
+gefüllt ist. Sie erzeugt einen Hinweis und wird übersprungen, ohne zu
+blockieren. Andere ID-lose Zeilen, auch die Summenzeile mit Inhalt in B,
+werden still übersprungen. Nicht passende nichtleere IDs blockieren.
+Worksharing-ID und IfcGUID bleiben als Quelltext erhalten und werden exakt,
+ordinal und case-sensitiv verglichen; ungültige äußere Leerzeichen werden
+gemeldet statt still korrigiert. IfcGUID wird optional gespeichert, doppelte
+Werte sind nur Hinweise.
 Numerische Projektion rundet Leistung auf 0,01 W, nicht die gespeicherte
 Quellzelle. Mengen aus `socketCount` müssen positive ganze Zahlen sein.
 
@@ -170,8 +178,7 @@ Neuer neutraler Vertrag `ExternalModelConfiguration`, Schema-Version 1:
 {
   schemaVersion: 1,
   layout: {
-    headerRow: 1, firstDataRow: 3, firstDataColumn: 1,
-    idColumn: "Worksharing-ID"
+    headerRow: 1, firstDataRow: 3, firstDataColumn: 1
   },
   circuitMode: "combined" | "separate",
   columns: {
@@ -200,8 +207,8 @@ Neuer neutraler Vertrag `ExternalModelConfiguration`, Schema-Version 1:
 ```
 
 Zeilen/Spalten sind intern 1-basiert; UI stellt Spalten als A, B, … dar.
-`layout.idColumn` und `columns.worksharingId` werden gemeinsam gesetzt und
-müssen übereinstimmen. Jede gemappte Kopfzeile muss eindeutig auflösbar sein;
+Es gibt nur `columns.worksharingId` und kein separates `layout.idColumn`.
+Jede gemappte Kopfzeile muss eindeutig auflösbar sein;
 doppelte Ausgabebelegungen werden abgelehnt. Freie Eingabe bleibt zulässig,
 aber ein nicht existierender Name erzeugt vor Import/Export einen konkreten
 Fehler. Erkennung und Vorbelegung nutzen die exakten Standardnamen aus dem
@@ -217,8 +224,8 @@ Referenzierte Gerätearten können nicht kommentarlos entfernt werden.
 Startwerte: je Feld ProjectDevice vor Geräteart vor leer. Anzeigename:
 Auswahlkenner, sonst Geräteartname, sonst Familie/Typ. Quellleistung bleibt
 Quelle; eine Übernahme geschieht nur als sichtbare Planungsentscheidung.
-Fehlender GZF bleibt vor Zuordnung leer; verlangt der Row-Vertrag einen Wert,
-wird `1` sichtbar vorgeschlagen und ausdrücklich bestätigt. Geräteart-
+Fehlender GZF wird sichtbar mit `1` vorbelegt, ohne zusätzliche Bestätigung.
+Geräteart-
 Änderungen schreiben keine vorhandenen Objekt-Overrides oder Rows um.
 
 ## 5. Konkretes Persistenzschema
@@ -228,20 +235,21 @@ Bestehende UUID-/Projekt-FKs und Eigentumsprüfungen werden beibehalten.
 
 | Tabelle | Zielspalten / Constraints |
 | --- | --- |
-| `external_model_configurations` (ersetzt CSV-Tabelle) | `id TEXT PK`, `project_id TEXT NOT NULL UNIQUE FK projects`, `configuration_version INTEGER NOT NULL CHECK > 0`, `configuration JSON NOT NULL`. Enthält obiges vollständiges Aggregat. |
+| `external_model_configurations` (ersetzt CSV-Tabelle) | `id TEXT PK`, `project_id TEXT NOT NULL UNIQUE FK projects`, `configuration JSON NOT NULL`. Enthält obiges vollständiges Aggregat; keine eigene Versionszählung. |
 | `external_model_sources` | `id`, `project_id UNIQUE`, `name`, `source_type = revit_xlsx`. Genau eine implizite Quelle je Projekt. |
-| `external_import_batches` | Bestehende IDs, Importart, Zeit, Dateiname, SHA-256, `applied_project_revision`, `configuration_version`, `configuration_snapshot JSON`, `original_bytes BLOB`, `document JSON`; Matrix jetzt typisiert und transportneutral. Unveränderlich innerhalb des aktiven Zustands; Undo/Restore darf ganze Batches entfernen/wiederherstellen. |
+| `external_import_batches` | Letzter Batch vollständig mit IDs, Importart, Zeit, Dateiname, SHA-256, Objektzahl, `applied_project_revision`, `configuration_snapshot JSON`, `original_bytes BLOB`, `document JSON`; ältere Batches nur als Metadaten Datum, Dateiname, SHA-256 und Objektzahl. |
 | `external_room_mappings` | Vorhandene Felder einschließlich normalisiertem Quellraumschlüssel, `room_id`, `default_distribution_board_id`; UNIQUE `(source_id, normalized_source_room_key)` bleibt. |
 | `external_model_objects` | Bestehende interne IDs/Links; neu `worksharing_id TEXT NOT NULL`, UNIQUE `(source_id, worksharing_id)`; `ifc_guid TEXT NULL`, ohne Unique; `device_type_id TEXT NOT NULL` als validierter Verweis in das Konfigurationsaggregat. |
 | Objektzustand | `accepted_source_values JSON` mit rohen typisierten Werten für Raum, Familie/Typ, Marker, Menge, Bemerkung und alle Rückgabefelder; `planning_values JSON` mit Anzeigename, Kategorie, Anschlussart, effektiver Menge, Einzelleistung W, nullable GZF/cosPhi/Kostengruppe/Bemerkung; `overridden_fields JSON`; bisherige Batch-/Raum-/Board-/ProjectDevice-/Row-Verweise und `presence_status` bleiben. |
-| `external_export_batches` (neu) | `id TEXT PK`, `project_id FK`, `project_revision INTEGER`, `import_batch_id TEXT`, `exported_at_iso TEXT`, `file_name TEXT`, `sha256 TEXT`, `configuration_version INTEGER`, `scope TEXT`, `object_count INTEGER`. Append-only Audit-Store. |
+| `external_export_batches` (neu) | `id TEXT PK`, `project_id FK`, `project_revision INTEGER`, `import_batch_id TEXT`, `exported_at_iso TEXT`, `file_name TEXT`, `sha256 TEXT`, `configuration_snapshot/hash`, `scope TEXT`, `object_count INTEGER`. Append-only Audit-Store. |
 
 `import_batch_id` des Exportnachweises ist absichtlich eine historische UUID
 ohne löschenden FK: Undo eines Imports oder Snapshot-Restore darf den Nachweis
 nicht entfernen. Exportnachweise liegen außerhalb rücksetzbarer Fachsnapshots
 und werden beim Projektduplikat nicht als dort erfolgte Exporte ausgegeben.
 Sie bleiben beim Originalprojekt erhalten; diese Abgrenzung wird in R1
-dokumentiert. Importbatches selbst gehören vollständig zu Snapshot/Transfer.
+dokumentiert. Nur der letzte Importbatch gehört mit Bytes und Matrix zu
+Snapshot/Transfer; ältere Batches werden dort nur als Metadaten erhalten.
 
 Indices: bisherige Projekt-/Presence-, Board- und Row-Indices behalten;
 zusätzlich `(project_id, device_type_id)`, `external_room_mapping_id`,
@@ -252,9 +260,9 @@ Transaktion; bloße Existenz eines UUID-FK genügt nicht.
 Effektiver Verteiler: ein gemeinsamer Resolver verwendet bei verknüpften
 Objekten die Row/Circuit-Verteilung, sonst die Objektabweichung, sonst die
 Raumvorgabe. `distributionBoardId = null` bedeutet Raumvorgabe verwenden;
-bei fehlender Vorgabe ist das Objekt ohne Verteiler. Room-/Board-
-Sammeländerungen prüfen alle betroffenen Row-Links und lehnen inkonsistente
-Umbuchungen ab, bis diese ausdrücklich gelöst/verschoben sind.
+bei fehlender Vorgabe ist das Objekt ohne Verteiler. Eine Änderung des
+Raum-Standardverteilers betrifft nur unzugeordnete Objekte; verknüpfte Objekte
+folgen immer der Row-Verteilung und blockieren diese Änderung nicht.
 
 Planungswerte bleiben von Quellwerten getrennt. Nach Row-Zuordnung sind
 Objekt-Planungswerte eingefrorene Startwerte; Anzeige, Abweichung und Export
@@ -272,7 +280,7 @@ Snapshots der betroffenen Datensätze, keine ungesicherten Teilpatches.
 
 | Command | Payload-Skizze und Gegenrichtung |
 | --- | --- |
-| `external-model-configuration.update` v1 | `{ expected, target }` einschließlich Layout, Mapping, Gerätearten und Regeln. Inverse tauscht Fachinhalt; Versionsgeneration siehe unten. |
+| `external-model-configuration.update` v1 | `{ expected, target }` einschließlich Layout, Mapping, Gerätearten und Regeln. Inverse tauscht den vollständigen Fachinhalt; keine eigene Konfigurationsversion. |
 | `external-import.apply-initial` v2 | `{ expectedConfiguration, targetConfiguration, expected, target }`. Quelle, Batch, Mapping, Objekte und neue Regeln zusammen; Inverse stellt leeren externen und vorherigen Konfigurationsinhalt wieder her. Keine Rows. |
 | `external-import.apply-follow-up` v1 | `{ configuration: transition, batch: transition, roomMappings: transitions, objects: transitions, rows: quantityTransitions, decisions }`; Server erzeugt deterministischen Diff und alle UUIDs. Inverse tauscht alle betroffenen Zustände. |
 | `external-model-object.update-planning` v1 | `{ objects: transitions }`; nur ungebundene Objekte; geänderte Felder in Overrides. Einzel-/Sammelbearbeitung identischer Regeln. |
@@ -290,32 +298,29 @@ Entwürfe und werden erst mit dem Import atomar persistiert. Nach separater
 Kataloganlage aktualisiert der Wizard die Projektrevision und plant neu,
 ohne lokale Entscheidungen zu verlieren.
 
-Konfigurationsgeneration: `configurationVersion` erhält bei jedem
-Konfigurationswechsel einschließlich Undo/Redo/Restore die neu entstehende
-Projektrevision. Sie ist damit strikt steigend, aber nicht lückenlos.
-Historienbefehle vergleichen den erwarteten Fachinhalt und die aktuelle
-Projektversion; die administrative Generation wird serverseitig neu erzeugt.
-Die Inverse restauriert alle Fachwerte exakt, nicht einen alten Zählerstand.
-Importbatches behalten ihre ursprüngliche Generation und ihren Snapshot.
-Ein Restore/Projekttransfer erhält diese Herkunft; die aktive Konfiguration
-wird an die Revision des Zielprojekts gebunden. Prüfen: Änderung → Undo →
-anderer Zweig darf niemals denselben Vorschau-Token wieder gültig machen.
+Die Konfiguration hat keine eigene Versionszählung. Vorschau und Apply binden
+sich an `expectedRevision`; weil auch Undo/Redo neue, strikt steigende
+Projektrevisionen erzeugen, wird ein veralteter Plan eindeutig ungültig.
+Importbatches speichern eine vollständige Konfigurationskopie. Prüfen:
+Änderung → Undo → anderer Zweig darf niemals denselben Plan wieder gültig
+machen.
 
 XLSX wird vor der synchronen SQLite-Transaktion in einer serverinternen
 Vorbereitung geparst. Apply überträgt Bytes erneut; Hash, Matrix und
 Entscheidungen werden erneut validiert. Im Store werden Revision,
-Konfigurationsinhalt/-generation, erwartete Objekte, Links und vollständiger
+Konfigurationsinhalt, erwartete Objekte, Links und vollständiger
 vorbereiteter Plan atomar geprüft. Vorbereitete Daten sind keine vom Client
 behauptete Validierung: Generic-Command-Requests dürfen Importcommands nicht
-an dieser serverseitigen Vorbereitung vorbeischleusen. Undo/Redo benutzen
-denselben Prüfdienst für persistierte Bytes vor der Transaktion. Keine
-asynchronen Callbacks in `better-sqlite3`-Transaktionen.
+an dieser serverseitigen Vorbereitung vorbeischleusen. Undo/Redo lesen und
+parsen keine Excel-Datei; sie wenden ausschließlich die gespeicherten
+Vorher-/Nachher-Zustände an. Keine asynchronen Callbacks in
+`better-sqlite3`-Transaktionen.
 
-Allgemeine Row-/Circuit-/Gruppen-/Board-/Raum-/ProjectDevice-Löschungen
-erhalten Guards, solange externe Referenzen betroffen sind. Nutzer lösen die
-Referenzen zuvor ausdrücklich über die passenden Commands. Guards gelten
-auch in Unterbaum- und History-only-Pfaden. Dadurch werden vorhandene
-Commands nicht unbemerkt zu unvollständigen externen Löschcommands.
+Row-/Circuit-/Gruppen-Löschcommands erfassen verknüpfte Objekte vollständig.
+Nach der Warnung `X Revit-Objekte werden wieder unzugeordnet` lösen sie die
+Links im selben Command; ihre Inverse stellt sie exakt wieder her. Sperren
+bleiben nur für das Löschen referenzierter Verteiler und Räume und gelten auch
+in Unterbaum- und History-only-Pfaden.
 
 ## 7. Migration, Snapshot 10, History und Transfer
 
@@ -351,7 +356,8 @@ allgemeine Commands können nach dem Reset zusätzlich an ihren exakten
 Vorbedingungen scheitern; das bleibt eine sichere, sichtbare Ablehnung.
 
 Snapshot v10 enthält aktive Excel-Konfiguration, Gerätearten/Regeln, Quelle,
-alle Batches mit Originalbytes/Matrix, Raum-Mappings, Objekte und Links.
+den letzten Batch mit Originalbytes/Matrix, ältere Batches nur als Metadaten
+sowie Raum-Mappings, Objekte und Links.
 Upgrade v1–9: bestehende nicht-externe Upgrader erhalten. Nur wenn
 `externalCsvConfiguration` fehlt/null ist **und** der externe Zustand leer
 ist, verlustfrei auf v10 heben. Auch eine gespeicherte CSV-Konfiguration
@@ -389,12 +395,13 @@ separater append-only Audit-Write, ohne Projektrevision oder Undo-Schritt.
 Bei Auditfehler kein Erfolg/download; ein Eintrag belegt Dateierzeugung,
 nicht einen tatsächlich abgeschlossenen Browserdownload.
 
-Die Revit-Seite zeigt Status, Aktionen und eine paginierte Objekttabelle
-(Vorschlag: 100 Zeilen pro Seite). Filter-/Sortierzustand, UUID-Auswahl und
-Sammelaktionen sind unabhängig vom DOM. „Alle gefilterten“ verwendet eine
-explizit aufgelöste Auswahl zur bekannten Revision; keine Mutation anhand
-eines inzwischen veränderten Filters. Große Auswahlmengen werden nicht in
-getrennte Undo-Schritte aufgeteilt. Kein vollständiges Batch-Blob im DTO.
+Die Revit-Seite lädt einmal eine kompakte Objektliste. Filterung und Sortierung
+laufen im Client; die Tabelle wird virtualisiert und verwendet keine Server-
+Pagination. Filter-/Sortierzustand, UUID-Auswahl und Sammelaktionen sind
+unabhängig vom DOM. „Alle gefilterten“ wird vor einer Mutation zu einer
+expliziten ID-Auswahl an der aktuellen Revision aufgelöst. Große Auswahlmengen
+werden nicht in getrennte Undo-Schritte aufgeteilt. Kein vollständiges
+Batch-Blob im DTO.
 
 Einstellungen verwenden Musterdatei-Erkennung mit editierbaren Positionen,
 Feld-Dropdowns/freier Eingabe und Kommentar-Typ-/Einheitenanzeige. Regeln
@@ -430,10 +437,10 @@ gegen den **zuletzt importierten**, nicht den zuletzt exportierten Stand.
 Umfang: alle im letzten Batch vorhandenen Objekte / abweichende / explizite
 Auswahl. Fehlende Objekte haben keine aktuelle Originalzeile und werden
 nicht künstlich wieder eingefügt. Alle Spalten bleiben, nicht ausgegebene
-Parameter behalten importierte Werte. Fehlende benötigte Zielspalten bzw.
-Linear-Bindungen blockieren die betreffende Exportkonfiguration mit Hinweis
-auf einen neuen vollständigen Linear-Export. Dateiname gemäß Auftrag mit
-bereinigtem Projektnamen und Tagesdatum.
+Parameter behalten importierte Werte. Fehlende optionale Spalten für
+Bezeichnung, Leistung, Spannung und Strom werden mit Hinweis übersprungen.
+Nur fehlende Stromkreisspalten des gewählten Modus blockieren. Dateiname gemäß
+Auftrag mit bereinigtem Projektnamen und Tagesdatum.
 
 Folgeimport matcht ausschließlich Worksharing-ID. Ein neuer Batch speichert
 immer den vollständigen letzten Quellstand. Unveränderte Objekte werden
@@ -457,12 +464,12 @@ nach Freigabe; keine Fortschreibung der alten 14.0–14.6-Liste.
 | Paket | Arbeit und entscheidende Abnahme |
 | --- | --- |
 | R1 | Neue Excel-Anforderungen und R0–R10-Plan; alte Dokumente archivieren/auf Verweise kürzen; AGENTS, Architektur, History-Doku, Phase-14-Abschnitt, LLM-Kontext und alle Links nachziehen. Referenzdatei gezielt ignorieren. |
-| R2 | XLSX-Adapter und lokaler Referenzprüfer mit Pfadargument. Synthetischer Roundtrip für Kommentare, Blattname, Spaltenbreiten, Typen, Header-/Startpositionen, unbekannte Spalten, Auswahl und Summenausschluss; ZIP-/Formelgrenzen. Keine DB-Änderung. |
+| R2 | XLSX-Adapter und lokaler Referenzprüfer mit Pfadargument. Synthetischer Roundtrip für Kommentare, Blattname, Spaltenbreiten, Typen, Header-/Startpositionen, unbekannte Spalten, Auswahl und Summenausschluss. Aus der lokalen Musterdatei entsteht eine Rückgabedatei mit geänderten Werten. Danach Nutzerabnahme in Linear; R3 bleibt bis zum Erfolg gesperrt. Bei Fehlschlag vor R3 OOXML-Direktänderung als Alternative vorlegen. Keine DB-Änderung. |
 | R3 | Neue Konfiguration/Identität, additive Migration, Snapshot 10, Transfer und History-Ablehnungen; Backend-CSV entfernen. Parser-Vorbereitung von synchroner Transaktion trennen. |
 | R4 | Revit-Seite, Navigation, Einstellungen; Projektseitenmodal und dessen CSV-Frontend-Verträge entfernen. |
 | R5 | Erstimport mit atomaren Regeln, Geräten, Raum-/Board- und Objektentscheidungen; ProjectDevice-Vorbelegung nach Priorität; ein Import-Undo-Schritt. |
-| R6 | Objekt-Reads, Paging/Filter, Sammel-Commands und Overrides; verwandte Lösch-/Referenzguards vollständig absichern. |
-| R7 | Gruppierung, Drag-and-drop, Row-Indikatoren und Lösen inklusive aktueller Row-Werte; drei Drop-Ziele und Reload/Undo/Redo. |
+| R6 | Kompakte Objekt-Reads, clientseitige Filter/Sortierung, Virtualisierung, Sammel-Commands und Overrides. |
+| R7 | Gruppierung, Drag-and-drop, Row-Indikatoren und Lösen inklusive aktueller Row-Werte; drei Drop-Ziele, atomare Objektlösung beim Row-/Circuit-/Gruppen-Löschen und Reload/Undo/Redo. |
 | R8 | Drei Exportumfänge, gemeinsame Abweichungsprojektion, typisierte Rückgabe, append-only Nachweis und Linear-Strukturabnahme. |
 | R9 | Kontrollierter Folgeimport, fehlende Objekte, explizites Löschen, mengenwirksame Entscheidungen und atomare Inverse. |
 | R10 | Vollständige synthetische Ende-zu-Ende-Kette einschließlich Neustart, Snapshot/Restore und Duplikat; mehrere Tausend Objekte; Doku auf ausgelieferten Stand. |
@@ -492,19 +499,19 @@ Zusätzlich erforderliche neue Prüfungen:
 - Migration mit externen Row-Anteilen; keine Phantomlast und unveränderte BMKs.
 - v1–9 ohne CSV verlustfrei, mit CSV klare Ablehnung; alte Command-Inversen
   und alte Restore-Payloads ebenfalls ohne Teilwrites ablehnen.
-- Config-Änderung/Undo/Neuzweig invalidiert alte Pläne; Apply mit anderem
+- Config-Änderung/Undo/Neuzweig invalidiert alte Pläne über `expectedRevision`; Apply mit anderem
   Dateiinhalt, fehlenden Entscheidungen oder fremden UUIDs rollt vollständig
   zurück. Später Historyfehler rollt auch Regeln, Links und Mengen zurück.
 - Gebundene Row ändern → Export → Lösen → Undo/Redo behält fachliche Werte.
 - Mehrfachsteckdosen: unterschiedliche effektive Mengen, identische
   Einzelwerte, richtige Gruppierung und objektweise Rückgabeleistung.
-- Löschen über alle Unterbaum-/History-Pfade kann externe FKs nicht still
-  nullen. Fremde Verteilungen/Räume/Kategorien und Gerätearten blockieren.
+- Row-/Circuit-/Gruppen-Löschen löst externe Links im Command und stellt sie
+  per Undo wieder her. Raum-/Verteilerlöschen mit Referenzen blockiert.
 - Export-Audit scheitert: keine fachliche Revision; SHA-256 entspricht exakt
   den gelieferten Bytes. Snapshot/Restore entfernt keine Exportnachweise.
 - 5.000/10.000 synthetische Objekte: Parserzeit, Peak-Speicher, Payloadgröße,
-  Command-/Snapshot-Dauer und UI-Reaktionszeit messen; höchstens eine
-  paginierte Seite im DOM, stabile Auswahl über Seitenwechsel.
+  Command-/Snapshot-Dauer und UI-Reaktionszeit messen; nur sichtbare Zeilen im
+  DOM, stabile Auswahl über virtuelle Bereiche.
 
 Wesentliche Restrisiken: Linear-Kommentarbindung ist nur anhand des
 Exports beobachtet; ExcelJS-Releasepflege und Roundtrip sind in R2 zu
@@ -515,7 +522,7 @@ externen Zustand begrenzt und nur nach verifiziertem Backup zulässig.
 Fehlende Zielparameter im Muster verlangen einen neuen vollständigen
 Linear-Export, keine geratenen GUID-Kommentare.
 
-**Freigabepunkt:** Der Nutzerauftrag verlangt wörtlich
-„R0. Audit (danach stoppen und Freigabe abwarten)“.
-Mit Freigabe dieses Vorschlags beginnt R1; R0 selbst autorisiert keine
-Installation, Migration oder Implementierung von R1–R10.
+**Freigabepunkt:** R0 wurde am 29.09.2026 mit den in R1 dokumentierten
+Korrekturen freigegeben. R2 besitzt einen neuen verbindlichen Freigabepunkt:
+Vor Beginn von R3 muss der Nutzer die in R2 erzeugte Rückgabedatei erfolgreich
+in Linear getestet haben.

From 52d3b1a2708d6f350676533b46e555d2a0eaf2b0 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 07:33:06 +0200
Subject: [PATCH 50/60] Add Linear Excel transport

---
 .gitignore                                    |   1 +
 docs/spec/revit-excel-phase-14-plan.md        |  20 +-
 package-lock.json                             | 811 ++++++++++++++++++
 package.json                                  |   3 +-
 scripts/verify-revit-reference-csv.ts         |  81 --
 scripts/verify-revit-reference-xlsx.ts        | 162 ++++
 .../xlsx/external-xlsx-contracts.ts           | 153 ++++
 .../xlsx/external-xlsx-transport.ts           | 582 +++++++++++++
 tests/external-xlsx-transport.test.ts         | 267 ++++++
 tests/fixtures/revit-xlsx-fixtures.ts         | 134 +++
 10 files changed, 2131 insertions(+), 83 deletions(-)
 delete mode 100644 scripts/verify-revit-reference-csv.ts
 create mode 100644 scripts/verify-revit-reference-xlsx.ts
 create mode 100644 src/external-model/xlsx/external-xlsx-contracts.ts
 create mode 100644 src/external-model/xlsx/external-xlsx-transport.ts
 create mode 100644 tests/external-xlsx-transport.test.ts
 create mode 100644 tests/fixtures/revit-xlsx-fixtures.ts

diff --git a/.gitignore b/.gitignore
index 911c16f..acbb157 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,4 @@ data/*.db
 data/backups/*.db
 .codex/*.log
 /docs/spec/kbp-Stromkreis.xlsx
+/data/revit-reference/*.xlsx
diff --git a/docs/spec/revit-excel-phase-14-plan.md b/docs/spec/revit-excel-phase-14-plan.md
index 46b4fba..bb00053 100644
--- a/docs/spec/revit-excel-phase-14-plan.md
+++ b/docs/spec/revit-excel-phase-14-plan.md
@@ -10,7 +10,7 @@ Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
 | --- | --- | --- |
 | R0 | abgeschlossen und freigegeben | Bestandsaudit, Zielmodell, Migration und Risiken; Freigabekorrekturen in R1 eingearbeitet. |
 | R1 | abgeschlossen | Anforderungen, Plan und Architektur auf Excel/Worksharing-ID umgestellt; alle Pflichtprüfungen bestanden. |
-| R2 | offen | XLSX-Adapter, Parser, synthetische Fixtures, lokaler Referenzprüfer und reale Rückgabedatei. Danach zwingende Linear-Abnahme durch den Nutzer. |
+| R2 | implementiert, Linear-Abnahme ausstehend | XLSX-Adapter, Parser, synthetische Fixtures, lokaler Referenzprüfer und reale Rückgabedatei sind erstellt. R3 bleibt bis zum erfolgreichen Linear-Test gesperrt. |
 | R3 | gesperrt bis R2-Abnahme | Konfiguration, Identität, Migration, Snapshot 10, Transfer und Backend-CSV-Entfernung. |
 | R4 | offen | Revit-Seite, Navigation, Einstellungen, altes Projektseitenmodal entfernen. |
 | R5 | offen | Erstimportwizard mit Gerätearten, Familienregeln und optionalen ProjectDevices. |
@@ -69,6 +69,24 @@ Danach stoppt die Arbeit. Der Nutzer testet diese Datei in Linear. Erst sein
 erfolgreicher Rückimport gibt R3 frei. Scheitert er, wird vor R3 ein konkreter
 OOXML-Patchadapter vorgeschlagen, der das Originalworkbook direkt ändert.
 
+Implementierungsstand vom 30.09.2026: Der Adapter liegt unter
+`src/external-model/xlsx`, der Referenzprüfer unter
+`scripts/verify-revit-reference-xlsx.ts`. Er hat aus der lokalen Musterdatei
+die ignorierte Datei
+`data/revit-reference/kbp-Stromkreis-R2-Rueckgabe.xlsx` erzeugt. Die Datei
+enthält 487 Objektzeilen in Originalreihenfolge, keine Summenzeile und gezielte
+Änderungen an den ersten drei Objekten. Synthetische Tests decken Zelltypen,
+Zahlenformate, Formelergebnisse, Kommentare, Breiten, Auswahl, exakte
+ID-Vergleiche und Grenzen ab.
+
+Für den Adapter ist `exceljs@4.4.0` als direkte Abhängigkeit aufgenommen. Der
+Produktionsaudit meldet dafür ausschließlich `uuid@8.3.2`: Die gemeldete
+Schwachstelle betrifft die UUID-Funktionen v3/v5 mit übergebenem Puffer;
+ExcelJS verwendet die Abhängigkeit nur für UUID v4 bei erweiterten bedingten
+Formatierungen. Dieser Adapter ruft keine UUID-Funktion auf. Weitere gemeldete
+Auditbefunde gehören zu bereits vorhandenen Abhängigkeiten und werden nicht im
+fachlich begrenzten R2-Paket aktualisiert.
+
 ## R3 – Datenmodell und Backend-Cutover
 
 - Konfiguration ohne eigene Versionszählung;
diff --git a/package-lock.json b/package-lock.json
index 417421b..9d27840 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12,6 +12,7 @@
         "better-sqlite3": "^12.9.0",
         "bootstrap": "^5.3.8",
         "drizzle-orm": "^0.45.2",
+        "exceljs": "^4.4.0",
         "express": "^5.2.1",
         "lucide-react": "^1.14.0",
         "next": "^16.2.4",
@@ -875,6 +876,47 @@
         "node": ">=18"
       }
     },
+    "node_modules/@fast-csv/format": {
+      "version": "4.3.5",
+      "resolved": "https://registry.npmjs.org/@fast-csv/format/-/format-4.3.5.tgz",
+      "integrity": "sha512-8iRn6QF3I8Ak78lNAa+Gdl5MJJBM5vRHivFtMRUWINdevNo00K7OXxS2PshawLKTejVwieIlPmK5YlLu6w4u8A==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "^14.0.1",
+        "lodash.escaperegexp": "^4.1.2",
+        "lodash.isboolean": "^3.0.3",
+        "lodash.isequal": "^4.5.0",
+        "lodash.isfunction": "^3.0.9",
+        "lodash.isnil": "^4.0.0"
+      }
+    },
+    "node_modules/@fast-csv/format/node_modules/@types/node": {
+      "version": "14.18.63",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-14.18.63.tgz",
+      "integrity": "sha512-fAtCfv4jJg+ExtXhvCkCqUKZ+4ok/JQk01qDKhL5BDDoS3AxKXhV5/MAVUZyQnSEd2GT92fkgZl0pz0Q0AzcIQ==",
+      "license": "MIT"
+    },
+    "node_modules/@fast-csv/parse": {
+      "version": "4.3.6",
+      "resolved": "https://registry.npmjs.org/@fast-csv/parse/-/parse-4.3.6.tgz",
+      "integrity": "sha512-uRsLYksqpbDmWaSmzvJcuApSEe38+6NQZBUsuAyMZKqHxH0g1wcJgsKUvN3WC8tewaqFjBMMGrkHmC+T7k8LvA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "^14.0.1",
+        "lodash.escaperegexp": "^4.1.2",
+        "lodash.groupby": "^4.6.0",
+        "lodash.isfunction": "^3.0.9",
+        "lodash.isnil": "^4.0.0",
+        "lodash.isundefined": "^3.0.1",
+        "lodash.uniq": "^4.5.0"
+      }
+    },
+    "node_modules/@fast-csv/parse/node_modules/@types/node": {
+      "version": "14.18.63",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-14.18.63.tgz",
+      "integrity": "sha512-fAtCfv4jJg+ExtXhvCkCqUKZ+4ok/JQk01qDKhL5BDDoS3AxKXhV5/MAVUZyQnSEd2GT92fkgZl0pz0Q0AzcIQ==",
+      "license": "MIT"
+    },
     "node_modules/@img/colour": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz",
@@ -1587,6 +1629,87 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/archiver": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/archiver/-/archiver-5.3.2.tgz",
+      "integrity": "sha512-+25nxyyznAXF7Nef3y0EbBeqmGZgeN/BxHX29Rs39djAfaFalmQ89SE6CWyDCHzGL0yt/ycBtNOmGTW0FyGWNw==",
+      "license": "MIT",
+      "dependencies": {
+        "archiver-utils": "^2.1.0",
+        "async": "^3.2.4",
+        "buffer-crc32": "^0.2.1",
+        "readable-stream": "^3.6.0",
+        "readdir-glob": "^1.1.2",
+        "tar-stream": "^2.2.0",
+        "zip-stream": "^4.1.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/archiver-utils": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/archiver-utils/-/archiver-utils-2.1.0.tgz",
+      "integrity": "sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw==",
+      "license": "MIT",
+      "dependencies": {
+        "glob": "^7.1.4",
+        "graceful-fs": "^4.2.0",
+        "lazystream": "^1.0.0",
+        "lodash.defaults": "^4.2.0",
+        "lodash.difference": "^4.5.0",
+        "lodash.flatten": "^4.4.0",
+        "lodash.isplainobject": "^4.0.6",
+        "lodash.union": "^4.6.0",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^2.0.0"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/archiver-utils/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/archiver-utils/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/archiver-utils/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/async": {
+      "version": "3.2.6",
+      "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+      "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
+      "license": "MIT"
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "license": "MIT"
+    },
     "node_modules/base64-js": {
       "version": "1.5.1",
       "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
@@ -1630,6 +1753,28 @@
         "node": "20.x || 22.x || 23.x || 24.x || 25.x"
       }
     },
+    "node_modules/big-integer": {
+      "version": "1.6.52",
+      "resolved": "https://registry.npmjs.org/big-integer/-/big-integer-1.6.52.tgz",
+      "integrity": "sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg==",
+      "license": "Unlicense",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/binary": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/binary/-/binary-0.3.0.tgz",
+      "integrity": "sha512-D4H1y5KYwpJgK8wk1Cue5LLPgmwHKYSChkbspQg5JtVuR5ulGckxfR62H3AE9UDkdMC8yyXlqYihuz3Aqg2XZg==",
+      "license": "MIT",
+      "dependencies": {
+        "buffers": "~0.1.1",
+        "chainsaw": "~0.1.0"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/bindings": {
       "version": "1.5.0",
       "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
@@ -1648,6 +1793,12 @@
         "readable-stream": "^3.4.0"
       }
     },
+    "node_modules/bluebird": {
+      "version": "3.4.7",
+      "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.4.7.tgz",
+      "integrity": "sha512-iD3898SR7sWVRHbiQv+sHUtHnMvC1o3nW5rAcqnq3uOn07DSAppZYUkIGslDz6gXC7HfunPe7YVBgoEJASPcHA==",
+      "license": "MIT"
+    },
     "node_modules/body-parser": {
       "version": "2.2.2",
       "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.2.tgz",
@@ -1689,6 +1840,16 @@
         "@popperjs/core": "^2.11.8"
       }
     },
+    "node_modules/brace-expansion": {
+      "version": "1.1.21",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.21.tgz",
+      "integrity": "sha512-9zeA+KLZNNzglF2TPKRQEDyx6Yby7daAkuy8MiPzpXPsYDWi/DRM8jmwUDxokQjYqBpv5DgPiwD4h4ZZSy1Ujw==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
     "node_modules/buffer": {
       "version": "5.7.1",
       "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
@@ -1712,12 +1873,38 @@
         "ieee754": "^1.1.13"
       }
     },
+    "node_modules/buffer-crc32": {
+      "version": "0.2.13",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+      "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/buffer-from": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
       "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
       "dev": true
     },
+    "node_modules/buffer-indexof-polyfill": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/buffer-indexof-polyfill/-/buffer-indexof-polyfill-1.0.2.tgz",
+      "integrity": "sha512-I7wzHwA3t1/lwXQh+A5PbNvJxgfo5r3xulgpYDB5zckTu/Z9oUK9biouBKQUjEqzaz3HnAT6TYoovmE+GqSf7A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/buffers": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/buffers/-/buffers-0.1.1.tgz",
+      "integrity": "sha512-9q/rDEGSb/Qsvv2qvzIzdluL5k7AaJOTrw23z9reQthrbF7is4CtlT0DXyO1oei2DCp4uojjzQ7igaSHp1kAEQ==",
+      "engines": {
+        "node": ">=0.2.0"
+      }
+    },
     "node_modules/bytes": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
@@ -1772,6 +1959,18 @@
         }
       ]
     },
+    "node_modules/chainsaw": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/chainsaw/-/chainsaw-0.1.0.tgz",
+      "integrity": "sha512-75kWfWt6MEKNC8xYXIdRpDehRYY/tNSgwKaJq+dbbDcxORuVrrQ+SEHoWsniVn9XPYfP4gmdWIeDk/4YNp1rNQ==",
+      "license": "MIT/X11",
+      "dependencies": {
+        "traverse": ">=0.3.0 <0.4"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/chownr": {
       "version": "1.1.4",
       "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz",
@@ -1782,6 +1981,27 @@
       "resolved": "https://registry.npmjs.org/client-only/-/client-only-0.0.1.tgz",
       "integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA=="
     },
+    "node_modules/compress-commons": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/compress-commons/-/compress-commons-4.1.2.tgz",
+      "integrity": "sha512-D3uMHtGc/fcO1Gt1/L7i1e33VOvD4A9hfQLP+6ewd+BvG/gQ84Yh4oftEhAdjSMgBgwGL+jsppT7JYNpo6MHHg==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-crc32": "^0.2.13",
+        "crc32-stream": "^4.0.2",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "license": "MIT"
+    },
     "node_modules/content-disposition": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.1.0.tgz",
@@ -1818,12 +2038,49 @@
         "node": ">=6.6.0"
       }
     },
+    "node_modules/core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+      "license": "MIT"
+    },
+    "node_modules/crc-32": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz",
+      "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==",
+      "license": "Apache-2.0",
+      "bin": {
+        "crc32": "bin/crc32.njs"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/crc32-stream": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/crc32-stream/-/crc32-stream-4.0.3.tgz",
+      "integrity": "sha512-NT7w2JVU7DFroFdYkeq8cywxrgjPHWkdX1wjpRQXPX5Asews3tA+Ght6lddQO5Mkumffp3X7GEqku3epj2toIw==",
+      "license": "MIT",
+      "dependencies": {
+        "crc-32": "^1.2.0",
+        "readable-stream": "^3.4.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
     "node_modules/csstype": {
       "version": "3.2.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
       "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
       "dev": true
     },
+    "node_modules/dayjs": {
+      "version": "1.11.23",
+      "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.23.tgz",
+      "integrity": "sha512-QDTCU0M0MxR3hQfnlDJfwekQiaanm1ubOD231u73WBckQ/fsamwRLiE2GBz6D3a/xF1NgfiDLJjXBa1hYOYTtQ==",
+      "license": "MIT"
+    },
     "node_modules/debug": {
       "version": "4.4.3",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
@@ -2030,6 +2287,45 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/duplexer2": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz",
+      "integrity": "sha512-asLFVfWWtJ90ZyOUHMqk7/S2w2guQKxUI2itj3d92ADHhxUSbCMGi1f1cBcJ7xM1To+pE/Khbwo1yuNbMEPKeA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "readable-stream": "^2.0.2"
+      }
+    },
+    "node_modules/duplexer2/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/duplexer2/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/duplexer2/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
     "node_modules/ee-first": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
@@ -2132,6 +2428,26 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/exceljs": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/exceljs/-/exceljs-4.4.0.tgz",
+      "integrity": "sha512-XctvKaEMaj1Ii9oDOqbW/6e1gXknSY4g/aLCDicOXqBE4M0nRWkUu0PTp++UPNzoFY12BNHMfs/VadKIS6llvg==",
+      "license": "MIT",
+      "dependencies": {
+        "archiver": "^5.0.0",
+        "dayjs": "^1.8.34",
+        "fast-csv": "^4.3.1",
+        "jszip": "^3.10.1",
+        "readable-stream": "^3.6.0",
+        "saxes": "^5.0.1",
+        "tmp": "^0.2.0",
+        "unzipper": "^0.10.11",
+        "uuid": "^8.3.0"
+      },
+      "engines": {
+        "node": ">=8.3.0"
+      }
+    },
     "node_modules/expand-template": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz",
@@ -2182,6 +2498,19 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/fast-csv": {
+      "version": "4.3.6",
+      "resolved": "https://registry.npmjs.org/fast-csv/-/fast-csv-4.3.6.tgz",
+      "integrity": "sha512-2RNSpuwwsJGP0frGsOmTb9oUF+VkFSM4SyLTDgwf2ciHWTarN0lQTC+F2f/t5J9QjW+c65VFIAAu85GsvMIusw==",
+      "license": "MIT",
+      "dependencies": {
+        "@fast-csv/format": "4.3.5",
+        "@fast-csv/parse": "4.3.6"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
     "node_modules/file-uri-to-path": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
@@ -2228,6 +2557,12 @@
       "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
       "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="
     },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "license": "ISC"
+    },
     "node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -2242,6 +2577,22 @@
         "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
       }
     },
+    "node_modules/fstream": {
+      "version": "1.0.12",
+      "resolved": "https://registry.npmjs.org/fstream/-/fstream-1.0.12.tgz",
+      "integrity": "sha512-WvJ193OHa0GHPEL+AycEJgxvBEwyfRkN1vhjca23OaPVMCaLCXTd5qAu82AjTcgP1UJmytkOKb63Ypde7raDIg==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "graceful-fs": "^4.1.2",
+        "inherits": "~2.0.0",
+        "mkdirp": ">=0.5 0",
+        "rimraf": "2"
+      },
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
     "node_modules/function-bind": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
@@ -2302,6 +2653,27 @@
       "resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz",
       "integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw=="
     },
+    "node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/gopd": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
@@ -2313,6 +2685,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "license": "ISC"
+    },
     "node_modules/has-symbols": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
@@ -2388,6 +2766,23 @@
         }
       ]
     },
+    "node_modules/immediate": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz",
+      "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==",
+      "license": "MIT"
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
     "node_modules/inherits": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
@@ -2411,6 +2806,190 @@
       "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
       "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ=="
     },
+    "node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+      "license": "MIT"
+    },
+    "node_modules/jszip": {
+      "version": "3.10.2",
+      "resolved": "https://registry.npmjs.org/jszip/-/jszip-3.10.2.tgz",
+      "integrity": "sha512-3l+rb15IOWtUhU0H5MFqES/T6Kh7abYwjosBey/vD6hDt8zoEffkSC5Ws5SGtgVw3gBx2NEbhTeSW1+kWkpyTQ==",
+      "license": "(MIT OR GPL-3.0-or-later)",
+      "dependencies": {
+        "lie": "~3.3.0",
+        "pako": "~1.0.2",
+        "readable-stream": "~2.3.6",
+        "setimmediate": "^1.0.5"
+      }
+    },
+    "node_modules/jszip/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/jszip/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/jszip/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/lazystream": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz",
+      "integrity": "sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==",
+      "license": "MIT",
+      "dependencies": {
+        "readable-stream": "^2.0.5"
+      },
+      "engines": {
+        "node": ">= 0.6.3"
+      }
+    },
+    "node_modules/lazystream/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/lazystream/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/lazystream/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/lie": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/lie/-/lie-3.3.0.tgz",
+      "integrity": "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "immediate": "~3.0.5"
+      }
+    },
+    "node_modules/listenercount": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/listenercount/-/listenercount-1.0.1.tgz",
+      "integrity": "sha512-3mk/Zag0+IJxeDrxSgaDPy4zZ3w05PRZeJNnlWhzFz5OkX49J4krc+A8X2d2M69vGMBEX0uyl8M+W+8gH+kBqQ==",
+      "license": "ISC"
+    },
+    "node_modules/lodash.defaults": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz",
+      "integrity": "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.difference": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.difference/-/lodash.difference-4.5.0.tgz",
+      "integrity": "sha512-dS2j+W26TQ7taQBGN8Lbbq04ssV3emRw4NY58WErlTO29pIqS0HmoT5aJ9+TUQ1N3G+JOZSji4eugsWwGp9yPA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.escaperegexp": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/lodash.escaperegexp/-/lodash.escaperegexp-4.1.2.tgz",
+      "integrity": "sha512-TM9YBvyC84ZxE3rgfefxUWiQKLilstD6k7PTGt6wfbtXF8ixIJLOL3VYyV/z+ZiPLsVxAsKAFVwWlWeb2Y8Yyw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.flatten": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz",
+      "integrity": "sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.groupby": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/lodash.groupby/-/lodash.groupby-4.6.0.tgz",
+      "integrity": "sha512-5dcWxm23+VAoz+awKmBaiBvzox8+RqMgFhi7UvX9DHZr2HdxHXM/Wrf8cfKpsW37RNrvtPn6hSwNqurSILbmJw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isboolean": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz",
+      "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isequal": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
+      "integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==",
+      "deprecated": "This package is deprecated. Use require('node:util').isDeepStrictEqual instead.",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isfunction": {
+      "version": "3.0.9",
+      "resolved": "https://registry.npmjs.org/lodash.isfunction/-/lodash.isfunction-3.0.9.tgz",
+      "integrity": "sha512-AirXNj15uRIMMPihnkInB4i3NHeb4iBtNg9WRWuK2o31S+ePwwNmDPaTL3o7dTJ+VXNZim7rFs4rxN4YU1oUJw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isnil": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/lodash.isnil/-/lodash.isnil-4.0.0.tgz",
+      "integrity": "sha512-up2Mzq3545mwVnMhTDMdfoG1OurpA/s5t88JmQX809eH3C8491iu2sfKhTfhQtKY78oPNhiaHJUpT/dUDAAtng==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isplainobject": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
+      "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isundefined": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/lodash.isundefined/-/lodash.isundefined-3.0.1.tgz",
+      "integrity": "sha512-MXB1is3s899/cD8jheYYE2V9qTHwKvt+npCwpD+1Sxm3Q3cECXCiYHjeHWXNwr6Q0SOBPrYUDxendrO6goVTEA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.union": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/lodash.union/-/lodash.union-4.6.0.tgz",
+      "integrity": "sha512-c4pB2CdGrGdjMKYLA+XiRDO7Y0PRQbm/Gzg8qMj+QH+pFVAoTp5sBpO0odL3FjoPCGjK96p6qsP+yQoiLoOBcw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.uniq": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz",
+      "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==",
+      "license": "MIT"
+    },
     "node_modules/lucide-react": {
       "version": "1.14.0",
       "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-1.14.0.tgz",
@@ -2480,6 +3059,18 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/minimist": {
       "version": "1.2.8",
       "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
@@ -2488,6 +3079,18 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/mkdirp": {
+      "version": "0.5.6",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",
+      "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",
+      "license": "MIT",
+      "dependencies": {
+        "minimist": "^1.2.6"
+      },
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      }
+    },
     "node_modules/mkdirp-classic": {
       "version": "0.5.3",
       "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
@@ -2591,6 +3194,15 @@
         "node": ">=10"
       }
     },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/object-inspect": {
       "version": "1.13.4",
       "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
@@ -2621,6 +3233,12 @@
         "wrappy": "1"
       }
     },
+    "node_modules/pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+      "license": "(MIT AND Zlib)"
+    },
     "node_modules/parseurl": {
       "version": "1.3.3",
       "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
@@ -2629,6 +3247,15 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/path-to-regexp": {
       "version": "8.4.2",
       "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.4.2.tgz",
@@ -2696,6 +3323,12 @@
         "node": ">=10"
       }
     },
+    "node_modules/process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "license": "MIT"
+    },
     "node_modules/proxy-addr": {
       "version": "2.0.7",
       "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
@@ -2799,6 +3432,36 @@
         "node": ">= 6"
       }
     },
+    "node_modules/readdir-glob": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/readdir-glob/-/readdir-glob-1.1.3.tgz",
+      "integrity": "sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "minimatch": "^5.1.0"
+      }
+    },
+    "node_modules/readdir-glob/node_modules/brace-expansion": {
+      "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.7.tgz",
+      "integrity": "sha512-uZbew1NqdmPDTMJ8ah1y+b+9QEJrfkXFk3RcTQw3X0jW/xRUvFKsg1CfQdSYGdTbXZWExtU3J3ccxtnfw1Fi0g==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/readdir-glob/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/resolve-pkg-maps": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
@@ -2808,6 +3471,19 @@
         "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
       }
     },
+    "node_modules/rimraf": {
+      "version": "2.7.1",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz",
+      "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==",
+      "deprecated": "Rimraf versions prior to v4 are no longer supported",
+      "license": "ISC",
+      "dependencies": {
+        "glob": "^7.1.3"
+      },
+      "bin": {
+        "rimraf": "bin.js"
+      }
+    },
     "node_modules/router": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
@@ -2847,6 +3523,18 @@
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
     },
+    "node_modules/saxes": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-5.0.1.tgz",
+      "integrity": "sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw==",
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
     "node_modules/scheduler": {
       "version": "0.27.0",
       "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
@@ -2906,6 +3594,12 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/setimmediate": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
+      "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==",
+      "license": "MIT"
+    },
     "node_modules/setprototypeof": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
@@ -3165,6 +3859,15 @@
         "node": ">=6"
       }
     },
+    "node_modules/tmp": {
+      "version": "0.2.7",
+      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.7.tgz",
+      "integrity": "sha512-e0votIpp4Uo2AJYSzVHV6xCcawuiez3DzqDAbrTc3YxBkplN6e+dM13ZeIcZnDg/QpSuU2zfZ3rzwY8ukEnaXw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
     "node_modules/toidentifier": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
@@ -3173,6 +3876,15 @@
         "node": ">=0.6"
       }
     },
+    "node_modules/traverse": {
+      "version": "0.3.9",
+      "resolved": "https://registry.npmjs.org/traverse/-/traverse-0.3.9.tgz",
+      "integrity": "sha512-iawgk0hLP3SxGKDfnDJf8wTz4p2qImnyihM5Hh/sGvQ3K37dPi/w8sRhdNIxYA1TwFwc5mDhIJq+O0RsvXBKdQ==",
+      "license": "MIT/X11",
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/tslib": {
       "version": "2.8.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
@@ -3706,11 +4418,69 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/unzipper": {
+      "version": "0.10.14",
+      "resolved": "https://registry.npmjs.org/unzipper/-/unzipper-0.10.14.tgz",
+      "integrity": "sha512-ti4wZj+0bQTiX2KmKWuwj7lhV+2n//uXEotUmGuQqrbVZSEGFMbI68+c6JCQ8aAmUWYvtHEz2A8K6wXvueR/6g==",
+      "license": "MIT",
+      "dependencies": {
+        "big-integer": "^1.6.17",
+        "binary": "~0.3.0",
+        "bluebird": "~3.4.1",
+        "buffer-indexof-polyfill": "~1.0.0",
+        "duplexer2": "~0.1.4",
+        "fstream": "^1.0.12",
+        "graceful-fs": "^4.2.2",
+        "listenercount": "~1.0.1",
+        "readable-stream": "~2.3.6",
+        "setimmediate": "~1.0.4"
+      }
+    },
+    "node_modules/unzipper/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/unzipper/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/unzipper/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
     "node_modules/util-deprecate": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
       "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
     },
+    "node_modules/uuid": {
+      "version": "8.3.2",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+      "deprecated": "uuid@10 and below is no longer supported.  For ESM codebases, update to uuid@latest.  For CommonJS codebases, use uuid@11 (but be aware this version will likely be deprecated in 2028).",
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
     "node_modules/vary": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
@@ -3724,6 +4494,47 @@
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
       "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
     },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "license": "MIT"
+    },
+    "node_modules/zip-stream": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-4.1.1.tgz",
+      "integrity": "sha512-9qv4rlDiopXg4E69k+vMHjNN63YFMe9sZMrdlvKnCjlCRWeCBswPPMPUfx+ipsAWq1LXHe70RcbaHdJJpS6hyQ==",
+      "license": "MIT",
+      "dependencies": {
+        "archiver-utils": "^3.0.4",
+        "compress-commons": "^4.1.2",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/zip-stream/node_modules/archiver-utils": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/archiver-utils/-/archiver-utils-3.0.4.tgz",
+      "integrity": "sha512-KVgf4XQVrTjhyWmx6cte4RxonPLR9onExufI1jhvw/MQ4BB6IsZD5gT8Lq+u/+pRkWna/6JoHpiQioaqFP5Rzw==",
+      "license": "MIT",
+      "dependencies": {
+        "glob": "^7.2.3",
+        "graceful-fs": "^4.2.0",
+        "lazystream": "^1.0.0",
+        "lodash.defaults": "^4.2.0",
+        "lodash.difference": "^4.5.0",
+        "lodash.flatten": "^4.4.0",
+        "lodash.isplainobject": "^4.0.6",
+        "lodash.union": "^4.6.0",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
     "node_modules/zod": {
       "version": "4.4.1",
       "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.1.tgz",
diff --git a/package.json b/package.json
index 414eb53..1c035ba 100644
--- a/package.json
+++ b/package.json
@@ -27,7 +27,7 @@
     "db:migrate": "drizzle-kit migrate",
     "db:backup": "tsx scripts/db-backup.ts",
     "db:verify:circuit-schema": "node scripts/db-verify-circuit-schema.js",
-    "revit:verify-reference": "tsx scripts/verify-revit-reference-csv.ts"
+    "revit:verify-reference": "tsx scripts/verify-revit-reference-xlsx.ts"
   },
   "keywords": [],
   "author": "",
@@ -36,6 +36,7 @@
     "better-sqlite3": "^12.9.0",
     "bootstrap": "^5.3.8",
     "drizzle-orm": "^0.45.2",
+    "exceljs": "^4.4.0",
     "express": "^5.2.1",
     "lucide-react": "^1.14.0",
     "next": "^16.2.4",
diff --git a/scripts/verify-revit-reference-csv.ts b/scripts/verify-revit-reference-csv.ts
deleted file mode 100644
index 07d605b..0000000
--- a/scripts/verify-revit-reference-csv.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { createHash } from "node:crypto";
-import { createDefaultExternalCsvConfiguration } from "../src/external-model/csv/external-csv-contracts.js";
-import {
-  parseExternalCsv,
-  serializeExternalCsv,
-} from "../src/external-model/csv/external-csv-transport.js";
-import { createExternalCsvPreview } from "../src/external-model/application/external-csv-preview.js";
-
-const filePath = resolve(
-  process.argv[2] ?? "docs/spec/ELT Stromkreisnummernvergabe-Check_DIV.csv"
-);
-const source = readFileSync(filePath);
-const configuration = createDefaultExternalCsvConfiguration({
-  ifcGuid: "IfcGUID",
-  roomNumber: "MEP-Raum: Nummer",
-  roomName: "MEP-Raum: Name",
-  familyAndType: "Familie und Typ",
-  selectionMarker: "CAx_Auswahlkenner",
-  circuitIdentifier: "kbp_Stromkreisnummer",
-  power: "kbp-E-Elektrische Leistung",
-  quantity: null,
-});
-configuration.additionalSourceMappings = [
-  { sourceColumn: "CAx_Anmerkung", targetField: "sourceRemark" },
-  { sourceColumn: "kbp-E-Spannung", targetField: "sourceVoltage" },
-  { sourceColumn: "kbp-E-Stromstärke", targetField: "sourceCurrent" },
-  { sourceColumn: "kbp-E-Versorgung von ELT", targetField: "sourceElectricalSupply" },
-  { sourceColumn: "kbp-E-Versorgung von MSR/GLT", targetField: "sourceControlSupply" },
-];
-
-const document = parseExternalCsv(source, configuration);
-const counts = Object.fromEntries(
-  ["metadata", "header", "passthrough", "object", "suspect-object"].map(
-    (classification) => [
-      classification,
-      document.rows.filter((row) => row.classification === classification).length,
-    ]
-  )
-);
-const nonEmptyPassthroughRows = document.rows.filter(
-  (row) =>
-    row.classification === "passthrough" &&
-    row.cells.some((cell) => cell.value !== "")
-).length;
-const serialized = serializeExternalCsv(document);
-const preview = createExternalCsvPreview({
-  fileName: filePath,
-  bytes: source,
-  configuration,
-});
-
-assert.equal(counts.object, 897, "Expected 897 object rows.");
-assert.equal(preview.objectCount, 897, "Expected 897 preview objects.");
-assert.equal(nonEmptyPassthroughRows, 211, "Expected 211 non-empty passthrough rows.");
-assert.equal(counts["suspect-object"], 0, "Expected no suspect object rows.");
-assert.equal(
-  Buffer.compare(Buffer.from(serialized), source),
-  0,
-  "Expected a byte-identical CSV round-trip."
-);
-
-const sha256 = createHash("sha256").update(source).digest("hex");
-process.stdout.write(
-  `${JSON.stringify(
-    {
-      file: filePath,
-      bytes: source.length,
-      sha256,
-      dialect: document.dialect,
-      rows: counts,
-      nonEmptyPassthroughRows,
-      roundTripByteIdentical: true,
-      previewObjectCount: preview.objectCount,
-    },
-    null,
-    2
-  )}\n`
-);
diff --git a/scripts/verify-revit-reference-xlsx.ts b/scripts/verify-revit-reference-xlsx.ts
new file mode 100644
index 0000000..ed568d4
--- /dev/null
+++ b/scripts/verify-revit-reference-xlsx.ts
@@ -0,0 +1,162 @@
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import ExcelJS from "exceljs";
+import {
+  createDefaultExternalXlsxTransportConfiguration,
+  type ExternalXlsxScalar,
+} from "../src/external-model/xlsx/external-xlsx-contracts.js";
+import {
+  createExternalXlsxReturn,
+  parseExternalXlsx,
+} from "../src/external-model/xlsx/external-xlsx-transport.js";
+
+async function main() {
+const inputPath = resolve(
+  process.argv[2] ?? "docs/spec/kbp-Stromkreis.xlsx"
+);
+const outputPath = resolve(
+  process.argv[3] ?? "data/revit-reference/kbp-Stromkreis-R2-Rueckgabe.xlsx"
+);
+assert.notEqual(
+  inputPath,
+  outputPath,
+  "Eingabe- und Ausgabedatei müssen verschieden sein."
+);
+
+const source = readFileSync(inputPath);
+const configuration = createDefaultExternalXlsxTransportConfiguration();
+const document = await parseExternalXlsx({
+  fileName: inputPath,
+  bytes: source,
+  configuration,
+});
+const objectRows = document.rows.filter((row) => row.classification === "object");
+const suspectRows = document.rows.filter(
+  (row) => row.classification === "suspect-object"
+);
+const worksharingIdColumn = document.columns.find(
+  (column) => column.header === configuration.columns.worksharingId
+)?.columnNumber;
+assert.ok(worksharingIdColumn, "Worksharing-ID-Spalte wurde nicht aufgelöst.");
+
+assert.equal(objectRows.length, 487, "Es werden 487 Objektzeilen erwartet.");
+assert.equal(suspectRows.length, 0, "Es werden keine verdächtigen Zeilen erwartet.");
+assert.equal(
+  document.columns.filter((column) => column.comment !== null).length,
+  14,
+  "Es werden 14 Kopfzeilenkommentare erwartet."
+);
+assert.equal(
+  document.issues.filter((issue) => issue.code === "duplicate-ifc-guid").length,
+  0,
+  "Die Musterdatei darf keine exakten IfcGUID-Duplikate enthalten."
+);
+
+const testValues = [
+  {
+    circuitCombined: "UV_R2_TEST-2F1",
+    electricalPowerW: 111,
+    voltageV: 230,
+    currentA: 0.48,
+  },
+  {
+    circuitCombined: "UV_R2_TEST-2F2",
+    electricalPowerW: 222,
+    voltageV: 230,
+    currentA: 0.97,
+  },
+  {
+    circuitCombined: "UV_R2_TEST-3F1",
+    electricalPowerW: 333,
+    voltageV: 400,
+    currentA: 0.48,
+  },
+] satisfies Record<string, ExternalXlsxScalar>[];
+
+const updates = testValues.map((values, index) => {
+  const value = objectRows[index]?.cells[worksharingIdColumn - 1]?.value;
+  if (typeof value !== "string") {
+    throw new Error("Worksharing-ID muss Text sein.");
+  }
+  return { worksharingId: value, values };
+});
+const result = await createExternalXlsxReturn({
+  fileName: inputPath,
+  bytes: source,
+  configuration,
+  updates,
+});
+assert.equal(result.exportedObjectCount, 487);
+mkdirSync(dirname(outputPath), { recursive: true });
+writeFileSync(outputPath, result.bytes);
+
+const outputDocument = await parseExternalXlsx({
+  fileName: outputPath,
+  bytes: result.bytes,
+  configuration,
+});
+assert.equal(
+  outputDocument.rows.filter((row) => row.classification === "object").length,
+  487
+);
+assert.equal(
+  outputDocument.rows.some((row) => row.classification !== "object"),
+  false,
+  "Die Rückgabedatei darf keine Summen- oder Hinweiszeilen enthalten."
+);
+assert.equal(outputDocument.sheetName, document.sheetName);
+assert.deepEqual(
+  outputDocument.columns,
+  document.columns,
+  "Kopfzeilen, Kommentare und Spaltenbreiten müssen erhalten bleiben."
+);
+assert.deepEqual(
+  outputDocument.rows.slice(updates.length).map((row) => row.cells),
+  objectRows.slice(updates.length).map((row) => row.cells),
+  "Nicht geänderte Objektzellen müssen Wert, Typ und Zahlenformat behalten."
+);
+const outputWorkbook = new ExcelJS.Workbook();
+await outputWorkbook.xlsx.load(result.bytes as never);
+const commentedCells: string[] = [];
+outputWorkbook.worksheets[0].eachRow({ includeEmpty: true }, (row) => {
+  row.eachCell({ includeEmpty: true }, (cell) => {
+    if (cell.note !== undefined) commentedCells.push(cell.address);
+  });
+});
+assert.equal(
+  commentedCells.length,
+  14,
+  "Nur die 14 Kopfzellen dürfen Kommentare enthalten."
+);
+assert.equal(
+  commentedCells.every((address) => address.endsWith("1")),
+  true,
+  "Datenzellen dürfen keine Kommentare enthalten."
+);
+
+process.stdout.write(
+  `${JSON.stringify(
+    {
+      input: inputPath,
+      output: outputPath,
+      inputBytes: source.length,
+      outputBytes: result.bytes.length,
+      inputSha256: createHash("sha256").update(source).digest("hex"),
+      outputSha256: createHash("sha256").update(result.bytes).digest("hex"),
+      sheetName: document.sheetName,
+      objectCount: objectRows.length,
+      headerCommentCount: document.columns.filter(
+        (column) => column.comment !== null
+      ).length,
+      exactDuplicateIfcGuidCount: 0,
+      changedObjectCount: updates.length,
+    },
+    null,
+    2
+  )}\n`
+);
+}
+
+void main();
diff --git a/src/external-model/xlsx/external-xlsx-contracts.ts b/src/external-model/xlsx/external-xlsx-contracts.ts
new file mode 100644
index 0000000..94c7b45
--- /dev/null
+++ b/src/external-model/xlsx/external-xlsx-contracts.ts
@@ -0,0 +1,153 @@
+export const MAX_EXTERNAL_XLSX_BYTES = 10 * 1024 * 1024;
+
+export const DEFAULT_EXTERNAL_XLSX_LIMITS = {
+  maxRows: 50_000,
+  maxColumns: 256,
+  maxCells: 2_000_000,
+} as const;
+
+export type ExternalXlsxScalar = string | number | boolean | null;
+
+export interface ExternalXlsxCell {
+  columnNumber: number;
+  value: ExternalXlsxScalar;
+  valueType: "empty" | "string" | "number" | "boolean";
+  numberFormat: string | null;
+  formula: string | null;
+  usedCachedFormulaValue: boolean;
+}
+
+export type ExternalXlsxRowClassification =
+  | "object"
+  | "suspect-object"
+  | "passthrough";
+
+export interface ExternalXlsxRow {
+  rowNumber: number;
+  classification: ExternalXlsxRowClassification;
+  cells: ExternalXlsxCell[];
+}
+
+export interface ExternalXlsxColumn {
+  columnNumber: number;
+  header: string;
+  comment: string | null;
+  width: number | null;
+}
+
+export type ExternalXlsxIssueCode =
+  | "cached-formula-value-used"
+  | "formula-without-cached-value"
+  | "suspect-object-skipped"
+  | "duplicate-ifc-guid"
+  | "optional-return-column-missing";
+
+export interface ExternalXlsxIssue {
+  code: ExternalXlsxIssueCode;
+  message: string;
+  rowNumber?: number;
+  columnNumber?: number;
+  field?: ExternalXlsxColumnKey;
+}
+
+export interface ExternalXlsxDocument {
+  sheetName: string;
+  headerRowNumber: number;
+  firstDataRowNumber: number;
+  firstDataColumnNumber: number;
+  columns: ExternalXlsxColumn[];
+  rows: ExternalXlsxRow[];
+  issues: ExternalXlsxIssue[];
+}
+
+export interface ExternalXlsxLayoutConfiguration {
+  headerRow: number;
+  firstDataRow: number;
+  firstDataColumn: number;
+}
+
+export type ExternalXlsxCircuitMode = "combined" | "separate";
+
+export interface ExternalXlsxColumnConfiguration {
+  worksharingId: string;
+  ifcGuid: string | null;
+  roomNumber: string | null;
+  roomName: string | null;
+  familyAndType: string;
+  selectionMarker: string | null;
+  socketCount: string | null;
+  sourceRemark: string | null;
+  circuitCombined: string | null;
+  boardName: string | null;
+  circuitIdentifier: string | null;
+  designation: string | null;
+  electricalPowerW: string | null;
+  voltageV: string | null;
+  currentA: string | null;
+}
+
+export type ExternalXlsxColumnKey = keyof ExternalXlsxColumnConfiguration;
+
+export interface ExternalXlsxTransportConfiguration {
+  layout: ExternalXlsxLayoutConfiguration;
+  circuitMode: ExternalXlsxCircuitMode;
+  columns: ExternalXlsxColumnConfiguration;
+}
+
+export interface ExternalXlsxLimits {
+  maxRows: number;
+  maxColumns: number;
+  maxCells: number;
+}
+
+export type ExternalXlsxReturnValues = Partial<
+  Record<
+    | "circuitCombined"
+    | "boardName"
+    | "circuitIdentifier"
+    | "designation"
+    | "electricalPowerW"
+    | "voltageV"
+    | "currentA",
+    ExternalXlsxScalar
+  >
+>;
+
+export interface ExternalXlsxReturnUpdate {
+  worksharingId: string;
+  values: ExternalXlsxReturnValues;
+}
+
+export interface ExternalXlsxReturnResult {
+  bytes: Uint8Array;
+  exportedObjectCount: number;
+  issues: ExternalXlsxIssue[];
+}
+
+export function createDefaultExternalXlsxTransportConfiguration(): ExternalXlsxTransportConfiguration {
+  return {
+    layout: {
+      headerRow: 1,
+      firstDataRow: 3,
+      firstDataColumn: 1,
+    },
+    circuitMode: "combined",
+    columns: {
+      worksharingId: "Worksharing-ID",
+      ifcGuid: "IfcGUID",
+      roomNumber: "MEP-Raum: Nummer",
+      roomName: "MEP-Raum: Name",
+      familyAndType: "Familie und Typ",
+      selectionMarker: "CAx_Auswahlkenner",
+      socketCount: "CAX_AnzahlObjekte",
+      sourceRemark: "CAx_Anmerkung",
+      circuitCombined: "kbp_Stromkreisnummer",
+      boardName: "kbp-E-Verteiler",
+      circuitIdentifier: "kbp-E-Stromkreis",
+      designation: "kbp-E-Bezeichnung",
+      electricalPowerW: "kbp-E-Elektrische Leistung",
+      voltageV: "kbp-E-Spannung",
+      currentA: "kbp-E-Stromstärke",
+    },
+  };
+}
diff --git a/src/external-model/xlsx/external-xlsx-transport.ts b/src/external-model/xlsx/external-xlsx-transport.ts
new file mode 100644
index 0000000..31cc707
--- /dev/null
+++ b/src/external-model/xlsx/external-xlsx-transport.ts
@@ -0,0 +1,582 @@
+import ExcelJS from "exceljs";
+import type { CellValue, Worksheet } from "exceljs";
+import {
+  DEFAULT_EXTERNAL_XLSX_LIMITS,
+  MAX_EXTERNAL_XLSX_BYTES,
+  type ExternalXlsxCell,
+  type ExternalXlsxColumnKey,
+  type ExternalXlsxDocument,
+  type ExternalXlsxIssue,
+  type ExternalXlsxLimits,
+  type ExternalXlsxReturnResult,
+  type ExternalXlsxReturnUpdate,
+  type ExternalXlsxScalar,
+  type ExternalXlsxTransportConfiguration,
+} from "./external-xlsx-contracts.js";
+
+export type ExternalXlsxErrorCode =
+  | "invalid-file-extension"
+  | "file-too-large"
+  | "invalid-workbook"
+  | "worksheet-count"
+  | "worksheet-too-large"
+  | "invalid-layout"
+  | "header-not-found"
+  | "ambiguous-header"
+  | "required-formula-result-missing"
+  | "invalid-worksharing-id"
+  | "duplicate-worksharing-id"
+  | "return-circuit-column-missing"
+  | "unknown-worksharing-id";
+
+export class ExternalXlsxError extends Error {
+  constructor(
+    public readonly code: ExternalXlsxErrorCode,
+    message: string
+  ) {
+    super(message);
+    this.name = "ExternalXlsxError";
+  }
+}
+
+export interface ParseExternalXlsxInput {
+  fileName: string;
+  bytes: Uint8Array;
+  configuration: ExternalXlsxTransportConfiguration;
+  limits?: ExternalXlsxLimits;
+}
+
+export interface CreateExternalXlsxReturnInput extends ParseExternalXlsxInput {
+  selectedWorksharingIds?: readonly string[];
+  updates?: readonly ExternalXlsxReturnUpdate[];
+}
+
+export async function parseExternalXlsx(
+  input: ParseExternalXlsxInput
+): Promise<ExternalXlsxDocument> {
+  assertUpload(input.fileName, input.bytes);
+  assertConfiguration(input.configuration);
+  const workbook = await loadWorkbook(input.bytes);
+  const worksheet = getOnlyWorksheet(workbook);
+  assertWorksheetLimits(
+    worksheet,
+    input.limits ?? DEFAULT_EXTERNAL_XLSX_LIMITS
+  );
+  return parseWorksheet(worksheet, input.configuration);
+}
+
+export async function createExternalXlsxReturn(
+  input: CreateExternalXlsxReturnInput
+): Promise<ExternalXlsxReturnResult> {
+  assertUpload(input.fileName, input.bytes);
+  assertConfiguration(input.configuration);
+  const workbook = await loadWorkbook(input.bytes);
+  const worksheet = getOnlyWorksheet(workbook);
+  assertWorksheetLimits(
+    worksheet,
+    input.limits ?? DEFAULT_EXTERNAL_XLSX_LIMITS
+  );
+  const document = parseWorksheet(worksheet, input.configuration);
+  const headerLookup = createHeaderLookup(worksheet, input.configuration);
+  const issues = [...document.issues];
+  const returnColumns = resolveReturnColumns(
+    headerLookup,
+    input.configuration,
+    issues
+  );
+  const worksharingIdColumn = headerLookup.get(
+    input.configuration.columns.worksharingId
+  )!;
+  const objectRows = document.rows.filter((row) => row.classification === "object");
+  const objectRowById = new Map(
+    objectRows.map((row) => [
+      scalarToIdentity(row.cells[worksharingIdColumn - 1]?.value ?? null),
+      row.rowNumber,
+    ])
+  );
+  const selectedIds = input.selectedWorksharingIds
+    ? new Set(input.selectedWorksharingIds)
+    : new Set(objectRowById.keys());
+  for (const worksharingId of selectedIds) {
+    if (!objectRowById.has(worksharingId)) {
+      throw new ExternalXlsxError(
+        "unknown-worksharing-id",
+        `Die Worksharing-ID ist im Workbook nicht vorhanden: ${worksharingId}`
+      );
+    }
+  }
+  const updates = new Map(
+    (input.updates ?? []).map((update) => [update.worksharingId, update.values])
+  );
+  for (const worksharingId of updates.keys()) {
+    if (!objectRowById.has(worksharingId)) {
+      throw new ExternalXlsxError(
+        "unknown-worksharing-id",
+        `Die Worksharing-ID ist im Workbook nicht vorhanden: ${worksharingId}`
+      );
+    }
+  }
+
+  const selectedRows = objectRows.filter((row) => {
+    const id = scalarToIdentity(row.cells[worksharingIdColumn - 1]?.value ?? null);
+    return selectedIds.has(id);
+  });
+  const lastColumn = worksheet.columnCount;
+  const snapshots = selectedRows.map((row) =>
+    captureRow(worksheet, row.rowNumber, lastColumn)
+  );
+  snapshots.forEach((snapshot, index) => {
+    restoreRow(
+      worksheet,
+      input.configuration.layout.firstDataRow + index,
+      snapshot,
+      lastColumn
+    );
+    const destinationRow = worksheet.getRow(
+      input.configuration.layout.firstDataRow + index
+    );
+    const id = scalarToIdentity(destinationRow.getCell(worksharingIdColumn).value);
+    const values = updates.get(id);
+    if (!values) return;
+    for (const [field, value] of Object.entries(values) as [
+      keyof typeof values,
+      ExternalXlsxScalar,
+    ][]) {
+      const columnNumber = returnColumns.get(field);
+      if (columnNumber !== undefined) {
+        destinationRow.getCell(columnNumber).value = value;
+      }
+    }
+  });
+
+  const firstRemovedRow =
+    input.configuration.layout.firstDataRow + snapshots.length;
+  const removeCount = Math.max(0, worksheet.rowCount - firstRemovedRow + 1);
+  // ExcelJS 4.4 does not shrink its internal row array when a multi-row
+  // splice removes the complete tail. Removing the tail one row at a time
+  // produces an actual OOXML deletion instead of serialized empty rows.
+  for (let index = 0; index < removeCount; index += 1) {
+    worksheet.spliceRows(worksheet.rowCount, 1);
+  }
+  const buffer = await workbook.xlsx.writeBuffer();
+  return {
+    bytes: new Uint8Array(buffer),
+    exportedObjectCount: snapshots.length,
+    issues,
+  };
+}
+
+function parseWorksheet(
+  worksheet: Worksheet,
+  configuration: ExternalXlsxTransportConfiguration
+): ExternalXlsxDocument {
+  const headerLookup = createHeaderLookup(worksheet, configuration);
+  const issues: ExternalXlsxIssue[] = [];
+  const worksharingIdColumn = headerLookup.get(configuration.columns.worksharingId)!;
+  const familyAndTypeColumn = headerLookup.get(configuration.columns.familyAndType)!;
+  const ifcGuidColumn = configuration.columns.ifcGuid
+    ? headerLookup.get(configuration.columns.ifcGuid)
+    : undefined;
+  const seenWorksharingIds = new Set<string>();
+  const seenIfcGuids = new Set<string>();
+  const rows = [] as ExternalXlsxDocument["rows"];
+
+  for (
+    let rowNumber = configuration.layout.firstDataRow;
+    rowNumber <= worksheet.rowCount;
+    rowNumber += 1
+  ) {
+    const row = worksheet.getRow(rowNumber);
+    const cells: ExternalXlsxCell[] = [];
+    for (let columnNumber = 1; columnNumber <= worksheet.columnCount; columnNumber += 1) {
+      cells.push(
+        toExternalCell(row.getCell(columnNumber), rowNumber, columnNumber, issues)
+      );
+    }
+    const worksharingIdCell = cells[worksharingIdColumn - 1];
+    const familyAndTypeCell = cells[familyAndTypeColumn - 1];
+    for (const [field, requiredCell] of [
+      ["Worksharing-ID", worksharingIdCell],
+      ["Familie und Typ", familyAndTypeCell],
+    ] as const) {
+      if (requiredCell?.formula != null && !requiredCell.usedCachedFormulaValue) {
+        throw new ExternalXlsxError(
+          "required-formula-result-missing",
+          `Das Pflichtfeld ${field} hat in Zeile ${rowNumber} kein gespeichertes Formelergebnis.`
+        );
+      }
+    }
+    const worksharingId = scalarToIdentity(worksharingIdCell?.value ?? null);
+    const familyAndType = scalarToIdentity(familyAndTypeCell?.value ?? null);
+    if (!worksharingId) {
+      const classification = familyAndType ? "suspect-object" : "passthrough";
+      if (classification === "suspect-object") {
+        issues.push({
+          code: "suspect-object-skipped",
+          message: `Zeile ${rowNumber} enthält Familie und Typ, aber keine Worksharing-ID, und wird übersprungen.`,
+          rowNumber,
+        });
+      }
+      rows.push({ rowNumber, classification, cells });
+      continue;
+    }
+    if (!isWorksharingId(worksharingId)) {
+      throw new ExternalXlsxError(
+        "invalid-worksharing-id",
+        `Zeile ${rowNumber} enthält eine ungültige Worksharing-ID.`
+      );
+    }
+    if (seenWorksharingIds.has(worksharingId)) {
+      throw new ExternalXlsxError(
+        "duplicate-worksharing-id",
+        `Die Worksharing-ID kommt mehrfach vor: ${worksharingId}`
+      );
+    }
+    seenWorksharingIds.add(worksharingId);
+    if (ifcGuidColumn !== undefined) {
+      const ifcGuid = scalarToIdentity(cells[ifcGuidColumn - 1]?.value ?? null);
+      if (ifcGuid) {
+        if (seenIfcGuids.has(ifcGuid)) {
+          issues.push({
+            code: "duplicate-ifc-guid",
+            message: `IfcGUID kommt mehrfach vor: ${ifcGuid}`,
+            rowNumber,
+            columnNumber: ifcGuidColumn,
+            field: "ifcGuid",
+          });
+        }
+        seenIfcGuids.add(ifcGuid);
+      }
+    }
+    rows.push({ rowNumber, classification: "object", cells });
+  }
+
+  const headerRow = worksheet.getRow(configuration.layout.headerRow);
+  const columns = [] as ExternalXlsxDocument["columns"];
+  for (let columnNumber = 1; columnNumber <= worksheet.columnCount; columnNumber += 1) {
+    const cell = headerRow.getCell(columnNumber);
+    columns.push({
+      columnNumber,
+      header: scalarToIdentity(toScalar(cell.value).value),
+      comment: getCommentText(cell.note),
+      width: worksheet.getColumn(columnNumber).width ?? null,
+    });
+  }
+  return {
+    sheetName: worksheet.name,
+    headerRowNumber: configuration.layout.headerRow,
+    firstDataRowNumber: configuration.layout.firstDataRow,
+    firstDataColumnNumber: configuration.layout.firstDataColumn,
+    columns,
+    rows,
+    issues,
+  };
+}
+
+function createHeaderLookup(
+  worksheet: Worksheet,
+  configuration: ExternalXlsxTransportConfiguration
+) {
+  const headers = new Map<string, number[]>();
+  const row = worksheet.getRow(configuration.layout.headerRow);
+  for (
+    let columnNumber = configuration.layout.firstDataColumn;
+    columnNumber <= worksheet.columnCount;
+    columnNumber += 1
+  ) {
+    const header = scalarToIdentity(toScalar(row.getCell(columnNumber).value).value);
+    if (!header) continue;
+    headers.set(header, [...(headers.get(header) ?? []), columnNumber]);
+  }
+  const configured = Object.entries(configuration.columns) as [
+    ExternalXlsxColumnKey,
+    string | null,
+  ][];
+  const required = new Set<ExternalXlsxColumnKey>(["worksharingId", "familyAndType"]);
+  const lookup = new Map<string, number>();
+  for (const [field, header] of configured) {
+    if (header === null) continue;
+    const matches = headers.get(header) ?? [];
+    if (matches.length > 1) {
+      throw new ExternalXlsxError(
+        "ambiguous-header",
+        `Die konfigurierte Kopfzelle ist nicht eindeutig: ${header}`
+      );
+    }
+    if (matches.length === 0 && required.has(field)) {
+      throw new ExternalXlsxError(
+        "header-not-found",
+        `Die konfigurierte Pflichtspalte fehlt: ${header}`
+      );
+    }
+    if (matches.length === 1) lookup.set(header, matches[0]);
+  }
+  return lookup;
+}
+
+function resolveReturnColumns(
+  headerLookup: Map<string, number>,
+  configuration: ExternalXlsxTransportConfiguration,
+  issues: ExternalXlsxIssue[]
+) {
+  const result = new Map<keyof ExternalXlsxReturnUpdate["values"], number>();
+  const circuitFields: ("circuitCombined" | "boardName" | "circuitIdentifier")[] =
+    configuration.circuitMode === "combined"
+      ? ["circuitCombined"]
+      : ["boardName", "circuitIdentifier"];
+  for (const field of circuitFields) {
+    const header = configuration.columns[field];
+    const columnNumber = header === null ? undefined : headerLookup.get(header);
+    if (columnNumber === undefined) {
+      throw new ExternalXlsxError(
+        "return-circuit-column-missing",
+        `Die Stromkreisspalte des gewählten Modus fehlt: ${field}`
+      );
+    }
+    result.set(field, columnNumber);
+  }
+  const optionalFields = [
+    "designation",
+    "electricalPowerW",
+    "voltageV",
+    "currentA",
+  ] as const;
+  for (const field of optionalFields) {
+    const header = configuration.columns[field];
+    const columnNumber = header === null ? undefined : headerLookup.get(header);
+    if (columnNumber === undefined) {
+      issues.push({
+        code: "optional-return-column-missing",
+        message: `Die optionale Rückgabespalte fehlt und wird übersprungen: ${field}`,
+        field,
+      });
+    } else {
+      result.set(field, columnNumber);
+    }
+  }
+  return result;
+}
+
+function toExternalCell(
+  cell: ExcelJS.Cell,
+  rowNumber: number,
+  columnNumber: number,
+  issues: ExternalXlsxIssue[]
+): ExternalXlsxCell {
+  const converted = toScalar(cell.value);
+  if (converted.formula !== null) {
+    issues.push({
+      code: converted.usedCachedFormulaValue
+        ? "cached-formula-value-used"
+        : "formula-without-cached-value",
+      message: converted.usedCachedFormulaValue
+        ? `Formel in Zeile ${rowNumber}, Spalte ${columnNumber} wird mit ihrem gespeicherten Ergebnis gelesen.`
+        : `Formel in Zeile ${rowNumber}, Spalte ${columnNumber} hat kein nutzbares gespeichertes Ergebnis und bleibt leer.`,
+      rowNumber,
+      columnNumber,
+    });
+  }
+  return {
+    columnNumber,
+    value: converted.value,
+    valueType: getScalarValueType(converted.value),
+    numberFormat: cell.numFmt || null,
+    formula: converted.formula,
+    usedCachedFormulaValue: converted.usedCachedFormulaValue,
+  };
+}
+
+function toScalar(value: CellValue): {
+  value: ExternalXlsxScalar;
+  formula: string | null;
+  usedCachedFormulaValue: boolean;
+} {
+  if (value === null || value === undefined) {
+    return { value: null, formula: null, usedCachedFormulaValue: false };
+  }
+  if (
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  ) {
+    return { value, formula: null, usedCachedFormulaValue: false };
+  }
+  if (value instanceof Date) {
+    return { value: value.toISOString(), formula: null, usedCachedFormulaValue: false };
+  }
+  if ("formula" in value || "sharedFormula" in value) {
+    const formula =
+      ("formula" in value ? value.formula : value.sharedFormula) ?? "";
+    const result = "result" in value ? value.result : undefined;
+    if (
+      typeof result === "string" ||
+      typeof result === "number" ||
+      typeof result === "boolean"
+    ) {
+      return { value: result, formula, usedCachedFormulaValue: true };
+    }
+    return { value: null, formula, usedCachedFormulaValue: false };
+  }
+  if ("error" in value) {
+    return { value: null, formula: null, usedCachedFormulaValue: false };
+  }
+  if ("richText" in value) {
+    return {
+      value: value.richText.map((part) => part.text).join(""),
+      formula: null,
+      usedCachedFormulaValue: false,
+    };
+  }
+  if ("text" in value) {
+    return { value: value.text, formula: null, usedCachedFormulaValue: false };
+  }
+  return { value: null, formula: null, usedCachedFormulaValue: false };
+}
+
+function captureRow(worksheet: Worksheet, rowNumber: number, lastColumn: number) {
+  const row = worksheet.getRow(rowNumber);
+  return {
+    height: row.height,
+    cells: Array.from({ length: lastColumn }, (_, index) => {
+      const cell = row.getCell(index + 1);
+      const converted = toScalar(cell.value);
+      return {
+        value: converted.formula === null ? cloneValue(cell.value) : converted.value,
+        style: structuredClone(cell.style),
+        note: cell.note === undefined ? undefined : structuredClone(cell.note),
+      };
+    }),
+  };
+}
+
+function restoreRow(
+  worksheet: Worksheet,
+  rowNumber: number,
+  snapshot: ReturnType<typeof captureRow>,
+  lastColumn: number
+) {
+  const row = worksheet.getRow(rowNumber);
+  row.height = snapshot.height;
+  for (let columnNumber = 1; columnNumber <= lastColumn; columnNumber += 1) {
+    const cell = row.getCell(columnNumber);
+    const source = snapshot.cells[columnNumber - 1];
+    cell.value = source.value;
+    cell.style = structuredClone(source.style);
+    if (source.note === undefined) {
+      // ExcelJS has no public comment-removal API. Its note setter creates a
+      // Note even for undefined, which would add an empty comment to the cell.
+      (cell as unknown as { _comment?: unknown })._comment = undefined;
+    } else {
+      cell.note = source.note;
+    }
+  }
+}
+
+function cloneValue(value: CellValue): CellValue {
+  if (value instanceof Date) return new Date(value);
+  if (value && typeof value === "object") return structuredClone(value);
+  return value;
+}
+
+function getCommentText(note: ExcelJS.Cell["note"]): string | null {
+  if (note === undefined) return null;
+  if (typeof note === "string") return note;
+  return note.texts?.map((part) => part.text).join("") ?? null;
+}
+
+function getScalarValueType(value: ExternalXlsxScalar): ExternalXlsxCell["valueType"] {
+  if (value === null) return "empty";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  return "boolean";
+}
+
+function scalarToIdentity(value: ExternalXlsxScalar | CellValue): string {
+  const scalar =
+    typeof value === "object" && value !== null ? toScalar(value).value : value;
+  return typeof scalar === "string" ? scalar : scalar === null ? "" : String(scalar);
+}
+
+function isWorksharingId(value: string) {
+  return /^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}-[0-9A-Fa-f]{8}$/.test(
+    value
+  );
+}
+
+function assertUpload(fileName: string, bytes: Uint8Array) {
+  if (!fileName.toLocaleLowerCase("en-US").endsWith(".xlsx")) {
+    throw new ExternalXlsxError(
+      "invalid-file-extension",
+      "Es werden ausschließlich .xlsx-Dateien unterstützt."
+    );
+  }
+  if (bytes.byteLength > MAX_EXTERNAL_XLSX_BYTES) {
+    throw new ExternalXlsxError(
+      "file-too-large",
+      "Die XLSX-Datei darf höchstens 10 MiB groß sein."
+    );
+  }
+}
+
+async function loadWorkbook(bytes: Uint8Array) {
+  const workbook = new ExcelJS.Workbook();
+  try {
+    await workbook.xlsx.load(
+      Buffer.from(bytes) as unknown as Parameters<typeof workbook.xlsx.load>[0]
+    );
+  } catch (error) {
+    throw new ExternalXlsxError(
+      "invalid-workbook",
+      `Die XLSX-Datei konnte nicht gelesen werden: ${error instanceof Error ? error.message : "Unbekannter Fehler"}`
+    );
+  }
+  return workbook;
+}
+
+function getOnlyWorksheet(workbook: ExcelJS.Workbook) {
+  if (workbook.worksheets.length !== 1) {
+    throw new ExternalXlsxError(
+      "worksheet-count",
+      "Die XLSX-Datei muss genau ein Arbeitsblatt enthalten."
+    );
+  }
+  return workbook.worksheets[0];
+}
+
+function assertWorksheetLimits(worksheet: Worksheet, limits: ExternalXlsxLimits) {
+  const rowCount = worksheet.rowCount;
+  const columnCount = worksheet.columnCount;
+  if (
+    rowCount > limits.maxRows ||
+    columnCount > limits.maxColumns ||
+    rowCount * columnCount > limits.maxCells
+  ) {
+    throw new ExternalXlsxError(
+      "worksheet-too-large",
+      `Das Arbeitsblatt überschreitet die Grenzen (${rowCount} Zeilen, ${columnCount} Spalten).`
+    );
+  }
+}
+
+function assertConfiguration(configuration: ExternalXlsxTransportConfiguration) {
+  const { headerRow, firstDataRow, firstDataColumn } = configuration.layout;
+  if (
+    !Number.isInteger(headerRow) ||
+    headerRow < 1 ||
+    !Number.isInteger(firstDataRow) ||
+    firstDataRow <= headerRow ||
+    !Number.isInteger(firstDataColumn) ||
+    firstDataColumn < 1
+  ) {
+    throw new ExternalXlsxError(
+      "invalid-layout",
+      "Kopfzeile, erste Datenzeile oder erste Datenspalte sind ungültig."
+    );
+  }
+  if (!configuration.columns.worksharingId || !configuration.columns.familyAndType) {
+    throw new ExternalXlsxError(
+      "invalid-layout",
+      "Worksharing-ID und Familie und Typ müssen konfiguriert sein."
+    );
+  }
+}
diff --git a/tests/external-xlsx-transport.test.ts b/tests/external-xlsx-transport.test.ts
new file mode 100644
index 0000000..32cd784
--- /dev/null
+++ b/tests/external-xlsx-transport.test.ts
@@ -0,0 +1,267 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import ExcelJS from "exceljs";
+import {
+  createExternalXlsxReturn,
+  ExternalXlsxError,
+  parseExternalXlsx,
+} from "../src/external-model/xlsx/external-xlsx-transport.js";
+import {
+  createRevitXlsxFixture,
+  externalXlsxTestConfiguration,
+  firstWorksharingId,
+  secondWorksharingId,
+} from "./fixtures/revit-xlsx-fixtures.js";
+
+describe("external XLSX transport", () => {
+  it("reads typed cells and classifies ID-less rows without blocking summaries", async () => {
+    const document = await parseExternalXlsx({
+      fileName: "linear.xlsx",
+      bytes: await createRevitXlsxFixture(),
+      configuration: externalXlsxTestConfiguration,
+    });
+
+    assert.equal(document.sheetName, "Linear Export");
+    assert.equal(document.headerRowNumber, 1);
+    assert.equal(document.firstDataRowNumber, 3);
+    assert.equal(document.firstDataColumnNumber, 1);
+    assert.deepEqual(
+      document.rows.map((row) => row.classification),
+      ["object", "object", "suspect-object", "passthrough"]
+    );
+    assert.equal(document.rows[0].cells[5].value, 2);
+    assert.equal(document.rows[0].cells[15].value, true);
+    assert.equal(document.columns[0].comment, "Kommentar Worksharing-ID");
+    assert.equal(document.columns[0].width, 12);
+    assert.deepEqual(
+      document.issues.map((issue) => issue.code),
+      ["suspect-object-skipped"]
+    );
+  });
+
+  it("resolves editable layout positions without a separate ID column", async () => {
+    const configuration = {
+      ...externalXlsxTestConfiguration,
+      layout: { headerRow: 2, firstDataRow: 5, firstDataColumn: 2 },
+    };
+    const document = await parseExternalXlsx({
+      fileName: "linear.xlsx",
+      bytes: await createRevitXlsxFixture(configuration.layout),
+      configuration,
+    });
+
+    assert.equal(document.headerRowNumber, 2);
+    assert.equal(document.firstDataRowNumber, 5);
+    assert.equal(document.firstDataColumnNumber, 2);
+    assert.equal(document.columns[1].header, "Worksharing-ID");
+    assert.equal(document.rows[0].cells[1].value, firstWorksharingId);
+    assert.deepEqual(
+      document.rows.map((row) => row.classification),
+      ["object", "object", "suspect-object", "passthrough"]
+    );
+  });
+
+  it("compares Worksharing-ID and IfcGUID exactly and case-sensitively", async () => {
+    const lowerCaseId = secondWorksharingId.toLowerCase();
+    const document = await parseExternalXlsx({
+      fileName: "linear.xlsx",
+      bytes: await createRevitXlsxFixture({
+        secondWorksharingId: lowerCaseId,
+        firstIfcGuid: "IfcGUID",
+        secondIfcGuid: "IFCGUID",
+      }),
+      configuration: externalXlsxTestConfiguration,
+    });
+    assert.equal(
+      document.rows.filter((row) => row.classification === "object").length,
+      2
+    );
+    assert.equal(
+      document.issues.some((issue) => issue.code === "duplicate-ifc-guid"),
+      false
+    );
+
+    await assert.rejects(
+      parseExternalXlsx({
+        fileName: "linear.xlsx",
+        bytes: await createRevitXlsxFixture({ duplicateWorksharingId: true }),
+        configuration: externalXlsxTestConfiguration,
+      }),
+      isXlsxError("duplicate-worksharing-id")
+    );
+
+    const duplicateIfcDocument = await parseExternalXlsx({
+      fileName: "linear.xlsx",
+      bytes: await createRevitXlsxFixture({
+        firstIfcGuid: "same",
+        secondIfcGuid: "same",
+      }),
+      configuration: externalXlsxTestConfiguration,
+    });
+    assert.equal(
+      duplicateIfcDocument.issues.filter(
+        (issue) => issue.code === "duplicate-ifc-guid"
+      ).length,
+      1
+    );
+  });
+
+  it("uses cached formula values without evaluating formulas", async () => {
+    const document = await parseExternalXlsx({
+      fileName: "linear.xlsx",
+      bytes: await createRevitXlsxFixture({ includeFormula: true }),
+      configuration: externalXlsxTestConfiguration,
+    });
+    const powerCell = document.rows[0].cells[11];
+    assert.equal(powerCell.value, 250);
+    assert.equal(powerCell.formula, "125*2");
+    assert.equal(powerCell.usedCachedFormulaValue, true);
+    assert.equal(
+      document.issues.some(
+        (issue) => issue.code === "cached-formula-value-used"
+      ),
+      true
+    );
+  });
+
+  it("blocks a required formula without a cached result", async () => {
+    await assert.rejects(
+      parseExternalXlsx({
+        fileName: "linear.xlsx",
+        bytes: await createRevitXlsxFixture({
+          includeRequiredFormulaWithoutResult: true,
+        }),
+        configuration: externalXlsxTestConfiguration,
+      }),
+      isXlsxError("required-formula-result-missing")
+    );
+  });
+
+  it("writes selected object rows in source order and preserves workbook structure", async () => {
+    const source = await createRevitXlsxFixture({ includeFormula: true });
+    const result = await createExternalXlsxReturn({
+      fileName: "linear.xlsx",
+      bytes: source,
+      configuration: externalXlsxTestConfiguration,
+      selectedWorksharingIds: [secondWorksharingId, firstWorksharingId],
+      updates: [
+        {
+          worksharingId: firstWorksharingId,
+          values: {
+            circuitCombined: "UV99-3F7",
+            electricalPowerW: 321.5,
+            voltageV: 400,
+            currentA: 0.46,
+          },
+        },
+      ],
+    });
+
+    assert.equal(result.exportedObjectCount, 2);
+    const workbook = new ExcelJS.Workbook();
+    await workbook.xlsx.load(result.bytes as never);
+    const worksheet = workbook.worksheets[0];
+    assert.equal(worksheet.name, "Linear Export");
+    assert.equal(worksheet.rowCount, 4);
+    assert.equal(worksheet.getCell("A3").value, firstWorksharingId);
+    assert.equal(worksheet.getCell("A4").value, secondWorksharingId);
+    assert.equal(worksheet.getCell("H3").value, "UV99-3F7");
+    assert.equal(worksheet.getCell("L3").value, 321.5);
+    assert.equal(worksheet.getCell("M3").value, 400);
+    assert.equal(worksheet.getCell("N3").value, 0.46);
+    assert.equal(worksheet.getCell("P4").value, "bleibt");
+    assert.equal(worksheet.getCell("L3").numFmt, "0.00");
+    assert.equal(worksheet.getColumn(1).width, 12);
+    assert.equal(
+      typeof worksheet.getCell("A1").note === "string"
+        ? worksheet.getCell("A1").note
+        : worksheet.getCell("A1").note?.texts?.[0]?.text,
+      "Kommentar Worksharing-ID"
+    );
+    const commentedCells: string[] = [];
+    worksheet.eachRow({ includeEmpty: true }, (row) => {
+      row.eachCell({ includeEmpty: true }, (cell) => {
+        if (cell.note !== undefined) commentedCells.push(cell.address);
+      });
+    });
+    assert.deepEqual(
+      commentedCells,
+      Array.from({ length: 16 }, (_, index) =>
+        worksheet.getCell(1, index + 1).address
+      )
+    );
+  });
+
+  it("warns for missing optional return columns and blocks missing circuit columns", async () => {
+    const source = await createRevitXlsxFixture();
+    const optionalMissing = {
+      ...externalXlsxTestConfiguration,
+      columns: {
+        ...externalXlsxTestConfiguration.columns,
+        designation: "Nicht vorhanden",
+      },
+    };
+    const result = await createExternalXlsxReturn({
+      fileName: "linear.xlsx",
+      bytes: source,
+      configuration: optionalMissing,
+    });
+    assert.equal(
+      result.issues.some(
+        (issue) =>
+          issue.code === "optional-return-column-missing" &&
+          issue.field === "designation"
+      ),
+      true
+    );
+
+    await assert.rejects(
+      createExternalXlsxReturn({
+        fileName: "linear.xlsx",
+        bytes: source,
+        configuration: {
+          ...externalXlsxTestConfiguration,
+          columns: {
+            ...externalXlsxTestConfiguration.columns,
+            circuitCombined: "Nicht vorhanden",
+          },
+        },
+      }),
+      isXlsxError("return-circuit-column-missing")
+    );
+  });
+
+  it("enforces extension, byte size and post-read sheet limits", async () => {
+    const source = await createRevitXlsxFixture();
+    await assert.rejects(
+      parseExternalXlsx({
+        fileName: "linear.xlsm",
+        bytes: source,
+        configuration: externalXlsxTestConfiguration,
+      }),
+      isXlsxError("invalid-file-extension")
+    );
+    await assert.rejects(
+      parseExternalXlsx({
+        fileName: "linear.xlsx",
+        bytes: new Uint8Array(10 * 1024 * 1024 + 1),
+        configuration: externalXlsxTestConfiguration,
+      }),
+      isXlsxError("file-too-large")
+    );
+    await assert.rejects(
+      parseExternalXlsx({
+        fileName: "linear.xlsx",
+        bytes: source,
+        configuration: externalXlsxTestConfiguration,
+        limits: { maxRows: 3, maxColumns: 100, maxCells: 1_000 },
+      }),
+      isXlsxError("worksheet-too-large")
+    );
+  });
+});
+
+function isXlsxError(code: ExternalXlsxError["code"]) {
+  return (error: unknown) =>
+    error instanceof ExternalXlsxError && error.code === code;
+}
diff --git a/tests/fixtures/revit-xlsx-fixtures.ts b/tests/fixtures/revit-xlsx-fixtures.ts
new file mode 100644
index 0000000..48e3cbd
--- /dev/null
+++ b/tests/fixtures/revit-xlsx-fixtures.ts
@@ -0,0 +1,134 @@
+import ExcelJS from "exceljs";
+import {
+  createDefaultExternalXlsxTransportConfiguration,
+  type ExternalXlsxTransportConfiguration,
+} from "../../src/external-model/xlsx/external-xlsx-contracts.js";
+
+export const firstWorksharingId =
+  "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE-00000001";
+export const secondWorksharingId =
+  "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE-00000002";
+
+export const externalXlsxTestConfiguration: ExternalXlsxTransportConfiguration =
+  createDefaultExternalXlsxTransportConfiguration();
+
+export async function createRevitXlsxFixture(options?: {
+  duplicateWorksharingId?: boolean;
+  secondWorksharingId?: string;
+  firstIfcGuid?: string;
+  secondIfcGuid?: string;
+  includeFormula?: boolean;
+  includeRequiredFormulaWithoutResult?: boolean;
+  headerRow?: number;
+  firstDataRow?: number;
+  firstDataColumn?: number;
+}) {
+  const workbook = new ExcelJS.Workbook();
+  const worksheet = workbook.addWorksheet("Linear Export");
+  const headerRow = options?.headerRow ?? 1;
+  const firstDataRow = options?.firstDataRow ?? 3;
+  const firstDataColumn = options?.firstDataColumn ?? 1;
+  const headers = [
+    "Worksharing-ID",
+    "CAx_Auswahlkenner",
+    "MEP-Raum: Nummer",
+    "MEP-Raum: Name",
+    "Familie und Typ",
+    "CAX_AnzahlObjekte",
+    "CAx_Anmerkung",
+    "kbp_Stromkreisnummer",
+    "kbp-E-Verteiler",
+    "kbp-E-Stromkreis",
+    "kbp-E-Bezeichnung",
+    "kbp-E-Elektrische Leistung",
+    "kbp-E-Spannung",
+    "kbp-E-Stromstärke",
+    "IfcGUID",
+    "Unbekannt",
+  ];
+  headers.forEach((header, index) => {
+    const columnNumber = firstDataColumn + index;
+    const cell = worksheet.getCell(headerRow, columnNumber);
+    cell.value = header;
+    cell.note = `Kommentar ${header}`;
+    cell.font = { bold: true };
+    worksheet.getColumn(columnNumber).width = 12 + index;
+  });
+
+  setRowValues(worksheet, firstDataRow, firstDataColumn, [
+    firstWorksharingId,
+    "Steckdose",
+    "01.101",
+    "Büro",
+    "Steckdose: Standard",
+    2,
+    "Quelle A",
+    "UV01-2F1",
+    "UV01",
+    "-2F1",
+    "Arbeitsplatz",
+    250,
+    230,
+    1.09,
+    options?.firstIfcGuid ?? "IfcCaseSensitive",
+    true,
+  ]);
+  worksheet.getCell(firstDataRow, firstDataColumn + 11).numFmt = "0.00";
+  worksheet.getCell(firstDataRow, firstDataColumn + 12).numFmt = "0";
+  worksheet.getCell(firstDataRow, firstDataColumn + 13).numFmt = "0.00";
+  if (options?.includeFormula) {
+    worksheet.getCell(firstDataRow, firstDataColumn + 11).value = {
+      formula: "125*2",
+      result: 250,
+    };
+  }
+  if (options?.includeRequiredFormulaWithoutResult) {
+    worksheet.getCell(firstDataRow, firstDataColumn).value = { formula: "\"\"" };
+  }
+
+  setRowValues(worksheet, firstDataRow + 1, firstDataColumn, [
+    options?.duplicateWorksharingId
+      ? firstWorksharingId
+      : options?.secondWorksharingId ?? secondWorksharingId,
+    "Leuchte",
+    null,
+    null,
+    "Leuchte: Decke",
+    1,
+    "Quelle B",
+    "UV01-1F1",
+    "UV01",
+    "-1F1",
+    "Beleuchtung",
+    42.5,
+    230,
+    0.18,
+    options?.secondIfcGuid ?? "IfcCaseSensitive2",
+    "bleibt",
+  ]);
+  worksheet.getCell(firstDataRow + 1, firstDataColumn + 11).numFmt = "0.00";
+  setRowValues(worksheet, firstDataRow + 2, firstDataColumn, [
+    null,
+    "verdächtig",
+    null,
+    null,
+    "Gerät: Ohne ID",
+  ]);
+  setRowValues(worksheet, firstDataRow + 3, firstDataColumn, [
+    null,
+    "Summe: 292,5 W",
+  ]);
+
+  return new Uint8Array(await workbook.xlsx.writeBuffer());
+}
+
+function setRowValues(
+  worksheet: ExcelJS.Worksheet,
+  rowNumber: number,
+  firstColumn: number,
+  values: ExcelJS.CellValue[]
+) {
+  values.forEach((value, index) => {
+    worksheet.getCell(rowNumber, firstColumn + index).value = value;
+  });
+}

From 1cfeb06ec780da9efe02fe484ba30ee9dec12e7f Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 08:46:07 +0200
Subject: [PATCH 51/60] Replace Revit CSV backend with Linear XLSX

---
 AGENTS.md                                     |   32 +-
 README.md                                     |   17 +-
 docs/current-architecture.md                  |   38 +-
 .../revit-excel-integration-requirements.md   |    3 +
 docs/spec/revit-excel-phase-14-plan.md        |    4 +-
 package.json                                  |    2 +-
 scripts/run-migrations.js                     |   64 +-
 .../0014_linear_xlsx_external_model.sql       |   97 +
 src/db/migrations/meta/0014_snapshot.json     | 3100 +++++++++++++++++
 src/db/migrations/meta/_journal.json          |    7 +
 ...onfiguration-project-command.repository.ts |  105 -
 ...itial-import-project-command.repository.ts |  252 --
 ...onfiguration-project-command.repository.ts |   79 +
 ...xternal-model-configuration.repository.ts} |   17 +-
 .../external-model-state.repository.ts        |   10 +-
 .../external-object-assignment.persistence.ts |    8 +-
 ...roject-state-restore-command.repository.ts |   19 +-
 .../project-state-snapshot.persistence.ts     |   10 +-
 .../project-transfer.repository.ts            |   13 +-
 src/db/schema/external-csv-configurations.ts  |   22 -
 src/db/schema/external-import-batches.ts      |   18 +-
 .../schema/external-model-configurations.ts   |   21 +
 src/db/schema/external-model-objects.ts       |   18 +-
 src/db/schema/external-model-sources.ts       |    7 +-
 ...csv-configuration-project-command.model.ts |   94 -
 ...al-initial-import-project-command.model.ts |  134 -
 ...del-configuration-project-command.model.ts |   88 +
 .../models/project-state-snapshot.model.ts    |  295 +-
 src/domain/models/project-transfer.model.ts   |   64 +-
 ...csv-configuration-project-command.store.ts |   19 -
 .../external-csv-configuration.reader.ts      |   10 -
 ...al-initial-import-project-command.store.ts |   19 -
 ...del-configuration-project-command.store.ts |   19 +
 .../external-model-configuration.reader.ts    |   10 +
 .../services/project-command.service.ts       |   51 +-
 .../external-circuit-list-objects.ts          |   88 -
 .../application/external-csv-preview.ts       |   91 -
 .../external-initial-import-plan.ts           |  164 -
 .../external-initial-import-target.ts         |  130 -
 .../external-model-configuration.ts           |  246 ++
 .../csv/external-csv-transport.ts             |  356 --
 .../domain/external-model-contracts.ts        |   45 +-
 .../domain/external-model-matching.ts         |  147 -
 src/frontend/types.ts                         |   78 +-
 .../composition/application-repositories.ts   |    6 +-
 .../composition/project-command-stores.ts     |   12 +-
 .../controllers/external-csv.controller.ts    |  298 --
 src/server/routes/project.routes.ts           |   23 -
 src/shared/validation/external-csv.schemas.ts |   40 -
 tests/external-circuit-list-objects.test.ts   |  105 -
 tests/external-csv-api-contract.test.ts       |   83 -
 ...uration-project-command.repository.test.ts |  244 --
 tests/external-csv-preview.test.ts            |   56 -
 tests/external-csv-transport.test.ts          |  146 -
 tests/external-initial-import-plan.test.ts    |  149 -
 ...-import-project-command.repository.test.ts |  297 --
 tests/external-model-configuration.test.ts    |  132 +
 tests/external-model-foundation.test.ts       |  431 ---
 tests/external-model-xlsx-foundation.test.ts  |   87 +
 ...ignment-project-command.repository.test.ts |   25 +-
 ...near-xlsx-external-model-migration.test.ts |  115 +
 tests/project-command.service.test.ts         |   56 +-
 ...ow-sync-project-command.repository.test.ts |   25 +-
 tests/project-snapshot.repository.test.ts     |    2 +
 tests/project-state-snapshot.test.ts          |   38 +-
 65 files changed, 4764 insertions(+), 3717 deletions(-)
 create mode 100644 src/db/migrations/0014_linear_xlsx_external_model.sql
 create mode 100644 src/db/migrations/meta/0014_snapshot.json
 delete mode 100644 src/db/repositories/external-csv-configuration-project-command.repository.ts
 delete mode 100644 src/db/repositories/external-initial-import-project-command.repository.ts
 create mode 100644 src/db/repositories/external-model-configuration-project-command.repository.ts
 rename src/db/repositories/{external-csv-configuration.repository.ts => external-model-configuration.repository.ts} (51%)
 delete mode 100644 src/db/schema/external-csv-configurations.ts
 create mode 100644 src/db/schema/external-model-configurations.ts
 delete mode 100644 src/domain/models/external-csv-configuration-project-command.model.ts
 delete mode 100644 src/domain/models/external-initial-import-project-command.model.ts
 create mode 100644 src/domain/models/external-model-configuration-project-command.model.ts
 delete mode 100644 src/domain/ports/external-csv-configuration-project-command.store.ts
 delete mode 100644 src/domain/ports/external-csv-configuration.reader.ts
 delete mode 100644 src/domain/ports/external-initial-import-project-command.store.ts
 create mode 100644 src/domain/ports/external-model-configuration-project-command.store.ts
 create mode 100644 src/domain/ports/external-model-configuration.reader.ts
 delete mode 100644 src/external-model/application/external-circuit-list-objects.ts
 delete mode 100644 src/external-model/application/external-csv-preview.ts
 delete mode 100644 src/external-model/application/external-initial-import-plan.ts
 delete mode 100644 src/external-model/application/external-initial-import-target.ts
 create mode 100644 src/external-model/configuration/external-model-configuration.ts
 delete mode 100644 src/external-model/csv/external-csv-transport.ts
 delete mode 100644 src/external-model/domain/external-model-matching.ts
 delete mode 100644 src/server/controllers/external-csv.controller.ts
 delete mode 100644 src/shared/validation/external-csv.schemas.ts
 delete mode 100644 tests/external-circuit-list-objects.test.ts
 delete mode 100644 tests/external-csv-api-contract.test.ts
 delete mode 100644 tests/external-csv-configuration-project-command.repository.test.ts
 delete mode 100644 tests/external-csv-preview.test.ts
 delete mode 100644 tests/external-csv-transport.test.ts
 delete mode 100644 tests/external-initial-import-plan.test.ts
 delete mode 100644 tests/external-initial-import-project-command.repository.test.ts
 create mode 100644 tests/external-model-configuration.test.ts
 delete mode 100644 tests/external-model-foundation.test.ts
 create mode 100644 tests/external-model-xlsx-foundation.test.ts
 create mode 100644 tests/linear-xlsx-external-model-migration.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index 7c0a120..c95a271 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -295,7 +295,10 @@ not change the project revision or undo/redo stacks. Restoring a server-stored
 snapshot verifies its checksum and the current-state hash, replaces supported
 project data atomically and records a new `restore` revision with a complete
 inverse command. Restore can therefore be undone and redone after a restart.
-Current snapshot schema version 9 additionally stores
+Current snapshot schema version 10 stores the Linear-XLSX configuration and
+external state with Worksharing-ID identity. Empty versions 1 to 9 are upgraded;
+versions containing legacy CSV configuration or external CSV state are rejected
+with a German migration error. Version 9 additionally stores
 `feedingDistributionBoardId` and `feedingCircuitId` on distribution boards;
 versions 1 to 8 are upgraded with both references set to `null`. Version 8
 stores the optional net room area `rooms[].areaM2` (see
@@ -307,8 +310,8 @@ distribution-board info fields `boardNumber`, `location`, `fedFrom` and
 `remark` and the project cover fields `siteAddress`, `workStage`,
 `projectLead` and `projectEditor`; all older supported versions are upgraded
 with `null` for these fields.
-Stored named and automatic snapshots of every supported version (1 to 9)
-remain restorable; they are upgraded while parsing. Version 5 stores
+Stored named and automatic snapshots of versions 1 to 9 remain restorable when
+they contain no legacy CSV state; they are upgraded while parsing. Version 5 stores
 the manual quantity share of every CircuitDeviceRow. Version 4 snapshots are upgraded with
 `manualQuantity = quantity`; they already contain the complete confirmed
 external-model source, import batches, room mappings and objects. Version 3
@@ -320,17 +323,17 @@ supported versions contain circuit-group identity, distribution-board components
 separate circuit/component protection records. Portable duplicate imports
 remap component ids and protection-owner references together with the existing
 project graph.
-The current runtime still contains the legacy Revit-CSV/IfcGUID foundation:
-project configuration, preview, confirmed initial import, external objects and
-the three row-assignment commands. It remains the audited starting point, not
-the Phase-14 target. Do not extend its CSV transport or IFCGUID identity model.
-The approved cutover is Linear XLSX with exact case-sensitive Worksharing-ID
-identity. See `docs/spec/revit-excel-integration-requirements.md` and
+R3 replaced the runtime configuration and persistence foundation with Linear
+XLSX and exact case-sensitive Worksharing-ID identity. Migration `0014` drops
+the old development-only external CSV data after resetting linked row totals to
+their manual share. Snapshot schema 10, restore and project transfer use the
+new state; non-empty legacy CSV snapshots and legacy CSV history entries are
+rejected with a German error. The backend CSV parser and routes are removed.
+The old project-page frontend remains only until its replacement in R4; do not
+reconnect it to runtime CSV endpoints. See
+`docs/spec/revit-excel-integration-requirements.md` and
 `docs/spec/revit-excel-phase-14-plan.md`.
 
-During R1/R2 no database or runtime schema changes are made. R3 will replace
-the legacy configuration and transport additively, reject non-empty legacy CSV
-snapshot/history state with a German error, and introduce snapshot schema 10.
 The target configuration has no independent version counter; `expectedRevision`
 invalidates stale plans, and each import batch stores a configuration copy.
 Only the newest import batch retains workbook bytes and the full matrix; older
@@ -582,9 +585,8 @@ Critical target rules:
   produce warnings and are skipped. Only missing circuit columns for the
   selected combined/separate mode block export.
 - Missing GZF defaults visibly to 1 without separate confirmation.
-- R2 must generate a changed return workbook from the local sample. The user
-  tests it in Linear before R3. If Linear rejects it, propose direct OOXML
-  modification of the original workbook before starting R3.
+- The corrected R2 return workbook was successfully imported into Linear on
+  2026-09-30; R3 is complete and R4 is the next package.
 - All confirmed writes use typed project commands with `expectedRevision`,
   complete inverse data and the shared project-command transaction boundary.
 - Do not add automatic circuit planning, Revit circuit adoption, multi-source
diff --git a/README.md b/README.md
index 3490332..b8b9c3e 100644
--- a/README.md
+++ b/README.md
@@ -9,12 +9,11 @@ Docker-Server-Stack mit gebautem Anwendungscode und ein separater
 Entwicklungsstack bereit. Ein vollständig unterstütztes Produktionsdeployment
 für mehrere gleichzeitig arbeitende Prozesse und ein vollständig unterstütztes
 Produktionsdeployment fehlen weiterhin. Anmeldung und zwei feste Rollen sind
-vorhanden. Die bisherige Revit-CSV-/IfcGUID-Grundlage mit Vorschau und
-bestätigtem Erstimport ist noch im Code vorhanden. Der freigegebene
-Phase-14-Plan ersetzt sie schrittweise durch den XLSX-Austausch des
-Linear-Plugins mit Worksharing-ID als externem Schlüssel. R0 ist abgeschlossen;
-R1 aktualisiert die Dokumentation. Editorzuordnung, Folgeimport und Rückexport
-sind noch nicht als neuer Excel-Pfad ausgeliefert.
+vorhanden. Die Backend- und Persistenzgrundlage der bisherigen
+Revit-CSV-/IfcGUID-Anbindung ist durch den XLSX-Austausch des Linear-Plugins mit
+Worksharing-ID als externem Schlüssel ersetzt. R0 bis R3 sind abgeschlossen;
+die eigene Revit-Seite, Erstimport, Editorzuordnung, Rückgabe und Folgeimport
+folgen in R4 bis R10.
 
 ## Unterstützter Arbeitsablauf
 
@@ -41,9 +40,9 @@ sind noch nicht als neuer Excel-Pfad ausgeliefert.
 - grobe Leistungsbilanzen für LPH 2/3 nach Kostengruppen führen, mit der
   detaillierten Bilanz vergleichen und einzelne Zeilen als Projektgerät
   übernehmen
-- den vorhandenen Legacy-Revit-CSV-Erstimport verwenden; der Zielpfad über
-  Linear-XLSX, eigene Revit-Seite, Editorzuordnung, Rückgabe und Folgeimport
-  wird gemäß Phase-14-Plan umgesetzt
+- Linear-XLSX-Dateien verlustarm lesen und schreiben; Revit-Seite,
+  Erstimport, Editorzuordnung, Rückgabe und Folgeimport werden gemäß
+  Phase-14-Plan in den nächsten Paketen angebunden
 
 ## Technik
 
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 8993974..846debb 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -510,6 +510,9 @@ Die projektweite Circuit-Tree-Projektion berechnet rekursiv die Lasten aller
 Verteilungen. Die Leistung einer Unterverteilung nach ihrem eigenen
 Verteiler-GZF wird als virtuelle, schreibgeschützte Zeile genau dem gewählten
 Abgang zugerechnet. Eine Verknüpfung ohne Stromkreis bildet nur die Hierarchie.
+Snapshot-Schema 10 enthält zusätzlich die Linear-XLSX-Konfiguration und den
+externen Zustand mit Worksharing-ID-Identität. Leere Versionen 1–9 werden
+hochgestuft; Versionen mit tatsächlichem Legacy-CSV-Zustand werden abgelehnt.
 Snapshot-Schema 9 enthält die beiden Einspeisungsverweise; Versionen 1–8 werden
 mit `null` hochgestuft. Restore und Projektduplizierung erhalten beziehungsweise
 remappen die Verweise. Snapshot-Schema 8 enthält zusätzlich die optionale Netto-Raumfläche
@@ -520,9 +523,9 @@ Snapshot-Schema 6 enthält diese Felder und die Deckblattangaben des
 Projekts; ältere Versionen werden mit `null`
 hochgestuft. Snapshot-Schema 5 enthält zusätzlich den manuellen Mengenanteil jeder
 Gerätezeile. Version 4 wird mit `manualQuantity = quantity` hochgestuft und
-enthält bereits den vollständigen externen Modellzustand
-aus Quelle, Batches, Raum-Mappings und Objekten. Es enthält außerdem die
-projektweite Revit-CSV-Konfiguration, die Gebäudekennzeichnung sowie den Gleichzeitigkeitsfaktor,
+enthielt bereits den damaligen externen CSV-Modellzustand
+aus Quelle, Batches, Raum-Mappings und Objekten. Es enthielt außerdem die
+damalige projektweite Revit-CSV-Konfiguration, die Gebäudekennzeichnung sowie den Gleichzeitigkeitsfaktor,
 Gruppenkategorie und -nummer, Verteilerkomponenten sowie die getrennten
 1:1-Schutzgerätedaten. Capture,
 benannte und automatische Snapshots, Wiederherstellung, Undo/Redo und beide
@@ -640,7 +643,34 @@ PostgreSQL ist bewusst nicht implementiert. Die Domainregeln und
 Transaktionsgrenzen sollen portabel bleiben; Schema und Betriebsmodell benötigen
 bei einem späteren Wechsel trotzdem einen eigenen PostgreSQL-Adapter.
 
-## Revit-Anbindung: Legacy-Ausgangslage und freigegebener Excel-Cutover
+## Revit-Anbindung: Linear-XLSX-Grundlage nach R3
+
+R3 hat den Backend- und Persistenz-Cutover abgeschlossen. Migration `0014`
+entfernt die alten externen CSV-Entwicklungsdaten, nachdem verknüpfte
+Gerätezeilen auf `manualQuantity` zurückgesetzt wurden. Die neue
+`external_model_configurations`-Tabelle besitzt keinen eigenen Versionszähler;
+Änderungen laufen als Projekt-Commands über `expectedRevision`.
+
+Externe Objekte werden je Quelle durch `worksharing_id` exakt und
+case-sensitiv identifiziert. `ifc_guid` ist nullable und nicht eindeutig.
+Importbatches speichern eine Konfigurationskopie; nur der neueste Batch darf
+Originalbytes und die vollständige XLSX-Matrix enthalten, ältere Batches nur
+Datum, Dateiname, SHA-256 und Objektzahl. Snapshot-Schema 10, Restore und
+Projekttransfer verwenden diesen Zustand und remappen alle internen
+Konfigurations-, Gerätearten-, Regel- und Objekt-UUIDs. Leere Snapshots 1–9
+werden hochgestuft; alte Snapshots mit CSV-Konfiguration oder externem
+CSV-Zustand sowie alte CSV-History-Commands werden mit einer deutschen Meldung
+abgelehnt.
+
+Der XLSX-Adapter liegt unter `src/external-model/xlsx`. Der Backend-CSV-Parser,
+seine Endpunkte und Laufzeitverträge sind entfernt. Die noch sichtbare alte
+Projektseiten-Oberfläche ist bis R4 ohne Backend-Anbindung und wird dort durch
+die Route `/projects/:projectId/revit` ersetzt.
+
+### Historische Ausgangslage vor R3
+
+Der folgende Text beschreibt den Stand nach R1 und ist keine aktuelle
+Laufzeitdokumentation mehr.
 
 Der nachfolgende Abschnitt beschreibt den am Ende von R1 noch vorhandenen
 Legacy-Laufzeitpfad. Er verwendet CSV und IfcGUID und ist die geprüfte
diff --git a/docs/spec/revit-excel-integration-requirements.md b/docs/spec/revit-excel-integration-requirements.md
index ff580ec..29a4aaf 100644
--- a/docs/spec/revit-excel-integration-requirements.md
+++ b/docs/spec/revit-excel-integration-requirements.md
@@ -386,6 +386,9 @@ erzeugt wurde und einige klar identifizierbare Rückgabewerte verändert. Diese
 Datei wird nicht committed. Der Nutzer testet sie in Linear. R3 darf erst nach
 erfolgreichem Linear-Rückimport beginnen.
 
+Die korrigierte R2-Rückgabedatei wurde am 30.09.2026 erfolgreich in Linear
+eingelesen. Damit ist diese Abnahme erfüllt und R3 freigegeben.
+
 Scheitert der Linear-Import, wird vor R3 eine Alternative zur Freigabe
 vorgelegt: Die Original-XLSX wird direkt auf OOXML-Ebene kopiert und nur die
 erforderlichen Zellwerte/-typen sowie Zeilenbereiche angepasst. Die
diff --git a/docs/spec/revit-excel-phase-14-plan.md b/docs/spec/revit-excel-phase-14-plan.md
index bb00053..4004eb3 100644
--- a/docs/spec/revit-excel-phase-14-plan.md
+++ b/docs/spec/revit-excel-phase-14-plan.md
@@ -10,8 +10,8 @@ Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
 | --- | --- | --- |
 | R0 | abgeschlossen und freigegeben | Bestandsaudit, Zielmodell, Migration und Risiken; Freigabekorrekturen in R1 eingearbeitet. |
 | R1 | abgeschlossen | Anforderungen, Plan und Architektur auf Excel/Worksharing-ID umgestellt; alle Pflichtprüfungen bestanden. |
-| R2 | implementiert, Linear-Abnahme ausstehend | XLSX-Adapter, Parser, synthetische Fixtures, lokaler Referenzprüfer und reale Rückgabedatei sind erstellt. R3 bleibt bis zum erfolgreichen Linear-Test gesperrt. |
-| R3 | gesperrt bis R2-Abnahme | Konfiguration, Identität, Migration, Snapshot 10, Transfer und Backend-CSV-Entfernung. |
+| R2 | abgeschlossen und freigegeben | XLSX-Adapter, Parser, synthetische Fixtures, lokaler Referenzprüfer und reale Rückgabedatei sind erstellt; der korrigierte Rückimport wurde am 30.09.2026 erfolgreich in Linear getestet. |
+| R3 | abgeschlossen | Konfiguration ohne eigene Revision, Worksharing-ID-Datenmodell, Migration 0014, Snapshot 10, Transfer und Backend-CSV-Entfernung sind umgesetzt und geprüft. |
 | R4 | offen | Revit-Seite, Navigation, Einstellungen, altes Projektseitenmodal entfernen. |
 | R5 | offen | Erstimportwizard mit Gerätearten, Familienregeln und optionalen ProjectDevices. |
 | R6 | offen | Virtualisierte Objekttabelle und Sammelzuordnungen. |
diff --git a/package.json b/package.json
index 1c035ba..17837f1 100644
--- a/package.json
+++ b/package.json
@@ -24,7 +24,7 @@
     "test": "node scripts/run-tests.mjs",
     "test:watch": "node scripts/run-tests.mjs --watch",
     "db:generate": "drizzle-kit generate",
-    "db:migrate": "drizzle-kit migrate",
+    "db:migrate": "node scripts/run-migrations.js",
     "db:backup": "tsx scripts/db-backup.ts",
     "db:verify:circuit-schema": "node scripts/db-verify-circuit-schema.js",
     "revit:verify-reference": "tsx scripts/verify-revit-reference-xlsx.ts"
diff --git a/scripts/run-migrations.js b/scripts/run-migrations.js
index ebbed8a..3a6fc84 100644
--- a/scripts/run-migrations.js
+++ b/scripts/run-migrations.js
@@ -4,13 +4,65 @@ const Database = require('better-sqlite3');
 const fs = require('node:fs');
 const path = require('node:path');
 
-const dataDir = path.resolve('data');
+const dataDir = path.resolve(
+  process.env.LEISTUNGSBILANZ_DATA_DIR || 'data'
+);
 if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
 
-const sqlite = new Database(path.join(dataDir, 'leistungsbilanz.db'));
-const db = drizzle(sqlite);
+const databasePath = path.join(dataDir, 'leistungsbilanz.db');
 
-migrate(db, { migrationsFolder: path.resolve('src/db/migrations') });
-sqlite.close();
+async function run() {
+  const sqlite = new Database(databasePath);
+  try {
+    if (requiresLinearXlsxBackup(sqlite)) {
+      const backupDir = path.join(dataDir, 'backups');
+      fs.mkdirSync(backupDir, { recursive: true });
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupPath = path.join(
+        backupDir,
+        `leistungsbilanz-before-linear-xlsx-${timestamp}.db`
+      );
+      await sqlite.backup(backupPath);
+      verifyBackup(backupPath);
+      console.log(`Verified pre-migration backup created: ${backupPath}`);
+    }
 
-console.log('Migrations applied');
+    migrate(drizzle(sqlite), {
+      migrationsFolder: path.resolve('src/db/migrations'),
+    });
+  } finally {
+    sqlite.close();
+  }
+  console.log('Migrations applied');
+}
+
+function requiresLinearXlsxBackup(sqlite) {
+  const tables = new Set(
+    sqlite.prepare("SELECT name FROM sqlite_master WHERE type = 'table'")
+      .all()
+      .map((row) => row.name)
+  );
+  return tables.has('external_csv_configurations') &&
+    !tables.has('external_model_configurations');
+}
+
+function verifyBackup(backupPath) {
+  const backup = new Database(backupPath, { readonly: true, fileMustExist: true });
+  try {
+    const integrity = backup.pragma('integrity_check', { simple: true });
+    const foreignKeyViolations = backup.pragma('foreign_key_check');
+    if (integrity !== 'ok' || foreignKeyViolations.length > 0) {
+      throw new Error(
+        `Pre-migration backup verification failed: integrity=${integrity}, ` +
+        `foreign-key violations=${foreignKeyViolations.length}`
+      );
+    }
+  } finally {
+    backup.close();
+  }
+}
+
+run().catch((error) => {
+  console.error('Migration failed:', error instanceof Error ? error.message : error);
+  process.exit(1);
+});
diff --git a/src/db/migrations/0014_linear_xlsx_external_model.sql b/src/db/migrations/0014_linear_xlsx_external_model.sql
new file mode 100644
index 0000000..cb8546b
--- /dev/null
+++ b/src/db/migrations/0014_linear_xlsx_external_model.sql
@@ -0,0 +1,97 @@
+PRAGMA foreign_keys=OFF;--> statement-breakpoint
+UPDATE `circuit_device_rows`
+SET `quantity` = `manual_quantity`
+WHERE EXISTS (
+  SELECT 1
+  FROM `external_model_objects`
+  WHERE `external_model_objects`.`circuit_device_row_id` = `circuit_device_rows`.`id`
+);--> statement-breakpoint
+DROP TABLE `external_model_objects`;--> statement-breakpoint
+DROP TABLE `external_room_mappings`;--> statement-breakpoint
+DROP TABLE `external_import_batches`;--> statement-breakpoint
+DROP TABLE `external_model_sources`;--> statement-breakpoint
+DROP TABLE `external_csv_configurations`;--> statement-breakpoint
+CREATE TABLE `external_model_configurations` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`configuration` text NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade
+);--> statement-breakpoint
+CREATE UNIQUE INDEX `external_model_configurations_project_id_unique` ON `external_model_configurations` (`project_id`);--> statement-breakpoint
+CREATE TABLE `external_model_sources` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`name` text NOT NULL,
+	`source_type` text DEFAULT 'revit_xlsx' NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade
+);--> statement-breakpoint
+CREATE UNIQUE INDEX `external_model_sources_project_unique` ON `external_model_sources` (`project_id`);--> statement-breakpoint
+CREATE TABLE `external_import_batches` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`source_id` text NOT NULL,
+	`import_kind` text NOT NULL,
+	`imported_at_iso` text NOT NULL,
+	`file_name` text NOT NULL,
+	`sha256` text NOT NULL,
+	`object_count` integer NOT NULL,
+	`applied_project_revision` integer,
+	`configuration_snapshot` text,
+	`original_bytes` blob,
+	`document` text,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`source_id`) REFERENCES `external_model_sources`(`id`) ON UPDATE no action ON DELETE cascade
+);--> statement-breakpoint
+CREATE INDEX `external_import_batches_project_revision_idx` ON `external_import_batches` (`project_id`,`applied_project_revision`);--> statement-breakpoint
+CREATE INDEX `external_import_batches_source_imported_idx` ON `external_import_batches` (`source_id`,`imported_at_iso`);--> statement-breakpoint
+CREATE TABLE `external_room_mappings` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`source_id` text NOT NULL,
+	`normalized_source_room_key` text NOT NULL,
+	`source_floor_name` text,
+	`source_room_number` text NOT NULL,
+	`source_room_name` text NOT NULL,
+	`room_id` text,
+	`default_distribution_board_id` text,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`source_id`) REFERENCES `external_model_sources`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`room_id`) REFERENCES `rooms`(`id`) ON UPDATE no action ON DELETE set null,
+	FOREIGN KEY (`default_distribution_board_id`) REFERENCES `distribution_boards`(`id`) ON UPDATE no action ON DELETE set null
+);--> statement-breakpoint
+CREATE UNIQUE INDEX `external_room_mappings_source_key_unique` ON `external_room_mappings` (`source_id`,`normalized_source_room_key`);--> statement-breakpoint
+CREATE INDEX `external_room_mappings_project_room_idx` ON `external_room_mappings` (`project_id`,`room_id`);--> statement-breakpoint
+CREATE TABLE `external_model_objects` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`source_id` text NOT NULL,
+	`worksharing_id` text NOT NULL,
+	`ifc_guid` text,
+	`device_type_id` text NOT NULL,
+	`last_seen_import_batch_id` text NOT NULL,
+	`last_accepted_import_batch_id` text NOT NULL,
+	`accepted_source_values` text NOT NULL,
+	`planning_values` text NOT NULL,
+	`overridden_fields` text NOT NULL,
+	`external_room_mapping_id` text,
+	`distribution_board_id` text,
+	`linked_project_device_id` text,
+	`circuit_device_row_id` text,
+	`presence_status` text DEFAULT 'present' NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`source_id`) REFERENCES `external_model_sources`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`last_seen_import_batch_id`) REFERENCES `external_import_batches`(`id`) ON UPDATE no action ON DELETE restrict,
+	FOREIGN KEY (`last_accepted_import_batch_id`) REFERENCES `external_import_batches`(`id`) ON UPDATE no action ON DELETE restrict,
+	FOREIGN KEY (`external_room_mapping_id`) REFERENCES `external_room_mappings`(`id`) ON UPDATE no action ON DELETE set null,
+	FOREIGN KEY (`distribution_board_id`) REFERENCES `distribution_boards`(`id`) ON UPDATE no action ON DELETE set null,
+	FOREIGN KEY (`linked_project_device_id`) REFERENCES `project_devices`(`id`) ON UPDATE no action ON DELETE set null,
+	FOREIGN KEY (`circuit_device_row_id`) REFERENCES `circuit_device_rows`(`id`) ON UPDATE no action ON DELETE set null
+);--> statement-breakpoint
+CREATE UNIQUE INDEX `external_model_objects_source_worksharing_id_unique` ON `external_model_objects` (`source_id`,`worksharing_id`);--> statement-breakpoint
+CREATE INDEX `external_model_objects_project_presence_idx` ON `external_model_objects` (`project_id`,`presence_status`);--> statement-breakpoint
+CREATE INDEX `external_model_objects_project_device_type_idx` ON `external_model_objects` (`project_id`,`device_type_id`);--> statement-breakpoint
+CREATE INDEX `external_model_objects_external_room_mapping_idx` ON `external_model_objects` (`external_room_mapping_id`);--> statement-breakpoint
+CREATE INDEX `external_model_objects_distribution_board_idx` ON `external_model_objects` (`distribution_board_id`);--> statement-breakpoint
+CREATE INDEX `external_model_objects_linked_project_device_idx` ON `external_model_objects` (`linked_project_device_id`);--> statement-breakpoint
+CREATE INDEX `external_model_objects_circuit_device_row_idx` ON `external_model_objects` (`circuit_device_row_id`);--> statement-breakpoint
+PRAGMA foreign_keys=ON;
diff --git a/src/db/migrations/meta/0014_snapshot.json b/src/db/migrations/meta/0014_snapshot.json
new file mode 100644
index 0000000..dc4c096
--- /dev/null
+++ b/src/db/migrations/meta/0014_snapshot.json
@@ -0,0 +1,3100 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "b443af16-e0aa-459a-9443-62a7f8c6b6dd",
+  "prevId": "a967fdfb-171b-4f1d-aa0c-f7124e28fba3",
+  "tables": {
+    "buildings": {
+      "name": "buildings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "buildings_project_id_projects_id_fk": {
+          "name": "buildings_project_id_projects_id_fk",
+          "tableFrom": "buildings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_device_rows": {
+      "name": "circuit_device_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "level": {
+          "name": "level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number_snapshot": {
+          "name": "room_number_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_name_snapshot": {
+          "name": "room_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "manual_quantity": {
+          "name": "manual_quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_device_rows_circuit_id_idx": {
+          "name": "circuit_device_rows_circuit_id_idx",
+          "columns": [
+            "circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "circuit_device_rows_circuit_id_circuits_id_fk": {
+          "name": "circuit_device_rows_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_linked_project_device_id_project_devices_id_fk": {
+          "name": "circuit_device_rows_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_room_id_rooms_id_fk": {
+          "name": "circuit_device_rows_room_id_rooms_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_list_equipment_identifiers": {
+      "name": "circuit_list_equipment_identifiers",
+      "columns": {
+        "owner_type": {
+          "name": "owner_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_list_equipment_identifiers_owner_unique": {
+          "name": "circuit_list_equipment_identifiers_owner_unique",
+          "columns": [
+            "owner_type",
+            "owner_id"
+          ],
+          "isUnique": true
+        },
+        "circuit_list_equipment_identifiers_list_identifier_unique": {
+          "name": "circuit_list_equipment_identifiers_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_list_equipment_identifiers",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_lists": {
+      "name": "circuit_lists",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_lists_distribution_board_id_unique": {
+          "name": "circuit_lists_distribution_board_id_unique",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_lists_project_id_projects_id_fk": {
+          "name": "circuit_lists_project_id_projects_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_lists_distribution_board_id_distribution_boards_id_fk": {
+          "name": "circuit_lists_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_protection_devices": {
+      "name": "circuit_protection_devices",
+      "columns": {
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "circuit_protection_devices_circuit_id_circuits_id_fk": {
+          "name": "circuit_protection_devices_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_protection_devices",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_sections": {
+      "name": "circuit_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "group_number": {
+          "name": "group_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_sections_list_key_unique": {
+          "name": "circuit_sections_list_key_unique",
+          "columns": [
+            "circuit_list_id",
+            "key"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_prefix_unique": {
+          "name": "circuit_sections_list_prefix_unique",
+          "columns": [
+            "circuit_list_id",
+            "prefix"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_category_group_unique": {
+          "name": "circuit_sections_list_category_group_unique",
+          "columns": [
+            "circuit_list_id",
+            "category",
+            "group_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_sections_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_sections_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_sections",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuits": {
+      "name": "circuits",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "cable_type": {
+          "name": "cable_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_cross_section": {
+          "name": "cable_cross_section",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_length": {
+          "name": "cable_length",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_assignment": {
+          "name": "rcd_assignment",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_designation": {
+          "name": "terminal_designation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage": {
+          "name": "voltage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "control_requirement": {
+          "name": "control_requirement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_reserve": {
+          "name": "is_reserve",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuits_section_id_idx": {
+          "name": "circuits_section_id_idx",
+          "columns": [
+            "section_id"
+          ],
+          "isUnique": false
+        },
+        "circuits_list_equipment_identifier_unique": {
+          "name": "circuits_list_equipment_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuits_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuits_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuits_section_id_circuit_sections_id_fk": {
+          "name": "circuits_section_id_circuit_sections_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_component_protection_devices": {
+      "name": "distribution_board_component_protection_devices",
+      "columns": {
+        "component_id": {
+          "name": "component_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk": {
+          "name": "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk",
+          "tableFrom": "distribution_board_component_protection_devices",
+          "tableTo": "distribution_board_components",
+          "columnsFrom": [
+            "component_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_components": {
+      "name": "distribution_board_components",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "placement": {
+          "name": "placement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "distribution_board_components_list_identifier_unique": {
+          "name": "distribution_board_components_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        },
+        "distribution_board_components_section_role_unique": {
+          "name": "distribution_board_components_section_role_unique",
+          "columns": [
+            "section_id",
+            "role"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "distribution_board_components_circuit_list_id_circuit_lists_id_fk": {
+          "name": "distribution_board_components_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_board_components_section_id_circuit_sections_id_fk": {
+          "name": "distribution_board_components_section_id_circuit_sections_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_boards": {
+      "name": "distribution_boards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "supply_type": {
+          "name": "supply_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "board_number": {
+          "name": "board_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "location": {
+          "name": "location",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fed_from": {
+          "name": "fed_from",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "feeding_distribution_board_id": {
+          "name": "feeding_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "feeding_circuit_id": {
+          "name": "feeding_circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "distribution_boards_feeding_board_idx": {
+          "name": "distribution_boards_feeding_board_idx",
+          "columns": [
+            "feeding_distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "distribution_boards_feeding_circuit_idx": {
+          "name": "distribution_boards_feeding_circuit_idx",
+          "columns": [
+            "feeding_circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "distribution_boards_project_id_projects_id_fk": {
+          "name": "distribution_boards_project_id_projects_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_floor_id_floors_id_fk": {
+          "name": "distribution_boards_floor_id_floors_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_feeding_distribution_board_id_distribution_boards_id_fk": {
+          "name": "distribution_boards_feeding_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "feeding_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_feeding_circuit_id_circuits_id_fk": {
+          "name": "distribution_boards_feeding_circuit_id_circuits_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "feeding_circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_assets": {
+      "name": "document_branding_assets",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_settings": {
+      "name": "document_branding_settings",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_balances": {
+      "name": "estimate_balances",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "date_iso": {
+          "name": "date_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "reserve_av_percent": {
+          "name": "reserve_av_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "reserve_sv_percent": {
+          "name": "reserve_sv_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_balances_project_id_idx": {
+          "name": "estimate_balances_project_id_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_balances_project_id_projects_id_fk": {
+          "name": "estimate_balances_project_id_projects_id_fk",
+          "tableFrom": "estimate_balances",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_groups": {
+      "name": "estimate_groups",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "balance_id": {
+          "name": "balance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "editor": {
+          "name": "editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_groups_balance_id_idx": {
+          "name": "estimate_groups_balance_id_idx",
+          "columns": [
+            "balance_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_groups_balance_id_estimate_balances_id_fk": {
+          "name": "estimate_groups_balance_id_estimate_balances_id_fk",
+          "tableFrom": "estimate_groups",
+          "tableTo": "estimate_balances",
+          "columnsFrom": [
+            "balance_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_rows": {
+      "name": "estimate_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "supply": {
+          "name": "supply",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "unit": {
+          "name": "unit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'piece'"
+        },
+        "connection": {
+          "name": "connection",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_per_unit_w": {
+          "name": "power_per_unit_w",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "safety_supply": {
+          "name": "safety_supply",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "estimate_rows_group_id_idx": {
+          "name": "estimate_rows_group_id_idx",
+          "columns": [
+            "group_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_rows_group_id_estimate_groups_id_fk": {
+          "name": "estimate_rows_group_id_estimate_groups_id_fk",
+          "tableFrom": "estimate_rows",
+          "tableTo": "estimate_groups",
+          "columnsFrom": [
+            "group_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_import_batches": {
+      "name": "external_import_batches",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "import_kind": {
+          "name": "import_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "imported_at_iso": {
+          "name": "imported_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "object_count": {
+          "name": "object_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "applied_project_revision": {
+          "name": "applied_project_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "configuration_snapshot": {
+          "name": "configuration_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "original_bytes": {
+          "name": "original_bytes",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "document": {
+          "name": "document",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_import_batches_project_revision_idx": {
+          "name": "external_import_batches_project_revision_idx",
+          "columns": [
+            "project_id",
+            "applied_project_revision"
+          ],
+          "isUnique": false
+        },
+        "external_import_batches_source_imported_idx": {
+          "name": "external_import_batches_source_imported_idx",
+          "columns": [
+            "source_id",
+            "imported_at_iso"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_import_batches_project_id_projects_id_fk": {
+          "name": "external_import_batches_project_id_projects_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_import_batches_source_id_external_model_sources_id_fk": {
+          "name": "external_import_batches_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_configurations": {
+      "name": "external_model_configurations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration": {
+          "name": "configuration",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_model_configurations_project_id_unique": {
+          "name": "external_model_configurations_project_id_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_configurations_project_id_projects_id_fk": {
+          "name": "external_model_configurations_project_id_projects_id_fk",
+          "tableFrom": "external_model_configurations",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_objects": {
+      "name": "external_model_objects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "worksharing_id": {
+          "name": "worksharing_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ifc_guid": {
+          "name": "ifc_guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "device_type_id": {
+          "name": "device_type_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen_import_batch_id": {
+          "name": "last_seen_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_accepted_import_batch_id": {
+          "name": "last_accepted_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "accepted_source_values": {
+          "name": "accepted_source_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "planning_values": {
+          "name": "planning_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "external_room_mapping_id": {
+          "name": "external_room_mapping_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "circuit_device_row_id": {
+          "name": "circuit_device_row_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "presence_status": {
+          "name": "presence_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'present'"
+        }
+      },
+      "indexes": {
+        "external_model_objects_source_worksharing_id_unique": {
+          "name": "external_model_objects_source_worksharing_id_unique",
+          "columns": [
+            "source_id",
+            "worksharing_id"
+          ],
+          "isUnique": true
+        },
+        "external_model_objects_project_presence_idx": {
+          "name": "external_model_objects_project_presence_idx",
+          "columns": [
+            "project_id",
+            "presence_status"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_project_device_type_idx": {
+          "name": "external_model_objects_project_device_type_idx",
+          "columns": [
+            "project_id",
+            "device_type_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_external_room_mapping_idx": {
+          "name": "external_model_objects_external_room_mapping_idx",
+          "columns": [
+            "external_room_mapping_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_distribution_board_idx": {
+          "name": "external_model_objects_distribution_board_idx",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_linked_project_device_idx": {
+          "name": "external_model_objects_linked_project_device_idx",
+          "columns": [
+            "linked_project_device_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_circuit_device_row_idx": {
+          "name": "external_model_objects_circuit_device_row_idx",
+          "columns": [
+            "circuit_device_row_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_model_objects_project_id_projects_id_fk": {
+          "name": "external_model_objects_project_id_projects_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_source_id_external_model_sources_id_fk": {
+          "name": "external_model_objects_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_seen_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_accepted_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk": {
+          "name": "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_room_mappings",
+          "columnsFrom": [
+            "external_room_mapping_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_model_objects_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_linked_project_device_id_project_devices_id_fk": {
+          "name": "external_model_objects_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk": {
+          "name": "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "circuit_device_rows",
+          "columnsFrom": [
+            "circuit_device_row_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_sources": {
+      "name": "external_model_sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_type": {
+          "name": "source_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'revit_xlsx'"
+        }
+      },
+      "indexes": {
+        "external_model_sources_project_unique": {
+          "name": "external_model_sources_project_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_sources_project_id_projects_id_fk": {
+          "name": "external_model_sources_project_id_projects_id_fk",
+          "tableFrom": "external_model_sources",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_room_mappings": {
+      "name": "external_room_mappings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "normalized_source_room_key": {
+          "name": "normalized_source_room_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_floor_name": {
+          "name": "source_floor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_room_number": {
+          "name": "source_room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_room_name": {
+          "name": "source_room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_distribution_board_id": {
+          "name": "default_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_room_mappings_source_key_unique": {
+          "name": "external_room_mappings_source_key_unique",
+          "columns": [
+            "source_id",
+            "normalized_source_room_key"
+          ],
+          "isUnique": true
+        },
+        "external_room_mappings_project_room_idx": {
+          "name": "external_room_mappings_project_room_idx",
+          "columns": [
+            "project_id",
+            "room_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_room_mappings_project_id_projects_id_fk": {
+          "name": "external_room_mappings_project_id_projects_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_source_id_external_model_sources_id_fk": {
+          "name": "external_room_mappings_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_room_id_rooms_id_fk": {
+          "name": "external_room_mappings_room_id_rooms_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "default_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "floors": {
+      "name": "floors",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "building_id": {
+          "name": "building_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "floors_project_id_projects_id_fk": {
+          "name": "floors_project_id_projects_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "floors_building_id_buildings_id_fk": {
+          "name": "floors_building_id_buildings_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "buildings",
+          "columnsFrom": [
+            "building_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "global_devices": {
+      "name": "global_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "installed_power_per_unit_kw": {
+          "name": "installed_power_per_unit_kw",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "demand_factor": {
+          "name": "demand_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase_count": {
+          "name": "phase_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_factor": {
+          "name": "power_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_change_sets": {
+      "name": "project_change_sets",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_revision_id": {
+          "name": "project_revision_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "command_type": {
+          "name": "command_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_schema_version": {
+          "name": "payload_schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "forward_payload_json": {
+          "name": "forward_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "inverse_payload_json": {
+          "name": "inverse_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_change_sets_revision_unique": {
+          "name": "project_change_sets_revision_unique",
+          "columns": [
+            "project_revision_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_change_sets_project_revision_id_project_revisions_id_fk": {
+          "name": "project_change_sets_project_revision_id_project_revisions_id_fk",
+          "tableFrom": "project_change_sets",
+          "tableTo": "project_revisions",
+          "columnsFrom": [
+            "project_revision_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_devices": {
+      "name": "project_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'single_phase'"
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "project_devices_project_id_projects_id_fk": {
+          "name": "project_devices_project_id_projects_id_fk",
+          "tableFrom": "project_devices",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_history_stack_entries": {
+      "name": "project_history_stack_entries",
+      "columns": {
+        "change_set_id": {
+          "name": "change_set_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stack": {
+          "name": "stack",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_history_stack_entries_position_unique": {
+          "name": "project_history_stack_entries_position_unique",
+          "columns": [
+            "project_id",
+            "stack",
+            "position"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_history_stack_entries_change_set_id_project_change_sets_id_fk": {
+          "name": "project_history_stack_entries_change_set_id_project_change_sets_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "project_change_sets",
+          "columnsFrom": [
+            "change_set_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "project_history_stack_entries_project_id_projects_id_fk": {
+          "name": "project_history_stack_entries_project_id_projects_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "project_history_stack_entries_stack_check": {
+          "name": "project_history_stack_entries_stack_check",
+          "value": "\"project_history_stack_entries\".\"stack\" in ('undo', 'redo')"
+        }
+      }
+    },
+    "project_revisions": {
+      "name": "project_revisions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision_number": {
+          "name": "revision_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_revisions_project_number_unique": {
+          "name": "project_revisions_project_number_unique",
+          "columns": [
+            "project_id",
+            "revision_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_revisions_project_id_projects_id_fk": {
+          "name": "project_revisions_project_id_projects_id_fk",
+          "tableFrom": "project_revisions",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_snapshots": {
+      "name": "project_snapshots",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_revision": {
+          "name": "source_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_version": {
+          "name": "schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'named'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "payload_json": {
+          "name": "payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_sha256": {
+          "name": "payload_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_by_actor_id": {
+          "name": "created_by_actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_snapshots_project_created_idx": {
+          "name": "project_snapshots_project_created_idx",
+          "columns": [
+            "project_id",
+            "created_at_iso"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_kind_revision_idx": {
+          "name": "project_snapshots_project_kind_revision_idx",
+          "columns": [
+            "project_id",
+            "kind",
+            "source_revision"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_name_unique": {
+          "name": "project_snapshots_project_name_unique",
+          "columns": [
+            "project_id",
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_snapshots_project_id_projects_id_fk": {
+          "name": "project_snapshots_project_id_projects_id_fk",
+          "tableFrom": "project_snapshots",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "internal_project_number": {
+          "name": "internal_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_project_number": {
+          "name": "external_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "building_owner": {
+          "name": "building_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_public_building": {
+          "name": "is_public_building",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "single_phase_voltage_v": {
+          "name": "single_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 230
+        },
+        "three_phase_voltage_v": {
+          "name": "three_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 400
+        },
+        "enabled_distribution_board_supply_types": {
+          "name": "enabled_distribution_board_supply_types",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'[\"AV\",\"SV\",\"EV\",\"USV\",\"MSR\",\"SiBe\"]'"
+        },
+        "site_address": {
+          "name": "site_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_lead": {
+          "name": "project_lead",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_editor": {
+          "name": "project_editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "current_revision": {
+          "name": "current_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "rooms": {
+      "name": "rooms",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number": {
+          "name": "room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_name": {
+          "name": "room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "area_m2": {
+          "name": "area_m2",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rooms_project_id_projects_id_fk": {
+          "name": "rooms_project_id_projects_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rooms_floor_id_floors_id_fk": {
+          "name": "rooms_floor_id_floors_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "users": {
+      "name": "users",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'user'"
+        },
+        "active": {
+          "name": "active",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "must_change_password": {
+          "name": "must_change_password",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {
+        "users_username_unique": {
+          "name": "users_username_unique",
+          "columns": [
+            "username"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index 2a2e076..0f6c303 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -99,6 +99,13 @@
       "when": 1790624623732,
       "tag": "0013_users",
       "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "6",
+      "when": 1790748107566,
+      "tag": "0014_linear_xlsx_external_model",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/db/repositories/external-csv-configuration-project-command.repository.ts b/src/db/repositories/external-csv-configuration-project-command.repository.ts
deleted file mode 100644
index c7d7bf7..0000000
--- a/src/db/repositories/external-csv-configuration-project-command.repository.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { eq } from "drizzle-orm";
-import {
-  assertExternalCsvConfigurationUpdateProjectCommand,
-  createExternalCsvConfigurationUpdateProjectCommand,
-  type ExternalCsvConfigurationSnapshot,
-} from "../../domain/models/external-csv-configuration-project-command.model.js";
-import type {
-  ExecuteExternalCsvConfigurationCommandInput,
-  ExternalCsvConfigurationProjectCommandStore,
-} from "../../domain/ports/external-csv-configuration-project-command.store.js";
-import type { AppDatabase } from "../database-context.js";
-import { externalCsvConfigurations } from "../schema/external-csv-configurations.js";
-import { projects } from "../schema/projects.js";
-import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
-
-export class ExternalCsvConfigurationProjectCommandRepository
-  implements ExternalCsvConfigurationProjectCommandStore
-{
-  constructor(private readonly database: AppDatabase) {}
-
-  execute(input: ExecuteExternalCsvConfigurationCommandInput) {
-    assertExternalCsvConfigurationUpdateProjectCommand(input.command);
-    return executeProjectCommandTransaction(this.database, input, (tx) => {
-      const project = tx
-        .select({ id: projects.id })
-        .from(projects)
-        .where(eq(projects.id, input.projectId))
-        .get();
-      if (!project) {
-        throw new Error("Project not found.");
-      }
-      const current = tx
-        .select()
-        .from(externalCsvConfigurations)
-        .where(eq(externalCsvConfigurations.projectId, input.projectId))
-        .get() ?? null;
-      assertSameSnapshot(current, input.command.payload.expected);
-      const target = input.command.payload.target;
-      if (target !== null && target.projectId !== input.projectId) {
-        throw new Error("External CSV configuration belongs to a different project.");
-      }
-      if (sameSnapshot(current, target)) {
-        throw new Error("External CSV configuration did not change.");
-      }
-      if (
-        input.source === "user" &&
-        target !== null &&
-        target.configurationVersion !== (current?.configurationVersion ?? 0) + 1
-      ) {
-        throw new Error("External CSV configuration version must advance by one.");
-      }
-
-      if (target === null) {
-        tx.delete(externalCsvConfigurations)
-          .where(eq(externalCsvConfigurations.projectId, input.projectId))
-          .run();
-      } else if (current === null) {
-        tx.insert(externalCsvConfigurations).values(target).run();
-      } else {
-        const updated = tx
-          .update(externalCsvConfigurations)
-          .set({
-            configurationVersion: target.configurationVersion,
-            configuration: target.configuration,
-          })
-          .where(eq(externalCsvConfigurations.id, current.id))
-          .run();
-        if (updated.changes !== 1) {
-          throw new Error("External CSV configuration changed before update.");
-        }
-      }
-      return createExternalCsvConfigurationUpdateProjectCommand(target, current);
-    });
-  }
-}
-
-function assertSameSnapshot(
-  current: ExternalCsvConfigurationSnapshot | null,
-  expected: ExternalCsvConfigurationSnapshot | null
-) {
-  if (!sameSnapshot(current, expected)) {
-    throw new Error("External CSV configuration changed before update.");
-  }
-}
-
-function sameSnapshot(
-  left: ExternalCsvConfigurationSnapshot | null,
-  right: ExternalCsvConfigurationSnapshot | null
-) {
-  return canonicalJson(left) === canonicalJson(right);
-}
-
-function canonicalJson(value: unknown): string {
-  if (Array.isArray(value)) {
-    return `[${value.map(canonicalJson).join(",")}]`;
-  }
-  if (value !== null && typeof value === "object") {
-    const record = value as Record<string, unknown>;
-    return `{${Object.keys(record)
-      .sort()
-      .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
-      .join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
diff --git a/src/db/repositories/external-initial-import-project-command.repository.ts b/src/db/repositories/external-initial-import-project-command.repository.ts
deleted file mode 100644
index 1f2281e..0000000
--- a/src/db/repositories/external-initial-import-project-command.repository.ts
+++ /dev/null
@@ -1,252 +0,0 @@
-import crypto from "node:crypto";
-import { eq } from "drizzle-orm";
-import {
-  assertExternalInitialImportProjectCommand,
-  createExternalInitialImportProjectCommand,
-  isEmptyExternalModelState,
-} from "../../domain/models/external-initial-import-project-command.model.js";
-import type { ExternalInitialImportProjectCommandStore } from "../../domain/ports/external-initial-import-project-command.store.js";
-import { createExternalCsvPreview } from "../../external-model/application/external-csv-preview.js";
-import { parseExternalCsv } from "../../external-model/csv/external-csv-transport.js";
-import type { ExternalModelStateSnapshot } from "../../external-model/domain/external-model-contracts.js";
-import {
-  createExternalRoomKey,
-  indexExternalObjectsByIfcGuid,
-  projectInitialExternalObject,
-} from "../../external-model/domain/external-model-matching.js";
-import type { AppDatabase } from "../database-context.js";
-import { distributionBoards } from "../schema/distribution-boards.js";
-import { externalCsvConfigurations } from "../schema/external-csv-configurations.js";
-import { externalImportBatches } from "../schema/external-import-batches.js";
-import { externalModelObjects } from "../schema/external-model-objects.js";
-import { externalModelSources } from "../schema/external-model-sources.js";
-import { externalRoomMappings } from "../schema/external-room-mappings.js";
-import { projectDevices } from "../schema/project-devices.js";
-import { rooms } from "../schema/rooms.js";
-import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
-import { ExternalModelStateRepository } from "./external-model-state.repository.js";
-
-export class ExternalInitialImportProjectCommandRepository
-  implements ExternalInitialImportProjectCommandStore
-{
-  constructor(private readonly database: AppDatabase) {}
-
-  execute(input: Parameters<ExternalInitialImportProjectCommandStore["execute"]>[0]) {
-    assertExternalInitialImportProjectCommand(input.command);
-    return executeProjectCommandTransaction(this.database, input, (tx) => {
-      const currentResult = new ExternalModelStateRepository(tx)
-        .getByProject(input.projectId);
-      if (!currentResult.projectExists) throw new Error("Project not found.");
-      const expected = input.command.payload.expected;
-      if (!sameState(currentResult.state, expected)) {
-        throw new Error("External model state changed before initial import.");
-      }
-      const target = input.command.payload.target;
-      if (!isEmptyExternalModelState(target)) {
-        validatePopulatedTarget(tx, input, target);
-      }
-
-      replaceExternalState(tx, input.projectId, target);
-      const persisted = new ExternalModelStateRepository(tx)
-        .getByProject(input.projectId).state;
-      if (!sameState(persisted, target)) {
-        throw new Error("Persisted external initial import differs from its target.");
-      }
-      return createExternalInitialImportProjectCommand(target, currentResult.state);
-    });
-  }
-}
-
-function validatePopulatedTarget(
-  database: AppDatabase,
-  input: Parameters<ExternalInitialImportProjectCommandStore["execute"]>[0],
-  target: ExternalModelStateSnapshot
-) {
-  const source = target.source!;
-  const batch = target.importBatches[0];
-  if (source.projectId !== input.projectId) {
-    throw new Error("External initial import belongs to a different project.");
-  }
-  if (
-    input.source === "user" &&
-    batch.appliedProjectRevision !== input.expectedRevision + 1
-  ) {
-    throw new Error("External initial import revision is invalid.");
-  }
-  const configuration = database
-    .select()
-    .from(externalCsvConfigurations)
-    .where(eq(externalCsvConfigurations.projectId, input.projectId))
-    .get();
-  if (
-    !configuration ||
-    configuration.configurationVersion !== batch.configurationVersion ||
-    canonicalJson(configuration.configuration) !==
-      canonicalJson(batch.configurationSnapshot)
-  ) {
-    throw new Error("External initial import configuration changed before apply.");
-  }
-
-  const bytes = decodeCanonicalBase64(batch.originalContentBase64);
-  const sha256 = crypto.createHash("sha256").update(bytes).digest("hex");
-  if (sha256 !== batch.sha256) {
-    throw new Error("External initial import checksum is invalid.");
-  }
-  const parsedDocument = parseExternalCsv(bytes, batch.configurationSnapshot);
-  if (canonicalJson(parsedDocument) !== canonicalJson(batch.document)) {
-    throw new Error("External initial import document differs from the original bytes.");
-  }
-  const preview = createExternalCsvPreview({
-    fileName: batch.fileName,
-    bytes,
-    configuration: batch.configurationSnapshot,
-  });
-  const targetByIfcGuid = indexExternalObjectsByIfcGuid(target.objects);
-  if (targetByIfcGuid.size !== preview.objects.length) {
-    throw new Error("External initial import must contain every CSV object exactly once.");
-  }
-  const mappingsById = new Map(
-    target.roomMappings.map((mapping) => [mapping.id, mapping])
-  );
-  const expectedRoomKeys = new Set<string>();
-  for (const candidate of preview.objects) {
-    const object = targetByIfcGuid.get(candidate.ifcGuid);
-    if (!object) {
-      throw new Error(`External initial import is missing IFCGUID ${candidate.ifcGuid}.`);
-    }
-    const projected = projectInitialExternalObject(
-      candidate,
-      batch.configurationSnapshot
-    );
-    if (canonicalJson(object.acceptedSourceValues) !== canonicalJson(projected.sourceValues)) {
-      throw new Error("External initial import source values differ from the CSV.");
-    }
-    for (const field of Object.keys(projected.planningValues) as Array<keyof typeof projected.planningValues>) {
-      if (
-        !object.overriddenFields.includes(field) &&
-        canonicalJson(object.planningValues[field]) !==
-          canonicalJson(projected.planningValues[field])
-      ) {
-        throw new Error(`External initial planning field ${field} changed without an override.`);
-      }
-    }
-    const roomKey = createExternalRoomKey(candidate.roomNumber, candidate.roomName);
-    if (roomKey === null) {
-      if (object.externalRoomMappingId !== null) {
-        throw new Error("External object without a source room must not use a room mapping.");
-      }
-    } else {
-      expectedRoomKeys.add(roomKey);
-      const mapping = object.externalRoomMappingId === null
-        ? null
-        : mappingsById.get(object.externalRoomMappingId);
-      if (!mapping || mapping.normalizedSourceRoomKey !== roomKey) {
-        throw new Error("External object source room mapping is incomplete.");
-      }
-    }
-  }
-  if (
-    target.roomMappings.length !== expectedRoomKeys.size ||
-    target.roomMappings.some(
-      (mapping) => !expectedRoomKeys.has(mapping.normalizedSourceRoomKey)
-    )
-  ) {
-    throw new Error("External initial import room mappings do not match CSV rooms.");
-  }
-  validateInternalLinks(database, input.projectId, target);
-}
-
-function validateInternalLinks(
-  database: AppDatabase,
-  projectId: string,
-  target: ExternalModelStateSnapshot
-) {
-  const roomIds = new Set(
-    database.select({ id: rooms.id }).from(rooms)
-      .where(eq(rooms.projectId, projectId)).all().map((row) => row.id)
-  );
-  const boardIds = new Set(
-    database.select({ id: distributionBoards.id }).from(distributionBoards)
-      .where(eq(distributionBoards.projectId, projectId)).all().map((row) => row.id)
-  );
-  const deviceIds = new Set(
-    database.select({ id: projectDevices.id }).from(projectDevices)
-      .where(eq(projectDevices.projectId, projectId)).all().map((row) => row.id)
-  );
-  for (const mapping of target.roomMappings) {
-    if (mapping.roomId !== null && !roomIds.has(mapping.roomId)) {
-      throw new Error("External room mapping references another project.");
-    }
-    if (
-      mapping.defaultDistributionBoardId !== null &&
-      !boardIds.has(mapping.defaultDistributionBoardId)
-    ) {
-      throw new Error("External room mapping distribution board belongs to another project.");
-    }
-  }
-  for (const object of target.objects) {
-    if (object.distributionBoardId !== null && !boardIds.has(object.distributionBoardId)) {
-      throw new Error("External object distribution board belongs to another project.");
-    }
-    if (object.linkedProjectDeviceId !== null && !deviceIds.has(object.linkedProjectDeviceId)) {
-      throw new Error("External object project device belongs to another project.");
-    }
-  }
-}
-
-function replaceExternalState(
-  database: AppDatabase,
-  projectId: string,
-  target: ExternalModelStateSnapshot
-) {
-  database.delete(externalModelSources)
-    .where(eq(externalModelSources.projectId, projectId)).run();
-  if (target.source === null) return;
-  database.insert(externalModelSources).values(target.source).run();
-  database.insert(externalImportBatches).values(
-    target.importBatches.map(({ originalContentBase64, ...batch }) => ({
-      ...batch,
-      originalBytes: Buffer.from(originalContentBase64, "base64"),
-    }))
-  ).run();
-  if (target.roomMappings.length) {
-    database.insert(externalRoomMappings).values(target.roomMappings).run();
-  }
-  if (target.objects.length) {
-    database.insert(externalModelObjects).values(target.objects).run();
-  }
-}
-
-function decodeCanonicalBase64(value: string) {
-  const bytes = Buffer.from(value, "base64");
-  if (bytes.toString("base64") !== value) {
-    throw new Error("External initial import bytes are not canonical base64.");
-  }
-  return bytes;
-}
-
-function sameState(left: ExternalModelStateSnapshot, right: ExternalModelStateSnapshot) {
-  return canonicalJson(sortState(left)) === canonicalJson(sortState(right));
-}
-
-function sortState(state: ExternalModelStateSnapshot): ExternalModelStateSnapshot {
-  const byId = <T extends { id: string }>(entries: readonly T[]) =>
-    [...entries].sort((left, right) => left.id.localeCompare(right.id));
-  return {
-    source: state.source,
-    importBatches: byId(state.importBatches),
-    roomMappings: byId(state.roomMappings),
-    objects: byId(state.objects),
-  };
-}
-
-function canonicalJson(value: unknown): string {
-  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    const record = value as Record<string, unknown>;
-    return `{${Object.keys(record).sort().map(
-      (key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`
-    ).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
diff --git a/src/db/repositories/external-model-configuration-project-command.repository.ts b/src/db/repositories/external-model-configuration-project-command.repository.ts
new file mode 100644
index 0000000..881cc8a
--- /dev/null
+++ b/src/db/repositories/external-model-configuration-project-command.repository.ts
@@ -0,0 +1,79 @@
+import { eq } from "drizzle-orm";
+import {
+  assertExternalModelConfigurationUpdateProjectCommand,
+  createExternalModelConfigurationUpdateProjectCommand,
+  type ExternalModelConfigurationSnapshot,
+} from "../../domain/models/external-model-configuration-project-command.model.js";
+import type {
+  ExecuteExternalModelConfigurationCommandInput,
+  ExternalModelConfigurationProjectCommandStore,
+} from "../../domain/ports/external-model-configuration-project-command.store.js";
+import type { AppDatabase } from "../database-context.js";
+import { externalModelConfigurations } from "../schema/external-model-configurations.js";
+import { projects } from "../schema/projects.js";
+import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+
+export class ExternalModelConfigurationProjectCommandRepository
+  implements ExternalModelConfigurationProjectCommandStore {
+  constructor(private readonly database: AppDatabase) {}
+
+  execute(input: ExecuteExternalModelConfigurationCommandInput) {
+    assertExternalModelConfigurationUpdateProjectCommand(input.command);
+    return executeProjectCommandTransaction(this.database, input, (tx) => {
+      const project = tx.select({ id: projects.id }).from(projects)
+        .where(eq(projects.id, input.projectId)).get();
+      if (!project) throw new Error("Project not found.");
+      const current = tx.select().from(externalModelConfigurations)
+        .where(eq(externalModelConfigurations.projectId, input.projectId)).get() ?? null;
+      assertSameSnapshot(current, input.command.payload.expected);
+      const target = input.command.payload.target;
+      if (target !== null && target.projectId !== input.projectId) {
+        throw new Error("Die Revit-XLSX-Konfiguration gehört zu einem anderen Projekt.");
+      }
+      if (sameSnapshot(current, target)) {
+        throw new Error("Die Revit-XLSX-Konfiguration wurde nicht geändert.");
+      }
+      if (target === null) {
+        tx.delete(externalModelConfigurations)
+          .where(eq(externalModelConfigurations.projectId, input.projectId)).run();
+      } else if (current === null) {
+        tx.insert(externalModelConfigurations).values(target).run();
+      } else {
+        const updated = tx.update(externalModelConfigurations)
+          .set({ configuration: target.configuration })
+          .where(eq(externalModelConfigurations.id, current.id)).run();
+        if (updated.changes !== 1) {
+          throw new Error("Die Revit-XLSX-Konfiguration wurde zwischenzeitlich geändert.");
+        }
+      }
+      return createExternalModelConfigurationUpdateProjectCommand(target, current);
+    });
+  }
+}
+
+function assertSameSnapshot(
+  current: ExternalModelConfigurationSnapshot | null,
+  expected: ExternalModelConfigurationSnapshot | null
+) {
+  if (!sameSnapshot(current, expected)) {
+    throw new Error("Die Revit-XLSX-Konfiguration wurde zwischenzeitlich geändert.");
+  }
+}
+
+function sameSnapshot(
+  left: ExternalModelConfigurationSnapshot | null,
+  right: ExternalModelConfigurationSnapshot | null
+) {
+  return canonicalJson(left) === canonicalJson(right);
+}
+
+function canonicalJson(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record = value as Record<string, unknown>;
+    return `{${Object.keys(record).sort().map(
+      (key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`
+    ).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
diff --git a/src/db/repositories/external-csv-configuration.repository.ts b/src/db/repositories/external-model-configuration.repository.ts
similarity index 51%
rename from src/db/repositories/external-csv-configuration.repository.ts
rename to src/db/repositories/external-model-configuration.repository.ts
index 2b39a65..7cbacab 100644
--- a/src/db/repositories/external-csv-configuration.repository.ts
+++ b/src/db/repositories/external-model-configuration.repository.ts
@@ -1,12 +1,11 @@
 import { eq } from "drizzle-orm";
-import type { ExternalCsvConfigurationReader } from "../../domain/ports/external-csv-configuration.reader.js";
+import type { ExternalModelConfigurationReader } from "../../domain/ports/external-model-configuration.reader.js";
 import type { AppDatabase } from "../database-context.js";
-import { externalCsvConfigurations } from "../schema/external-csv-configurations.js";
+import { externalModelConfigurations } from "../schema/external-model-configurations.js";
 import { projects } from "../schema/projects.js";
 
-export class ExternalCsvConfigurationRepository
-  implements ExternalCsvConfigurationReader
-{
+export class ExternalModelConfigurationRepository
+  implements ExternalModelConfigurationReader {
   constructor(private readonly database: AppDatabase) {}
 
   getByProject(projectId: string) {
@@ -15,13 +14,11 @@ export class ExternalCsvConfigurationRepository
       .from(projects)
       .where(eq(projects.id, projectId))
       .get();
-    if (!project) {
-      return { projectExists: false, configuration: null };
-    }
+    if (!project) return { projectExists: false, configuration: null };
     const configuration = this.database
       .select()
-      .from(externalCsvConfigurations)
-      .where(eq(externalCsvConfigurations.projectId, projectId))
+      .from(externalModelConfigurations)
+      .where(eq(externalModelConfigurations.projectId, projectId))
       .get() ?? null;
     return { projectExists: true, configuration };
   }
diff --git a/src/db/repositories/external-model-state.repository.ts b/src/db/repositories/external-model-state.repository.ts
index 36079c9..c2adb7c 100644
--- a/src/db/repositories/external-model-state.repository.ts
+++ b/src/db/repositories/external-model-state.repository.ts
@@ -55,7 +55,10 @@ export class ExternalModelStateRepository implements ExternalModelStateReader {
       .select()
       .from(externalModelObjects)
       .where(eq(externalModelObjects.sourceId, source.id))
-      .orderBy(asc(externalModelObjects.ifcGuid), asc(externalModelObjects.id))
+      .orderBy(
+        asc(externalModelObjects.worksharingId),
+        asc(externalModelObjects.id)
+      )
       .all();
 
     return {
@@ -64,7 +67,10 @@ export class ExternalModelStateRepository implements ExternalModelStateReader {
         source,
         importBatches: batches.map(({ originalBytes, ...batch }) => ({
           ...batch,
-          originalContentBase64: Buffer.from(originalBytes).toString("base64"),
+          originalContentBase64:
+            originalBytes === null
+              ? null
+              : Buffer.from(originalBytes).toString("base64"),
         })),
         roomMappings,
         objects,
diff --git a/src/db/repositories/external-object-assignment.persistence.ts b/src/db/repositories/external-object-assignment.persistence.ts
index ddc9891..1111730 100644
--- a/src/db/repositories/external-object-assignment.persistence.ts
+++ b/src/db/repositories/external-object-assignment.persistence.ts
@@ -51,7 +51,7 @@ export function assertExternalObjectsCompatibleWithRow(input: {
   const roomIdByMappingId = new Map(mappings.map((mapping) => [mapping.id, mapping.roomId]));
   const markers = new Set(
     input.allLinkedObjects.map((object) =>
-      object.acceptedSourceValues.selectionMarker.trim()
+      scalarText(object.acceptedSourceValues.selectionMarker).trim()
     )
   );
   if (markers.size > 1) {
@@ -118,13 +118,17 @@ function matchesRowPlanningValues(
     row.category === planning.category &&
     row.connectionKind === planning.connectionKind &&
     (planning.powerPerUnitW === null || row.powerPerUnit === planning.powerPerUnitW / 1000) &&
-    row.simultaneityFactor === planning.simultaneityFactor &&
+    row.simultaneityFactor === (planning.simultaneityFactor ?? 1) &&
     row.cosPhi === planning.cosPhi &&
     row.costGroup === planning.costGroup &&
     row.remark === planning.remark
   );
 }
 
+function scalarText(value: string | number | boolean | null) {
+  return value === null ? "" : String(value);
+}
+
 function canonicalJson(value: unknown): string {
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
   if (value !== null && typeof value === "object") {
diff --git a/src/db/repositories/project-state-restore-command.repository.ts b/src/db/repositories/project-state-restore-command.repository.ts
index 386d805..006b742 100644
--- a/src/db/repositories/project-state-restore-command.repository.ts
+++ b/src/db/repositories/project-state-restore-command.repository.ts
@@ -31,7 +31,7 @@ import { projectDevices } from "../schema/project-devices.js";
 import { projectChangeSets } from "../schema/project-change-sets.js";
 import { projects } from "../schema/projects.js";
 import { rooms } from "../schema/rooms.js";
-import { externalCsvConfigurations } from "../schema/external-csv-configurations.js";
+import { externalModelConfigurations } from "../schema/external-model-configurations.js";
 import { externalImportBatches } from "../schema/external-import-batches.js";
 import { externalModelObjects } from "../schema/external-model-objects.js";
 import { externalModelSources } from "../schema/external-model-sources.js";
@@ -241,7 +241,7 @@ function canonicalProjectState(state: ProjectStateSnapshot) {
     buildings: byId(state.buildings),
     floors: byId(state.floors),
     rooms: byId(state.rooms),
-    externalCsvConfiguration: state.externalCsvConfiguration,
+    externalModelConfiguration: state.externalModelConfiguration,
     externalModel: {
       source: state.externalModel.source,
       importBatches: byId(state.externalModel.importBatches),
@@ -283,8 +283,8 @@ function replaceProjectState(
     .where(eq(externalModelSources.projectId, state.project.id))
     .run();
   database
-    .delete(externalCsvConfigurations)
-    .where(eq(externalCsvConfigurations.projectId, state.project.id))
+    .delete(externalModelConfigurations)
+    .where(eq(externalModelConfigurations.projectId, state.project.id))
     .run();
   database
     .delete(distributionBoards)
@@ -330,10 +330,10 @@ function replaceProjectState(
 
   insertMany(database, buildings, state.buildings);
   insertMany(database, floors, state.floors);
-  if (state.externalCsvConfiguration !== null) {
+  if (state.externalModelConfiguration !== null) {
     database
-      .insert(externalCsvConfigurations)
-      .values(state.externalCsvConfiguration)
+      .insert(externalModelConfigurations)
+      .values(state.externalModelConfiguration)
       .run();
   }
   insertMany(database, rooms, state.rooms);
@@ -387,7 +387,10 @@ function replaceProjectState(
     state.externalModel.importBatches.map(
       ({ originalContentBase64, ...batch }) => ({
         ...batch,
-        originalBytes: Buffer.from(originalContentBase64, "base64"),
+        originalBytes:
+          originalContentBase64 === null
+            ? null
+            : Buffer.from(originalContentBase64, "base64"),
       })
     )
   );
diff --git a/src/db/repositories/project-state-snapshot.persistence.ts b/src/db/repositories/project-state-snapshot.persistence.ts
index a11cd58..431241b 100644
--- a/src/db/repositories/project-state-snapshot.persistence.ts
+++ b/src/db/repositories/project-state-snapshot.persistence.ts
@@ -20,7 +20,7 @@ import { floors } from "../schema/floors.js";
 import { projectDevices } from "../schema/project-devices.js";
 import { projects } from "../schema/projects.js";
 import { rooms } from "../schema/rooms.js";
-import { externalCsvConfigurations } from "../schema/external-csv-configurations.js";
+import { externalModelConfigurations } from "../schema/external-model-configurations.js";
 import { ExternalModelStateRepository } from "./external-model-state.repository.js";
 
 export interface PersistedProjectStateSnapshot {
@@ -66,10 +66,10 @@ export function readProjectStateSnapshot(
     .where(eq(distributionBoards.projectId, projectId))
     .orderBy(asc(distributionBoards.name), asc(distributionBoards.id))
     .all();
-  const externalCsvConfiguration = database
+  const externalModelConfiguration = database
     .select()
-    .from(externalCsvConfigurations)
-    .where(eq(externalCsvConfigurations.projectId, projectId))
+    .from(externalModelConfigurations)
+    .where(eq(externalModelConfigurations.projectId, projectId))
     .get() ?? null;
   const externalModel = new ExternalModelStateRepository(database)
     .getByProject(projectId).state;
@@ -266,7 +266,7 @@ export function readProjectStateSnapshot(
       projectEditor: project.projectEditor,
     },
     distributionBoards: boardRows,
-    externalCsvConfiguration,
+    externalModelConfiguration,
     externalModel,
     circuitLists: listRows,
     circuitSections: sectionRows,
diff --git a/src/db/repositories/project-transfer.repository.ts b/src/db/repositories/project-transfer.repository.ts
index 1d93afd..fc73db5 100644
--- a/src/db/repositories/project-transfer.repository.ts
+++ b/src/db/repositories/project-transfer.repository.ts
@@ -23,7 +23,7 @@ import { floors } from "../schema/floors.js";
 import { projectDevices } from "../schema/project-devices.js";
 import { projects } from "../schema/projects.js";
 import { rooms } from "../schema/rooms.js";
-import { externalCsvConfigurations } from "../schema/external-csv-configurations.js";
+import { externalModelConfigurations } from "../schema/external-model-configurations.js";
 import { externalImportBatches } from "../schema/external-import-batches.js";
 import { externalModelObjects } from "../schema/external-model-objects.js";
 import { externalModelSources } from "../schema/external-model-sources.js";
@@ -163,10 +163,10 @@ function insertProjectState(
     .insert(projects)
     .values({ ...state.project, currentRevision: 0 })
     .run();
-  if (state.externalCsvConfiguration !== null) {
+  if (state.externalModelConfiguration !== null) {
     database
-      .insert(externalCsvConfigurations)
-      .values(state.externalCsvConfiguration)
+      .insert(externalModelConfigurations)
+      .values(state.externalModelConfiguration)
       .run();
   }
   insertMany(database, buildings, state.buildings);
@@ -240,7 +240,10 @@ function insertProjectState(
     state.externalModel.importBatches.map(
       ({ originalContentBase64, ...batch }) => ({
         ...batch,
-        originalBytes: Buffer.from(originalContentBase64, "base64"),
+        originalBytes:
+          originalContentBase64 === null
+            ? null
+            : Buffer.from(originalContentBase64, "base64"),
       })
     )
   );
diff --git a/src/db/schema/external-csv-configurations.ts b/src/db/schema/external-csv-configurations.ts
deleted file mode 100644
index 2cbcd06..0000000
--- a/src/db/schema/external-csv-configurations.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
-import type { ExternalCsvConfiguration } from "../../external-model/csv/external-csv-contracts.js";
-import { projects } from "./projects.js";
-
-export const externalCsvConfigurations = sqliteTable(
-  "external_csv_configurations",
-  {
-    id: text("id").primaryKey(),
-    projectId: text("project_id")
-      .notNull()
-      .references(() => projects.id, { onDelete: "cascade" }),
-    configurationVersion: integer("configuration_version").notNull(),
-    configuration: text("configuration", { mode: "json" })
-      .$type<ExternalCsvConfiguration>()
-      .notNull(),
-  },
-  (table) => [
-    uniqueIndex("external_csv_configurations_project_id_unique").on(
-      table.projectId
-    ),
-  ]
-);
diff --git a/src/db/schema/external-import-batches.ts b/src/db/schema/external-import-batches.ts
index 125077e..0919891 100644
--- a/src/db/schema/external-import-batches.ts
+++ b/src/db/schema/external-import-batches.ts
@@ -1,9 +1,7 @@
 import { blob, index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
-import type {
-  ExternalCsvConfiguration,
-  ExternalCsvDocument,
-} from "../../external-model/csv/external-csv-contracts.js";
+import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
 import { externalImportKinds } from "../../external-model/domain/external-model-contracts.js";
+import type { ExternalXlsxDocument } from "../../external-model/xlsx/external-xlsx-contracts.js";
 import { externalModelSources } from "./external-model-sources.js";
 import { projects } from "./projects.js";
 
@@ -21,15 +19,13 @@ export const externalImportBatches = sqliteTable(
     importedAtIso: text("imported_at_iso").notNull(),
     fileName: text("file_name").notNull(),
     sha256: text("sha256").notNull(),
-    appliedProjectRevision: integer("applied_project_revision").notNull(),
-    configurationVersion: integer("configuration_version").notNull(),
+    objectCount: integer("object_count").notNull(),
+    appliedProjectRevision: integer("applied_project_revision"),
     configurationSnapshot: text("configuration_snapshot", { mode: "json" })
-      .$type<ExternalCsvConfiguration>()
-      .notNull(),
-    originalBytes: blob("original_bytes", { mode: "buffer" }).notNull(),
+      .$type<ExternalModelConfiguration>(),
+    originalBytes: blob("original_bytes", { mode: "buffer" }),
     document: text("document", { mode: "json" })
-      .$type<ExternalCsvDocument>()
-      .notNull(),
+      .$type<ExternalXlsxDocument>(),
   },
   (table) => [
     index("external_import_batches_project_revision_idx").on(
diff --git a/src/db/schema/external-model-configurations.ts b/src/db/schema/external-model-configurations.ts
new file mode 100644
index 0000000..e28ced7
--- /dev/null
+++ b/src/db/schema/external-model-configurations.ts
@@ -0,0 +1,21 @@
+import { sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
+import { projects } from "./projects.js";
+
+export const externalModelConfigurations = sqliteTable(
+  "external_model_configurations",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id")
+      .notNull()
+      .references(() => projects.id, { onDelete: "cascade" }),
+    configuration: text("configuration", { mode: "json" })
+      .$type<ExternalModelConfiguration>()
+      .notNull(),
+  },
+  (table) => [
+    uniqueIndex("external_model_configurations_project_id_unique").on(
+      table.projectId
+    ),
+  ]
+);
diff --git a/src/db/schema/external-model-objects.ts b/src/db/schema/external-model-objects.ts
index fbd50b7..2de80cb 100644
--- a/src/db/schema/external-model-objects.ts
+++ b/src/db/schema/external-model-objects.ts
@@ -23,7 +23,9 @@ export const externalModelObjects = sqliteTable(
     sourceId: text("source_id")
       .notNull()
       .references(() => externalModelSources.id, { onDelete: "cascade" }),
-    ifcGuid: text("ifc_guid").notNull(),
+    worksharingId: text("worksharing_id").notNull(),
+    ifcGuid: text("ifc_guid"),
+    deviceTypeId: text("device_type_id").notNull(),
     lastSeenImportBatchId: text("last_seen_import_batch_id")
       .notNull()
       .references(() => externalImportBatches.id, { onDelete: "restrict" }),
@@ -62,17 +64,27 @@ export const externalModelObjects = sqliteTable(
       .default("present"),
   },
   (table) => [
-    uniqueIndex("external_model_objects_source_ifc_guid_unique").on(
+    uniqueIndex("external_model_objects_source_worksharing_id_unique").on(
       table.sourceId,
-      table.ifcGuid
+      table.worksharingId
     ),
     index("external_model_objects_project_presence_idx").on(
       table.projectId,
       table.presenceStatus
     ),
+    index("external_model_objects_project_device_type_idx").on(
+      table.projectId,
+      table.deviceTypeId
+    ),
+    index("external_model_objects_external_room_mapping_idx").on(
+      table.externalRoomMappingId
+    ),
     index("external_model_objects_distribution_board_idx").on(
       table.distributionBoardId
     ),
+    index("external_model_objects_linked_project_device_idx").on(
+      table.linkedProjectDeviceId
+    ),
     index("external_model_objects_circuit_device_row_idx").on(
       table.circuitDeviceRowId
     ),
diff --git a/src/db/schema/external-model-sources.ts b/src/db/schema/external-model-sources.ts
index a4f9ded..7dfb3d1 100644
--- a/src/db/schema/external-model-sources.ts
+++ b/src/db/schema/external-model-sources.ts
@@ -12,12 +12,9 @@ export const externalModelSources = sqliteTable(
     name: text("name").notNull(),
     sourceType: text("source_type", { enum: externalModelSourceTypes })
       .notNull()
-      .default("revit_csv"),
+      .default("revit_xlsx"),
   },
   (table) => [
-    uniqueIndex("external_model_sources_project_type_unique").on(
-      table.projectId,
-      table.sourceType
-    ),
+    uniqueIndex("external_model_sources_project_unique").on(table.projectId),
   ]
 );
diff --git a/src/domain/models/external-csv-configuration-project-command.model.ts b/src/domain/models/external-csv-configuration-project-command.model.ts
deleted file mode 100644
index bb87342..0000000
--- a/src/domain/models/external-csv-configuration-project-command.model.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-import { assertExternalCsvConfiguration } from "../../external-model/csv/external-csv-configuration.js";
-import type { ExternalCsvConfiguration } from "../../external-model/csv/external-csv-contracts.js";
-import type { SerializedProjectCommand } from "./project-command.model.js";
-
-export const externalCsvConfigurationUpdateCommandType =
-  "external-csv-configuration.update" as const;
-export const externalCsvConfigurationCommandSchemaVersion = 1 as const;
-
-export interface ExternalCsvConfigurationSnapshot {
-  id: string;
-  projectId: string;
-  configurationVersion: number;
-  configuration: ExternalCsvConfiguration;
-}
-
-export interface ExternalCsvConfigurationUpdatePayload {
-  expected: ExternalCsvConfigurationSnapshot | null;
-  target: ExternalCsvConfigurationSnapshot | null;
-}
-
-export interface ExternalCsvConfigurationUpdateProjectCommand
-  extends SerializedProjectCommand<ExternalCsvConfigurationUpdatePayload> {
-  schemaVersion: typeof externalCsvConfigurationCommandSchemaVersion;
-  type: typeof externalCsvConfigurationUpdateCommandType;
-}
-
-export function createExternalCsvConfigurationUpdateProjectCommand(
-  expected: ExternalCsvConfigurationSnapshot | null,
-  target: ExternalCsvConfigurationSnapshot | null
-): ExternalCsvConfigurationUpdateProjectCommand {
-  const command: ExternalCsvConfigurationUpdateProjectCommand = {
-    schemaVersion: externalCsvConfigurationCommandSchemaVersion,
-    type: externalCsvConfigurationUpdateCommandType,
-    payload: { expected, target },
-  };
-  assertExternalCsvConfigurationUpdateProjectCommand(command);
-  return command;
-}
-
-export function assertExternalCsvConfigurationUpdateProjectCommand(
-  command: SerializedProjectCommand<unknown>
-): asserts command is ExternalCsvConfigurationUpdateProjectCommand {
-  if (
-    command.schemaVersion !== externalCsvConfigurationCommandSchemaVersion ||
-    command.type !== externalCsvConfigurationUpdateCommandType ||
-    !isRecord(command.payload)
-  ) {
-    throw new Error("Unsupported external CSV configuration update command.");
-  }
-  assertSnapshot(command.payload.expected, "expected");
-  assertSnapshot(command.payload.target, "target");
-  if (command.payload.expected === null && command.payload.target === null) {
-    throw new Error("External CSV configuration command must change state.");
-  }
-  if (
-    command.payload.expected !== null &&
-    command.payload.target !== null &&
-    (command.payload.expected.id !== command.payload.target.id ||
-      command.payload.expected.projectId !== command.payload.target.projectId)
-  ) {
-    throw new Error("External CSV configuration identity must remain stable.");
-  }
-}
-
-function assertSnapshot(
-  value: unknown,
-  field: string
-): asserts value is ExternalCsvConfigurationSnapshot | null {
-  if (value === null) {
-    return;
-  }
-  if (!isRecord(value)) {
-    throw new Error(`${field} external CSV configuration must be an object or null.`);
-  }
-  assertId(value.id, `${field}.id`);
-  assertId(value.projectId, `${field}.projectId`);
-  if (!Number.isSafeInteger(value.configurationVersion) || (value.configurationVersion as number) < 1) {
-    throw new Error(`${field}.configurationVersion must be a positive integer.`);
-  }
-  assertExternalCsvConfiguration(value.configuration);
-  if (Object.keys(value).length !== 4) {
-    throw new Error(`${field} external CSV configuration contains unknown fields.`);
-  }
-}
-
-function assertId(value: unknown, field: string) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`${field} must be a non-empty string.`);
-  }
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
diff --git a/src/domain/models/external-initial-import-project-command.model.ts b/src/domain/models/external-initial-import-project-command.model.ts
deleted file mode 100644
index 2004cfc..0000000
--- a/src/domain/models/external-initial-import-project-command.model.ts
+++ /dev/null
@@ -1,134 +0,0 @@
-import type { ExternalModelStateSnapshot } from "../../external-model/domain/external-model-contracts.js";
-import { parseExternalModelStateSnapshot } from "./project-state-snapshot.model.js";
-import type { SerializedProjectCommand } from "./project-command.model.js";
-
-export const externalInitialImportCommandType =
-  "external-import.apply-initial" as const;
-export const externalInitialImportCommandSchemaVersion = 1 as const;
-
-export interface ExternalInitialImportPayload {
-  expected: ExternalModelStateSnapshot;
-  target: ExternalModelStateSnapshot;
-}
-
-export interface ExternalInitialImportProjectCommand
-  extends SerializedProjectCommand<ExternalInitialImportPayload> {
-  schemaVersion: typeof externalInitialImportCommandSchemaVersion;
-  type: typeof externalInitialImportCommandType;
-}
-
-export function createExternalInitialImportProjectCommand(
-  expected: ExternalModelStateSnapshot,
-  target: ExternalModelStateSnapshot
-): ExternalInitialImportProjectCommand {
-  const command: ExternalInitialImportProjectCommand = {
-    schemaVersion: externalInitialImportCommandSchemaVersion,
-    type: externalInitialImportCommandType,
-    payload: { expected, target },
-  };
-  assertExternalInitialImportProjectCommand(command);
-  return command;
-}
-
-export function assertExternalInitialImportProjectCommand(
-  command: SerializedProjectCommand<unknown>
-): asserts command is ExternalInitialImportProjectCommand {
-  if (
-    command.schemaVersion !== externalInitialImportCommandSchemaVersion ||
-    command.type !== externalInitialImportCommandType ||
-    !isRecord(command.payload) ||
-    Object.keys(command.payload).length !== 2
-  ) {
-    throw new Error("Unsupported external initial import command.");
-  }
-  const expected = parseExternalModelStateSnapshot(command.payload.expected);
-  const target = parseExternalModelStateSnapshot(command.payload.target);
-  const expectedIsEmpty = isEmptyExternalModelState(expected);
-  const targetIsEmpty = isEmptyExternalModelState(target);
-  if (expectedIsEmpty === targetIsEmpty) {
-    throw new Error("External initial import must transition between empty and populated state.");
-  }
-  assertPopulatedInitialState(expectedIsEmpty ? target : expected);
-}
-
-export function createEmptyExternalModelState(): ExternalModelStateSnapshot {
-  return { source: null, importBatches: [], roomMappings: [], objects: [] };
-}
-
-export function isEmptyExternalModelState(state: ExternalModelStateSnapshot) {
-  return (
-    state.source === null &&
-    state.importBatches.length === 0 &&
-    state.roomMappings.length === 0 &&
-    state.objects.length === 0
-  );
-}
-
-function assertPopulatedInitialState(state: ExternalModelStateSnapshot) {
-  if (state.source === null || state.importBatches.length !== 1 || state.objects.length === 0) {
-    throw new Error("External initial import requires one source, one batch and at least one object.");
-  }
-  const source = state.source;
-  const batch = state.importBatches[0];
-  if (
-    batch.importKind !== "initial" ||
-    batch.projectId !== source.projectId ||
-    batch.sourceId !== source.id
-  ) {
-    throw new Error("External initial import batch identity is invalid.");
-  }
-  const mappingIds = uniqueIds(state.roomMappings, "room mapping");
-  const roomKeys = new Set<string>();
-  for (const mapping of state.roomMappings) {
-    if (mapping.projectId !== source.projectId || mapping.sourceId !== source.id) {
-      throw new Error("External initial room mapping identity is invalid.");
-    }
-    if (roomKeys.has(mapping.normalizedSourceRoomKey)) {
-      throw new Error("External initial import contains duplicate room keys.");
-    }
-    roomKeys.add(mapping.normalizedSourceRoomKey);
-  }
-  uniqueIds(state.objects, "object");
-  const ifcGuids = new Set<string>();
-  for (const object of state.objects) {
-    if (
-      object.projectId !== source.projectId ||
-      object.sourceId !== source.id ||
-      object.lastSeenImportBatchId !== batch.id ||
-      object.lastAcceptedImportBatchId !== batch.id
-    ) {
-      throw new Error("External initial object identity is invalid.");
-    }
-    if (ifcGuids.has(object.ifcGuid)) {
-      throw new Error("External initial import contains duplicate IFCGUIDs.");
-    }
-    ifcGuids.add(object.ifcGuid);
-    if (
-      object.externalRoomMappingId !== null &&
-      !mappingIds.has(object.externalRoomMappingId)
-    ) {
-      throw new Error("External initial object room mapping is invalid.");
-    }
-    if (object.circuitDeviceRowId !== null) {
-      throw new Error("External initial import must not assign circuit device rows.");
-    }
-    if (object.presenceStatus !== "present") {
-      throw new Error("External initial import objects must be present.");
-    }
-  }
-}
-
-function uniqueIds(entries: ReadonlyArray<{ id: string }>, label: string) {
-  const ids = new Set<string>();
-  for (const entry of entries) {
-    if (ids.has(entry.id)) {
-      throw new Error(`External initial import contains duplicate ${label} ids.`);
-    }
-    ids.add(entry.id);
-  }
-  return ids;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
diff --git a/src/domain/models/external-model-configuration-project-command.model.ts b/src/domain/models/external-model-configuration-project-command.model.ts
new file mode 100644
index 0000000..e606b6a
--- /dev/null
+++ b/src/domain/models/external-model-configuration-project-command.model.ts
@@ -0,0 +1,88 @@
+import {
+  assertExternalModelConfiguration,
+  type ExternalModelConfiguration,
+} from "../../external-model/configuration/external-model-configuration.js";
+import type { SerializedProjectCommand } from "./project-command.model.js";
+
+export const externalModelConfigurationUpdateCommandType =
+  "external-model-configuration.update" as const;
+export const externalModelConfigurationCommandSchemaVersion = 1 as const;
+
+export interface ExternalModelConfigurationSnapshot {
+  id: string;
+  projectId: string;
+  configuration: ExternalModelConfiguration;
+}
+
+export interface ExternalModelConfigurationUpdatePayload {
+  expected: ExternalModelConfigurationSnapshot | null;
+  target: ExternalModelConfigurationSnapshot | null;
+}
+
+export interface ExternalModelConfigurationUpdateProjectCommand
+  extends SerializedProjectCommand<ExternalModelConfigurationUpdatePayload> {
+  schemaVersion: typeof externalModelConfigurationCommandSchemaVersion;
+  type: typeof externalModelConfigurationUpdateCommandType;
+}
+
+export function createExternalModelConfigurationUpdateProjectCommand(
+  expected: ExternalModelConfigurationSnapshot | null,
+  target: ExternalModelConfigurationSnapshot | null
+): ExternalModelConfigurationUpdateProjectCommand {
+  const command: ExternalModelConfigurationUpdateProjectCommand = {
+    schemaVersion: externalModelConfigurationCommandSchemaVersion,
+    type: externalModelConfigurationUpdateCommandType,
+    payload: { expected, target },
+  };
+  assertExternalModelConfigurationUpdateProjectCommand(command);
+  return command;
+}
+
+export function assertExternalModelConfigurationUpdateProjectCommand(
+  command: SerializedProjectCommand<unknown>
+): asserts command is ExternalModelConfigurationUpdateProjectCommand {
+  if (
+    command.schemaVersion !== externalModelConfigurationCommandSchemaVersion ||
+    command.type !== externalModelConfigurationUpdateCommandType ||
+    !isRecord(command.payload) ||
+    Object.keys(command.payload).length !== 2
+  ) {
+    throw new Error("Nicht unterstützter Revit-XLSX-Konfigurationscommand.");
+  }
+  assertSnapshot(command.payload.expected, "expected");
+  assertSnapshot(command.payload.target, "target");
+  if (command.payload.expected === null && command.payload.target === null) {
+    throw new Error("Der Konfigurationscommand muss den Zustand ändern.");
+  }
+  if (
+    command.payload.expected !== null &&
+    command.payload.target !== null &&
+    (command.payload.expected.id !== command.payload.target.id ||
+      command.payload.expected.projectId !== command.payload.target.projectId)
+  ) {
+    throw new Error("Die Identität der Revit-XLSX-Konfiguration muss stabil bleiben.");
+  }
+}
+
+function assertSnapshot(
+  value: unknown,
+  field: string
+): asserts value is ExternalModelConfigurationSnapshot | null {
+  if (value === null) return;
+  if (!isRecord(value) || Object.keys(value).length !== 3) {
+    throw new Error(`${field} muss eine vollständige Konfiguration oder null sein.`);
+  }
+  assertId(value.id, `${field}.id`);
+  assertId(value.projectId, `${field}.projectId`);
+  assertExternalModelConfiguration(value.configuration);
+}
+
+function assertId(value: unknown, field: string) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${field} muss eine nichtleere ID sein.`);
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
diff --git a/src/domain/models/project-state-snapshot.model.ts b/src/domain/models/project-state-snapshot.model.ts
index ea3aba7..2296bc1 100644
--- a/src/domain/models/project-state-snapshot.model.ts
+++ b/src/domain/models/project-state-snapshot.model.ts
@@ -28,6 +28,10 @@ import {
 } from "../services/project-voltage.service.js";
 import { validateExternalCsvConfiguration } from "../../external-model/csv/external-csv-configuration.js";
 import type { ExternalCsvConfiguration } from "../../external-model/csv/external-csv-contracts.js";
+import {
+  validateExternalModelConfiguration,
+  type ExternalModelConfiguration,
+} from "../../external-model/configuration/external-model-configuration.js";
 import {
   externalImportKinds,
   externalModelSourceTypes,
@@ -35,7 +39,8 @@ import {
   type ExternalModelStateSnapshot,
 } from "../../external-model/domain/external-model-contracts.js";
 
-export const projectStateSnapshotSchemaVersion = 9 as const;
+export const projectStateSnapshotSchemaVersion = 10 as const;
+const legacyCsvProjectStateSnapshotSchemaVersion = 9 as const;
 const roomAreaProjectStateSnapshotSchemaVersion = 8 as const;
 const buildingProjectStateSnapshotSchemaVersion = 7 as const;
 const coverProjectStateSnapshotSchemaVersion = 6 as const;
@@ -423,14 +428,14 @@ const externalCsvDocumentSchema = z.object({
   });
 });
 
-const externalModelSourceSchema = z.object({
+const legacyExternalModelSourceSchema = z.object({
   id: idSchema,
   projectId: idSchema,
   name: z.string().trim().min(1),
-  sourceType: z.enum(externalModelSourceTypes),
+  sourceType: z.literal("revit_csv"),
 }).strict();
 
-const externalImportBatchSchema = z.object({
+const legacyExternalImportBatchSchema = z.object({
   id: idSchema,
   projectId: idSchema,
   sourceId: idSchema,
@@ -461,7 +466,7 @@ const externalRoomMappingSchema = z.object({
   defaultDistributionBoardId: idSchema.nullable(),
 }).strict();
 
-const externalPlanningFieldNames = [
+const legacyExternalPlanningFieldNames = [
   "displayName",
   "internalDeviceType",
   "category",
@@ -474,7 +479,7 @@ const externalPlanningFieldNames = [
   "remark",
 ] as const;
 
-const externalModelObjectSchema = z.object({
+const legacyExternalModelObjectSchema = z.object({
   id: idSchema,
   projectId: idSchema,
   sourceId: idSchema,
@@ -504,6 +509,170 @@ const externalModelObjectSchema = z.object({
     costGroup: nullableStringSchema,
     remark: nullableStringSchema,
   }).strict(),
+  overriddenFields: z.array(z.enum(legacyExternalPlanningFieldNames)).refine(
+    (values) => new Set(values).size === values.length
+  ),
+  externalRoomMappingId: idSchema.nullable(),
+  distributionBoardId: idSchema.nullable(),
+  linkedProjectDeviceId: idSchema.nullable(),
+  circuitDeviceRowId: idSchema.nullable(),
+  presenceStatus: z.enum(externalObjectPresenceStatuses),
+}).strict();
+
+const legacyExternalModelStateSchema = z.object({
+  source: legacyExternalModelSourceSchema.nullable(),
+  importBatches: z.array(legacyExternalImportBatchSchema),
+  roomMappings: z.array(externalRoomMappingSchema),
+  objects: z.array(legacyExternalModelObjectSchema),
+}).strict();
+
+const externalModelConfigurationSnapshotSchema = z.object({
+  id: idSchema,
+  projectId: idSchema,
+  configuration: z.custom<ExternalModelConfiguration>(
+    (value) => validateExternalModelConfiguration(value).success
+  ),
+}).strict();
+
+const externalXlsxScalarSchema = z.union([
+  z.string(),
+  finiteNumberSchema,
+  z.boolean(),
+  z.null(),
+]);
+
+const externalXlsxDocumentSchema = z.object({
+  sheetName: z.string().min(1).max(31),
+  headerRowNumber: z.number().int().positive(),
+  firstDataRowNumber: z.number().int().positive(),
+  firstDataColumnNumber: z.number().int().positive(),
+  columns: z.array(z.object({
+    columnNumber: z.number().int().positive(),
+    header: z.string(),
+    comment: z.string().nullable(),
+    width: finiteNumberSchema.positive().nullable(),
+  }).strict()),
+  rows: z.array(z.object({
+    rowNumber: z.number().int().positive(),
+    classification: z.enum(["object", "suspect-object", "passthrough"]),
+    cells: z.array(z.object({
+      columnNumber: z.number().int().positive(),
+      value: externalXlsxScalarSchema,
+      valueType: z.enum(["empty", "string", "number", "boolean"]),
+      numberFormat: z.string().nullable(),
+      formula: z.string().nullable(),
+      usedCachedFormulaValue: z.boolean(),
+    }).strict()),
+  }).strict()),
+  issues: z.array(z.object({
+    code: z.enum([
+      "cached-formula-value-used",
+      "formula-without-cached-value",
+      "suspect-object-skipped",
+      "duplicate-ifc-guid",
+      "optional-return-column-missing",
+    ]),
+    message: z.string().min(1),
+    rowNumber: z.number().int().positive().optional(),
+    columnNumber: z.number().int().positive().optional(),
+    field: z.enum([
+      "worksharingId", "ifcGuid", "roomNumber", "roomName",
+      "familyAndType", "selectionMarker", "socketCount", "sourceRemark",
+      "circuitCombined", "boardName", "circuitIdentifier", "designation",
+      "electricalPowerW", "voltageV", "currentA",
+    ]).optional(),
+  }).strict()),
+}).strict();
+
+const externalModelSourceSchema = z.object({
+  id: idSchema,
+  projectId: idSchema,
+  name: z.string().trim().min(1),
+  sourceType: z.enum(externalModelSourceTypes),
+}).strict();
+
+const externalImportBatchSchema = z.object({
+  id: idSchema,
+  projectId: idSchema,
+  sourceId: idSchema,
+  importKind: z.enum(externalImportKinds),
+  importedAtIso: z.string().refine((value) => Number.isFinite(Date.parse(value))),
+  fileName: z.string().trim().min(1),
+  sha256: z.string().regex(/^[a-f0-9]{64}$/),
+  objectCount: z.number().int().nonnegative(),
+  appliedProjectRevision: z.number().int().nonnegative().nullable(),
+  configurationSnapshot: z.custom<ExternalModelConfiguration>(
+    (value) => value === null || validateExternalModelConfiguration(value).success
+  ).nullable(),
+  originalContentBase64: z.string().min(1).regex(
+    /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/
+  ).nullable(),
+  document: externalXlsxDocumentSchema.nullable(),
+}).strict().superRefine((batch, context) => {
+  const complete = [
+    batch.appliedProjectRevision,
+    batch.configurationSnapshot,
+    batch.originalContentBase64,
+    batch.document,
+  ].map((value) => value !== null);
+  if (!complete.every((value) => value === complete[0])) {
+    context.addIssue({
+      code: "custom",
+      message: "Importbatch muss vollständig oder auf Metadaten reduziert sein.",
+    });
+  }
+});
+
+const externalPlanningFieldNames = [
+  "displayName",
+  "category",
+  "connectionKind",
+  "effectiveQuantity",
+  "powerPerUnitW",
+  "simultaneityFactor",
+  "cosPhi",
+  "costGroup",
+  "remark",
+] as const;
+
+const externalModelObjectSchema = z.object({
+  id: idSchema,
+  projectId: idSchema,
+  sourceId: idSchema,
+  worksharingId: z.string().regex(
+    /^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}-[0-9A-Fa-f]{8}$/
+  ),
+  ifcGuid: externalIfcGuidSchema.nullable(),
+  deviceTypeId: idSchema,
+  lastSeenImportBatchId: idSchema,
+  lastAcceptedImportBatchId: idSchema,
+  acceptedSourceValues: z.object({
+    rowNumber: z.number().int().positive(),
+    roomNumber: externalXlsxScalarSchema,
+    roomName: externalXlsxScalarSchema,
+    familyAndType: z.string().min(1),
+    selectionMarker: externalXlsxScalarSchema,
+    socketCount: externalXlsxScalarSchema,
+    sourceRemark: externalXlsxScalarSchema,
+    circuitCombined: externalXlsxScalarSchema,
+    boardName: externalXlsxScalarSchema,
+    circuitIdentifier: externalXlsxScalarSchema,
+    designation: externalXlsxScalarSchema,
+    electricalPowerW: externalXlsxScalarSchema,
+    voltageV: externalXlsxScalarSchema,
+    currentA: externalXlsxScalarSchema,
+  }).strict(),
+  planningValues: z.object({
+    displayName: nullableStringSchema,
+    category: z.enum(circuitGroupCategories).nullable(),
+    connectionKind: nullableStringSchema,
+    effectiveQuantity: finiteNumberSchema.positive(),
+    powerPerUnitW: finiteNumberSchema.nonnegative().nullable(),
+    simultaneityFactor: finiteNumberSchema.min(0).max(1).nullable(),
+    cosPhi: finiteNumberSchema.positive().max(1).nullable(),
+    costGroup: nullableStringSchema,
+    remark: nullableStringSchema,
+  }).strict(),
   overriddenFields: z.array(z.enum(externalPlanningFieldNames)).refine(
     (values) => new Set(values).size === values.length
   ),
@@ -519,7 +688,21 @@ const externalModelStateSchema = z.object({
   importBatches: z.array(externalImportBatchSchema),
   roomMappings: z.array(externalRoomMappingSchema),
   objects: z.array(externalModelObjectSchema),
-}).strict();
+}).strict().superRefine((state, context) => {
+  const fullBatchIndexes = state.importBatches.flatMap((batch, index) =>
+    batch.originalContentBase64 === null ? [] : [index]
+  );
+  if (
+    state.importBatches.length > 0 &&
+    (fullBatchIndexes.length !== 1 ||
+      fullBatchIndexes[0] !== state.importBatches.length - 1)
+  ) {
+    context.addIssue({
+      code: "custom",
+      message: "Nur der letzte Importbatch darf vollständig gespeichert sein.",
+    });
+  }
+});
 
 export function parseExternalModelStateSnapshot(
   value: unknown
@@ -565,19 +748,30 @@ export const projectStateSnapshotSchema = z
     schemaVersion: z.literal(projectStateSnapshotSchemaVersion),
     project: projectSchema,
     distributionBoards: z.array(distributionBoardSchema),
-    externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
+    externalModelConfiguration: externalModelConfigurationSnapshotSchema.nullable(),
     externalModel: externalModelStateSchema,
     ...projectStateSnapshotContents,
   })
   .strict();
 
+const legacyCsvProjectStateSnapshotSchema = z
+  .object({
+    schemaVersion: z.literal(legacyCsvProjectStateSnapshotSchemaVersion),
+    project: projectSchema,
+    distributionBoards: z.array(distributionBoardSchema),
+    externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
+    externalModel: legacyExternalModelStateSchema,
+    ...projectStateSnapshotContents,
+  })
+  .strict();
+
 const roomAreaProjectStateSnapshotSchema = z
   .object({
     schemaVersion: z.literal(roomAreaProjectStateSnapshotSchemaVersion),
     project: projectSchema,
     distributionBoards: z.array(distributionBoardWithoutFeedingSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
-    externalModel: externalModelStateSchema,
+    externalModel: legacyExternalModelStateSchema,
     ...projectStateSnapshotContents,
   })
   .strict();
@@ -588,7 +782,7 @@ const buildingProjectStateSnapshotSchema = z
     project: projectSchema,
     distributionBoards: z.array(distributionBoardWithoutFeedingSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
-    externalModel: externalModelStateSchema,
+    externalModel: legacyExternalModelStateSchema,
     ...buildingProjectStateSnapshotContents,
   })
   .strict();
@@ -599,7 +793,7 @@ const coverProjectStateSnapshotSchema = z
     project: projectSchema,
     distributionBoards: z.array(distributionBoardWithoutFeedingSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
-    externalModel: externalModelStateSchema,
+    externalModel: legacyExternalModelStateSchema,
     ...previousProjectStateSnapshotContents,
   })
   .strict();
@@ -610,7 +804,7 @@ const boardInfoProjectStateSnapshotSchema = z
     project: publicBuildingProjectSchema,
     distributionBoards: z.array(legacyDistributionBoardSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
-    externalModel: externalModelStateSchema,
+    externalModel: legacyExternalModelStateSchema,
     ...previousProjectStateSnapshotContents,
   })
   .strict();
@@ -621,7 +815,7 @@ const previousProjectStateSnapshotSchema = z
     project: publicBuildingProjectSchema,
     distributionBoards: z.array(legacyDistributionBoardSchema),
     externalCsvConfiguration: externalCsvConfigurationSnapshotSchema.nullable(),
-    externalModel: externalModelStateSchema,
+    externalModel: legacyExternalModelStateSchema,
     ...previousProjectStateSnapshotContents,
   })
   .strict();
@@ -684,6 +878,39 @@ export function parseProjectStateSnapshot(
 }
 
 function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
+  const legacyCsv = upgradeToLegacyCsvProjectStateSnapshot(value);
+  if (
+    legacyCsv !== null &&
+    typeof legacyCsv === "object" &&
+    !Array.isArray(legacyCsv) &&
+    (legacyCsv as { schemaVersion?: unknown }).schemaVersion ===
+      legacyCsvProjectStateSnapshotSchemaVersion
+  ) {
+    const previous = legacyCsvProjectStateSnapshotSchema.parse(legacyCsv);
+    if (
+      previous.externalCsvConfiguration !== null ||
+      !isEmptyExternalModelState(previous.externalModel)
+    ) {
+      throw new Error(
+        "Dieser alte Projektstand enthält Revit-CSV-Daten und kann nicht auf die Revit-XLSX-Struktur aktualisiert werden."
+      );
+    }
+    const {
+      externalCsvConfiguration: _externalCsvConfiguration,
+      externalModel: _legacyExternalModel,
+      ...remaining
+    } = previous;
+    return {
+      ...remaining,
+      schemaVersion: projectStateSnapshotSchemaVersion,
+      externalModelConfiguration: null,
+      externalModel: emptyExternalModelState(),
+    };
+  }
+  return legacyCsv;
+}
+
+function upgradeToLegacyCsvProjectStateSnapshot(value: unknown): unknown {
   const roomArea = upgradeToRoomAreaProjectStateSnapshot(value);
   if (
     roomArea !== null &&
@@ -695,7 +922,7 @@ function upgradePreviousProjectStateSnapshot(value: unknown): unknown {
     const previous = roomAreaProjectStateSnapshotSchema.parse(roomArea);
     return {
       ...previous,
-      schemaVersion: projectStateSnapshotSchemaVersion,
+      schemaVersion: legacyCsvProjectStateSnapshotSchemaVersion,
       distributionBoards: withEmptyDistributionBoardFeeding(
         previous.distributionBoards
       ),
@@ -830,6 +1057,20 @@ function emptyExternalModelState() {
   };
 }
 
+function isEmptyExternalModelState(state: {
+  source: unknown;
+  importBatches: unknown[];
+  roomMappings: unknown[];
+  objects: unknown[];
+}) {
+  return (
+    state.source === null &&
+    state.importBatches.length === 0 &&
+    state.roomMappings.length === 0 &&
+    state.objects.length === 0
+  );
+}
+
 function normalizeSnapshotPhaseTypes(
   snapshot: ProjectStateSnapshot
 ): ProjectStateSnapshot {
@@ -891,10 +1132,10 @@ function assertProjectStateSnapshotRelations(
 ) {
   const projectId = snapshot.project.id;
   if (
-    snapshot.externalCsvConfiguration !== null &&
-    snapshot.externalCsvConfiguration.projectId !== projectId
+    snapshot.externalModelConfiguration !== null &&
+    snapshot.externalModelConfiguration.projectId !== projectId
   ) {
-    throw new Error("Snapshot external CSV configuration belongs to a different project.");
+    throw new Error("Snapshot Revit-XLSX configuration belongs to a different project.");
   }
   const boardIds = uniqueIds(
     snapshot.distributionBoards,
@@ -1235,6 +1476,12 @@ function assertExternalModelRelations(
     }
     return;
   }
+  if (snapshot.externalModelConfiguration === null) {
+    throw new Error("Snapshot external model requires a Revit-XLSX configuration.");
+  }
+  if (importBatches.length === 0) {
+    throw new Error("Snapshot external model source requires an import batch.");
+  }
   assertProjectOwnership(source.projectId, references.projectId, "external model source");
   const batchIds = uniqueIds(importBatches, "external import batch");
   const mappingIds = uniqueIds(roomMappings, "external room mapping");
@@ -1270,17 +1517,23 @@ function assertExternalModelRelations(
     }
   }
 
-  const ifcGuids = new Set<string>();
+  const worksharingIds = new Set<string>();
+  const deviceTypeIds = new Set(
+    snapshot.externalModelConfiguration.configuration.deviceTypes.map(
+      (deviceType) => deviceType.id
+    )
+  );
   for (const object of objects) {
     assertProjectOwnership(object.projectId, references.projectId, "external model object");
     if (object.sourceId !== source.id) {
       throw new Error("Snapshot external model object belongs to a different source.");
     }
     assertUniqueKey(
-      ifcGuids,
-      object.ifcGuid,
-      "Snapshot contains duplicate external IFCGUIDs."
+      worksharingIds,
+      object.worksharingId,
+      "Snapshot contains duplicate external Worksharing-IDs."
     );
+    assertReference(deviceTypeIds, object.deviceTypeId, "external object device type");
     assertReference(batchIds, object.lastSeenImportBatchId, "external object last-seen batch");
     assertReference(batchIds, object.lastAcceptedImportBatchId, "external object accepted batch");
     if (object.externalRoomMappingId !== null) {
diff --git a/src/domain/models/project-transfer.model.ts b/src/domain/models/project-transfer.model.ts
index d68b29e..e067896 100644
--- a/src/domain/models/project-transfer.model.ts
+++ b/src/domain/models/project-transfer.model.ts
@@ -146,16 +146,35 @@ export function remapProjectState(
     createId
   );
   const externalObjectIds = idMap(source.externalModel.objects, createId);
+  const configurations = [
+    source.externalModelConfiguration?.configuration ?? null,
+    ...source.externalModel.importBatches.map(
+      (batch) => batch.configurationSnapshot
+    ),
+  ].filter((configuration) => configuration !== null);
+  const deviceTypeIds = uniqueIdMap(
+    configurations.flatMap((configuration) => configuration.deviceTypes),
+    createId
+  );
+  const familyRuleIds = uniqueIdMap(
+    configurations.flatMap((configuration) => configuration.familyTypeRules),
+    createId
+  );
   return parseProjectStateSnapshot({
     ...source,
     project: { ...source.project, id: targetProjectId, name },
-    externalCsvConfiguration:
-      source.externalCsvConfiguration === null
+    externalModelConfiguration:
+      source.externalModelConfiguration === null
         ? null
         : {
-            ...source.externalCsvConfiguration,
+            ...source.externalModelConfiguration,
             id: createId(),
             projectId: targetProjectId,
+            configuration: remapExternalModelConfiguration(
+              source.externalModelConfiguration.configuration,
+              deviceTypeIds,
+              familyRuleIds
+            ),
           },
     externalModel: {
       source: source.externalModel.source === null
@@ -170,6 +189,14 @@ export function remapProjectState(
         id: requiredId(externalBatchIds, batch.id),
         projectId: targetProjectId,
         sourceId: externalSourceId!,
+        configurationSnapshot:
+          batch.configurationSnapshot === null
+            ? null
+            : remapExternalModelConfiguration(
+                batch.configurationSnapshot,
+                deviceTypeIds,
+                familyRuleIds
+              ),
       })),
       roomMappings: source.externalModel.roomMappings.map((mapping) => ({
         ...mapping,
@@ -190,6 +217,7 @@ export function remapProjectState(
         id: requiredId(externalObjectIds, object.id),
         projectId: targetProjectId,
         sourceId: externalSourceId!,
+        deviceTypeId: requiredId(deviceTypeIds, object.deviceTypeId),
         lastSeenImportBatchId: requiredId(
           externalBatchIds,
           object.lastSeenImportBatchId
@@ -322,6 +350,36 @@ export function remapProjectState(
   });
 }
 
+function remapExternalModelConfiguration(
+  configuration: NonNullable<
+    ProjectStateSnapshot["externalModelConfiguration"]
+  >["configuration"],
+  deviceTypeIds: ReadonlyMap<string, string>,
+  familyRuleIds: ReadonlyMap<string, string>
+) {
+  return {
+    ...configuration,
+    deviceTypes: configuration.deviceTypes.map((deviceType) => ({
+      ...deviceType,
+      id: requiredId(deviceTypeIds, deviceType.id),
+    })),
+    familyTypeRules: configuration.familyTypeRules.map((rule) => ({
+      ...rule,
+      id: requiredId(familyRuleIds, rule.id),
+      deviceTypeId: requiredId(deviceTypeIds, rule.deviceTypeId),
+    })),
+  };
+}
+
+function uniqueIdMap(
+  entries: ReadonlyArray<{ id: string }>,
+  createId: () => string
+) {
+  return new Map(
+    [...new Set(entries.map((entry) => entry.id))].map((id) => [id, createId()])
+  );
+}
+
 function idMap(
   entries: ReadonlyArray<{ id: string }>,
   createId: () => string
diff --git a/src/domain/ports/external-csv-configuration-project-command.store.ts b/src/domain/ports/external-csv-configuration-project-command.store.ts
deleted file mode 100644
index 0bc74b4..0000000
--- a/src/domain/ports/external-csv-configuration-project-command.store.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import type { ExternalCsvConfigurationUpdateProjectCommand } from "../models/external-csv-configuration-project-command.model.js";
-import type { AppendedProjectRevision, ProjectRevisionSource } from "./project-revision.store.js";
-
-export interface ExecuteExternalCsvConfigurationCommandInput {
-  projectId: string;
-  expectedRevision: number;
-  source: ProjectRevisionSource;
-  description?: string;
-  actorId?: string;
-  historyTargetChangeSetId?: string;
-  command: ExternalCsvConfigurationUpdateProjectCommand;
-}
-
-export interface ExternalCsvConfigurationProjectCommandStore {
-  execute(input: ExecuteExternalCsvConfigurationCommandInput): {
-    revision: AppendedProjectRevision;
-    inverse: ExternalCsvConfigurationUpdateProjectCommand;
-  };
-}
diff --git a/src/domain/ports/external-csv-configuration.reader.ts b/src/domain/ports/external-csv-configuration.reader.ts
deleted file mode 100644
index a50144b..0000000
--- a/src/domain/ports/external-csv-configuration.reader.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import type { ExternalCsvConfigurationSnapshot } from "../models/external-csv-configuration-project-command.model.js";
-
-export interface ExternalCsvConfigurationReadResult {
-  projectExists: boolean;
-  configuration: ExternalCsvConfigurationSnapshot | null;
-}
-
-export interface ExternalCsvConfigurationReader {
-  getByProject(projectId: string): ExternalCsvConfigurationReadResult;
-}
diff --git a/src/domain/ports/external-initial-import-project-command.store.ts b/src/domain/ports/external-initial-import-project-command.store.ts
deleted file mode 100644
index db1917e..0000000
--- a/src/domain/ports/external-initial-import-project-command.store.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import type { ExternalInitialImportProjectCommand } from "../models/external-initial-import-project-command.model.js";
-import type { AppendedProjectRevision, ProjectRevisionSource } from "./project-revision.store.js";
-
-export interface ExecuteExternalInitialImportCommandInput {
-  projectId: string;
-  expectedRevision: number;
-  source: ProjectRevisionSource;
-  description?: string;
-  actorId?: string;
-  historyTargetChangeSetId?: string;
-  command: ExternalInitialImportProjectCommand;
-}
-
-export interface ExternalInitialImportProjectCommandStore {
-  execute(input: ExecuteExternalInitialImportCommandInput): {
-    revision: AppendedProjectRevision;
-    inverse: ExternalInitialImportProjectCommand;
-  };
-}
diff --git a/src/domain/ports/external-model-configuration-project-command.store.ts b/src/domain/ports/external-model-configuration-project-command.store.ts
new file mode 100644
index 0000000..d6dce8c
--- /dev/null
+++ b/src/domain/ports/external-model-configuration-project-command.store.ts
@@ -0,0 +1,19 @@
+import type { ExternalModelConfigurationUpdateProjectCommand } from "../models/external-model-configuration-project-command.model.js";
+import type { AppendedProjectRevision, ProjectRevisionSource } from "./project-revision.store.js";
+
+export interface ExecuteExternalModelConfigurationCommandInput {
+  projectId: string;
+  expectedRevision: number;
+  source: ProjectRevisionSource;
+  description?: string;
+  actorId?: string;
+  historyTargetChangeSetId?: string;
+  command: ExternalModelConfigurationUpdateProjectCommand;
+}
+
+export interface ExternalModelConfigurationProjectCommandStore {
+  execute(input: ExecuteExternalModelConfigurationCommandInput): {
+    revision: AppendedProjectRevision;
+    inverse: ExternalModelConfigurationUpdateProjectCommand;
+  };
+}
diff --git a/src/domain/ports/external-model-configuration.reader.ts b/src/domain/ports/external-model-configuration.reader.ts
new file mode 100644
index 0000000..1b54f77
--- /dev/null
+++ b/src/domain/ports/external-model-configuration.reader.ts
@@ -0,0 +1,10 @@
+import type { ExternalModelConfigurationSnapshot } from "../models/external-model-configuration-project-command.model.js";
+
+export interface ExternalModelConfigurationReadResult {
+  projectExists: boolean;
+  configuration: ExternalModelConfigurationSnapshot | null;
+}
+
+export interface ExternalModelConfigurationReader {
+  getByProject(projectId: string): ExternalModelConfigurationReadResult;
+}
diff --git a/src/domain/services/project-command.service.ts b/src/domain/services/project-command.service.ts
index 35dd9e8..603a4be 100644
--- a/src/domain/services/project-command.service.ts
+++ b/src/domain/services/project-command.service.ts
@@ -173,15 +173,10 @@ import type { ProjectRevisionSource } from "../ports/project-revision.store.js";
 import type { ProjectSettingsProjectCommandStore } from "../ports/project-settings-project-command.store.js";
 import type { ProjectStateRestoreCommandStore } from "../ports/project-state-restore-command.store.js";
 import {
-  assertExternalCsvConfigurationUpdateProjectCommand,
-  externalCsvConfigurationUpdateCommandType,
-} from "../models/external-csv-configuration-project-command.model.js";
-import type { ExternalCsvConfigurationProjectCommandStore } from "../ports/external-csv-configuration-project-command.store.js";
-import {
-  assertExternalInitialImportProjectCommand,
-  externalInitialImportCommandType,
-} from "../models/external-initial-import-project-command.model.js";
-import type { ExternalInitialImportProjectCommandStore } from "../ports/external-initial-import-project-command.store.js";
+  assertExternalModelConfigurationUpdateProjectCommand,
+  externalModelConfigurationUpdateCommandType,
+} from "../models/external-model-configuration-project-command.model.js";
+import type { ExternalModelConfigurationProjectCommandStore } from "../ports/external-model-configuration-project-command.store.js";
 import {
   assertExternalObjectRowAssignmentProjectCommand,
   externalObjectRowAssignmentCommandType,
@@ -243,8 +238,7 @@ export class ProjectCommandService implements ProjectCommandExecutor {
     private readonly circuitGroupSubtreeStore: CircuitGroupSubtreeProjectCommandStore,
     private readonly circuitProtectionStore: CircuitProtectionProjectCommandStore,
     private readonly historyStore: ProjectHistoryStore,
-    private readonly externalCsvConfigurationStore?: ExternalCsvConfigurationProjectCommandStore,
-    private readonly externalInitialImportStore?: ExternalInitialImportProjectCommandStore,
+    private readonly externalModelConfigurationStore?: ExternalModelConfigurationProjectCommandStore,
     private readonly externalObjectRowAssignmentStore?: ExternalObjectRowAssignmentProjectCommandStore,
     private readonly externalObjectNewRowStore?: ExternalObjectNewRowProjectCommandStore,
     private readonly externalObjectNewCircuitStore?: ExternalObjectNewCircuitProjectCommandStore,
@@ -308,6 +302,8 @@ export class ProjectCommandService implements ProjectCommandExecutor {
       );
     }
 
+    assertNoLegacyExternalCsvHistoryCommand(step.command);
+
     return this.dispatch({
       ...input,
       source: direction,
@@ -625,22 +621,12 @@ export class ProjectCommandService implements ProjectCommandExecutor {
           command: input.command,
         }).revision;
       }
-      case externalCsvConfigurationUpdateCommandType: {
-        assertExternalCsvConfigurationUpdateProjectCommand(input.command);
-        if (!this.externalCsvConfigurationStore) {
-          throw new Error("External CSV configuration store is not available.");
+      case externalModelConfigurationUpdateCommandType: {
+        assertExternalModelConfigurationUpdateProjectCommand(input.command);
+        if (!this.externalModelConfigurationStore) {
+          throw new Error("External model configuration store is not available.");
         }
-        return this.externalCsvConfigurationStore.execute({
-          ...input,
-          command: input.command,
-        }).revision;
-      }
-      case externalInitialImportCommandType: {
-        assertExternalInitialImportProjectCommand(input.command);
-        if (!this.externalInitialImportStore) {
-          throw new Error("External initial import store is not available.");
-        }
-        return this.externalInitialImportStore.execute({
+        return this.externalModelConfigurationStore.execute({
           ...input,
           command: input.command,
         }).revision;
@@ -720,3 +706,16 @@ function assertExpectedRevision(expectedRevision: number) {
     );
   }
 }
+
+function assertNoLegacyExternalCsvHistoryCommand(
+  command: SerializedProjectCommand<unknown>
+) {
+  if (
+    command.type === "external-csv-configuration.update" ||
+    command.type === "external-import.apply-initial"
+  ) {
+    throw new Error(
+      "Dieser Verlaufseintrag stammt aus der alten Revit-CSV-Anbindung und kann nach der Umstellung auf Linear-XLSX nicht mehr ausgef\u00fchrt werden."
+    );
+  }
+}
diff --git a/src/external-model/application/external-circuit-list-objects.ts b/src/external-model/application/external-circuit-list-objects.ts
deleted file mode 100644
index 43f57c5..0000000
--- a/src/external-model/application/external-circuit-list-objects.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import type {
-  ExternalModelStateSnapshot,
-} from "../domain/external-model-contracts.js";
-
-export interface ExternalCircuitListObjectDto {
-  id: string;
-  ifcGuid: string;
-  selectionMarker: string;
-  familyAndType: string;
-  sourceCircuitIdentifier: string;
-  displayName: string | null;
-  category: string | null;
-  connectionKind: string | null;
-  effectiveQuantity: number;
-  powerPerUnitW: number | null;
-  sourceRoomNumber: string;
-  sourceRoomName: string;
-  roomId: string | null;
-  linkedProjectDeviceId: string | null;
-  circuitDeviceRowId: string | null;
-  presenceStatus: "present" | "missing";
-}
-
-export interface ExternalCircuitListObjectsDto {
-  sourceName: string | null;
-  objectCount: number;
-  unassignedObjectCount: number;
-  objects: ExternalCircuitListObjectDto[];
-}
-
-export function createExternalCircuitListObjects(input: {
-  state: ExternalModelStateSnapshot;
-  distributionBoardId: string;
-}): ExternalCircuitListObjectsDto {
-  const mappingById = new Map(
-    input.state.roomMappings.map((mapping) => [mapping.id, mapping])
-  );
-  const objects = input.state.objects
-    .filter((object) => object.distributionBoardId === input.distributionBoardId)
-    .map((object) => {
-      const mapping = object.externalRoomMappingId === null
-        ? null
-        : mappingById.get(object.externalRoomMappingId) ?? null;
-      return {
-        id: object.id,
-        ifcGuid: object.ifcGuid,
-        selectionMarker: object.acceptedSourceValues.selectionMarker,
-        familyAndType: object.acceptedSourceValues.familyAndType,
-        sourceCircuitIdentifier: object.acceptedSourceValues.circuitIdentifier,
-        displayName: object.planningValues.displayName,
-        category: object.planningValues.category,
-        connectionKind: object.planningValues.connectionKind,
-        effectiveQuantity: object.planningValues.effectiveQuantity,
-        powerPerUnitW: object.planningValues.powerPerUnitW,
-        sourceRoomNumber:
-          mapping?.sourceRoomNumber ?? object.acceptedSourceValues.roomNumber,
-        sourceRoomName:
-          mapping?.sourceRoomName ?? object.acceptedSourceValues.roomName,
-        roomId: mapping?.roomId ?? null,
-        linkedProjectDeviceId: object.linkedProjectDeviceId,
-        circuitDeviceRowId: object.circuitDeviceRowId,
-        presenceStatus: object.presenceStatus,
-      } satisfies ExternalCircuitListObjectDto;
-    })
-    .sort(compareExternalObjects);
-  return {
-    sourceName: input.state.source?.name ?? null,
-    objectCount: objects.length,
-    unassignedObjectCount: objects.filter(
-      (object) => object.circuitDeviceRowId === null
-    ).length,
-    objects,
-  };
-}
-
-function compareExternalObjects(
-  left: ExternalCircuitListObjectDto,
-  right: ExternalCircuitListObjectDto
-) {
-  const assignmentOrder = Number(left.circuitDeviceRowId !== null) -
-    Number(right.circuitDeviceRowId !== null);
-  if (assignmentOrder !== 0) return assignmentOrder;
-  return left.sourceRoomNumber.localeCompare(right.sourceRoomNumber, "de", {
-    numeric: true,
-  }) || left.selectionMarker.localeCompare(right.selectionMarker, "de", {
-    numeric: true,
-  }) || left.ifcGuid.localeCompare(right.ifcGuid);
-}
diff --git a/src/external-model/application/external-csv-preview.ts b/src/external-model/application/external-csv-preview.ts
deleted file mode 100644
index 57aa480..0000000
--- a/src/external-model/application/external-csv-preview.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import { createHash } from "node:crypto";
-import type { ExternalCsvConfiguration } from "../csv/external-csv-contracts.js";
-import { parseExternalCsv } from "../csv/external-csv-transport.js";
-
-export interface ExternalCsvPreviewObject {
-  rowNumber: number;
-  ifcGuid: string;
-  roomNumber: string;
-  roomName: string;
-  familyAndType: string;
-  selectionMarker: string;
-  circuitIdentifier: string;
-  power: string;
-  quantity: string | null;
-  additionalSourceValues: Record<string, string>;
-}
-
-export interface ExternalCsvPreview {
-  fileName: string;
-  byteLength: number;
-  sha256: string;
-  dialect: ReturnType<typeof parseExternalCsv>["dialect"];
-  headerRowNumber: number;
-  headerColumns: string[];
-  rowCount: number;
-  objectCount: number;
-  passthroughCount: number;
-  nonEmptyPassthroughCount: number;
-  suspectObjectCount: number;
-  objects: ExternalCsvPreviewObject[];
-  suspectRowNumbers: number[];
-}
-
-export function createExternalCsvPreview(input: {
-  fileName: string;
-  bytes: Uint8Array;
-  configuration: ExternalCsvConfiguration;
-}): ExternalCsvPreview {
-  const document = parseExternalCsv(input.bytes, input.configuration);
-  const header = document.rows[document.headerRowIndex];
-  const headerIndex = new Map(
-    header.cells.map((cell, index) => [cell.value, index])
-  );
-  const valueAt = (row: (typeof document.rows)[number], column: string) =>
-    row.cells[headerIndex.get(column)!]?.value ?? "";
-  const objects = document.rows
-    .filter((row) => row.classification === "object")
-    .map((row): ExternalCsvPreviewObject => ({
-      rowNumber: row.index + 1,
-      ifcGuid: valueAt(row, input.configuration.columns.ifcGuid),
-      roomNumber: valueAt(row, input.configuration.columns.roomNumber),
-      roomName: valueAt(row, input.configuration.columns.roomName),
-      familyAndType: valueAt(row, input.configuration.columns.familyAndType),
-      selectionMarker: valueAt(row, input.configuration.columns.selectionMarker),
-      circuitIdentifier: valueAt(row, input.configuration.columns.circuitIdentifier),
-      power: valueAt(row, input.configuration.columns.power),
-      quantity:
-        input.configuration.columns.quantity === null
-          ? null
-          : valueAt(row, input.configuration.columns.quantity),
-      additionalSourceValues: Object.fromEntries(
-        input.configuration.additionalSourceMappings.map((mapping) => [
-          mapping.targetField,
-          valueAt(row, mapping.sourceColumn),
-        ])
-      ),
-    }));
-  const passthroughRows = document.rows.filter(
-    (row) => row.classification === "passthrough"
-  );
-  const suspectRows = document.rows.filter(
-    (row) => row.classification === "suspect-object"
-  );
-  return {
-    fileName: input.fileName,
-    byteLength: input.bytes.byteLength,
-    sha256: createHash("sha256").update(input.bytes).digest("hex"),
-    dialect: document.dialect,
-    headerRowNumber: document.headerRowIndex + 1,
-    headerColumns: header.cells.map((cell) => cell.value),
-    rowCount: document.rows.length,
-    objectCount: objects.length,
-    passthroughCount: passthroughRows.length,
-    nonEmptyPassthroughCount: passthroughRows.filter((row) =>
-      row.cells.some((cell) => cell.value !== "")
-    ).length,
-    suspectObjectCount: suspectRows.length,
-    objects,
-    suspectRowNumbers: suspectRows.map((row) => row.index + 1),
-  };
-}
diff --git a/src/external-model/application/external-initial-import-plan.ts b/src/external-model/application/external-initial-import-plan.ts
deleted file mode 100644
index bc916f8..0000000
--- a/src/external-model/application/external-initial-import-plan.ts
+++ /dev/null
@@ -1,164 +0,0 @@
-import type { ExternalCsvConfiguration } from "../csv/external-csv-contracts.js";
-import {
-  createExternalRoomKey,
-  normalizeExternalRoomPart,
-  projectInitialExternalObject,
-} from "../domain/external-model-matching.js";
-import { createExternalCsvPreview } from "./external-csv-preview.js";
-
-interface ExistingRoom {
-  id: string;
-  floorId: string | null;
-  roomNumber: string;
-  roomName: string;
-}
-
-interface ExistingFloor {
-  id: string;
-  name: string;
-  sortOrder: number;
-}
-
-interface ExistingDistributionBoard {
-  id: string;
-  name: string;
-  floorId: string | null;
-}
-
-interface ExistingProjectDevice {
-  id: string;
-  name: string;
-  displayName: string;
-  category: string | null;
-  connectionKind: string | null;
-  powerPerUnit: number;
-}
-
-export function createExternalInitialImportPlan(input: {
-  fileName: string;
-  bytes: Uint8Array;
-  configurationVersion: number;
-  configuration: ExternalCsvConfiguration;
-  rooms: ExistingRoom[];
-  floors: ExistingFloor[];
-  distributionBoards: ExistingDistributionBoard[];
-  projectDevices: ExistingProjectDevice[];
-}) {
-  const preview = createExternalCsvPreview(input);
-  const roomCandidatesByNumber = new Map<string, ExistingRoom[]>();
-  for (const room of input.rooms) {
-    const key = normalizeExternalRoomPart(room.roomNumber);
-    if (!key) continue;
-    const candidates = roomCandidatesByNumber.get(key) ?? [];
-    candidates.push(room);
-    roomCandidatesByNumber.set(key, candidates);
-  }
-
-  const objects = preview.objects.map((object) => {
-    const projected = projectInitialExternalObject(object, input.configuration);
-    return {
-      ifcGuid: projected.ifcGuid,
-      sourceRoomKey: createExternalRoomKey(object.roomNumber, object.roomName),
-      sourceValues: projected.sourceValues,
-      suggestedPlanningValues: projected.planningValues,
-      issues: projected.issues,
-    };
-  });
-  const sourceRooms = new Map<string, {
-    sourceRoomKey: string;
-    roomNumber: string;
-    roomName: string;
-    objectCount: number;
-  }>();
-  for (const object of objects) {
-    if (object.sourceRoomKey === null) continue;
-    const existing = sourceRooms.get(object.sourceRoomKey);
-    if (existing) {
-      existing.objectCount += 1;
-    } else {
-      sourceRooms.set(object.sourceRoomKey, {
-        sourceRoomKey: object.sourceRoomKey,
-        roomNumber: object.sourceValues.roomNumber,
-        roomName: object.sourceValues.roomName,
-        objectCount: 1,
-      });
-    }
-  }
-  const roomPlans = [...sourceRooms.values()]
-    .map((room) => {
-      const candidates = roomCandidatesByNumber.get(
-        normalizeExternalRoomPart(room.roomNumber)
-      ) ?? [];
-      return {
-        ...room,
-        suggestedRoomId: candidates.length === 1 ? candidates[0].id : null,
-        matchStatus:
-          candidates.length === 1
-            ? "exact-number"
-            : candidates.length > 1
-              ? "ambiguous-number"
-              : "new",
-        candidateRoomIds: candidates.map((candidate) => candidate.id),
-      } as const;
-    })
-    .sort((left, right) =>
-      left.roomNumber.localeCompare(right.roomNumber, "de", { numeric: true }) ||
-      left.roomName.localeCompare(right.roomName, "de")
-    );
-
-  const familyGroups = new Map<string, {
-    familyAndType: string;
-    objectCount: number;
-    classified: boolean;
-    category: string | null;
-    connectionKind: string | null;
-    internalDeviceType: string | null;
-  }>();
-  for (const object of objects) {
-    const key = object.sourceValues.familyAndType;
-    const group = familyGroups.get(key);
-    if (group) {
-      group.objectCount += 1;
-    } else {
-      familyGroups.set(key, {
-        familyAndType: key,
-        objectCount: 1,
-        classified: !object.issues.includes("unknown-family-and-type"),
-        category: object.suggestedPlanningValues.category,
-        connectionKind: object.suggestedPlanningValues.connectionKind,
-        internalDeviceType: object.suggestedPlanningValues.internalDeviceType,
-      });
-    }
-  }
-
-  return {
-    configurationVersion: input.configurationVersion,
-    fileName: preview.fileName,
-    sha256: preview.sha256,
-    byteLength: preview.byteLength,
-    rowCount: preview.rowCount,
-    objectCount: preview.objectCount,
-    passthroughCount: preview.passthroughCount,
-    suspectObjectCount: preview.suspectObjectCount,
-    suspectRowNumbers: preview.suspectRowNumbers,
-    sourceRooms: roomPlans,
-    familyGroups: [...familyGroups.values()].sort((left, right) =>
-      left.familyAndType.localeCompare(right.familyAndType, "de")
-    ),
-    issueCounts: {
-      unknownFamilyAndType: objects.filter((object) =>
-        object.issues.includes("unknown-family-and-type")
-      ).length,
-      invalidPower: objects.filter((object) => object.issues.includes("invalid-power")).length,
-      invalidQuantity: objects.filter((object) => object.issues.includes("invalid-quantity")).length,
-      missingRoom: objects.filter((object) => object.issues.includes("missing-room")).length,
-    },
-    objects,
-    existing: {
-      floors: input.floors,
-      rooms: input.rooms,
-      distributionBoards: input.distributionBoards,
-      projectDevices: input.projectDevices,
-    },
-  };
-}
diff --git a/src/external-model/application/external-initial-import-target.ts b/src/external-model/application/external-initial-import-target.ts
deleted file mode 100644
index be0925e..0000000
--- a/src/external-model/application/external-initial-import-target.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-import type { ExternalCsvConfiguration, ExternalCsvDocument } from "../csv/external-csv-contracts.js";
-import type { ExternalModelStateSnapshot } from "../domain/external-model-contracts.js";
-import type { createExternalInitialImportPlan } from "./external-initial-import-plan.js";
-
-type ExternalInitialImportPlan = ReturnType<typeof createExternalInitialImportPlan>;
-
-export interface ExternalRoomDecision {
-  sourceRoomKey: string;
-  roomId: string | null;
-  defaultDistributionBoardId: string | null;
-}
-
-export interface ExternalFamilyProjectDeviceDecision {
-  familyAndType: string;
-  projectDeviceId: string | null;
-}
-
-export function buildExternalInitialImportTarget(input: {
-  projectId: string;
-  expectedRevision: number;
-  sourceName: string;
-  importedAtIso: string;
-  configurationVersion: number;
-  configuration: ExternalCsvConfiguration;
-  originalContentBase64: string;
-  document: ExternalCsvDocument;
-  plan: ExternalInitialImportPlan;
-  roomDecisions: ExternalRoomDecision[];
-  familyProjectDeviceDecisions: ExternalFamilyProjectDeviceDecision[];
-  createId: () => string;
-}): ExternalModelStateSnapshot {
-  if (input.plan.familyGroups.some((group) => !group.classified)) {
-    throw new Error("Alle Familie-und-Typ-Werte müssen vor dem Erstimport klassifiziert sein.");
-  }
-  const roomDecisionByKey = exactDecisionMap(
-    input.plan.sourceRooms.map((room) => room.sourceRoomKey),
-    input.roomDecisions,
-    (decision) => decision.sourceRoomKey,
-    "Quellraum"
-  );
-  const familyDecisionByName = exactDecisionMap(
-    input.plan.familyGroups.map((group) => group.familyAndType),
-    input.familyProjectDeviceDecisions,
-    (decision) => decision.familyAndType,
-    "Familie und Typ"
-  );
-  const sourceId = input.createId();
-  const batchId = input.createId();
-  const roomMappingIdByKey = new Map(
-    input.plan.sourceRooms.map((room) => [room.sourceRoomKey, input.createId()])
-  );
-  return {
-    source: {
-      id: sourceId,
-      projectId: input.projectId,
-      name: input.sourceName.trim(),
-      sourceType: "revit_csv",
-    },
-    importBatches: [{
-      id: batchId,
-      projectId: input.projectId,
-      sourceId,
-      importKind: "initial",
-      importedAtIso: input.importedAtIso,
-      fileName: input.plan.fileName,
-      sha256: input.plan.sha256,
-      appliedProjectRevision: input.expectedRevision + 1,
-      configurationVersion: input.configurationVersion,
-      configurationSnapshot: input.configuration,
-      originalContentBase64: input.originalContentBase64,
-      document: input.document,
-    }],
-    roomMappings: input.plan.sourceRooms.map((room) => {
-      const decision = roomDecisionByKey.get(room.sourceRoomKey)!;
-      return {
-        id: roomMappingIdByKey.get(room.sourceRoomKey)!,
-        projectId: input.projectId,
-        sourceId,
-        normalizedSourceRoomKey: room.sourceRoomKey,
-        sourceFloorName: null,
-        sourceRoomNumber: room.roomNumber,
-        sourceRoomName: room.roomName,
-        roomId: decision.roomId,
-        defaultDistributionBoardId: decision.defaultDistributionBoardId,
-      };
-    }),
-    objects: input.plan.objects.map((object) => ({
-      id: input.createId(),
-      projectId: input.projectId,
-      sourceId,
-      ifcGuid: object.ifcGuid,
-      lastSeenImportBatchId: batchId,
-      lastAcceptedImportBatchId: batchId,
-      acceptedSourceValues: object.sourceValues,
-      planningValues: object.suggestedPlanningValues,
-      overriddenFields: [],
-      externalRoomMappingId:
-        object.sourceRoomKey === null
-          ? null
-          : roomMappingIdByKey.get(object.sourceRoomKey)!,
-      distributionBoardId: null,
-      linkedProjectDeviceId:
-        familyDecisionByName.get(object.sourceValues.familyAndType)!
-          .projectDeviceId,
-      circuitDeviceRowId: null,
-      presenceStatus: "present",
-    })),
-  };
-}
-
-function exactDecisionMap<T>(
-  expectedKeys: string[],
-  decisions: T[],
-  keyOf: (decision: T) => string,
-  label: string
-) {
-  const expected = new Set(expectedKeys);
-  const result = new Map<string, T>();
-  for (const decision of decisions) {
-    const key = keyOf(decision);
-    if (!expected.has(key) || result.has(key)) {
-      throw new Error(`${label}-Entscheidungen sind unvollständig oder doppelt.`);
-    }
-    result.set(key, decision);
-  }
-  if (result.size !== expected.size) {
-    throw new Error(`${label}-Entscheidungen sind unvollständig oder doppelt.`);
-  }
-  return result;
-}
diff --git a/src/external-model/configuration/external-model-configuration.ts b/src/external-model/configuration/external-model-configuration.ts
new file mode 100644
index 0000000..b3dc20e
--- /dev/null
+++ b/src/external-model/configuration/external-model-configuration.ts
@@ -0,0 +1,246 @@
+import type { CircuitGroupCategory } from "../../shared/constants/circuit-group.js";
+import {
+  createDefaultExternalXlsxTransportConfiguration,
+  type ExternalXlsxColumnConfiguration,
+  type ExternalXlsxTransportConfiguration,
+} from "../xlsx/external-xlsx-contracts.js";
+
+export const externalModelConfigurationSchemaVersion = 1 as const;
+export const externalQuantityRules = ["one", "socketCount"] as const;
+export type ExternalQuantityRule = (typeof externalQuantityRules)[number];
+
+export interface ExternalDeviceTypeDefaults {
+  powerPerUnitW: number | null;
+  simultaneityFactor: number | null;
+  cosPhi: number | null;
+  costGroup: string | null;
+}
+
+export interface ExternalDeviceTypeConfiguration {
+  id: string;
+  name: string;
+  category: CircuitGroupCategory;
+  defaults: ExternalDeviceTypeDefaults;
+}
+
+export interface ExternalFamilyTypeRule {
+  id: string;
+  exactFamilyAndType: string;
+  deviceTypeId: string;
+  quantityRule: ExternalQuantityRule;
+}
+
+export interface ExternalModelConfiguration
+  extends ExternalXlsxTransportConfiguration {
+  schemaVersion: typeof externalModelConfigurationSchemaVersion;
+  deviceTypes: ExternalDeviceTypeConfiguration[];
+  familyTypeRules: ExternalFamilyTypeRule[];
+}
+
+export function createDefaultExternalModelConfiguration(): ExternalModelConfiguration {
+  return {
+    schemaVersion: externalModelConfigurationSchemaVersion,
+    ...createDefaultExternalXlsxTransportConfiguration(),
+    deviceTypes: [],
+    familyTypeRules: [],
+  };
+}
+
+export function assertExternalModelConfiguration(
+  value: unknown
+): asserts value is ExternalModelConfiguration {
+  if (!isRecord(value) || value.schemaVersion !== externalModelConfigurationSchemaVersion) {
+    throw new Error("Nicht unterstützte Revit-XLSX-Konfiguration.");
+  }
+  assertExactKeys(value, [
+    "schemaVersion",
+    "layout",
+    "circuitMode",
+    "columns",
+    "deviceTypes",
+    "familyTypeRules",
+  ], "Revit-XLSX-Konfiguration");
+  assertLayout(value.layout);
+  if (value.circuitMode !== "combined" && value.circuitMode !== "separate") {
+    throw new Error("Der Stromkreismodus der Revit-XLSX-Konfiguration ist ungültig.");
+  }
+  assertColumns(value.columns, value.circuitMode);
+  if (!Array.isArray(value.deviceTypes) || !Array.isArray(value.familyTypeRules)) {
+    throw new Error("Gerätearten und Familienregeln müssen Listen sein.");
+  }
+
+  const deviceTypeIds = new Set<string>();
+  const deviceTypeNames = new Set<string>();
+  for (const [index, deviceType] of value.deviceTypes.entries()) {
+    assertDeviceType(deviceType, index);
+    assertUnique(deviceTypeIds, deviceType.id, "Geräteart-ID");
+    assertUnique(deviceTypeNames, deviceType.name, "Geräteartname");
+  }
+  const ruleIds = new Set<string>();
+  const familyNames = new Set<string>();
+  for (const [index, rule] of value.familyTypeRules.entries()) {
+    assertFamilyRule(rule, index);
+    assertUnique(ruleIds, rule.id, "Familienregel-ID");
+    assertUnique(familyNames, rule.exactFamilyAndType, "Familie und Typ");
+    if (!deviceTypeIds.has(rule.deviceTypeId)) {
+      throw new Error(
+        `Familienregel ${index + 1} verweist auf eine unbekannte Geräteart.`
+      );
+    }
+  }
+}
+
+export function validateExternalModelConfiguration(value: unknown):
+  | { success: true; data: ExternalModelConfiguration }
+  | { success: false; error: string } {
+  try {
+    assertExternalModelConfiguration(value);
+    return { success: true, data: value };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Ungültige Konfiguration.",
+    };
+  }
+}
+
+function assertLayout(value: unknown) {
+  if (!isRecord(value)) throw new Error("Das XLSX-Layout fehlt.");
+  assertExactKeys(value, ["headerRow", "firstDataRow", "firstDataColumn"], "XLSX-Layout");
+  assertPositiveInteger(value.headerRow, "Kopfzeile");
+  assertPositiveInteger(value.firstDataRow, "erste Datenzeile");
+  assertPositiveInteger(value.firstDataColumn, "erste Datenspalte");
+  if ((value.firstDataRow as number) <= (value.headerRow as number)) {
+    throw new Error("Die erste Datenzeile muss nach der Kopfzeile liegen.");
+  }
+}
+
+function assertColumns(
+  value: unknown,
+  circuitMode: ExternalModelConfiguration["circuitMode"]
+) {
+  if (!isRecord(value)) throw new Error("Die XLSX-Spaltenzuordnung fehlt.");
+  const keys = [
+    "worksharingId",
+    "ifcGuid",
+    "roomNumber",
+    "roomName",
+    "familyAndType",
+    "selectionMarker",
+    "socketCount",
+    "sourceRemark",
+    "circuitCombined",
+    "boardName",
+    "circuitIdentifier",
+    "designation",
+    "electricalPowerW",
+    "voltageV",
+    "currentA",
+  ] satisfies (keyof ExternalXlsxColumnConfiguration)[];
+  assertExactKeys(value, keys, "XLSX-Spaltenzuordnung");
+  const mappedNames = new Set<string>();
+  for (const key of keys) {
+    const columnName = value[key];
+    const required =
+      key === "worksharingId" ||
+      key === "familyAndType" ||
+      (circuitMode === "combined" && key === "circuitCombined") ||
+      (circuitMode === "separate" &&
+        (key === "boardName" || key === "circuitIdentifier"));
+    if (columnName === null && !required) continue;
+    assertNonEmptyString(columnName, `Spalte ${key}`);
+    assertUnique(mappedNames, columnName, "Spaltenzuordnung");
+  }
+}
+
+function assertDeviceType(value: unknown, index: number): asserts value is ExternalDeviceTypeConfiguration {
+  if (!isRecord(value)) throw new Error(`Geräteart ${index + 1} ist ungültig.`);
+  assertExactKeys(value, ["id", "name", "category", "defaults"], `Geräteart ${index + 1}`);
+  assertUuid(value.id, `Geräteart ${index + 1}.id`);
+  assertNonEmptyString(value.name, `Geräteart ${index + 1}.name`);
+  if (!(["lighting", "single_phase", "three_phase"] as unknown[]).includes(value.category)) {
+    throw new Error(`Geräteart ${index + 1} besitzt eine ungültige Kategorie.`);
+  }
+  if (!isRecord(value.defaults)) throw new Error(`Geräteart ${index + 1}.defaults fehlt.`);
+  assertExactKeys(
+    value.defaults,
+    ["powerPerUnitW", "simultaneityFactor", "cosPhi", "costGroup"],
+    `Geräteart ${index + 1}.defaults`
+  );
+  assertNullableNumber(value.defaults.powerPerUnitW, 0, Number.POSITIVE_INFINITY, "Leistung");
+  assertNullableNumber(value.defaults.simultaneityFactor, 0, 1, "GZF");
+  assertNullableNumber(value.defaults.cosPhi, Number.MIN_VALUE, 1, "cosPhi");
+  if (value.defaults.costGroup !== null) {
+    assertNonEmptyString(value.defaults.costGroup, "Kostengruppe");
+  }
+}
+
+function assertFamilyRule(value: unknown, index: number): asserts value is ExternalFamilyTypeRule {
+  if (!isRecord(value)) throw new Error(`Familienregel ${index + 1} ist ungültig.`);
+  assertExactKeys(
+    value,
+    ["id", "exactFamilyAndType", "deviceTypeId", "quantityRule"],
+    `Familienregel ${index + 1}`
+  );
+  assertUuid(value.id, `Familienregel ${index + 1}.id`);
+  assertNonEmptyString(value.exactFamilyAndType, `Familienregel ${index + 1}.exactFamilyAndType`);
+  assertUuid(value.deviceTypeId, `Familienregel ${index + 1}.deviceTypeId`);
+  if (!externalQuantityRules.includes(value.quantityRule as ExternalQuantityRule)) {
+    throw new Error(`Familienregel ${index + 1} besitzt eine ungültige Mengenregel.`);
+  }
+}
+
+function assertPositiveInteger(value: unknown, label: string) {
+  if (!Number.isSafeInteger(value) || (value as number) < 1) {
+    throw new Error(`${label} muss eine positive Ganzzahl sein.`);
+  }
+}
+
+function assertNullableNumber(
+  value: unknown,
+  minimum: number,
+  maximum: number,
+  label: string
+) {
+  if (value === null) return;
+  if (
+    typeof value !== "number" ||
+    !Number.isFinite(value) ||
+    value < minimum ||
+    value > maximum
+  ) {
+    throw new Error(`${label} ist ungültig.`);
+  }
+}
+
+function assertNonEmptyString(value: unknown, label: string): asserts value is string {
+  if (typeof value !== "string" || value.length === 0 || value !== value.trim()) {
+    throw new Error(`${label} muss nichtleer und ohne äußere Leerzeichen sein.`);
+  }
+}
+
+function assertUuid(value: unknown, label: string): asserts value is string {
+  if (
+    typeof value !== "string" ||
+    !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)
+  ) {
+    throw new Error(`${label} muss eine UUID sein.`);
+  }
+}
+
+function assertUnique(values: Set<string>, value: string, label: string) {
+  if (values.has(value)) throw new Error(`${label} ist nicht eindeutig: ${value}`);
+  values.add(value);
+}
+
+function assertExactKeys(value: Record<string, unknown>, keys: readonly string[], label: string) {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+    throw new Error(`${label} enthält unbekannte oder fehlende Felder.`);
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
diff --git a/src/external-model/csv/external-csv-transport.ts b/src/external-model/csv/external-csv-transport.ts
deleted file mode 100644
index 3446d24..0000000
--- a/src/external-model/csv/external-csv-transport.ts
+++ /dev/null
@@ -1,356 +0,0 @@
-import { assertExternalCsvConfiguration } from "./external-csv-configuration.js";
-import type {
-  ExternalCsvCell,
-  ExternalCsvConfiguration,
-  ExternalCsvDocument,
-  ExternalCsvLineEnding,
-  ExternalCsvRow,
-} from "./external-csv-contracts.js";
-
-export type ExternalCsvParseErrorCode =
-  | "invalid-encoding"
-  | "invalid-csv"
-  | "header-not-found"
-  | "ambiguous-header"
-  | "invalid-ifc-guid"
-  | "duplicate-ifc-guid";
-
-export class ExternalCsvParseError extends Error {
-  constructor(
-    public readonly code: ExternalCsvParseErrorCode,
-    message: string
-  ) {
-    super(message);
-    this.name = "ExternalCsvParseError";
-  }
-}
-
-export function parseExternalCsv(
-  input: Uint8Array,
-  configuration: ExternalCsvConfiguration
-): ExternalCsvDocument {
-  assertExternalCsvConfiguration(configuration);
-  const hasBom = hasUtf8Bom(input);
-  const contentBytes = hasBom ? input.subarray(3) : input;
-  let text: string;
-  try {
-    text = new TextDecoder("utf-8", { fatal: true }).decode(contentBytes);
-  } catch {
-    throw new ExternalCsvParseError(
-      "invalid-encoding",
-      "CSV is not valid UTF-8."
-    );
-  }
-
-  const parsed = parseRows(text, configuration.delimiter);
-  const headerMatches = findHeaderRows(parsed.rows, configuration);
-  if (headerMatches.length === 0) {
-    throw new ExternalCsvParseError(
-      "header-not-found",
-      "CSV does not contain exactly the configured required columns in one header row."
-    );
-  }
-  if (headerMatches.length > 1) {
-    throw new ExternalCsvParseError(
-      "ambiguous-header",
-      "CSV contains more than one possible header row."
-    );
-  }
-
-  const headerRowIndex = headerMatches[0];
-  const configuredColumnNames = [
-    ...Object.values(configuration.columns).filter(
-      (column): column is string => column !== null
-    ),
-    ...configuration.additionalSourceMappings.map((mapping) => mapping.sourceColumn),
-  ];
-  const headerValues = parsed.rows[headerRowIndex].map((cell) => cell.value);
-  if (
-    configuredColumnNames.some(
-      (columnName) => headerValues.filter((value) => value === columnName).length !== 1
-    )
-  ) {
-    throw new ExternalCsvParseError(
-      "ambiguous-header",
-      "CSV header contains a configured column more than once."
-    );
-  }
-  const headerLookup = createHeaderLookup(parsed.rows[headerRowIndex]);
-  const ifcGuidColumnIndex = headerLookup.get(configuration.columns.ifcGuid)!;
-  const objectBearingColumnIndexes = [
-    configuration.columns.roomNumber,
-    configuration.columns.roomName,
-    configuration.columns.familyAndType,
-    configuration.columns.selectionMarker,
-    configuration.columns.power,
-    ...(configuration.columns.quantity === null
-      ? []
-      : [configuration.columns.quantity]),
-    ...configuration.additionalSourceMappings.map((mapping) => mapping.sourceColumn),
-  ].map((column) => headerLookup.get(column)!);
-  const seenIfcGuids = new Set<string>();
-
-  const rows: ExternalCsvRow[] = parsed.rows.map((cells, index) => {
-    if (index < headerRowIndex) {
-      return { index, cells, classification: "metadata" };
-    }
-    if (index === headerRowIndex) {
-      return { index, cells, classification: "header" };
-    }
-
-    const rawIfcGuid = cells[ifcGuidColumnIndex]?.value ?? "";
-    const ifcGuid = rawIfcGuid.trim();
-    if (ifcGuid) {
-      if (ifcGuid !== rawIfcGuid || !isIfcGuid(ifcGuid)) {
-        throw new ExternalCsvParseError(
-          "invalid-ifc-guid",
-          `CSV row ${index + 1} contains an invalid IfcGUID.`
-        );
-      }
-      if (seenIfcGuids.has(ifcGuid)) {
-        throw new ExternalCsvParseError(
-          "duplicate-ifc-guid",
-          `CSV contains the IfcGUID more than once: ${ifcGuid}`
-        );
-      }
-      seenIfcGuids.add(ifcGuid);
-      return { index, cells, classification: "object" };
-    }
-
-    const looksLikeObject = objectBearingColumnIndexes.some(
-      (columnIndex) => (cells[columnIndex]?.value.trim() ?? "") !== ""
-    );
-    return {
-      index,
-      cells,
-      classification: looksLikeObject ? "suspect-object" : "passthrough",
-    };
-  });
-
-  return {
-    dialect: {
-      encoding: "utf-8",
-      hasBom,
-      delimiter: configuration.delimiter,
-      lineEnding: resolveLineEnding(parsed.lineEndings),
-      quoteCharacter: '"',
-      quoteAllFields:
-        rows.flatMap((row) => row.cells).length > 0 &&
-        rows.flatMap((row) => row.cells).every((cell) => cell.wasQuoted),
-      hasTrailingLineEnding: parsed.hasTrailingLineEnding,
-    },
-    headerRowIndex,
-    rows,
-  };
-}
-
-export function serializeExternalCsv(document: ExternalCsvDocument): Uint8Array {
-  assertSerializableDocument(document);
-  const serializedRows = document.rows.map((row) =>
-    row.cells
-      .map((cell) => serializeCell(cell, document.dialect.delimiter))
-      .join(document.dialect.delimiter)
-  );
-  let text = serializedRows.join(document.dialect.lineEnding);
-  if (document.dialect.hasTrailingLineEnding && document.rows.length > 0) {
-    text += document.dialect.lineEnding;
-  }
-  const encoded = new TextEncoder().encode(text);
-  if (!document.dialect.hasBom) {
-    return encoded;
-  }
-  const result = new Uint8Array(encoded.length + 3);
-  result.set([0xef, 0xbb, 0xbf]);
-  result.set(encoded, 3);
-  return result;
-}
-
-function parseRows(text: string, delimiter: string) {
-  const rows: ExternalCsvCell[][] = [];
-  const lineEndings: ExternalCsvLineEnding[] = [];
-  let cells: ExternalCsvCell[] = [];
-  let value = "";
-  let wasQuoted = false;
-  let inQuotes = false;
-  let afterClosingQuote = false;
-  let fieldStarted = false;
-  let hasTrailingLineEnding = false;
-
-  const finishCell = () => {
-    cells.push({ value, wasQuoted });
-    value = "";
-    wasQuoted = false;
-    inQuotes = false;
-    afterClosingQuote = false;
-    fieldStarted = false;
-  };
-  const finishRow = (lineEnding: ExternalCsvLineEnding) => {
-    finishCell();
-    rows.push(cells);
-    cells = [];
-    lineEndings.push(lineEnding);
-    hasTrailingLineEnding = true;
-  };
-
-  for (let index = 0; index < text.length; index += 1) {
-    const character = text[index];
-    if (inQuotes) {
-      if (character === '"') {
-        if (text[index + 1] === '"') {
-          value += '"';
-          index += 1;
-        } else {
-          inQuotes = false;
-          afterClosingQuote = true;
-        }
-      } else {
-        value += character;
-      }
-      hasTrailingLineEnding = false;
-      continue;
-    }
-
-    if (afterClosingQuote) {
-      if (character !== delimiter && character !== "\r" && character !== "\n") {
-        throw new ExternalCsvParseError(
-          "invalid-csv",
-          "CSV contains characters after a closing quote."
-        );
-      }
-    }
-
-    if (character === delimiter) {
-      finishCell();
-      hasTrailingLineEnding = false;
-      continue;
-    }
-    if (character === "\r" || character === "\n") {
-      const lineEnding: ExternalCsvLineEnding =
-        character === "\r" && text[index + 1] === "\n"
-          ? "\r\n"
-          : character;
-      if (lineEnding === "\r\n") {
-        index += 1;
-      }
-      finishRow(lineEnding);
-      continue;
-    }
-    if (character === '"') {
-      if (fieldStarted || value.length > 0 || afterClosingQuote) {
-        throw new ExternalCsvParseError(
-          "invalid-csv",
-          "CSV contains a quote inside an unquoted field."
-        );
-      }
-      wasQuoted = true;
-      inQuotes = true;
-      fieldStarted = true;
-      hasTrailingLineEnding = false;
-      continue;
-    }
-    if (afterClosingQuote) {
-      throw new ExternalCsvParseError(
-        "invalid-csv",
-        "CSV contains invalid data after a quoted field."
-      );
-    }
-    value += character;
-    fieldStarted = true;
-    hasTrailingLineEnding = false;
-  }
-
-  if (inQuotes) {
-    throw new ExternalCsvParseError(
-      "invalid-csv",
-      "CSV contains an unterminated quoted field."
-    );
-  }
-  if (!hasTrailingLineEnding || cells.length > 0 || fieldStarted || value.length > 0) {
-    finishCell();
-    rows.push(cells);
-  }
-
-  return { rows, lineEndings, hasTrailingLineEnding };
-}
-
-function findHeaderRows(
-  rows: ExternalCsvCell[][],
-  configuration: ExternalCsvConfiguration
-) {
-  const requiredColumns = new Set([
-    ...Object.values(configuration.columns).filter(
-      (column): column is string => column !== null
-    ),
-    ...configuration.additionalSourceMappings.map((mapping) => mapping.sourceColumn),
-  ]);
-  const matches: number[] = [];
-  rows.forEach((row, index) => {
-    const values = new Set(row.map((cell) => cell.value));
-    if ([...requiredColumns].every((column) => values.has(column))) {
-      matches.push(index);
-    }
-  });
-  return matches;
-}
-
-function createHeaderLookup(cells: ExternalCsvCell[]) {
-  return new Map(cells.map((cell, index) => [cell.value, index]));
-}
-
-function isIfcGuid(value: string) {
-  return /^[0-9A-Za-z_$]{22}$/.test(value);
-}
-
-function resolveLineEnding(lineEndings: ExternalCsvLineEnding[]): ExternalCsvLineEnding {
-  if (lineEndings.length === 0) {
-    return "\r\n";
-  }
-  const unique = new Set(lineEndings);
-  if (unique.size !== 1) {
-    throw new ExternalCsvParseError(
-      "invalid-csv",
-      "CSV contains mixed line endings that cannot be preserved reliably."
-    );
-  }
-  return lineEndings[0];
-}
-
-function serializeCell(cell: ExternalCsvCell, delimiter: string) {
-  const mustQuote =
-    cell.wasQuoted ||
-    cell.value.includes(delimiter) ||
-    cell.value.includes('"') ||
-    cell.value.includes("\r") ||
-    cell.value.includes("\n");
-  if (!mustQuote) {
-    return cell.value;
-  }
-  return `"${cell.value.replaceAll('"', '""')}"`;
-}
-
-function assertSerializableDocument(document: ExternalCsvDocument) {
-  if (document.dialect.encoding !== "utf-8") {
-    throw new Error("Only UTF-8 external CSV documents can be serialized.");
-  }
-  if (
-    document.headerRowIndex < 0 ||
-    document.headerRowIndex >= document.rows.length ||
-    document.rows[document.headerRowIndex]?.classification !== "header"
-  ) {
-    throw new Error("External CSV document has an invalid header row.");
-  }
-  document.rows.forEach((row, index) => {
-    if (row.index !== index) {
-      throw new Error("External CSV row indexes must be contiguous and stable.");
-    }
-    for (const cell of row.cells) {
-      if (typeof cell.value !== "string" || typeof cell.wasQuoted !== "boolean") {
-        throw new Error("External CSV document contains an invalid cell.");
-      }
-    }
-  });
-}
-
-function hasUtf8Bom(input: Uint8Array) {
-  return input.length >= 3 && input[0] === 0xef && input[1] === 0xbb && input[2] === 0xbf;
-}
diff --git a/src/external-model/domain/external-model-contracts.ts b/src/external-model/domain/external-model-contracts.ts
index b06e2fb..95ab137 100644
--- a/src/external-model/domain/external-model-contracts.ts
+++ b/src/external-model/domain/external-model-contracts.ts
@@ -1,10 +1,11 @@
 import type { CircuitGroupCategory } from "../../shared/constants/circuit-group.js";
+import type { ExternalModelConfiguration } from "../configuration/external-model-configuration.js";
 import type {
-  ExternalCsvConfiguration,
-  ExternalCsvDocument,
-} from "../csv/external-csv-contracts.js";
+  ExternalXlsxDocument,
+  ExternalXlsxScalar,
+} from "../xlsx/external-xlsx-contracts.js";
 
-export const externalModelSourceTypes = ["revit_csv"] as const;
+export const externalModelSourceTypes = ["revit_xlsx"] as const;
 export type ExternalModelSourceType = (typeof externalModelSourceTypes)[number];
 
 export const externalImportKinds = ["initial", "follow_up"] as const;
@@ -29,11 +30,11 @@ export interface ExternalImportBatchSnapshot {
   importedAtIso: string;
   fileName: string;
   sha256: string;
-  appliedProjectRevision: number;
-  configurationVersion: number;
-  configurationSnapshot: ExternalCsvConfiguration;
-  originalContentBase64: string;
-  document: ExternalCsvDocument;
+  objectCount: number;
+  appliedProjectRevision: number | null;
+  configurationSnapshot: ExternalModelConfiguration | null;
+  originalContentBase64: string | null;
+  document: ExternalXlsxDocument | null;
 }
 
 export interface ExternalRoomMappingSnapshot {
@@ -50,24 +51,28 @@ export interface ExternalRoomMappingSnapshot {
 
 export interface ExternalModelObjectSourceValues {
   rowNumber: number;
-  roomNumber: string;
-  roomName: string;
+  roomNumber: ExternalXlsxScalar;
+  roomName: ExternalXlsxScalar;
   familyAndType: string;
-  selectionMarker: string;
-  circuitIdentifier: string;
-  power: string;
-  quantity: string | null;
-  additionalSourceValues: Record<string, string>;
+  selectionMarker: ExternalXlsxScalar;
+  socketCount: ExternalXlsxScalar;
+  sourceRemark: ExternalXlsxScalar;
+  circuitCombined: ExternalXlsxScalar;
+  boardName: ExternalXlsxScalar;
+  circuitIdentifier: ExternalXlsxScalar;
+  designation: ExternalXlsxScalar;
+  electricalPowerW: ExternalXlsxScalar;
+  voltageV: ExternalXlsxScalar;
+  currentA: ExternalXlsxScalar;
 }
 
 export interface ExternalModelObjectPlanningValues {
   displayName: string | null;
-  internalDeviceType: string | null;
   category: CircuitGroupCategory | null;
   connectionKind: string | null;
   effectiveQuantity: number;
   powerPerUnitW: number | null;
-  simultaneityFactor: number;
+  simultaneityFactor: number | null;
   cosPhi: number | null;
   costGroup: string | null;
   remark: string | null;
@@ -80,7 +85,9 @@ export interface ExternalModelObjectSnapshot {
   id: string;
   projectId: string;
   sourceId: string;
-  ifcGuid: string;
+  worksharingId: string;
+  ifcGuid: string | null;
+  deviceTypeId: string;
   lastSeenImportBatchId: string;
   lastAcceptedImportBatchId: string;
   acceptedSourceValues: ExternalModelObjectSourceValues;
diff --git a/src/external-model/domain/external-model-matching.ts b/src/external-model/domain/external-model-matching.ts
deleted file mode 100644
index 3085211..0000000
--- a/src/external-model/domain/external-model-matching.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-import type { ExternalCsvConfiguration } from "../csv/external-csv-contracts.js";
-import type {
-  ExternalModelObjectPlanningValues,
-  ExternalModelObjectSourceValues,
-} from "./external-model-contracts.js";
-
-export type InitialExternalObjectIssue =
-  | "unknown-family-and-type"
-  | "invalid-power"
-  | "invalid-quantity"
-  | "missing-room";
-
-export interface InitialExternalObjectProjection {
-  ifcGuid: string;
-  sourceValues: ExternalModelObjectSourceValues;
-  planningValues: ExternalModelObjectPlanningValues;
-  issues: InitialExternalObjectIssue[];
-}
-
-export interface ExternalObjectImportCandidate {
-  rowNumber: number;
-  ifcGuid: string;
-  roomNumber: string;
-  roomName: string;
-  familyAndType: string;
-  selectionMarker: string;
-  circuitIdentifier: string;
-  power: string;
-  quantity: string | null;
-  additionalSourceValues: Record<string, string>;
-}
-
-export function normalizeExternalRoomPart(value: string): string {
-  return value.trim().normalize("NFKC").toLocaleUpperCase("de-DE");
-}
-
-export function createExternalRoomKey(
-  roomNumber: string,
-  roomName: string
-): string | null {
-  const normalizedNumber = normalizeExternalRoomPart(roomNumber);
-  if (normalizedNumber) return `number:${normalizedNumber}`;
-  const normalizedName = normalizeExternalRoomPart(roomName);
-  return normalizedName ? `name:${normalizedName}` : null;
-}
-
-export function indexExternalObjectsByIfcGuid<T extends { ifcGuid: string }>(
-  objects: readonly T[]
-): Map<string, T> {
-  const index = new Map<string, T>();
-  for (const object of objects) {
-    if (!object.ifcGuid || object.ifcGuid !== object.ifcGuid.trim()) {
-      throw new Error("IfcGUID must be non-empty and must not contain outer whitespace.");
-    }
-    if (index.has(object.ifcGuid)) {
-      throw new Error(`Duplicate IfcGUID: ${object.ifcGuid}`);
-    }
-    index.set(object.ifcGuid, object);
-  }
-  return index;
-}
-
-export function projectInitialExternalObject(
-  object: ExternalObjectImportCandidate,
-  configuration: ExternalCsvConfiguration
-): InitialExternalObjectProjection {
-  const rule = configuration.familyTypeRules.find(
-    (candidate) => candidate.exactFamilyAndType === object.familyAndType
-  );
-  const issues: InitialExternalObjectIssue[] = [];
-  if (!rule) issues.push("unknown-family-and-type");
-  if (!createExternalRoomKey(object.roomNumber, object.roomName)) {
-    issues.push("missing-room");
-  }
-
-  const parsedPower = parseConfiguredNumber(object.power, configuration);
-  if (object.power.trim() && parsedPower === null) issues.push("invalid-power");
-
-  let effectiveQuantity = 1;
-  if (rule?.quantityRule.kind === "fixed") {
-    effectiveQuantity = rule.quantityRule.quantity;
-  } else if (rule?.quantityRule.kind === "mapped-column") {
-    const parsedQuantity = parseConfiguredNumber(object.quantity ?? "", configuration);
-    if (parsedQuantity === null || !Number.isInteger(parsedQuantity) || parsedQuantity <= 0) {
-      issues.push("invalid-quantity");
-    } else {
-      effectiveQuantity = parsedQuantity;
-    }
-  }
-
-  return {
-    ifcGuid: object.ifcGuid,
-    sourceValues: {
-      rowNumber: object.rowNumber,
-      roomNumber: object.roomNumber,
-      roomName: object.roomName,
-      familyAndType: object.familyAndType,
-      selectionMarker: object.selectionMarker,
-      circuitIdentifier: object.circuitIdentifier,
-      power: object.power,
-      quantity: object.quantity,
-      additionalSourceValues: { ...object.additionalSourceValues },
-    },
-    planningValues: {
-      displayName: rule
-        ? resolveDisplayName(rule.displayNameSuggestion, object)
-        : null,
-      internalDeviceType: rule?.internalDeviceType ?? null,
-      category: rule?.category ?? null,
-      connectionKind: rule?.connectionKind ?? null,
-      effectiveQuantity,
-      powerPerUnitW:
-        parsedPower === null ? null : parsedPower * configuration.wattsPerSourceUnit,
-      simultaneityFactor: 1,
-      cosPhi: null,
-      costGroup: null,
-      remark: null,
-    },
-    issues,
-  };
-}
-
-function parseConfiguredNumber(
-  value: string,
-  configuration: ExternalCsvConfiguration
-): number | null {
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  const normalized = configuration.decimalSeparator === ","
-    ? trimmed.replace(",", ".")
-    : trimmed;
-  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/.test(normalized)) return null;
-  const parsed = Number(normalized);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
-}
-
-function resolveDisplayName(
-  suggestion: ExternalCsvConfiguration["familyTypeRules"][number]["displayNameSuggestion"],
-  object: ExternalObjectImportCandidate
-): string | null {
-  if (suggestion === null) return null;
-  if (suggestion.kind === "fixed") return suggestion.value;
-  if (suggestion.kind === "selection-marker") {
-    return object.selectionMarker.trim() || null;
-  }
-  return object.familyAndType.trim() || null;
-}
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 572182b..96fd6c2 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -14,7 +14,6 @@ import type {
   ExternalCsvConfiguration,
   ExternalCsvDialect,
 } from "../external-model/csv/external-csv-contracts";
-import type { createExternalInitialImportPlan } from "../external-model/application/external-initial-import-plan";
 
 export interface ExternalCsvConfigurationSnapshotDto {
   id: string;
@@ -52,9 +51,80 @@ export interface ExternalCsvPreviewDto {
   suspectRowNumbers: number[];
 }
 
-export type ExternalInitialImportPlanDto = ReturnType<
-  typeof createExternalInitialImportPlan
->;
+export interface ExternalInitialImportPlanDto {
+  configurationVersion: number;
+  fileName: string;
+  sha256: string;
+  byteLength: number;
+  rowCount: number;
+  objectCount: number;
+  passthroughCount: number;
+  suspectObjectCount: number;
+  suspectRowNumbers: number[];
+  sourceRooms: Array<{
+    sourceRoomKey: string;
+    roomNumber: string;
+    roomName: string;
+    objectCount: number;
+    suggestedRoomId: string | null;
+    matchStatus: "exact-number" | "ambiguous-number" | "new";
+    candidateRoomIds: string[];
+  }>;
+  familyGroups: Array<{
+    familyAndType: string;
+    objectCount: number;
+    classified: boolean;
+    category: string | null;
+    connectionKind: string | null;
+    internalDeviceType: string | null;
+  }>;
+  issueCounts: {
+    unknownFamilyAndType: number;
+    invalidPower: number;
+    invalidQuantity: number;
+    missingRoom: number;
+  };
+  objects: Array<{
+    ifcGuid: string;
+    sourceRoomKey: string | null;
+    sourceValues: ExternalCsvPreviewObjectDto;
+    suggestedPlanningValues: {
+      displayName: string | null;
+      internalDeviceType: string | null;
+      category: CircuitGroupCategory | null;
+      connectionKind: string | null;
+      effectiveQuantity: number;
+      powerPerUnitW: number | null;
+      simultaneityFactor: number;
+      cosPhi: number | null;
+      costGroup: string | null;
+      remark: string | null;
+    };
+    issues: string[];
+  }>;
+  existing: {
+    floors: Array<{ id: string; name: string; sortOrder: number }>;
+    rooms: Array<{
+      id: string;
+      floorId: string | null;
+      roomNumber: string;
+      roomName: string;
+    }>;
+    distributionBoards: Array<{
+      id: string;
+      name: string;
+      floorId: string | null;
+    }>;
+    projectDevices: Array<{
+      id: string;
+      name: string;
+      displayName: string;
+      category: string | null;
+      connectionKind: string | null;
+      powerPerUnit: number;
+    }>;
+  };
+}
 
 export interface ApplyExternalInitialImportInput {
   expectedRevision: number;
diff --git a/src/server/composition/application-repositories.ts b/src/server/composition/application-repositories.ts
index 846a0da..a165a30 100644
--- a/src/server/composition/application-repositories.ts
+++ b/src/server/composition/application-repositories.ts
@@ -13,7 +13,7 @@ import { GlobalDeviceRepository } from "../../db/repositories/global-device.repo
 import { ProjectDeviceRepository } from "../../db/repositories/project-device.repository.js";
 import { ProjectRepository } from "../../db/repositories/project.repository.js";
 import { RoomRepository } from "../../db/repositories/room.repository.js";
-import { ExternalCsvConfigurationRepository } from "../../db/repositories/external-csv-configuration.repository.js";
+import { ExternalModelConfigurationRepository } from "../../db/repositories/external-model-configuration.repository.js";
 import { ExternalModelStateRepository } from "../../db/repositories/external-model-state.repository.js";
 import { DocumentBrandingRepository } from "../../db/repositories/document-branding.repository.js";
 import { UserRepository } from "../../db/repositories/user.repository.js";
@@ -36,8 +36,8 @@ export const globalDeviceRepository = new GlobalDeviceRepository(db);
 export const projectDeviceRepository = new ProjectDeviceRepository(db);
 export const projectRepository = new ProjectRepository(db);
 export const roomRepository = new RoomRepository(db);
-export const externalCsvConfigurationRepository =
-  new ExternalCsvConfigurationRepository(db);
+export const externalModelConfigurationRepository =
+  new ExternalModelConfigurationRepository(db);
 export const externalModelStateRepository = new ExternalModelStateRepository(db);
 export const documentBrandingRepository = new DocumentBrandingRepository(db);
 export const userRepository = new UserRepository(db);
diff --git a/src/server/composition/project-command-stores.ts b/src/server/composition/project-command-stores.ts
index 8768173..00f2d5f 100644
--- a/src/server/composition/project-command-stores.ts
+++ b/src/server/composition/project-command-stores.ts
@@ -22,8 +22,7 @@ import { ProjectDeviceStructureProjectCommandRepository } from "../../db/reposit
 import { ProjectSettingsProjectCommandRepository } from "../../db/repositories/project-settings-project-command.repository.js";
 import { ProjectStateRestoreCommandRepository } from "../../db/repositories/project-state-restore-command.repository.js";
 import { ProjectCommandService } from "../../domain/services/project-command.service.js";
-import { ExternalCsvConfigurationProjectCommandRepository } from "../../db/repositories/external-csv-configuration-project-command.repository.js";
-import { ExternalInitialImportProjectCommandRepository } from "../../db/repositories/external-initial-import-project-command.repository.js";
+import { ExternalModelConfigurationProjectCommandRepository } from "../../db/repositories/external-model-configuration-project-command.repository.js";
 import { ExternalObjectRowAssignmentProjectCommandRepository } from "../../db/repositories/external-object-row-assignment-project-command.repository.js";
 import { ExternalObjectNewRowProjectCommandRepository } from "../../db/repositories/external-object-new-row-project-command.repository.js";
 import { ExternalObjectNewCircuitProjectCommandRepository } from "../../db/repositories/external-object-new-circuit-project-command.repository.js";
@@ -71,10 +70,8 @@ export const projectSettingsProjectCommandStore =
 export const projectStateRestoreCommandStore =
   new ProjectStateRestoreCommandRepository(db);
 export const projectHistoryStore = new ProjectHistoryRepository(db);
-export const externalCsvConfigurationProjectCommandStore =
-  new ExternalCsvConfigurationProjectCommandRepository(db);
-export const externalInitialImportProjectCommandStore =
-  new ExternalInitialImportProjectCommandRepository(db);
+export const externalModelConfigurationProjectCommandStore =
+  new ExternalModelConfigurationProjectCommandRepository(db);
 export const externalObjectRowAssignmentProjectCommandStore =
   new ExternalObjectRowAssignmentProjectCommandRepository(db);
 export const externalObjectNewRowProjectCommandStore =
@@ -106,8 +103,7 @@ export const projectCommandService = new ProjectCommandService(
   circuitGroupSubtreeProjectCommandStore,
   circuitProtectionProjectCommandStore,
   projectHistoryStore,
-  externalCsvConfigurationProjectCommandStore,
-  externalInitialImportProjectCommandStore,
+  externalModelConfigurationProjectCommandStore,
   externalObjectRowAssignmentProjectCommandStore,
   externalObjectNewRowProjectCommandStore,
   externalObjectNewCircuitProjectCommandStore,
diff --git a/src/server/controllers/external-csv.controller.ts b/src/server/controllers/external-csv.controller.ts
deleted file mode 100644
index 4862d9b..0000000
--- a/src/server/controllers/external-csv.controller.ts
+++ /dev/null
@@ -1,298 +0,0 @@
-import crypto from "node:crypto";
-import type { Request, Response } from "express";
-import { assertExternalCsvConfiguration } from "../../external-model/csv/external-csv-configuration.js";
-import { ExternalCsvParseError } from "../../external-model/csv/external-csv-transport.js";
-import { createExternalCsvPreview } from "../../external-model/application/external-csv-preview.js";
-import { createExternalInitialImportPlan } from "../../external-model/application/external-initial-import-plan.js";
-import { buildExternalInitialImportTarget } from "../../external-model/application/external-initial-import-target.js";
-import { createExternalCircuitListObjects } from "../../external-model/application/external-circuit-list-objects.js";
-import { parseExternalCsv } from "../../external-model/csv/external-csv-transport.js";
-import {
-  createEmptyExternalModelState,
-  createExternalInitialImportProjectCommand,
-} from "../../domain/models/external-initial-import-project-command.model.js";
-import { createExternalCsvConfigurationUpdateProjectCommand } from "../../domain/models/external-csv-configuration-project-command.model.js";
-import {
-  previewExternalCsvSchema,
-  planExternalInitialImportSchema,
-  applyExternalInitialImportSchema,
-  updateExternalCsvConfigurationSchema,
-} from "../../shared/validation/external-csv.schemas.js";
-import {
-  distributionBoardRepository,
-  externalCsvConfigurationRepository,
-  externalModelStateRepository,
-  floorRepository,
-  projectDeviceRepository,
-  roomRepository,
-  circuitListRepository,
-} from "../composition/application-repositories.js";
-import { projectCommandService } from "../composition/project-command-stores.js";
-import { respondWithProjectCommandError } from "./project-command.controller.js";
-
-export function getExternalCsvConfiguration(req: Request, res: Response) {
-  const projectId = getProjectId(req, res);
-  if (!projectId) return;
-  const result = externalCsvConfigurationRepository.getByProject(projectId);
-  if (!result.projectExists) {
-    return res.status(404).json({ error: "Project not found" });
-  }
-  return res.json({ configuration: result.configuration });
-}
-
-export async function getExternalCircuitListObjects(req: Request, res: Response) {
-  const projectId = getProjectId(req, res);
-  if (!projectId) return;
-  const { circuitListId } = req.params;
-  if (typeof circuitListId !== "string" || !circuitListId.trim()) {
-    return res.status(400).json({ error: "Invalid circuitListId" });
-  }
-  const circuitList = await circuitListRepository.findById(projectId, circuitListId);
-  if (!circuitList) {
-    return res.status(404).json({ error: "Circuit list not found" });
-  }
-  const state = externalModelStateRepository.getByProject(projectId);
-  if (!state.projectExists) {
-    return res.status(404).json({ error: "Project not found" });
-  }
-  return res.json(createExternalCircuitListObjects({
-    state: state.state,
-    distributionBoardId: circuitList.distributionBoardId,
-  }));
-}
-
-export function updateExternalCsvConfiguration(req: Request, res: Response) {
-  const projectId = getProjectId(req, res);
-  if (!projectId) return;
-  const parsed = updateExternalCsvConfigurationSchema.safeParse(req.body);
-  if (!parsed.success) {
-    return res.status(400).json({ error: parsed.error.flatten() });
-  }
-  try {
-    assertExternalCsvConfiguration(parsed.data.configuration);
-    const current = externalCsvConfigurationRepository.getByProject(projectId);
-    if (!current.projectExists) {
-      return res.status(404).json({ error: "Project not found" });
-    }
-    const target = {
-      id: current.configuration?.id ?? crypto.randomUUID(),
-      projectId,
-      configurationVersion:
-        (current.configuration?.configurationVersion ?? 0) + 1,
-      configuration: parsed.data.configuration,
-    };
-    const result = projectCommandService.executeUser({
-      projectId,
-      expectedRevision: parsed.data.expectedRevision,
-      description: "Revit-CSV-Konfiguration bearbeiten",
-      command: createExternalCsvConfigurationUpdateProjectCommand(
-        current.configuration,
-        target
-      ),
-    });
-    return res.json({ ...result, configuration: target });
-  } catch (error) {
-    return respondWithProjectCommandError(error, res);
-  }
-}
-
-export function previewExternalCsv(req: Request, res: Response) {
-  const projectId = getProjectId(req, res);
-  if (!projectId) return;
-  const parsed = previewExternalCsvSchema.safeParse(req.body);
-  if (!parsed.success) {
-    return res.status(400).json({ error: parsed.error.flatten() });
-  }
-  const stored = externalCsvConfigurationRepository.getByProject(projectId);
-  if (!stored.projectExists) {
-    return res.status(404).json({ error: "Project not found" });
-  }
-  if (!stored.configuration) {
-    return res.status(409).json({
-      error: "Für das Projekt ist noch keine Revit-CSV-Konfiguration gespeichert.",
-      code: "EXTERNAL_CSV_CONFIGURATION_REQUIRED",
-    });
-  }
-  try {
-    const bytes = decodeBase64(parsed.data.contentBase64);
-    return res.json(
-      createExternalCsvPreview({
-        fileName: parsed.data.fileName,
-        bytes,
-        configuration: stored.configuration.configuration,
-      })
-    );
-  } catch (error) {
-    if (error instanceof ExternalCsvParseError) {
-      return res.status(400).json({ error: error.message, code: error.code });
-    }
-    return res.status(400).json({
-      error: error instanceof Error ? error.message : "CSV-Vorschau fehlgeschlagen.",
-    });
-  }
-}
-
-export async function planExternalInitialImport(req: Request, res: Response) {
-  const projectId = getProjectId(req, res);
-  if (!projectId) return;
-  const parsed = planExternalInitialImportSchema.safeParse(req.body);
-  if (!parsed.success) {
-    return res.status(400).json({ error: parsed.error.flatten() });
-  }
-  const stored = externalCsvConfigurationRepository.getByProject(projectId);
-  if (!stored.projectExists) {
-    return res.status(404).json({ error: "Project not found" });
-  }
-  if (!stored.configuration) {
-    return res.status(409).json({
-      error: "Für das Projekt ist noch keine Revit-CSV-Konfiguration gespeichert.",
-      code: "EXTERNAL_CSV_CONFIGURATION_REQUIRED",
-    });
-  }
-  const externalState = externalModelStateRepository.getByProject(projectId);
-  if (externalState.state.source !== null) {
-    return res.status(409).json({
-      error: "Für dieses Projekt wurde bereits ein Revit-Modell importiert.",
-      code: "EXTERNAL_INITIAL_IMPORT_ALREADY_APPLIED",
-    });
-  }
-  try {
-    const bytes = decodeBase64(parsed.data.contentBase64);
-    const [floors, rooms, distributionBoards, projectDevices] = await Promise.all([
-      floorRepository.listByProject(projectId),
-      roomRepository.listByProject(projectId),
-      distributionBoardRepository.listByProject(projectId),
-      projectDeviceRepository.listByProject(projectId),
-    ]);
-    return res.json(createExternalInitialImportPlan({
-      fileName: parsed.data.fileName,
-      bytes,
-      configurationVersion: stored.configuration.configurationVersion,
-      configuration: stored.configuration.configuration,
-      floors,
-      rooms,
-      distributionBoards,
-      projectDevices,
-    }));
-  } catch (error) {
-    if (error instanceof ExternalCsvParseError) {
-      return res.status(400).json({ error: error.message, code: error.code });
-    }
-    return res.status(400).json({
-      error: error instanceof Error ? error.message : "Erstimport-Planung fehlgeschlagen.",
-    });
-  }
-}
-
-export async function applyExternalInitialImport(req: Request, res: Response) {
-  const projectId = getProjectId(req, res);
-  if (!projectId) return;
-  const parsed = applyExternalInitialImportSchema.safeParse(req.body);
-  if (!parsed.success) {
-    return res.status(400).json({ error: parsed.error.flatten() });
-  }
-  const stored = externalCsvConfigurationRepository.getByProject(projectId);
-  if (!stored.projectExists) {
-    return res.status(404).json({ error: "Project not found" });
-  }
-  if (!stored.configuration) {
-    return res.status(409).json({
-      error: "Für das Projekt ist noch keine Revit-CSV-Konfiguration gespeichert.",
-      code: "EXTERNAL_CSV_CONFIGURATION_REQUIRED",
-    });
-  }
-  if (
-    stored.configuration.configurationVersion !==
-    parsed.data.expectedConfigurationVersion
-  ) {
-    return res.status(409).json({
-      error: "Die Revit-CSV-Konfiguration wurde seit der Planung geändert.",
-      code: "EXTERNAL_CSV_CONFIGURATION_CHANGED",
-    });
-  }
-  try {
-    const bytes = decodeBase64(parsed.data.contentBase64);
-    const [floors, rooms, distributionBoards, projectDevices] = await Promise.all([
-      floorRepository.listByProject(projectId),
-      roomRepository.listByProject(projectId),
-      distributionBoardRepository.listByProject(projectId),
-      projectDeviceRepository.listByProject(projectId),
-    ]);
-    const plan = createExternalInitialImportPlan({
-      fileName: parsed.data.fileName,
-      bytes,
-      configurationVersion: stored.configuration.configurationVersion,
-      configuration: stored.configuration.configuration,
-      floors,
-      rooms,
-      distributionBoards,
-      projectDevices,
-    });
-    if (plan.sha256 !== parsed.data.expectedSha256) {
-      return res.status(409).json({
-        error: "Die CSV-Datei stimmt nicht mehr mit der geprüften Planung überein.",
-        code: "EXTERNAL_CSV_FILE_CHANGED",
-      });
-    }
-    const target = buildExternalInitialImportTarget({
-      projectId,
-      expectedRevision: parsed.data.expectedRevision,
-      sourceName: parsed.data.sourceName,
-      importedAtIso: new Date().toISOString(),
-      configurationVersion: stored.configuration.configurationVersion,
-      configuration: stored.configuration.configuration,
-      originalContentBase64: parsed.data.contentBase64,
-      document: parseExternalCsv(bytes, stored.configuration.configuration),
-      plan,
-      roomDecisions: parsed.data.roomDecisions,
-      familyProjectDeviceDecisions:
-        parsed.data.familyProjectDeviceDecisions,
-      createId: () => crypto.randomUUID(),
-    });
-    const result = projectCommandService.executeUser({
-      projectId,
-      expectedRevision: parsed.data.expectedRevision,
-      description: `Revit-Erstimport ${parsed.data.fileName}`,
-      command: createExternalInitialImportProjectCommand(
-        createEmptyExternalModelState(),
-        target
-      ),
-    });
-    return res.status(201).json({
-      ...result,
-      import: {
-        sourceId: target.source!.id,
-        importBatchId: target.importBatches[0].id,
-        objectCount: target.objects.length,
-      },
-    });
-  } catch (error) {
-    if (error instanceof ExternalCsvParseError) {
-      return res.status(400).json({ error: error.message, code: error.code });
-    }
-    return respondWithProjectCommandError(error, res);
-  }
-}
-
-function decodeBase64(value: string) {
-  if (!/^[A-Za-z0-9+/]+={0,2}$/.test(value) || value.length % 4 !== 0) {
-    throw new Error("CSV-Inhalt ist nicht gültig Base64-kodiert.");
-  }
-  const bytes = Buffer.from(value, "base64");
-  if (bytes.toString("base64") !== value) {
-    throw new Error("CSV-Inhalt ist nicht kanonisch Base64-kodiert.");
-  }
-  if (bytes.length > 18 * 1024 * 1024) {
-    throw new Error("CSV-Datei überschreitet die maximale Größe von 18 MB.");
-  }
-  return bytes;
-}
-
-function getProjectId(req: Request, res: Response) {
-  const { projectId } = req.params;
-  if (typeof projectId !== "string" || !projectId.trim()) {
-    res.status(400).json({ error: "Invalid projectId" });
-    return null;
-  }
-  return projectId;
-}
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index 927223e..06f9ec2 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -53,14 +53,6 @@ import {
   importProjectTransfer,
   importProjectTransferAsNewProject,
 } from "../controllers/project-transfer.controller.js";
-import {
-  getExternalCsvConfiguration,
-  applyExternalInitialImport,
-  previewExternalCsv,
-  planExternalInitialImport,
-  updateExternalCsvConfiguration,
-  getExternalCircuitListObjects,
-} from "../controllers/external-csv.controller.js";
 
 export const projectRouter = Router();
 
@@ -70,21 +62,6 @@ projectRouter.post("/import", importProjectTransferAsNewProject);
 projectRouter.get("/:projectId", getProject);
 projectRouter.get("/:projectId/export", exportProjectTransfer);
 projectRouter.post("/:projectId/import", importProjectTransfer);
-projectRouter.get("/:projectId/external-csv/configuration", getExternalCsvConfiguration);
-projectRouter.put("/:projectId/external-csv/configuration", updateExternalCsvConfiguration);
-projectRouter.post("/:projectId/external-csv/preview", previewExternalCsv);
-projectRouter.post(
-  "/:projectId/external-csv/initial-import/plan",
-  planExternalInitialImport
-);
-projectRouter.get(
-  "/:projectId/circuit-lists/:circuitListId/external-objects",
-  getExternalCircuitListObjects
-);
-projectRouter.post(
-  "/:projectId/external-csv/initial-import/apply",
-  applyExternalInitialImport
-);
 projectRouter.get("/:projectId/history", getProjectHistory);
 projectRouter.get("/:projectId/history/revisions", listProjectRevisions);
 projectRouter.post("/:projectId/commands", executeProjectCommand);
diff --git a/src/shared/validation/external-csv.schemas.ts b/src/shared/validation/external-csv.schemas.ts
deleted file mode 100644
index cf99e66..0000000
--- a/src/shared/validation/external-csv.schemas.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { z } from "zod";
-
-// Base64 length of the 18 MiB transport limit documented for CSV uploads
-// (18 * 1024 * 1024 bytes, evenly divisible by 3, so ceil(N/3)*4 with no
-// padding). Keep in sync with the controller's raw byte-length check.
-export const MAX_CSV_CONTENT_BASE64_LENGTH = 25_165_824;
-
-export const updateExternalCsvConfigurationSchema = z
-  .object({
-    expectedRevision: z.number().int().nonnegative(),
-    configuration: z.unknown(),
-  })
-  .strict();
-
-export const previewExternalCsvSchema = z
-  .object({
-    fileName: z.string().trim().min(1).max(255),
-    contentBase64: z.string().min(1).max(MAX_CSV_CONTENT_BASE64_LENGTH),
-  })
-  .strict();
-
-export const planExternalInitialImportSchema = previewExternalCsvSchema;
-
-export const applyExternalInitialImportSchema = z.object({
-  expectedRevision: z.number().int().nonnegative(),
-  expectedConfigurationVersion: z.number().int().positive(),
-  expectedSha256: z.string().regex(/^[a-f0-9]{64}$/),
-  fileName: z.string().trim().min(1).max(255),
-  contentBase64: z.string().min(1).max(MAX_CSV_CONTENT_BASE64_LENGTH),
-  sourceName: z.string().trim().min(1).max(200),
-  roomDecisions: z.array(z.object({
-    sourceRoomKey: z.string().trim().min(1),
-    roomId: z.string().trim().min(1).nullable(),
-    defaultDistributionBoardId: z.string().trim().min(1).nullable(),
-  }).strict()),
-  familyProjectDeviceDecisions: z.array(z.object({
-    familyAndType: z.string(),
-    projectDeviceId: z.string().trim().min(1).nullable(),
-  }).strict()),
-}).strict();
diff --git a/tests/external-circuit-list-objects.test.ts b/tests/external-circuit-list-objects.test.ts
deleted file mode 100644
index 4552d58..0000000
--- a/tests/external-circuit-list-objects.test.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { createExternalCircuitListObjects } from "../src/external-model/application/external-circuit-list-objects.js";
-import type {
-  ExternalModelObjectSnapshot,
-  ExternalModelStateSnapshot,
-} from "../src/external-model/domain/external-model-contracts.js";
-
-function object(input: {
-  id: string;
-  distributionBoardId: string;
-  circuitDeviceRowId: string | null;
-  roomNumber: string;
-}): ExternalModelObjectSnapshot {
-  return {
-    id: input.id,
-    projectId: "project-1",
-    sourceId: "source-1",
-    ifcGuid: `ifc-${input.id}`,
-    lastSeenImportBatchId: "batch-1",
-    lastAcceptedImportBatchId: "batch-1",
-    acceptedSourceValues: {
-      rowNumber: 2,
-      roomNumber: input.roomNumber,
-      roomName: "Büro",
-      familyAndType: "Steckdose: Standard",
-      selectionMarker: `S-${input.id}`,
-      circuitIdentifier: "-2F1.1",
-      power: "120",
-      quantity: "1",
-      additionalSourceValues: {},
-    },
-    planningValues: {
-      displayName: "Steckdose",
-      internalDeviceType: "socket",
-      category: "single_phase",
-      connectionKind: "socket",
-      effectiveQuantity: 1,
-      powerPerUnitW: 120,
-      simultaneityFactor: 1,
-      cosPhi: null,
-      costGroup: null,
-      remark: null,
-    },
-    overriddenFields: [],
-    externalRoomMappingId: input.distributionBoardId === "board-1" ? "mapping-1" : null,
-    distributionBoardId: input.distributionBoardId,
-    linkedProjectDeviceId: null,
-    circuitDeviceRowId: input.circuitDeviceRowId,
-    presenceStatus: "present",
-  };
-}
-
-describe("external circuit-list object projection", () => {
-  it("returns only the board objects with unassigned objects first", () => {
-    const state: ExternalModelStateSnapshot = {
-      source: {
-        id: "source-1",
-        projectId: "project-1",
-        name: "Revit-Gesamtmodell",
-        sourceType: "revit_csv",
-      },
-      importBatches: [],
-      roomMappings: [{
-        id: "mapping-1",
-        projectId: "project-1",
-        sourceId: "source-1",
-        normalizedSourceRoomKey: "number:101",
-        sourceFloorName: "EG",
-        sourceRoomNumber: "101",
-        sourceRoomName: "Besprechung",
-        roomId: "room-1",
-        defaultDistributionBoardId: "board-1",
-      }],
-      objects: [
-        object({ id: "assigned", distributionBoardId: "board-1", circuitDeviceRowId: "row-1", roomNumber: "102" }),
-        object({ id: "unassigned", distributionBoardId: "board-1", circuitDeviceRowId: null, roomNumber: "101" }),
-        object({ id: "other-board", distributionBoardId: "board-2", circuitDeviceRowId: null, roomNumber: "001" }),
-      ],
-    };
-
-    const result = createExternalCircuitListObjects({
-      state,
-      distributionBoardId: "board-1",
-    });
-
-    assert.equal(result.sourceName, "Revit-Gesamtmodell");
-    assert.equal(result.objectCount, 2);
-    assert.equal(result.unassignedObjectCount, 1);
-    assert.deepEqual(result.objects.map(({ id }) => id), ["unassigned", "assigned"]);
-    assert.equal(result.objects[0].sourceRoomName, "Besprechung");
-    assert.equal(result.objects[0].roomId, "room-1");
-    assert.equal(result.objects[0].sourceCircuitIdentifier, "-2F1.1");
-  });
-
-  it("returns an empty projection before the optional Revit import", () => {
-    assert.deepEqual(
-      createExternalCircuitListObjects({
-        state: { source: null, importBatches: [], roomMappings: [], objects: [] },
-        distributionBoardId: "board-1",
-      }),
-      { sourceName: null, objectCount: 0, unassignedObjectCount: 0, objects: [] }
-    );
-  });
-});
diff --git a/tests/external-csv-api-contract.test.ts b/tests/external-csv-api-contract.test.ts
deleted file mode 100644
index dfba2ae..0000000
--- a/tests/external-csv-api-contract.test.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-  applyExternalInitialImportSchema,
-  MAX_CSV_CONTENT_BASE64_LENGTH,
-  planExternalInitialImportSchema,
-  previewExternalCsvSchema,
-  updateExternalCsvConfigurationSchema,
-} from "../src/shared/validation/external-csv.schemas.js";
-import { createDefaultExternalCsvConfiguration } from "../src/external-model/csv/external-csv-contracts.js";
-import { externalCsvTestColumns } from "./fixtures/revit-csv-fixtures.js";
-
-describe("external CSV API contracts", () => {
-  it("accepts strict update and preview request envelopes", () => {
-    assert.equal(
-      updateExternalCsvConfigurationSchema.safeParse({
-        expectedRevision: 4,
-        configuration: createDefaultExternalCsvConfiguration(externalCsvTestColumns),
-      }).success,
-      true
-    );
-    assert.equal(
-      previewExternalCsvSchema.safeParse({
-        fileName: "revit.csv",
-        contentBase64: "YWJj",
-      }).success,
-      true
-    );
-    assert.equal(
-      planExternalInitialImportSchema.safeParse({
-        fileName: "revit.csv",
-        contentBase64: "YWJj",
-      }).success,
-      true
-    );
-    assert.equal(
-      applyExternalInitialImportSchema.safeParse({
-        expectedRevision: 5,
-        expectedConfigurationVersion: 2,
-        expectedSha256: "a".repeat(64),
-        fileName: "revit.csv",
-        contentBase64: "YWJj",
-        sourceName: "Revit-Gesamtmodell",
-        roomDecisions: [],
-        familyProjectDeviceDecisions: [],
-      }).success,
-      true
-    );
-  });
-
-  it("rejects stale-shaped, oversized and unknown request fields", () => {
-    assert.equal(
-      updateExternalCsvConfigurationSchema.safeParse({
-        expectedRevision: -1,
-        configuration: {},
-      }).success,
-      false
-    );
-    assert.equal(
-      previewExternalCsvSchema.safeParse({
-        fileName: "revit.csv",
-        contentBase64: "YWJj",
-        apply: true,
-      }).success,
-      false
-    );
-    assert.equal(
-      planExternalInitialImportSchema.safeParse({
-        fileName: "revit.csv",
-        contentBase64: "YWJj",
-        decisions: [],
-      }).success,
-      false
-    );
-    assert.equal(
-      previewExternalCsvSchema.safeParse({
-        fileName: "revit.csv",
-        contentBase64: "a".repeat(MAX_CSV_CONTENT_BASE64_LENGTH + 1),
-      }).success,
-      false
-    );
-  });
-});
diff --git a/tests/external-csv-configuration-project-command.repository.test.ts b/tests/external-csv-configuration-project-command.repository.test.ts
deleted file mode 100644
index 0186581..0000000
--- a/tests/external-csv-configuration-project-command.repository.test.ts
+++ /dev/null
@@ -1,244 +0,0 @@
-import path from "node:path";
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { eq } from "drizzle-orm";
-import { migrate } from "drizzle-orm/better-sqlite3/migrator";
-import {
-  createDatabaseContext,
-  type DatabaseContext,
-} from "../src/db/database-context.js";
-import { ExternalCsvConfigurationProjectCommandRepository } from "../src/db/repositories/external-csv-configuration-project-command.repository.js";
-import { ExternalCsvConfigurationRepository } from "../src/db/repositories/external-csv-configuration.repository.js";
-import { ProjectTransferRepository } from "../src/db/repositories/project-transfer.repository.js";
-import { ProjectStateRestoreCommandRepository } from "../src/db/repositories/project-state-restore-command.repository.js";
-import { readProjectStateSnapshot } from "../src/db/repositories/project-state-snapshot.persistence.js";
-import { externalCsvConfigurations } from "../src/db/schema/external-csv-configurations.js";
-import { projects } from "../src/db/schema/projects.js";
-import { createExternalCsvConfigurationUpdateProjectCommand } from "../src/domain/models/external-csv-configuration-project-command.model.js";
-import { createProjectStateRestoreCommand } from "../src/domain/models/project-state-restore-command.model.js";
-import { createDefaultExternalCsvConfiguration } from "../src/external-model/csv/external-csv-contracts.js";
-import { externalCsvTestColumns } from "./fixtures/revit-csv-fixtures.js";
-
-function createTestDatabase(): DatabaseContext {
-  const context = createDatabaseContext(":memory:");
-  migrate(context.db, {
-    migrationsFolder: path.resolve("src", "db", "migrations"),
-  });
-  context.db.insert(projects).values({ id: "project-1", name: "Projekt" }).run();
-  return context;
-}
-
-function snapshot(version = 1) {
-  const configuration = createDefaultExternalCsvConfiguration(externalCsvTestColumns);
-  configuration.familyTypeRules.push({
-    exactFamilyAndType: "Steckdose: Standard",
-    internalDeviceType: "Steckdose",
-    connectionKind: null,
-    category: "single_phase",
-    quantityRule: { kind: "fixed", quantity: 1 },
-    displayNameSuggestion: { kind: "selection-marker" },
-  });
-  return {
-    id: "external-config-1",
-    projectId: "project-1",
-    configurationVersion: version,
-    configuration,
-  };
-}
-
-describe("external CSV configuration project command", () => {
-  it("persists insert and update with exact inverse commands", () => {
-    const context = createTestDatabase();
-    try {
-      const repository = new ExternalCsvConfigurationProjectCommandRepository(context.db);
-      const initial = snapshot();
-      const inserted = repository.execute({
-        projectId: "project-1",
-        expectedRevision: 0,
-        source: "user",
-        description: "Revit-CSV-Konfiguration anlegen",
-        command: createExternalCsvConfigurationUpdateProjectCommand(null, initial),
-      });
-      assert.equal(inserted.revision.revisionNumber, 1);
-      assert.deepEqual(readConfiguration(context), initial);
-      assert.deepEqual(inserted.inverse.payload, { expected: initial, target: null });
-
-      const target = structuredClone(initial);
-      target.configurationVersion = 2;
-      target.configuration.decimalSeparator = ".";
-      const updated = repository.execute({
-        projectId: "project-1",
-        expectedRevision: 1,
-        source: "user",
-        command: createExternalCsvConfigurationUpdateProjectCommand(initial, target),
-      });
-      assert.equal(updated.revision.revisionNumber, 2);
-      assert.deepEqual(readConfiguration(context), target);
-      assert.deepEqual(updated.inverse.payload, { expected: target, target: initial });
-    } finally {
-      context.close();
-    }
-  });
-
-  it("rejects stale state and cross-project targets without a partial revision", () => {
-    const context = createTestDatabase();
-    try {
-      const repository = new ExternalCsvConfigurationProjectCommandRepository(context.db);
-      const initial = snapshot();
-      repository.execute({
-        projectId: "project-1",
-        expectedRevision: 0,
-        source: "user",
-        command: createExternalCsvConfigurationUpdateProjectCommand(null, initial),
-      });
-
-      assert.throws(
-        () => repository.execute({
-          projectId: "project-1",
-          expectedRevision: 1,
-          source: "user",
-          command: createExternalCsvConfigurationUpdateProjectCommand(null, snapshot(2)),
-        }),
-        /changed before update/
-      );
-      const foreign = snapshot(2);
-      foreign.projectId = "project-2";
-      assert.throws(
-        () => repository.execute({
-          projectId: "project-1",
-          expectedRevision: 1,
-          source: "user",
-          command: createExternalCsvConfigurationUpdateProjectCommand(initial, foreign),
-        }),
-        /identity must remain stable|different project/
-      );
-      assert.equal(context.db.select({ revision: projects.currentRevision }).from(projects).get()?.revision, 1);
-
-      const skippedVersion = snapshot(3);
-      assert.throws(
-        () => repository.execute({
-          projectId: "project-1",
-          expectedRevision: 1,
-          source: "user",
-          command: createExternalCsvConfigurationUpdateProjectCommand(initial, skippedVersion),
-        }),
-        /version must advance by one/
-      );
-      assert.throws(
-        () => repository.execute({
-          projectId: "project-1",
-          expectedRevision: 1,
-          source: "user",
-          command: createExternalCsvConfigurationUpdateProjectCommand(initial, initial),
-        }),
-        /did not change/
-      );
-    } finally {
-      context.close();
-    }
-  });
-
-  it("includes configuration in snapshots and remaps it for project duplicates", () => {
-    const context = createTestDatabase();
-    try {
-      const repository = new ExternalCsvConfigurationProjectCommandRepository(context.db);
-      const initial = snapshot();
-      repository.execute({
-        projectId: "project-1",
-        expectedRevision: 0,
-        source: "user",
-        command: createExternalCsvConfigurationUpdateProjectCommand(null, initial),
-      });
-
-      const state = readProjectStateSnapshot(context.db, "project-1")?.state;
-      assert.deepEqual(state?.externalCsvConfiguration, initial);
-      const transferRepository = new ProjectTransferRepository(context.db);
-      const transfer = transferRepository.exportProject("project-1");
-      assert.ok(transfer);
-      const duplicate = transferRepository.importDuplicate(transfer);
-      const duplicatedConfiguration = context.db
-        .select()
-        .from(externalCsvConfigurations)
-        .where(eq(externalCsvConfigurations.projectId, duplicate.projectId))
-        .get();
-      assert.ok(duplicatedConfiguration);
-      assert.notEqual(duplicatedConfiguration.id, initial.id);
-      assert.equal(duplicatedConfiguration.projectId, duplicate.projectId);
-      assert.deepEqual(duplicatedConfiguration.configuration, initial.configuration);
-    } finally {
-      context.close();
-    }
-  });
-
-  it("distinguishes projects without configuration from unknown projects", () => {
-    const context = createTestDatabase();
-    try {
-      const reader = new ExternalCsvConfigurationRepository(context.db);
-      assert.deepEqual(reader.getByProject("project-1"), {
-        projectExists: true,
-        configuration: null,
-      });
-      assert.deepEqual(reader.getByProject("missing"), {
-        projectExists: false,
-        configuration: null,
-      });
-    } finally {
-      context.close();
-    }
-  });
-
-  it("restores and undoes the complete configuration through snapshot history", () => {
-    const context = createTestDatabase();
-    try {
-      const configurationRepository = new ExternalCsvConfigurationProjectCommandRepository(context.db);
-      const initial = snapshot();
-      configurationRepository.execute({
-        projectId: "project-1",
-        expectedRevision: 0,
-        source: "user",
-        command: createExternalCsvConfigurationUpdateProjectCommand(null, initial),
-      });
-      const configuredState = readProjectStateSnapshot(context.db, "project-1");
-      assert.ok(configuredState);
-      configurationRepository.execute({
-        projectId: "project-1",
-        expectedRevision: 1,
-        source: "user",
-        command: createExternalCsvConfigurationUpdateProjectCommand(initial, null),
-      });
-      const emptyState = readProjectStateSnapshot(context.db, "project-1");
-      assert.ok(emptyState);
-
-      const restoreRepository = new ProjectStateRestoreCommandRepository(context.db);
-      const restored = restoreRepository.execute({
-        projectId: "project-1",
-        expectedRevision: 2,
-        source: "user",
-        command: createProjectStateRestoreCommand(
-          emptyState.payloadSha256,
-          configuredState.state
-        ),
-      });
-      assert.deepEqual(readConfiguration(context), initial);
-
-      restoreRepository.execute({
-        projectId: "project-1",
-        expectedRevision: 3,
-        source: "undo",
-        historyTargetChangeSetId: restored.revision.changeSetId,
-        command: restored.inverse,
-      });
-      assert.equal(readConfiguration(context), null);
-    } finally {
-      context.close();
-    }
-  });
-});
-
-function readConfiguration(context: DatabaseContext) {
-  return context.db
-    .select()
-    .from(externalCsvConfigurations)
-    .where(eq(externalCsvConfigurations.projectId, "project-1"))
-    .get() ?? null;
-}
diff --git a/tests/external-csv-preview.test.ts b/tests/external-csv-preview.test.ts
deleted file mode 100644
index b786ebd..0000000
--- a/tests/external-csv-preview.test.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { createExternalCsvPreview } from "../src/external-model/application/external-csv-preview.js";
-import {
-  externalCsvTestConfiguration,
-  firstIfcGuid,
-  quotedRevitCsv,
-  utf8Bytes,
-} from "./fixtures/revit-csv-fixtures.js";
-
-describe("external CSV preview", () => {
-  it("projects transport statistics and mapped object source values without writes", () => {
-    const configuration = structuredClone(externalCsvTestConfiguration);
-    configuration.additionalSourceMappings.push({
-      sourceColumn: "Raumname",
-      targetField: "sourceRoomLabel",
-    });
-    // The additional mapping intentionally needs a distinct source column in
-    // persisted configuration, so use a separately named synthetic header.
-    configuration.additionalSourceMappings[0].sourceColumn = "Zusatzwert";
-    const csv = quotedRevitCsv
-      .replace('"Anzahl";"IfcGUID"', '"Anzahl";"Zusatzwert";"IfcGUID"')
-      .replaceAll(';"2";"0Ab', ';"2";"A";"0Ab')
-      .replaceAll(';"1";"1Ab', ';"1";"B";"1Ab')
-      .replaceAll(';"1";""', ';"1";"C";""')
-      .replaceAll(';"";""\r\n', ';"";"";""\r\n');
-
-    const preview = createExternalCsvPreview({
-      fileName: "export.csv",
-      bytes: utf8Bytes(csv, true),
-      configuration,
-    });
-
-    assert.equal(preview.fileName, "export.csv");
-    assert.equal(preview.headerRowNumber, 2);
-    assert.equal(preview.rowCount, 7);
-    assert.equal(preview.objectCount, 2);
-    assert.equal(preview.passthroughCount, 2);
-    assert.equal(preview.nonEmptyPassthroughCount, 1);
-    assert.equal(preview.suspectObjectCount, 1);
-    assert.deepEqual(preview.suspectRowNumbers, [6]);
-    assert.match(preview.sha256, /^[a-f0-9]{64}$/);
-    assert.deepEqual(preview.objects[0], {
-      rowNumber: 4,
-      ifcGuid: firstIfcGuid,
-      roomNumber: "01/101",
-      roomName: "Technik",
-      familyAndType: "Steckdose: Doppelsteckdose",
-      selectionMarker: "Arbeitsplatz",
-      circuitIdentifier: "UV_AV_01-2F1",
-      power: "120,5",
-      quantity: "2",
-      additionalSourceValues: { sourceRoomLabel: "A" },
-    });
-  });
-});
diff --git a/tests/external-csv-transport.test.ts b/tests/external-csv-transport.test.ts
deleted file mode 100644
index 11a44ac..0000000
--- a/tests/external-csv-transport.test.ts
+++ /dev/null
@@ -1,146 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-  ExternalCsvParseError,
-  parseExternalCsv,
-  serializeExternalCsv,
-} from "../src/external-model/csv/external-csv-transport.js";
-import {
-  externalCsvTestConfiguration,
-  firstIfcGuid,
-  quotedRevitCsv,
-  utf8Bytes,
-} from "./fixtures/revit-csv-fixtures.js";
-
-describe("external CSV transport", () => {
-  it("detects the observed Revit dialect and classifies every row", () => {
-    const document = parseExternalCsv(
-      utf8Bytes(quotedRevitCsv, true),
-      externalCsvTestConfiguration
-    );
-
-    assert.deepEqual(document.dialect, {
-      encoding: "utf-8",
-      hasBom: true,
-      delimiter: ";",
-      lineEnding: "\r\n",
-      quoteCharacter: '"',
-      quoteAllFields: true,
-      hasTrailingLineEnding: true,
-    });
-    assert.equal(document.headerRowIndex, 1);
-    assert.deepEqual(
-      document.rows.map((row) => row.classification),
-      [
-        "metadata",
-        "header",
-        "passthrough",
-        "object",
-        "passthrough",
-        "suspect-object",
-        "object",
-      ]
-    );
-    assert.equal(document.rows[6].cells[2].value, 'Büro "Nord"');
-  });
-
-  it("round-trips BOM, CRLF, quotation, order and cell values byte for byte", () => {
-    const source = utf8Bytes(quotedRevitCsv, true);
-    const document = parseExternalCsv(source, externalCsvTestConfiguration);
-
-    assert.deepEqual(serializeExternalCsv(document), source);
-  });
-
-  it("parses exports without an optional quantity column", () => {
-    const configuration = {
-      ...externalCsvTestConfiguration,
-      columns: {
-        ...externalCsvTestConfiguration.columns,
-        quantity: null,
-      },
-    };
-    const csv = [
-      '"Projekt-Export";"";"";"";"";"";""',
-      '"Stromkreis";"Raumnummer";"Raumname";"Familie und Typ";"CAx_Auswahlkenner";"Elektrische Leistung";"IfcGUID"',
-      `"UV_AV_01-2F1";"01/101";"Technik";"Steckdose: Standard";"Arbeitsplatz";"100";"${firstIfcGuid}"`,
-    ].join("\r\n") + "\r\n";
-
-    const document = parseExternalCsv(utf8Bytes(csv, true), configuration);
-
-    assert.equal(
-      document.rows.filter((row) => row.classification === "object").length,
-      1
-    );
-  });
-
-  it("preserves embedded delimiters and line endings inside quoted cells", () => {
-    const csv = quotedRevitCsv.replace(
-      '"Steckdose: Doppelsteckdose"',
-      '"Steckdose; Doppel\r\nsteckdose"'
-    );
-    const source = utf8Bytes(csv, true);
-    const document = parseExternalCsv(source, externalCsvTestConfiguration);
-
-    assert.equal(
-      document.rows[3].cells[3].value,
-      "Steckdose; Doppel\r\nsteckdose"
-    );
-    assert.deepEqual(serializeExternalCsv(document), source);
-  });
-
-  it("blocks missing and ambiguous configured headers", () => {
-    assertParseError(
-      utf8Bytes(quotedRevitCsv.replace("IfcGUID", "Andere ID")),
-      "header-not-found"
-    );
-    const duplicatedHeader = quotedRevitCsv.replace(
-      '"";"";"";"";"";"";"";""',
-      quotedRevitCsv.split("\r\n")[1]
-    );
-    assertParseError(utf8Bytes(duplicatedHeader), "ambiguous-header");
-
-    const duplicateConfiguredColumn = quotedRevitCsv.replace(
-      '"Stromkreis";"Raumnummer"',
-      '"Stromkreis";"Raumnummer";"Raumnummer"'
-    );
-    assertParseError(
-      utf8Bytes(duplicateConfiguredColumn),
-      "ambiguous-header"
-    );
-  });
-
-  it("blocks invalid and duplicate non-empty IfcGUIDs", () => {
-    assertParseError(
-      utf8Bytes(quotedRevitCsv.replace(firstIfcGuid, "not-an-ifc-guid")),
-      "invalid-ifc-guid"
-    );
-    assertParseError(
-      utf8Bytes(quotedRevitCsv.replace(firstIfcGuid, ` ${firstIfcGuid}`)),
-      "invalid-ifc-guid"
-    );
-    const duplicate = quotedRevitCsv.replace(
-      "1AbCdEfGhIjKlMnOpQrStu",
-      firstIfcGuid
-    );
-    assertParseError(utf8Bytes(duplicate), "duplicate-ifc-guid");
-  });
-
-  it("blocks invalid UTF-8, unterminated quotes and mixed row endings", () => {
-    assertParseError(new Uint8Array([0xff, 0xfe, 0xfd]), "invalid-encoding");
-    assertParseError(
-      utf8Bytes(quotedRevitCsv.replace(/"\r\n$/, "\r\n")),
-      "invalid-csv"
-    );
-    assertParseError(
-      utf8Bytes(quotedRevitCsv.replace("\r\n", "\n")),
-      "invalid-csv"
-    );
-  });
-});
-
-function assertParseError(input: Uint8Array, code: ExternalCsvParseError["code"]) {
-  assert.throws(
-    () => parseExternalCsv(input, externalCsvTestConfiguration),
-    (error: unknown) => error instanceof ExternalCsvParseError && error.code === code
-  );
-}
diff --git a/tests/external-initial-import-plan.test.ts b/tests/external-initial-import-plan.test.ts
deleted file mode 100644
index 7fc1a43..0000000
--- a/tests/external-initial-import-plan.test.ts
+++ /dev/null
@@ -1,149 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { createExternalInitialImportPlan } from "../src/external-model/application/external-initial-import-plan.js";
-import { buildExternalInitialImportTarget } from "../src/external-model/application/external-initial-import-target.js";
-import { parseExternalCsv } from "../src/external-model/csv/external-csv-transport.js";
-import {
-  externalCsvTestConfiguration,
-  firstIfcGuid,
-  quotedRevitCsv,
-  utf8Bytes,
-} from "./fixtures/revit-csv-fixtures.js";
-
-describe("external initial import plan", () => {
-  it("groups source rooms and exposes exact room and classification suggestions", () => {
-    const configuration = structuredClone(externalCsvTestConfiguration);
-    configuration.familyTypeRules.push({
-      exactFamilyAndType: "Steckdose: Doppelsteckdose",
-      internalDeviceType: "Steckdose",
-      connectionKind: "socket",
-      category: "single_phase",
-      quantityRule: { kind: "mapped-column" },
-      displayNameSuggestion: { kind: "selection-marker" },
-    });
-
-    const plan = createExternalInitialImportPlan({
-      fileName: "revit.csv",
-      bytes: utf8Bytes(quotedRevitCsv, true),
-      configurationVersion: 4,
-      configuration,
-      floors: [{ id: "floor-1", name: "EG", sortOrder: 10 }],
-      rooms: [{
-        id: "room-1",
-        floorId: "floor-1",
-        roomNumber: "01/101",
-        roomName: "Technik Bestand",
-      }],
-      distributionBoards: [{ id: "board-1", name: "UV 1", floorId: "floor-1" }],
-      projectDevices: [{
-        id: "device-1",
-        name: "socket",
-        displayName: "Steckdose",
-        category: "single_phase",
-        connectionKind: "socket",
-        powerPerUnit: 0.12,
-      }],
-    });
-
-    assert.equal(plan.configurationVersion, 4);
-    assert.equal(plan.objectCount, 2);
-    assert.equal(plan.sourceRooms.length, 2);
-    assert.deepEqual(
-      plan.sourceRooms.map((room) => ({
-        number: room.roomNumber,
-        status: room.matchStatus,
-        suggested: room.suggestedRoomId,
-      })),
-      [
-        { number: "01/101", status: "exact-number", suggested: "room-1" },
-        { number: "01/103", status: "new", suggested: null },
-      ]
-    );
-    assert.equal(plan.familyGroups.length, 2);
-    assert.equal(plan.issueCounts.unknownFamilyAndType, 1);
-    assert.equal(plan.issueCounts.invalidPower, 0);
-    assert.equal(plan.issueCounts.invalidQuantity, 0);
-    assert.equal(plan.objects[0].ifcGuid, firstIfcGuid);
-    assert.equal(plan.objects[0].suggestedPlanningValues.effectiveQuantity, 2);
-    assert.equal(plan.existing.distributionBoards[0].id, "board-1");
-    assert.equal(plan.existing.projectDevices[0].id, "device-1");
-  });
-
-  it("builds a stable row-free target only after every family is classified", () => {
-    const configuration = structuredClone(externalCsvTestConfiguration);
-    for (const exactFamilyAndType of [
-      "Steckdose: Doppelsteckdose",
-      "Steckdose: Standard",
-    ]) {
-      configuration.familyTypeRules.push({
-        exactFamilyAndType,
-        internalDeviceType: "Steckdose",
-        connectionKind: "socket",
-        category: "single_phase",
-        quantityRule: exactFamilyAndType.includes("Doppel")
-          ? { kind: "mapped-column" }
-          : { kind: "fixed", quantity: 1 },
-        displayNameSuggestion: { kind: "selection-marker" },
-      });
-    }
-    const bytes = utf8Bytes(quotedRevitCsv, true);
-    const plan = createExternalInitialImportPlan({
-      fileName: "revit.csv",
-      bytes,
-      configurationVersion: 2,
-      configuration,
-      floors: [],
-      rooms: [],
-      distributionBoards: [],
-      projectDevices: [],
-    });
-    let id = 0;
-    const target = buildExternalInitialImportTarget({
-      projectId: "project-1",
-      expectedRevision: 7,
-      sourceName: "Revit-Gesamtmodell",
-      importedAtIso: "2026-08-02T17:00:00.000Z",
-      configurationVersion: 2,
-      configuration,
-      originalContentBase64: Buffer.from(bytes).toString("base64"),
-      document: parseExternalCsv(bytes, configuration),
-      plan,
-      roomDecisions: plan.sourceRooms.map((room) => ({
-        sourceRoomKey: room.sourceRoomKey,
-        roomId: null,
-        defaultDistributionBoardId: null,
-      })),
-      familyProjectDeviceDecisions: plan.familyGroups.map((group) => ({
-        familyAndType: group.familyAndType,
-        projectDeviceId: null,
-      })),
-      createId: () => `generated-${++id}`,
-    });
-
-    assert.equal(target.importBatches[0].appliedProjectRevision, 8);
-    assert.equal(target.importBatches[0].configurationVersion, 2);
-    assert.equal(target.objects.length, 2);
-    assert.ok(target.objects.every((object) => object.circuitDeviceRowId === null));
-    assert.ok(target.objects.every((object) => object.overriddenFields.length === 0));
-    assert.throws(
-      () => buildExternalInitialImportTarget({
-        projectId: "project-1",
-        expectedRevision: 7,
-        sourceName: "Revit-Gesamtmodell",
-        importedAtIso: "2026-08-02T17:00:00.000Z",
-        configurationVersion: 2,
-        configuration,
-        originalContentBase64: Buffer.from(bytes).toString("base64"),
-        document: parseExternalCsv(bytes, configuration),
-        plan,
-        roomDecisions: [],
-        familyProjectDeviceDecisions: plan.familyGroups.map((group) => ({
-          familyAndType: group.familyAndType,
-          projectDeviceId: null,
-        })),
-        createId: () => "unused",
-      }),
-      /Quellraum-Entscheidungen/
-    );
-  });
-});
diff --git a/tests/external-initial-import-project-command.repository.test.ts b/tests/external-initial-import-project-command.repository.test.ts
deleted file mode 100644
index b9acb83..0000000
--- a/tests/external-initial-import-project-command.repository.test.ts
+++ /dev/null
@@ -1,297 +0,0 @@
-import crypto from "node:crypto";
-import path from "node:path";
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { migrate } from "drizzle-orm/better-sqlite3/migrator";
-import { createDatabaseContext } from "../src/db/database-context.js";
-import { ExternalInitialImportProjectCommandRepository } from "../src/db/repositories/external-initial-import-project-command.repository.js";
-import { ExternalModelStateRepository } from "../src/db/repositories/external-model-state.repository.js";
-import { externalCsvConfigurations } from "../src/db/schema/external-csv-configurations.js";
-import { projects } from "../src/db/schema/projects.js";
-import {
-  createEmptyExternalModelState,
-  createExternalInitialImportProjectCommand,
-} from "../src/domain/models/external-initial-import-project-command.model.js";
-import { createExternalCsvPreview } from "../src/external-model/application/external-csv-preview.js";
-import { parseExternalCsv } from "../src/external-model/csv/external-csv-transport.js";
-import type { ExternalModelStateSnapshot } from "../src/external-model/domain/external-model-contracts.js";
-import {
-  createExternalRoomKey,
-  projectInitialExternalObject,
-} from "../src/external-model/domain/external-model-matching.js";
-import {
-  externalCsvTestConfiguration,
-  quotedRevitCsv,
-  utf8Bytes,
-} from "./fixtures/revit-csv-fixtures.js";
-
-function createTestContext() {
-  const context = createDatabaseContext(":memory:");
-  migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
-  context.db.insert(projects).values({ id: "project-1", name: "Projekt" }).run();
-  const configuration = configuredCsv();
-  context.db.insert(externalCsvConfigurations).values({
-    id: "config-1",
-    projectId: "project-1",
-    configurationVersion: 1,
-    configuration,
-  }).run();
-  return { context, configuration };
-}
-
-function configuredCsv() {
-  const configuration = structuredClone(externalCsvTestConfiguration);
-  configuration.familyTypeRules.push(
-    {
-      exactFamilyAndType: "Steckdose: Doppelsteckdose",
-      internalDeviceType: "Steckdose",
-      connectionKind: "socket",
-      category: "single_phase",
-      quantityRule: { kind: "mapped-column" },
-      displayNameSuggestion: { kind: "selection-marker" },
-    },
-    {
-      exactFamilyAndType: "Steckdose: Standard",
-      internalDeviceType: "Steckdose",
-      connectionKind: "socket",
-      category: "single_phase",
-      quantityRule: { kind: "fixed", quantity: 1 },
-      displayNameSuggestion: { kind: "selection-marker" },
-    }
-  );
-  return configuration;
-}
-
-function initialState(
-  configuration: ReturnType<typeof configuredCsv>
-): ExternalModelStateSnapshot {
-  const bytes = utf8Bytes(quotedRevitCsv, true);
-  const preview = createExternalCsvPreview({
-    fileName: "revit.csv",
-    bytes,
-    configuration,
-  });
-  const roomKeys = [...new Set(preview.objects.map((object) =>
-    createExternalRoomKey(object.roomNumber, object.roomName)
-  ).filter((key): key is string => key !== null))];
-  const roomMappings = roomKeys.map((key, index) => {
-    const object = preview.objects.find(
-      (candidate) => createExternalRoomKey(candidate.roomNumber, candidate.roomName) === key
-    )!;
-    return {
-      id: `mapping-${index + 1}`,
-      projectId: "project-1",
-      sourceId: "source-1",
-      normalizedSourceRoomKey: key,
-      sourceFloorName: null,
-      sourceRoomNumber: object.roomNumber,
-      sourceRoomName: object.roomName,
-      roomId: null,
-      defaultDistributionBoardId: null,
-    };
-  });
-  const mappingByKey = new Map(
-    roomMappings.map((mapping) => [mapping.normalizedSourceRoomKey, mapping.id])
-  );
-  return {
-    source: {
-      id: "source-1",
-      projectId: "project-1",
-      name: "Revit-Gesamtmodell",
-      sourceType: "revit_csv",
-    },
-    importBatches: [{
-      id: "batch-1",
-      projectId: "project-1",
-      sourceId: "source-1",
-      importKind: "initial",
-      importedAtIso: "2026-08-02T16:00:00.000Z",
-      fileName: "revit.csv",
-      sha256: crypto.createHash("sha256").update(bytes).digest("hex"),
-      appliedProjectRevision: 1,
-      configurationVersion: 1,
-      configurationSnapshot: configuration,
-      originalContentBase64: Buffer.from(bytes).toString("base64"),
-      document: parseExternalCsv(bytes, configuration),
-    }],
-    roomMappings,
-    objects: preview.objects.map((candidate, index) => {
-      const projected = projectInitialExternalObject(candidate, configuration);
-      const roomKey = createExternalRoomKey(candidate.roomNumber, candidate.roomName);
-      return {
-        id: `object-${index + 1}`,
-        projectId: "project-1",
-        sourceId: "source-1",
-        ifcGuid: projected.ifcGuid,
-        lastSeenImportBatchId: "batch-1",
-        lastAcceptedImportBatchId: "batch-1",
-        acceptedSourceValues: projected.sourceValues,
-        planningValues: projected.planningValues,
-        overriddenFields: [],
-        externalRoomMappingId: roomKey === null ? null : mappingByKey.get(roomKey)!,
-        distributionBoardId: null,
-        linkedProjectDeviceId: null,
-        circuitDeviceRowId: null,
-        presenceStatus: "present",
-      };
-    }),
-  };
-}
-
-describe("external initial import project command", () => {
-  it("commits the complete import and supports persisted undo and redo", () => {
-    const { context, configuration } = createTestContext();
-    try {
-      const target = initialState(configuration);
-      const repository = new ExternalInitialImportProjectCommandRepository(context.db);
-      const inserted = repository.execute({
-        projectId: "project-1",
-        expectedRevision: 0,
-        source: "user",
-        description: "Revit-Erstimport übernehmen",
-        command: createExternalInitialImportProjectCommand(
-          createEmptyExternalModelState(),
-          target
-        ),
-      });
-      assert.equal(inserted.revision.revisionNumber, 1);
-      assert.equal(
-        new ExternalModelStateRepository(context.db).getByProject("project-1")
-          .state.objects.length,
-        2
-      );
-      assert.ok(
-        new ExternalModelStateRepository(context.db).getByProject("project-1")
-          .state.objects.every((object) => object.circuitDeviceRowId === null)
-      );
-
-      const undone = repository.execute({
-        projectId: "project-1",
-        expectedRevision: 1,
-        source: "undo",
-        historyTargetChangeSetId: inserted.revision.changeSetId,
-        command: inserted.inverse,
-      });
-      assert.equal(undone.revision.revisionNumber, 2);
-      assert.equal(
-        new ExternalModelStateRepository(context.db).getByProject("project-1")
-          .state.source,
-        null
-      );
-
-      repository.execute({
-        projectId: "project-1",
-        expectedRevision: 2,
-        source: "redo",
-        historyTargetChangeSetId: inserted.revision.changeSetId,
-        command: undone.inverse,
-      });
-      const redone = new ExternalModelStateRepository(context.db)
-        .getByProject("project-1").state;
-      assert.deepEqual(redone.objects.map((object) => object.id), ["object-1", "object-2"]);
-      assert.equal(redone.importBatches[0].configurationVersion, 1);
-    } finally {
-      context.close();
-    }
-  });
-
-  it("rejects a target state with zero classified objects before writing anything", () => {
-    // assertPopulatedInitialState requires at least one object, so a CSV
-    // that classified none must be rejected at command construction, not
-    // reach the persistence layer's bulk insert.
-    const { context, configuration } = createTestContext();
-    try {
-      const target: ExternalModelStateSnapshot = {
-        ...initialState(configuration),
-        roomMappings: [],
-        objects: [],
-      };
-      assert.throws(
-        () =>
-          createExternalInitialImportProjectCommand(
-            createEmptyExternalModelState(),
-            target
-          ),
-        /at least one object/
-      );
-    } finally {
-      context.close();
-    }
-  });
-
-  it("rejects changed state, checksum drift and row assignment", () => {
-    const { context, configuration } = createTestContext();
-    try {
-      const target = initialState(configuration);
-      const repository = new ExternalInitialImportProjectCommandRepository(context.db);
-      const assigned = structuredClone(target);
-      assigned.objects[0].circuitDeviceRowId = "row-1";
-      assert.throws(
-        () => createExternalInitialImportProjectCommand(
-          createEmptyExternalModelState(),
-          assigned
-        ),
-        /must not assign circuit device rows/
-      );
-
-      const invalidHash = structuredClone(target);
-      invalidHash.importBatches[0].sha256 = "b".repeat(64);
-      assert.throws(
-        () => repository.execute({
-          projectId: "project-1",
-          expectedRevision: 0,
-          source: "user",
-          command: createExternalInitialImportProjectCommand(
-            createEmptyExternalModelState(),
-            invalidHash
-          ),
-        }),
-        /checksum is invalid/
-      );
-      assert.equal(
-        new ExternalModelStateRepository(context.db).getByProject("project-1")
-          .state.source,
-        null
-      );
-    } finally {
-      context.close();
-    }
-  });
-
-  it("rolls back all external rows when late history persistence fails", () => {
-    const { context, configuration } = createTestContext();
-    try {
-      context.sqlite.exec(`
-        CREATE TRIGGER fail_external_import_history
-        BEFORE INSERT ON project_change_sets
-        BEGIN
-          SELECT RAISE(ABORT, 'late history failure');
-        END;
-      `);
-      const repository = new ExternalInitialImportProjectCommandRepository(context.db);
-      assert.throws(
-        () => repository.execute({
-          projectId: "project-1",
-          expectedRevision: 0,
-          source: "user",
-          command: createExternalInitialImportProjectCommand(
-            createEmptyExternalModelState(),
-            initialState(configuration)
-          ),
-        }),
-        /late history failure/
-      );
-      assert.equal(
-        new ExternalModelStateRepository(context.db).getByProject("project-1")
-          .state.source,
-        null
-      );
-      assert.equal(
-        context.db.select({ revision: projects.currentRevision }).from(projects).get()?.revision,
-        0
-      );
-    } finally {
-      context.close();
-    }
-  });
-});
diff --git a/tests/external-model-configuration.test.ts b/tests/external-model-configuration.test.ts
new file mode 100644
index 0000000..7c1066a
--- /dev/null
+++ b/tests/external-model-configuration.test.ts
@@ -0,0 +1,132 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { eq } from "drizzle-orm";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext, type DatabaseContext } from "../src/db/database-context.js";
+import { ExternalModelConfigurationProjectCommandRepository } from "../src/db/repositories/external-model-configuration-project-command.repository.js";
+import { ExternalModelConfigurationRepository } from "../src/db/repositories/external-model-configuration.repository.js";
+import { ProjectTransferRepository } from "../src/db/repositories/project-transfer.repository.js";
+import { externalModelConfigurations } from "../src/db/schema/external-model-configurations.js";
+import { projects } from "../src/db/schema/projects.js";
+import { createExternalModelConfigurationUpdateProjectCommand } from "../src/domain/models/external-model-configuration-project-command.model.js";
+import {
+  assertExternalModelConfiguration,
+  createDefaultExternalModelConfiguration,
+} from "../src/external-model/configuration/external-model-configuration.js";
+
+const deviceTypeId = "10000000-0000-4000-8000-000000000001";
+const ruleId = "20000000-0000-4000-8000-000000000001";
+
+function configuration() {
+  const value = createDefaultExternalModelConfiguration();
+  value.deviceTypes.push({
+    id: deviceTypeId,
+    name: "Steckdose",
+    category: "single_phase",
+    defaults: { powerPerUnitW: 200, simultaneityFactor: null, cosPhi: 0.95, costGroup: "440" },
+  });
+  value.familyTypeRules.push({
+    id: ruleId,
+    exactFamilyAndType: "Steckdose: Standard",
+    deviceTypeId,
+    quantityRule: "socketCount",
+  });
+  return value;
+}
+
+function snapshot(projectId = "project-1") {
+  return { id: "config-1", projectId, configuration: configuration() };
+}
+
+function createTestDatabase(): DatabaseContext {
+  const context = createDatabaseContext(":memory:");
+  migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+  context.db.insert(projects).values({ id: "project-1", name: "Projekt" }).run();
+  return context;
+}
+
+describe("external model configuration", () => {
+  it("validates the single Worksharing-ID mapping and exact family rules", () => {
+    const value = configuration();
+    assert.doesNotThrow(() => assertExternalModelConfiguration(value));
+    assert.equal("idColumn" in value.layout, false);
+
+    const duplicate = structuredClone(value);
+    duplicate.columns.ifcGuid = duplicate.columns.worksharingId;
+    assert.throws(() => assertExternalModelConfiguration(duplicate), /nicht eindeutig/);
+
+    const unknownType = structuredClone(value);
+    unknownType.familyTypeRules[0]!.deviceTypeId = "30000000-0000-4000-8000-000000000001";
+    assert.throws(() => assertExternalModelConfiguration(unknownType), /unbekannte Ger.*teart/);
+  });
+
+  it("persists changes without an independent configuration revision", () => {
+    const context = createTestDatabase();
+    try {
+      const repository = new ExternalModelConfigurationProjectCommandRepository(context.db);
+      const initial = snapshot();
+      const inserted = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createExternalModelConfigurationUpdateProjectCommand(null, initial),
+      });
+      assert.equal(inserted.revision.revisionNumber, 1);
+      assert.equal("configurationVersion" in initial, false);
+
+      const target = structuredClone(initial);
+      target.configuration.deviceTypes[0]!.name = "Steckdose allgemein";
+      const updated = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 1,
+        source: "user",
+        command: createExternalModelConfigurationUpdateProjectCommand(initial, target),
+      });
+      assert.equal(updated.revision.revisionNumber, 2);
+      assert.deepEqual(updated.inverse.payload, { expected: target, target: initial });
+      assert.throws(
+        () => repository.execute({
+          projectId: "project-1",
+          expectedRevision: 2,
+          source: "user",
+          command: createExternalModelConfigurationUpdateProjectCommand(initial, target),
+        }),
+        /zwischenzeitlich ge.*ndert/
+      );
+    } finally {
+      context.close();
+    }
+  });
+
+  it("distinguishes missing projects and remaps configuration identities on duplicate", () => {
+    const context = createTestDatabase();
+    try {
+      const reader = new ExternalModelConfigurationRepository(context.db);
+      assert.deepEqual(reader.getByProject("project-1"), { projectExists: true, configuration: null });
+      assert.deepEqual(reader.getByProject("missing"), { projectExists: false, configuration: null });
+
+      new ExternalModelConfigurationProjectCommandRepository(context.db).execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createExternalModelConfigurationUpdateProjectCommand(null, snapshot()),
+      });
+      const transferRepository = new ProjectTransferRepository(context.db);
+      const transfer = transferRepository.exportProject("project-1");
+      assert.ok(transfer);
+      const duplicate = transferRepository.importDuplicate(transfer);
+      const copied = context.db.select().from(externalModelConfigurations)
+        .where(eq(externalModelConfigurations.projectId, duplicate.projectId)).get();
+      assert.ok(copied);
+      assert.notEqual(copied.id, "config-1");
+      assert.notEqual(copied.configuration.deviceTypes[0]!.id, deviceTypeId);
+      assert.equal(
+        copied.configuration.familyTypeRules[0]!.deviceTypeId,
+        copied.configuration.deviceTypes[0]!.id
+      );
+    } finally {
+      context.close();
+    }
+  });
+});
diff --git a/tests/external-model-foundation.test.ts b/tests/external-model-foundation.test.ts
deleted file mode 100644
index 08319ec..0000000
--- a/tests/external-model-foundation.test.ts
+++ /dev/null
@@ -1,431 +0,0 @@
-import path from "node:path";
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { migrate } from "drizzle-orm/better-sqlite3/migrator";
-import { createDatabaseContext } from "../src/db/database-context.js";
-import { ExternalModelStateRepository } from "../src/db/repositories/external-model-state.repository.js";
-import { ProjectStateRestoreCommandRepository } from "../src/db/repositories/project-state-restore-command.repository.js";
-import { readProjectStateSnapshot } from "../src/db/repositories/project-state-snapshot.persistence.js";
-import { ProjectTransferRepository } from "../src/db/repositories/project-transfer.repository.js";
-import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
-import { circuitLists } from "../src/db/schema/circuit-lists.js";
-import { circuitSections } from "../src/db/schema/circuit-sections.js";
-import { circuits } from "../src/db/schema/circuits.js";
-import { distributionBoards } from "../src/db/schema/distribution-boards.js";
-import { externalImportBatches } from "../src/db/schema/external-import-batches.js";
-import { externalModelObjects } from "../src/db/schema/external-model-objects.js";
-import { externalModelSources } from "../src/db/schema/external-model-sources.js";
-import { externalRoomMappings } from "../src/db/schema/external-room-mappings.js";
-import { floors } from "../src/db/schema/floors.js";
-import { projectDevices } from "../src/db/schema/project-devices.js";
-import { projects } from "../src/db/schema/projects.js";
-import { rooms } from "../src/db/schema/rooms.js";
-import { createProjectStateRestoreCommand } from "../src/domain/models/project-state-restore-command.model.js";
-import { projectStateSnapshotSchemaVersion } from "../src/domain/models/project-state-snapshot.model.js";
-import { createExternalCsvPreview } from "../src/external-model/application/external-csv-preview.js";
-import { parseExternalCsv } from "../src/external-model/csv/external-csv-transport.js";
-import {
-  createExternalRoomKey,
-  indexExternalObjectsByIfcGuid,
-  projectInitialExternalObject,
-} from "../src/external-model/domain/external-model-matching.js";
-import {
-  externalCsvTestConfiguration,
-  firstIfcGuid,
-  quotedRevitCsv,
-  utf8Bytes,
-} from "./fixtures/revit-csv-fixtures.js";
-
-function configuredCsv() {
-  const configuration = structuredClone(externalCsvTestConfiguration);
-  configuration.familyTypeRules.push({
-    exactFamilyAndType: "Steckdose: Doppelsteckdose",
-    internalDeviceType: "Steckdose",
-    connectionKind: "socket",
-    category: "single_phase",
-    quantityRule: { kind: "mapped-column" },
-    displayNameSuggestion: { kind: "selection-marker" },
-  });
-  return configuration;
-}
-
-describe("external model matching", () => {
-  it("normalizes source rooms and rejects duplicate IFC identities", () => {
-    assert.equal(createExternalRoomKey(" 01/101 ", "Technik"), "number:01/101");
-    assert.equal(createExternalRoomKey("", " Büro  Nord "), "name:BÜRO  NORD");
-    assert.equal(createExternalRoomKey(" ", " "), null);
-    assert.throws(
-      () => indexExternalObjectsByIfcGuid([{ ifcGuid: firstIfcGuid }, { ifcGuid: firstIfcGuid }]),
-      /Duplicate IfcGUID/
-    );
-  });
-
-  it("derives initial planning values from an exact family rule", () => {
-    const configuration = configuredCsv();
-    const preview = createExternalCsvPreview({
-      fileName: "revit.csv",
-      bytes: utf8Bytes(quotedRevitCsv, true),
-      configuration,
-    });
-    const projected = projectInitialExternalObject(preview.objects[0], configuration);
-
-    assert.deepEqual(projected.issues, []);
-    assert.equal(projected.ifcGuid, firstIfcGuid);
-    assert.equal(projected.planningValues.displayName, "Arbeitsplatz");
-    assert.equal(projected.planningValues.category, "single_phase");
-    assert.equal(projected.planningValues.effectiveQuantity, 2);
-    assert.equal(projected.planningValues.powerPerUnitW, 120.5);
-  });
-
-  it("keeps unclassified or invalid values visible as issues", () => {
-    const projected = projectInitialExternalObject(
-      {
-        rowNumber: 4,
-        ifcGuid: firstIfcGuid,
-        roomNumber: "",
-        roomName: "",
-        familyAndType: "Unbekannt",
-        selectionMarker: "",
-        circuitIdentifier: "",
-        power: "12,3,4",
-        quantity: "0",
-        additionalSourceValues: {},
-      },
-      externalCsvTestConfiguration
-    );
-
-    assert.deepEqual(projected.issues, [
-      "unknown-family-and-type",
-      "missing-room",
-      "invalid-power",
-    ]);
-    assert.equal(projected.planningValues.powerPerUnitW, null);
-  });
-});
-
-describe("external model state repository", () => {
-  it("reads a deterministic complete external state without changing project data", () => {
-    const context = createDatabaseContext(":memory:");
-    migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
-    try {
-      context.db.insert(projects).values({ id: "project-1", name: "Projekt" }).run();
-      context.db.insert(externalModelSources).values({
-        id: "source-1",
-        projectId: "project-1",
-        name: "Revit-Gesamtmodell",
-        sourceType: "revit_csv",
-      }).run();
-      const configuration = configuredCsv();
-      const bytes = utf8Bytes(quotedRevitCsv, true);
-      const document = parseExternalCsv(bytes, configuration);
-      context.db.insert(externalImportBatches).values({
-        id: "batch-1",
-        projectId: "project-1",
-        sourceId: "source-1",
-        importKind: "initial",
-        importedAtIso: "2026-08-02T15:30:00.000Z",
-        fileName: "revit.csv",
-        sha256: "hash",
-        appliedProjectRevision: 1,
-        configurationVersion: 1,
-        configurationSnapshot: configuration,
-        originalBytes: Buffer.from(bytes),
-        document,
-      }).run();
-      context.db.insert(externalRoomMappings).values({
-        id: "mapping-1",
-        projectId: "project-1",
-        sourceId: "source-1",
-        normalizedSourceRoomKey: "number:01/101",
-        sourceFloorName: null,
-        sourceRoomNumber: "01/101",
-        sourceRoomName: "Technik",
-        roomId: null,
-        defaultDistributionBoardId: null,
-      }).run();
-      const preview = createExternalCsvPreview({
-        fileName: "revit.csv",
-        bytes,
-        configuration,
-      });
-      const projected = projectInitialExternalObject(preview.objects[0], configuration);
-      context.db.insert(externalModelObjects).values({
-        id: "object-1",
-        projectId: "project-1",
-        sourceId: "source-1",
-        ifcGuid: projected.ifcGuid,
-        lastSeenImportBatchId: "batch-1",
-        lastAcceptedImportBatchId: "batch-1",
-        acceptedSourceValues: projected.sourceValues,
-        planningValues: projected.planningValues,
-        overriddenFields: [],
-        externalRoomMappingId: "mapping-1",
-        distributionBoardId: null,
-        linkedProjectDeviceId: null,
-        circuitDeviceRowId: null,
-        presenceStatus: "present",
-      }).run();
-
-      const result = new ExternalModelStateRepository(context.db).getByProject("project-1");
-      assert.equal(result.projectExists, true);
-      assert.equal(result.state.source?.id, "source-1");
-      assert.equal(result.state.importBatches[0].originalContentBase64, Buffer.from(bytes).toString("base64"));
-      assert.equal(result.state.roomMappings[0].normalizedSourceRoomKey, "number:01/101");
-      assert.equal(result.state.objects[0].ifcGuid, firstIfcGuid);
-      assert.equal(result.state.objects[0].circuitDeviceRowId, null);
-      assert.equal(result.state.objects[0].planningValues.effectiveQuantity, 2);
-
-      assert.throws(
-        () => context.db.insert(externalModelObjects).values({
-          ...context.db.select().from(externalModelObjects).get()!,
-          id: "object-2",
-        }).run(),
-        /UNIQUE constraint failed/
-      );
-    } finally {
-      context.close();
-    }
-  });
-
-  it("distinguishes an empty project from an unknown project", () => {
-    const context = createDatabaseContext(":memory:");
-    migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
-    try {
-      context.db.insert(projects).values({ id: "project-1", name: "Projekt" }).run();
-      const repository = new ExternalModelStateRepository(context.db);
-      assert.deepEqual(repository.getByProject("project-1"), {
-        projectExists: true,
-        state: { source: null, importBatches: [], roomMappings: [], objects: [] },
-      });
-      assert.equal(repository.getByProject("missing").projectExists, false);
-    } finally {
-      context.close();
-    }
-  });
-});
-
-describe("external model snapshot and transfer", () => {
-  it("captures, restores and undoes the complete external state", () => {
-    const context = createDatabaseContext(":memory:");
-    migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
-    try {
-      insertLinkedExternalFixture(context.db);
-      const populated = readProjectStateSnapshot(context.db, "project-1");
-      assert.ok(populated);
-      assert.equal(populated.state.schemaVersion, projectStateSnapshotSchemaVersion);
-      assert.equal(populated.state.externalModel.objects[0].circuitDeviceRowId, "row-1");
-
-      context.db.delete(externalModelSources).run();
-      const empty = readProjectStateSnapshot(context.db, "project-1");
-      assert.ok(empty);
-      assert.equal(empty.state.externalModel.source, null);
-
-      const repository = new ProjectStateRestoreCommandRepository(context.db);
-      const restored = repository.execute({
-        projectId: "project-1",
-        expectedRevision: 0,
-        source: "user",
-        command: createProjectStateRestoreCommand(
-          empty.payloadSha256,
-          populated.state
-        ),
-      });
-      assert.equal(
-        new ExternalModelStateRepository(context.db).getByProject("project-1")
-          .state.objects[0].linkedProjectDeviceId,
-        "device-1"
-      );
-
-      repository.execute({
-        projectId: "project-1",
-        expectedRevision: 1,
-        source: "undo",
-        historyTargetChangeSetId: restored.revision.changeSetId,
-        command: restored.inverse,
-      });
-      assert.equal(
-        new ExternalModelStateRepository(context.db).getByProject("project-1")
-          .state.source,
-        null
-      );
-    } finally {
-      context.close();
-    }
-  });
-
-  it("remaps every internal external-model link for a project duplicate", () => {
-    const context = createDatabaseContext(":memory:");
-    migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
-    try {
-      insertLinkedExternalFixture(context.db);
-      const transferRepository = new ProjectTransferRepository(context.db);
-      const transfer = transferRepository.exportProject("project-1");
-      assert.ok(transfer);
-      const duplicate = transferRepository.importDuplicate(transfer);
-      const copied = new ExternalModelStateRepository(context.db)
-        .getByProject(duplicate.projectId).state;
-
-      assert.notEqual(copied.source?.id, "source-1");
-      assert.notEqual(copied.importBatches[0].id, "batch-1");
-      assert.notEqual(copied.roomMappings[0].id, "mapping-1");
-      assert.notEqual(copied.objects[0].id, "object-1");
-      assert.equal(copied.objects[0].ifcGuid, firstIfcGuid);
-      assert.equal(copied.objects[0].lastSeenImportBatchId, copied.importBatches[0].id);
-      assert.equal(copied.objects[0].externalRoomMappingId, copied.roomMappings[0].id);
-      assert.notEqual(copied.objects[0].distributionBoardId, "board-1");
-      assert.notEqual(copied.objects[0].linkedProjectDeviceId, "device-1");
-      assert.notEqual(copied.objects[0].circuitDeviceRowId, "row-1");
-      assert.equal(
-        copied.importBatches[0].originalContentBase64,
-        Buffer.from(utf8Bytes(quotedRevitCsv, true)).toString("base64")
-      );
-    } finally {
-      context.close();
-    }
-  });
-});
-
-function insertLinkedExternalFixture(database: ReturnType<typeof createDatabaseContext>["db"]) {
-  database.insert(projects).values({ id: "project-1", name: "Projekt" }).run();
-  database.insert(floors).values({
-    id: "floor-1",
-    projectId: "project-1",
-    name: "EG",
-    sortOrder: 10,
-  }).run();
-  database.insert(rooms).values({
-    id: "room-1",
-    projectId: "project-1",
-    floorId: "floor-1",
-    roomNumber: "01/101",
-    roomName: "Technik",
-  }).run();
-  database.insert(projectDevices).values({
-    id: "device-1",
-    projectId: "project-1",
-    name: "socket",
-    displayName: "Steckdose",
-    phaseType: "single_phase",
-    connectionKind: "socket",
-    costGroup: null,
-    category: "single_phase",
-    quantity: 1,
-    powerPerUnit: 0.12,
-    simultaneityFactor: 1,
-    cosPhi: null,
-    remark: null,
-    voltageV: 230,
-  }).run();
-  database.insert(distributionBoards).values({
-    id: "board-1",
-    projectId: "project-1",
-    name: "UV 1",
-    floorId: "floor-1",
-    supplyType: "AV",
-    simultaneityFactor: 1,
-  }).run();
-  database.insert(circuitLists).values({
-    id: "list-1",
-    projectId: "project-1",
-    distributionBoardId: "board-1",
-    name: "UV 1 Stromkreisliste",
-  }).run();
-  database.insert(circuitSections).values({
-    id: "section-1",
-    circuitListId: "list-1",
-    key: "single_phase",
-    displayName: "1-phasig 1",
-    prefix: "-2F1.",
-    sortOrder: 10,
-    category: "single_phase",
-    groupNumber: 1,
-  }).run();
-  database.insert(circuits).values({
-    id: "circuit-1",
-    circuitListId: "list-1",
-    sectionId: "section-1",
-    equipmentIdentifier: "-2F1.1",
-    displayName: "Steckdosen",
-    sortOrder: 10,
-    voltage: 230,
-    isReserve: 0,
-  }).run();
-  database.insert(circuitDeviceRows).values({
-    id: "row-1",
-    circuitId: "circuit-1",
-    linkedProjectDeviceId: "device-1",
-    sortOrder: 10,
-    name: "socket",
-    displayName: "Steckdose",
-    phaseType: "single_phase",
-    connectionKind: "socket",
-    costGroup: null,
-    category: "single_phase",
-    level: null,
-    roomId: "room-1",
-    roomNumberSnapshot: "01/101",
-    roomNameSnapshot: "Technik",
-    quantity: 2,
-    powerPerUnit: 0.12,
-    simultaneityFactor: 1,
-    cosPhi: null,
-    remark: null,
-    overriddenFields: null,
-  }).run();
-
-  database.insert(externalModelSources).values({
-    id: "source-1",
-    projectId: "project-1",
-    name: "Revit-Gesamtmodell",
-    sourceType: "revit_csv",
-  }).run();
-  const configuration = configuredCsv();
-  const bytes = utf8Bytes(quotedRevitCsv, true);
-  database.insert(externalImportBatches).values({
-    id: "batch-1",
-    projectId: "project-1",
-    sourceId: "source-1",
-    importKind: "initial",
-    importedAtIso: "2026-08-02T15:30:00.000Z",
-    fileName: "revit.csv",
-    sha256: "a".repeat(64),
-    appliedProjectRevision: 0,
-    configurationVersion: 1,
-    configurationSnapshot: configuration,
-    originalBytes: Buffer.from(bytes),
-    document: parseExternalCsv(bytes, configuration),
-  }).run();
-  database.insert(externalRoomMappings).values({
-    id: "mapping-1",
-    projectId: "project-1",
-    sourceId: "source-1",
-    normalizedSourceRoomKey: "number:01/101",
-    sourceFloorName: "EG",
-    sourceRoomNumber: "01/101",
-    sourceRoomName: "Technik",
-    roomId: "room-1",
-    defaultDistributionBoardId: "board-1",
-  }).run();
-  const preview = createExternalCsvPreview({
-    fileName: "revit.csv",
-    bytes,
-    configuration,
-  });
-  const projected = projectInitialExternalObject(preview.objects[0], configuration);
-  database.insert(externalModelObjects).values({
-    id: "object-1",
-    projectId: "project-1",
-    sourceId: "source-1",
-    ifcGuid: projected.ifcGuid,
-    lastSeenImportBatchId: "batch-1",
-    lastAcceptedImportBatchId: "batch-1",
-    acceptedSourceValues: projected.sourceValues,
-    planningValues: projected.planningValues,
-    overriddenFields: [],
-    externalRoomMappingId: "mapping-1",
-    distributionBoardId: "board-1",
-    linkedProjectDeviceId: "device-1",
-    circuitDeviceRowId: "row-1",
-    presenceStatus: "present",
-  }).run();
-}
diff --git a/tests/external-model-xlsx-foundation.test.ts b/tests/external-model-xlsx-foundation.test.ts
new file mode 100644
index 0000000..a4836ac
--- /dev/null
+++ b/tests/external-model-xlsx-foundation.test.ts
@@ -0,0 +1,87 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { parseExternalModelStateSnapshot } from "../src/domain/models/project-state-snapshot.model.js";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
+
+const lowerId = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee-ffffffff";
+const upperId = "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE-FFFFFFFF";
+
+function fullBatch(id: string, importedAtIso: string) {
+  return {
+    id,
+    projectId: "p",
+    sourceId: "s",
+    importKind: "follow_up" as const,
+    importedAtIso,
+    fileName: `${id}.xlsx`,
+    sha256: "a".repeat(64),
+    objectCount: 1,
+    appliedProjectRevision: 3,
+    configurationSnapshot: createDefaultExternalModelConfiguration(),
+    originalContentBase64: "AA==",
+    document: {
+      sheetName: "Bauteilliste",
+      headerRowNumber: 1,
+      firstDataRowNumber: 3,
+      firstDataColumnNumber: 1,
+      columns: [],
+      rows: [],
+      issues: [],
+    },
+  };
+}
+
+describe("Linear XLSX external model foundation", () => {
+  it("keeps only the newest batch complete", () => {
+    const newest = fullBatch("new", "2026-02-01T00:00:00.000Z");
+    const older = {
+      ...fullBatch("old", "2026-01-01T00:00:00.000Z"),
+      appliedProjectRevision: null,
+      configurationSnapshot: null,
+      originalContentBase64: null,
+      document: null,
+    };
+    assert.doesNotThrow(() => parseExternalModelStateSnapshot({
+      source: { id: "s", projectId: "p", name: "Revit", sourceType: "revit_xlsx" },
+      importBatches: [older, newest],
+      roomMappings: [],
+      objects: [],
+    }));
+    assert.throws(() => parseExternalModelStateSnapshot({
+      source: { id: "s", projectId: "p", name: "Revit", sourceType: "revit_xlsx" },
+      importBatches: [newest, fullBatch("newer", "2026-03-01T00:00:00.000Z")],
+      roomMappings: [],
+      objects: [],
+    }), /Nur der letzte Importbatch/);
+  });
+
+  it("compares Worksharing-IDs exactly and allows duplicate IfcGUID values", () => {
+    const context = createDatabaseContext(":memory:");
+    try {
+      migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+      context.sqlite.exec(`
+        INSERT INTO projects (id, name) VALUES ('p', 'Projekt');
+        INSERT INTO external_model_sources (id, project_id, name) VALUES ('s', 'p', 'Revit');
+        INSERT INTO external_import_batches
+          (id, project_id, source_id, import_kind, imported_at_iso, file_name, sha256, object_count)
+          VALUES ('b', 'p', 's', 'initial', '2026-01-01T00:00:00.000Z', 'model.xlsx', '${"a".repeat(64)}', 2);
+      `);
+      const insert = context.sqlite.prepare(`
+        INSERT INTO external_model_objects
+          (id, project_id, source_id, worksharing_id, ifc_guid, device_type_id,
+           last_seen_import_batch_id, last_accepted_import_batch_id,
+           accepted_source_values, planning_values, overridden_fields)
+        VALUES (?, 'p', 's', ?, 'same-IfcGUID', 'type', 'b', 'b', '{}', '{}', '[]')
+      `);
+      insert.run("o1", lowerId);
+      insert.run("o2", upperId);
+      assert.equal(context.sqlite.prepare("SELECT count(*) AS count FROM external_model_objects").get()!.count, 2);
+      assert.throws(() => insert.run("o3", lowerId), /UNIQUE constraint failed/);
+    } finally {
+      context.close();
+    }
+  });
+});
diff --git a/tests/external-object-row-assignment-project-command.repository.test.ts b/tests/external-object-row-assignment-project-command.repository.test.ts
index 35579eb..4512e90 100644
--- a/tests/external-object-row-assignment-project-command.repository.test.ts
+++ b/tests/external-object-row-assignment-project-command.repository.test.ts
@@ -31,7 +31,6 @@ import {
   externalObjectAssignToNewCircuitCommandType,
 } from "../src/domain/models/external-object-new-circuit-project-command.model.js";
 import type { ExternalModelObjectSnapshot } from "../src/external-model/domain/external-model-contracts.js";
-import { externalCsvTestConfiguration } from "./fixtures/revit-csv-fixtures.js";
 
 function createFixture(initialObjectRowId: string | null = "row-1") {
   const context = createDatabaseContext(":memory:");
@@ -63,20 +62,16 @@ function createFixture(initialObjectRowId: string | null = "row-1") {
       simultaneityFactor: 1,
     }).run();
   }
-  database.insert(externalModelSources).values({ id: "source-1", projectId: "project-1", name: "Revit", sourceType: "revit_csv" }).run();
+  database.insert(externalModelSources).values({ id: "source-1", projectId: "project-1", name: "Revit", sourceType: "revit_xlsx" }).run();
   database.insert(externalImportBatches).values({
     id: "batch-1",
     projectId: "project-1",
     sourceId: "source-1",
     importKind: "initial",
     importedAtIso: "2026-08-02T16:00:00.000Z",
-    fileName: "revit.csv",
+    fileName: "revit.xlsx",
     sha256: "a".repeat(64),
-    appliedProjectRevision: 0,
-    configurationVersion: 1,
-    configurationSnapshot: externalCsvTestConfiguration,
-    originalBytes: Buffer.from("test"),
-    document: { delimiter: ";", encoding: "utf-8", headers: [], rows: [] },
+    objectCount: 1,
   }).run();
   database.insert(externalRoomMappings).values({
     id: "mapping-1",
@@ -98,7 +93,9 @@ function objectSnapshot(circuitDeviceRowId: string | null): ExternalModelObjectS
     id: "object-1",
     projectId: "project-1",
     sourceId: "source-1",
+    worksharingId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee-ffffffff",
     ifcGuid: "ifc-1",
+    deviceTypeId: "device-type-1",
     lastSeenImportBatchId: "batch-1",
     lastAcceptedImportBatchId: "batch-1",
     acceptedSourceValues: {
@@ -107,14 +104,18 @@ function objectSnapshot(circuitDeviceRowId: string | null): ExternalModelObjectS
       roomName: "Büro",
       familyAndType: "Steckdose: Standard",
       selectionMarker: "Steckdose",
+      socketCount: "2",
+      sourceRemark: null,
+      circuitCombined: "-2F1.1",
+      boardName: "UV 1",
       circuitIdentifier: "-2F1.1",
-      power: "120",
-      quantity: "2",
-      additionalSourceValues: {},
+      designation: null,
+      electricalPowerW: "120",
+      voltageV: 230,
+      currentA: null,
     },
     planningValues: {
       displayName: "Steckdose",
-      internalDeviceType: "socket",
       category: "single_phase",
       connectionKind: "socket",
       effectiveQuantity: 2,
diff --git a/tests/linear-xlsx-external-model-migration.test.ts b/tests/linear-xlsx-external-model-migration.test.ts
new file mode 100644
index 0000000..6bfc8bf
--- /dev/null
+++ b/tests/linear-xlsx-external-model-migration.test.ts
@@ -0,0 +1,115 @@
+import assert from "node:assert/strict";
+import { copyFileSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { it } from "node:test";
+import { spawnSync } from "node:child_process";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+
+it("replaces legacy CSV state and resets linked row quantities to their manual share", () => {
+  const source = path.resolve("src", "db", "migrations");
+  const staging = mkdtempSync(path.join(tmpdir(), "leistungsbilanz-linear-xlsx-migration-"));
+  const journal = JSON.parse(readFileSync(path.join(source, "meta", "_journal.json"), "utf8"));
+  journal.entries = journal.entries.filter((entry: { idx: number }) => entry.idx <= 13);
+  mkdirSync(path.join(staging, "meta"));
+  writeFileSync(path.join(staging, "meta", "_journal.json"), JSON.stringify(journal));
+  for (const entry of journal.entries) {
+    copyFileSync(path.join(source, `${entry.tag}.sql`), path.join(staging, `${entry.tag}.sql`));
+  }
+
+  const context = createDatabaseContext(":memory:");
+  try {
+    migrate(context.db, { migrationsFolder: staging });
+    context.sqlite.exec(`
+      INSERT INTO projects (id, name) VALUES ('p', 'Projekt');
+      INSERT INTO distribution_boards (id, project_id, name) VALUES ('b', 'p', 'UV');
+      INSERT INTO circuit_lists (id, project_id, distribution_board_id, name) VALUES ('l', 'p', 'b', 'Liste');
+      INSERT INTO circuit_sections (id, circuit_list_id, key, display_name, prefix) VALUES ('s', 'l', 'single_phase', 'Einphasig', '-2F1.');
+      INSERT INTO circuits (id, circuit_list_id, section_id, equipment_identifier) VALUES ('c', 'l', 's', '-2F1.1');
+      INSERT INTO circuit_device_rows
+        (id, circuit_id, name, display_name, quantity, manual_quantity, power_per_unit, simultaneity_factor)
+        VALUES ('r', 'c', 'Steckdose', 'Steckdose', 5, 2, 0.2, 1);
+      INSERT INTO external_csv_configurations
+        (id, project_id, configuration_version, configuration)
+        VALUES ('cfg', 'p', 3, '{}');
+      INSERT INTO external_model_sources (id, project_id, name, source_type)
+        VALUES ('src', 'p', 'Revit', 'revit_csv');
+      INSERT INTO external_import_batches
+        (id, project_id, source_id, import_kind, imported_at_iso, file_name, sha256,
+         applied_project_revision, configuration_snapshot, original_bytes, document, configuration_version)
+        VALUES ('batch', 'p', 'src', 'initial', '2026-01-01T00:00:00.000Z', 'legacy.csv',
+         'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 0, '{}', X'00', '{}', 3);
+      INSERT INTO external_model_objects
+        (id, project_id, source_id, ifc_guid, last_seen_import_batch_id,
+         last_accepted_import_batch_id, accepted_source_values, planning_values,
+         overridden_fields, circuit_device_row_id)
+        VALUES ('object', 'p', 'src', 'Ifc-GUID', 'batch', 'batch', '{}', '{}', '[]', 'r');
+    `);
+
+    migrate(context.db, { migrationsFolder: source });
+
+    assert.equal(
+      (context.sqlite.prepare("SELECT quantity FROM circuit_device_rows WHERE id = 'r'").get() as { quantity: number }).quantity,
+      2
+    );
+    assert.equal(context.sqlite.prepare("SELECT count(*) AS count FROM external_model_objects").get()!.count, 0);
+    assert.equal(context.sqlite.prepare("SELECT count(*) AS count FROM external_model_configurations").get()!.count, 0);
+    assert.throws(() => context.sqlite.prepare("SELECT * FROM external_csv_configurations").all(), /no such table/);
+
+    const columns = context.sqlite.prepare("PRAGMA table_info(external_model_objects)").all() as Array<{ name: string; notnull: number }>;
+    assert.equal(columns.find((column) => column.name === "worksharing_id")?.notnull, 1);
+    assert.equal(columns.find((column) => column.name === "ifc_guid")?.notnull, 0);
+    assert.deepEqual(context.sqlite.pragma("foreign_key_check"), []);
+    assert.equal(context.sqlite.pragma("integrity_check", { simple: true }), "ok");
+  } finally {
+    context.close();
+    rmSync(staging, { recursive: true, force: true });
+  }
+});
+
+it("creates and verifies a backup before the Linear-XLSX migration", () => {
+  const source = path.resolve("src", "db", "migrations");
+  const root = mkdtempSync(path.join(tmpdir(), "leistungsbilanz-linear-xlsx-backup-"));
+  const staging = path.join(root, "migrations");
+  const dataDirectory = path.join(root, "data");
+  mkdirSync(path.join(staging, "meta"), { recursive: true });
+  mkdirSync(dataDirectory, { recursive: true });
+  const journal = JSON.parse(readFileSync(path.join(source, "meta", "_journal.json"), "utf8"));
+  journal.entries = journal.entries.filter((entry: { idx: number }) => entry.idx <= 13);
+  writeFileSync(path.join(staging, "meta", "_journal.json"), JSON.stringify(journal));
+  for (const entry of journal.entries) {
+    copyFileSync(path.join(source, `${entry.tag}.sql`), path.join(staging, `${entry.tag}.sql`));
+  }
+
+  const databasePath = path.join(dataDirectory, "leistungsbilanz.db");
+  const context = createDatabaseContext(databasePath);
+  try {
+    migrate(context.db, { migrationsFolder: staging });
+  } finally {
+    context.close();
+  }
+
+  try {
+    const result = spawnSync(process.execPath, ["scripts/run-migrations.js"], {
+      cwd: path.resolve("."),
+      env: { ...process.env, LEISTUNGSBILANZ_DATA_DIR: dataDirectory },
+      encoding: "utf8",
+    });
+    assert.equal(result.status, 0, result.stderr || result.stdout);
+    assert.match(result.stdout, /Verified pre-migration backup created/);
+    const backups = readdirSync(path.join(dataDirectory, "backups"));
+    assert.equal(backups.length, 1);
+
+    const migrated = createDatabaseContext(databasePath);
+    try {
+      assert.ok(migrated.sqlite.prepare(
+        "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'external_model_configurations'"
+      ).get());
+    } finally {
+      migrated.close();
+    }
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
diff --git a/tests/project-command.service.test.ts b/tests/project-command.service.test.ts
index 5630cb8..ac6d887 100644
--- a/tests/project-command.service.test.ts
+++ b/tests/project-command.service.test.ts
@@ -30,7 +30,7 @@ import { ProjectDeviceRowSyncProjectCommandRepository } from "../src/db/reposito
 import { ProjectDeviceStructureProjectCommandRepository } from "../src/db/repositories/project-device-structure-project-command.repository.js";
 import { ProjectStateRestoreCommandRepository } from "../src/db/repositories/project-state-restore-command.repository.js";
 import { ProjectSettingsProjectCommandRepository } from "../src/db/repositories/project-settings-project-command.repository.js";
-import { ExternalCsvConfigurationProjectCommandRepository } from "../src/db/repositories/external-csv-configuration-project-command.repository.js";
+import { ExternalModelConfigurationProjectCommandRepository } from "../src/db/repositories/external-model-configuration-project-command.repository.js";
 import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
 import { circuitProtectionDevices } from "../src/db/schema/circuit-protection-devices.js";
 import { circuitSections } from "../src/db/schema/circuit-sections.js";
@@ -44,7 +44,7 @@ import { projects } from "../src/db/schema/projects.js";
 import { buildings } from "../src/db/schema/buildings.js";
 import { floors } from "../src/db/schema/floors.js";
 import { rooms } from "../src/db/schema/rooms.js";
-import { externalCsvConfigurations } from "../src/db/schema/external-csv-configurations.js";
+import { externalModelConfigurations } from "../src/db/schema/external-model-configurations.js";
 import { createCircuitProtectionUpdateProjectCommand } from "../src/domain/models/circuit-protection-project-command.model.js";
 import { ProjectHistoryOperationUnavailableError } from "../src/domain/errors/project-history-operation-unavailable.error.js";
 import { ProjectRevisionConflictError } from "../src/domain/errors/project-revision-conflict.error.js";
@@ -90,9 +90,8 @@ import { createProjectDeviceRowSyncProjectCommand } from "../src/domain/models/p
 import { createProjectDeviceUpdateProjectCommand } from "../src/domain/models/project-device-project-command.model.js";
 import { createProjectDeviceInsertProjectCommand } from "../src/domain/models/project-device-structure-project-command.model.js";
 import { createProjectSettingsUpdateProjectCommand } from "../src/domain/models/project-settings-project-command.model.js";
-import { createExternalCsvConfigurationUpdateProjectCommand } from "../src/domain/models/external-csv-configuration-project-command.model.js";
-import { createDefaultExternalCsvConfiguration } from "../src/external-model/csv/external-csv-contracts.js";
-import { externalCsvTestColumns } from "./fixtures/revit-csv-fixtures.js";
+import { createExternalModelConfigurationUpdateProjectCommand } from "../src/domain/models/external-model-configuration-project-command.model.js";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
 import { ProjectCommandService } from "../src/domain/services/project-command.service.js";
 
 function createTestDatabase(): DatabaseContext {
@@ -166,7 +165,7 @@ function createService(context: DatabaseContext) {
     new CircuitGroupSubtreeProjectCommandRepository(context.db),
     new CircuitProtectionProjectCommandRepository(context.db),
     new ProjectHistoryRepository(context.db),
-    new ExternalCsvConfigurationProjectCommandRepository(context.db)
+    new ExternalModelConfigurationProjectCommandRepository(context.db)
   );
 }
 
@@ -1127,31 +1126,62 @@ describe("project command service", () => {
     }
   });
 
-  it("dispatches external CSV configuration updates through persistent history", () => {
+  it("dispatches external XLSX configuration updates through persistent history", () => {
     const context = createTestDatabase();
     try {
       const service = createService(context);
       const target = {
         id: "external-config-1",
         projectId: "project-1",
-        configurationVersion: 1,
-        configuration: createDefaultExternalCsvConfiguration(externalCsvTestColumns),
+        configuration: createDefaultExternalModelConfiguration(),
       };
       const updated = service.executeUser({
         projectId: "project-1",
         expectedRevision: 0,
-        command: createExternalCsvConfigurationUpdateProjectCommand(null, target),
+        command: createExternalModelConfigurationUpdateProjectCommand(null, target),
       });
       assert.equal(updated.history.currentRevision, 1);
-      assert.equal(context.db.select().from(externalCsvConfigurations).all().length, 1);
+      assert.equal(context.db.select().from(externalModelConfigurations).all().length, 1);
 
       const undone = service.undo({ projectId: "project-1", expectedRevision: 1 });
       assert.equal(undone.history.currentRevision, 2);
-      assert.equal(context.db.select().from(externalCsvConfigurations).all().length, 0);
+      assert.equal(context.db.select().from(externalModelConfigurations).all().length, 0);
 
       const redone = service.redo({ projectId: "project-1", expectedRevision: 2 });
       assert.equal(redone.history.currentRevision, 3);
-      assert.equal(context.db.select().from(externalCsvConfigurations).all().length, 1);
+      assert.equal(context.db.select().from(externalModelConfigurations).all().length, 1);
+    } finally {
+      context.close();
+    }
+  });
+
+  it("rejects legacy CSV commands stored in project history with a clear error", () => {
+    const context = createTestDatabase();
+    try {
+      const service = createService(context);
+      service.executeUser({
+        projectId: "project-1",
+        expectedRevision: 0,
+        command: createExternalModelConfigurationUpdateProjectCommand(null, {
+          id: "external-config-1",
+          projectId: "project-1",
+          configuration: createDefaultExternalModelConfiguration(),
+        }),
+      });
+      context.db.update(projectChangeSets).set({
+        inversePayloadJson: JSON.stringify({
+          schemaVersion: 1,
+          type: "external-import.apply-initial",
+          payload: {},
+        }),
+      }).run();
+
+      assert.throws(
+        () => service.undo({ projectId: "project-1", expectedRevision: 1 }),
+        /alten Revit-CSV-Anbindung/
+      );
+      assert.equal(context.db.select().from(externalModelConfigurations).all().length, 1);
+      assert.equal(context.db.select({ revision: projects.currentRevision }).from(projects).get()?.revision, 1);
     } finally {
       context.close();
     }
diff --git a/tests/project-device-row-sync-project-command.repository.test.ts b/tests/project-device-row-sync-project-command.repository.test.ts
index 593a7f6..f5e7a60 100644
--- a/tests/project-device-row-sync-project-command.repository.test.ts
+++ b/tests/project-device-row-sync-project-command.repository.test.ts
@@ -19,7 +19,6 @@ import { externalModelSources } from "../src/db/schema/external-model-sources.js
 import { projectDevices } from "../src/db/schema/project-devices.js";
 import { projectRevisions } from "../src/db/schema/project-revisions.js";
 import { projects } from "../src/db/schema/projects.js";
-import { externalCsvTestConfiguration } from "./fixtures/revit-csv-fixtures.js";
 import {
   createProjectDeviceRowSyncProjectCommand,
   type ProjectDeviceSyncRowSnapshot,
@@ -178,7 +177,7 @@ function linkExternalObject(
       id: "source-1",
       projectId: "project-1",
       name: "Revit",
-      sourceType: "revit_csv",
+      sourceType: "revit_xlsx",
     })
     .run();
   context.db
@@ -189,13 +188,9 @@ function linkExternalObject(
       sourceId: "source-1",
       importKind: "initial",
       importedAtIso: "2026-08-02T16:00:00.000Z",
-      fileName: "revit.csv",
+      fileName: "revit.xlsx",
       sha256: "a".repeat(64),
-      appliedProjectRevision: 0,
-      configurationVersion: 1,
-      configurationSnapshot: externalCsvTestConfiguration,
-      originalBytes: Buffer.from("test"),
-      document: { delimiter: ";", encoding: "utf-8", headers: [], rows: [] },
+      objectCount: 1,
     })
     .run();
   context.db
@@ -204,7 +199,9 @@ function linkExternalObject(
       id: "object-1",
       projectId: "project-1",
       sourceId: "source-1",
+      worksharingId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee-ffffffff",
       ifcGuid: "ifc-1",
+      deviceTypeId: "device-type-1",
       lastSeenImportBatchId: "batch-1",
       lastAcceptedImportBatchId: "batch-1",
       acceptedSourceValues: {
@@ -213,14 +210,18 @@ function linkExternalObject(
         roomName: "Büro",
         familyAndType: "Leuchte: Standard",
         selectionMarker: "Leuchte",
+        socketCount: String(effectiveQuantity),
+        sourceRemark: null,
+        circuitCombined: "-1F1",
+        boardName: "UV 1",
         circuitIdentifier: "-1F1",
-        power: "30",
-        quantity: String(effectiveQuantity),
-        additionalSourceValues: {},
+        designation: null,
+        electricalPowerW: "30",
+        voltageV: 230,
+        currentA: null,
       },
       planningValues: {
         displayName: "Leuchte",
-        internalDeviceType: "luminaire",
         category: "single_phase",
         connectionKind: "fixed",
         effectiveQuantity,
diff --git a/tests/project-snapshot.repository.test.ts b/tests/project-snapshot.repository.test.ts
index bc4cd12..b85485c 100644
--- a/tests/project-snapshot.repository.test.ts
+++ b/tests/project-snapshot.repository.test.ts
@@ -465,6 +465,8 @@ describe("project snapshot repository", () => {
         rooms: Array<Record<string, unknown>>;
       };
       payload.schemaVersion = 5;
+      (payload as Record<string, unknown>).externalCsvConfiguration = null;
+      delete (payload as Record<string, unknown>).externalModelConfiguration;
       delete payload.buildings;
       for (const floor of payload.floors) {
         delete floor.buildingId;
diff --git a/tests/project-state-snapshot.test.ts b/tests/project-state-snapshot.test.ts
index aa2371b..1ae460f 100644
--- a/tests/project-state-snapshot.test.ts
+++ b/tests/project-state-snapshot.test.ts
@@ -8,11 +8,16 @@ import {
 } from "../src/domain/models/project-state-snapshot.model.js";
 import { remapProjectState } from "../src/domain/models/project-transfer.model.js";
 import { createNamedProjectSnapshotSchema } from "../src/shared/validation/project-snapshot.schemas.js";
+import { createDefaultExternalCsvConfiguration } from "../src/external-model/csv/external-csv-contracts.js";
+import { externalCsvTestColumns } from "./fixtures/revit-csv-fixtures.js";
 
 /** Removes the fields introduced by snapshot schema version 9. */
 function withoutVersionNineFields<
   T extends { distributionBoards: object[] },
 >(snapshot: T): T {
+  const record = snapshot as Record<string, unknown>;
+  record.externalCsvConfiguration = null;
+  delete record.externalModelConfiguration;
   for (const board of snapshot.distributionBoards) {
     delete (board as Record<string, unknown>).feedingDistributionBoardId;
     delete (board as Record<string, unknown>).feedingCircuitId;
@@ -77,7 +82,7 @@ function minimalSnapshot() {
       projectEditor: null as string | null,
     },
     distributionBoards: [],
-    externalCsvConfiguration: null,
+    externalModelConfiguration: null,
     externalModel: {
       source: null,
       importBatches: [],
@@ -315,6 +320,7 @@ describe("project state snapshot model", () => {
     const baseline = withoutVersionSixFields(structuredClone(minimalSnapshot()));
     baseline.schemaVersion = 1 as typeof baseline.schemaVersion;
     delete (baseline.project as Record<string, unknown>).isPublicBuilding;
+    delete (baseline as Record<string, unknown>).externalModelConfiguration;
     delete (baseline as Record<string, unknown>).externalCsvConfiguration;
     delete (baseline as Record<string, unknown>).externalModel;
 
@@ -322,7 +328,7 @@ describe("project state snapshot model", () => {
 
     assert.equal(upgraded.schemaVersion, projectStateSnapshotSchemaVersion);
     assert.equal(upgraded.project.isPublicBuilding, false);
-    assert.equal(upgraded.externalCsvConfiguration, null);
+    assert.equal(upgraded.externalModelConfiguration, null);
   });
 
   it("upgrades snapshot version 2 with an empty external CSV configuration", () => {
@@ -334,7 +340,7 @@ describe("project state snapshot model", () => {
     const upgraded = parseProjectStateSnapshot(previous);
 
     assert.equal(upgraded.schemaVersion, projectStateSnapshotSchemaVersion);
-    assert.equal(upgraded.externalCsvConfiguration, null);
+    assert.equal(upgraded.externalModelConfiguration, null);
     assert.deepEqual(upgraded.externalModel, {
       source: null,
       importBatches: [],
@@ -351,7 +357,7 @@ describe("project state snapshot model", () => {
     const upgraded = parseProjectStateSnapshot(previous);
 
     assert.equal(upgraded.schemaVersion, projectStateSnapshotSchemaVersion);
-    assert.equal(upgraded.externalCsvConfiguration, null);
+    assert.equal(upgraded.externalModelConfiguration, null);
     assert.deepEqual(upgraded.externalModel, {
       source: null,
       importBatches: [],
@@ -360,6 +366,28 @@ describe("project state snapshot model", () => {
     });
   });
 
+  it("rejects legacy CSV configuration and imported state with a German migration error", () => {
+    const configured = withoutVersionNineFields(structuredClone(minimalSnapshot()));
+    configured.schemaVersion = 9 as typeof configured.schemaVersion;
+    configured.externalCsvConfiguration = {
+      id: "legacy",
+      projectId: "project-1",
+      configurationVersion: 1,
+      configuration: createDefaultExternalCsvConfiguration(externalCsvTestColumns),
+    };
+    assert.throws(() => parseProjectStateSnapshot(configured), /Revit-CSV-Daten/);
+
+    const imported = withoutVersionNineFields(structuredClone(minimalSnapshot()));
+    imported.schemaVersion = 9 as typeof imported.schemaVersion;
+    imported.externalModel.source = {
+      id: "legacy-source",
+      projectId: "project-1",
+      name: "Legacy",
+      sourceType: "revit_csv",
+    };
+    assert.throws(() => parseProjectStateSnapshot(imported), /Revit-CSV-Daten/);
+  });
+
   it("upgrades snapshot version 5 with empty board info and cover fields", () => {
     const previous = withoutVersionSixFields(protectedSnapshot());
     previous.schemaVersion = 5 as typeof previous.schemaVersion;
@@ -567,7 +595,7 @@ describe("project state snapshot model", () => {
     });
     assert.equal(parseProjectStateSnapshot(current).rooms[0]?.areaM2, 23.456);
 
-    const previous = structuredClone(current);
+    const previous = withoutVersionNineFields(structuredClone(current));
     previous.schemaVersion = 7 as typeof previous.schemaVersion;
     delete (previous.rooms[0] as Partial<(typeof previous.rooms)[number]>).areaM2;
     const upgraded = parseProjectStateSnapshot(previous);

From c633e78cd406688a23f89c0dc15569ad87f6f394 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 09:02:52 +0200
Subject: [PATCH 52/60] Add Revit XLSX settings page

---
 AGENTS.md                                     |   6 +-
 README.md                                     |   6 +-
 docs/spec/revit-excel-phase-14-plan.md        |   2 +-
 src/app/projects/[projectId]/page.tsx         |  44 +-
 src/app/projects/[projectId]/revit/page.tsx   |  34 +
 src/frontend/components/revit-csv-modal.tsx   | 666 ------------------
 .../components/revit-xlsx-settings-modal.tsx  |  45 ++
 src/frontend/types.ts                         |   7 +
 src/frontend/utils/api.ts                     |  99 +--
 src/frontend/utils/project-version-history.ts |   1 +
 src/frontend/utils/revit-xlsx-settings.ts     |  17 +
 ...external-model-configuration.controller.ts |  60 ++
 src/server/routes/project.routes.ts           |   8 +
 tests/revit-csv-frontend-api.test.ts          | 251 -------
 tests/revit-xlsx-settings-api.test.ts         |  38 +
 15 files changed, 259 insertions(+), 1025 deletions(-)
 create mode 100644 src/app/projects/[projectId]/revit/page.tsx
 delete mode 100644 src/frontend/components/revit-csv-modal.tsx
 create mode 100644 src/frontend/components/revit-xlsx-settings-modal.tsx
 create mode 100644 src/frontend/utils/revit-xlsx-settings.ts
 create mode 100644 src/server/controllers/external-model-configuration.controller.ts
 delete mode 100644 tests/revit-csv-frontend-api.test.ts
 create mode 100644 tests/revit-xlsx-settings-api.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index c95a271..e8d4bff 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -329,8 +329,8 @@ the old development-only external CSV data after resetting linked row totals to
 their manual share. Snapshot schema 10, restore and project transfer use the
 new state; non-empty legacy CSV snapshots and legacy CSV history entries are
 rejected with a German error. The backend CSV parser and routes are removed.
-The old project-page frontend remains only until its replacement in R4; do not
-reconnect it to runtime CSV endpoints. See
+R4 adds `/projects/:projectId/revit`, its revisioned XLSX settings and
+server-side sample detection, and removes the old project-page CSV modal. See
 `docs/spec/revit-excel-integration-requirements.md` and
 `docs/spec/revit-excel-phase-14-plan.md`.
 
@@ -586,7 +586,7 @@ Critical target rules:
   selected combined/separate mode block export.
 - Missing GZF defaults visibly to 1 without separate confirmation.
 - The corrected R2 return workbook was successfully imported into Linear on
-  2026-09-30; R3 is complete and R4 is the next package.
+  2026-09-30; R3 and R4 are complete and R5 is the next package.
 - All confirmed writes use typed project commands with `expectedRevision`,
   complete inverse data and the shared project-command transaction boundary.
 - Do not add automatic circuit planning, Revit circuit adoption, multi-source
diff --git a/README.md b/README.md
index b8b9c3e..b70a145 100644
--- a/README.md
+++ b/README.md
@@ -11,9 +11,9 @@ für mehrere gleichzeitig arbeitende Prozesse und ein vollständig unterstützte
 Produktionsdeployment fehlen weiterhin. Anmeldung und zwei feste Rollen sind
 vorhanden. Die Backend- und Persistenzgrundlage der bisherigen
 Revit-CSV-/IfcGUID-Anbindung ist durch den XLSX-Austausch des Linear-Plugins mit
-Worksharing-ID als externem Schlüssel ersetzt. R0 bis R3 sind abgeschlossen;
-die eigene Revit-Seite, Erstimport, Editorzuordnung, Rückgabe und Folgeimport
-folgen in R4 bis R10.
+Worksharing-ID als externem Schlüssel ersetzt. R0 bis R4 sind abgeschlossen;
+die eigene Revit-Seite mit XLSX-Einstellungen ist vorhanden. Erstimport,
+Editorzuordnung, Rückgabe und Folgeimport folgen in R5 bis R10.
 
 ## Unterstützter Arbeitsablauf
 
diff --git a/docs/spec/revit-excel-phase-14-plan.md b/docs/spec/revit-excel-phase-14-plan.md
index 4004eb3..0b1b71a 100644
--- a/docs/spec/revit-excel-phase-14-plan.md
+++ b/docs/spec/revit-excel-phase-14-plan.md
@@ -12,7 +12,7 @@ Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
 | R1 | abgeschlossen | Anforderungen, Plan und Architektur auf Excel/Worksharing-ID umgestellt; alle Pflichtprüfungen bestanden. |
 | R2 | abgeschlossen und freigegeben | XLSX-Adapter, Parser, synthetische Fixtures, lokaler Referenzprüfer und reale Rückgabedatei sind erstellt; der korrigierte Rückimport wurde am 30.09.2026 erfolgreich in Linear getestet. |
 | R3 | abgeschlossen | Konfiguration ohne eigene Revision, Worksharing-ID-Datenmodell, Migration 0014, Snapshot 10, Transfer und Backend-CSV-Entfernung sind umgesetzt und geprüft. |
-| R4 | offen | Revit-Seite, Navigation, Einstellungen, altes Projektseitenmodal entfernen. |
+| R4 | abgeschlossen | Revit-Seite, Navigation und revisionierte XLSX-Einstellungen mit Musterdateiprüfung sind umgesetzt; das alte Projektseitenmodal ist entfernt. |
 | R5 | offen | Erstimportwizard mit Gerätearten, Familienregeln und optionalen ProjectDevices. |
 | R6 | offen | Virtualisierte Objekttabelle und Sammelzuordnungen. |
 | R7 | offen | Editorbereich, Gruppierung, Drag-and-drop, Lösen und integrierte Löschübergänge. |
diff --git a/src/app/projects/[projectId]/page.tsx b/src/app/projects/[projectId]/page.tsx
index ec99d54..5eb864e 100644
--- a/src/app/projects/[projectId]/page.tsx
+++ b/src/app/projects/[projectId]/page.tsx
@@ -5,7 +5,7 @@ import { useParams } from "next/navigation";
 import { FormEvent, useEffect, useMemo, useState } from "react";
 import {
   ArrowLeft,
-  FileUp,
+  FileSpreadsheet,
   Library,
   Link2,
   ListTree,
@@ -51,7 +51,6 @@ import {
   copyProjectDeviceToGlobal,
   createDistributionBoard,
   createProjectDevice,
-  createRoom,
   deleteProjectDevice,
   deleteDistributionBoard,
   disconnectProjectDeviceRows,
@@ -83,7 +82,6 @@ import type {
   BuildingDto,
   CircuitListDto,
   CircuitTreeResponseDto,
-  CreateRoomInput,
   CreateProjectDeviceInput,
   DistributionBoardDto,
   FloorDto,
@@ -115,7 +113,6 @@ import {
 } from "../../../frontend/components/project-settings-modal";
 import { FormModal } from "../../../frontend/components/form-modal";
 import { ProjectDeviceModal } from "../../../frontend/components/project-device-modal";
-import { RevitCsvModal } from "../../../frontend/components/revit-csv-modal";
 import { FloorSelectOptions } from "../../../frontend/components/floor-select-options";
 
 const projectDeviceSyncFieldLabels: Record<ProjectDeviceSyncField, string> = {
@@ -200,7 +197,6 @@ export default function ProjectDetailPage() {
       })
     );
   const [isProjectSettingsOpen, setIsProjectSettingsOpen] = useState(false);
-  const [isRevitCsvOpen, setIsRevitCsvOpen] = useState(false);
   const [structureModal, setStructureModal] = useState<"board" | null>(null);
   const [isProjectDeviceModalOpen, setIsProjectDeviceModalOpen] =
     useState(false);
@@ -679,22 +675,6 @@ export default function ProjectDetailPage() {
     }
   }
 
-  async function handleCreateRevitRoom(input: CreateRoomInput) {
-    if (!projectId || !project) throw new Error("Projekt ist nicht geladen.");
-    const result = await createRoom(projectId, input, project.currentRevision);
-    setRooms((current) => [...current, result.room]);
-    applyProjectRevision(result.history.currentRevision);
-    return result;
-  }
-
-  async function handleCreateRevitProjectDevice(input: CreateProjectDeviceInput) {
-    if (!projectId || !project) throw new Error("Projekt ist nicht geladen.");
-    const result = await createProjectDevice(projectId, input, project.currentRevision);
-    setProjectDevices((current) => [...current, result.projectDevice]);
-    applyProjectRevision(result.history.currentRevision);
-    return result;
-  }
-
   async function handleCopyBoard() {
     if (
       !projectId ||
@@ -997,15 +977,13 @@ export default function ProjectDetailPage() {
             <Printer aria-hidden="true" size={16} />
             Seitenansicht
           </Link>
-          <button
+          <Link
             className="btn btn-outline-primary btn-with-icon"
-            disabled={!project}
-            onClick={() => setIsRevitCsvOpen(true)}
-            type="button"
+            href={`/projects/${projectId}/revit`}
           >
-            <FileUp aria-hidden="true" size={16} strokeWidth={2} />
-            Revit-CSV
-          </button>
+            <FileSpreadsheet aria-hidden="true" size={16} strokeWidth={2} />
+            Revit
+          </Link>
           <button
             className="btn btn-outline-primary btn-with-icon"
             disabled={!project}
@@ -1897,16 +1875,6 @@ export default function ProjectDetailPage() {
           usedDistributionBoardSupplyTypes={usedBoardSupplyTypes}
         />
       ) : null}
-      {project && isRevitCsvOpen ? (
-        <RevitCsvModal
-          currentRevision={project.currentRevision}
-          onClose={() => setIsRevitCsvOpen(false)}
-          onCreateProjectDevice={handleCreateRevitProjectDevice}
-          onCreateRoom={handleCreateRevitRoom}
-          onRevisionChange={applyProjectRevision}
-          projectId={projectId}
-        />
-      ) : null}
     </main>
   );
 }
diff --git a/src/app/projects/[projectId]/revit/page.tsx b/src/app/projects/[projectId]/revit/page.tsx
new file mode 100644
index 0000000..96af41c
--- /dev/null
+++ b/src/app/projects/[projectId]/revit/page.tsx
@@ -0,0 +1,34 @@
+"use client";
+
+import { ArrowLeft, FileSpreadsheet, Settings } from "lucide-react";
+import { useParams } from "next/navigation";
+import { useEffect, useState } from "react";
+import { IconLink } from "../../../../frontend/components/icon-link";
+import { RevitXlsxSettingsModal } from "../../../../frontend/components/revit-xlsx-settings-modal";
+import type { ExternalModelConfiguration } from "../../../../external-model/configuration/external-model-configuration";
+import { detectExternalModelWorkbook, getExternalModelConfiguration, getProject, updateExternalModelConfiguration } from "../../../../frontend/utils/api";
+import { createDefaultRevitXlsxConfiguration } from "../../../../frontend/utils/revit-xlsx-settings";
+import type { ExternalModelConfigurationSnapshotDto, ProjectDto } from "../../../../frontend/types";
+
+export default function RevitPage() {
+  const { projectId } = useParams<{ projectId: string }>();
+  const [project, setProject] = useState<ProjectDto | null>(null);
+  const [snapshot, setSnapshot] = useState<ExternalModelConfigurationSnapshotDto | null>(null);
+  const [open, setOpen] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  useEffect(() => { Promise.all([getProject(projectId), getExternalModelConfiguration(projectId)]).then(([loadedProject, result]) => { setProject(loadedProject); setSnapshot(result.configuration); }).catch((value: unknown) => setError(value instanceof Error ? value.message : "Revit-Daten konnten nicht geladen werden.")); }, [projectId]);
+  async function save(configuration: ExternalModelConfiguration) {
+    if (!project) return;
+    setSaving(true); setError(null);
+    try { const result = await updateExternalModelConfiguration(projectId, project.currentRevision, configuration); setSnapshot(result.configuration); setProject({ ...project, currentRevision: result.history.currentRevision }); setOpen(false); }
+    catch (value) { setError(value instanceof Error ? value.message : "Einstellungen konnten nicht gespeichert werden."); }
+    finally { setSaving(false); }
+  }
+  return <main className="container py-4">
+    <div className="page-header"><div><div className="kicker">Projekt · Revit</div><h1>{project?.name ?? "Revit-Anbindung"}</h1><p className="text-secondary mb-0">Linear-XLSX austauschen und Revit-Objekte verwalten</p></div><div className="d-flex gap-2"><button className="btn btn-primary btn-with-icon" disabled={!project} onClick={() => setOpen(true)} type="button"><Settings size={16} />Einstellungen</button><IconLink href={`/projects/${projectId}`} icon={ArrowLeft} label="Zum Projekt" showLabel /></div></div>
+    {error ? <div className="alert alert-danger">{error}</div> : null}
+    <div className="row g-3 mt-1"><div className="col-md-6"><section className="card h-100"><div className="card-body"><FileSpreadsheet className="mb-3" size={28} /><h2 className="h5">XLSX-Konfiguration</h2><p className="text-secondary">{snapshot ? "Die Linear-Spalten und das Tabellenlayout sind konfiguriert." : "Noch keine XLSX-Konfiguration gespeichert."}</p><span className={`badge ${snapshot ? "text-bg-success" : "text-bg-secondary"}`}>{snapshot ? "Konfiguriert" : "Offen"}</span></div></section></div><div className="col-md-6"><section className="card h-100"><div className="card-body"><h2 className="h5">Importstatus</h2><p className="text-secondary mb-0">Noch kein Linear-XLSX-Import vorhanden. Der Erstimport folgt in R5.</p></div></section></div></div>
+    {open ? <RevitXlsxSettingsModal configuration={snapshot?.configuration ?? createDefaultRevitXlsxConfiguration()} isSaving={saving} onClose={() => setOpen(false)} onInspectSample={async (file, configuration) => { const result = await detectExternalModelWorkbook(projectId, file, configuration); return `Muster erkannt: ${result.sheetName}, ${result.columnCount} Spalten, ${result.objectCount} Objekte.`; }} onSave={save} /> : null}
+  </main>;
+}
diff --git a/src/frontend/components/revit-csv-modal.tsx b/src/frontend/components/revit-csv-modal.tsx
deleted file mode 100644
index 3602bd8..0000000
--- a/src/frontend/components/revit-csv-modal.tsx
+++ /dev/null
@@ -1,666 +0,0 @@
-"use client";
-
-import React, { useEffect, useMemo, useState, type FormEvent } from "react";
-import {
-  createDefaultExternalCsvConfiguration,
-  type ExternalCsvConfiguration,
-  type ExternalCsvFamilyTypeRule,
-} from "../../external-model/csv/external-csv-contracts";
-import type {
-  CreateProjectDeviceInput,
-  CreateRoomInput,
-  ExternalCsvPreviewDto,
-  ExternalInitialImportPlanDto,
-  ProjectDeviceCommandResultDto,
-  ProjectRoomCommandResultDto,
-} from "../types";
-import {
-  applyExternalInitialImport,
-  getExternalCsvConfiguration,
-  planExternalInitialImport,
-  previewExternalCsv,
-  updateExternalCsvConfiguration,
-} from "../utils/api";
-import { FormModal } from "./form-modal";
-import { ProjectDeviceModal } from "./project-device-modal";
-import { RoomModal } from "./room-modal";
-
-interface RevitCsvModalProps {
-  currentRevision: number;
-  onClose: () => void;
-  onCreateProjectDevice: (
-    input: CreateProjectDeviceInput
-  ) => Promise<ProjectDeviceCommandResultDto>;
-  onCreateRoom: (input: CreateRoomInput) => Promise<ProjectRoomCommandResultDto>;
-  onRevisionChange: (currentRevision: number) => void;
-  projectId: string;
-}
-
-const defaultConfiguration = createDefaultExternalCsvConfiguration({
-  ifcGuid: "IfcGUID",
-  roomNumber: "MEP-Raum: Nummer",
-  roomName: "MEP-Raum: Name",
-  familyAndType: "Familie und Typ",
-  selectionMarker: "CAx_Auswahlkenner",
-  circuitIdentifier: "kbp_Stromkreisnummer",
-  power: "kbp-E-Elektrische Leistung",
-  quantity: null,
-});
-defaultConfiguration.additionalSourceMappings = [
-  { sourceColumn: "CAx_Anmerkung", targetField: "sourceRemark" },
-  { sourceColumn: "kbp-E-Spannung", targetField: "sourceVoltage" },
-  { sourceColumn: "kbp-E-Stromstärke", targetField: "sourceCurrent" },
-  { sourceColumn: "kbp-E-Versorgung von ELT", targetField: "sourceElectricalSupply" },
-  { sourceColumn: "kbp-E-Versorgung von MSR/GLT", targetField: "sourceControlSupply" },
-];
-
-const columnFields = [
-  ["ifcGuid", "IFC-GUID"],
-  ["roomNumber", "Raumnummer"],
-  ["roomName", "Raumname"],
-  ["familyAndType", "Familie und Typ"],
-  ["selectionMarker", "CAx-Auswahlkenner"],
-  ["circuitIdentifier", "Stromkreiskennzeichnung"],
-  ["power", "Elektrische Leistung"],
-  ["quantity", "Menge (optional)"],
-] as const;
-
-export function RevitCsvModal({
-  currentRevision,
-  onClose,
-  onCreateProjectDevice,
-  onCreateRoom,
-  onRevisionChange,
-  projectId,
-}: RevitCsvModalProps) {
-  const [configuration, setConfiguration] = useState<ExternalCsvConfiguration>(
-    structuredClone(defaultConfiguration)
-  );
-  const [savedConfiguration, setSavedConfiguration] = useState<string | null>(null);
-  const [file, setFile] = useState<File | null>(null);
-  const [preview, setPreview] = useState<ExternalCsvPreviewDto | null>(null);
-  const [importPlan, setImportPlan] = useState<ExternalInitialImportPlanDto | null>(null);
-  const [roomDecisions, setRoomDecisions] = useState<Record<string, { roomId: string | null; defaultDistributionBoardId: string | null }>>({});
-  const [familyLinks, setFamilyLinks] = useState<Record<string, string | null>>({});
-  const [sourceName, setSourceName] = useState("Revit-Gesamtmodell");
-  const [success, setSuccess] = useState<string | null>(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const [isSaving, setIsSaving] = useState(false);
-  const [isPreviewing, setIsPreviewing] = useState(false);
-  const [isPlanning, setIsPlanning] = useState(false);
-  const [isApplying, setIsApplying] = useState(false);
-  const [isCreatingCatalogEntry, setIsCreatingCatalogEntry] = useState(false);
-  const [newRoomSourceKey, setNewRoomSourceKey] = useState<string | null>(null);
-  const [newProjectDeviceFamily, setNewProjectDeviceFamily] = useState<string | null>(null);
-  const [error, setError] = useState<string | null>(null);
-
-  useEffect(() => {
-    getExternalCsvConfiguration(projectId)
-      .then(({ configuration: stored }) => {
-        const next = stored?.configuration ?? structuredClone(defaultConfiguration);
-        setConfiguration(next);
-        setSavedConfiguration(stored ? JSON.stringify(next) : null);
-      })
-      .catch((reason: unknown) =>
-        setError(reason instanceof Error ? reason.message : "Konfiguration konnte nicht geladen werden.")
-      )
-      .finally(() => setIsLoading(false));
-  }, [projectId]);
-
-  const isDirty = savedConfiguration !== JSON.stringify(configuration);
-
-  function replaceConfiguration(next: ExternalCsvConfiguration) {
-    setConfiguration(next);
-    setPreview(null);
-    setImportPlan(null);
-    setSuccess(null);
-  }
-
-  async function handleSave(event: FormEvent<HTMLFormElement>) {
-    event.preventDefault();
-    setIsSaving(true);
-    setError(null);
-    try {
-      const result = await updateExternalCsvConfiguration(
-        projectId,
-        currentRevision,
-        configuration
-      );
-      setSavedConfiguration(JSON.stringify(result.configuration.configuration));
-      setImportPlan(null);
-      onRevisionChange(result.history.currentRevision);
-    } catch (reason) {
-      setError(reason instanceof Error ? reason.message : "Konfiguration konnte nicht gespeichert werden.");
-    } finally {
-      setIsSaving(false);
-    }
-  }
-
-  async function handlePreview() {
-    if (!file || isDirty || savedConfiguration === null) return;
-    setIsPreviewing(true);
-    setError(null);
-    try {
-      const contentBase64 = await fileToBase64(file);
-      setPreview(await previewExternalCsv(projectId, file.name, contentBase64));
-      setImportPlan(null);
-      setSuccess(null);
-    } catch (reason) {
-      setPreview(null);
-      setError(reason instanceof Error ? reason.message : "CSV-Vorschau konnte nicht erstellt werden.");
-    } finally {
-      setIsPreviewing(false);
-    }
-  }
-
-  async function handlePlanImport() {
-    if (!file || !preview || isDirty || savedConfiguration === null) return;
-    setIsPlanning(true);
-    setError(null);
-    try {
-      const contentBase64 = await fileToBase64(file);
-      const plan = await planExternalInitialImport(projectId, file.name, contentBase64);
-      if (plan.sha256 !== preview.sha256) {
-        throw new Error("Die Datei stimmt nicht mehr mit der Vorschau überein.");
-      }
-      setImportPlan(plan);
-      setRoomDecisions(Object.fromEntries(plan.sourceRooms.map((room) => [
-        room.sourceRoomKey,
-        { roomId: room.suggestedRoomId, defaultDistributionBoardId: null },
-      ])));
-      setFamilyLinks(Object.fromEntries(plan.familyGroups.map((group) => [
-        group.familyAndType,
-        null,
-      ])));
-    } catch (reason) {
-      setImportPlan(null);
-      setError(reason instanceof Error ? reason.message : "Erstimport konnte nicht geplant werden.");
-    } finally {
-      setIsPlanning(false);
-    }
-  }
-
-  async function handleApplyImport() {
-    if (!file || !importPlan) return;
-    if (!window.confirm(
-      `${importPlan.objectCount} Revit-Objekte jetzt als einen rückgängig machbaren Import übernehmen?`
-    )) return;
-    setIsApplying(true);
-    setError(null);
-    try {
-      const contentBase64 = await fileToBase64(file);
-      const result = await applyExternalInitialImport(projectId, {
-        expectedRevision: currentRevision,
-        expectedConfigurationVersion: importPlan.configurationVersion,
-        expectedSha256: importPlan.sha256,
-        fileName: file.name,
-        contentBase64,
-        sourceName,
-        roomDecisions: importPlan.sourceRooms.map((room) => ({
-          sourceRoomKey: room.sourceRoomKey,
-          roomId: roomDecisions[room.sourceRoomKey]?.roomId ?? null,
-          defaultDistributionBoardId:
-            roomDecisions[room.sourceRoomKey]?.defaultDistributionBoardId ?? null,
-        })),
-        familyProjectDeviceDecisions: importPlan.familyGroups.map((group) => ({
-          familyAndType: group.familyAndType,
-          projectDeviceId: familyLinks[group.familyAndType] ?? null,
-        })),
-      });
-      onRevisionChange(result.history.currentRevision);
-      setSuccess(`${result.import.objectCount} Revit-Objekte wurden übernommen.`);
-      setImportPlan(null);
-      setPreview(null);
-    } catch (reason) {
-      setError(reason instanceof Error ? reason.message : "Erstimport konnte nicht übernommen werden.");
-    } finally {
-      setIsApplying(false);
-    }
-  }
-
-  function updateColumn(key: (typeof columnFields)[number][0], value: string) {
-    setConfiguration((current) => ({
-      ...current,
-      columns: { ...current.columns, [key]: key === "quantity" && !value.trim() ? null : value },
-    }));
-    setPreview(null);
-    setImportPlan(null);
-  }
-
-  async function handleCreateRoom(input: CreateRoomInput) {
-    if (!newRoomSourceKey) return;
-    setIsCreatingCatalogEntry(true);
-    setError(null);
-    try {
-      const result = await onCreateRoom(input);
-      setImportPlan((current) => current ? {
-        ...current,
-        existing: {
-          ...current.existing,
-          rooms: [...current.existing.rooms, result.room],
-        },
-      } : current);
-      setRoomDecisions((current) => ({
-        ...current,
-        [newRoomSourceKey]: {
-          roomId: result.room.id,
-          defaultDistributionBoardId:
-            current[newRoomSourceKey]?.defaultDistributionBoardId ?? null,
-        },
-      }));
-      setNewRoomSourceKey(null);
-    } catch (reason) {
-      setError(reason instanceof Error ? reason.message : "Raum konnte nicht angelegt werden.");
-      setNewRoomSourceKey(null);
-    } finally {
-      setIsCreatingCatalogEntry(false);
-    }
-  }
-
-  async function handleCreateProjectDevice(input: CreateProjectDeviceInput) {
-    if (!newProjectDeviceFamily) return;
-    setIsCreatingCatalogEntry(true);
-    setError(null);
-    try {
-      const result = await onCreateProjectDevice(input);
-      setImportPlan((current) => current ? {
-        ...current,
-        existing: {
-          ...current.existing,
-          projectDevices: [...current.existing.projectDevices, result.projectDevice],
-        },
-      } : current);
-      setFamilyLinks((current) => ({
-        ...current,
-        [newProjectDeviceFamily]: result.projectDevice.id,
-      }));
-      setNewProjectDeviceFamily(null);
-    } catch (reason) {
-      setError(reason instanceof Error ? reason.message : "ProjectDevice konnte nicht angelegt werden.");
-      setNewProjectDeviceFamily(null);
-    } finally {
-      setIsCreatingCatalogEntry(false);
-    }
-  }
-
-  if (newRoomSourceKey && importPlan) {
-    const sourceRoom = importPlan.sourceRooms.find((room) => room.sourceRoomKey === newRoomSourceKey);
-    if (sourceRoom) {
-      return (
-        <RoomModal
-          floors={importPlan.existing.floors.map((floor) => ({ ...floor, projectId }))}
-          initialValues={{ roomNumber: sourceRoom.roomNumber, roomName: sourceRoom.roomName }}
-          isSaving={isCreatingCatalogEntry}
-          onClose={() => setNewRoomSourceKey(null)}
-          onSave={handleCreateRoom}
-        />
-      );
-    }
-  }
-
-  if (newProjectDeviceFamily && importPlan) {
-    const group = importPlan.familyGroups.find((entry) => entry.familyAndType === newProjectDeviceFamily);
-    if (group) {
-      return (
-        <ProjectDeviceModal
-          globalDevices={[]}
-          initialValues={createRevitProjectDevicePrefill(importPlan, group.familyAndType)}
-          isSaving={isCreatingCatalogEntry}
-          onClose={() => setNewProjectDeviceFamily(null)}
-          onImportGlobal={async () => undefined}
-          onSave={handleCreateProjectDevice}
-        />
-      );
-    }
-  }
-
-  return (
-    <FormModal
-      description="Projektweites Mapping speichern und Revit-CSV ohne Datenübernahme prüfen."
-      dialogSize="viewport"
-      isSaving={isSaving || isApplying}
-      onClose={onClose}
-      onSubmit={handleSave}
-      submitDisabled={isLoading || isPreviewing || isPlanning || isApplying || !isDirty}
-      submitLabel="Konfiguration speichern"
-      title="Revit-CSV"
-    >
-      {error ? <div className="alert alert-warning">{error}</div> : null}
-      {success ? <div className="alert alert-success">{success}</div> : null}
-      {isLoading ? <p>Konfiguration wird geladen …</p> : (
-        <div className="d-grid gap-4">
-          <section>
-            <h3 className="h6">Transport</h3>
-            <div className="row g-3">
-              <Field label="Encoding"><select className="form-select" disabled value={configuration.encoding}><option value="utf-8">UTF-8</option></select></Field>
-              <Field label="Trennzeichen"><select className="form-select" value={configuration.delimiter} onChange={(event) => replaceConfiguration({ ...configuration, delimiter: event.target.value as ExternalCsvConfiguration["delimiter"] })}><option value=";">Semikolon (;)</option><option value=",">Komma (,)</option><option value="\t">Tabulator</option></select></Field>
-              <Field label="Dezimaltrennzeichen"><select className="form-select" value={configuration.decimalSeparator} onChange={(event) => replaceConfiguration({ ...configuration, decimalSeparator: event.target.value as "," | "." })}><option value=",">Komma</option><option value=".">Punkt</option></select></Field>
-              <Field label="Leistungseinheit"><select className="form-select" value={configuration.powerUnit} onChange={(event) => replaceConfiguration({ ...configuration, powerUnit: event.target.value as "W" | "kW", wattsPerSourceUnit: event.target.value === "kW" ? 1000 : 1 })}><option value="W">Watt</option><option value="kW">Kilowatt</option></select></Field>
-              <Field label="Umrechnung in Watt"><input className="form-control" min="0.000001" step="any" type="number" value={configuration.wattsPerSourceUnit} onChange={(event) => replaceConfiguration({ ...configuration, wattsPerSourceUnit: Number(event.target.value) })} /></Field>
-            </div>
-          </section>
-
-          <section>
-            <h3 className="h6">Spaltenzuordnung</h3>
-            <div className="row g-3">
-              {columnFields.map(([key, label]) => (
-                <Field key={key} label={label}>
-                  <input className="form-control" value={configuration.columns[key] ?? ""} onChange={(event) => updateColumn(key, event.target.value)} />
-                </Field>
-              ))}
-            </div>
-          </section>
-
-          <AdditionalMappings configuration={configuration} onChange={(additionalSourceMappings) => replaceConfiguration({ ...configuration, additionalSourceMappings })} />
-          <FamilyRules configuration={configuration} onChange={(familyTypeRules) => replaceConfiguration({ ...configuration, familyTypeRules })} />
-
-          <section className="border-top pt-3">
-            <h3 className="h6">CSV prüfen</h3>
-            <p className="small text-secondary">Die Vorschau speichert keine Datei und verändert keine Projektdaten.</p>
-            <div className="d-flex flex-wrap gap-2 align-items-center">
-              <input accept=".csv,text/csv" className="form-control" onChange={(event) => { setFile(event.target.files?.[0] ?? null); setPreview(null); setImportPlan(null); setSuccess(null); }} style={{ maxWidth: 480 }} type="file" />
-              <button className="btn btn-outline-primary" disabled={!file || isDirty || savedConfiguration === null || isPreviewing || isSaving} onClick={handlePreview} type="button">{isPreviewing ? "Wird geprüft …" : "Vorschau erstellen"}</button>
-              <button className="btn btn-primary" disabled={!preview || isDirty || isPlanning || isPreviewing || isSaving} onClick={handlePlanImport} type="button">{isPlanning ? "Wird geplant …" : "Erstimport planen"}</button>
-            </div>
-            {isDirty ? <div className="form-text">Vor der Vorschau muss die Konfiguration gespeichert werden.</div> : null}
-          </section>
-
-          {preview ? <PreviewResult preview={preview} /> : null}
-          {importPlan ? (
-            <RevitCsvImportPlan
-              familyLinks={familyLinks}
-              isApplying={isApplying}
-              onApply={handleApplyImport}
-              onCreateProjectDevice={setNewProjectDeviceFamily}
-              onCreateRoom={setNewRoomSourceKey}
-              onFamilyLinkChange={(familyAndType, projectDeviceId) => setFamilyLinks((current) => ({ ...current, [familyAndType]: projectDeviceId }))}
-              onRoomDecisionChange={(sourceRoomKey, decision) => setRoomDecisions((current) => ({ ...current, [sourceRoomKey]: decision }))}
-              plan={importPlan}
-              roomDecisions={roomDecisions}
-              setSourceName={setSourceName}
-              sourceName={sourceName}
-            />
-          ) : null}
-        </div>
-      )}
-    </FormModal>
-  );
-}
-
-function Field({ children, label }: { children: React.ReactNode; label: string }) {
-  return <label className="col-12 col-md-6"><span className="form-label">{label}</span>{children}</label>;
-}
-
-function AdditionalMappings({ configuration, onChange }: { configuration: ExternalCsvConfiguration; onChange: (value: ExternalCsvConfiguration["additionalSourceMappings"]) => void }) {
-  return <section><div className="d-flex justify-content-between align-items-center"><h3 className="h6 mb-0">Weitere Quellfelder</h3><button className="btn btn-sm btn-outline-secondary" onClick={() => onChange([...configuration.additionalSourceMappings, { sourceColumn: "", targetField: "" }])} type="button">Zuordnung hinzufügen</button></div><div className="d-grid gap-2 mt-2">{configuration.additionalSourceMappings.map((mapping, index) => <div className="row g-2" key={index}><div className="col"><input aria-label={`Quellspalte ${index + 1}`} className="form-control" placeholder="CSV-Spalte" value={mapping.sourceColumn} onChange={(event) => onChange(configuration.additionalSourceMappings.map((entry, entryIndex) => entryIndex === index ? { ...entry, sourceColumn: event.target.value } : entry))} /></div><div className="col"><input aria-label={`Zielfeld ${index + 1}`} className="form-control" placeholder="Internes Zielfeld" value={mapping.targetField} onChange={(event) => onChange(configuration.additionalSourceMappings.map((entry, entryIndex) => entryIndex === index ? { ...entry, targetField: event.target.value } : entry))} /></div><div className="col-auto"><button aria-label={`Zuordnung ${index + 1} entfernen`} className="btn btn-outline-danger" onClick={() => onChange(configuration.additionalSourceMappings.filter((_, entryIndex) => entryIndex !== index))} type="button">Entfernen</button></div></div>)}</div></section>;
-}
-
-function FamilyRules({ configuration, onChange }: { configuration: ExternalCsvConfiguration; onChange: (value: ExternalCsvFamilyTypeRule[]) => void }) {
-  const rules = configuration.familyTypeRules;
-  function change(index: number, patch: Partial<ExternalCsvFamilyTypeRule>) { onChange(rules.map((rule, ruleIndex) => ruleIndex === index ? { ...rule, ...patch } : rule)); }
-  return <section><div className="d-flex justify-content-between align-items-center"><div><h3 className="h6 mb-0">Familie-und-Typ-Regeln</h3><div className="form-text">Exakter Textvergleich; Reihenfolge wird beibehalten.</div></div><button className="btn btn-sm btn-outline-secondary" onClick={() => onChange([...rules, { exactFamilyAndType: "", internalDeviceType: "", connectionKind: null, category: "single_phase", quantityRule: { kind: "fixed", quantity: 1 }, displayNameSuggestion: null }])} type="button">Regel hinzufügen</button></div><div className="d-grid gap-3 mt-2">{rules.map((rule, index) => <div className="border rounded p-3" key={index}><div className="row g-2"><Field label="Exakter Familie-und-Typ-Wert"><input className="form-control" value={rule.exactFamilyAndType} onChange={(event) => change(index, { exactFamilyAndType: event.target.value })} /></Field><Field label="Interner Gerätetyp"><input className="form-control" value={rule.internalDeviceType} onChange={(event) => change(index, { internalDeviceType: event.target.value })} /></Field><Field label="Anschlussart (optional)"><input className="form-control" value={rule.connectionKind ?? ""} onChange={(event) => change(index, { connectionKind: event.target.value || null })} /></Field><Field label="Kategorie"><select className="form-select" value={rule.category} onChange={(event) => change(index, { category: event.target.value as ExternalCsvFamilyTypeRule["category"] })}><option value="lighting">Beleuchtung</option><option value="single_phase">1-phasig</option><option value="three_phase">3-phasig</option></select></Field><Field label="Mengenregel"><select className="form-select" value={rule.quantityRule.kind} onChange={(event) => change(index, { quantityRule: event.target.value === "mapped-column" ? { kind: "mapped-column" } : { kind: "fixed", quantity: 1 } })}><option value="fixed">Feste Menge</option><option disabled={configuration.columns.quantity === null} value="mapped-column">Aus Mengenspalte</option></select></Field>{rule.quantityRule.kind === "fixed" ? <Field label="Feste Menge"><input className="form-control" min="0.001" step="any" type="number" value={rule.quantityRule.quantity} onChange={(event) => change(index, { quantityRule: { kind: "fixed", quantity: Number(event.target.value) } })} /></Field> : null}<Field label="Anzeigename vorschlagen aus"><select className="form-select" value={rule.displayNameSuggestion?.kind ?? "none"} onChange={(event) => change(index, { displayNameSuggestion: event.target.value === "none" ? null : event.target.value === "fixed" ? { kind: "fixed", value: "" } : { kind: event.target.value as "selection-marker" | "family-and-type" } })}><option value="none">Kein Vorschlag</option><option value="selection-marker">CAx-Auswahlkenner</option><option value="family-and-type">Familie und Typ</option><option value="fixed">Fester Text</option></select></Field>{rule.displayNameSuggestion?.kind === "fixed" ? <Field label="Fester Anzeigename"><input className="form-control" value={rule.displayNameSuggestion.value} onChange={(event) => change(index, { displayNameSuggestion: { kind: "fixed", value: event.target.value } })} /></Field> : null}</div><button className="btn btn-sm btn-outline-danger mt-2" onClick={() => onChange(rules.filter((_, ruleIndex) => ruleIndex !== index))} type="button">Regel entfernen</button></div>)}</div></section>;
-}
-
-function PreviewResult({ preview }: { preview: ExternalCsvPreviewDto }) {
-  const visibleObjects = useMemo(() => preview.objects.slice(0, 25), [preview]);
-  return <section className="border-top pt-3"><h3 className="h6">Prüfergebnis</h3><div className="row g-2 mb-3"><Stat label="Objekte" value={preview.objectCount} /><Stat label="Passthrough-Zeilen" value={preview.passthroughCount} /><Stat label="Verdachtszeilen" value={preview.suspectObjectCount} /><Stat label="Kopfzeile" value={preview.headerRowNumber} /></div><p className="small text-secondary text-break mb-2">SHA-256: {preview.sha256}</p><div className="table-responsive"><table className="table table-sm"><thead><tr><th>Zeile</th><th>IFC-GUID</th><th>Raum</th><th>Familie und Typ</th><th>Auswahlkenner</th><th>Stromkreis</th></tr></thead><tbody>{visibleObjects.map((object) => <tr key={object.ifcGuid}><td>{object.rowNumber}</td><td><code>{object.ifcGuid}</code></td><td>{[object.roomNumber, object.roomName].filter(Boolean).join(" · ") || "–"}</td><td>{object.familyAndType || "–"}</td><td>{object.selectionMarker || "–"}</td><td>{object.circuitIdentifier || "–"}</td></tr>)}</tbody></table></div>{preview.objects.length > visibleObjects.length ? <p className="small text-secondary">Es werden die ersten {visibleObjects.length} von {preview.objects.length} Objekten angezeigt.</p> : null}</section>;
-}
-
-interface RoomDecision {
-  roomId: string | null;
-  defaultDistributionBoardId: string | null;
-}
-
-export function RevitCsvImportPlan({
-  familyLinks,
-  isApplying,
-  onApply,
-  onCreateProjectDevice,
-  onCreateRoom,
-  onFamilyLinkChange,
-  onRoomDecisionChange,
-  plan,
-  roomDecisions,
-  setSourceName,
-  sourceName,
-}: {
-  familyLinks: Record<string, string | null>;
-  isApplying: boolean;
-  onApply: () => void;
-  onCreateProjectDevice: (familyAndType: string) => void;
-  onCreateRoom: (sourceRoomKey: string) => void;
-  onFamilyLinkChange: (familyAndType: string, projectDeviceId: string | null) => void;
-  onRoomDecisionChange: (sourceRoomKey: string, decision: RoomDecision) => void;
-  plan: ExternalInitialImportPlanDto;
-  roomDecisions: Record<string, RoomDecision>;
-  setSourceName: (value: string) => void;
-  sourceName: string;
-}) {
-  const hasBlockingIssues = plan.issueCounts.unknownFamilyAndType > 0;
-  const warningCount =
-    plan.issueCounts.invalidPower +
-    plan.issueCounts.invalidQuantity +
-    plan.issueCounts.missingRoom +
-    plan.suspectObjectCount;
-  const floorsById = new Map(plan.existing.floors.map((floor) => [floor.id, floor]));
-
-  return (
-    <section className="border-top pt-3">
-      <div className="d-flex flex-wrap justify-content-between gap-2 align-items-start">
-        <div>
-          <h3 className="h6 mb-1">Erstimport vorbereiten</h3>
-          <p className="small text-secondary mb-0">
-            Raum- und Gerätekatalog-Zuordnungen werden zusammen mit {plan.objectCount} Revit-Objekten gespeichert.
-            Stromkreise und Gerätezeilen entstehen dabei noch nicht.
-          </p>
-        </div>
-        <span className="badge text-bg-secondary">Konfiguration {plan.configurationVersion}</span>
-      </div>
-
-      <div className="row g-2 my-2">
-        <Stat label="Quellräume" value={plan.sourceRooms.length} />
-        <Stat label="Familien/Typen" value={plan.familyGroups.length} />
-        <Stat label="Objekte" value={plan.objectCount} />
-        <Stat label="Hinweise" value={warningCount} />
-      </div>
-
-      {hasBlockingIssues ? (
-        <div className="alert alert-danger">
-          {plan.issueCounts.unknownFamilyAndType} Objekte besitzen noch keine exakte Familie-und-Typ-Regel.
-          Ergänze die Regeln oben, speichere die Konfiguration und plane den Import erneut.
-        </div>
-      ) : null}
-      {plan.issueCounts.invalidPower > 0 ? <div className="alert alert-warning py-2">Bei {plan.issueCounts.invalidPower} Objekten ist die Leistung ungültig.</div> : null}
-      {plan.issueCounts.invalidQuantity > 0 ? <div className="alert alert-warning py-2">Bei {plan.issueCounts.invalidQuantity} Objekten ist die Menge ungültig.</div> : null}
-      {plan.issueCounts.missingRoom > 0 ? <div className="alert alert-warning py-2">{plan.issueCounts.missingRoom} Objekte besitzen keine Raumangabe.</div> : null}
-      {plan.suspectObjectCount > 0 ? <div className="alert alert-warning py-2">{plan.suspectObjectCount} Objektzeilen wurden als verdächtig erkannt.</div> : null}
-
-      <label className="form-label mt-2" style={{ maxWidth: 520 }}>
-        <span>Bezeichnung des externen Modells</span>
-        <input
-          className="form-control"
-          onChange={(event) => setSourceName(event.target.value)}
-          value={sourceName}
-        />
-      </label>
-
-      <h4 className="h6 mt-4">Räume zuordnen</h4>
-      <div className="table-responsive">
-        <table className="table table-sm align-middle">
-          <thead><tr><th>Quellraum</th><th>Objekte</th><th>Treffer</th><th>Interner Raum</th><th>Standardverteilung</th></tr></thead>
-          <tbody>
-            {plan.sourceRooms.map((sourceRoom) => {
-              const decision = roomDecisions[sourceRoom.sourceRoomKey] ?? {
-                roomId: sourceRoom.suggestedRoomId,
-                defaultDistributionBoardId: null,
-              };
-              return (
-                <tr key={sourceRoom.sourceRoomKey}>
-                  <td>{[sourceRoom.roomNumber, sourceRoom.roomName].filter(Boolean).join(" · ")}</td>
-                  <td>{sourceRoom.objectCount}</td>
-                  <td><RoomMatchBadge status={sourceRoom.matchStatus} /></td>
-                  <td>
-                    <div className="input-group input-group-sm">
-                      <select
-                        aria-label={`Interner Raum für ${sourceRoom.roomNumber || sourceRoom.roomName}`}
-                        className="form-select"
-                        onChange={(event) => onRoomDecisionChange(sourceRoom.sourceRoomKey, {
-                          ...decision,
-                          roomId: event.target.value || null,
-                        })}
-                        value={decision.roomId ?? ""}
-                      >
-                        <option value="">Nicht verknüpfen</option>
-                        {plan.existing.rooms.map((room) => {
-                          const floor = room.floorId ? floorsById.get(room.floorId) : null;
-                          return <option key={room.id} value={room.id}>{room.roomNumber} · {room.roomName}{floor ? ` (${floor.name})` : ""}</option>;
-                        })}
-                      </select>
-                      <button
-                        aria-label={`Raum ${sourceRoom.roomNumber || sourceRoom.roomName} neu anlegen`}
-                        className="btn btn-outline-secondary"
-                        onClick={() => onCreateRoom(sourceRoom.sourceRoomKey)}
-                        type="button"
-                      >
-                        Neu
-                      </button>
-                    </div>
-                  </td>
-                  <td>
-                    <select
-                      aria-label={`Standardverteilung für ${sourceRoom.roomNumber || sourceRoom.roomName}`}
-                      className="form-select form-select-sm"
-                      onChange={(event) => onRoomDecisionChange(sourceRoom.sourceRoomKey, {
-                        ...decision,
-                        defaultDistributionBoardId: event.target.value || null,
-                      })}
-                      value={decision.defaultDistributionBoardId ?? ""}
-                    >
-                      <option value="">Keine Standardverteilung</option>
-                      {plan.existing.distributionBoards.map((board) => <option key={board.id} value={board.id}>{board.name}</option>)}
-                    </select>
-                  </td>
-                </tr>
-              );
-            })}
-          </tbody>
-        </table>
-      </div>
-
-      <h4 className="h6 mt-4">Familien und Typen zuordnen</h4>
-      <div className="table-responsive">
-        <table className="table table-sm align-middle">
-          <thead><tr><th>Familie und Typ</th><th>Objekte</th><th>Klassifizierung</th><th>ProjectDevice (optional)</th></tr></thead>
-          <tbody>
-            {plan.familyGroups.map((group) => (
-              <tr key={group.familyAndType}>
-                <td>{group.familyAndType || "–"}</td>
-                <td>{group.objectCount}</td>
-                <td>
-                  {group.classified
-                    ? `${group.internalDeviceType ?? "–"} · ${categoryLabel(group.category)}`
-                    : <span className="badge text-bg-danger">Regel fehlt</span>}
-                </td>
-                <td>
-                  <div className="input-group input-group-sm">
-                    <select
-                      aria-label={`ProjectDevice für ${group.familyAndType}`}
-                      className="form-select"
-                      onChange={(event) => onFamilyLinkChange(group.familyAndType, event.target.value || null)}
-                      value={familyLinks[group.familyAndType] ?? ""}
-                    >
-                      <option value="">Nicht verknüpfen</option>
-                      {plan.existing.projectDevices.map((device) => (
-                        <option key={device.id} value={device.id}>{device.displayName || device.name} · {categoryLabel(device.category)}</option>
-                      ))}
-                    </select>
-                    <button
-                      aria-label={`ProjectDevice für ${group.familyAndType} neu anlegen`}
-                      className="btn btn-outline-secondary"
-                      disabled={!group.classified}
-                      onClick={() => onCreateProjectDevice(group.familyAndType)}
-                      type="button"
-                    >
-                      Neu
-                    </button>
-                  </div>
-                </td>
-              </tr>
-            ))}
-          </tbody>
-        </table>
-      </div>
-
-      <div className="d-flex justify-content-end mt-3">
-        <button
-          className="btn btn-primary"
-          disabled={hasBlockingIssues || isApplying || !sourceName.trim()}
-          onClick={onApply}
-          type="button"
-        >
-          {isApplying ? "Import wird übernommen …" : "Erstimport übernehmen"}
-        </button>
-      </div>
-    </section>
-  );
-}
-
-function RoomMatchBadge({ status }: { status: ExternalInitialImportPlanDto["sourceRooms"][number]["matchStatus"] }) {
-  if (status === "exact-number") return <span className="badge text-bg-success">Eindeutig</span>;
-  if (status === "ambiguous-number") return <span className="badge text-bg-warning">Mehrdeutig</span>;
-  return <span className="badge text-bg-secondary">Neu</span>;
-}
-
-function categoryLabel(category: string | null) {
-  if (category === "lighting") return "Beleuchtung";
-  if (category === "single_phase") return "1-phasig";
-  if (category === "three_phase") return "3-phasig";
-  return "Ohne Kategorie";
-}
-
-export function createRevitProjectDevicePrefill(
-  plan: ExternalInitialImportPlanDto,
-  familyAndType: string
-): Partial<CreateProjectDeviceInput> {
-  const group = plan.familyGroups.find((entry) => entry.familyAndType === familyAndType);
-  const firstObject = plan.objects.find(
-    (object) => object.sourceValues.familyAndType === familyAndType
-  );
-  const category = group?.category;
-  return {
-    name: group?.internalDeviceType || familyAndType || "Revit-Gerät",
-    displayName: firstObject?.suggestedPlanningValues.displayName || familyAndType,
-    connectionKind: group?.connectionKind ?? undefined,
-    category:
-      category === "lighting" || category === "three_phase"
-        ? category
-        : "single_phase",
-    quantity: firstObject?.suggestedPlanningValues.effectiveQuantity ?? 1,
-    powerPerUnit:
-      firstObject?.suggestedPlanningValues.powerPerUnitW === null ||
-      firstObject?.suggestedPlanningValues.powerPerUnitW === undefined
-        ? 0.1
-        : firstObject.suggestedPlanningValues.powerPerUnitW / 1000,
-    simultaneityFactor:
-      firstObject?.suggestedPlanningValues.simultaneityFactor ?? 1,
-    cosPhi: firstObject?.suggestedPlanningValues.cosPhi ?? undefined,
-    costGroup: firstObject?.suggestedPlanningValues.costGroup ?? undefined,
-    remark: firstObject?.suggestedPlanningValues.remark ?? undefined,
-  };
-}
-
-function Stat({ label, value }: { label: string; value: number }) { return <div className="col-6 col-lg-3"><div className="border rounded p-2"><div className="small text-secondary">{label}</div><strong>{value}</strong></div></div>; }
-
-function fileToBase64(file: File) {
-  return new Promise<string>((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onerror = () => reject(new Error("CSV-Datei konnte nicht gelesen werden."));
-    reader.onload = () => {
-      const result = String(reader.result ?? "");
-      const commaIndex = result.indexOf(",");
-      if (commaIndex < 0) reject(new Error("CSV-Datei konnte nicht kodiert werden."));
-      else resolve(result.slice(commaIndex + 1));
-    };
-    reader.readAsDataURL(file);
-  });
-}
diff --git a/src/frontend/components/revit-xlsx-settings-modal.tsx b/src/frontend/components/revit-xlsx-settings-modal.tsx
new file mode 100644
index 0000000..7041ebc
--- /dev/null
+++ b/src/frontend/components/revit-xlsx-settings-modal.tsx
@@ -0,0 +1,45 @@
+"use client";
+
+import { useState, type FormEvent } from "react";
+import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration";
+import type { ExternalXlsxColumnKey } from "../../external-model/xlsx/external-xlsx-contracts";
+import { FormModal } from "./form-modal";
+
+const labels: Record<ExternalXlsxColumnKey, string> = {
+  worksharingId: "Worksharing-ID", ifcGuid: "IfcGUID", roomNumber: "Raumnummer",
+  roomName: "Raumname", familyAndType: "Familie und Typ", selectionMarker: "Auswahlkenner",
+  socketCount: "Anzahl Objekte", sourceRemark: "Quellbemerkung", circuitCombined: "Stromkreis kombiniert",
+  boardName: "Verteiler", circuitIdentifier: "Stromkreis", designation: "Bezeichnung",
+  electricalPowerW: "Elektrische Leistung", voltageV: "Spannung", currentA: "Stromstärke",
+};
+
+export function RevitXlsxSettingsModal({ configuration, isSaving, onClose, onInspectSample, onSave }: {
+  configuration: ExternalModelConfiguration;
+  isSaving: boolean;
+  onClose: () => void;
+  onInspectSample: (file: File, configuration: ExternalModelConfiguration) => Promise<string>;
+  onSave: (configuration: ExternalModelConfiguration) => Promise<void>;
+}) {
+  const [draft, setDraft] = useState(() => structuredClone(configuration));
+  const [sampleStatus, setSampleStatus] = useState<string | null>(null);
+  const columnKeys = Object.keys(draft.columns) as ExternalXlsxColumnKey[];
+
+  async function inspectSample(file: File | undefined) {
+    if (!file) return;
+    try {
+      setSampleStatus(await onInspectSample(file, draft));
+    } catch (error) {
+      setSampleStatus(error instanceof Error ? error.message : "Musterdatei konnte nicht gelesen werden.");
+    }
+  }
+
+  return <FormModal title="Revit-XLSX-Einstellungen" description="Layout und Spalten der Linear-Bauteilliste" isSaving={isSaving} onClose={onClose} submitDisabled={JSON.stringify(draft) === JSON.stringify(configuration)} submitLabel="Einstellungen speichern" onSubmit={(event: FormEvent) => { event.preventDefault(); void onSave(draft); }}>
+    <div className="row g-3">
+      <div className="col-12"><label className="form-label" htmlFor="revit-sample">Musterdatei prüfen</label><input id="revit-sample" className="form-control" type="file" accept=".xlsx" onChange={(event) => void inspectSample(event.target.files?.[0])} />{sampleStatus ? <div className="form-text">{sampleStatus}</div> : null}</div>
+      {(["headerRow", "firstDataRow", "firstDataColumn"] as const).map((key) => <div className="col-md-4" key={key}><label className="form-label" htmlFor={`layout-${key}`}>{key === "headerRow" ? "Kopfzeile" : key === "firstDataRow" ? "Erste Datenzeile" : "Erste Datenspalte"}</label><input id={`layout-${key}`} className="form-control" min={1} type="number" value={draft.layout[key]} onChange={(event) => setDraft({ ...draft, layout: { ...draft.layout, [key]: Number(event.target.value) } })} /></div>)}
+      <div className="col-12"><label className="form-label" htmlFor="circuit-mode">Stromkreisspalten</label><select id="circuit-mode" className="form-select" value={draft.circuitMode} onChange={(event) => setDraft({ ...draft, circuitMode: event.target.value as ExternalModelConfiguration["circuitMode"] })}><option value="combined">Kombinierte Stromkreisspalte</option><option value="separate">Verteiler und Stromkreis getrennt</option></select></div>
+      <div className="col-12"><h3 className="fs-6 mb-0">Spaltenzuordnung</h3></div>
+      {columnKeys.map((key) => <div className="col-md-6" key={key}><label className="form-label" htmlFor={`column-${key}`}>{labels[key]}</label><input id={`column-${key}`} className="form-control" value={draft.columns[key] ?? ""} onChange={(event) => setDraft({ ...draft, columns: { ...draft.columns, [key]: event.target.value.trim() ? event.target.value : null } })} /></div>)}
+    </div>
+  </FormModal>;
+}
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 96fd6c2..401b618 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -14,6 +14,13 @@ import type {
   ExternalCsvConfiguration,
   ExternalCsvDialect,
 } from "../external-model/csv/external-csv-contracts";
+import type { ExternalModelConfiguration } from "../external-model/configuration/external-model-configuration";
+
+export interface ExternalModelConfigurationSnapshotDto {
+  id: string;
+  projectId: string;
+  configuration: ExternalModelConfiguration;
+}
 
 export interface ExternalCsvConfigurationSnapshotDto {
   id: string;
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index 5256195..3694c2e 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -38,18 +38,14 @@ import type {
   RoomDto,
   CircuitTreeResponseDto,
   ProjectCircuitTreesResponseDto,
-  ExternalCsvConfigurationSnapshotDto,
-  ExternalCsvPreviewDto,
-  ExternalInitialImportPlanDto,
-  ApplyExternalInitialImportInput,
-  ExternalInitialImportResultDto,
+  ExternalModelConfigurationSnapshotDto,
   CreateEstimateBalanceInput,
   EstimateBalanceCommandResultDto,
   EstimateBalanceDto,
   EstimateBalanceUpdateResultDto,
   EstimateComparisonDto,
 } from "../types";
-import type { ExternalCsvConfiguration } from "../../external-model/csv/external-csv-contracts";
+import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration";
 import type { ProjectDeviceSyncField } from "../../shared/constants/project-device-sync-fields";
 import {
   createCircuitUpdateProjectCommand,
@@ -168,6 +164,40 @@ export function getProject(projectId: string) {
   return request<ProjectDto>(`/api/projects/${projectId}`);
 }
 
+export function getExternalModelConfiguration(projectId: string) {
+  return request<{ configuration: ExternalModelConfigurationSnapshotDto | null }>(
+    `/api/projects/${projectId}/external-model/configuration`
+  );
+}
+
+export function updateExternalModelConfiguration(
+  projectId: string,
+  expectedRevision: number,
+  configuration: ExternalModelConfiguration
+) {
+  return request<{
+    configuration: ExternalModelConfigurationSnapshotDto;
+    history: ProjectHistoryStateDto;
+  }>(`/api/projects/${projectId}/external-model/configuration`, {
+    method: "PUT",
+    body: JSON.stringify({ expectedRevision, configuration }),
+  });
+}
+
+export async function detectExternalModelWorkbook(
+  projectId: string,
+  file: File,
+  configuration: ExternalModelConfiguration
+) {
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return request<{ sheetName: string; columnCount: number; objectCount: number }>(
+    `/api/projects/${projectId}/external-model/configuration/detect`,
+    { method: "POST", body: JSON.stringify({ fileName: file.name, contentBase64: btoa(binary), configuration }) }
+  );
+}
+
 export function getProjectHistory(projectId: string) {
   return request<ProjectHistoryStateDto>(
     `/api/projects/${projectId}/history`
@@ -469,12 +499,6 @@ export function deleteDocumentLogo() {
   return request<void>(documentLogoUrl, { method: "DELETE" });
 }
 
-export function getExternalCsvConfiguration(projectId: string) {
-  return request<{ configuration: ExternalCsvConfigurationSnapshotDto | null }>(
-    `/api/projects/${projectId}/external-csv/configuration`
-  );
-}
-
 export function getExternalCircuitListObjects(
   projectId: string,
   circuitListId: string
@@ -484,57 +508,6 @@ export function getExternalCircuitListObjects(
   );
 }
 
-export function updateExternalCsvConfiguration(
-  projectId: string,
-  expectedRevision: number,
-  configuration: ExternalCsvConfiguration
-) {
-  return request<
-    ProjectCommandResultDto & { configuration: ExternalCsvConfigurationSnapshotDto }
-  >(`/api/projects/${projectId}/external-csv/configuration`, {
-    method: "PUT",
-    body: JSON.stringify({ expectedRevision, configuration }),
-  });
-}
-
-export function previewExternalCsv(
-  projectId: string,
-  fileName: string,
-  contentBase64: string
-) {
-  return request<ExternalCsvPreviewDto>(
-    `/api/projects/${projectId}/external-csv/preview`,
-    {
-      method: "POST",
-      body: JSON.stringify({ fileName, contentBase64 }),
-    }
-  );
-}
-
-export function planExternalInitialImport(
-  projectId: string,
-  fileName: string,
-  contentBase64: string
-) {
-  return request<ExternalInitialImportPlanDto>(
-    `/api/projects/${projectId}/external-csv/initial-import/plan`,
-    {
-      method: "POST",
-      body: JSON.stringify({ fileName, contentBase64 }),
-    }
-  );
-}
-
-export function applyExternalInitialImport(
-  projectId: string,
-  input: ApplyExternalInitialImportInput
-) {
-  return request<ExternalInitialImportResultDto>(
-    `/api/projects/${projectId}/external-csv/initial-import/apply`,
-    { method: "POST", body: JSON.stringify(input) }
-  );
-}
-
 export function copyDistributionBoard(
   projectId: string,
   distributionBoardId: string,
diff --git a/src/frontend/utils/project-version-history.ts b/src/frontend/utils/project-version-history.ts
index eb195d0..6a191cb 100644
--- a/src/frontend/utils/project-version-history.ts
+++ b/src/frontend/utils/project-version-history.ts
@@ -62,6 +62,7 @@ const commandTypeLabels: Record<string, string> = {
   "project.restore-state": "Projektstand wiederhergestellt",
   "circuit-protection.update": "Stromkreisschutz bearbeitet",
   "external-csv-configuration.update": "Revit-CSV-Konfiguration bearbeitet",
+  "external-model-configuration.update": "Revit-XLSX-Einstellungen bearbeitet",
   "external-import.apply-initial": "Revit-Erstimport übernommen",
   "external-object.assign-to-new-circuit":
     "Externes Objekt in neuen Stromkreis übernommen",
diff --git a/src/frontend/utils/revit-xlsx-settings.ts b/src/frontend/utils/revit-xlsx-settings.ts
new file mode 100644
index 0000000..6c05c14
--- /dev/null
+++ b/src/frontend/utils/revit-xlsx-settings.ts
@@ -0,0 +1,17 @@
+import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration";
+
+export function createDefaultRevitXlsxConfiguration(): ExternalModelConfiguration {
+  return {
+    schemaVersion: 1,
+    layout: { headerRow: 1, firstDataRow: 3, firstDataColumn: 1 },
+    circuitMode: "combined",
+    columns: {
+      worksharingId: "Worksharing-ID", ifcGuid: "IfcGUID", roomNumber: "MEP-Raum: Nummer",
+      roomName: "MEP-Raum: Name", familyAndType: "Familie und Typ", selectionMarker: "CAx_Auswahlkenner",
+      socketCount: "CAX_AnzahlObjekte", sourceRemark: "CAx_Anmerkung", circuitCombined: "kbp_Stromkreisnummer",
+      boardName: "kbp-E-Verteiler", circuitIdentifier: "kbp-E-Stromkreis", designation: "kbp-E-Bezeichnung",
+      electricalPowerW: "kbp-E-Elektrische Leistung", voltageV: "kbp-E-Spannung", currentA: "kbp-E-Stromstärke",
+    },
+    deviceTypes: [], familyTypeRules: [],
+  };
+}
diff --git a/src/server/controllers/external-model-configuration.controller.ts b/src/server/controllers/external-model-configuration.controller.ts
new file mode 100644
index 0000000..0a4166a
--- /dev/null
+++ b/src/server/controllers/external-model-configuration.controller.ts
@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+import type { Request, Response } from "express";
+import { createExternalModelConfigurationUpdateProjectCommand } from "../../domain/models/external-model-configuration-project-command.model.js";
+import { assertExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
+import { parseExternalXlsx } from "../../external-model/xlsx/external-xlsx-transport.js";
+import { externalModelConfigurationRepository } from "../composition/application-repositories.js";
+import { projectCommandService } from "../composition/project-command-stores.js";
+import { respondWithProjectCommandError } from "./project-command.controller.js";
+
+export function getExternalModelConfiguration(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  const result = externalModelConfigurationRepository.getByProject(projectId);
+  if (!result.projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+  return res.json({ configuration: result.configuration });
+}
+
+export function updateExternalModelConfiguration(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  const expectedRevision = req.body?.expectedRevision;
+  if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) {
+    return res.status(400).json({ error: "Ungültige Projektrevision." });
+  }
+  try {
+    assertExternalModelConfiguration(req.body?.configuration);
+    const current = externalModelConfigurationRepository.getByProject(projectId);
+    if (!current.projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    const target = {
+      id: current.configuration?.id ?? randomUUID(),
+      projectId,
+      configuration: req.body.configuration,
+    };
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision,
+      description: "Revit-XLSX-Einstellungen gespeichert",
+      command: createExternalModelConfigurationUpdateProjectCommand(current.configuration, target),
+    });
+    return res.json({ configuration: target, history: result.history });
+  } catch (error) {
+    return respondWithProjectCommandError(error, res);
+  }
+}
+
+export async function detectExternalModelWorkbook(req: Request, res: Response) {
+  try {
+    assertExternalModelConfiguration(req.body?.configuration);
+    const document = await parseExternalXlsx({
+      fileName: req.body?.fileName,
+      bytes: Buffer.from(req.body?.contentBase64 ?? "", "base64"),
+      configuration: req.body.configuration,
+    });
+    return res.json({
+      sheetName: document.sheetName,
+      columnCount: document.columns.length,
+      objectCount: document.rows.filter((row) => row.classification === "object").length,
+    });
+  } catch (error) {
+    return res.status(400).json({ error: error instanceof Error ? error.message : "Musterdatei konnte nicht gelesen werden." });
+  }
+}
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index 06f9ec2..d0ca12d 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -53,6 +53,11 @@ import {
   importProjectTransfer,
   importProjectTransferAsNewProject,
 } from "../controllers/project-transfer.controller.js";
+import {
+  getExternalModelConfiguration,
+  detectExternalModelWorkbook,
+  updateExternalModelConfiguration,
+} from "../controllers/external-model-configuration.controller.js";
 
 export const projectRouter = Router();
 
@@ -74,6 +79,9 @@ projectRouter.post(
   restoreProjectSnapshot
 );
 projectRouter.put("/:projectId", updateProjectSettings);
+projectRouter.get("/:projectId/external-model/configuration", getExternalModelConfiguration);
+projectRouter.put("/:projectId/external-model/configuration", updateExternalModelConfiguration);
+projectRouter.post("/:projectId/external-model/configuration/detect", detectExternalModelWorkbook);
 projectRouter.get("/:projectId/distribution-boards", listDistributionBoardsByProject);
 projectRouter.post("/:projectId/distribution-boards", createDistributionBoard);
 projectRouter.post(
diff --git a/tests/revit-csv-frontend-api.test.ts b/tests/revit-csv-frontend-api.test.ts
deleted file mode 100644
index add2eb7..0000000
--- a/tests/revit-csv-frontend-api.test.ts
+++ /dev/null
@@ -1,251 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { createElement } from "react";
-import { renderToStaticMarkup } from "react-dom/server";
-import {
-  createRevitProjectDevicePrefill,
-  RevitCsvImportPlan,
-  RevitCsvModal,
-} from "../src/frontend/components/revit-csv-modal.js";
-import { ProjectDeviceModal } from "../src/frontend/components/project-device-modal.js";
-import { RoomModal } from "../src/frontend/components/room-modal.js";
-import {
-  applyExternalInitialImport,
-  getExternalCsvConfiguration,
-  getExternalCircuitListObjects,
-  planExternalInitialImport,
-  previewExternalCsv,
-  updateExternalCsvConfiguration,
-} from "../src/frontend/utils/api.js";
-import type { ExternalInitialImportPlanDto } from "../src/frontend/types.js";
-import { createDefaultExternalCsvConfiguration } from "../src/external-model/csv/external-csv-contracts.js";
-import { externalCsvTestColumns } from "./fixtures/revit-csv-fixtures.js";
-
-describe("Revit CSV frontend API", () => {
-  it("uses the project-scoped configuration, preview and import endpoints", async () => {
-    const requests: Array<{ url: string; method: string; body: unknown }> = [];
-    const originalFetch = globalThis.fetch;
-    globalThis.fetch = async (input, init) => {
-      requests.push({
-        url: String(input),
-        method: init?.method ?? "GET",
-        body: init?.body ? JSON.parse(String(init.body)) : null,
-      });
-      return new Response(JSON.stringify({ configuration: null }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    };
-    const configuration = createDefaultExternalCsvConfiguration(externalCsvTestColumns);
-
-    try {
-      await getExternalCsvConfiguration("project-1");
-      await getExternalCircuitListObjects("project-1", "list-1");
-      await updateExternalCsvConfiguration("project-1", 7, configuration);
-      await previewExternalCsv("project-1", "revit.csv", "YWJj");
-      await planExternalInitialImport("project-1", "revit.csv", "YWJj");
-      await applyExternalInitialImport("project-1", {
-        expectedRevision: 8,
-        expectedConfigurationVersion: 2,
-        expectedSha256: "sha",
-        fileName: "revit.csv",
-        contentBase64: "YWJj",
-        sourceName: "Revit-Gesamtmodell",
-        roomDecisions: [{ sourceRoomKey: "101|büro", roomId: "room-1", defaultDistributionBoardId: "board-1" }],
-        familyProjectDeviceDecisions: [{ familyAndType: "Steckdose : Standard", projectDeviceId: "device-1" }],
-      });
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-
-    assert.deepEqual(requests, [
-      {
-        url: "/api/projects/project-1/external-csv/configuration",
-        method: "GET",
-        body: null,
-      },
-      {
-        url: "/api/projects/project-1/circuit-lists/list-1/external-objects",
-        method: "GET",
-        body: null,
-      },
-      {
-        url: "/api/projects/project-1/external-csv/configuration",
-        method: "PUT",
-        body: { expectedRevision: 7, configuration },
-      },
-      {
-        url: "/api/projects/project-1/external-csv/preview",
-        method: "POST",
-        body: { fileName: "revit.csv", contentBase64: "YWJj" },
-      },
-      {
-        url: "/api/projects/project-1/external-csv/initial-import/plan",
-        method: "POST",
-        body: { fileName: "revit.csv", contentBase64: "YWJj" },
-      },
-      {
-        url: "/api/projects/project-1/external-csv/initial-import/apply",
-        method: "POST",
-        body: {
-          expectedRevision: 8,
-          expectedConfigurationVersion: 2,
-          expectedSha256: "sha",
-          fileName: "revit.csv",
-          contentBase64: "YWJj",
-          sourceName: "Revit-Gesamtmodell",
-          roomDecisions: [{ sourceRoomKey: "101|büro", roomId: "room-1", defaultDistributionBoardId: "board-1" }],
-          familyProjectDeviceDecisions: [{ familyAndType: "Steckdose : Standard", projectDeviceId: "device-1" }],
-        },
-      },
-    ]);
-  });
-});
-
-describe("Revit CSV modal presentation", () => {
-  it("uses the viewport-wide dialog variant", () => {
-    const markup = renderToStaticMarkup(
-      createElement(RevitCsvModal, {
-        currentRevision: 0,
-        onClose: () => undefined,
-        onCreateProjectDevice: async () => ({} as never),
-        onCreateRoom: async () => ({} as never),
-        onRevisionChange: () => undefined,
-        projectId: "project-1",
-      })
-    );
-
-    assert.match(markup, /max-width:calc\(100vw - 2rem\)/);
-    assert.doesNotMatch(markup, /modal-lg/);
-  });
-
-  it("renders the initial import decisions without individual object rows", () => {
-    const plan: ExternalInitialImportPlanDto = {
-      configurationVersion: 2,
-      fileName: "revit.csv",
-      sha256: "sha",
-      byteLength: 100,
-      rowCount: 2,
-      objectCount: 1,
-      passthroughCount: 1,
-      suspectObjectCount: 0,
-      suspectRowNumbers: [],
-      sourceRooms: [{
-        sourceRoomKey: "101|büro",
-        roomNumber: "101",
-        roomName: "Büro",
-        objectCount: 1,
-        suggestedRoomId: "room-1",
-        matchStatus: "exact-number",
-        candidateRoomIds: ["room-1"],
-      }],
-      familyGroups: [{
-        familyAndType: "Steckdose : Standard",
-        objectCount: 1,
-        classified: true,
-        category: "single_phase",
-        connectionKind: null,
-        internalDeviceType: "socket",
-      }],
-      issueCounts: { unknownFamilyAndType: 0, invalidPower: 0, invalidQuantity: 0, missingRoom: 0 },
-      objects: [],
-      existing: {
-        floors: [{ id: "floor-1", name: "EG", sortOrder: 0 }],
-        rooms: [{ id: "room-1", floorId: "floor-1", roomNumber: "101", roomName: "Büro", areaM2: null }],
-        distributionBoards: [{ id: "board-1", name: "UV-01", floorId: "floor-1" }],
-        projectDevices: [{ id: "device-1", name: "Steckdose", displayName: "Steckdose", category: "single_phase", connectionKind: null, powerPerUnit: 100 }],
-      },
-    };
-    const markup = renderToStaticMarkup(createElement(RevitCsvImportPlan, {
-      familyLinks: { "Steckdose : Standard": "device-1" },
-      isApplying: false,
-      onApply: () => undefined,
-      onCreateProjectDevice: () => undefined,
-      onCreateRoom: () => undefined,
-      onFamilyLinkChange: () => undefined,
-      onRoomDecisionChange: () => undefined,
-      plan,
-      roomDecisions: { "101|büro": { roomId: "room-1", defaultDistributionBoardId: "board-1" } },
-      setSourceName: () => undefined,
-      sourceName: "Revit-Gesamtmodell",
-    }));
-
-    assert.match(markup, /Erstimport vorbereiten/);
-    assert.match(markup, /101 · Büro/);
-    assert.match(markup, /Steckdose : Standard/);
-    assert.match(markup, /Erstimport übernehmen/);
-    assert.match(markup, /Raum 101 neu anlegen/);
-    assert.match(markup, /ProjectDevice für Steckdose : Standard neu anlegen/);
-    assert.doesNotMatch(markup, /IFC-GUID/);
-  });
-
-  it("prefills the existing room and ProjectDevice forms from Revit decisions", () => {
-    const roomMarkup = renderToStaticMarkup(createElement(RoomModal, {
-      floors: [{ id: "floor-1", projectId: "project-1", name: "EG", sortOrder: 0 }],
-      initialValues: { roomNumber: "101", roomName: "Büro" },
-      isSaving: false,
-      onClose: () => undefined,
-      onSave: async () => undefined,
-    }));
-    const deviceMarkup = renderToStaticMarkup(createElement(ProjectDeviceModal, {
-      globalDevices: [],
-      initialValues: {
-        name: "socket",
-        displayName: "Steckdose",
-        category: "single_phase",
-        quantity: 2,
-        powerPerUnit: 0.1,
-        simultaneityFactor: 1,
-      },
-      isSaving: false,
-      onClose: () => undefined,
-      onImportGlobal: async () => undefined,
-      onSave: async () => undefined,
-    }));
-
-    assert.match(roomMarkup, /value="101"/);
-    assert.match(roomMarkup, /value="Büro"/);
-    assert.match(deviceMarkup, /value="socket"/);
-    assert.match(deviceMarkup, /value="Steckdose"/);
-    assert.match(deviceMarkup, /value="2"/);
-  });
-
-  it("converts mapped Revit watts into ProjectDevice kilowatts", () => {
-    const plan = {
-      familyGroups: [{
-        familyAndType: "Steckdose : Standard",
-        internalDeviceType: "socket",
-        category: "single_phase",
-        connectionKind: "230 V",
-      }],
-      objects: [{
-        sourceValues: { familyAndType: "Steckdose : Standard" },
-        suggestedPlanningValues: {
-          displayName: "Arbeitsplatzsteckdose",
-          effectiveQuantity: 4,
-          powerPerUnitW: 250,
-          simultaneityFactor: 0.8,
-          cosPhi: 0.95,
-          costGroup: "440",
-          remark: "Aus Revit",
-        },
-      }],
-    } as ExternalInitialImportPlanDto;
-
-    assert.deepEqual(
-      createRevitProjectDevicePrefill(plan, "Steckdose : Standard"),
-      {
-        name: "socket",
-        displayName: "Arbeitsplatzsteckdose",
-        connectionKind: "230 V",
-        category: "single_phase",
-        quantity: 4,
-        powerPerUnit: 0.25,
-        simultaneityFactor: 0.8,
-        cosPhi: 0.95,
-        costGroup: "440",
-        remark: "Aus Revit",
-      }
-    );
-  });
-});
diff --git a/tests/revit-xlsx-settings-api.test.ts b/tests/revit-xlsx-settings-api.test.ts
new file mode 100644
index 0000000..090e6b3
--- /dev/null
+++ b/tests/revit-xlsx-settings-api.test.ts
@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { describe, it } from "node:test";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
+import { detectExternalModelWorkbook, getExternalModelConfiguration, updateExternalModelConfiguration } from "../src/frontend/utils/api.js";
+
+describe("Revit XLSX settings", () => {
+  it("uses the project-scoped configuration endpoint with expectedRevision", async () => {
+    const requests: Array<{ url: string; method: string; body: unknown }> = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+      requests.push({ url: String(input), method: init?.method ?? "GET", body: init?.body ? JSON.parse(String(init.body)) : undefined });
+      return new Response(JSON.stringify({ configuration: null, history: { currentRevision: 8 } }), { status: 200, headers: { "Content-Type": "application/json" } });
+    };
+    try {
+      const configuration = createDefaultExternalModelConfiguration();
+      await getExternalModelConfiguration("project-1");
+      await updateExternalModelConfiguration("project-1", 7, configuration);
+      await detectExternalModelWorkbook("project-1", new File([new Uint8Array([1, 2])], "sample.xlsx"), configuration);
+      assert.deepEqual(requests, [
+        { url: "/api/projects/project-1/external-model/configuration", method: "GET", body: undefined },
+        { url: "/api/projects/project-1/external-model/configuration", method: "PUT", body: { expectedRevision: 7, configuration } },
+        { url: "/api/projects/project-1/external-model/configuration/detect", method: "POST", body: { fileName: "sample.xlsx", contentBase64: "AQI=", configuration } },
+      ]);
+    } finally { globalThis.fetch = originalFetch; }
+  });
+
+  it("exposes the Revit route and removes the old project modal", () => {
+    const projectPage = readFileSync("src/app/projects/[projectId]/page.tsx", "utf8");
+    const revitPage = readFileSync("src/app/projects/[projectId]/revit/page.tsx", "utf8");
+    const settings = readFileSync("src/frontend/components/revit-xlsx-settings-modal.tsx", "utf8");
+    assert.match(projectPage, /href={`\/projects\/\$\{projectId\}\/revit`}/);
+    assert.doesNotMatch(projectPage, /RevitCsvModal|Revit-CSV/);
+    assert.match(revitPage, /Importstatus/);
+    assert.match(settings, /Musterdatei prüfen/);
+    assert.match(settings, /Kombinierte Stromkreisspalte/);
+  });
+});

From bfdd0482695da50dc89f3ee6c0c5b670428902fa Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 09:50:58 +0200
Subject: [PATCH 53/60] Add Linear XLSX initial import

---
 AGENTS.md                                     |   8 +-
 README.md                                     |   7 +-
 docs/current-architecture.md                  |  19 +-
 docs/spec/revit-excel-phase-14-plan.md        |  13 +-
 src/app/projects/[projectId]/revit/page.tsx   |  35 ++-
 ...itial-import-project-command.repository.ts |  87 +++++++
 ...al-initial-import-project-command.model.ts | 105 ++++++++
 ...al-initial-import-project-command.store.ts |  15 ++
 .../services/project-command.service.ts       |  18 +-
 .../external-xlsx-initial-import-target.ts    |  62 +++++
 .../external-xlsx-initial-import.ts           | 246 ++++++++++++++++++
 .../revit-initial-import-wizard.tsx           | 106 ++++++++
 src/frontend/types.ts                         |  78 ++----
 src/frontend/utils/api.ts                     |  38 +++
 src/frontend/utils/project-version-history.ts |   1 +
 .../composition/project-command-stores.ts     |   6 +-
 .../external-initial-import.controller.ts     |  68 +++++
 src/server/routes/project.routes.ts           |   8 +
 tests/external-xlsx-initial-import.test.ts    |  68 +++++
 tests/revit-xlsx-settings-api.test.ts         |  29 ++-
 20 files changed, 932 insertions(+), 85 deletions(-)
 create mode 100644 src/db/repositories/external-initial-import-project-command.repository.ts
 create mode 100644 src/domain/models/external-initial-import-project-command.model.ts
 create mode 100644 src/domain/ports/external-initial-import-project-command.store.ts
 create mode 100644 src/external-model/application/external-xlsx-initial-import-target.ts
 create mode 100644 src/external-model/application/external-xlsx-initial-import.ts
 create mode 100644 src/frontend/components/revit-initial-import-wizard.tsx
 create mode 100644 src/server/controllers/external-initial-import.controller.ts
 create mode 100644 tests/external-xlsx-initial-import.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index e8d4bff..d771e59 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -333,6 +333,12 @@ R4 adds `/projects/:projectId/revit`, its revisioned XLSX settings and
 server-side sample detection, and removes the old project-page CSV modal. See
 `docs/spec/revit-excel-integration-requirements.md` and
 `docs/spec/revit-excel-phase-14-plan.md`.
+R5 adds stateless XLSX preview/planning and the six-step initial-import wizard.
+`external-model.apply-initial-import` stores the configuration and complete
+external model state atomically; its inverse powers persistent Undo/Redo
+without parsing workbook bytes. Apply retransmits and reparses the XLSX,
+verifies its preview SHA-256 and creates no circuit, equipment identifier or
+CircuitDeviceRow.
 
 The target configuration has no independent version counter; `expectedRevision`
 invalidates stale plans, and each import batch stores a configuration copy.
@@ -586,7 +592,7 @@ Critical target rules:
   selected combined/separate mode block export.
 - Missing GZF defaults visibly to 1 without separate confirmation.
 - The corrected R2 return workbook was successfully imported into Linear on
-  2026-09-30; R3 and R4 are complete and R5 is the next package.
+  2026-09-30; R3 through R5 are complete and R6 is the next package.
 - All confirmed writes use typed project commands with `expectedRevision`,
   complete inverse data and the shared project-command transaction boundary.
 - Do not add automatic circuit planning, Revit circuit adoption, multi-source
diff --git a/README.md b/README.md
index b70a145..b965df8 100644
--- a/README.md
+++ b/README.md
@@ -11,9 +11,10 @@ für mehrere gleichzeitig arbeitende Prozesse und ein vollständig unterstützte
 Produktionsdeployment fehlen weiterhin. Anmeldung und zwei feste Rollen sind
 vorhanden. Die Backend- und Persistenzgrundlage der bisherigen
 Revit-CSV-/IfcGUID-Anbindung ist durch den XLSX-Austausch des Linear-Plugins mit
-Worksharing-ID als externem Schlüssel ersetzt. R0 bis R4 sind abgeschlossen;
-die eigene Revit-Seite mit XLSX-Einstellungen ist vorhanden. Erstimport,
-Editorzuordnung, Rückgabe und Folgeimport folgen in R5 bis R10.
+Worksharing-ID als externem Schlüssel ersetzt. R0 bis R5 sind abgeschlossen;
+die eigene Revit-Seite besitzt XLSX-Einstellungen und einen persistenten
+Erstimport. Objekttabelle, Editorzuordnung, Rückgabe und Folgeimport folgen in
+R6 bis R10.
 
 ## Unterstützter Arbeitsablauf
 
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 846debb..4dfa96c 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -643,7 +643,7 @@ PostgreSQL ist bewusst nicht implementiert. Die Domainregeln und
 Transaktionsgrenzen sollen portabel bleiben; Schema und Betriebsmodell benötigen
 bei einem späteren Wechsel trotzdem einen eigenen PostgreSQL-Adapter.
 
-## Revit-Anbindung: Linear-XLSX-Grundlage nach R3
+## Revit-Anbindung: Linear-XLSX-Erstimport nach R5
 
 R3 hat den Backend- und Persistenz-Cutover abgeschlossen. Migration `0014`
 entfernt die alten externen CSV-Entwicklungsdaten, nachdem verknüpfte
@@ -663,9 +663,20 @@ CSV-Zustand sowie alte CSV-History-Commands werden mit einer deutschen Meldung
 abgelehnt.
 
 Der XLSX-Adapter liegt unter `src/external-model/xlsx`. Der Backend-CSV-Parser,
-seine Endpunkte und Laufzeitverträge sind entfernt. Die noch sichtbare alte
-Projektseiten-Oberfläche ist bis R4 ohne Backend-Anbindung und wird dort durch
-die Route `/projects/:projectId/revit` ersetzt.
+seine Endpunkte und Laufzeitverträge sind entfernt. Die Route
+`/projects/:projectId/revit` enthält Einstellungen, Importstatus und den
+sechsstufigen Erstimportwizard.
+
+`POST /api/projects/:projectId/external-model/initial-import/plan` liest eine
+lokale XLSX zustandslos, gruppiert Quellräume und exakte Familie-und-Typ-Werte
+und liefert die vorhandenen Raum-, Verteiler- und ProjectDevice-Kataloge.
+Unbekannte Familien bleiben blockierend; fehlender GZF wird sichtbar mit 1
+vorbelegt. `apply` erhält die Datei erneut, parst sie erneut und vergleicht den
+Vorschau-SHA-256. Der Command `external-model.apply-initial-import` speichert
+die dabei verwendete Konfiguration und den vollständigen externen Zustand in
+derselben Transaktion. Er erzeugt weder CircuitDeviceRows noch Circuits oder
+BMKs. Seine vollständige Inverse macht Undo/Redo nach Neustart möglich, ohne
+Workbookbytes erneut einzulesen oder zu parsen.
 
 ### Historische Ausgangslage vor R3
 
diff --git a/docs/spec/revit-excel-phase-14-plan.md b/docs/spec/revit-excel-phase-14-plan.md
index 0b1b71a..f4d1c7c 100644
--- a/docs/spec/revit-excel-phase-14-plan.md
+++ b/docs/spec/revit-excel-phase-14-plan.md
@@ -13,7 +13,7 @@ Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
 | R2 | abgeschlossen und freigegeben | XLSX-Adapter, Parser, synthetische Fixtures, lokaler Referenzprüfer und reale Rückgabedatei sind erstellt; der korrigierte Rückimport wurde am 30.09.2026 erfolgreich in Linear getestet. |
 | R3 | abgeschlossen | Konfiguration ohne eigene Revision, Worksharing-ID-Datenmodell, Migration 0014, Snapshot 10, Transfer und Backend-CSV-Entfernung sind umgesetzt und geprüft. |
 | R4 | abgeschlossen | Revit-Seite, Navigation und revisionierte XLSX-Einstellungen mit Musterdateiprüfung sind umgesetzt; das alte Projektseitenmodal ist entfernt. |
-| R5 | offen | Erstimportwizard mit Gerätearten, Familienregeln und optionalen ProjectDevices. |
+| R5 | abgeschlossen | Zustandslose XLSX-Vorschau, sechsstufiger Erstimportwizard und atomarer Importcommand mit parserfreiem Undo/Redo. |
 | R6 | offen | Virtualisierte Objekttabelle und Sammelzuordnungen. |
 | R7 | offen | Editorbereich, Gruppierung, Drag-and-drop, Lösen und integrierte Löschübergänge. |
 | R8 | offen | Rückgabe-Excel und append-only Exportnachweis. |
@@ -121,6 +121,17 @@ vollständiges UUID-Remapping. Pflicht: echte SQLite-Commit-/Rollback-Tests.
 - ein atomarer Importcommand, keine Row-/Circuit-Erzeugung;
 - Undo/Redo aus Commandzuständen ohne Workbook-Parsing.
 
+Implementierungsstand vom 30.09.2026: Vorschau und Apply verwenden die
+projektweite XLSX-Konfiguration; Apply überträgt und parst die Datei erneut und
+vergleicht den SHA-256 der Vorschau. Der Wizard führt über Vorschau, Räume,
+Standardverteiler einschließlich Objekten ohne Raum, exakte Familienregeln,
+optionale ProjectDevices und Bestätigung. Unbekannte Familien können als
+Geräteart mit stabilen Client-UUIDs und sichtbarem GZF-Startwert 1 klassifiziert
+werden. `external-model.apply-initial-import` schreibt Konfiguration, Quelle,
+vollständigen letzten Batch, Raumzuordnungen und Objekte in einer Revision;
+alle `circuitDeviceRowId` bleiben `null`. Seine Inverse speichert beide
+Zustände vollständig, sodass Undo/Redo weder Datei noch Parser benötigen.
+
 ## R6 – Objekttabelle und Sammelaktionen
 
 - kompakte Objektliste einmal laden;
diff --git a/src/app/projects/[projectId]/revit/page.tsx b/src/app/projects/[projectId]/revit/page.tsx
index 96af41c..bf9b39f 100644
--- a/src/app/projects/[projectId]/revit/page.tsx
+++ b/src/app/projects/[projectId]/revit/page.tsx
@@ -1,34 +1,49 @@
 "use client";
 
-import { ArrowLeft, FileSpreadsheet, Settings } from "lucide-react";
+import { ArrowLeft, FileSpreadsheet, Settings, Upload } from "lucide-react";
 import { useParams } from "next/navigation";
 import { useEffect, useState } from "react";
 import { IconLink } from "../../../../frontend/components/icon-link";
+import { RevitInitialImportWizard } from "../../../../frontend/components/revit-initial-import-wizard";
 import { RevitXlsxSettingsModal } from "../../../../frontend/components/revit-xlsx-settings-modal";
 import type { ExternalModelConfiguration } from "../../../../external-model/configuration/external-model-configuration";
-import { detectExternalModelWorkbook, getExternalModelConfiguration, getProject, updateExternalModelConfiguration } from "../../../../frontend/utils/api";
+import { detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getProject, updateExternalModelConfiguration } from "../../../../frontend/utils/api";
 import { createDefaultRevitXlsxConfiguration } from "../../../../frontend/utils/revit-xlsx-settings";
-import type { ExternalModelConfigurationSnapshotDto, ProjectDto } from "../../../../frontend/types";
+import type { ExternalInitialImportStatusDto, ExternalModelConfigurationSnapshotDto, ProjectDto } from "../../../../frontend/types";
 
 export default function RevitPage() {
   const { projectId } = useParams<{ projectId: string }>();
   const [project, setProject] = useState<ProjectDto | null>(null);
   const [snapshot, setSnapshot] = useState<ExternalModelConfigurationSnapshotDto | null>(null);
-  const [open, setOpen] = useState(false);
+  const [importStatus, setImportStatus] = useState<ExternalInitialImportStatusDto | null>(null);
+  const [settingsOpen, setSettingsOpen] = useState(false);
+  const [importOpen, setImportOpen] = useState(false);
   const [saving, setSaving] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  useEffect(() => { Promise.all([getProject(projectId), getExternalModelConfiguration(projectId)]).then(([loadedProject, result]) => { setProject(loadedProject); setSnapshot(result.configuration); }).catch((value: unknown) => setError(value instanceof Error ? value.message : "Revit-Daten konnten nicht geladen werden.")); }, [projectId]);
+
+  useEffect(() => {
+    Promise.all([getProject(projectId), getExternalModelConfiguration(projectId), getExternalInitialImportStatus(projectId)])
+      .then(([loadedProject, configuration, status]) => { setProject(loadedProject); setSnapshot(configuration.configuration); setImportStatus(status); })
+      .catch((value: unknown) => setError(value instanceof Error ? value.message : "Revit-Daten konnten nicht geladen werden."));
+  }, [projectId]);
+
   async function save(configuration: ExternalModelConfiguration) {
     if (!project) return;
     setSaving(true); setError(null);
-    try { const result = await updateExternalModelConfiguration(projectId, project.currentRevision, configuration); setSnapshot(result.configuration); setProject({ ...project, currentRevision: result.history.currentRevision }); setOpen(false); }
-    catch (value) { setError(value instanceof Error ? value.message : "Einstellungen konnten nicht gespeichert werden."); }
+    try {
+      const result = await updateExternalModelConfiguration(projectId, project.currentRevision, configuration);
+      setSnapshot(result.configuration);
+      setProject({ ...project, currentRevision: result.history.currentRevision });
+      setSettingsOpen(false);
+    } catch (value) { setError(value instanceof Error ? value.message : "Einstellungen konnten nicht gespeichert werden."); }
     finally { setSaving(false); }
   }
+
   return <main className="container py-4">
-    <div className="page-header"><div><div className="kicker">Projekt · Revit</div><h1>{project?.name ?? "Revit-Anbindung"}</h1><p className="text-secondary mb-0">Linear-XLSX austauschen und Revit-Objekte verwalten</p></div><div className="d-flex gap-2"><button className="btn btn-primary btn-with-icon" disabled={!project} onClick={() => setOpen(true)} type="button"><Settings size={16} />Einstellungen</button><IconLink href={`/projects/${projectId}`} icon={ArrowLeft} label="Zum Projekt" showLabel /></div></div>
+    <div className="page-header"><div><div className="kicker">Projekt · Revit</div><h1>{project?.name ?? "Revit-Anbindung"}</h1><p className="text-secondary mb-0">Linear-XLSX austauschen und Revit-Objekte verwalten</p></div><div className="d-flex gap-2"><button className="btn btn-success btn-with-icon" disabled={!project || !snapshot || Boolean(importStatus?.imported)} onClick={() => setImportOpen(true)} type="button"><Upload size={16} />Erstimport</button><button className="btn btn-primary btn-with-icon" disabled={!project} onClick={() => setSettingsOpen(true)} type="button"><Settings size={16} />Einstellungen</button><IconLink href={`/projects/${projectId}`} icon={ArrowLeft} label="Zum Projekt" showLabel /></div></div>
     {error ? <div className="alert alert-danger">{error}</div> : null}
-    <div className="row g-3 mt-1"><div className="col-md-6"><section className="card h-100"><div className="card-body"><FileSpreadsheet className="mb-3" size={28} /><h2 className="h5">XLSX-Konfiguration</h2><p className="text-secondary">{snapshot ? "Die Linear-Spalten und das Tabellenlayout sind konfiguriert." : "Noch keine XLSX-Konfiguration gespeichert."}</p><span className={`badge ${snapshot ? "text-bg-success" : "text-bg-secondary"}`}>{snapshot ? "Konfiguriert" : "Offen"}</span></div></section></div><div className="col-md-6"><section className="card h-100"><div className="card-body"><h2 className="h5">Importstatus</h2><p className="text-secondary mb-0">Noch kein Linear-XLSX-Import vorhanden. Der Erstimport folgt in R5.</p></div></section></div></div>
-    {open ? <RevitXlsxSettingsModal configuration={snapshot?.configuration ?? createDefaultRevitXlsxConfiguration()} isSaving={saving} onClose={() => setOpen(false)} onInspectSample={async (file, configuration) => { const result = await detectExternalModelWorkbook(projectId, file, configuration); return `Muster erkannt: ${result.sheetName}, ${result.columnCount} Spalten, ${result.objectCount} Objekte.`; }} onSave={save} /> : null}
+    <div className="row g-3 mt-1"><div className="col-md-6"><section className="card h-100"><div className="card-body"><FileSpreadsheet className="mb-3" size={28} /><h2 className="h5">XLSX-Konfiguration</h2><p className="text-secondary">{snapshot ? "Die Linear-Spalten und das Tabellenlayout sind konfiguriert." : "Noch keine XLSX-Konfiguration gespeichert."}</p><span className={`badge ${snapshot ? "text-bg-success" : "text-bg-secondary"}`}>{snapshot ? "Konfiguriert" : "Offen"}</span></div></section></div><div className="col-md-6"><section className="card h-100"><div className="card-body"><h2 className="h5">Importstatus</h2>{importStatus?.imported ? <><p className="mb-1"><strong>{importStatus.objectCount} Revit-Objekte</strong>{importStatus.fileName ? ` aus ${importStatus.fileName}` : ""}</p><p className="text-secondary mb-0">Quelle: {importStatus.sourceName}</p></> : <p className="text-secondary mb-0">Noch kein Linear-XLSX-Import vorhanden.</p>}</div></section></div></div>
+    {settingsOpen ? <RevitXlsxSettingsModal configuration={snapshot?.configuration ?? createDefaultRevitXlsxConfiguration()} isSaving={saving} onClose={() => setSettingsOpen(false)} onInspectSample={async (file, configuration) => { const result = await detectExternalModelWorkbook(projectId, file, configuration); return `Muster erkannt: ${result.sheetName}, ${result.columnCount} Spalten, ${result.objectCount} Objekte.`; }} onSave={save} /> : null}
+    {importOpen && project && snapshot ? <RevitInitialImportWizard projectId={projectId} expectedRevision={project.currentRevision} initialConfiguration={snapshot.configuration} onClose={() => setImportOpen(false)} onImported={({ history }) => { setProject({ ...project, currentRevision: history.currentRevision }); setImportOpen(false); void Promise.all([getExternalInitialImportStatus(projectId), getExternalModelConfiguration(projectId)]).then(([status, configuration]) => { setImportStatus(status); setSnapshot(configuration.configuration); }); }} /> : null}
   </main>;
 }
diff --git a/src/db/repositories/external-initial-import-project-command.repository.ts b/src/db/repositories/external-initial-import-project-command.repository.ts
new file mode 100644
index 0000000..70a249b
--- /dev/null
+++ b/src/db/repositories/external-initial-import-project-command.repository.ts
@@ -0,0 +1,87 @@
+import { createHash } from "node:crypto";
+import { eq } from "drizzle-orm";
+import {
+  assertExternalInitialImportProjectCommand,
+  createExternalInitialImportProjectCommand,
+  isEmptyExternalModelState,
+} from "../../domain/models/external-initial-import-project-command.model.js";
+import type { ExternalModelConfigurationSnapshot } from "../../domain/models/external-model-configuration-project-command.model.js";
+import type { ExternalInitialImportProjectCommandStore } from "../../domain/ports/external-initial-import-project-command.store.js";
+import type { ExternalModelStateSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import type { AppDatabase } from "../database-context.js";
+import { distributionBoards } from "../schema/distribution-boards.js";
+import { externalImportBatches } from "../schema/external-import-batches.js";
+import { externalModelConfigurations } from "../schema/external-model-configurations.js";
+import { externalModelObjects } from "../schema/external-model-objects.js";
+import { externalModelSources } from "../schema/external-model-sources.js";
+import { externalRoomMappings } from "../schema/external-room-mappings.js";
+import { projectDevices } from "../schema/project-devices.js";
+import { projects } from "../schema/projects.js";
+import { rooms } from "../schema/rooms.js";
+import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { ExternalModelStateRepository } from "./external-model-state.repository.js";
+
+export class ExternalInitialImportProjectCommandRepository implements ExternalInitialImportProjectCommandStore {
+  constructor(private readonly database: AppDatabase) {}
+
+  execute(input: Parameters<ExternalInitialImportProjectCommandStore["execute"]>[0]) {
+    assertExternalInitialImportProjectCommand(input.command);
+    return executeProjectCommandTransaction(this.database, input, (tx) => {
+      const currentStateResult = new ExternalModelStateRepository(tx).getByProject(input.projectId);
+      if (!currentStateResult.projectExists) throw new Error("Projekt nicht gefunden.");
+      const currentConfiguration = tx.select().from(externalModelConfigurations).where(eq(externalModelConfigurations.projectId, input.projectId)).get() ?? null;
+      const payload = input.command.payload;
+      if (!same(payload.expectedState, currentStateResult.state) || !same(payload.expectedConfiguration, currentConfiguration)) {
+        throw new Error("Revit-Zustand oder Konfiguration wurde zwischenzeitlich geändert.");
+      }
+      if (!isEmptyExternalModelState(payload.targetState)) validateTarget(tx, input.projectId, input.expectedRevision, input.source, payload.targetConfiguration, payload.targetState);
+      replaceConfiguration(tx, input.projectId, payload.targetConfiguration);
+      replaceState(tx, input.projectId, payload.targetState);
+      const persistedState = new ExternalModelStateRepository(tx).getByProject(input.projectId).state;
+      const persistedConfiguration = tx.select().from(externalModelConfigurations).where(eq(externalModelConfigurations.projectId, input.projectId)).get() ?? null;
+      if (!same(payload.targetState, persistedState) || !same(payload.targetConfiguration, persistedConfiguration)) throw new Error("Gespeicherter Revit-Erstimport weicht vom Zielzustand ab.");
+      return createExternalInitialImportProjectCommand(payload.targetConfiguration, currentConfiguration, payload.targetState, currentStateResult.state);
+    });
+  }
+}
+
+function validateTarget(database: AppDatabase, projectId: string, expectedRevision: number, source: string, configuration: ExternalModelConfigurationSnapshot | null, state: ExternalModelStateSnapshot) {
+  if (!configuration || configuration.projectId !== projectId || state.source?.projectId !== projectId) throw new Error("Der Revit-Erstimport gehört zu einem anderen Projekt.");
+  const batch = state.importBatches[0];
+  if (source === "user" && batch.appliedProjectRevision !== expectedRevision + 1) throw new Error("Die Projektrevision des Revit-Erstimports ist ungültig.");
+  if (!same(batch.configurationSnapshot, configuration.configuration)) throw new Error("Die Konfigurationskopie des Importbatches ist ungültig.");
+  const bytes = decodeCanonicalBase64(batch.originalContentBase64!);
+  if (createHash("sha256").update(bytes).digest("hex") !== batch.sha256) throw new Error("Die Prüfsumme des Revit-Erstimports ist ungültig.");
+  const roomIds = ids(database.select({ id: rooms.id }).from(rooms).where(eq(rooms.projectId, projectId)).all());
+  const boardIds = ids(database.select({ id: distributionBoards.id }).from(distributionBoards).where(eq(distributionBoards.projectId, projectId)).all());
+  const projectDeviceIds = ids(database.select({ id: projectDevices.id }).from(projectDevices).where(eq(projectDevices.projectId, projectId)).all());
+  const deviceTypeIds = new Set(configuration.configuration.deviceTypes.map((type) => type.id));
+  for (const mapping of state.roomMappings) {
+    if (mapping.roomId !== null && !roomIds.has(mapping.roomId)) throw new Error("Eine Raumzuordnung verweist auf ein anderes Projekt.");
+    if (mapping.defaultDistributionBoardId !== null && !boardIds.has(mapping.defaultDistributionBoardId)) throw new Error("Ein Standardverteiler verweist auf ein anderes Projekt.");
+  }
+  for (const object of state.objects) {
+    if (!deviceTypeIds.has(object.deviceTypeId)) throw new Error("Ein Revit-Objekt verweist auf eine unbekannte Geräteart.");
+    if (object.distributionBoardId !== null && !boardIds.has(object.distributionBoardId)) throw new Error("Ein Revit-Objekt verweist auf einen fremden Verteiler.");
+    if (object.linkedProjectDeviceId !== null && !projectDeviceIds.has(object.linkedProjectDeviceId)) throw new Error("Ein Revit-Objekt verweist auf ein fremdes Projektgerät.");
+  }
+}
+
+function replaceConfiguration(database: AppDatabase, projectId: string, target: ExternalModelConfigurationSnapshot | null) {
+  database.delete(externalModelConfigurations).where(eq(externalModelConfigurations.projectId, projectId)).run();
+  if (target) database.insert(externalModelConfigurations).values(target).run();
+}
+
+function replaceState(database: AppDatabase, projectId: string, target: ExternalModelStateSnapshot) {
+  database.delete(externalModelSources).where(eq(externalModelSources.projectId, projectId)).run();
+  if (!target.source) return;
+  database.insert(externalModelSources).values(target.source).run();
+  database.insert(externalImportBatches).values(target.importBatches.map(({ originalContentBase64, ...batch }) => ({ ...batch, originalBytes: originalContentBase64 === null ? null : Buffer.from(originalContentBase64, "base64") }))).run();
+  if (target.roomMappings.length) database.insert(externalRoomMappings).values(target.roomMappings).run();
+  if (target.objects.length) database.insert(externalModelObjects).values(target.objects).run();
+}
+
+function decodeCanonicalBase64(value: string) { const bytes = Buffer.from(value, "base64"); if (bytes.toString("base64") !== value) throw new Error("Der XLSX-Inhalt ist nicht kanonisch Base64-kodiert."); return bytes; }
+function ids(entries: Array<{ id: string }>) { return new Set(entries.map((entry) => entry.id)); }
+function same(left: unknown, right: unknown) { return canonical(left) === canonical(right); }
+function canonical(value: unknown): string { if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`; if (value !== null && typeof value === "object") { const record = value as Record<string, unknown>; return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`; } return JSON.stringify(value); }
diff --git a/src/domain/models/external-initial-import-project-command.model.ts b/src/domain/models/external-initial-import-project-command.model.ts
new file mode 100644
index 0000000..c63ae43
--- /dev/null
+++ b/src/domain/models/external-initial-import-project-command.model.ts
@@ -0,0 +1,105 @@
+import type { ExternalModelStateSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import { assertExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
+import { parseExternalModelStateSnapshot } from "./project-state-snapshot.model.js";
+import type { ExternalModelConfigurationSnapshot } from "./external-model-configuration-project-command.model.js";
+import type { SerializedProjectCommand } from "./project-command.model.js";
+
+export const externalInitialImportCommandType = "external-model.apply-initial-import" as const;
+export const externalInitialImportCommandSchemaVersion = 1 as const;
+
+export interface ExternalInitialImportPayload {
+  expectedConfiguration: ExternalModelConfigurationSnapshot | null;
+  targetConfiguration: ExternalModelConfigurationSnapshot | null;
+  expectedState: ExternalModelStateSnapshot;
+  targetState: ExternalModelStateSnapshot;
+}
+
+export interface ExternalInitialImportProjectCommand extends SerializedProjectCommand<ExternalInitialImportPayload> {
+  schemaVersion: typeof externalInitialImportCommandSchemaVersion;
+  type: typeof externalInitialImportCommandType;
+}
+
+export function createExternalInitialImportProjectCommand(
+  expectedConfiguration: ExternalModelConfigurationSnapshot | null,
+  targetConfiguration: ExternalModelConfigurationSnapshot | null,
+  expectedState: ExternalModelStateSnapshot,
+  targetState: ExternalModelStateSnapshot
+): ExternalInitialImportProjectCommand {
+  const command: ExternalInitialImportProjectCommand = {
+    schemaVersion: externalInitialImportCommandSchemaVersion,
+    type: externalInitialImportCommandType,
+    payload: { expectedConfiguration, targetConfiguration, expectedState, targetState },
+  };
+  assertExternalInitialImportProjectCommand(command);
+  return command;
+}
+
+export function assertExternalInitialImportProjectCommand(
+  command: SerializedProjectCommand<unknown>
+): asserts command is ExternalInitialImportProjectCommand {
+  if (command.schemaVersion !== 1 || command.type !== externalInitialImportCommandType || !isRecord(command.payload)) {
+    throw new Error("Nicht unterstützter Revit-Erstimport-Command.");
+  }
+  const keys = Object.keys(command.payload).sort().join(",");
+  if (keys !== "expectedConfiguration,expectedState,targetConfiguration,targetState") {
+    throw new Error("Der Revit-Erstimport-Command ist unvollständig.");
+  }
+  assertConfigurationSnapshot(command.payload.expectedConfiguration);
+  assertConfigurationSnapshot(command.payload.targetConfiguration);
+  const expected = parseExternalModelStateSnapshot(command.payload.expectedState);
+  const target = parseExternalModelStateSnapshot(command.payload.targetState);
+  if (isEmptyExternalModelState(expected) === isEmptyExternalModelState(target)) {
+    throw new Error("Der Erstimport muss zwischen leerem und gefülltem Modellzustand wechseln.");
+  }
+  assertPopulatedInitialState(isEmptyExternalModelState(expected) ? target : expected);
+}
+
+export function createEmptyExternalModelState(): ExternalModelStateSnapshot {
+  return { source: null, importBatches: [], roomMappings: [], objects: [] };
+}
+
+export function isEmptyExternalModelState(state: ExternalModelStateSnapshot) {
+  return state.source === null && state.importBatches.length === 0 && state.roomMappings.length === 0 && state.objects.length === 0;
+}
+
+function assertConfigurationSnapshot(value: unknown): asserts value is ExternalModelConfigurationSnapshot | null {
+  if (value === null) return;
+  if (!isRecord(value) || typeof value.id !== "string" || typeof value.projectId !== "string") {
+    throw new Error("Ungültiger Konfigurationszustand im Revit-Erstimport.");
+  }
+  assertExternalModelConfiguration(value.configuration);
+}
+
+function assertPopulatedInitialState(state: ExternalModelStateSnapshot) {
+  if (!state.source || state.source.sourceType !== "revit_xlsx" || state.importBatches.length !== 1 || state.objects.length === 0) {
+    throw new Error("Der Erstimport benötigt eine Quelle, einen Batch und mindestens ein Objekt.");
+  }
+  const source = state.source;
+  const batch = state.importBatches[0];
+  if (batch.importKind !== "initial" || batch.projectId !== source.projectId || batch.sourceId !== source.id || batch.configurationSnapshot === null || batch.originalContentBase64 === null || batch.document === null || batch.objectCount !== state.objects.length) {
+    throw new Error("Der Erstimport-Batch ist unvollständig.");
+  }
+  const mappingIds = uniqueIds(state.roomMappings);
+  const roomKeys = new Set<string>();
+  for (const mapping of state.roomMappings) {
+    if (mapping.projectId !== source.projectId || mapping.sourceId !== source.id || roomKeys.has(mapping.normalizedSourceRoomKey)) throw new Error("Ungültige oder doppelte Quellraumzuordnung.");
+    roomKeys.add(mapping.normalizedSourceRoomKey);
+  }
+  uniqueIds(state.objects);
+  const worksharingIds = new Set<string>();
+  for (const object of state.objects) {
+    if (object.projectId !== source.projectId || object.sourceId !== source.id || object.lastSeenImportBatchId !== batch.id || object.lastAcceptedImportBatchId !== batch.id) throw new Error("Ungültige Objektidentität im Erstimport.");
+    if (worksharingIds.has(object.worksharingId)) throw new Error("Doppelte Worksharing-ID im Erstimport.");
+    worksharingIds.add(object.worksharingId);
+    if (object.externalRoomMappingId !== null && !mappingIds.has(object.externalRoomMappingId)) throw new Error("Ungültige Quellraumzuordnung am Revit-Objekt.");
+    if (object.circuitDeviceRowId !== null) throw new Error("Der Erstimport darf keine Gerätezeile zuordnen.");
+    if (object.presenceStatus !== "present") throw new Error("Erstimportobjekte müssen vorhanden sein.");
+  }
+}
+
+function uniqueIds(entries: ReadonlyArray<{ id: string }>) {
+  const ids = new Set<string>();
+  for (const entry of entries) { if (ids.has(entry.id)) throw new Error("Doppelte ID im Revit-Erstimport."); ids.add(entry.id); }
+  return ids;
+}
+function isRecord(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); }
diff --git a/src/domain/ports/external-initial-import-project-command.store.ts b/src/domain/ports/external-initial-import-project-command.store.ts
new file mode 100644
index 0000000..411d3c3
--- /dev/null
+++ b/src/domain/ports/external-initial-import-project-command.store.ts
@@ -0,0 +1,15 @@
+import type { ExternalInitialImportProjectCommand } from "../models/external-initial-import-project-command.model.js";
+import type { AppendedProjectRevision, ProjectRevisionSource } from "./project-revision.store.js";
+
+export interface ExecuteExternalInitialImportCommandInput {
+  projectId: string;
+  expectedRevision: number;
+  source: ProjectRevisionSource;
+  description?: string;
+  actorId?: string;
+  historyTargetChangeSetId?: string;
+  command: ExternalInitialImportProjectCommand;
+}
+export interface ExternalInitialImportProjectCommandStore {
+  execute(input: ExecuteExternalInitialImportCommandInput): { revision: AppendedProjectRevision; inverse: ExternalInitialImportProjectCommand };
+}
diff --git a/src/domain/services/project-command.service.ts b/src/domain/services/project-command.service.ts
index 603a4be..8e4bf36 100644
--- a/src/domain/services/project-command.service.ts
+++ b/src/domain/services/project-command.service.ts
@@ -177,6 +177,11 @@ import {
   externalModelConfigurationUpdateCommandType,
 } from "../models/external-model-configuration-project-command.model.js";
 import type { ExternalModelConfigurationProjectCommandStore } from "../ports/external-model-configuration-project-command.store.js";
+import {
+  assertExternalInitialImportProjectCommand,
+  externalInitialImportCommandType,
+} from "../models/external-initial-import-project-command.model.js";
+import type { ExternalInitialImportProjectCommandStore } from "../ports/external-initial-import-project-command.store.js";
 import {
   assertExternalObjectRowAssignmentProjectCommand,
   externalObjectRowAssignmentCommandType,
@@ -242,7 +247,8 @@ export class ProjectCommandService implements ProjectCommandExecutor {
     private readonly externalObjectRowAssignmentStore?: ExternalObjectRowAssignmentProjectCommandStore,
     private readonly externalObjectNewRowStore?: ExternalObjectNewRowProjectCommandStore,
     private readonly externalObjectNewCircuitStore?: ExternalObjectNewCircuitProjectCommandStore,
-    private readonly estimateBalanceStore?: EstimateBalanceProjectCommandStore
+    private readonly estimateBalanceStore?: EstimateBalanceProjectCommandStore,
+    private readonly externalInitialImportStore?: ExternalInitialImportProjectCommandStore
   ) {}
 
   executeUser(
@@ -631,6 +637,16 @@ export class ProjectCommandService implements ProjectCommandExecutor {
           command: input.command,
         }).revision;
       }
+      case externalInitialImportCommandType: {
+        assertExternalInitialImportProjectCommand(input.command);
+        if (!this.externalInitialImportStore) {
+          throw new Error("External initial import store is not available.");
+        }
+        return this.externalInitialImportStore.execute({
+          ...input,
+          command: input.command,
+        }).revision;
+      }
       case externalObjectRowAssignmentCommandType: {
         assertExternalObjectRowAssignmentProjectCommand(input.command);
         if (!this.externalObjectRowAssignmentStore) {
diff --git a/src/external-model/application/external-xlsx-initial-import-target.ts b/src/external-model/application/external-xlsx-initial-import-target.ts
new file mode 100644
index 0000000..8a7fd27
--- /dev/null
+++ b/src/external-model/application/external-xlsx-initial-import-target.ts
@@ -0,0 +1,62 @@
+import type { ExternalModelConfiguration } from "../configuration/external-model-configuration.js";
+import type { ExternalModelStateSnapshot } from "../domain/external-model-contracts.js";
+import type { ExternalXlsxDocument } from "../xlsx/external-xlsx-contracts.js";
+import type { ExternalInitialImportPlan } from "./external-xlsx-initial-import.js";
+
+export interface ExternalRoomDecision { sourceRoomKey: string; roomId: string | null; defaultDistributionBoardId: string | null; }
+export interface ExternalFamilyProjectDeviceDecision { familyAndType: string; projectDeviceId: string | null; }
+
+export function buildExternalXlsxInitialImportTarget(input: {
+  projectId: string;
+  expectedRevision: number;
+  sourceName: string;
+  importedAtIso: string;
+  configuration: ExternalModelConfiguration;
+  originalContentBase64: string;
+  document: ExternalXlsxDocument;
+  plan: ExternalInitialImportPlan;
+  roomDecisions: ExternalRoomDecision[];
+  familyProjectDeviceDecisions: ExternalFamilyProjectDeviceDecision[];
+  objectsWithoutRoomDefaultDistributionBoardId: string | null;
+  createId: () => string;
+}): ExternalModelStateSnapshot {
+  if (input.plan.familyGroups.some((group) => !group.classified) || input.plan.issueCounts.invalidQuantity > 0) {
+    throw new Error("Alle Familien müssen klassifiziert sein und gültige Mengen besitzen.");
+  }
+  const roomDecisions = exactDecisionMap(input.plan.sourceRooms.map((room) => room.sourceRoomKey), input.roomDecisions, (decision) => decision.sourceRoomKey, "Quellraum");
+  const familyDecisions = exactDecisionMap(input.plan.familyGroups.map((group) => group.familyAndType), input.familyProjectDeviceDecisions, (decision) => decision.familyAndType, "Familie und Typ");
+  const sourceId = input.createId();
+  const batchId = input.createId();
+  const mappingIds = new Map(input.plan.sourceRooms.map((room) => [room.sourceRoomKey, input.createId()]));
+  const mappings = input.plan.sourceRooms.map((room) => {
+    const decision = roomDecisions.get(room.sourceRoomKey)!;
+    return { id: mappingIds.get(room.sourceRoomKey)!, projectId: input.projectId, sourceId, normalizedSourceRoomKey: room.sourceRoomKey, sourceFloorName: null, sourceRoomNumber: room.roomNumber, sourceRoomName: room.roomName, roomId: decision.roomId, defaultDistributionBoardId: decision.defaultDistributionBoardId };
+  });
+  const mappingByKey = new Map(mappings.map((mapping) => [mapping.normalizedSourceRoomKey, mapping]));
+  const objects = input.plan.objects.map((object) => {
+    const roomMapping = object.sourceRoomKey === null ? null : mappingByKey.get(object.sourceRoomKey)!;
+    const rule = input.configuration.familyTypeRules.find((candidate) => candidate.exactFamilyAndType === object.sourceValues.familyAndType)!;
+    return {
+      id: input.createId(), projectId: input.projectId, sourceId, worksharingId: object.worksharingId, ifcGuid: object.ifcGuid,
+      deviceTypeId: rule.deviceTypeId, lastSeenImportBatchId: batchId, lastAcceptedImportBatchId: batchId,
+      acceptedSourceValues: object.sourceValues, planningValues: object.suggestedPlanningValues, overriddenFields: [],
+      externalRoomMappingId: roomMapping?.id ?? null,
+      distributionBoardId: roomMapping?.defaultDistributionBoardId ?? input.objectsWithoutRoomDefaultDistributionBoardId,
+      linkedProjectDeviceId: familyDecisions.get(object.sourceValues.familyAndType)!.projectDeviceId,
+      circuitDeviceRowId: null, presenceStatus: "present" as const,
+    };
+  });
+  return {
+    source: { id: sourceId, projectId: input.projectId, name: input.sourceName.trim(), sourceType: "revit_xlsx" },
+    importBatches: [{ id: batchId, projectId: input.projectId, sourceId, importKind: "initial", importedAtIso: input.importedAtIso, fileName: input.plan.fileName, sha256: input.plan.sha256, objectCount: objects.length, appliedProjectRevision: input.expectedRevision + 1, configurationSnapshot: input.configuration, originalContentBase64: input.originalContentBase64, document: input.document }],
+    roomMappings: mappings,
+    objects,
+  };
+}
+
+function exactDecisionMap<T>(expectedKeys: string[], decisions: T[], keyOf: (decision: T) => string, label: string) {
+  const expected = new Set(expectedKeys); const result = new Map<string, T>();
+  for (const decision of decisions) { const key = keyOf(decision); if (!expected.has(key) || result.has(key)) throw new Error(`${label}-Entscheidungen sind unvollständig oder doppelt.`); result.set(key, decision); }
+  if (result.size !== expected.size) throw new Error(`${label}-Entscheidungen sind unvollständig oder doppelt.`);
+  return result;
+}
diff --git a/src/external-model/application/external-xlsx-initial-import.ts b/src/external-model/application/external-xlsx-initial-import.ts
new file mode 100644
index 0000000..f89403c
--- /dev/null
+++ b/src/external-model/application/external-xlsx-initial-import.ts
@@ -0,0 +1,246 @@
+import { createHash } from "node:crypto";
+import type { ExternalModelConfiguration } from "../configuration/external-model-configuration.js";
+import type {
+  ExternalModelObjectPlanningValues,
+  ExternalModelObjectSourceValues,
+} from "../domain/external-model-contracts.js";
+import type {
+  ExternalXlsxDocument,
+  ExternalXlsxRow,
+  ExternalXlsxScalar,
+} from "../xlsx/external-xlsx-contracts.js";
+import { parseExternalXlsx } from "../xlsx/external-xlsx-transport.js";
+
+export interface ExternalInitialImportCatalogs {
+  floors: Array<{ id: string; name: string; sortOrder: number }>;
+  rooms: Array<{ id: string; floorId: string | null; roomNumber: string; roomName: string }>;
+  distributionBoards: Array<{ id: string; name: string; floorId: string | null }>;
+  projectDevices: Array<{
+    id: string;
+    name: string;
+    displayName: string;
+    category: string | null;
+    connectionKind: string | null;
+    powerPerUnit: number;
+  }>;
+}
+
+export interface ExternalInitialImportProjectedObject {
+  worksharingId: string;
+  ifcGuid: string | null;
+  sourceRoomKey: string | null;
+  sourceValues: ExternalModelObjectSourceValues;
+  suggestedPlanningValues: ExternalModelObjectPlanningValues;
+  issues: string[];
+}
+
+export interface ExternalInitialImportPlan {
+  fileName: string;
+  sha256: string;
+  byteLength: number;
+  rowCount: number;
+  objectCount: number;
+  passthroughCount: number;
+  suspectObjectCount: number;
+  suspectRowNumbers: number[];
+  warnings: string[];
+  sourceRooms: Array<{
+    sourceRoomKey: string;
+    roomNumber: string;
+    roomName: string;
+    objectCount: number;
+    suggestedRoomId: string | null;
+    matchStatus: "exact-number" | "ambiguous-number" | "new";
+    candidateRoomIds: string[];
+  }>;
+  familyGroups: Array<{
+    familyAndType: string;
+    objectCount: number;
+    classified: boolean;
+    deviceTypeId: string | null;
+    deviceTypeName: string | null;
+    quantityRule: "one" | "socketCount" | null;
+  }>;
+  issueCounts: {
+    unknownFamilyAndType: number;
+    invalidPower: number;
+    invalidQuantity: number;
+    missingRoom: number;
+  };
+  objects: ExternalInitialImportProjectedObject[];
+  existing: ExternalInitialImportCatalogs;
+}
+
+export async function createExternalXlsxInitialImportPlan(input: {
+  fileName: string;
+  bytes: Uint8Array;
+  configuration: ExternalModelConfiguration;
+  catalogs: ExternalInitialImportCatalogs;
+}): Promise<{ plan: ExternalInitialImportPlan; document: ExternalXlsxDocument }> {
+  const document = await parseExternalXlsx(input);
+  const columns = resolveColumns(document, input.configuration);
+  const rules = new Map(input.configuration.familyTypeRules.map((rule) => [rule.exactFamilyAndType, rule]));
+  const deviceTypes = new Map(input.configuration.deviceTypes.map((type) => [type.id, type]));
+  const objects = document.rows
+    .filter((row) => row.classification === "object")
+    .map((row) => projectObject(row, columns, rules, deviceTypes));
+
+  const roomCandidates = new Map<string, ExternalInitialImportCatalogs["rooms"]>();
+  for (const room of input.catalogs.rooms) {
+    const key = normalizeRoomPart(room.roomNumber);
+    if (!key) continue;
+    const entries = roomCandidates.get(key) ?? [];
+    entries.push(room);
+    roomCandidates.set(key, entries);
+  }
+  const sourceRoomMap = new Map<string, { sourceRoomKey: string; roomNumber: string; roomName: string; objectCount: number }>();
+  for (const object of objects) {
+    if (object.sourceRoomKey === null) continue;
+    const existing = sourceRoomMap.get(object.sourceRoomKey);
+    if (existing) existing.objectCount += 1;
+    else sourceRoomMap.set(object.sourceRoomKey, {
+      sourceRoomKey: object.sourceRoomKey,
+      roomNumber: scalarText(object.sourceValues.roomNumber),
+      roomName: scalarText(object.sourceValues.roomName),
+      objectCount: 1,
+    });
+  }
+  const sourceRooms = [...sourceRoomMap.values()].map((room) => {
+    const candidates = roomCandidates.get(normalizeRoomPart(room.roomNumber)) ?? [];
+    return {
+      ...room,
+      suggestedRoomId: candidates.length === 1 ? candidates[0].id : null,
+      matchStatus: candidates.length === 1 ? "exact-number" as const : candidates.length > 1 ? "ambiguous-number" as const : "new" as const,
+      candidateRoomIds: candidates.map((candidate) => candidate.id),
+    };
+  }).sort((a, b) => a.roomNumber.localeCompare(b.roomNumber, "de", { numeric: true }) || a.roomName.localeCompare(b.roomName, "de"));
+
+  const familyMap = new Map<string, ExternalInitialImportPlan["familyGroups"][number]>();
+  for (const object of objects) {
+    const name = object.sourceValues.familyAndType;
+    const existing = familyMap.get(name);
+    if (existing) { existing.objectCount += 1; continue; }
+    const rule = rules.get(name);
+    const type = rule ? deviceTypes.get(rule.deviceTypeId) : undefined;
+    familyMap.set(name, {
+      familyAndType: name,
+      objectCount: 1,
+      classified: Boolean(rule && type),
+      deviceTypeId: type?.id ?? null,
+      deviceTypeName: type?.name ?? null,
+      quantityRule: rule?.quantityRule ?? null,
+    });
+  }
+  const countIssue = (issue: string) => objects.filter((object) => object.issues.includes(issue)).length;
+  return {
+    document,
+    plan: {
+      fileName: input.fileName,
+      sha256: createHash("sha256").update(input.bytes).digest("hex"),
+      byteLength: input.bytes.byteLength,
+      rowCount: document.rows.length,
+      objectCount: objects.length,
+      passthroughCount: document.rows.filter((row) => row.classification === "passthrough").length,
+      suspectObjectCount: document.rows.filter((row) => row.classification === "suspect-object").length,
+      suspectRowNumbers: document.rows.filter((row) => row.classification === "suspect-object").map((row) => row.rowNumber),
+      warnings: document.issues.map((issue) => issue.message),
+      sourceRooms,
+      familyGroups: [...familyMap.values()].sort((a, b) => a.familyAndType.localeCompare(b.familyAndType, "de")),
+      issueCounts: {
+        unknownFamilyAndType: countIssue("unknown-family-and-type"),
+        invalidPower: countIssue("invalid-power"),
+        invalidQuantity: countIssue("invalid-quantity"),
+        missingRoom: countIssue("missing-room"),
+      },
+      objects,
+      existing: input.catalogs,
+    },
+  };
+}
+
+function resolveColumns(document: ExternalXlsxDocument, configuration: ExternalModelConfiguration) {
+  const byHeader = new Map(document.columns.map((column) => [column.header, column.columnNumber]));
+  return Object.fromEntries(Object.entries(configuration.columns).map(([key, header]) => [key, header === null ? null : byHeader.get(header) ?? null])) as Record<keyof ExternalModelConfiguration["columns"], number | null>;
+}
+
+function projectObject(
+  row: ExternalXlsxRow,
+  columns: Record<keyof ExternalModelConfiguration["columns"], number | null>,
+  rules: Map<string, ExternalModelConfiguration["familyTypeRules"][number]>,
+  deviceTypes: Map<string, ExternalModelConfiguration["deviceTypes"][number]>
+): ExternalInitialImportProjectedObject {
+  const value = (key: keyof typeof columns): ExternalXlsxScalar => {
+    const column = columns[key];
+    return column === null ? null : row.cells[column - 1]?.value ?? null;
+  };
+  const worksharingId = scalarText(value("worksharingId"));
+  const familyAndType = scalarText(value("familyAndType"));
+  const roomNumber = value("roomNumber");
+  const roomName = value("roomName");
+  const rule = rules.get(familyAndType);
+  const deviceType = rule ? deviceTypes.get(rule.deviceTypeId) : undefined;
+  const issues: string[] = [];
+  if (!rule || !deviceType) issues.push("unknown-family-and-type");
+  const sourcePower = nullableNumber(value("electricalPowerW"));
+  if (value("electricalPowerW") !== null && sourcePower === null) issues.push("invalid-power");
+  let quantity = 1;
+  if (rule?.quantityRule === "socketCount") {
+    const parsed = nullableNumber(value("socketCount"));
+    if (parsed === null || !Number.isSafeInteger(parsed) || parsed < 1) issues.push("invalid-quantity");
+    else quantity = parsed;
+  }
+  const sourceRoomKey = createExternalRoomKey(roomNumber, roomName);
+  if (sourceRoomKey === null) issues.push("missing-room");
+  const selectionMarker = value("selectionMarker");
+  const designation = value("designation");
+  const displayName = scalarText(designation) || scalarText(selectionMarker) || familyAndType || null;
+  return {
+    worksharingId,
+    ifcGuid: scalarText(value("ifcGuid")) || null,
+    sourceRoomKey,
+    sourceValues: {
+      rowNumber: row.rowNumber,
+      roomNumber,
+      roomName,
+      familyAndType,
+      selectionMarker,
+      socketCount: value("socketCount"),
+      sourceRemark: value("sourceRemark"),
+      circuitCombined: value("circuitCombined"),
+      boardName: value("boardName"),
+      circuitIdentifier: value("circuitIdentifier"),
+      designation,
+      electricalPowerW: value("electricalPowerW"),
+      voltageV: value("voltageV"),
+      currentA: value("currentA"),
+    },
+    suggestedPlanningValues: {
+      displayName,
+      category: deviceType?.category ?? null,
+      connectionKind: null,
+      effectiveQuantity: quantity,
+      powerPerUnitW: sourcePower ?? deviceType?.defaults.powerPerUnitW ?? null,
+      simultaneityFactor: deviceType?.defaults.simultaneityFactor ?? 1,
+      cosPhi: deviceType?.defaults.cosPhi ?? null,
+      costGroup: deviceType?.defaults.costGroup ?? null,
+      remark: scalarText(value("sourceRemark")) || null,
+    },
+    issues,
+  };
+}
+
+export function createExternalRoomKey(roomNumber: ExternalXlsxScalar, roomName: ExternalXlsxScalar) {
+  const number = normalizeRoomPart(scalarText(roomNumber));
+  const name = normalizeRoomPart(scalarText(roomName));
+  return number || name ? `${number}\u0000${name}` : null;
+}
+
+function normalizeRoomPart(value: string) { return value.trim().toLocaleLowerCase("de-DE"); }
+function scalarText(value: ExternalXlsxScalar) { return value === null ? "" : String(value).trim(); }
+function nullableNumber(value: ExternalXlsxScalar) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string" || !value.trim()) return null;
+  const normalized = value.trim().replace(/\s/g, "").replace(/,(?=\d+$)/, ".");
+  const parsed = Number(normalized);
+  return Number.isFinite(parsed) ? parsed : null;
+}
diff --git a/src/frontend/components/revit-initial-import-wizard.tsx b/src/frontend/components/revit-initial-import-wizard.tsx
new file mode 100644
index 0000000..8a4fc4d
--- /dev/null
+++ b/src/frontend/components/revit-initial-import-wizard.tsx
@@ -0,0 +1,106 @@
+"use client";
+
+import { useState, type FormEvent } from "react";
+import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration";
+import type { ExternalInitialImportPlanDto, ProjectHistoryStateDto } from "../types";
+import { applyExternalInitialImport, planExternalInitialImport } from "../utils/api";
+import { createClientId } from "../utils/client-id";
+import { FormModal } from "./form-modal";
+
+const steps = ["Vorschau", "Räume", "Verteiler", "Familienregeln", "Projektgeräte", "Bestätigung"];
+
+export function RevitInitialImportWizard({ projectId, expectedRevision, initialConfiguration, onClose, onImported }: {
+  projectId: string;
+  expectedRevision: number;
+  initialConfiguration: ExternalModelConfiguration;
+  onClose: () => void;
+  onImported: (result: { history: ProjectHistoryStateDto; objectCount: number }) => void;
+}) {
+  const [step, setStep] = useState(0);
+  const [file, setFile] = useState<File | null>(null);
+  const [configuration, setConfiguration] = useState(() => structuredClone(initialConfiguration));
+  const [plan, setPlan] = useState<ExternalInitialImportPlanDto | null>(null);
+  const [roomIds, setRoomIds] = useState<Record<string, string>>( {} );
+  const [boardIds, setBoardIds] = useState<Record<string, string>>( {} );
+  const [deviceIds, setDeviceIds] = useState<Record<string, string>>( {} );
+  const [sourceName, setSourceName] = useState("Revit-Gesamtmodell");
+  const [noRoomBoardId, setNoRoomBoardId] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  async function loadPlan(nextFile: File, nextConfiguration = configuration) {
+    setBusy(true); setError(null);
+    try {
+      const loaded = await planExternalInitialImport(projectId, nextFile, nextConfiguration, expectedRevision);
+      setPlan(loaded);
+      setRoomIds((current) => Object.fromEntries(loaded.sourceRooms.map((room) => [room.sourceRoomKey, current[room.sourceRoomKey] ?? room.suggestedRoomId ?? ""])));
+      setBoardIds((current) => Object.fromEntries(loaded.sourceRooms.map((room) => [room.sourceRoomKey, current[room.sourceRoomKey] ?? ""])));
+      setDeviceIds((current) => Object.fromEntries(loaded.familyGroups.map((family) => [family.familyAndType, current[family.familyAndType] ?? ""])));
+    } catch (value) { setError(value instanceof Error ? value.message : "XLSX-Vorschau fehlgeschlagen."); setPlan(null); }
+    finally { setBusy(false); }
+  }
+
+  async function classifyFamily(familyAndType: string, category: "lighting" | "single_phase" | "three_phase", quantityRule: "one" | "socketCount") {
+    if (!file) return;
+    const deviceTypeId = createClientId();
+    const next = structuredClone(configuration);
+    next.deviceTypes.push({ id: deviceTypeId, name: familyAndType, category, defaults: { powerPerUnitW: null, simultaneityFactor: 1, cosPhi: null, costGroup: null } });
+    next.familyTypeRules.push({ id: createClientId(), exactFamilyAndType: familyAndType, deviceTypeId, quantityRule });
+    setConfiguration(next);
+    await loadPlan(file, next);
+  }
+
+  async function assignExistingDeviceType(familyAndType: string, encoded: string) {
+    if (!file || !encoded) return;
+    const separator = encoded.lastIndexOf("|");
+    const deviceTypeId = encoded.slice(0, separator);
+    const quantityRule = encoded.slice(separator + 1) as "one" | "socketCount";
+    const next = structuredClone(configuration);
+    next.familyTypeRules.push({ id: createClientId(), exactFamilyAndType: familyAndType, deviceTypeId, quantityRule });
+    setConfiguration(next);
+    await loadPlan(file, next);
+  }
+
+  async function toggleQuantityRule(familyAndType: string) {
+    if (!file) return;
+    const next = structuredClone(configuration);
+    const rule = next.familyTypeRules.find((candidate) => candidate.exactFamilyAndType === familyAndType);
+    if (!rule) return;
+    rule.quantityRule = rule.quantityRule === "one" ? "socketCount" : "one";
+    setConfiguration(next);
+    await loadPlan(file, next);
+  }
+
+  async function submit(event: FormEvent) {
+    event.preventDefault();
+    if (step < steps.length - 1) { setStep(step + 1); return; }
+    if (!file || !plan) return;
+    setBusy(true); setError(null);
+    try {
+      const result = await applyExternalInitialImport(projectId, file, {
+        expectedRevision,
+        expectedSha256: plan.sha256,
+        sourceName,
+        configuration,
+        objectsWithoutRoomDefaultDistributionBoardId: noRoomBoardId || null,
+        roomDecisions: plan.sourceRooms.map((room) => ({ sourceRoomKey: room.sourceRoomKey, roomId: roomIds[room.sourceRoomKey] || null, defaultDistributionBoardId: boardIds[room.sourceRoomKey] || null })),
+        familyProjectDeviceDecisions: plan.familyGroups.map((family) => ({ familyAndType: family.familyAndType, projectDeviceId: deviceIds[family.familyAndType] || null })),
+      });
+      onImported({ history: result.history, objectCount: result.import.objectCount });
+    } catch (value) { setError(value instanceof Error ? value.message : "Erstimport fehlgeschlagen."); }
+    finally { setBusy(false); }
+  }
+
+  const blocked = !plan || (step >= 3 && (plan.issueCounts.unknownFamilyAndType > 0 || plan.issueCounts.invalidQuantity > 0));
+  return <FormModal dialogSize="viewport" title="Linear-XLSX-Erstimport" description={`Schritt ${step + 1} von ${steps.length}: ${steps[step]}`} isSaving={busy} onClose={onClose} onSubmit={(event) => void submit(event)} submitDisabled={blocked} submitLabel={step === steps.length - 1 ? "Erstimport übernehmen" : "Weiter"}>
+    <div className="d-flex gap-2 flex-wrap mb-3">{steps.map((label, index) => <span className={`badge ${index === step ? "text-bg-primary" : index < step ? "text-bg-success" : "text-bg-secondary"}`} key={label}>{index + 1}. {label}</span>)}</div>
+    {error ? <div className="alert alert-danger">{error}</div> : null}
+    {step === 0 ? <div className="row g-3"><div className="col-12"><label className="form-label" htmlFor="initial-xlsx">Linear-XLSX-Datei</label><input accept=".xlsx" className="form-control" id="initial-xlsx" type="file" onChange={(event) => { const selected = event.target.files?.[0] ?? null; setFile(selected); if (selected) void loadPlan(selected); }} /></div>{plan ? <><div className="col-md-3"><strong>{plan.objectCount}</strong><div className="text-secondary small">Objekte</div></div><div className="col-md-3"><strong>{plan.sourceRooms.length}</strong><div className="text-secondary small">Quellräume</div></div><div className="col-md-3"><strong>{plan.familyGroups.length}</strong><div className="text-secondary small">Familien</div></div><div className="col-md-3"><strong>{plan.suspectObjectCount}</strong><div className="text-secondary small">übersprungene verdächtige Zeilen</div></div><div className="col-12"><div className="small text-secondary">Unbekannte Familien: {plan.issueCounts.unknownFamilyAndType} · Ungültige Leistungen: {plan.issueCounts.invalidPower} · Ungültige Mengen: {plan.issueCounts.invalidQuantity} · Objekte ohne Raum: {plan.issueCounts.missingRoom}</div></div>{plan.warnings.length ? <div className="col-12"><div className="alert alert-warning mb-0">{plan.warnings.map((warning) => <div key={warning}>{warning}</div>)}</div></div> : null}</> : null}</div> : null}
+    {step === 1 && plan ? <div><p className="text-secondary">Quellräume vorhandenen Projekträumen zuordnen. Neue Räume können vorher in der Gebäudestruktur angelegt werden.</p>{plan.sourceRooms.map((room) => <div className="row align-items-center g-2 mb-2" key={room.sourceRoomKey}><div className="col-md-5"><strong>{room.roomNumber || "–"}</strong> {room.roomName} <span className="badge text-bg-light">{room.objectCount}</span></div><div className="col-md-7"><select className="form-select" value={roomIds[room.sourceRoomKey] ?? ""} onChange={(event) => setRoomIds({ ...roomIds, [room.sourceRoomKey]: event.target.value })}><option value="">Nicht zuordnen</option>{plan.existing.rooms.map((candidate) => <option value={candidate.id} key={candidate.id}>{candidate.roomNumber} · {candidate.roomName}</option>)}</select></div></div>)}</div> : null}
+    {step === 2 && plan ? <div><p className="text-secondary">Der Standardverteiler gilt beim Import nur für unzugeordnete Objekte.</p>{plan.sourceRooms.map((room) => <div className="row align-items-center g-2 mb-2" key={room.sourceRoomKey}><div className="col-md-5">{room.roomNumber || "–"} · {room.roomName}</div><div className="col-md-7"><select className="form-select" value={boardIds[room.sourceRoomKey] ?? ""} onChange={(event) => setBoardIds({ ...boardIds, [room.sourceRoomKey]: event.target.value })}><option value="">Kein Standardverteiler</option>{plan.existing.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></div></div>)}{plan.issueCounts.missingRoom > 0 ? <div className="row align-items-center g-2 mt-3"><div className="col-md-5"><strong>Objekte ohne Quellraum</strong> <span className="badge text-bg-light">{plan.issueCounts.missingRoom}</span></div><div className="col-md-7"><select className="form-select" value={noRoomBoardId} onChange={(event) => setNoRoomBoardId(event.target.value)}><option value="">Kein Standardverteiler</option>{plan.existing.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></div></div> : null}</div> : null}
+    {step === 3 && plan ? <div><p className="text-secondary">Exakte Familie-und-Typ-Werte werden einer Geräteart und Mengenregel zugeordnet. Ein fehlender GZF startet sichtbar mit 1.</p>{plan.familyGroups.map((family) => <div className="border rounded p-2 mb-2" key={family.familyAndType}><div className="d-flex justify-content-between gap-2"><div><strong>{family.familyAndType}</strong> <span className="badge text-bg-light">{family.objectCount}</span><div className="small text-secondary">{family.classified ? `${family.deviceTypeName} · ${family.quantityRule === "socketCount" ? "Anzahl aus XLSX" : "Menge 1"} · GZF 1, falls nicht gepflegt` : "Noch nicht klassifiziert"}</div></div>{family.classified ? <button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => void toggleQuantityRule(family.familyAndType)}>Mengenregel wechseln</button> : <div className="d-flex gap-2 flex-wrap justify-content-end">{configuration.deviceTypes.length ? <select aria-label={`Vorhandene Geräteart für ${family.familyAndType}`} className="form-select form-select-sm" defaultValue="" onChange={(event) => void assignExistingDeviceType(family.familyAndType, event.target.value)}><option value="">Vorhandene Geräteart wählen …</option>{configuration.deviceTypes.flatMap((type) => [<option value={`${type.id}|one`} key={`${type.id}-one`}>{type.name} · Menge 1</option>, <option value={`${type.id}|socketCount`} key={`${type.id}-socket`}>{type.name} · XLSX-Anzahl</option>])}</select> : null}<button className="btn btn-sm btn-outline-primary" type="button" onClick={() => void classifyFamily(family.familyAndType, "single_phase", "one")}>Neue 1-phasige Geräteart</button><button className="btn btn-sm btn-outline-primary" type="button" onClick={() => void classifyFamily(family.familyAndType, "single_phase", "socketCount")}>Neu · XLSX-Anzahl</button><button className="btn btn-sm btn-outline-primary" type="button" onClick={() => void classifyFamily(family.familyAndType, "lighting", "one")}>Neue Beleuchtungsart</button><button className="btn btn-sm btn-outline-primary" type="button" onClick={() => void classifyFamily(family.familyAndType, "three_phase", "one")}>Neue 3-phasige Geräteart</button></div>}</div></div>)}</div> : null}
+    {step === 4 && plan ? <div><p className="text-secondary">Optional kann jede Familie mit einem vorhandenen Projektgerät verknüpft werden.</p>{plan.familyGroups.map((family) => <div className="row align-items-center g-2 mb-2" key={family.familyAndType}><div className="col-md-5">{family.familyAndType}</div><div className="col-md-7"><select className="form-select" value={deviceIds[family.familyAndType] ?? ""} onChange={(event) => setDeviceIds({ ...deviceIds, [family.familyAndType]: event.target.value })}><option value="">Kein Projektgerät</option>{plan.existing.projectDevices.map((device) => <option value={device.id} key={device.id}>{device.name} · {device.displayName}</option>)}</select></div></div>)}</div> : null}
+    {step === 5 && plan ? <div className="row g-3"><div className="col-12"><label className="form-label" htmlFor="source-name">Quellenname</label><input className="form-control" id="source-name" value={sourceName} onChange={(event) => setSourceName(event.target.value)} /></div><div className="col-12"><div className="alert alert-info mb-0"><strong>{plan.objectCount} Revit-Objekte</strong> werden importiert. Es werden keine Gerätezeilen, Stromkreise oder BMKs erzeugt. Die Datei wird beim Übernehmen erneut übertragen und geprüft.</div></div></div> : null}
+    {step > 0 ? <button className="btn btn-link px-0 mt-3" disabled={busy} onClick={() => setStep(step - 1)} type="button">Zurück</button> : null}
+  </FormModal>;
+}
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 401b618..9a18a94 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -10,10 +10,6 @@ import type {
   ProtectionDeviceType,
   RcdType,
 } from "../shared/constants/protection-device";
-import type {
-  ExternalCsvConfiguration,
-  ExternalCsvDialect,
-} from "../external-model/csv/external-csv-contracts";
 import type { ExternalModelConfiguration } from "../external-model/configuration/external-model-configuration";
 
 export interface ExternalModelConfigurationSnapshotDto {
@@ -22,44 +18,7 @@ export interface ExternalModelConfigurationSnapshotDto {
   configuration: ExternalModelConfiguration;
 }
 
-export interface ExternalCsvConfigurationSnapshotDto {
-  id: string;
-  projectId: string;
-  configurationVersion: number;
-  configuration: ExternalCsvConfiguration;
-}
-
-export interface ExternalCsvPreviewObjectDto {
-  rowNumber: number;
-  ifcGuid: string;
-  roomNumber: string;
-  roomName: string;
-  familyAndType: string;
-  selectionMarker: string;
-  circuitIdentifier: string;
-  power: string;
-  quantity: string | null;
-  additionalSourceValues: Record<string, string>;
-}
-
-export interface ExternalCsvPreviewDto {
-  fileName: string;
-  byteLength: number;
-  sha256: string;
-  dialect: ExternalCsvDialect;
-  headerRowNumber: number;
-  headerColumns: string[];
-  rowCount: number;
-  objectCount: number;
-  passthroughCount: number;
-  nonEmptyPassthroughCount: number;
-  suspectObjectCount: number;
-  objects: ExternalCsvPreviewObjectDto[];
-  suspectRowNumbers: number[];
-}
-
 export interface ExternalInitialImportPlanDto {
-  configurationVersion: number;
   fileName: string;
   sha256: string;
   byteLength: number;
@@ -68,6 +27,7 @@ export interface ExternalInitialImportPlanDto {
   passthroughCount: number;
   suspectObjectCount: number;
   suspectRowNumbers: number[];
+  warnings: string[];
   sourceRooms: Array<{
     sourceRoomKey: string;
     roomNumber: string;
@@ -81,9 +41,9 @@ export interface ExternalInitialImportPlanDto {
     familyAndType: string;
     objectCount: number;
     classified: boolean;
-    category: string | null;
-    connectionKind: string | null;
-    internalDeviceType: string | null;
+    deviceTypeId: string | null;
+    deviceTypeName: string | null;
+    quantityRule: "one" | "socketCount" | null;
   }>;
   issueCounts: {
     unknownFamilyAndType: number;
@@ -91,24 +51,7 @@ export interface ExternalInitialImportPlanDto {
     invalidQuantity: number;
     missingRoom: number;
   };
-  objects: Array<{
-    ifcGuid: string;
-    sourceRoomKey: string | null;
-    sourceValues: ExternalCsvPreviewObjectDto;
-    suggestedPlanningValues: {
-      displayName: string | null;
-      internalDeviceType: string | null;
-      category: CircuitGroupCategory | null;
-      connectionKind: string | null;
-      effectiveQuantity: number;
-      powerPerUnitW: number | null;
-      simultaneityFactor: number;
-      cosPhi: number | null;
-      costGroup: string | null;
-      remark: string | null;
-    };
-    issues: string[];
-  }>;
+  objects: Array<{ worksharingId: string; ifcGuid: string | null; sourceRoomKey: string | null; sourceValues: { familyAndType: string }; suggestedPlanningValues: { simultaneityFactor: number; effectiveQuantity: number }; issues: string[] }>;
   existing: {
     floors: Array<{ id: string; name: string; sortOrder: number }>;
     rooms: Array<{
@@ -135,11 +78,12 @@ export interface ExternalInitialImportPlanDto {
 
 export interface ApplyExternalInitialImportInput {
   expectedRevision: number;
-  expectedConfigurationVersion: number;
   expectedSha256: string;
   fileName: string;
   contentBase64: string;
   sourceName: string;
+  configuration: ExternalModelConfiguration;
+  objectsWithoutRoomDefaultDistributionBoardId: string | null;
   roomDecisions: Array<{
     sourceRoomKey: string;
     roomId: string | null;
@@ -151,6 +95,14 @@ export interface ApplyExternalInitialImportInput {
   }>;
 }
 
+export interface ExternalInitialImportStatusDto {
+  imported: boolean;
+  sourceName: string | null;
+  objectCount: number;
+  importedAtIso: string | null;
+  fileName: string | null;
+}
+
 export interface ExternalInitialImportResultDto extends ProjectCommandResultDto {
   import: {
     sourceId: string;
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index 3694c2e..692640d 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -39,6 +39,10 @@ import type {
   CircuitTreeResponseDto,
   ProjectCircuitTreesResponseDto,
   ExternalModelConfigurationSnapshotDto,
+  ExternalInitialImportPlanDto,
+  ExternalInitialImportResultDto,
+  ExternalInitialImportStatusDto,
+  ApplyExternalInitialImportInput,
   CreateEstimateBalanceInput,
   EstimateBalanceCommandResultDto,
   EstimateBalanceDto,
@@ -198,6 +202,40 @@ export async function detectExternalModelWorkbook(
   );
 }
 
+export function getExternalInitialImportStatus(projectId: string) {
+  return request<ExternalInitialImportStatusDto>(`/api/projects/${projectId}/external-model/import-status`);
+}
+
+export async function planExternalInitialImport(
+  projectId: string,
+  file: File,
+  configuration: ExternalModelConfiguration,
+  expectedRevision: number
+) {
+  return request<ExternalInitialImportPlanDto>(`/api/projects/${projectId}/external-model/initial-import/plan`, {
+    method: "POST",
+    body: JSON.stringify({ fileName: file.name, contentBase64: await fileToBase64(file), configuration, expectedRevision }),
+  });
+}
+
+export async function applyExternalInitialImport(
+  projectId: string,
+  file: File,
+  input: Omit<ApplyExternalInitialImportInput, "fileName" | "contentBase64">
+) {
+  return request<ExternalInitialImportResultDto>(`/api/projects/${projectId}/external-model/initial-import/apply`, {
+    method: "POST",
+    body: JSON.stringify({ ...input, fileName: file.name, contentBase64: await fileToBase64(file) }),
+  });
+}
+
+async function fileToBase64(file: File) {
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
 export function getProjectHistory(projectId: string) {
   return request<ProjectHistoryStateDto>(
     `/api/projects/${projectId}/history`
diff --git a/src/frontend/utils/project-version-history.ts b/src/frontend/utils/project-version-history.ts
index 6a191cb..4d6003a 100644
--- a/src/frontend/utils/project-version-history.ts
+++ b/src/frontend/utils/project-version-history.ts
@@ -64,6 +64,7 @@ const commandTypeLabels: Record<string, string> = {
   "external-csv-configuration.update": "Revit-CSV-Konfiguration bearbeitet",
   "external-model-configuration.update": "Revit-XLSX-Einstellungen bearbeitet",
   "external-import.apply-initial": "Revit-Erstimport übernommen",
+  "external-model.apply-initial-import": "Linear-XLSX-Erstimport übernommen",
   "external-object.assign-to-new-circuit":
     "Externes Objekt in neuen Stromkreis übernommen",
   "external-object.unassign-and-delete-created-circuit":
diff --git a/src/server/composition/project-command-stores.ts b/src/server/composition/project-command-stores.ts
index 00f2d5f..4017144 100644
--- a/src/server/composition/project-command-stores.ts
+++ b/src/server/composition/project-command-stores.ts
@@ -23,6 +23,7 @@ import { ProjectSettingsProjectCommandRepository } from "../../db/repositories/p
 import { ProjectStateRestoreCommandRepository } from "../../db/repositories/project-state-restore-command.repository.js";
 import { ProjectCommandService } from "../../domain/services/project-command.service.js";
 import { ExternalModelConfigurationProjectCommandRepository } from "../../db/repositories/external-model-configuration-project-command.repository.js";
+import { ExternalInitialImportProjectCommandRepository } from "../../db/repositories/external-initial-import-project-command.repository.js";
 import { ExternalObjectRowAssignmentProjectCommandRepository } from "../../db/repositories/external-object-row-assignment-project-command.repository.js";
 import { ExternalObjectNewRowProjectCommandRepository } from "../../db/repositories/external-object-new-row-project-command.repository.js";
 import { ExternalObjectNewCircuitProjectCommandRepository } from "../../db/repositories/external-object-new-circuit-project-command.repository.js";
@@ -72,6 +73,8 @@ export const projectStateRestoreCommandStore =
 export const projectHistoryStore = new ProjectHistoryRepository(db);
 export const externalModelConfigurationProjectCommandStore =
   new ExternalModelConfigurationProjectCommandRepository(db);
+export const externalInitialImportProjectCommandStore =
+  new ExternalInitialImportProjectCommandRepository(db);
 export const externalObjectRowAssignmentProjectCommandStore =
   new ExternalObjectRowAssignmentProjectCommandRepository(db);
 export const externalObjectNewRowProjectCommandStore =
@@ -107,5 +110,6 @@ export const projectCommandService = new ProjectCommandService(
   externalObjectRowAssignmentProjectCommandStore,
   externalObjectNewRowProjectCommandStore,
   externalObjectNewCircuitProjectCommandStore,
-  estimateBalanceProjectCommandStore
+  estimateBalanceProjectCommandStore,
+  externalInitialImportProjectCommandStore
 );
diff --git a/src/server/controllers/external-initial-import.controller.ts b/src/server/controllers/external-initial-import.controller.ts
new file mode 100644
index 0000000..53227f4
--- /dev/null
+++ b/src/server/controllers/external-initial-import.controller.ts
@@ -0,0 +1,68 @@
+import { randomUUID } from "node:crypto";
+import type { Request, Response } from "express";
+import { createEmptyExternalModelState, createExternalInitialImportProjectCommand } from "../../domain/models/external-initial-import-project-command.model.js";
+import { createExternalXlsxInitialImportPlan } from "../../external-model/application/external-xlsx-initial-import.js";
+import { buildExternalXlsxInitialImportTarget } from "../../external-model/application/external-xlsx-initial-import-target.js";
+import { assertExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
+import { distributionBoardRepository, externalModelConfigurationRepository, externalModelStateRepository, floorRepository, projectDeviceRepository, projectRepository, roomRepository } from "../composition/application-repositories.js";
+import { projectCommandService } from "../composition/project-command-stores.js";
+import { respondWithProjectCommandError } from "./project-command.controller.js";
+
+export function getExternalInitialImportStatus(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  const result = externalModelStateRepository.getByProject(projectId);
+  if (!result.projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+  const batch = result.state.importBatches.at(-1) ?? null;
+  return res.json({ imported: result.state.source !== null, sourceName: result.state.source?.name ?? null, objectCount: result.state.objects.length, importedAtIso: batch?.importedAtIso ?? null, fileName: batch?.fileName ?? null });
+}
+
+export async function planExternalInitialImport(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = req.body?.expectedRevision;
+    if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) throw new Error("Ungültige Projektrevision.");
+    const stored = externalModelConfigurationRepository.getByProject(projectId);
+    if (!stored.projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    if (!stored.configuration) return res.status(409).json({ error: "Für das Projekt ist noch keine Revit-XLSX-Konfiguration gespeichert.", code: "EXTERNAL_XLSX_CONFIGURATION_REQUIRED" });
+    const project = await projectRepository.findById(projectId);
+    if (!project || project.currentRevision !== expectedRevision) return res.status(409).json({ error: "Der Erstimportplan ist wegen einer neueren Projektrevision ungültig.", code: "PROJECT_REVISION_CONFLICT", expectedRevision, currentRevision: project?.currentRevision ?? null });
+    if (externalModelStateRepository.getByProject(projectId).state.source) return res.status(409).json({ error: "Für dieses Projekt wurde bereits ein Revit-Modell importiert.", code: "EXTERNAL_INITIAL_IMPORT_ALREADY_APPLIED" });
+    const configuration = req.body?.configuration ?? stored.configuration.configuration;
+    assertExternalModelConfiguration(configuration);
+    const { plan } = await createExternalXlsxInitialImportPlan({ fileName: requiredString(req.body?.fileName, "Dateiname"), bytes: decodeBase64(req.body?.contentBase64), configuration, catalogs: await loadCatalogs(projectId) });
+    return res.json(plan);
+  } catch (error) {
+    return res.status(400).json({ error: error instanceof Error ? error.message : "Erstimport-Vorschau fehlgeschlagen." });
+  }
+}
+
+export async function applyExternalInitialImport(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = req.body?.expectedRevision;
+    if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) throw new Error("Ungültige Projektrevision.");
+    const stored = externalModelConfigurationRepository.getByProject(projectId);
+    if (!stored.projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    if (!stored.configuration) return res.status(409).json({ error: "Für das Projekt ist noch keine Revit-XLSX-Konfiguration gespeichert.", code: "EXTERNAL_XLSX_CONFIGURATION_REQUIRED" });
+    if (externalModelStateRepository.getByProject(projectId).state.source) return res.status(409).json({ error: "Für dieses Projekt wurde bereits ein Revit-Modell importiert.", code: "EXTERNAL_INITIAL_IMPORT_ALREADY_APPLIED" });
+    assertExternalModelConfiguration(req.body?.configuration);
+    const bytes = decodeBase64(req.body?.contentBase64);
+    const { plan, document } = await createExternalXlsxInitialImportPlan({ fileName: requiredString(req.body?.fileName, "Dateiname"), bytes, configuration: req.body.configuration, catalogs: await loadCatalogs(projectId) });
+    if (plan.sha256 !== req.body?.expectedSha256) return res.status(409).json({ error: "Die XLSX-Datei stimmt nicht mehr mit der geprüften Vorschau überein.", code: "EXTERNAL_XLSX_FILE_CHANGED" });
+    const target = buildExternalXlsxInitialImportTarget({ projectId, expectedRevision, sourceName: requiredString(req.body?.sourceName, "Quellenname"), importedAtIso: new Date().toISOString(), configuration: req.body.configuration, originalContentBase64: req.body.contentBase64, document, plan, roomDecisions: requireArray(req.body?.roomDecisions, "Raumentscheidungen"), familyProjectDeviceDecisions: requireArray(req.body?.familyProjectDeviceDecisions, "ProjectDevice-Entscheidungen"), objectsWithoutRoomDefaultDistributionBoardId: nullableString(req.body?.objectsWithoutRoomDefaultDistributionBoardId, "Standardverteiler ohne Raum"), createId: randomUUID });
+    const targetConfiguration = { id: stored.configuration.id, projectId, configuration: req.body.configuration };
+    const result = projectCommandService.executeUser({ projectId, expectedRevision, description: `Revit-Erstimport ${plan.fileName}`, command: createExternalInitialImportProjectCommand(stored.configuration, targetConfiguration, createEmptyExternalModelState(), target) });
+    return res.status(201).json({ ...result, import: { sourceId: target.source!.id, importBatchId: target.importBatches[0].id, objectCount: target.objects.length } });
+  } catch (error) {
+    return respondWithProjectCommandError(error, res);
+  }
+}
+
+async function loadCatalogs(projectId: string) {
+  const [floors, rooms, distributionBoards, projectDevices] = await Promise.all([floorRepository.listByProject(projectId), roomRepository.listByProject(projectId), distributionBoardRepository.listByProject(projectId), projectDeviceRepository.listByProject(projectId)]);
+  return { floors, rooms, distributionBoards, projectDevices };
+}
+function decodeBase64(value: unknown) { if (typeof value !== "string" || !/^[A-Za-z0-9+/]*={0,2}$/.test(value) || value.length % 4 !== 0) throw new Error("XLSX-Inhalt ist nicht gültig Base64-kodiert."); const bytes = Buffer.from(value, "base64"); if (bytes.toString("base64") !== value) throw new Error("XLSX-Inhalt ist nicht kanonisch Base64-kodiert."); return bytes; }
+function requiredString(value: unknown, label: string) { if (typeof value !== "string" || !value.trim()) throw new Error(`${label} fehlt.`); return value.trim(); }
+function nullableString(value: unknown, label: string) { if (value === null || value === undefined || value === "") return null; if (typeof value !== "string") throw new Error(`${label} ist ungültig.`); return value; }
+function requireArray<T>(value: unknown, label: string): T[] { if (!Array.isArray(value)) throw new Error(`${label} fehlen.`); return value as T[]; }
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index d0ca12d..84f2ea3 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -58,6 +58,11 @@ import {
   detectExternalModelWorkbook,
   updateExternalModelConfiguration,
 } from "../controllers/external-model-configuration.controller.js";
+import {
+  applyExternalInitialImport,
+  getExternalInitialImportStatus,
+  planExternalInitialImport,
+} from "../controllers/external-initial-import.controller.js";
 
 export const projectRouter = Router();
 
@@ -82,6 +87,9 @@ projectRouter.put("/:projectId", updateProjectSettings);
 projectRouter.get("/:projectId/external-model/configuration", getExternalModelConfiguration);
 projectRouter.put("/:projectId/external-model/configuration", updateExternalModelConfiguration);
 projectRouter.post("/:projectId/external-model/configuration/detect", detectExternalModelWorkbook);
+projectRouter.get("/:projectId/external-model/import-status", getExternalInitialImportStatus);
+projectRouter.post("/:projectId/external-model/initial-import/plan", planExternalInitialImport);
+projectRouter.post("/:projectId/external-model/initial-import/apply", applyExternalInitialImport);
 projectRouter.get("/:projectId/distribution-boards", listDistributionBoardsByProject);
 projectRouter.post("/:projectId/distribution-boards", createDistributionBoard);
 projectRouter.post(
diff --git a/tests/external-xlsx-initial-import.test.ts b/tests/external-xlsx-initial-import.test.ts
new file mode 100644
index 0000000..33400d6
--- /dev/null
+++ b/tests/external-xlsx-initial-import.test.ts
@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { ExternalInitialImportProjectCommandRepository } from "../src/db/repositories/external-initial-import-project-command.repository.js";
+import { ExternalModelStateRepository } from "../src/db/repositories/external-model-state.repository.js";
+import { externalModelConfigurations } from "../src/db/schema/external-model-configurations.js";
+import { projects } from "../src/db/schema/projects.js";
+import { createEmptyExternalModelState, createExternalInitialImportProjectCommand } from "../src/domain/models/external-initial-import-project-command.model.js";
+import { createExternalXlsxInitialImportPlan } from "../src/external-model/application/external-xlsx-initial-import.js";
+import { buildExternalXlsxInitialImportTarget } from "../src/external-model/application/external-xlsx-initial-import-target.js";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
+import { createRevitXlsxFixture, externalXlsxTestConfiguration, firstWorksharingId } from "./fixtures/revit-xlsx-fixtures.js";
+
+const deviceTypeA = "10000000-0000-4000-8000-000000000001";
+const deviceTypeB = "10000000-0000-4000-8000-000000000002";
+
+function configured() {
+  return {
+    ...createDefaultExternalModelConfiguration(),
+    ...externalXlsxTestConfiguration,
+    deviceTypes: [
+      { id: deviceTypeA, name: "Steckdose", category: "single_phase" as const, defaults: { powerPerUnitW: null, simultaneityFactor: null, cosPhi: 0.9, costGroup: "440" } },
+      { id: deviceTypeB, name: "Leuchte", category: "lighting" as const, defaults: { powerPerUnitW: 40, simultaneityFactor: 0.8, cosPhi: null, costGroup: null } },
+    ],
+    familyTypeRules: [
+      { id: "20000000-0000-4000-8000-000000000001", exactFamilyAndType: "Steckdose: Standard", deviceTypeId: deviceTypeA, quantityRule: "socketCount" as const },
+      { id: "20000000-0000-4000-8000-000000000002", exactFamilyAndType: "Leuchte: Decke", deviceTypeId: deviceTypeB, quantityRule: "one" as const },
+    ],
+  };
+}
+
+describe("Linear XLSX initial import", () => {
+  it("plans exact families, skips suspicious rows and defaults missing GZF to one", async () => {
+    const { plan } = await createExternalXlsxInitialImportPlan({ fileName: "linear.xlsx", bytes: await createRevitXlsxFixture(), configuration: configured(), catalogs: { floors: [], rooms: [], distributionBoards: [], projectDevices: [] } });
+    assert.equal(plan.objectCount, 2);
+    assert.equal(plan.suspectObjectCount, 1);
+    assert.equal(plan.issueCounts.unknownFamilyAndType, 0);
+    assert.equal(plan.objects[0].worksharingId, firstWorksharingId);
+    assert.equal(plan.objects[0].suggestedPlanningValues.effectiveQuantity, 2);
+    assert.equal(plan.objects[0].suggestedPlanningValues.simultaneityFactor, 1);
+    assert.equal(plan.objects[1].suggestedPlanningValues.simultaneityFactor, 0.8);
+  });
+
+  it("commits atomically and undo/redo uses stored states", async () => {
+    const context = createDatabaseContext(":memory:");
+    migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+    context.db.insert(projects).values({ id: "project-1", name: "Projekt" }).run();
+    const configuration = configured();
+    const configurationSnapshot = { id: "config-1", projectId: "project-1", configuration };
+    context.db.insert(externalModelConfigurations).values(configurationSnapshot).run();
+    try {
+      const bytes = await createRevitXlsxFixture();
+      const { plan, document } = await createExternalXlsxInitialImportPlan({ fileName: "linear.xlsx", bytes, configuration, catalogs: { floors: [], rooms: [], distributionBoards: [], projectDevices: [] } });
+      let sequence = 0;
+      const target = buildExternalXlsxInitialImportTarget({ projectId: "project-1", expectedRevision: 0, sourceName: "Revit", importedAtIso: "2026-09-30T10:00:00.000Z", configuration, originalContentBase64: Buffer.from(bytes).toString("base64"), document, plan, roomDecisions: plan.sourceRooms.map((room) => ({ sourceRoomKey: room.sourceRoomKey, roomId: null, defaultDistributionBoardId: null })), familyProjectDeviceDecisions: plan.familyGroups.map((family) => ({ familyAndType: family.familyAndType, projectDeviceId: null })), objectsWithoutRoomDefaultDistributionBoardId: null, createId: () => `30000000-0000-4000-8000-${String(++sequence).padStart(12, "0")}` });
+      const repository = new ExternalInitialImportProjectCommandRepository(context.db);
+      const inserted = repository.execute({ projectId: "project-1", expectedRevision: 0, source: "user", command: createExternalInitialImportProjectCommand(configurationSnapshot, configurationSnapshot, createEmptyExternalModelState(), target) });
+      assert.equal(inserted.revision.revisionNumber, 1);
+      assert.equal(new ExternalModelStateRepository(context.db).getByProject("project-1").state.objects.length, 2);
+      const undone = repository.execute({ projectId: "project-1", expectedRevision: 1, source: "undo", historyTargetChangeSetId: inserted.revision.changeSetId, command: inserted.inverse });
+      assert.equal(new ExternalModelStateRepository(context.db).getByProject("project-1").state.source, null);
+      repository.execute({ projectId: "project-1", expectedRevision: 2, source: "redo", historyTargetChangeSetId: inserted.revision.changeSetId, command: undone.inverse });
+      assert.deepEqual(new ExternalModelStateRepository(context.db).getByProject("project-1").state.objects.map((object) => object.worksharingId), plan.objects.map((object) => object.worksharingId).sort());
+    } finally { context.close(); }
+  });
+});
diff --git a/tests/revit-xlsx-settings-api.test.ts b/tests/revit-xlsx-settings-api.test.ts
index 090e6b3..22d633c 100644
--- a/tests/revit-xlsx-settings-api.test.ts
+++ b/tests/revit-xlsx-settings-api.test.ts
@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { describe, it } from "node:test";
 import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
-import { detectExternalModelWorkbook, getExternalModelConfiguration, updateExternalModelConfiguration } from "../src/frontend/utils/api.js";
+import { applyExternalInitialImport, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, planExternalInitialImport, updateExternalModelConfiguration } from "../src/frontend/utils/api.js";
 
 describe("Revit XLSX settings", () => {
   it("uses the project-scoped configuration endpoint with expectedRevision", async () => {
@@ -25,14 +25,41 @@ describe("Revit XLSX settings", () => {
     } finally { globalThis.fetch = originalFetch; }
   });
 
+  it("uses stateless preview and retransmits the workbook for apply", async () => {
+    const requests: Array<{ url: string; method: string; body: Record<string, unknown> | undefined }> = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+      requests.push({ url: String(input), method: init?.method ?? "GET", body: init?.body ? JSON.parse(String(init.body)) : undefined });
+      return new Response(JSON.stringify({ imported: false, familyGroups: [], sourceRooms: [], objects: [], warnings: [], issueCounts: {}, existing: {}, history: { currentRevision: 9 }, import: { objectCount: 2 } }), { status: 200, headers: { "Content-Type": "application/json" } });
+    };
+    try {
+      const configuration = createDefaultExternalModelConfiguration();
+      const file = new File([new Uint8Array([1, 2])], "linear.xlsx");
+      await getExternalInitialImportStatus("project-1");
+      await planExternalInitialImport("project-1", file, configuration, 8);
+      await applyExternalInitialImport("project-1", file, { expectedRevision: 8, expectedSha256: "a".repeat(64), sourceName: "Revit", configuration, objectsWithoutRoomDefaultDistributionBoardId: null, roomDecisions: [], familyProjectDeviceDecisions: [] });
+      assert.equal(requests[0].url, "/api/projects/project-1/external-model/import-status");
+      assert.equal(requests[1].url, "/api/projects/project-1/external-model/initial-import/plan");
+      assert.equal(requests[2].url, "/api/projects/project-1/external-model/initial-import/apply");
+      assert.equal(requests[1].body?.contentBase64, "AQI=");
+      assert.equal(requests[1].body?.expectedRevision, 8);
+      assert.equal(requests[2].body?.contentBase64, "AQI=");
+      assert.equal(requests[2].body?.expectedRevision, 8);
+    } finally { globalThis.fetch = originalFetch; }
+  });
+
   it("exposes the Revit route and removes the old project modal", () => {
     const projectPage = readFileSync("src/app/projects/[projectId]/page.tsx", "utf8");
     const revitPage = readFileSync("src/app/projects/[projectId]/revit/page.tsx", "utf8");
     const settings = readFileSync("src/frontend/components/revit-xlsx-settings-modal.tsx", "utf8");
+    const wizard = readFileSync("src/frontend/components/revit-initial-import-wizard.tsx", "utf8");
     assert.match(projectPage, /href={`\/projects\/\$\{projectId\}\/revit`}/);
     assert.doesNotMatch(projectPage, /RevitCsvModal|Revit-CSV/);
     assert.match(revitPage, /Importstatus/);
     assert.match(settings, /Musterdatei prüfen/);
     assert.match(settings, /Kombinierte Stromkreisspalte/);
+    assert.match(wizard, /Schritt.*von/);
+    assert.match(wizard, /keine Gerätezeilen, Stromkreise oder BMKs/);
+    assert.match(wizard, /GZF 1/);
   });
 });

From 4ac32e103da9b9c81772687002147ba1987c0d8d Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 10:03:36 +0200
Subject: [PATCH 54/60] Add virtualized Revit object planning

---
 AGENTS.md                                     |  7 +-
 README.md                                     |  6 +-
 docs/spec/revit-excel-phase-14-plan.md        | 10 ++-
 src/app/projects/[projectId]/revit/page.tsx   |  2 +
 ...ect-planning-project-command.repository.ts | 29 ++++++++
 ...l-object-planning-project-command.model.ts | 30 ++++++++
 ...l-object-planning-project-command.store.ts |  3 +
 .../services/project-command.service.ts       | 10 ++-
 .../components/revit-object-table.tsx         | 73 +++++++++++++++++++
 src/frontend/types.ts                         | 15 ++++
 src/frontend/utils/api.ts                     |  9 +++
 src/frontend/utils/project-version-history.ts |  1 +
 .../composition/project-command-stores.ts     |  6 +-
 .../external-objects.controller.ts            | 56 ++++++++++++++
 src/server/routes/project.routes.ts           |  3 +
 tests/external-xlsx-initial-import.test.ts    | 12 ++-
 tests/revit-xlsx-settings-api.test.ts         | 14 +++-
 17 files changed, 277 insertions(+), 9 deletions(-)
 create mode 100644 src/db/repositories/external-object-planning-project-command.repository.ts
 create mode 100644 src/domain/models/external-object-planning-project-command.model.ts
 create mode 100644 src/domain/ports/external-object-planning-project-command.store.ts
 create mode 100644 src/frontend/components/revit-object-table.tsx
 create mode 100644 src/server/controllers/external-objects.controller.ts

diff --git a/AGENTS.md b/AGENTS.md
index d771e59..d438bae 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -339,6 +339,11 @@ external model state atomically; its inverse powers persistent Undo/Redo
 without parsing workbook bytes. Apply retransmits and reparses the XLSX,
 verifies its preview SHA-256 and creates no circuit, equipment identifier or
 CircuitDeviceRow.
+R6 adds one compact project-wide external-object GET without pagination or
+batch payloads. The Revit page filters and sorts it in the client and renders a
+virtualized window. `external-object.update-planning` applies multi-object
+board, ProjectDevice and planning-value changes as one persistent command;
+linked objects are excluded because they follow their CircuitDeviceRow board.
 
 The target configuration has no independent version counter; `expectedRevision`
 invalidates stale plans, and each import batch stores a configuration copy.
@@ -592,7 +597,7 @@ Critical target rules:
   selected combined/separate mode block export.
 - Missing GZF defaults visibly to 1 without separate confirmation.
 - The corrected R2 return workbook was successfully imported into Linear on
-  2026-09-30; R3 through R5 are complete and R6 is the next package.
+  2026-09-30; R3 through R6 are complete and R7 is the next package.
 - All confirmed writes use typed project commands with `expectedRevision`,
   complete inverse data and the shared project-command transaction boundary.
 - Do not add automatic circuit planning, Revit circuit adoption, multi-source
diff --git a/README.md b/README.md
index b965df8..d4aeae4 100644
--- a/README.md
+++ b/README.md
@@ -11,10 +11,10 @@ für mehrere gleichzeitig arbeitende Prozesse und ein vollständig unterstützte
 Produktionsdeployment fehlen weiterhin. Anmeldung und zwei feste Rollen sind
 vorhanden. Die Backend- und Persistenzgrundlage der bisherigen
 Revit-CSV-/IfcGUID-Anbindung ist durch den XLSX-Austausch des Linear-Plugins mit
-Worksharing-ID als externem Schlüssel ersetzt. R0 bis R5 sind abgeschlossen;
+Worksharing-ID als externem Schlüssel ersetzt. R0 bis R6 sind abgeschlossen;
 die eigene Revit-Seite besitzt XLSX-Einstellungen und einen persistenten
-Erstimport. Objekttabelle, Editorzuordnung, Rückgabe und Folgeimport folgen in
-R6 bis R10.
+Erstimport sowie eine virtualisierte Objekttabelle mit Sammeländerungen.
+Editorzuordnung, Rückgabe und Folgeimport folgen in R7 bis R10.
 
 ## Unterstützter Arbeitsablauf
 
diff --git a/docs/spec/revit-excel-phase-14-plan.md b/docs/spec/revit-excel-phase-14-plan.md
index f4d1c7c..9b43c4f 100644
--- a/docs/spec/revit-excel-phase-14-plan.md
+++ b/docs/spec/revit-excel-phase-14-plan.md
@@ -14,7 +14,7 @@ Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
 | R3 | abgeschlossen | Konfiguration ohne eigene Revision, Worksharing-ID-Datenmodell, Migration 0014, Snapshot 10, Transfer und Backend-CSV-Entfernung sind umgesetzt und geprüft. |
 | R4 | abgeschlossen | Revit-Seite, Navigation und revisionierte XLSX-Einstellungen mit Musterdateiprüfung sind umgesetzt; das alte Projektseitenmodal ist entfernt. |
 | R5 | abgeschlossen | Zustandslose XLSX-Vorschau, sechsstufiger Erstimportwizard und atomarer Importcommand mit parserfreiem Undo/Redo. |
-| R6 | offen | Virtualisierte Objekttabelle und Sammelzuordnungen. |
+| R6 | abgeschlossen | Projektweite kompakte Objektliste, clientseitige Filter/Sortierung, Virtualisierung und revisionierte Sammeländerungen. |
 | R7 | offen | Editorbereich, Gruppierung, Drag-and-drop, Lösen und integrierte Löschübergänge. |
 | R8 | offen | Rückgabe-Excel und append-only Exportnachweis. |
 | R9 | offen | Vollständiger Folgeimport nach Worksharing-ID. |
@@ -142,6 +142,14 @@ Zustände vollständig, sodass Undo/Redo weder Datei noch Parser benötigen.
 - Standardverteileränderung wirkt nur auf unzugeordnete Objekte; verknüpfte
   Objekte folgen unverändert ihrer Row.
 
+Implementierungsstand vom 30.09.2026: Der projektweite GET-Endpunkt liefert
+eine kompakte Liste ohne Batchbytes, Matrix oder Pagination. Die Revit-Seite
+sucht, filtert und sortiert vollständig im Client und rendert nur den
+sichtbaren Ausschnitt. Eine stabile Mehrfachauswahl ändert Verteiler,
+ProjectDevice, Leistung und GZF in einem persistenten
+`external-object.update-planning`-Command. Verknüpfte Objekte sind für diese
+Sammelaktionen gesperrt und folgen weiterhin ausschließlich ihrer Row.
+
 ## R7 – Stromkreislisteneditor
 
 - gruppierter rechter Revit-Bereich mit Anzahl-Badge;
diff --git a/src/app/projects/[projectId]/revit/page.tsx b/src/app/projects/[projectId]/revit/page.tsx
index bf9b39f..fc8b85e 100644
--- a/src/app/projects/[projectId]/revit/page.tsx
+++ b/src/app/projects/[projectId]/revit/page.tsx
@@ -5,6 +5,7 @@ import { useParams } from "next/navigation";
 import { useEffect, useState } from "react";
 import { IconLink } from "../../../../frontend/components/icon-link";
 import { RevitInitialImportWizard } from "../../../../frontend/components/revit-initial-import-wizard";
+import { RevitObjectTable } from "../../../../frontend/components/revit-object-table";
 import { RevitXlsxSettingsModal } from "../../../../frontend/components/revit-xlsx-settings-modal";
 import type { ExternalModelConfiguration } from "../../../../external-model/configuration/external-model-configuration";
 import { detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getProject, updateExternalModelConfiguration } from "../../../../frontend/utils/api";
@@ -43,6 +44,7 @@ export default function RevitPage() {
     <div className="page-header"><div><div className="kicker">Projekt · Revit</div><h1>{project?.name ?? "Revit-Anbindung"}</h1><p className="text-secondary mb-0">Linear-XLSX austauschen und Revit-Objekte verwalten</p></div><div className="d-flex gap-2"><button className="btn btn-success btn-with-icon" disabled={!project || !snapshot || Boolean(importStatus?.imported)} onClick={() => setImportOpen(true)} type="button"><Upload size={16} />Erstimport</button><button className="btn btn-primary btn-with-icon" disabled={!project} onClick={() => setSettingsOpen(true)} type="button"><Settings size={16} />Einstellungen</button><IconLink href={`/projects/${projectId}`} icon={ArrowLeft} label="Zum Projekt" showLabel /></div></div>
     {error ? <div className="alert alert-danger">{error}</div> : null}
     <div className="row g-3 mt-1"><div className="col-md-6"><section className="card h-100"><div className="card-body"><FileSpreadsheet className="mb-3" size={28} /><h2 className="h5">XLSX-Konfiguration</h2><p className="text-secondary">{snapshot ? "Die Linear-Spalten und das Tabellenlayout sind konfiguriert." : "Noch keine XLSX-Konfiguration gespeichert."}</p><span className={`badge ${snapshot ? "text-bg-success" : "text-bg-secondary"}`}>{snapshot ? "Konfiguriert" : "Offen"}</span></div></section></div><div className="col-md-6"><section className="card h-100"><div className="card-body"><h2 className="h5">Importstatus</h2>{importStatus?.imported ? <><p className="mb-1"><strong>{importStatus.objectCount} Revit-Objekte</strong>{importStatus.fileName ? ` aus ${importStatus.fileName}` : ""}</p><p className="text-secondary mb-0">Quelle: {importStatus.sourceName}</p></> : <p className="text-secondary mb-0">Noch kein Linear-XLSX-Import vorhanden.</p>}</div></section></div></div>
+    {importStatus?.imported ? <RevitObjectTable projectId={projectId} onRevision={(revision) => setProject((current) => current ? { ...current, currentRevision: revision } : current)} /> : null}
     {settingsOpen ? <RevitXlsxSettingsModal configuration={snapshot?.configuration ?? createDefaultRevitXlsxConfiguration()} isSaving={saving} onClose={() => setSettingsOpen(false)} onInspectSample={async (file, configuration) => { const result = await detectExternalModelWorkbook(projectId, file, configuration); return `Muster erkannt: ${result.sheetName}, ${result.columnCount} Spalten, ${result.objectCount} Objekte.`; }} onSave={save} /> : null}
     {importOpen && project && snapshot ? <RevitInitialImportWizard projectId={projectId} expectedRevision={project.currentRevision} initialConfiguration={snapshot.configuration} onClose={() => setImportOpen(false)} onImported={({ history }) => { setProject({ ...project, currentRevision: history.currentRevision }); setImportOpen(false); void Promise.all([getExternalInitialImportStatus(projectId), getExternalModelConfiguration(projectId)]).then(([status, configuration]) => { setImportStatus(status); setSnapshot(configuration.configuration); }); }} /> : null}
   </main>;
diff --git a/src/db/repositories/external-object-planning-project-command.repository.ts b/src/db/repositories/external-object-planning-project-command.repository.ts
new file mode 100644
index 0000000..e6b3b1f
--- /dev/null
+++ b/src/db/repositories/external-object-planning-project-command.repository.ts
@@ -0,0 +1,29 @@
+import { and, eq } from "drizzle-orm";
+import { assertExternalObjectPlanningUpdateProjectCommand, invertExternalObjectPlanningUpdateProjectCommand } from "../../domain/models/external-object-planning-project-command.model.js";
+import type { ExternalObjectPlanningProjectCommandStore } from "../../domain/ports/external-object-planning-project-command.store.js";
+import type { AppDatabase } from "../database-context.js";
+import { distributionBoards } from "../schema/distribution-boards.js";
+import { externalModelObjects } from "../schema/external-model-objects.js";
+import { projectDevices } from "../schema/project-devices.js";
+import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { snapshotsEqual, toExternalObjectSnapshot } from "./external-object-assignment.persistence.js";
+
+export class ExternalObjectPlanningProjectCommandRepository implements ExternalObjectPlanningProjectCommandStore {
+  constructor(private readonly database: AppDatabase) {}
+  execute(input: Parameters<ExternalObjectPlanningProjectCommandStore["execute"]>[0]) {
+    assertExternalObjectPlanningUpdateProjectCommand(input.command);
+    return executeProjectCommandTransaction(this.database, input, (tx) => {
+      const boardIds = new Set(tx.select({ id: distributionBoards.id }).from(distributionBoards).where(eq(distributionBoards.projectId, input.projectId)).all().map((row) => row.id));
+      const deviceIds = new Set(tx.select({ id: projectDevices.id }).from(projectDevices).where(eq(projectDevices.projectId, input.projectId)).all().map((row) => row.id));
+      for (const { expected, target } of input.command.payload.objects) {
+        const current = tx.select().from(externalModelObjects).where(and(eq(externalModelObjects.id, expected.id), eq(externalModelObjects.projectId, input.projectId))).get();
+        if (!current || !snapshotsEqual(toExternalObjectSnapshot(current), expected)) throw new Error("Ein Revit-Objekt wurde zwischenzeitlich geändert.");
+        if (target.distributionBoardId !== null && !boardIds.has(target.distributionBoardId)) throw new Error("Der Verteiler gehört zu einem anderen Projekt.");
+        if (target.linkedProjectDeviceId !== null && !deviceIds.has(target.linkedProjectDeviceId)) throw new Error("Das Projektgerät gehört zu einem anderen Projekt.");
+        const updated = tx.update(externalModelObjects).set({ planningValues: target.planningValues, overriddenFields: target.overriddenFields, distributionBoardId: target.distributionBoardId, linkedProjectDeviceId: target.linkedProjectDeviceId }).where(and(eq(externalModelObjects.id, expected.id), eq(externalModelObjects.projectId, input.projectId))).run();
+        if (updated.changes !== 1) throw new Error("Revit-Objekt konnte nicht geändert werden.");
+      }
+      return invertExternalObjectPlanningUpdateProjectCommand(input.command);
+    });
+  }
+}
diff --git a/src/domain/models/external-object-planning-project-command.model.ts b/src/domain/models/external-object-planning-project-command.model.ts
new file mode 100644
index 0000000..f31d126
--- /dev/null
+++ b/src/domain/models/external-object-planning-project-command.model.ts
@@ -0,0 +1,30 @@
+import type { ExternalModelObjectSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import { parseExternalModelStateSnapshot } from "./project-state-snapshot.model.js";
+import type { SerializedProjectCommand } from "./project-command.model.js";
+
+export const externalObjectPlanningUpdateCommandType = "external-object.update-planning" as const;
+export interface ExternalObjectPlanningUpdateProjectCommand extends SerializedProjectCommand<{ objects: Array<{ expected: ExternalModelObjectSnapshot; target: ExternalModelObjectSnapshot }> }> {
+  schemaVersion: 1;
+  type: typeof externalObjectPlanningUpdateCommandType;
+}
+export function createExternalObjectPlanningUpdateProjectCommand(objects: Array<{ expected: ExternalModelObjectSnapshot; target: ExternalModelObjectSnapshot }>): ExternalObjectPlanningUpdateProjectCommand {
+  const command: ExternalObjectPlanningUpdateProjectCommand = { schemaVersion: 1, type: externalObjectPlanningUpdateCommandType, payload: { objects } };
+  assertExternalObjectPlanningUpdateProjectCommand(command); return command;
+}
+export function invertExternalObjectPlanningUpdateProjectCommand(command: ExternalObjectPlanningUpdateProjectCommand) { return createExternalObjectPlanningUpdateProjectCommand(command.payload.objects.map(({ expected, target }) => ({ expected: target, target: expected }))); }
+export function assertExternalObjectPlanningUpdateProjectCommand(command: SerializedProjectCommand<unknown>): asserts command is ExternalObjectPlanningUpdateProjectCommand {
+  if (command.schemaVersion !== 1 || command.type !== externalObjectPlanningUpdateCommandType || !isRecord(command.payload) || !Array.isArray(command.payload.objects) || command.payload.objects.length === 0) throw new Error("Nicht unterstützter Revit-Objektplanungs-Command.");
+  const ids = new Set<string>();
+  for (const transition of command.payload.objects) {
+    if (!isRecord(transition)) throw new Error("Ungültiger Revit-Objektübergang.");
+    const expected = parseObject(transition.expected); const target = parseObject(transition.target);
+    if (expected.id !== target.id || ids.has(expected.id)) throw new Error("Doppelte oder abweichende Revit-Objekt-ID.");
+    ids.add(expected.id);
+    if (expected.circuitDeviceRowId !== null || target.circuitDeviceRowId !== null) throw new Error("Verknüpfte Revit-Objekte werden über ihre Gerätezeile geplant.");
+    const left = { ...expected, planningValues: undefined, overriddenFields: undefined, distributionBoardId: undefined, linkedProjectDeviceId: undefined };
+    const right = { ...target, planningValues: undefined, overriddenFields: undefined, distributionBoardId: undefined, linkedProjectDeviceId: undefined };
+    if (JSON.stringify(left) !== JSON.stringify(right) || JSON.stringify(expected) === JSON.stringify(target)) throw new Error("Der Objektplanungs-Command ändert unzulässige oder keine Felder.");
+  }
+}
+function parseObject(value: unknown) { return parseExternalModelStateSnapshot({ source: null, importBatches: [], roomMappings: [], objects: [value] }).objects[0]!; }
+function isRecord(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); }
diff --git a/src/domain/ports/external-object-planning-project-command.store.ts b/src/domain/ports/external-object-planning-project-command.store.ts
new file mode 100644
index 0000000..19c610b
--- /dev/null
+++ b/src/domain/ports/external-object-planning-project-command.store.ts
@@ -0,0 +1,3 @@
+import type { ExternalObjectPlanningUpdateProjectCommand } from "../models/external-object-planning-project-command.model.js";
+import type { AppendedProjectRevision, ProjectRevisionSource } from "./project-revision.store.js";
+export interface ExternalObjectPlanningProjectCommandStore { execute(input: { projectId: string; expectedRevision: number; source: ProjectRevisionSource; description?: string; actorId?: string; historyTargetChangeSetId?: string; command: ExternalObjectPlanningUpdateProjectCommand }): { revision: AppendedProjectRevision; inverse: ExternalObjectPlanningUpdateProjectCommand }; }
diff --git a/src/domain/services/project-command.service.ts b/src/domain/services/project-command.service.ts
index 8e4bf36..ca99c5f 100644
--- a/src/domain/services/project-command.service.ts
+++ b/src/domain/services/project-command.service.ts
@@ -182,6 +182,8 @@ import {
   externalInitialImportCommandType,
 } from "../models/external-initial-import-project-command.model.js";
 import type { ExternalInitialImportProjectCommandStore } from "../ports/external-initial-import-project-command.store.js";
+import { assertExternalObjectPlanningUpdateProjectCommand, externalObjectPlanningUpdateCommandType } from "../models/external-object-planning-project-command.model.js";
+import type { ExternalObjectPlanningProjectCommandStore } from "../ports/external-object-planning-project-command.store.js";
 import {
   assertExternalObjectRowAssignmentProjectCommand,
   externalObjectRowAssignmentCommandType,
@@ -248,7 +250,8 @@ export class ProjectCommandService implements ProjectCommandExecutor {
     private readonly externalObjectNewRowStore?: ExternalObjectNewRowProjectCommandStore,
     private readonly externalObjectNewCircuitStore?: ExternalObjectNewCircuitProjectCommandStore,
     private readonly estimateBalanceStore?: EstimateBalanceProjectCommandStore,
-    private readonly externalInitialImportStore?: ExternalInitialImportProjectCommandStore
+    private readonly externalInitialImportStore?: ExternalInitialImportProjectCommandStore,
+    private readonly externalObjectPlanningStore?: ExternalObjectPlanningProjectCommandStore
   ) {}
 
   executeUser(
@@ -647,6 +650,11 @@ export class ProjectCommandService implements ProjectCommandExecutor {
           command: input.command,
         }).revision;
       }
+      case externalObjectPlanningUpdateCommandType: {
+        assertExternalObjectPlanningUpdateProjectCommand(input.command);
+        if (!this.externalObjectPlanningStore) throw new Error("External object planning store is not available.");
+        return this.externalObjectPlanningStore.execute({ ...input, command: input.command }).revision;
+      }
       case externalObjectRowAssignmentCommandType: {
         assertExternalObjectRowAssignmentProjectCommand(input.command);
         if (!this.externalObjectRowAssignmentStore) {
diff --git a/src/frontend/components/revit-object-table.tsx b/src/frontend/components/revit-object-table.tsx
new file mode 100644
index 0000000..c82d9c7
--- /dev/null
+++ b/src/frontend/components/revit-object-table.tsx
@@ -0,0 +1,73 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import type { ExternalProjectObjectsDto } from "../types";
+import { getExternalProjectObjects, updateExternalProjectObjects } from "../utils/api";
+
+const rowHeight = 44;
+const viewportHeight = 520;
+
+export function RevitObjectTable({ projectId, onRevision }: { projectId: string; onRevision: (revision: number) => void }) {
+  const [data, setData] = useState<ExternalProjectObjectsDto | null>(null);
+  const [search, setSearch] = useState("");
+  const [boardFilter, setBoardFilter] = useState("all");
+  const [assignmentFilter, setAssignmentFilter] = useState("all");
+  const [sort, setSort] = useState<"family" | "room" | "worksharing">("family");
+  const [selected, setSelected] = useState<Set<string>>(new Set());
+  const [scrollTop, setScrollTop] = useState(0);
+  const [bulkBoard, setBulkBoard] = useState("");
+  const [bulkDevice, setBulkDevice] = useState("");
+  const [power, setPower] = useState("");
+  const [gzf, setGzf] = useState("");
+  const [planningField, setPlanningField] = useState("");
+  const [planningValue, setPlanningValue] = useState("");
+  const [error, setError] = useState<string | null>(null);
+  const [saving, setSaving] = useState(false);
+
+  async function load() { try { const loaded = await getExternalProjectObjects(projectId); setData(loaded); onRevision(loaded.currentRevision); } catch (value) { setError(value instanceof Error ? value.message : "Revit-Objekte konnten nicht geladen werden."); } }
+  useEffect(() => { void load(); }, [projectId]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const rows = useMemo(() => {
+    if (!data) return [];
+    const needle = search.trim().toLocaleLowerCase("de-DE");
+    return data.objects.filter((object) => {
+      if (boardFilter !== "all" && (boardFilter === "none" ? object.distributionBoardId !== null : object.distributionBoardId !== boardFilter)) return false;
+      if (assignmentFilter === "unassigned" && object.circuitDeviceRowId !== null) return false;
+      if (assignmentFilter === "linked" && object.circuitDeviceRowId === null) return false;
+      return !needle || [object.worksharingId, object.familyAndType, object.selectionMarker, object.sourceRoomNumber, object.sourceRoomName, object.planningValues.displayName ?? ""].some((value) => value.toLocaleLowerCase("de-DE").includes(needle));
+    }).sort((a, b) => {
+      const left = sort === "family" ? a.familyAndType : sort === "room" ? `${a.sourceRoomNumber}\u0000${a.sourceRoomName}` : a.worksharingId;
+      const right = sort === "family" ? b.familyAndType : sort === "room" ? `${b.sourceRoomNumber}\u0000${b.sourceRoomName}` : b.worksharingId;
+      return left.localeCompare(right, "de", { numeric: true }) || a.worksharingId.localeCompare(b.worksharingId);
+    });
+  }, [data, search, boardFilter, assignmentFilter, sort]);
+  const first = Math.max(0, Math.floor(scrollTop / rowHeight) - 5);
+  const visible = rows.slice(first, first + Math.ceil(viewportHeight / rowHeight) + 10);
+  const selectable = rows.filter((object) => object.circuitDeviceRowId === null);
+
+  async function applyBulk() {
+    if (!data || selected.size === 0) return;
+    const patch: Record<string, unknown> = {};
+    if (bulkBoard !== "") patch.distributionBoardId = bulkBoard === "none" ? null : bulkBoard;
+    if (bulkDevice !== "") patch.linkedProjectDeviceId = bulkDevice === "none" ? null : bulkDevice;
+    if (power !== "") patch.powerPerUnitW = Number(power.replace(",", "."));
+    if (gzf !== "") patch.simultaneityFactor = Number(gzf.replace(",", "."));
+    if (planningField) {
+      patch[planningField] = ["effectiveQuantity", "cosPhi"].includes(planningField)
+        ? Number(planningValue.replace(",", "."))
+        : planningValue === "" ? null : planningValue;
+    }
+    if (Object.keys(patch).length === 0) { setError("Mindestens eine Sammeländerung auswählen."); return; }
+    setSaving(true); setError(null);
+    try { const result = await updateExternalProjectObjects(projectId, data.currentRevision, [...selected], patch); onRevision(result.history.currentRevision); setSelected(new Set()); await load(); }
+    catch (value) { setError(value instanceof Error ? value.message : "Sammeländerung fehlgeschlagen."); }
+    finally { setSaving(false); }
+  }
+
+  if (!data) return <section className="card mt-3"><div className="card-body">Revit-Objekte werden geladen …</div></section>;
+  return <section className="card mt-3"><div className="card-body"><div className="d-flex justify-content-between align-items-start gap-3 flex-wrap mb-3"><div><h2 className="h5 mb-1">Revit-Objekte</h2><div className="text-secondary small">{rows.length} von {data.objects.length} · {selected.size} ausgewählt</div></div><div className="d-flex gap-2 flex-wrap"><input aria-label="Revit-Objekte suchen" className="form-control" placeholder="Suchen …" value={search} onChange={(event) => setSearch(event.target.value)} /><select aria-label="Verteiler filtern" className="form-select" value={boardFilter} onChange={(event) => setBoardFilter(event.target.value)}><option value="all">Alle Verteiler</option><option value="none">Ohne Verteiler</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select><select aria-label="Zuordnung filtern" className="form-select" value={assignmentFilter} onChange={(event) => setAssignmentFilter(event.target.value)}><option value="all">Alle Zuordnungen</option><option value="unassigned">Unzugeordnet</option><option value="linked">Mit Gerätezeile</option></select><select aria-label="Sortierung" className="form-select" value={sort} onChange={(event) => setSort(event.target.value as typeof sort)}><option value="family">Familie</option><option value="room">Raum</option><option value="worksharing">Worksharing-ID</option></select></div></div>
+    {error ? <div className="alert alert-danger">{error}</div> : null}
+    <div className="border rounded mb-3" style={{ height: viewportHeight, overflowY: "auto" }} onScroll={(event) => setScrollTop(event.currentTarget.scrollTop)}><div style={{ height: rows.length * rowHeight, position: "relative" }}>{visible.map((object, index) => { const top = (first + index) * rowHeight; const linked = object.circuitDeviceRowId !== null; return <div className="d-grid align-items-center border-bottom px-2" key={object.id} style={{ gridTemplateColumns: "32px minmax(180px,2fr) minmax(120px,1fr) minmax(120px,1fr) minmax(130px,1fr) 100px", height: rowHeight, left: 0, position: "absolute", right: 0, top }}><input aria-label={`${object.familyAndType} auswählen`} checked={selected.has(object.id)} disabled={linked} type="checkbox" onChange={() => setSelected((current) => { const next = new Set(current); if (next.has(object.id)) next.delete(object.id); else next.add(object.id); return next; })} /><div className="text-truncate"><strong>{object.planningValues.displayName ?? object.familyAndType}</strong><div className="small text-secondary text-truncate">{object.familyAndType}</div></div><div className="text-truncate">{object.sourceRoomNumber} {object.sourceRoomName}</div><div className="text-truncate">{data.distributionBoards.find((board) => board.id === object.distributionBoardId)?.name ?? "Ohne Verteiler"}</div><div className="text-truncate">{object.selectionMarker || object.worksharingId}</div><span className={`badge ${linked ? "text-bg-success" : "text-bg-secondary"}`}>{linked ? "verknüpft" : "frei"}</span></div>; })}</div></div>
+    <div className="d-flex gap-2 flex-wrap align-items-end"><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(selectable.map((object) => object.id)))}>Sichtbare freie auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set())}>Auswahl leeren</button><label className="small">Verteiler<select className="form-select form-select-sm" value={bulkBoard} onChange={(event) => setBulkBoard(event.target.value)}><option value="">Unverändert</option><option value="none">Zuordnung lösen</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></label><label className="small">Projektgerät<select className="form-select form-select-sm" value={bulkDevice} onChange={(event) => setBulkDevice(event.target.value)}><option value="">Unverändert</option><option value="none">Verknüpfung lösen</option>{data.projectDevices.map((device) => <option value={device.id} key={device.id}>{device.name}</option>)}</select></label><label className="small">Leistung [W]<input className="form-control form-control-sm" inputMode="decimal" value={power} onChange={(event) => setPower(event.target.value)} /></label><label className="small">GZF<input className="form-control form-control-sm" inputMode="decimal" value={gzf} onChange={(event) => setGzf(event.target.value)} /></label><label className="small">Weiterer Planungswert<select className="form-select form-select-sm" value={planningField} onChange={(event) => setPlanningField(event.target.value)}><option value="">Unverändert</option><option value="displayName">Anzeigename</option><option value="category">Kategorie (lighting/single_phase/three_phase)</option><option value="connectionKind">Anschlussart</option><option value="effectiveQuantity">Wirksame Menge</option><option value="cosPhi">cosPhi</option><option value="costGroup">Kostengruppe</option><option value="remark">Bemerkung</option></select></label>{planningField ? <label className="small">Neuer Wert<input className="form-control form-control-sm" value={planningValue} onChange={(event) => setPlanningValue(event.target.value)} /></label> : null}<button className="btn btn-sm btn-primary" disabled={saving || selected.size === 0} type="button" onClick={() => void applyBulk()}>{saving ? "Wird gespeichert …" : "Sammeländerung anwenden"}</button></div>
+  </div></section>;
+}
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 9a18a94..49466f5 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -111,6 +111,21 @@ export interface ExternalInitialImportResultDto extends ProjectCommandResultDto
   };
 }
 
+export interface ExternalProjectObjectDto {
+  id: string; worksharingId: string; ifcGuid: string | null; deviceTypeId: string;
+  familyAndType: string; selectionMarker: string; sourceCircuitIdentifier: string;
+  sourceRoomNumber: string; sourceRoomName: string; roomId: string | null;
+  distributionBoardId: string | null; linkedProjectDeviceId: string | null;
+  circuitDeviceRowId: string | null; presenceStatus: "present" | "missing";
+  planningValues: { displayName: string | null; category: CircuitGroupCategory | null; connectionKind: string | null; effectiveQuantity: number; powerPerUnitW: number | null; simultaneityFactor: number | null; cosPhi: number | null; costGroup: string | null; remark: string | null };
+}
+export interface ExternalProjectObjectsDto {
+  currentRevision: number; sourceName: string | null;
+  distributionBoards: Array<{ id: string; name: string }>;
+  projectDevices: Array<{ id: string; name: string; displayName: string }>;
+  objects: ExternalProjectObjectDto[];
+}
+
 export interface ProjectDto {
   id: string;
   name: string;
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index 692640d..c46f80b 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -43,6 +43,7 @@ import type {
   ExternalInitialImportResultDto,
   ExternalInitialImportStatusDto,
   ApplyExternalInitialImportInput,
+  ExternalProjectObjectsDto,
   CreateEstimateBalanceInput,
   EstimateBalanceCommandResultDto,
   EstimateBalanceDto,
@@ -236,6 +237,14 @@ async function fileToBase64(file: File) {
   return btoa(binary);
 }
 
+export function getExternalProjectObjects(projectId: string) {
+  return request<ExternalProjectObjectsDto>(`/api/projects/${projectId}/external-model/objects`);
+}
+
+export function updateExternalProjectObjects(projectId: string, expectedRevision: number, objectIds: string[], patch: Record<string, unknown>) {
+  return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects`, { method: "PUT", body: JSON.stringify({ expectedRevision, objectIds, patch }) });
+}
+
 export function getProjectHistory(projectId: string) {
   return request<ProjectHistoryStateDto>(
     `/api/projects/${projectId}/history`
diff --git a/src/frontend/utils/project-version-history.ts b/src/frontend/utils/project-version-history.ts
index 4d6003a..2f1f35b 100644
--- a/src/frontend/utils/project-version-history.ts
+++ b/src/frontend/utils/project-version-history.ts
@@ -65,6 +65,7 @@ const commandTypeLabels: Record<string, string> = {
   "external-model-configuration.update": "Revit-XLSX-Einstellungen bearbeitet",
   "external-import.apply-initial": "Revit-Erstimport übernommen",
   "external-model.apply-initial-import": "Linear-XLSX-Erstimport übernommen",
+  "external-object.update-planning": "Revit-Objekte bearbeitet",
   "external-object.assign-to-new-circuit":
     "Externes Objekt in neuen Stromkreis übernommen",
   "external-object.unassign-and-delete-created-circuit":
diff --git a/src/server/composition/project-command-stores.ts b/src/server/composition/project-command-stores.ts
index 4017144..669e25d 100644
--- a/src/server/composition/project-command-stores.ts
+++ b/src/server/composition/project-command-stores.ts
@@ -24,6 +24,7 @@ import { ProjectStateRestoreCommandRepository } from "../../db/repositories/proj
 import { ProjectCommandService } from "../../domain/services/project-command.service.js";
 import { ExternalModelConfigurationProjectCommandRepository } from "../../db/repositories/external-model-configuration-project-command.repository.js";
 import { ExternalInitialImportProjectCommandRepository } from "../../db/repositories/external-initial-import-project-command.repository.js";
+import { ExternalObjectPlanningProjectCommandRepository } from "../../db/repositories/external-object-planning-project-command.repository.js";
 import { ExternalObjectRowAssignmentProjectCommandRepository } from "../../db/repositories/external-object-row-assignment-project-command.repository.js";
 import { ExternalObjectNewRowProjectCommandRepository } from "../../db/repositories/external-object-new-row-project-command.repository.js";
 import { ExternalObjectNewCircuitProjectCommandRepository } from "../../db/repositories/external-object-new-circuit-project-command.repository.js";
@@ -75,6 +76,8 @@ export const externalModelConfigurationProjectCommandStore =
   new ExternalModelConfigurationProjectCommandRepository(db);
 export const externalInitialImportProjectCommandStore =
   new ExternalInitialImportProjectCommandRepository(db);
+export const externalObjectPlanningProjectCommandStore =
+  new ExternalObjectPlanningProjectCommandRepository(db);
 export const externalObjectRowAssignmentProjectCommandStore =
   new ExternalObjectRowAssignmentProjectCommandRepository(db);
 export const externalObjectNewRowProjectCommandStore =
@@ -111,5 +114,6 @@ export const projectCommandService = new ProjectCommandService(
   externalObjectNewRowProjectCommandStore,
   externalObjectNewCircuitProjectCommandStore,
   estimateBalanceProjectCommandStore,
-  externalInitialImportProjectCommandStore
+  externalInitialImportProjectCommandStore,
+  externalObjectPlanningProjectCommandStore
 );
diff --git a/src/server/controllers/external-objects.controller.ts b/src/server/controllers/external-objects.controller.ts
new file mode 100644
index 0000000..f56f7be
--- /dev/null
+++ b/src/server/controllers/external-objects.controller.ts
@@ -0,0 +1,56 @@
+import type { Request, Response } from "express";
+import { createExternalObjectPlanningUpdateProjectCommand } from "../../domain/models/external-object-planning-project-command.model.js";
+import type { ExternalModelObjectPlanningValues } from "../../external-model/domain/external-model-contracts.js";
+import { distributionBoardRepository, externalModelStateRepository, projectDeviceRepository, projectRepository } from "../composition/application-repositories.js";
+import { projectCommandService } from "../composition/project-command-stores.js";
+import { respondWithProjectCommandError } from "./project-command.controller.js";
+
+export async function listExternalObjects(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  const [project, boards, devices] = await Promise.all([projectRepository.findById(projectId), distributionBoardRepository.listByProject(projectId), projectDeviceRepository.listByProject(projectId)]);
+  if (!project) return res.status(404).json({ error: "Projekt nicht gefunden." });
+  const state = externalModelStateRepository.getByProject(projectId).state;
+  const mappings = new Map(state.roomMappings.map((mapping) => [mapping.id, mapping]));
+  return res.json({
+    currentRevision: project.currentRevision,
+    sourceName: state.source?.name ?? null,
+    distributionBoards: boards.map(({ id, name }) => ({ id, name })),
+    projectDevices: devices.map(({ id, name, displayName }) => ({ id, name, displayName })),
+    objects: state.objects.map((object) => {
+      const mapping = object.externalRoomMappingId ? mappings.get(object.externalRoomMappingId) : null;
+      return { id: object.id, worksharingId: object.worksharingId, ifcGuid: object.ifcGuid, deviceTypeId: object.deviceTypeId, familyAndType: object.acceptedSourceValues.familyAndType, selectionMarker: scalarText(object.acceptedSourceValues.selectionMarker), sourceCircuitIdentifier: scalarText(object.acceptedSourceValues.circuitCombined) || scalarText(object.acceptedSourceValues.circuitIdentifier), sourceRoomNumber: scalarText(object.acceptedSourceValues.roomNumber), sourceRoomName: scalarText(object.acceptedSourceValues.roomName), roomId: mapping?.roomId ?? null, distributionBoardId: object.distributionBoardId, linkedProjectDeviceId: object.linkedProjectDeviceId, circuitDeviceRowId: object.circuitDeviceRowId, presenceStatus: object.presenceStatus, planningValues: object.planningValues };
+    }),
+  });
+}
+
+export function updateExternalObjects(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = req.body?.expectedRevision;
+    if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) throw new Error("Ungültige Projektrevision.");
+    const objectIds = req.body?.objectIds;
+    const patch = req.body?.patch;
+    if (!Array.isArray(objectIds) || objectIds.length === 0 || new Set(objectIds).size !== objectIds.length || !isRecord(patch)) throw new Error("Objektauswahl oder Änderungen sind ungültig.");
+    const state = externalModelStateRepository.getByProject(projectId);
+    if (!state.projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    const byId = new Map(state.state.objects.map((object) => [object.id, object]));
+    const transitions = objectIds.map((id: unknown) => {
+      if (typeof id !== "string") throw new Error("Ungültige Revit-Objekt-ID.");
+      const expected = byId.get(id);
+      if (!expected) throw new Error("Ein ausgewähltes Revit-Objekt wurde nicht gefunden.");
+      if (expected.circuitDeviceRowId !== null) throw new Error("Verknüpfte Revit-Objekte folgen ihrer Gerätezeile und können hier nicht geändert werden.");
+      const planningValues = { ...expected.planningValues };
+      const overriddenFields = new Set(expected.overriddenFields);
+      for (const field of planningFields) if (hasOwn(patch, field)) { planningValues[field] = patch[field] as never; overriddenFields.add(field); }
+      return { expected, target: { ...expected, planningValues, overriddenFields: [...overriddenFields], distributionBoardId: hasOwn(patch, "distributionBoardId") ? nullableId(patch.distributionBoardId) : expected.distributionBoardId, linkedProjectDeviceId: hasOwn(patch, "linkedProjectDeviceId") ? nullableId(patch.linkedProjectDeviceId) : expected.linkedProjectDeviceId } };
+    });
+    const result = projectCommandService.executeUser({ projectId, expectedRevision, description: `${transitions.length} Revit-Objekte bearbeitet`, command: createExternalObjectPlanningUpdateProjectCommand(transitions) });
+    return res.json(result);
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+const planningFields = ["displayName", "category", "connectionKind", "effectiveQuantity", "powerPerUnitW", "simultaneityFactor", "cosPhi", "costGroup", "remark"] as const satisfies readonly (keyof ExternalModelObjectPlanningValues)[];
+function scalarText(value: string | number | boolean | null) { return value === null ? "" : String(value); }
+function isRecord(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); }
+function hasOwn(value: object, key: PropertyKey) { return Object.prototype.hasOwnProperty.call(value, key); }
+function nullableId(value: unknown) { if (value === null || value === "") return null; if (typeof value !== "string") throw new Error("Ungültige Zuordnungs-ID."); return value; }
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index 84f2ea3..53c2225 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -63,6 +63,7 @@ import {
   getExternalInitialImportStatus,
   planExternalInitialImport,
 } from "../controllers/external-initial-import.controller.js";
+import { listExternalObjects, updateExternalObjects } from "../controllers/external-objects.controller.js";
 
 export const projectRouter = Router();
 
@@ -90,6 +91,8 @@ projectRouter.post("/:projectId/external-model/configuration/detect", detectExte
 projectRouter.get("/:projectId/external-model/import-status", getExternalInitialImportStatus);
 projectRouter.post("/:projectId/external-model/initial-import/plan", planExternalInitialImport);
 projectRouter.post("/:projectId/external-model/initial-import/apply", applyExternalInitialImport);
+projectRouter.get("/:projectId/external-model/objects", listExternalObjects);
+projectRouter.put("/:projectId/external-model/objects", updateExternalObjects);
 projectRouter.get("/:projectId/distribution-boards", listDistributionBoardsByProject);
 projectRouter.post("/:projectId/distribution-boards", createDistributionBoard);
 projectRouter.post(
diff --git a/tests/external-xlsx-initial-import.test.ts b/tests/external-xlsx-initial-import.test.ts
index 33400d6..75af423 100644
--- a/tests/external-xlsx-initial-import.test.ts
+++ b/tests/external-xlsx-initial-import.test.ts
@@ -5,9 +5,11 @@ import { migrate } from "drizzle-orm/better-sqlite3/migrator";
 import { createDatabaseContext } from "../src/db/database-context.js";
 import { ExternalInitialImportProjectCommandRepository } from "../src/db/repositories/external-initial-import-project-command.repository.js";
 import { ExternalModelStateRepository } from "../src/db/repositories/external-model-state.repository.js";
+import { ExternalObjectPlanningProjectCommandRepository } from "../src/db/repositories/external-object-planning-project-command.repository.js";
 import { externalModelConfigurations } from "../src/db/schema/external-model-configurations.js";
 import { projects } from "../src/db/schema/projects.js";
 import { createEmptyExternalModelState, createExternalInitialImportProjectCommand } from "../src/domain/models/external-initial-import-project-command.model.js";
+import { createExternalObjectPlanningUpdateProjectCommand } from "../src/domain/models/external-object-planning-project-command.model.js";
 import { createExternalXlsxInitialImportPlan } from "../src/external-model/application/external-xlsx-initial-import.js";
 import { buildExternalXlsxInitialImportTarget } from "../src/external-model/application/external-xlsx-initial-import-target.js";
 import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
@@ -62,7 +64,15 @@ describe("Linear XLSX initial import", () => {
       const undone = repository.execute({ projectId: "project-1", expectedRevision: 1, source: "undo", historyTargetChangeSetId: inserted.revision.changeSetId, command: inserted.inverse });
       assert.equal(new ExternalModelStateRepository(context.db).getByProject("project-1").state.source, null);
       repository.execute({ projectId: "project-1", expectedRevision: 2, source: "redo", historyTargetChangeSetId: inserted.revision.changeSetId, command: undone.inverse });
-      assert.deepEqual(new ExternalModelStateRepository(context.db).getByProject("project-1").state.objects.map((object) => object.worksharingId), plan.objects.map((object) => object.worksharingId).sort());
+      const redone = new ExternalModelStateRepository(context.db).getByProject("project-1").state;
+      assert.deepEqual(redone.objects.map((object) => object.worksharingId), plan.objects.map((object) => object.worksharingId).sort());
+      const expectedObject = redone.objects[0];
+      const targetObject = { ...expectedObject, planningValues: { ...expectedObject.planningValues, simultaneityFactor: 0.5 }, overriddenFields: [...expectedObject.overriddenFields, "simultaneityFactor" as const] };
+      const planningRepository = new ExternalObjectPlanningProjectCommandRepository(context.db);
+      const planned = planningRepository.execute({ projectId: "project-1", expectedRevision: 3, source: "user", command: createExternalObjectPlanningUpdateProjectCommand([{ expected: expectedObject, target: targetObject }]) });
+      assert.equal(new ExternalModelStateRepository(context.db).getByProject("project-1").state.objects[0].planningValues.simultaneityFactor, 0.5);
+      planningRepository.execute({ projectId: "project-1", expectedRevision: 4, source: "undo", historyTargetChangeSetId: planned.revision.changeSetId, command: planned.inverse });
+      assert.equal(new ExternalModelStateRepository(context.db).getByProject("project-1").state.objects[0].planningValues.simultaneityFactor, 1);
     } finally { context.close(); }
   });
 });
diff --git a/tests/revit-xlsx-settings-api.test.ts b/tests/revit-xlsx-settings-api.test.ts
index 22d633c..ed91b57 100644
--- a/tests/revit-xlsx-settings-api.test.ts
+++ b/tests/revit-xlsx-settings-api.test.ts
@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { describe, it } from "node:test";
 import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
-import { applyExternalInitialImport, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, planExternalInitialImport, updateExternalModelConfiguration } from "../src/frontend/utils/api.js";
+import { applyExternalInitialImport, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getExternalProjectObjects, planExternalInitialImport, updateExternalModelConfiguration, updateExternalProjectObjects } from "../src/frontend/utils/api.js";
 
 describe("Revit XLSX settings", () => {
   it("uses the project-scoped configuration endpoint with expectedRevision", async () => {
@@ -53,6 +53,7 @@ describe("Revit XLSX settings", () => {
     const revitPage = readFileSync("src/app/projects/[projectId]/revit/page.tsx", "utf8");
     const settings = readFileSync("src/frontend/components/revit-xlsx-settings-modal.tsx", "utf8");
     const wizard = readFileSync("src/frontend/components/revit-initial-import-wizard.tsx", "utf8");
+    const objectTable = readFileSync("src/frontend/components/revit-object-table.tsx", "utf8");
     assert.match(projectPage, /href={`\/projects\/\$\{projectId\}\/revit`}/);
     assert.doesNotMatch(projectPage, /RevitCsvModal|Revit-CSV/);
     assert.match(revitPage, /Importstatus/);
@@ -61,5 +62,16 @@ describe("Revit XLSX settings", () => {
     assert.match(wizard, /Schritt.*von/);
     assert.match(wizard, /keine Gerätezeilen, Stromkreise oder BMKs/);
     assert.match(wizard, /GZF 1/);
+    assert.match(objectTable, /viewportHeight/);
+    assert.match(objectTable, /Sammeländerung anwenden/);
+  });
+
+  it("loads one project object list and sends revision-safe bulk updates", async () => {
+    const requests: Array<{ url: string; method: string; body: unknown }> = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => { requests.push({ url: String(input), method: init?.method ?? "GET", body: init?.body ? JSON.parse(String(init.body)) : undefined }); return new Response(JSON.stringify({ currentRevision: 4, sourceName: null, distributionBoards: [], projectDevices: [], objects: [], history: { currentRevision: 5 } }), { status: 200, headers: { "Content-Type": "application/json" } }); };
+    try { await getExternalProjectObjects("project-1"); await updateExternalProjectObjects("project-1", 4, ["object-1"], { simultaneityFactor: 0.7 }); }
+    finally { globalThis.fetch = originalFetch; }
+    assert.deepEqual(requests, [{ url: "/api/projects/project-1/external-model/objects", method: "GET", body: undefined }, { url: "/api/projects/project-1/external-model/objects", method: "PUT", body: { expectedRevision: 4, objectIds: ["object-1"], patch: { simultaneityFactor: 0.7 } } }]);
   });
 });

From 4489cd76f0fb5b38a0399d4cac59b75a05a6d85e Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 13:51:43 +0200
Subject: [PATCH 55/60] Allow saving default Revit settings

---
 src/app/projects/[projectId]/revit/page.tsx           | 2 +-
 src/frontend/components/revit-xlsx-settings-modal.tsx | 5 +++--
 tests/revit-xlsx-settings-api.test.ts                 | 2 ++
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/app/projects/[projectId]/revit/page.tsx b/src/app/projects/[projectId]/revit/page.tsx
index fc8b85e..46c3d5d 100644
--- a/src/app/projects/[projectId]/revit/page.tsx
+++ b/src/app/projects/[projectId]/revit/page.tsx
@@ -45,7 +45,7 @@ export default function RevitPage() {
     {error ? <div className="alert alert-danger">{error}</div> : null}
     <div className="row g-3 mt-1"><div className="col-md-6"><section className="card h-100"><div className="card-body"><FileSpreadsheet className="mb-3" size={28} /><h2 className="h5">XLSX-Konfiguration</h2><p className="text-secondary">{snapshot ? "Die Linear-Spalten und das Tabellenlayout sind konfiguriert." : "Noch keine XLSX-Konfiguration gespeichert."}</p><span className={`badge ${snapshot ? "text-bg-success" : "text-bg-secondary"}`}>{snapshot ? "Konfiguriert" : "Offen"}</span></div></section></div><div className="col-md-6"><section className="card h-100"><div className="card-body"><h2 className="h5">Importstatus</h2>{importStatus?.imported ? <><p className="mb-1"><strong>{importStatus.objectCount} Revit-Objekte</strong>{importStatus.fileName ? ` aus ${importStatus.fileName}` : ""}</p><p className="text-secondary mb-0">Quelle: {importStatus.sourceName}</p></> : <p className="text-secondary mb-0">Noch kein Linear-XLSX-Import vorhanden.</p>}</div></section></div></div>
     {importStatus?.imported ? <RevitObjectTable projectId={projectId} onRevision={(revision) => setProject((current) => current ? { ...current, currentRevision: revision } : current)} /> : null}
-    {settingsOpen ? <RevitXlsxSettingsModal configuration={snapshot?.configuration ?? createDefaultRevitXlsxConfiguration()} isSaving={saving} onClose={() => setSettingsOpen(false)} onInspectSample={async (file, configuration) => { const result = await detectExternalModelWorkbook(projectId, file, configuration); return `Muster erkannt: ${result.sheetName}, ${result.columnCount} Spalten, ${result.objectCount} Objekte.`; }} onSave={save} /> : null}
+    {settingsOpen ? <RevitXlsxSettingsModal configuration={snapshot?.configuration ?? createDefaultRevitXlsxConfiguration()} isNewConfiguration={snapshot === null} isSaving={saving} onClose={() => setSettingsOpen(false)} onInspectSample={async (file, configuration) => { const result = await detectExternalModelWorkbook(projectId, file, configuration); return `Muster erkannt: ${result.sheetName}, ${result.columnCount} Spalten, ${result.objectCount} Objekte.`; }} onSave={save} /> : null}
     {importOpen && project && snapshot ? <RevitInitialImportWizard projectId={projectId} expectedRevision={project.currentRevision} initialConfiguration={snapshot.configuration} onClose={() => setImportOpen(false)} onImported={({ history }) => { setProject({ ...project, currentRevision: history.currentRevision }); setImportOpen(false); void Promise.all([getExternalInitialImportStatus(projectId), getExternalModelConfiguration(projectId)]).then(([status, configuration]) => { setImportStatus(status); setSnapshot(configuration.configuration); }); }} /> : null}
   </main>;
 }
diff --git a/src/frontend/components/revit-xlsx-settings-modal.tsx b/src/frontend/components/revit-xlsx-settings-modal.tsx
index 7041ebc..899c3ca 100644
--- a/src/frontend/components/revit-xlsx-settings-modal.tsx
+++ b/src/frontend/components/revit-xlsx-settings-modal.tsx
@@ -13,8 +13,9 @@ const labels: Record<ExternalXlsxColumnKey, string> = {
   electricalPowerW: "Elektrische Leistung", voltageV: "Spannung", currentA: "Stromstärke",
 };
 
-export function RevitXlsxSettingsModal({ configuration, isSaving, onClose, onInspectSample, onSave }: {
+export function RevitXlsxSettingsModal({ configuration, isNewConfiguration = false, isSaving, onClose, onInspectSample, onSave }: {
   configuration: ExternalModelConfiguration;
+  isNewConfiguration?: boolean;
   isSaving: boolean;
   onClose: () => void;
   onInspectSample: (file: File, configuration: ExternalModelConfiguration) => Promise<string>;
@@ -33,7 +34,7 @@ export function RevitXlsxSettingsModal({ configuration, isSaving, onClose, onIns
     }
   }
 
-  return <FormModal title="Revit-XLSX-Einstellungen" description="Layout und Spalten der Linear-Bauteilliste" isSaving={isSaving} onClose={onClose} submitDisabled={JSON.stringify(draft) === JSON.stringify(configuration)} submitLabel="Einstellungen speichern" onSubmit={(event: FormEvent) => { event.preventDefault(); void onSave(draft); }}>
+  return <FormModal title="Revit-XLSX-Einstellungen" description="Layout und Spalten der Linear-Bauteilliste" isSaving={isSaving} onClose={onClose} submitDisabled={!isNewConfiguration && JSON.stringify(draft) === JSON.stringify(configuration)} submitLabel="Einstellungen speichern" onSubmit={(event: FormEvent) => { event.preventDefault(); void onSave(draft); }}>
     <div className="row g-3">
       <div className="col-12"><label className="form-label" htmlFor="revit-sample">Musterdatei prüfen</label><input id="revit-sample" className="form-control" type="file" accept=".xlsx" onChange={(event) => void inspectSample(event.target.files?.[0])} />{sampleStatus ? <div className="form-text">{sampleStatus}</div> : null}</div>
       {(["headerRow", "firstDataRow", "firstDataColumn"] as const).map((key) => <div className="col-md-4" key={key}><label className="form-label" htmlFor={`layout-${key}`}>{key === "headerRow" ? "Kopfzeile" : key === "firstDataRow" ? "Erste Datenzeile" : "Erste Datenspalte"}</label><input id={`layout-${key}`} className="form-control" min={1} type="number" value={draft.layout[key]} onChange={(event) => setDraft({ ...draft, layout: { ...draft.layout, [key]: Number(event.target.value) } })} /></div>)}
diff --git a/tests/revit-xlsx-settings-api.test.ts b/tests/revit-xlsx-settings-api.test.ts
index ed91b57..4f13b70 100644
--- a/tests/revit-xlsx-settings-api.test.ts
+++ b/tests/revit-xlsx-settings-api.test.ts
@@ -59,6 +59,8 @@ describe("Revit XLSX settings", () => {
     assert.match(revitPage, /Importstatus/);
     assert.match(settings, /Musterdatei prüfen/);
     assert.match(settings, /Kombinierte Stromkreisspalte/);
+    assert.match(settings, /isNewConfiguration/);
+    assert.match(revitPage, /isNewConfiguration={snapshot === null}/);
     assert.match(wizard, /Schritt.*von/);
     assert.match(wizard, /keine Gerätezeilen, Stromkreise oder BMKs/);
     assert.match(wizard, /GZF 1/);

From 77d775fde11224b4297de9206c5f89633ef36d8f Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 14:35:14 +0200
Subject: [PATCH 56/60] Complete Revit object editor assignments

---
 .../revit-excel-integration-requirements.md   |  10 +
 docs/spec/revit-excel-phase-14-plan.md        |   2 +-
 src/app/globals.css                           |  11 +
 ...ow-structure-project-command.repository.ts |  53 ++--
 ...roup-subtree-project-command.repository.ts |  41 +++-
 ...it-structure-project-command.repository.ts |  65 +++--
 ...rd-structure-project-command.repository.ts |   2 +
 ...oard-subtree-project-command.repository.ts |   2 +
 .../external-object-assignment.persistence.ts |  29 ++-
 ...ernal-object-deletion-guard.persistence.ts |  37 +++
 ...on-structure-project-command.repository.ts |   2 +
 ...ice-row-structure-project-command.model.ts |  55 ++++-
 ...uit-group-subtree-project-command.model.ts |  15 +-
 ...circuit-structure-project-command.model.ts |  16 +-
 src/domain/models/circuit-tree.model.ts       |   1 +
 ...bject-new-circuit-project-command.model.ts |   4 +-
 ...al-object-new-row-project-command.model.ts |   4 +-
 ...ct-row-assignment-project-command.model.ts |  19 +-
 .../components/circuit-tree-editor.tsx        | 231 ++++++++++++++++--
 src/frontend/types.ts                         |   1 +
 src/frontend/utils/api.ts                     |  26 ++
 .../controllers/circuit-tree.controller.ts    |   9 +
 .../external-objects.controller.ts            | 223 +++++++++++++++++
 src/server/routes/project.routes.ts           |   6 +-
 ...ignment-project-command.repository.test.ts |  66 +++++
 25 files changed, 853 insertions(+), 77 deletions(-)
 create mode 100644 src/db/repositories/external-object-deletion-guard.persistence.ts

diff --git a/docs/spec/revit-excel-integration-requirements.md b/docs/spec/revit-excel-integration-requirements.md
index 29a4aaf..5add6fb 100644
--- a/docs/spec/revit-excel-integration-requirements.md
+++ b/docs/spec/revit-excel-integration-requirements.md
@@ -306,6 +306,16 @@ aktuellen Row-Werte als Planungswerte und entsprechende Overrides.
 
 ## 11. Editor-Zuordnung und Löschen
 
+Umsetzungsstand R7: Der Stromkreislisteneditor lädt die kompakte Projektliste
+gemeinsam mit dem Baum, gruppiert unzugeordnete Objekte des aktuellen
+Verteilers im Client und bietet Gruppen sowie einzelne Worksharing-IDs als
+Drag-Quelle an. Drop auf Row, Circuit und freien Gruppenbereich verwendet die
+drei persistenten Zuordnungscommands. Row-Badges zeigen die Linkzahl; Lösen
+kopiert die aktuellen Row-Planungswerte als Overrides. Row-, Circuit- und
+Gruppenlöschungen speichern die vollständigen Linkübergänge im Forward- und
+Inverse-Command. Raum- und Verteilerlöschungen prüfen externe Referenzen
+explizit.
+
 Der rechte, überlagernde Editorbereich zeigt unzugeordnete konfliktfreie
 Objekte des aktuellen Verteilers. Gruppierungsschlüssel sind interner Raum,
 Auswahlkenner, Geräteart, Kategorie, identische Planungswerte und kompatibler
diff --git a/docs/spec/revit-excel-phase-14-plan.md b/docs/spec/revit-excel-phase-14-plan.md
index 9b43c4f..700db4c 100644
--- a/docs/spec/revit-excel-phase-14-plan.md
+++ b/docs/spec/revit-excel-phase-14-plan.md
@@ -15,7 +15,7 @@ Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
 | R4 | abgeschlossen | Revit-Seite, Navigation und revisionierte XLSX-Einstellungen mit Musterdateiprüfung sind umgesetzt; das alte Projektseitenmodal ist entfernt. |
 | R5 | abgeschlossen | Zustandslose XLSX-Vorschau, sechsstufiger Erstimportwizard und atomarer Importcommand mit parserfreiem Undo/Redo. |
 | R6 | abgeschlossen | Projektweite kompakte Objektliste, clientseitige Filter/Sortierung, Virtualisierung und revisionierte Sammeländerungen. |
-| R7 | offen | Editorbereich, Gruppierung, Drag-and-drop, Lösen und integrierte Löschübergänge. |
+| R7 | abgeschlossen | Gruppierter Editorbereich, drei Drag-and-drop-Ziele, Row-Indikator, ausdrückliches Lösen und atomare Löschübergänge mit exaktem Undo/Redo. |
 | R8 | offen | Rückgabe-Excel und append-only Exportnachweis. |
 | R9 | offen | Vollständiger Folgeimport nach Worksharing-ID. |
 | R10 | offen | Ende-zu-Ende-Härtung, große Datenmengen und Abschlussdokumentation. |
diff --git a/src/app/globals.css b/src/app/globals.css
index 8b55c75..67985f4 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -1128,6 +1128,17 @@ a.kpi:hover {
   border-style: dashed;
 }
 
+.project-device-item > summary {
+  display: flex;
+  flex-direction: column;
+  gap: 0.1rem;
+  cursor: grab;
+}
+
+.project-device-item > summary::marker {
+  color: var(--text-faint);
+}
+
 .sidebar-actions {
   display: flex;
   flex-direction: column;
diff --git a/src/db/repositories/circuit-device-row-structure-project-command.repository.ts b/src/db/repositories/circuit-device-row-structure-project-command.repository.ts
index 6919d20..f69dc78 100644
--- a/src/db/repositories/circuit-device-row-structure-project-command.repository.ts
+++ b/src/db/repositories/circuit-device-row-structure-project-command.repository.ts
@@ -23,8 +23,15 @@ import {
   toCircuitDeviceRowInsertValues,
   toCircuitDeviceRowSnapshot,
 } from "./circuit-device-row-structure.persistence.js";
-import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { executeProjectCommandTransactionWithAppliedForward, type AppliedProjectCommand } from "./project-command-transaction.persistence.js";
 import { updateDerivedCircuitVoltage } from "./project-voltage.persistence.js";
+import {
+  applyExternalObjectLinks,
+  captureExternalObjectDetachTransitions,
+  invertExternalObjectLinkTransitions,
+  loadExpectedExternalObjectTransitions,
+  type ExternalObjectLinkTransition,
+} from "./external-object-assignment.persistence.js";
 
 export class CircuitDeviceRowStructureProjectCommandRepository
   implements CircuitDeviceRowStructureProjectCommandStore
@@ -32,7 +39,11 @@ export class CircuitDeviceRowStructureProjectCommandRepository
   constructor(private readonly database: AppDatabase) {}
 
   execute(input: ExecuteCircuitDeviceRowStructureCommandInput) {
-    return executeProjectCommandTransaction(
+    return executeProjectCommandTransactionWithAppliedForward<
+      CircuitDeviceRowStructureProjectCommand,
+      CircuitDeviceRowStructureProjectCommand,
+      CircuitDeviceRowStructureProjectCommand
+    >(
       this.database,
       input,
       (tx) =>
@@ -50,14 +61,15 @@ export class CircuitDeviceRowStructureProjectCommandRepository
     projectId: string,
     source: ExecuteCircuitDeviceRowStructureCommandInput["source"],
     command: CircuitDeviceRowStructureProjectCommand
-  ): CircuitDeviceRowStructureProjectCommand {
+  ): AppliedProjectCommand<CircuitDeviceRowStructureProjectCommand, CircuitDeviceRowStructureProjectCommand> {
     if (command.type === circuitDeviceRowInsertCommandType) {
       assertCircuitDeviceRowInsertProjectCommand(command);
       return this.insert(
         database,
         projectId,
         source,
-        command.payload.row
+        command.payload.row,
+        command.payload.externalObjects ?? []
       );
     }
     if (command.type === circuitDeviceRowDeleteCommandType) {
@@ -66,7 +78,8 @@ export class CircuitDeviceRowStructureProjectCommandRepository
         database,
         projectId,
         command.payload.rowId,
-        command.payload.expectedCircuitId
+        command.payload.expectedCircuitId,
+        command.payload.externalObjects
       );
     }
     throw new Error("Unsupported circuit device-row structure command.");
@@ -76,7 +89,8 @@ export class CircuitDeviceRowStructureProjectCommandRepository
     database: AppDatabase,
     projectId: string,
     source: ExecuteCircuitDeviceRowStructureCommandInput["source"],
-    row: CircuitDeviceRowSnapshot
+    row: CircuitDeviceRowSnapshot,
+    externalObjects: ExternalObjectLinkTransition[]
   ) {
     if (source === "user" && !isElectricalPhaseType(row.phaseType)) {
       throw new Error("Device-row phase type is invalid.");
@@ -107,17 +121,23 @@ export class CircuitDeviceRowStructureProjectCommandRepository
     }
     updateDerivedCircuitVoltage(database, projectId, row.circuitId);
 
-    return createCircuitDeviceRowDeleteProjectCommand(
-      row.id,
-      row.circuitId
-    );
+    if (externalObjects.length > 0) {
+      loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Wiederherstellen geändert.");
+      applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Wiederherstellen geändert.");
+    }
+
+    return {
+      forward: createCircuitDeviceRowInsertProjectCommand(row, externalObjects),
+      inverse: createCircuitDeviceRowDeleteProjectCommand(row.id, row.circuitId, invertExternalObjectLinkTransitions(externalObjects)),
+    };
   }
 
   private delete(
     database: AppDatabase,
     projectId: string,
     rowId: string,
-    expectedCircuitId: string
+    expectedCircuitId: string,
+    suppliedExternalObjects?: ExternalObjectLinkTransition[]
   ) {
     const row = database
       .select()
@@ -130,6 +150,10 @@ export class CircuitDeviceRowStructureProjectCommandRepository
       );
     }
     this.assertCircuitInProject(database, projectId, row.circuitId);
+    const externalObjects = suppliedExternalObjects ??
+      captureExternalObjectDetachTransitions(database, projectId, [rowId]);
+    loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Löschen geändert.");
+    applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Löschen geändert.");
 
     const result = database
       .delete(circuitDeviceRows)
@@ -164,9 +188,10 @@ export class CircuitDeviceRowStructureProjectCommandRepository
       expectedCircuitId
     );
 
-    return createCircuitDeviceRowInsertProjectCommand(
-      toCircuitDeviceRowSnapshot(row)
-    );
+    return {
+      forward: createCircuitDeviceRowDeleteProjectCommand(rowId, expectedCircuitId, externalObjects),
+      inverse: createCircuitDeviceRowInsertProjectCommand(toCircuitDeviceRowSnapshot(row), invertExternalObjectLinkTransitions(externalObjects)),
+    };
   }
 
   private assertCircuitInProject(
diff --git a/src/db/repositories/circuit-group-subtree-project-command.repository.ts b/src/db/repositories/circuit-group-subtree-project-command.repository.ts
index 9bf27a0..b4baeb6 100644
--- a/src/db/repositories/circuit-group-subtree-project-command.repository.ts
+++ b/src/db/repositories/circuit-group-subtree-project-command.repository.ts
@@ -25,8 +25,14 @@ import { circuits } from "../schema/circuits.js";
 import { distributionBoardComponentProtectionDevices } from "../schema/distribution-board-component-protection-devices.js";
 import { distributionBoardComponents } from "../schema/distribution-board-components.js";
 import { toCircuitDeviceRowInsertValues } from "./circuit-device-row-structure.persistence.js";
-import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { executeProjectCommandTransactionWithAppliedForward, type AppliedProjectCommand } from "./project-command-transaction.persistence.js";
 import { assertCircuitsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
+import {
+  applyExternalObjectLinks,
+  captureExternalObjectDetachTransitions,
+  invertExternalObjectLinkTransitions,
+  loadExpectedExternalObjectTransitions,
+} from "./external-object-assignment.persistence.js";
 
 export class CircuitGroupSubtreeProjectCommandRepository
   implements CircuitGroupSubtreeProjectCommandStore
@@ -43,7 +49,11 @@ export class CircuitGroupSubtreeProjectCommandRepository
     } else {
       assertCircuitGroupRestoreSubtreeProjectCommand(input.command);
     }
-    return executeProjectCommandTransaction(
+    return executeProjectCommandTransactionWithAppliedForward<
+      CircuitGroupSubtreeProjectCommand,
+      CircuitGroupSubtreeProjectCommand,
+      CircuitGroupSubtreeProjectCommand
+    >(
       this.database,
       input,
       (tx) => this.applyCommand(tx, input.projectId, input.command)
@@ -54,7 +64,7 @@ export class CircuitGroupSubtreeProjectCommandRepository
     database: AppDatabase,
     projectId: string,
     command: CircuitGroupSubtreeProjectCommand
-  ) {
+  ): AppliedProjectCommand<CircuitGroupSubtreeProjectCommand, CircuitGroupSubtreeProjectCommand> {
     if (command.type === circuitGroupDeleteSubtreeCommandType) {
       const current = this.captureFrom(
         database,
@@ -71,6 +81,14 @@ export class CircuitGroupSubtreeProjectCommandRepository
         projectId,
         current.circuits.map((entry) => entry.circuit.id)
       );
+      const externalObjects = command.payload.externalObjects ??
+        captureExternalObjectDetachTransitions(
+          database,
+          projectId,
+          current.circuits.flatMap((entry) => entry.circuit.deviceRows.map((row) => row.id))
+        );
+      loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Löschen geändert.");
+      applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Löschen geändert.");
       const deleted = database
         .delete(circuitSections)
         .where(eq(circuitSections.id, current.group.id))
@@ -78,15 +96,20 @@ export class CircuitGroupSubtreeProjectCommandRepository
       if (deleted.changes !== 1) {
         throw new Error("Circuit-group subtree could not be deleted.");
       }
-      return createCircuitGroupRestoreSubtreeProjectCommand(
-        command.payload.snapshot
-      );
+      return {
+        forward: createCircuitGroupDeleteSubtreeProjectCommand(command.payload.snapshot, externalObjects),
+        inverse: createCircuitGroupRestoreSubtreeProjectCommand(command.payload.snapshot, invertExternalObjectLinkTransitions(externalObjects)),
+      };
     }
     if (command.type === circuitGroupRestoreSubtreeCommandType) {
       this.restore(database, projectId, command.payload.snapshot);
-      return createCircuitGroupDeleteSubtreeProjectCommand(
-        command.payload.snapshot
-      );
+      const externalObjects = command.payload.externalObjects ?? [];
+      loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Wiederherstellen geändert.");
+      applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Wiederherstellen geändert.");
+      return {
+        forward: createCircuitGroupRestoreSubtreeProjectCommand(command.payload.snapshot, externalObjects),
+        inverse: createCircuitGroupDeleteSubtreeProjectCommand(command.payload.snapshot, invertExternalObjectLinkTransitions(externalObjects)),
+      };
     }
     throw new Error("Unsupported circuit-group subtree command.");
   }
diff --git a/src/db/repositories/circuit-structure-project-command.repository.ts b/src/db/repositories/circuit-structure-project-command.repository.ts
index 4841616..f4fc420 100644
--- a/src/db/repositories/circuit-structure-project-command.repository.ts
+++ b/src/db/repositories/circuit-structure-project-command.repository.ts
@@ -25,10 +25,17 @@ import {
   toCircuitDeviceRowInsertValues,
   toCircuitDeviceRowSnapshot,
 } from "./circuit-device-row-structure.persistence.js";
-import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { executeProjectCommandTransactionWithAppliedForward, type AppliedProjectCommand } from "./project-command-transaction.persistence.js";
 import { assertCircuitsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
 import { resolveCircuitVoltage } from "./project-voltage.persistence.js";
 import { assertEquipmentIdentifierAvailable } from "./equipment-identifier-uniqueness.persistence.js";
+import {
+  applyExternalObjectLinks,
+  captureExternalObjectDetachTransitions,
+  invertExternalObjectLinkTransitions,
+  loadExpectedExternalObjectTransitions,
+  type ExternalObjectLinkTransition,
+} from "./external-object-assignment.persistence.js";
 
 export class CircuitStructureProjectCommandRepository
   implements CircuitStructureProjectCommandStore
@@ -36,11 +43,15 @@ export class CircuitStructureProjectCommandRepository
   constructor(private readonly database: AppDatabase) {}
 
   execute(input: ExecuteCircuitStructureCommandInput) {
-    return executeProjectCommandTransaction(
+    return executeProjectCommandTransactionWithAppliedForward<
+      CircuitStructureProjectCommand,
+      CircuitStructureProjectCommand,
+      CircuitStructureProjectCommand
+    >(
       this.database,
       input,
       (tx) =>
-        this.applyInTransaction(
+        this.applyWithForward(
           tx,
           input.projectId,
           input.source,
@@ -59,13 +70,23 @@ export class CircuitStructureProjectCommandRepository
     source: ExecuteCircuitStructureCommandInput["source"],
     command: CircuitStructureProjectCommand
   ): CircuitStructureProjectCommand {
+    return this.applyWithForward(database, projectId, source, command).inverse;
+  }
+
+  private applyWithForward(
+    database: AppDatabase,
+    projectId: string,
+    source: ExecuteCircuitStructureCommandInput["source"],
+    command: CircuitStructureProjectCommand
+  ): AppliedProjectCommand<CircuitStructureProjectCommand, CircuitStructureProjectCommand> {
     if (command.type === circuitInsertCommandType) {
       assertCircuitInsertProjectCommand(command);
       return this.insert(
         database,
         projectId,
         source,
-        command.payload.circuit
+        command.payload.circuit,
+        command.payload.externalObjects ?? []
       );
     }
     if (command.type === circuitDeleteCommandType) {
@@ -74,7 +95,8 @@ export class CircuitStructureProjectCommandRepository
         database,
         projectId,
         command.payload.circuitId,
-        command.payload.expectedCircuitListId
+        command.payload.expectedCircuitListId,
+        command.payload.externalObjects
       );
     }
     throw new Error("Unsupported circuit structure command.");
@@ -84,7 +106,8 @@ export class CircuitStructureProjectCommandRepository
     database: AppDatabase,
     projectId: string,
     source: ExecuteCircuitStructureCommandInput["source"],
-    snapshot: CircuitSnapshot
+    snapshot: CircuitSnapshot,
+    externalObjects: ExternalObjectLinkTransition[]
   ) {
     this.assertCircuitLocation(database, projectId, snapshot);
     if (source === "user") {
@@ -172,17 +195,23 @@ export class CircuitStructureProjectCommandRepository
         .run();
     }
 
-    return createCircuitDeleteProjectCommand(
-      snapshot.id,
-      snapshot.circuitListId
-    );
+    if (externalObjects.length > 0) {
+      loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Wiederherstellen geändert.");
+      applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Wiederherstellen geändert.");
+    }
+
+    return {
+      forward: createCircuitInsertProjectCommand(snapshot, externalObjects),
+      inverse: createCircuitDeleteProjectCommand(snapshot.id, snapshot.circuitListId, invertExternalObjectLinkTransitions(externalObjects)),
+    };
   }
 
   private delete(
     database: AppDatabase,
     projectId: string,
     circuitId: string,
-    expectedCircuitListId: string
+    expectedCircuitListId: string,
+    suppliedExternalObjects?: ExternalObjectLinkTransition[]
   ) {
     const circuit = database
       .select()
@@ -220,7 +249,12 @@ export class CircuitStructureProjectCommandRepository
       .from(circuitProtectionDevices)
       .where(eq(circuitProtectionDevices.circuitId, circuit.id))
       .get();
-    const inverse = createCircuitInsertProjectCommand({
+    const externalObjects = suppliedExternalObjects ?? captureExternalObjectDetachTransitions(
+      database, projectId, rows.map((row) => row.id)
+    );
+    loadExpectedExternalObjectTransitions(database, projectId, externalObjects, "Revit-Objekt wurde vor dem Löschen geändert.");
+    applyExternalObjectLinks(database, externalObjects, "Revit-Objekt wurde beim Löschen geändert.");
+    const circuitSnapshot: CircuitSnapshot = {
       id: circuit.id,
       circuitListId: circuit.circuitListId,
       sectionId: circuit.sectionId,
@@ -239,7 +273,7 @@ export class CircuitStructureProjectCommandRepository
       remark: circuit.remark,
       deviceRows: rows.map(toCircuitDeviceRowSnapshot),
       protectionDevice: protectionDevice ?? null,
-    });
+    };
 
     assertCircuitsAreNotReferencedAsFeeders(database, projectId, [circuit.id]);
 
@@ -255,7 +289,10 @@ export class CircuitStructureProjectCommandRepository
     if (result.changes !== 1) {
       throw new Error("Circuit could not be deleted.");
     }
-    return inverse;
+    return {
+      forward: createCircuitDeleteProjectCommand(circuitId, expectedCircuitListId, externalObjects),
+      inverse: createCircuitInsertProjectCommand(circuitSnapshot, invertExternalObjectLinkTransitions(externalObjects)),
+    };
   }
 
   private assertCircuitLocation(
diff --git a/src/db/repositories/distribution-board-structure-project-command.repository.ts b/src/db/repositories/distribution-board-structure-project-command.repository.ts
index 115705b..f7003c5 100644
--- a/src/db/repositories/distribution-board-structure-project-command.repository.ts
+++ b/src/db/repositories/distribution-board-structure-project-command.repository.ts
@@ -46,6 +46,7 @@ import { floors } from "../schema/floors.js";
 import { projects } from "../schema/projects.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
 import { assertBoardsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
+import { assertDistributionBoardHasNoExternalObjects } from "./external-object-deletion-guard.persistence.js";
 import { CircuitStructureProjectCommandRepository } from "./circuit-structure-project-command.repository.js";
 
 export class DistributionBoardStructureProjectCommandRepository
@@ -290,6 +291,7 @@ export class DistributionBoardStructureProjectCommandRepository
     }
 
     assertBoardsAreNotReferencedAsFeeders(database, projectId, [board.id]);
+    assertDistributionBoardHasNoExternalObjects(database, projectId, board.id);
 
     const deleted = database
       .delete(distributionBoards)
diff --git a/src/db/repositories/distribution-board-subtree-project-command.repository.ts b/src/db/repositories/distribution-board-subtree-project-command.repository.ts
index 969c287..b32fee5 100644
--- a/src/db/repositories/distribution-board-subtree-project-command.repository.ts
+++ b/src/db/repositories/distribution-board-subtree-project-command.repository.ts
@@ -33,6 +33,7 @@ import { rooms } from "../schema/rooms.js";
 import { toCircuitDeviceRowInsertValues } from "./circuit-device-row-structure.persistence.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
 import { assertBoardsAreNotReferencedAsFeeders } from "./distribution-board-feeding-deletion-guard.persistence.js";
+import { assertDistributionBoardHasNoExternalObjects } from "./external-object-deletion-guard.persistence.js";
 
 export class DistributionBoardSubtreeProjectCommandRepository
   implements DistributionBoardSubtreeProjectCommandStore
@@ -86,6 +87,7 @@ export class DistributionBoardSubtreeProjectCommandRepository
       assertBoardsAreNotReferencedAsFeeders(database, projectId, [
         current.distributionBoard.id,
       ]);
+      assertDistributionBoardHasNoExternalObjects(database, projectId, current.distributionBoard.id);
       const deleted = database
         .delete(distributionBoards)
         .where(
diff --git a/src/db/repositories/external-object-assignment.persistence.ts b/src/db/repositories/external-object-assignment.persistence.ts
index 1111730..505481d 100644
--- a/src/db/repositories/external-object-assignment.persistence.ts
+++ b/src/db/repositories/external-object-assignment.persistence.ts
@@ -11,6 +11,27 @@ export interface ExternalObjectLinkTransition {
   target: ExternalModelObjectSnapshot;
 }
 
+export function captureExternalObjectDetachTransitions(
+  database: AppDatabase,
+  projectId: string,
+  rowIds: string[]
+): ExternalObjectLinkTransition[] {
+  if (rowIds.length === 0) return [];
+  return database.select().from(externalModelObjects)
+    .where(and(
+      eq(externalModelObjects.projectId, projectId),
+      inArray(externalModelObjects.circuitDeviceRowId, rowIds)
+    )).all()
+    .map(toExternalObjectSnapshot)
+    .map((expected) => ({ expected, target: { ...expected, circuitDeviceRowId: null } }));
+}
+
+export function invertExternalObjectLinkTransitions(
+  transitions: ExternalObjectLinkTransition[]
+): ExternalObjectLinkTransition[] {
+  return transitions.map(({ expected, target }) => ({ expected: target, target: expected }));
+}
+
 export function loadExpectedExternalObjectTransitions(
   database: AppDatabase,
   projectId: string,
@@ -86,7 +107,13 @@ export function applyExternalObjectLinks(
 ) {
   for (const { expected, target } of transitions) {
     const updated = database.update(externalModelObjects)
-      .set({ circuitDeviceRowId: target.circuitDeviceRowId })
+      .set({
+        circuitDeviceRowId: target.circuitDeviceRowId,
+        distributionBoardId: target.distributionBoardId,
+        linkedProjectDeviceId: target.linkedProjectDeviceId,
+        planningValues: target.planningValues,
+        overriddenFields: target.overriddenFields,
+      })
       .where(and(
         eq(externalModelObjects.id, expected.id),
         expected.circuitDeviceRowId === null
diff --git a/src/db/repositories/external-object-deletion-guard.persistence.ts b/src/db/repositories/external-object-deletion-guard.persistence.ts
new file mode 100644
index 0000000..45fdac7
--- /dev/null
+++ b/src/db/repositories/external-object-deletion-guard.persistence.ts
@@ -0,0 +1,37 @@
+import { and, eq } from "drizzle-orm";
+import type { AppDatabase } from "../database-context.js";
+import { externalModelObjects } from "../schema/external-model-objects.js";
+import { externalRoomMappings } from "../schema/external-room-mappings.js";
+
+export function assertDistributionBoardHasNoExternalObjects(
+  database: AppDatabase,
+  projectId: string,
+  distributionBoardId: string
+) {
+  const reference = database.select({ id: externalModelObjects.id })
+    .from(externalModelObjects)
+    .where(and(
+      eq(externalModelObjects.projectId, projectId),
+      eq(externalModelObjects.distributionBoardId, distributionBoardId)
+    )).limit(1).get();
+  if (reference) {
+    throw new Error("Der Verteiler kann nicht gelöscht werden, solange Revit-Objekte auf ihn verweisen.");
+  }
+}
+
+export function assertRoomHasNoExternalObjects(
+  database: AppDatabase,
+  projectId: string,
+  roomId: string
+) {
+  const reference = database.select({ id: externalModelObjects.id })
+    .from(externalModelObjects)
+    .innerJoin(externalRoomMappings, eq(externalRoomMappings.id, externalModelObjects.externalRoomMappingId))
+    .where(and(
+      eq(externalModelObjects.projectId, projectId),
+      eq(externalRoomMappings.roomId, roomId)
+    )).limit(1).get();
+  if (reference) {
+    throw new Error("Der Raum kann nicht gelöscht werden, solange Revit-Objekte auf ihn verweisen.");
+  }
+}
diff --git a/src/db/repositories/project-location-structure-project-command.repository.ts b/src/db/repositories/project-location-structure-project-command.repository.ts
index 51edb3b..40a1743 100644
--- a/src/db/repositories/project-location-structure-project-command.repository.ts
+++ b/src/db/repositories/project-location-structure-project-command.repository.ts
@@ -46,6 +46,7 @@ import { distributionBoards } from "../schema/distribution-boards.js";
 import { projects } from "../schema/projects.js";
 import { rooms } from "../schema/rooms.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { assertRoomHasNoExternalObjects } from "./external-object-deletion-guard.persistence.js";
 
 export class ProjectLocationStructureProjectCommandRepository
   implements ProjectLocationStructureProjectCommandStore
@@ -439,6 +440,7 @@ export class ProjectLocationStructureProjectCommandRepository
         "Der Raum kann nicht gelöscht werden, solange er in einem Stromkreis verwendet wird."
       );
     }
+    assertRoomHasNoExternalObjects(database, projectId, expected.id);
     const deleted = database
       .delete(rooms)
       .where(
diff --git a/src/domain/models/circuit-device-row-structure-project-command.model.ts b/src/domain/models/circuit-device-row-structure-project-command.model.ts
index 2464a27..ebba5ac 100644
--- a/src/domain/models/circuit-device-row-structure-project-command.model.ts
+++ b/src/domain/models/circuit-device-row-structure-project-command.model.ts
@@ -1,4 +1,11 @@
 import type { SerializedProjectCommand } from "./project-command.model.js";
+import type { ExternalModelObjectSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import { parseExternalModelStateSnapshot } from "./project-state-snapshot.model.js";
+
+export interface ExternalObjectLinkSnapshotTransition {
+  expected: ExternalModelObjectSnapshot;
+  target: ExternalModelObjectSnapshot;
+}
 
 export const circuitDeviceRowInsertCommandType =
   "circuit-device-row.insert" as const;
@@ -32,11 +39,13 @@ export interface CircuitDeviceRowSnapshot {
 
 export interface CircuitDeviceRowInsertCommandPayload {
   row: CircuitDeviceRowSnapshot;
+  externalObjects?: ExternalObjectLinkSnapshotTransition[];
 }
 
 export interface CircuitDeviceRowDeleteCommandPayload {
   rowId: string;
   expectedCircuitId: string;
+  externalObjects?: ExternalObjectLinkSnapshotTransition[];
 }
 
 export interface CircuitDeviceRowInsertProjectCommand
@@ -56,7 +65,8 @@ export type CircuitDeviceRowStructureProjectCommand =
   | CircuitDeviceRowDeleteProjectCommand;
 
 export function createCircuitDeviceRowInsertProjectCommand(
-  row: CircuitDeviceRowSnapshot
+  row: CircuitDeviceRowSnapshot,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitDeviceRowInsertProjectCommand {
   const normalizedRow = {
     ...row,
@@ -65,7 +75,7 @@ export function createCircuitDeviceRowInsertProjectCommand(
   const command: CircuitDeviceRowInsertProjectCommand = {
     schemaVersion: circuitDeviceRowStructureCommandSchemaVersion,
     type: circuitDeviceRowInsertCommandType,
-    payload: { row: normalizedRow },
+    payload: { row: normalizedRow, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitDeviceRowInsertProjectCommand(command);
   return command;
@@ -73,12 +83,13 @@ export function createCircuitDeviceRowInsertProjectCommand(
 
 export function createCircuitDeviceRowDeleteProjectCommand(
   rowId: string,
-  expectedCircuitId: string
+  expectedCircuitId: string,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitDeviceRowDeleteProjectCommand {
   const command: CircuitDeviceRowDeleteProjectCommand = {
     schemaVersion: circuitDeviceRowStructureCommandSchemaVersion,
     type: circuitDeviceRowDeleteCommandType,
-    payload: { rowId, expectedCircuitId },
+    payload: { rowId, expectedCircuitId, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitDeviceRowDeleteProjectCommand(command);
   return command;
@@ -143,6 +154,7 @@ export function assertCircuitDeviceRowInsertProjectCommand(
       throw new Error("row.cosPhi must be positive or null.");
     }
   }
+  assertExternalObjectLinkTransitions(command.payload.externalObjects);
 }
 
 export function assertCircuitDeviceRowDeleteProjectCommand(
@@ -163,6 +175,41 @@ export function assertCircuitDeviceRowDeleteProjectCommand(
     command.payload.expectedCircuitId,
     "expectedCircuitId"
   );
+  assertExternalObjectLinkTransitions(command.payload.externalObjects);
+}
+
+export function assertExternalObjectLinkTransitions(value: unknown) {
+  if (value === undefined) return;
+  if (!Array.isArray(value)) throw new Error("externalObjects must be an array.");
+  const ids = new Set<string>();
+  for (const transition of value) {
+    if (!isPlainObject(transition) || !isPlainObject(transition.expected) || !isPlainObject(transition.target)) {
+      throw new Error("Invalid external object link transition.");
+    }
+    const expectedId = transition.expected.id;
+    const targetId = transition.target.id;
+    if (typeof expectedId !== "string" || expectedId !== targetId || ids.has(expectedId)) {
+      throw new Error("External object link transition has mismatched or duplicate ids.");
+    }
+    ids.add(expectedId);
+    const expectedRowId = transition.expected.circuitDeviceRowId;
+    const targetRowId = transition.target.circuitDeviceRowId;
+    if ((expectedRowId !== null && typeof expectedRowId !== "string") || (targetRowId !== null && typeof targetRowId !== "string")) {
+      throw new Error("Invalid external object row link.");
+    }
+    const parsed = parseExternalModelStateSnapshot({ source: null, importBatches: [], roomMappings: [], objects: [transition.expected, transition.target] }).objects;
+    const expectedRest = { ...parsed[0], circuitDeviceRowId: null };
+    const targetRest = { ...parsed[1], circuitDeviceRowId: null };
+    if (canonicalJson(expectedRest) !== canonicalJson(targetRest) || expectedRowId === targetRowId) {
+      throw new Error("External object transition may only change the row link.");
+    }
+  }
+}
+
+function canonicalJson(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (isPlainObject(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+  return JSON.stringify(value) ?? "null";
 }
 
 function assertNonEmptyString(value: unknown, field: string) {
diff --git a/src/domain/models/circuit-group-subtree-project-command.model.ts b/src/domain/models/circuit-group-subtree-project-command.model.ts
index a3e53b3..4470cd2 100644
--- a/src/domain/models/circuit-group-subtree-project-command.model.ts
+++ b/src/domain/models/circuit-group-subtree-project-command.model.ts
@@ -3,6 +3,7 @@ import {
   type CircuitGroupSubtreeSnapshot,
 } from "./circuit-group-subtree-snapshot.model.js";
 import type { SerializedProjectCommand } from "./project-command.model.js";
+import { assertExternalObjectLinkTransitions, type ExternalObjectLinkSnapshotTransition } from "./circuit-device-row-structure-project-command.model.js";
 
 export const circuitGroupDeleteSubtreeCommandType =
   "circuit-group.delete-subtree" as const;
@@ -12,6 +13,7 @@ export const circuitGroupSubtreeCommandSchemaVersion = 1 as const;
 
 interface Payload {
   snapshot: CircuitGroupSubtreeSnapshot;
+  externalObjects?: ExternalObjectLinkSnapshotTransition[];
 }
 
 export interface CircuitGroupDeleteSubtreeProjectCommand
@@ -31,24 +33,26 @@ export type CircuitGroupSubtreeProjectCommand =
   | CircuitGroupRestoreSubtreeProjectCommand;
 
 export function createCircuitGroupDeleteSubtreeProjectCommand(
-  snapshot: CircuitGroupSubtreeSnapshot
+  snapshot: CircuitGroupSubtreeSnapshot,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitGroupDeleteSubtreeProjectCommand {
   const command: CircuitGroupDeleteSubtreeProjectCommand = {
     schemaVersion: circuitGroupSubtreeCommandSchemaVersion,
     type: circuitGroupDeleteSubtreeCommandType,
-    payload: { snapshot },
+    payload: { snapshot, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitGroupDeleteSubtreeProjectCommand(command);
   return command;
 }
 
 export function createCircuitGroupRestoreSubtreeProjectCommand(
-  snapshot: CircuitGroupSubtreeSnapshot
+  snapshot: CircuitGroupSubtreeSnapshot,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitGroupRestoreSubtreeProjectCommand {
   const command: CircuitGroupRestoreSubtreeProjectCommand = {
     schemaVersion: circuitGroupSubtreeCommandSchemaVersion,
     type: circuitGroupRestoreSubtreeCommandType,
-    payload: { snapshot },
+    payload: { snapshot, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitGroupRestoreSubtreeProjectCommand(command);
   return command;
@@ -76,11 +80,12 @@ function assertCommand(
     command.schemaVersion !== circuitGroupSubtreeCommandSchemaVersion ||
     command.type !== type ||
     !isPlainObject(command.payload) ||
-    Object.keys(command.payload).length !== 1
+    Object.keys(command.payload).some((key) => key !== "snapshot" && key !== "externalObjects")
   ) {
     throw new Error("Unsupported circuit-group subtree command.");
   }
   assertCircuitGroupSubtreeSnapshot(command.payload.snapshot);
+  assertExternalObjectLinkTransitions(command.payload.externalObjects);
 }
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
diff --git a/src/domain/models/circuit-structure-project-command.model.ts b/src/domain/models/circuit-structure-project-command.model.ts
index 5260c4b..292c776 100644
--- a/src/domain/models/circuit-structure-project-command.model.ts
+++ b/src/domain/models/circuit-structure-project-command.model.ts
@@ -3,6 +3,8 @@ import {
   circuitDeviceRowInsertCommandType,
   circuitDeviceRowStructureCommandSchemaVersion,
   type CircuitDeviceRowSnapshot,
+  type ExternalObjectLinkSnapshotTransition,
+  assertExternalObjectLinkTransitions,
 } from "./circuit-device-row-structure-project-command.model.js";
 import type { SerializedProjectCommand } from "./project-command.model.js";
 import {
@@ -37,11 +39,13 @@ export interface CircuitSnapshot {
 
 export interface CircuitInsertCommandPayload {
   circuit: CircuitSnapshot;
+  externalObjects?: ExternalObjectLinkSnapshotTransition[];
 }
 
 export interface CircuitDeleteCommandPayload {
   circuitId: string;
   expectedCircuitListId: string;
+  externalObjects?: ExternalObjectLinkSnapshotTransition[];
 }
 
 export interface CircuitInsertProjectCommand
@@ -61,12 +65,13 @@ export type CircuitStructureProjectCommand =
   | CircuitDeleteProjectCommand;
 
 export function createCircuitInsertProjectCommand(
-  circuit: CircuitSnapshot
+  circuit: CircuitSnapshot,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitInsertProjectCommand {
   const command: CircuitInsertProjectCommand = {
     schemaVersion: circuitStructureCommandSchemaVersion,
     type: circuitInsertCommandType,
-    payload: { circuit },
+    payload: { circuit, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitInsertProjectCommand(command);
   return command;
@@ -74,12 +79,13 @@ export function createCircuitInsertProjectCommand(
 
 export function createCircuitDeleteProjectCommand(
   circuitId: string,
-  expectedCircuitListId: string
+  expectedCircuitListId: string,
+  externalObjects?: ExternalObjectLinkSnapshotTransition[]
 ): CircuitDeleteProjectCommand {
   const command: CircuitDeleteProjectCommand = {
     schemaVersion: circuitStructureCommandSchemaVersion,
     type: circuitDeleteCommandType,
-    payload: { circuitId, expectedCircuitListId },
+    payload: { circuitId, expectedCircuitListId, ...(externalObjects?.length ? { externalObjects } : {}) },
   };
   assertCircuitDeleteProjectCommand(command);
   return command;
@@ -168,6 +174,7 @@ export function assertCircuitInsertProjectCommand(
     }
     rowIds.add(row.id);
   }
+  assertExternalObjectLinkTransitions(command.payload.externalObjects);
 }
 
 export function assertCircuitDeleteProjectCommand(
@@ -187,6 +194,7 @@ export function assertCircuitDeleteProjectCommand(
     command.payload.expectedCircuitListId,
     "expectedCircuitListId"
   );
+  assertExternalObjectLinkTransitions(command.payload.externalObjects);
 }
 
 function assertNonEmptyString(value: unknown, field: string) {
diff --git a/src/domain/models/circuit-tree.model.ts b/src/domain/models/circuit-tree.model.ts
index 00a0c2d..fd1bd2c 100644
--- a/src/domain/models/circuit-tree.model.ts
+++ b/src/domain/models/circuit-tree.model.ts
@@ -20,6 +20,7 @@ export interface CircuitTreeDeviceRow {
   remark?: string;
   overriddenFields?: string;
   rowTotalPower: number;
+  externalObjectCount?: number;
 }
 
 export interface CircuitTreeCircuit {
diff --git a/src/domain/models/external-object-new-circuit-project-command.model.ts b/src/domain/models/external-object-new-circuit-project-command.model.ts
index b34a449..e7a3e23 100644
--- a/src/domain/models/external-object-new-circuit-project-command.model.ts
+++ b/src/domain/models/external-object-new-circuit-project-command.model.ts
@@ -146,8 +146,8 @@ function assertOnlyAssignmentChanged(
   expected: ExternalModelObjectSnapshot,
   target: ExternalModelObjectSnapshot
 ) {
-  const expectedRest = { ...expected, circuitDeviceRowId: null };
-  const targetRest = { ...target, circuitDeviceRowId: null };
+  const expectedRest = { ...expected, circuitDeviceRowId: null, distributionBoardId: null };
+  const targetRest = { ...target, circuitDeviceRowId: null, distributionBoardId: null };
   if (canonicalJson(expectedRest) !== canonicalJson(targetRest)) {
     throw new Error("New-circuit assignment may only change the external object row link.");
   }
diff --git a/src/domain/models/external-object-new-row-project-command.model.ts b/src/domain/models/external-object-new-row-project-command.model.ts
index d0416dd..6bae039 100644
--- a/src/domain/models/external-object-new-row-project-command.model.ts
+++ b/src/domain/models/external-object-new-row-project-command.model.ts
@@ -141,8 +141,8 @@ function assertOnlyAssignmentChanged(
   expected: ExternalModelObjectSnapshot,
   target: ExternalModelObjectSnapshot
 ) {
-  const expectedRest = { ...expected, circuitDeviceRowId: null };
-  const targetRest = { ...target, circuitDeviceRowId: null };
+  const expectedRest = { ...expected, circuitDeviceRowId: null, distributionBoardId: null };
+  const targetRest = { ...target, circuitDeviceRowId: null, distributionBoardId: null };
   if (canonicalJson(expectedRest) !== canonicalJson(targetRest)) {
     throw new Error("New-row assignment may only change the external object row link.");
   }
diff --git a/src/domain/models/external-object-row-assignment-project-command.model.ts b/src/domain/models/external-object-row-assignment-project-command.model.ts
index a45fe31..cb4ae97 100644
--- a/src/domain/models/external-object-row-assignment-project-command.model.ts
+++ b/src/domain/models/external-object-row-assignment-project-command.model.ts
@@ -104,10 +104,10 @@ export function assertExternalObjectRowAssignmentProjectCommand(
     if (expected.circuitDeviceRowId === target.circuitDeviceRowId) {
       throw new Error("External object row assignment must change its row link.");
     }
-    assertOnlyFieldChanged(
+    assertOnlyFieldsChanged(
       expected as unknown as Record<string, unknown>,
       target as unknown as Record<string, unknown>,
-      "circuitDeviceRowId",
+      new Set(["circuitDeviceRowId", "distributionBoardId", "linkedProjectDeviceId", "planningValues", "overriddenFields"]),
       "external object"
     );
     if (expected.circuitDeviceRowId) affectedRowIds.add(expected.circuitDeviceRowId);
@@ -161,11 +161,22 @@ function assertOnlyFieldChanged(
   target: Record<string, unknown>,
   allowedField: string,
   label: string
+) {
+  assertOnlyFieldsChanged(expected, target, new Set([allowedField]), label);
+}
+
+function assertOnlyFieldsChanged(
+  expected: Record<string, unknown>,
+  target: Record<string, unknown>,
+  allowedFields: ReadonlySet<string>,
+  label: string
 ) {
   const expectedRest = { ...expected };
   const targetRest = { ...target };
-  delete expectedRest[allowedField];
-  delete targetRest[allowedField];
+  for (const field of allowedFields) {
+    delete expectedRest[field];
+    delete targetRest[field];
+  }
   if (canonicalJson(expectedRest) !== canonicalJson(targetRest)) {
     throw new Error(`Row assignment may only change the ${label} assignment state.`);
   }
diff --git a/src/frontend/components/circuit-tree-editor.tsx b/src/frontend/components/circuit-tree-editor.tsx
index f75b64e..5418922 100644
--- a/src/frontend/components/circuit-tree-editor.tsx
+++ b/src/frontend/components/circuit-tree-editor.tsx
@@ -120,6 +120,11 @@ import {
   deleteCircuitGroupCommand,
   deleteCircuitGroupSubtreeCommand,
   deleteDistributionBoardComponentCommand,
+  assignExternalProjectObjectsToRow,
+  assignExternalProjectObjectsToNewRow,
+  assignExternalProjectObjectsToNewCircuit,
+  detachExternalProjectObjectsFromRow,
+  getExternalProjectObjects,
   getCircuitTree,
   getNextCircuitIdentifier,
   getProjectHistory,
@@ -154,6 +159,7 @@ import type {
   ProjectCommandResultDto,
   ProjectDeviceDto,
   ProjectHistoryStateDto,
+  ExternalProjectObjectsDto,
 } from "../types";
 import type {
   CircuitDeviceRowSnapshot,
@@ -330,6 +336,9 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
   const [cableSizingEditorCircuit, setCableSizingEditorCircuit] =
     useState<CircuitTreeCircuitDto | null>(null);
   const [projectDevices, setProjectDevices] = useState<ProjectDeviceDto[]>([]);
+  const [externalObjects, setExternalObjects] = useState<ExternalProjectObjectsDto | null>(null);
+  const [isRevitDrawerOpen, setIsRevitDrawerOpen] = useState(false);
+  const [draggingExternalObjectIds, setDraggingExternalObjectIds] = useState<string[]>([]);
   const [isProjectDeviceDrawerOpen, setIsProjectDeviceDrawerOpen] =
     useState(false);
   const [projectDeviceSearch, setProjectDeviceSearch] = useState("");
@@ -381,6 +390,26 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     () => orderedColumns.filter((column) => visibleColumnKeys.includes(column.key)),
     [orderedColumns, visibleColumnKeys]
   );
+  const externalObjectGroups = useMemo(() => {
+    if (!data || !externalObjects) return [];
+    const groups = new Map<string, typeof externalObjects.objects>();
+    for (const object of externalObjects.objects) {
+      if (object.presenceStatus !== "present" || object.circuitDeviceRowId !== null || object.distributionBoardId !== data.distributionBoardId) continue;
+      const key = JSON.stringify([
+        object.roomId, object.selectionMarker, object.deviceTypeId,
+        object.planningValues.category, object.linkedProjectDeviceId,
+        object.planningValues,
+      ]);
+      const entries = groups.get(key) ?? [];
+      entries.push(object);
+      groups.set(key, entries);
+    }
+    return [...groups.values()].map((objects) => ({
+      key: objects.map((object) => object.id).sort().join("|"),
+      objects,
+      quantity: objects.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0),
+    }));
+  }, [data, externalObjects]);
 
   async function loadTree(options?: { showLoading?: boolean }) {
     const showLoading = options?.showLoading ?? false;
@@ -389,13 +418,17 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     }
     setError(null);
     try {
-      const { tree, history } = await loadCircuitEditorSnapshot(
-        () => getCircuitTree(projectId, circuitListId),
-        () => getProjectHistory(projectId)
-      );
+      const [{ tree, history }, external] = await Promise.all([
+        loadCircuitEditorSnapshot(
+          () => getCircuitTree(projectId, circuitListId),
+          () => getProjectHistory(projectId)
+        ),
+        getExternalProjectObjects(projectId),
+      ]);
       projectRevisionRef.current = history.currentRevision;
       setHistoryState(history);
       setData(tree);
+      setExternalObjects(external);
     } catch (err) {
       setError(normalizeUiError(err));
     } finally {
@@ -1321,12 +1354,20 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     const summary = subtree
       ? summarizeCircuitGroupSubtree(subtree)
       : null;
+    const externalObjectCount = section.circuits.reduce(
+      (total, circuit) => total + circuit.deviceRows.reduce(
+        (rowTotal, row) => rowTotal + (row.externalObjectCount ?? 0), 0
+      ), 0
+    );
+    const externalWarning = externalObjectCount > 0
+      ? `\n\n${externalObjectCount} Revit-Objekte werden wieder unzugeordnet.`
+      : "";
     const warning = isEmpty
       ? `Leere Stromkreisgruppe „${section.displayName}“ entfernen?`
       : `Stromkreisgruppe „${section.displayName}“ vollständig entfernen?\n\n` +
         `Dabei werden ${summary!.circuitCount} Stromkreis(e), ${summary!.deviceRowCount} Gerätezeile(n) und ${summary!.protectionComponentCount} Gruppenschutzgerät(e) gelöscht.\n\n` +
         "Die Änderung kann über die projektweite Versionshistorie rückgängig gemacht werden.";
-    if (!confirm(warning)) {
+    if (!confirm(warning + externalWarning)) {
       return;
     }
     await runCommand({
@@ -2878,11 +2919,15 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       setError("Die Gerätezeile ist ungültig.");
       return;
     }
+    const externalWarning = (rowSnapshot.externalObjectCount ?? 0) > 0
+      ? `\n\n${rowSnapshot.externalObjectCount} Revit-Objekte werden wieder unzugeordnet.`
+      : "";
     if (sourceCircuit.deviceRows.length === 1) {
       const keepAsReserve = confirm(
         `„${rowSnapshot.displayName}“ ist das letzte Gerät in ${sourceCircuit.equipmentIdentifier}.\n\n` +
           "OK: Gerät löschen und den leeren Stromkreis als Reserve behalten.\n" +
-          "Abbrechen: anschließend entscheiden, ob stattdessen der gesamte Stromkreis gelöscht werden soll."
+          "Abbrechen: anschließend entscheiden, ob stattdessen der gesamte Stromkreis gelöscht werden soll." +
+          externalWarning
       );
       if (!keepAsReserve) {
         const deleteCircuit = confirm(
@@ -2894,7 +2939,7 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
         }
         return;
       }
-    } else if (!confirm(`Gerätezeile „${rowSnapshot.displayName}“ löschen?`)) {
+    } else if (!confirm(`Gerätezeile „${rowSnapshot.displayName}“ löschen?${externalWarning}`)) {
       return;
     }
     await runCommand({
@@ -2917,11 +2962,18 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       setError("Der Stromkreis ist ungültig.");
       return;
     }
+    const externalObjectCount = circuit.deviceRows.reduce(
+      (total, row) => total + (row.externalObjectCount ?? 0), 0
+    );
+    const externalWarning = externalObjectCount > 0
+      ? `\n\n${externalObjectCount} Revit-Objekte werden wieder unzugeordnet.`
+      : "";
     if (
       askForConfirmation &&
       !confirm(
         `Stromkreis ${circuit.equipmentIdentifier} und ${circuit.deviceRows.length} zugeordnete Gerätezeile(n) löschen?\n\n` +
-          "Bestehende Betriebsmittelkennzeichen werden nicht neu nummeriert."
+          "Bestehende Betriebsmittelkennzeichen werden nicht neu nummeriert." +
+          externalWarning
       )
     ) {
       return;
@@ -2958,6 +3010,56 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
     await handleDeleteCircuit(intent.circuitId);
   }
 
+  async function handleAssignExternalObjects(rowId: string, objectIds: string[]) {
+    if (!confirm(`${objectIds.length} Revit-Objekt(e) dieser Gerätezeile zuordnen?\n\nAbweichende Planungswerte werden ausdrücklich zugunsten der Gerätezeile bestätigt.`)) return;
+    await runCommand({
+      label: "Revit-Objekte zuordnen",
+      redo: async () => {
+        const result = await assignExternalProjectObjectsToRow(
+          projectId,
+          getExpectedProjectRevision(),
+          objectIds,
+          rowId,
+          objectIds
+        );
+        applyProjectCommandResult(result);
+        setDraggingExternalObjectIds([]);
+        return null;
+      },
+    });
+  }
+
+  async function handleAssignExternalObjectsToNewRow(circuitId: string, objectIds: string[]) {
+    if (!confirm(`${objectIds.length} Revit-Objekt(e) als neue Gerätezeile anlegen?`)) return;
+    await runCommand({ label: "Revit-Objekte als Gerätezeile zuordnen", redo: async () => {
+      const result = await assignExternalProjectObjectsToNewRow(projectId, getExpectedProjectRevision(), objectIds, circuitId);
+      applyProjectCommandResult(result); setDraggingExternalObjectIds([]); return null;
+    }});
+  }
+
+  async function handleAssignExternalObjectsToNewCircuit(sectionId: string, objectIds: string[]) {
+    if (!confirm(`${objectIds.length} Revit-Objekt(e) als neuen Stromkreis anlegen?`)) return;
+    await runCommand({ label: "Revit-Objekte als Stromkreis zuordnen", redo: async () => {
+      const result = await assignExternalProjectObjectsToNewCircuit(projectId, getExpectedProjectRevision(), objectIds, sectionId);
+      applyProjectCommandResult(result); setDraggingExternalObjectIds([]); return null;
+    }});
+  }
+
+  async function handleDetachExternalObjects(rowId: string) {
+    const objectIds = externalObjects?.objects
+      .filter((object) => object.circuitDeviceRowId === rowId)
+      .map((object) => object.id) ?? [];
+    if (objectIds.length === 0 || !confirm(`${objectIds.length} Revit-Objekt(e) lösen?\n\nDie aktuellen Werte der Gerätezeile werden als Planungswerte und Overrides übernommen.`)) return;
+    await runCommand({
+      label: "Revit-Objekte lösen",
+      redo: async () => {
+        const result = await detachExternalProjectObjectsFromRow(projectId, getExpectedProjectRevision(), objectIds);
+        applyProjectCommandResult(result);
+        return null;
+      },
+    });
+  }
+
   // Explicit renumber action through project history. Sorting and device rows
   // remain unchanged; the server handles collision-safe identifier swaps.
   async function handleRenumberSection(sectionId: string) {
@@ -3381,6 +3483,15 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
           }
           showLabel
         />
+        <IconButton
+          ariaControls="revit-object-drawer"
+          ariaExpanded={isRevitDrawerOpen}
+          className="project-device-drawer-toggle"
+          icon={isRevitDrawerOpen ? PanelRightClose : PanelRightOpen}
+          label={isRevitDrawerOpen ? "Revit-Objekte schließen" : `Revit-Objekte öffnen (${externalObjectGroups.reduce((sum, group) => sum + group.objects.length, 0)})`}
+          onClick={() => setIsRevitDrawerOpen((current) => !current)}
+          showLabel
+        />
         <IconButton
           ariaControls="project-device-drawer"
           ariaExpanded={isProjectDeviceDrawerOpen}
@@ -3419,6 +3530,62 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
       ) : null}
       {isSaving ? <div className="notice info">Wird gespeichert …</div> : null}
       <div className="tree-editor-layout">
+        {isRevitDrawerOpen ? (
+          <aside className="project-device-sidebar project-device-drawer" id="revit-object-drawer">
+            <div className="project-device-drawer-header">
+              <div>
+                <h3>Revit-Objekte</h3>
+                <span>{externalObjectGroups.reduce((sum, group) => sum + group.objects.length, 0)} unzugeordnet</span>
+              </div>
+              <button type="button" onClick={() => setIsRevitDrawerOpen(false)}>Schließen</button>
+            </div>
+            <div className="project-device-list">
+              {externalObjectGroups.map((group) => {
+                const first = group.objects[0]!;
+                return (
+                  <details
+                    key={group.key}
+                    className={`project-device-item ${draggingExternalObjectIds[0] === first.id ? "dragging" : ""}`}
+                  >
+                    <summary
+                      draggable
+                      onDragStart={(event) => {
+                        const ids = group.objects.map((object) => object.id);
+                        setDraggingExternalObjectIds(ids);
+                        event.dataTransfer.effectAllowed = "move";
+                        event.dataTransfer.setData("application/x-revit-object-ids", JSON.stringify(ids));
+                      }}
+                      onDragEnd={() => setDraggingExternalObjectIds([])}
+                    >
+                      <strong>{first.planningValues.displayName || first.selectionMarker || first.familyAndType}</strong>
+                      <span>{first.sourceRoomNumber} {first.sourceRoomName}</span>
+                      <span>{group.objects.length} Objekt(e), Menge {formatValue(group.quantity, "quantity")}</span>
+                      <span>{first.familyAndType}</span>
+                    </summary>
+                    {group.objects.map((object) => (
+                      <button
+                        key={object.id}
+                        type="button"
+                        draggable
+                        className="btn btn-sm btn-outline-secondary mt-2 w-100 text-start"
+                        onDragStart={(event) => {
+                          setDraggingExternalObjectIds([object.id]);
+                          event.dataTransfer.effectAllowed = "move";
+                          event.dataTransfer.setData("application/x-revit-object-ids", JSON.stringify([object.id]));
+                          event.stopPropagation();
+                        }}
+                        onDragEnd={() => setDraggingExternalObjectIds([])}
+                      >
+                        {object.worksharingId}
+                      </button>
+                    ))}
+                  </details>
+                );
+              })}
+              {externalObjectGroups.length === 0 ? <p className="notice muted">Keine unzugeordneten Revit-Objekte für diesen Verteiler.</p> : null}
+            </div>
+          </aside>
+        ) : null}
         {isProjectDeviceDrawerOpen ? (
         <aside
           className="project-device-sidebar project-device-drawer"
@@ -4202,6 +4369,11 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                   }`}
                   onClick={() => setActiveSectionId(row.sectionId)}
                   onDragOver={(event) => {
+                    if (draggingExternalObjectIds.length > 0 && (row.device || row.circuit || row.rowType === "placeholder")) {
+                      event.preventDefault();
+                      event.dataTransfer.dropEffect = "move";
+                      return;
+                    }
                     if (draggingCircuitCount > 0) {
                       const valid = isCircuitDropTargetValid(
                         row.sectionId
@@ -4342,6 +4514,21 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                     });
                   }}
                   onDrop={(event) => {
+                    if (draggingExternalObjectIds.length > 0 && row.device) {
+                      event.preventDefault();
+                      void handleAssignExternalObjects(row.device.id, draggingExternalObjectIds);
+                      return;
+                    }
+                    if (draggingExternalObjectIds.length > 0 && row.rowType === "placeholder") {
+                      event.preventDefault();
+                      void handleAssignExternalObjectsToNewCircuit(row.sectionId, draggingExternalObjectIds);
+                      return;
+                    }
+                    if (draggingExternalObjectIds.length > 0 && row.circuit) {
+                      event.preventDefault();
+                      void handleAssignExternalObjectsToNewRow(row.circuit.id, draggingExternalObjectIds);
+                      return;
+                    }
                     if (draggingCircuitCount > 0) {
                       if (row.rowType === "placeholder") {
                         void handleCircuitReorderDrop(event, {
@@ -4728,14 +4915,26 @@ export function CircuitTreeEditor(props: { projectId: string; circuitListId: str
                       </>
                     ) : null}
                     {row.device ? (
-                      <IconButton
-                        disabled={isSaving}
-                        icon={ListX}
-                        label="Gerät löschen"
-                        onClick={() => void handleDeleteDevice(row.device!.id)}
-                        tabIndex={-1}
-                        variant="danger"
-                      />
+                      <>
+                        {(row.device.externalObjectCount ?? 0) > 0 ? (
+                          <button
+                            type="button"
+                            className="badge rounded-pill text-bg-info border-0"
+                            title="Verknüpfte Revit-Objekte anzeigen und lösen"
+                            onClick={() => void handleDetachExternalObjects(row.device!.id)}
+                          >
+                            Revit {row.device.externalObjectCount}
+                          </button>
+                        ) : null}
+                        <IconButton
+                          disabled={isSaving}
+                          icon={ListX}
+                          label="Gerät löschen"
+                          onClick={() => void handleDeleteDevice(row.device!.id)}
+                          tabIndex={-1}
+                          variant="danger"
+                        />
+                      </>
                     ) : null}
                     {dropIntent?.kind === "new-circuit" && row.rowType === "placeholder" && dropIntent.sectionId === row.sectionId ? (
                       <span className="drop-hint">
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 49466f5..b1a6344 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -447,6 +447,7 @@ export interface CircuitTreeDeviceRowDto {
   remark?: string;
   overriddenFields?: string;
   rowTotalPower: number;
+  externalObjectCount?: number;
 }
 
 export interface CircuitTreeProtectionDeviceDto {
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index c46f80b..b329f53 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -245,6 +245,32 @@ export function updateExternalProjectObjects(projectId: string, expectedRevision
   return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects`, { method: "PUT", body: JSON.stringify({ expectedRevision, objectIds, patch }) });
 }
 
+export function assignExternalProjectObjectsToRow(projectId: string, expectedRevision: number, objectIds: string[], rowId: string, confirmedConflictObjectIds: string[] = []) {
+  return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects/assign-row`, {
+    method: "POST",
+    body: JSON.stringify({ expectedRevision, objectIds, rowId, confirmedConflictObjectIds }),
+  });
+}
+
+export function detachExternalProjectObjectsFromRow(projectId: string, expectedRevision: number, objectIds: string[]) {
+  return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects/detach-row`, {
+    method: "POST",
+    body: JSON.stringify({ expectedRevision, objectIds }),
+  });
+}
+
+export function assignExternalProjectObjectsToNewRow(projectId: string, expectedRevision: number, objectIds: string[], circuitId: string) {
+  return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects/assign-new-row`, {
+    method: "POST", body: JSON.stringify({ expectedRevision, objectIds, circuitId }),
+  });
+}
+
+export function assignExternalProjectObjectsToNewCircuit(projectId: string, expectedRevision: number, objectIds: string[], sectionId: string) {
+  return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects/assign-new-circuit`, {
+    method: "POST", body: JSON.stringify({ expectedRevision, objectIds, sectionId }),
+  });
+}
+
 export function getProjectHistory(projectId: string) {
   return request<ProjectHistoryStateDto>(
     `/api/projects/${projectId}/history`
diff --git a/src/server/controllers/circuit-tree.controller.ts b/src/server/controllers/circuit-tree.controller.ts
index 17ac134..d1fb7f6 100644
--- a/src/server/controllers/circuit-tree.controller.ts
+++ b/src/server/controllers/circuit-tree.controller.ts
@@ -14,6 +14,7 @@ import {
   circuitSectionRepository,
   distributionBoardComponentRepository,
   distributionBoardRepository,
+  externalModelStateRepository,
   projectRepository,
 } from "../composition/application-repositories.js";
 
@@ -88,6 +89,13 @@ export async function buildProjectCircuitTrees(
     circuitListRepository.listByProject(projectId),
     distributionBoardRepository.listByProject(projectId),
   ]);
+  const externalState = externalModelStateRepository.getByProject(projectId).state;
+  const externalCountByRowId = new Map<string, number>();
+  for (const object of externalState.objects) {
+    if (object.circuitDeviceRowId) {
+      externalCountByRowId.set(object.circuitDeviceRowId, (externalCountByRowId.get(object.circuitDeviceRowId) ?? 0) + 1);
+    }
+  }
   const listIds = lists.map((entry) => entry.id);
   const [sections, circuits, components] = await Promise.all([
     circuitSectionRepository.listByCircuitLists(listIds),
@@ -237,6 +245,7 @@ export async function buildProjectCircuitTrees(
           row.powerPerUnit,
           row.simultaneityFactor
         ),
+        externalObjectCount: externalCountByRowId.get(row.id) ?? 0,
       }));
       const circuitLoad = loads.circuits.get(circuit.id);
       if (!circuitLoad) throw new Error("Circuit load is missing.");
diff --git a/src/server/controllers/external-objects.controller.ts b/src/server/controllers/external-objects.controller.ts
index f56f7be..8e90673 100644
--- a/src/server/controllers/external-objects.controller.ts
+++ b/src/server/controllers/external-objects.controller.ts
@@ -1,9 +1,17 @@
 import type { Request, Response } from "express";
+import { randomUUID } from "node:crypto";
 import { createExternalObjectPlanningUpdateProjectCommand } from "../../domain/models/external-object-planning-project-command.model.js";
+import { createExternalObjectRowAssignmentProjectCommand } from "../../domain/models/external-object-row-assignment-project-command.model.js";
+import type { CircuitDeviceRowSnapshot } from "../../domain/models/circuit-device-row-structure-project-command.model.js";
 import type { ExternalModelObjectPlanningValues } from "../../external-model/domain/external-model-contracts.js";
 import { distributionBoardRepository, externalModelStateRepository, projectDeviceRepository, projectRepository } from "../composition/application-repositories.js";
 import { projectCommandService } from "../composition/project-command-stores.js";
 import { respondWithProjectCommandError } from "./project-command.controller.js";
+import { buildProjectCircuitTrees } from "./circuit-tree.controller.js";
+import { createExternalObjectNewRowProjectCommand, externalObjectAssignToNewRowCommandType } from "../../domain/models/external-object-new-row-project-command.model.js";
+import { createExternalObjectNewCircuitProjectCommand, externalObjectAssignToNewCircuitCommandType } from "../../domain/models/external-object-new-circuit-project-command.model.js";
+import { createDefaultCircuitProtection } from "../../domain/services/protection-device-defaults.js";
+import { circuitNumberingService } from "../composition/circuit-numbering-service.js";
 
 export async function listExternalObjects(req: Request, res: Response) {
   const projectId = String(req.params.projectId ?? "");
@@ -49,6 +57,221 @@ export function updateExternalObjects(req: Request, res: Response) {
   } catch (error) { return respondWithProjectCommandError(error, res); }
 }
 
+export async function assignExternalObjectsToRow(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const objectIds = parseObjectIds(req.body?.objectIds);
+    const rowId = requiredId(req.body?.rowId, "Ungültige Gerätezeile.");
+    const confirmedConflictObjectIds = Array.isArray(req.body?.confirmedConflictObjectIds)
+      ? req.body.confirmedConflictObjectIds.map((value: unknown) => requiredId(value, "Ungültige Konfliktbestätigung."))
+      : [];
+    const { state, projectExists } = externalModelStateRepository.getByProject(projectId);
+    if (!projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    const treeResult = await buildProjectCircuitTrees(projectId);
+    const location = findRow(treeResult, rowId);
+    if (!location) throw new Error("Gerätezeile wurde nicht gefunden.");
+    const byId = new Map(state.objects.map((object) => [object.id, object]));
+    const selected = objectIds.map((id) => {
+      const object = byId.get(id);
+      if (!object) throw new Error("Ein Revit-Objekt wurde nicht gefunden.");
+      if (object.circuitDeviceRowId !== null) throw new Error("Ein Revit-Objekt ist bereits einer Gerätezeile zugeordnet.");
+      return object;
+    });
+    const expectedRow = toRowSnapshot(location.row, location.circuitId);
+    const addedQuantity = selected.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0);
+    const targetRow = { ...expectedRow, quantity: expectedRow.quantity + addedQuantity };
+    const objects = selected.map((expected) => ({
+      expected,
+      target: { ...expected, distributionBoardId: location.distributionBoardId, circuitDeviceRowId: rowId },
+    }));
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision,
+      description: `${objects.length} Revit-Objekte zugeordnet`,
+      command: createExternalObjectRowAssignmentProjectCommand({
+        rows: [{ expected: expectedRow, target: targetRow }],
+        objects,
+        confirmedConflictObjectIds,
+      }),
+    });
+    return res.json(result);
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+export async function detachExternalObjectsFromRow(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const objectIds = parseObjectIds(req.body?.objectIds);
+    const { state, projectExists } = externalModelStateRepository.getByProject(projectId);
+    if (!projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    const treeResult = await buildProjectCircuitTrees(projectId);
+    const byId = new Map(state.objects.map((object) => [object.id, object]));
+    const selected = objectIds.map((id) => {
+      const object = byId.get(id);
+      if (!object?.circuitDeviceRowId) throw new Error("Ein Revit-Objekt ist keiner Gerätezeile zugeordnet.");
+      return object;
+    });
+    const rowIds = new Set(selected.map((object) => object.circuitDeviceRowId!));
+    if (rowIds.size !== 1) throw new Error("Revit-Objekte können nur aus derselben Gerätezeile gemeinsam gelöst werden.");
+    const rowId = [...rowIds][0]!;
+    const location = findRow(treeResult, rowId);
+    if (!location) throw new Error("Gerätezeile wurde nicht gefunden.");
+    const expectedRow = toRowSnapshot(location.row, location.circuitId);
+    const removedQuantity = selected.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0);
+    const targetRow = { ...expectedRow, quantity: expectedRow.quantity - removedQuantity };
+    const copiedFields = ["displayName", "category", "connectionKind", "powerPerUnitW", "simultaneityFactor", "cosPhi", "costGroup", "remark"] as const;
+    const objects = selected.map((expected) => ({
+      expected,
+      target: {
+        ...expected,
+        circuitDeviceRowId: null,
+        distributionBoardId: location.distributionBoardId,
+        linkedProjectDeviceId: expectedRow.linkedProjectDeviceId,
+        planningValues: {
+          ...expected.planningValues,
+          displayName: expectedRow.displayName,
+          category: location.category,
+          connectionKind: expectedRow.connectionKind,
+          powerPerUnitW: expectedRow.powerPerUnit * 1000,
+          simultaneityFactor: expectedRow.simultaneityFactor,
+          cosPhi: expectedRow.cosPhi,
+          costGroup: expectedRow.costGroup,
+          remark: expectedRow.remark,
+        },
+        overriddenFields: [...new Set([...expected.overriddenFields, ...copiedFields])],
+      },
+    }));
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision,
+      description: `${objects.length} Revit-Objekte gelöst`,
+      command: createExternalObjectRowAssignmentProjectCommand({
+        rows: [{ expected: expectedRow, target: targetRow }],
+        objects,
+        confirmedConflictObjectIds: [],
+      }),
+    });
+    return res.json(result);
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+export async function assignExternalObjectsToNewRow(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const objectIds = parseObjectIds(req.body?.objectIds);
+    const circuitId = requiredId(req.body?.circuitId, "Ungültiger Stromkreis.");
+    const context = await loadAssignmentContext(projectId, objectIds);
+    const circuitLocation = context.treeResult?.trees.flatMap((tree) => tree.sections.flatMap((section) => section.circuits.map((circuit) => ({ tree, section, circuit })))).find((entry) => entry.circuit.id === circuitId);
+    if (!circuitLocation || !circuitLocation.section.category) throw new Error("Stromkreis wurde nicht gefunden.");
+    const row = buildExternalRow(context.objects, context.roomId, circuitId, Math.max(0, ...circuitLocation.circuit.deviceRows.map((entry) => entry.sortOrder)) + 10);
+    const transitions = context.objects.map((expected) => ({ expected, target: { ...expected, distributionBoardId: circuitLocation.tree.distributionBoardId, circuitDeviceRowId: row.id } }));
+    const result = projectCommandService.executeUser({ projectId, expectedRevision, description: `${transitions.length} Revit-Objekte als neue Gerätezeile zugeordnet`, command: createExternalObjectNewRowProjectCommand(externalObjectAssignToNewRowCommandType, { row, objects: transitions, confirmedConflictObjectIds: objectIds }) });
+    return res.json(result);
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+export async function assignExternalObjectsToNewCircuit(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const objectIds = parseObjectIds(req.body?.objectIds);
+    const sectionId = requiredId(req.body?.sectionId, "Ungültige Stromkreisgruppe.");
+    const context = await loadAssignmentContext(projectId, objectIds);
+    const sectionLocation = context.treeResult?.trees.flatMap((tree) => tree.sections.map((section) => ({ tree, section }))).find((entry) => entry.section.id === sectionId);
+    if (!sectionLocation?.section.category) throw new Error("Stromkreisgruppe wurde nicht gefunden.");
+    const circuitId = randomUUID();
+    const row = buildExternalRow(context.objects, context.roomId, circuitId, 10);
+    const protection = createDefaultCircuitProtection(sectionLocation.section.category);
+    const circuit = {
+      id: circuitId,
+      circuitListId: sectionLocation.tree.circuitListId,
+      sectionId,
+      equipmentIdentifier: await circuitNumberingService.getNextIdentifier(sectionId),
+      displayName: null,
+      sortOrder: Math.max(0, ...sectionLocation.section.circuits.map((entry) => entry.sortOrder)) + 10,
+      cableType: null, cableCrossSection: null, cableLength: null, rcdAssignment: null,
+      terminalDesignation: null,
+      voltage: sectionLocation.section.category === "three_phase" ? sectionLocation.tree.threePhaseVoltageV : sectionLocation.tree.singlePhaseVoltageV,
+      controlRequirement: null, status: null, isReserve: false, remark: null,
+      deviceRows: [row],
+      protectionDevice: {
+        circuitId,
+        type: protection.type,
+        ratedCurrentA: protection.ratedCurrentA,
+        fuseUtilizationCategory: "fuseUtilizationCategory" in protection ? protection.fuseUtilizationCategory : null,
+        tripCharacteristic: "tripCharacteristic" in protection ? protection.tripCharacteristic : null,
+        rcdType: "rcdType" in protection ? protection.rcdType : null,
+        ratedResidualCurrentMa: "ratedResidualCurrentMa" in protection ? protection.ratedResidualCurrentMa : null,
+      },
+    };
+    const transitions = context.objects.map((expected) => ({ expected, target: { ...expected, distributionBoardId: sectionLocation.tree.distributionBoardId, circuitDeviceRowId: row.id } }));
+    const result = projectCommandService.executeUser({ projectId, expectedRevision, description: `${transitions.length} Revit-Objekte als neuen Stromkreis zugeordnet`, command: createExternalObjectNewCircuitProjectCommand(externalObjectAssignToNewCircuitCommandType, { circuit, objects: transitions, confirmedConflictObjectIds: objectIds }) });
+    return res.json(result);
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+async function loadAssignmentContext(projectId: string, objectIds: string[]) {
+  const { state, projectExists } = externalModelStateRepository.getByProject(projectId);
+  if (!projectExists) throw new Error("Projekt nicht gefunden.");
+  const byId = new Map(state.objects.map((object) => [object.id, object]));
+  const objects = objectIds.map((id) => {
+    const object = byId.get(id);
+    if (!object) throw new Error("Ein Revit-Objekt wurde nicht gefunden.");
+    if (object.circuitDeviceRowId !== null) throw new Error("Ein Revit-Objekt ist bereits zugeordnet.");
+    return object;
+  });
+  const roomIds = new Set(objects.map((object) => object.externalRoomMappingId === null ? null : state.roomMappings.find((mapping) => mapping.id === object.externalRoomMappingId)?.roomId ?? null));
+  if (roomIds.size !== 1) throw new Error("Revit-Objekte aus verschiedenen Räumen benötigen getrennte Gerätezeilen.");
+  return { objects, roomId: [...roomIds][0]!, treeResult: await buildProjectCircuitTrees(projectId) };
+}
+
+function buildExternalRow(objects: ReturnType<typeof externalModelStateRepository.getByProject>["state"]["objects"], roomId: string | null, circuitId: string, sortOrder: number): CircuitDeviceRowSnapshot {
+  const first = objects[0]!;
+  const planning = first.planningValues;
+  const quantity = objects.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0);
+  return {
+    id: randomUUID(), circuitId, linkedProjectDeviceId: first.linkedProjectDeviceId,
+    sortOrder, name: first.acceptedSourceValues.familyAndType,
+    displayName: planning.displayName ?? (scalarText(first.acceptedSourceValues.selectionMarker) || first.acceptedSourceValues.familyAndType),
+    phaseType: planning.category === "three_phase" ? "three_phase" : "single_phase",
+    connectionKind: planning.connectionKind, costGroup: planning.costGroup,
+    category: planning.category, level: null,
+    roomId,
+    roomNumberSnapshot: scalarText(first.acceptedSourceValues.roomNumber) || null,
+    roomNameSnapshot: scalarText(first.acceptedSourceValues.roomName) || null,
+    quantity, manualQuantity: 0,
+    powerPerUnit: (planning.powerPerUnitW ?? 0) / 1000,
+    simultaneityFactor: planning.simultaneityFactor ?? 1,
+    cosPhi: planning.cosPhi, remark: planning.remark, overriddenFields: null,
+  };
+}
+
+function parseExpectedRevision(value: unknown) {
+  if (!Number.isSafeInteger(value) || (value as number) < 0) throw new Error("Ungültige Projektrevision.");
+  return value as number;
+}
+function parseObjectIds(value: unknown): string[] {
+  if (!Array.isArray(value) || value.length === 0) throw new Error("Keine Revit-Objekte ausgewählt.");
+  const ids = value.map((entry) => requiredId(entry, "Ungültige Revit-Objekt-ID."));
+  if (new Set(ids).size !== ids.length) throw new Error("Revit-Objekte sind doppelt ausgewählt.");
+  return ids;
+}
+function requiredId(value: unknown, message: string) { if (typeof value !== "string" || !value) throw new Error(message); return value; }
+function findRow(result: Awaited<ReturnType<typeof buildProjectCircuitTrees>>, rowId: string) {
+  if (!result) return null;
+  for (const tree of result.trees) for (const section of tree.sections) for (const circuit of section.circuits) {
+    const row = circuit.deviceRows.find((entry) => entry.id === rowId);
+    if (row) return { row, circuitId: circuit.id, distributionBoardId: tree.distributionBoardId, category: section.category ?? null };
+  }
+  return null;
+}
+function toRowSnapshot(row: NonNullable<ReturnType<typeof findRow>>["row"], circuitId: string): CircuitDeviceRowSnapshot {
+  return { id: row.id, circuitId, linkedProjectDeviceId: row.linkedProjectDeviceId ?? null, sortOrder: row.sortOrder, name: row.name, displayName: row.displayName, phaseType: row.phaseType ?? null, connectionKind: row.connectionKind ?? null, costGroup: row.costGroup ?? null, category: row.category ?? null, level: row.level ?? null, roomId: row.roomId ?? null, roomNumberSnapshot: row.roomNumberSnapshot ?? null, roomNameSnapshot: row.roomNameSnapshot ?? null, quantity: row.quantity, manualQuantity: row.manualQuantity, powerPerUnit: row.powerPerUnit, simultaneityFactor: row.simultaneityFactor, cosPhi: row.cosPhi ?? null, remark: row.remark ?? null, overriddenFields: row.overriddenFields ?? null };
+}
+
 const planningFields = ["displayName", "category", "connectionKind", "effectiveQuantity", "powerPerUnitW", "simultaneityFactor", "cosPhi", "costGroup", "remark"] as const satisfies readonly (keyof ExternalModelObjectPlanningValues)[];
 function scalarText(value: string | number | boolean | null) { return value === null ? "" : String(value); }
 function isRecord(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); }
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index 53c2225..f07d9b0 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -63,7 +63,7 @@ import {
   getExternalInitialImportStatus,
   planExternalInitialImport,
 } from "../controllers/external-initial-import.controller.js";
-import { listExternalObjects, updateExternalObjects } from "../controllers/external-objects.controller.js";
+import { assignExternalObjectsToNewCircuit, assignExternalObjectsToNewRow, assignExternalObjectsToRow, detachExternalObjectsFromRow, listExternalObjects, updateExternalObjects } from "../controllers/external-objects.controller.js";
 
 export const projectRouter = Router();
 
@@ -93,6 +93,10 @@ projectRouter.post("/:projectId/external-model/initial-import/plan", planExterna
 projectRouter.post("/:projectId/external-model/initial-import/apply", applyExternalInitialImport);
 projectRouter.get("/:projectId/external-model/objects", listExternalObjects);
 projectRouter.put("/:projectId/external-model/objects", updateExternalObjects);
+projectRouter.post("/:projectId/external-model/objects/assign-row", assignExternalObjectsToRow);
+projectRouter.post("/:projectId/external-model/objects/assign-new-row", assignExternalObjectsToNewRow);
+projectRouter.post("/:projectId/external-model/objects/assign-new-circuit", assignExternalObjectsToNewCircuit);
+projectRouter.post("/:projectId/external-model/objects/detach-row", detachExternalObjectsFromRow);
 projectRouter.get("/:projectId/distribution-boards", listDistributionBoardsByProject);
 projectRouter.post("/:projectId/distribution-boards", createDistributionBoard);
 projectRouter.post(
diff --git a/tests/external-object-row-assignment-project-command.repository.test.ts b/tests/external-object-row-assignment-project-command.repository.test.ts
index 4512e90..547d60f 100644
--- a/tests/external-object-row-assignment-project-command.repository.test.ts
+++ b/tests/external-object-row-assignment-project-command.repository.test.ts
@@ -7,6 +7,9 @@ import { createDatabaseContext, type AppDatabase } from "../src/db/database-cont
 import { ExternalObjectRowAssignmentProjectCommandRepository } from "../src/db/repositories/external-object-row-assignment-project-command.repository.js";
 import { ExternalObjectNewRowProjectCommandRepository } from "../src/db/repositories/external-object-new-row-project-command.repository.js";
 import { ExternalObjectNewCircuitProjectCommandRepository } from "../src/db/repositories/external-object-new-circuit-project-command.repository.js";
+import { CircuitDeviceRowStructureProjectCommandRepository } from "../src/db/repositories/circuit-device-row-structure-project-command.repository.js";
+import { CircuitStructureProjectCommandRepository } from "../src/db/repositories/circuit-structure-project-command.repository.js";
+import { CircuitGroupSubtreeProjectCommandRepository } from "../src/db/repositories/circuit-group-subtree-project-command.repository.js";
 import { toCircuitDeviceRowSnapshot } from "../src/db/repositories/circuit-device-row-structure.persistence.js";
 import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
 import { circuitLists } from "../src/db/schema/circuit-lists.js";
@@ -31,6 +34,10 @@ import {
   externalObjectAssignToNewCircuitCommandType,
 } from "../src/domain/models/external-object-new-circuit-project-command.model.js";
 import type { ExternalModelObjectSnapshot } from "../src/external-model/domain/external-model-contracts.js";
+import { createCircuitDeviceRowDeleteProjectCommand } from "../src/domain/models/circuit-device-row-structure-project-command.model.js";
+import { createCircuitDeleteProjectCommand } from "../src/domain/models/circuit-structure-project-command.model.js";
+import { createCircuitGroupDeleteSubtreeProjectCommand } from "../src/domain/models/circuit-group-subtree-project-command.model.js";
+import { assertDistributionBoardHasNoExternalObjects, assertRoomHasNoExternalObjects } from "../src/db/repositories/external-object-deletion-guard.persistence.js";
 
 function createFixture(initialObjectRowId: string | null = "row-1") {
   const context = createDatabaseContext(":memory:");
@@ -626,4 +633,63 @@ describe("external object new-circuit project command", () => {
       context.close();
     }
   });
+
+  it("detaches linked objects on row deletion and restores the exact link on undo", () => {
+    const context = createFixture();
+    try {
+      const repository = new CircuitDeviceRowStructureProjectCommandRepository(context.db);
+      const deleted = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createCircuitDeviceRowDeleteProjectCommand("row-1", "circuit-1"),
+      });
+      assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, null);
+      assert.equal(context.db.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, "row-1")).get(), undefined);
+
+      repository.execute({
+        projectId: "project-1",
+        expectedRevision: 1,
+        source: "undo",
+        historyTargetChangeSetId: deleted.revision.changeSetId,
+        command: deleted.inverse,
+      });
+      assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, "row-1");
+      assert.ok(context.db.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, "row-1")).get());
+    } finally {
+      context.close();
+    }
+  });
+
+  it("preserves external links through circuit and populated-group deletion undo", () => {
+    for (const kind of ["circuit", "group"] as const) {
+      const context = createFixture();
+      try {
+        const repository = kind === "circuit"
+          ? new CircuitStructureProjectCommandRepository(context.db)
+          : new CircuitGroupSubtreeProjectCommandRepository(context.db);
+        const command = kind === "circuit"
+          ? createCircuitDeleteProjectCommand("circuit-1", "list-1")
+          : createCircuitGroupDeleteSubtreeProjectCommand(
+              (repository as CircuitGroupSubtreeProjectCommandRepository).capture("project-1", "section-1")
+            );
+        const deleted = repository.execute({ projectId: "project-1", expectedRevision: 0, source: "user", command } as never);
+        assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, null);
+        repository.execute({ projectId: "project-1", expectedRevision: 1, source: "undo", historyTargetChangeSetId: deleted.revision.changeSetId, command: deleted.inverse } as never);
+        assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, "row-1");
+      } finally {
+        context.close();
+      }
+    }
+  });
+
+  it("blocks room and distribution-board deletion while external objects reference them", () => {
+    const context = createFixture(null);
+    try {
+      assert.throws(() => assertDistributionBoardHasNoExternalObjects(context.db, "project-1", "board-1"), /Revit-Objekte/);
+      assert.throws(() => assertRoomHasNoExternalObjects(context.db, "project-1", "room-1"), /Revit-Objekte/);
+    } finally {
+      context.close();
+    }
+  });
 });

From 1a4c8cad8cd9f88044dd3d267616fdd9f58398cd Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 15:15:17 +0200
Subject: [PATCH 57/60] Add Revit return workbook export

---
 .../revit-excel-integration-requirements.md   |    8 +
 docs/spec/revit-excel-phase-14-plan.md        |    9 +-
 .../migrations/0015_wide_night_thrasher.sql   |   16 +
 src/db/migrations/meta/0015_snapshot.json     | 3210 +++++++++++++++++
 src/db/migrations/meta/_journal.json          |    7 +
 .../external-export-batch.repository.ts       |   18 +
 src/db/schema/external-export-batches.ts      |   24 +
 .../external-xlsx-return-projection.ts        |  135 +
 .../components/revit-object-table.tsx         |   41 +-
 src/frontend/types.ts                         |   23 +
 src/frontend/utils/api.ts                     |   14 +
 .../composition/application-repositories.ts   |    2 +
 .../external-return-workbook.controller.ts    |  180 +
 src/server/routes/project.routes.ts           |    3 +
 .../external-export-batch.repository.test.ts  |   40 +
 tests/external-xlsx-return-projection.test.ts |   43 +
 tests/revit-xlsx-settings-api.test.ts         |   16 +-
 17 files changed, 3783 insertions(+), 6 deletions(-)
 create mode 100644 src/db/migrations/0015_wide_night_thrasher.sql
 create mode 100644 src/db/migrations/meta/0015_snapshot.json
 create mode 100644 src/db/repositories/external-export-batch.repository.ts
 create mode 100644 src/db/schema/external-export-batches.ts
 create mode 100644 src/external-model/application/external-xlsx-return-projection.ts
 create mode 100644 src/server/controllers/external-return-workbook.controller.ts
 create mode 100644 tests/external-export-batch.repository.test.ts
 create mode 100644 tests/external-xlsx-return-projection.test.ts

diff --git a/docs/spec/revit-excel-integration-requirements.md b/docs/spec/revit-excel-integration-requirements.md
index 5add6fb..ce80c46 100644
--- a/docs/spec/revit-excel-integration-requirements.md
+++ b/docs/spec/revit-excel-integration-requirements.md
@@ -348,6 +348,14 @@ Pfade.
 
 ## 12. Rückgabe-Excel
 
+Umsetzungsstand R8: Die Revit-Objekttabelle bietet alle drei Rückgabeumfänge
+an und lädt eine aus dem letzten vollständigen Import erzeugte XLSX herunter.
+Die Serverprojektion verwendet für verknüpfte Objekte die aktuellen Row- und
+Circuit-Werte, für freie Objekte die Planungswerte und schreibt Zahlen als
+Excel-Zahlen. Hinweise zu nicht berechenbaren Werten und fehlenden optionalen
+Spalten werden nach dem Download angezeigt. Der append-only Exportnachweis
+liegt außerhalb von Projektrevision, Undo/Redo, Snapshots und Transfer.
+
 Der Export ist eine Leseoperation ohne Projektrevision. Ein append-only
 Nachweis speichert Projektrevision, zugrunde liegenden letzten Import,
 Zeitpunkt, Dateiname, SHA-256, Konfigurationskopie beziehungsweise ihren Hash
diff --git a/docs/spec/revit-excel-phase-14-plan.md b/docs/spec/revit-excel-phase-14-plan.md
index 700db4c..61d8f2d 100644
--- a/docs/spec/revit-excel-phase-14-plan.md
+++ b/docs/spec/revit-excel-phase-14-plan.md
@@ -16,7 +16,7 @@ Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
 | R5 | abgeschlossen | Zustandslose XLSX-Vorschau, sechsstufiger Erstimportwizard und atomarer Importcommand mit parserfreiem Undo/Redo. |
 | R6 | abgeschlossen | Projektweite kompakte Objektliste, clientseitige Filter/Sortierung, Virtualisierung und revisionierte Sammeländerungen. |
 | R7 | abgeschlossen | Gruppierter Editorbereich, drei Drag-and-drop-Ziele, Row-Indikator, ausdrückliches Lösen und atomare Löschübergänge mit exaktem Undo/Redo. |
-| R8 | offen | Rückgabe-Excel und append-only Exportnachweis. |
+| R8 | abgeschlossen | Rückgabe-Excel für alle, abweichende oder ausgewählte Objekte und append-only Exportnachweis sind umgesetzt. |
 | R9 | offen | Vollständiger Folgeimport nach Worksharing-ID. |
 | R10 | offen | Ende-zu-Ende-Härtung, große Datenmengen und Abschlussdokumentation. |
 
@@ -173,6 +173,13 @@ Sammelaktionen gesperrt und folgen weiterhin ausschließlich ihrer Row.
 
 R8 baut auf der in R2 durch Linear bestätigten Transportstrategie auf.
 
+Umsetzungsstand: Die Revit-Objekttabelle erzeugt die Rückgabe revisionssicher
+aus dem letzten vollständigen Import. Die gemeinsame Projektion berechnet
+Stromkreis, Bezeichnung, Leistung, Spannung und Strom; der XLSX-Adapter erhält
+Struktur und Formate und meldet fehlende optionale Spalten. Jeder erfolgreiche
+Download wird außerhalb von Projektcommands, Snapshots und Transfers mit
+Revision, Importbatch, Konfigurationskopie und Prüfsummen protokolliert.
+
 ## R9 – Folgeimport
 
 - exaktes, case-sensitives Matching nach Worksharing-ID;
diff --git a/src/db/migrations/0015_wide_night_thrasher.sql b/src/db/migrations/0015_wide_night_thrasher.sql
new file mode 100644
index 0000000..fcd376b
--- /dev/null
+++ b/src/db/migrations/0015_wide_night_thrasher.sql
@@ -0,0 +1,16 @@
+CREATE TABLE `external_export_batches` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`project_revision` integer NOT NULL,
+	`import_batch_id` text NOT NULL,
+	`exported_at_iso` text NOT NULL,
+	`file_name` text NOT NULL,
+	`sha256` text NOT NULL,
+	`configuration_snapshot` text NOT NULL,
+	`configuration_sha256` text NOT NULL,
+	`scope` text NOT NULL,
+	`object_count` integer NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX `external_export_batches_project_exported_idx` ON `external_export_batches` (`project_id`,`exported_at_iso`);
\ No newline at end of file
diff --git a/src/db/migrations/meta/0015_snapshot.json b/src/db/migrations/meta/0015_snapshot.json
new file mode 100644
index 0000000..9c00cc3
--- /dev/null
+++ b/src/db/migrations/meta/0015_snapshot.json
@@ -0,0 +1,3210 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "eab4abfa-dc46-4330-9ddd-b4676343d610",
+  "prevId": "b443af16-e0aa-459a-9443-62a7f8c6b6dd",
+  "tables": {
+    "buildings": {
+      "name": "buildings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "buildings_project_id_projects_id_fk": {
+          "name": "buildings_project_id_projects_id_fk",
+          "tableFrom": "buildings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_device_rows": {
+      "name": "circuit_device_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "level": {
+          "name": "level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number_snapshot": {
+          "name": "room_number_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_name_snapshot": {
+          "name": "room_name_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "manual_quantity": {
+          "name": "manual_quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_device_rows_circuit_id_idx": {
+          "name": "circuit_device_rows_circuit_id_idx",
+          "columns": [
+            "circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "circuit_device_rows_circuit_id_circuits_id_fk": {
+          "name": "circuit_device_rows_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_linked_project_device_id_project_devices_id_fk": {
+          "name": "circuit_device_rows_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "circuit_device_rows_room_id_rooms_id_fk": {
+          "name": "circuit_device_rows_room_id_rooms_id_fk",
+          "tableFrom": "circuit_device_rows",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_list_equipment_identifiers": {
+      "name": "circuit_list_equipment_identifiers",
+      "columns": {
+        "owner_type": {
+          "name": "owner_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "owner_id": {
+          "name": "owner_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_list_equipment_identifiers_owner_unique": {
+          "name": "circuit_list_equipment_identifiers_owner_unique",
+          "columns": [
+            "owner_type",
+            "owner_id"
+          ],
+          "isUnique": true
+        },
+        "circuit_list_equipment_identifiers_list_identifier_unique": {
+          "name": "circuit_list_equipment_identifiers_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_list_equipment_identifiers_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_list_equipment_identifiers",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_lists": {
+      "name": "circuit_lists",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_lists_distribution_board_id_unique": {
+          "name": "circuit_lists_distribution_board_id_unique",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_lists_project_id_projects_id_fk": {
+          "name": "circuit_lists_project_id_projects_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuit_lists_distribution_board_id_distribution_boards_id_fk": {
+          "name": "circuit_lists_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "circuit_lists",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_protection_devices": {
+      "name": "circuit_protection_devices",
+      "columns": {
+        "circuit_id": {
+          "name": "circuit_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "circuit_protection_devices_circuit_id_circuits_id_fk": {
+          "name": "circuit_protection_devices_circuit_id_circuits_id_fk",
+          "tableFrom": "circuit_protection_devices",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuit_sections": {
+      "name": "circuit_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "group_number": {
+          "name": "group_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuit_sections_list_key_unique": {
+          "name": "circuit_sections_list_key_unique",
+          "columns": [
+            "circuit_list_id",
+            "key"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_prefix_unique": {
+          "name": "circuit_sections_list_prefix_unique",
+          "columns": [
+            "circuit_list_id",
+            "prefix"
+          ],
+          "isUnique": true
+        },
+        "circuit_sections_list_category_group_unique": {
+          "name": "circuit_sections_list_category_group_unique",
+          "columns": [
+            "circuit_list_id",
+            "category",
+            "group_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuit_sections_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuit_sections_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuit_sections",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "circuits": {
+      "name": "circuits",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "cable_type": {
+          "name": "cable_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_cross_section": {
+          "name": "cable_cross_section",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cable_length": {
+          "name": "cable_length",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_assignment": {
+          "name": "rcd_assignment",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "terminal_designation": {
+          "name": "terminal_designation",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage": {
+          "name": "voltage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "control_requirement": {
+          "name": "control_requirement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_reserve": {
+          "name": "is_reserve",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "circuits_section_id_idx": {
+          "name": "circuits_section_id_idx",
+          "columns": [
+            "section_id"
+          ],
+          "isUnique": false
+        },
+        "circuits_list_equipment_identifier_unique": {
+          "name": "circuits_list_equipment_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "circuits_circuit_list_id_circuit_lists_id_fk": {
+          "name": "circuits_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "circuits_section_id_circuit_sections_id_fk": {
+          "name": "circuits_section_id_circuit_sections_id_fk",
+          "tableFrom": "circuits",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_component_protection_devices": {
+      "name": "distribution_board_component_protection_devices",
+      "columns": {
+        "component_id": {
+          "name": "component_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rated_current_a": {
+          "name": "rated_current_a",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "fuse_utilization_category": {
+          "name": "fuse_utilization_category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trip_characteristic": {
+          "name": "trip_characteristic",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rcd_type": {
+          "name": "rcd_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rated_residual_current_ma": {
+          "name": "rated_residual_current_ma",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk": {
+          "name": "distribution_board_component_protection_devices_component_id_distribution_board_components_id_fk",
+          "tableFrom": "distribution_board_component_protection_devices",
+          "tableTo": "distribution_board_components",
+          "columnsFrom": [
+            "component_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_board_components": {
+      "name": "distribution_board_components",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "circuit_list_id": {
+          "name": "circuit_list_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "equipment_identifier": {
+          "name": "equipment_identifier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "placement": {
+          "name": "placement",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "distribution_board_components_list_identifier_unique": {
+          "name": "distribution_board_components_list_identifier_unique",
+          "columns": [
+            "circuit_list_id",
+            "equipment_identifier"
+          ],
+          "isUnique": true
+        },
+        "distribution_board_components_section_role_unique": {
+          "name": "distribution_board_components_section_role_unique",
+          "columns": [
+            "section_id",
+            "role"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "distribution_board_components_circuit_list_id_circuit_lists_id_fk": {
+          "name": "distribution_board_components_circuit_list_id_circuit_lists_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_lists",
+          "columnsFrom": [
+            "circuit_list_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_board_components_section_id_circuit_sections_id_fk": {
+          "name": "distribution_board_components_section_id_circuit_sections_id_fk",
+          "tableFrom": "distribution_board_components",
+          "tableTo": "circuit_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_boards": {
+      "name": "distribution_boards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "supply_type": {
+          "name": "supply_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "board_number": {
+          "name": "board_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "location": {
+          "name": "location",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "fed_from": {
+          "name": "fed_from",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "feeding_distribution_board_id": {
+          "name": "feeding_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "feeding_circuit_id": {
+          "name": "feeding_circuit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "distribution_boards_feeding_board_idx": {
+          "name": "distribution_boards_feeding_board_idx",
+          "columns": [
+            "feeding_distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "distribution_boards_feeding_circuit_idx": {
+          "name": "distribution_boards_feeding_circuit_idx",
+          "columns": [
+            "feeding_circuit_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "distribution_boards_project_id_projects_id_fk": {
+          "name": "distribution_boards_project_id_projects_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_floor_id_floors_id_fk": {
+          "name": "distribution_boards_floor_id_floors_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_feeding_distribution_board_id_distribution_boards_id_fk": {
+          "name": "distribution_boards_feeding_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "feeding_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "distribution_boards_feeding_circuit_id_circuits_id_fk": {
+          "name": "distribution_boards_feeding_circuit_id_circuits_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "circuits",
+          "columnsFrom": [
+            "feeding_circuit_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_assets": {
+      "name": "document_branding_assets",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "document_branding_settings": {
+      "name": "document_branding_settings",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_balances": {
+      "name": "estimate_balances",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "date_iso": {
+          "name": "date_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "reserve_av_percent": {
+          "name": "reserve_av_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "reserve_sv_percent": {
+          "name": "reserve_sv_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_balances_project_id_idx": {
+          "name": "estimate_balances_project_id_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_balances_project_id_projects_id_fk": {
+          "name": "estimate_balances_project_id_projects_id_fk",
+          "tableFrom": "estimate_balances",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_groups": {
+      "name": "estimate_groups",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "balance_id": {
+          "name": "balance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "editor": {
+          "name": "editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "estimate_groups_balance_id_idx": {
+          "name": "estimate_groups_balance_id_idx",
+          "columns": [
+            "balance_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_groups_balance_id_estimate_balances_id_fk": {
+          "name": "estimate_groups_balance_id_estimate_balances_id_fk",
+          "tableFrom": "estimate_groups",
+          "tableTo": "estimate_balances",
+          "columnsFrom": [
+            "balance_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "estimate_rows": {
+      "name": "estimate_rows",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "supply": {
+          "name": "supply",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "unit": {
+          "name": "unit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'piece'"
+        },
+        "connection": {
+          "name": "connection",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_per_unit_w": {
+          "name": "power_per_unit_w",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "safety_supply": {
+          "name": "safety_supply",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "estimate_rows_group_id_idx": {
+          "name": "estimate_rows_group_id_idx",
+          "columns": [
+            "group_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "estimate_rows_group_id_estimate_groups_id_fk": {
+          "name": "estimate_rows_group_id_estimate_groups_id_fk",
+          "tableFrom": "estimate_rows",
+          "tableTo": "estimate_groups",
+          "columnsFrom": [
+            "group_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_export_batches": {
+      "name": "external_export_batches",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_revision": {
+          "name": "project_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "import_batch_id": {
+          "name": "import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "exported_at_iso": {
+          "name": "exported_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_snapshot": {
+          "name": "configuration_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration_sha256": {
+          "name": "configuration_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "object_count": {
+          "name": "object_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_export_batches_project_exported_idx": {
+          "name": "external_export_batches_project_exported_idx",
+          "columns": [
+            "project_id",
+            "exported_at_iso"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_export_batches_project_id_projects_id_fk": {
+          "name": "external_export_batches_project_id_projects_id_fk",
+          "tableFrom": "external_export_batches",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_import_batches": {
+      "name": "external_import_batches",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "import_kind": {
+          "name": "import_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "imported_at_iso": {
+          "name": "imported_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sha256": {
+          "name": "sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "object_count": {
+          "name": "object_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "applied_project_revision": {
+          "name": "applied_project_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "configuration_snapshot": {
+          "name": "configuration_snapshot",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "original_bytes": {
+          "name": "original_bytes",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "document": {
+          "name": "document",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_import_batches_project_revision_idx": {
+          "name": "external_import_batches_project_revision_idx",
+          "columns": [
+            "project_id",
+            "applied_project_revision"
+          ],
+          "isUnique": false
+        },
+        "external_import_batches_source_imported_idx": {
+          "name": "external_import_batches_source_imported_idx",
+          "columns": [
+            "source_id",
+            "imported_at_iso"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_import_batches_project_id_projects_id_fk": {
+          "name": "external_import_batches_project_id_projects_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_import_batches_source_id_external_model_sources_id_fk": {
+          "name": "external_import_batches_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_import_batches",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_configurations": {
+      "name": "external_model_configurations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "configuration": {
+          "name": "configuration",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_model_configurations_project_id_unique": {
+          "name": "external_model_configurations_project_id_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_configurations_project_id_projects_id_fk": {
+          "name": "external_model_configurations_project_id_projects_id_fk",
+          "tableFrom": "external_model_configurations",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_objects": {
+      "name": "external_model_objects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "worksharing_id": {
+          "name": "worksharing_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ifc_guid": {
+          "name": "ifc_guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "device_type_id": {
+          "name": "device_type_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen_import_batch_id": {
+          "name": "last_seen_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_accepted_import_batch_id": {
+          "name": "last_accepted_import_batch_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "accepted_source_values": {
+          "name": "accepted_source_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "planning_values": {
+          "name": "planning_values",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "overridden_fields": {
+          "name": "overridden_fields",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "external_room_mapping_id": {
+          "name": "external_room_mapping_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "linked_project_device_id": {
+          "name": "linked_project_device_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "circuit_device_row_id": {
+          "name": "circuit_device_row_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "presence_status": {
+          "name": "presence_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'present'"
+        }
+      },
+      "indexes": {
+        "external_model_objects_source_worksharing_id_unique": {
+          "name": "external_model_objects_source_worksharing_id_unique",
+          "columns": [
+            "source_id",
+            "worksharing_id"
+          ],
+          "isUnique": true
+        },
+        "external_model_objects_project_presence_idx": {
+          "name": "external_model_objects_project_presence_idx",
+          "columns": [
+            "project_id",
+            "presence_status"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_project_device_type_idx": {
+          "name": "external_model_objects_project_device_type_idx",
+          "columns": [
+            "project_id",
+            "device_type_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_external_room_mapping_idx": {
+          "name": "external_model_objects_external_room_mapping_idx",
+          "columns": [
+            "external_room_mapping_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_distribution_board_idx": {
+          "name": "external_model_objects_distribution_board_idx",
+          "columns": [
+            "distribution_board_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_linked_project_device_idx": {
+          "name": "external_model_objects_linked_project_device_idx",
+          "columns": [
+            "linked_project_device_id"
+          ],
+          "isUnique": false
+        },
+        "external_model_objects_circuit_device_row_idx": {
+          "name": "external_model_objects_circuit_device_row_idx",
+          "columns": [
+            "circuit_device_row_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_model_objects_project_id_projects_id_fk": {
+          "name": "external_model_objects_project_id_projects_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_source_id_external_model_sources_id_fk": {
+          "name": "external_model_objects_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_seen_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_seen_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk": {
+          "name": "external_model_objects_last_accepted_import_batch_id_external_import_batches_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_import_batches",
+          "columnsFrom": [
+            "last_accepted_import_batch_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk": {
+          "name": "external_model_objects_external_room_mapping_id_external_room_mappings_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "external_room_mappings",
+          "columnsFrom": [
+            "external_room_mapping_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_model_objects_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_linked_project_device_id_project_devices_id_fk": {
+          "name": "external_model_objects_linked_project_device_id_project_devices_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "project_devices",
+          "columnsFrom": [
+            "linked_project_device_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk": {
+          "name": "external_model_objects_circuit_device_row_id_circuit_device_rows_id_fk",
+          "tableFrom": "external_model_objects",
+          "tableTo": "circuit_device_rows",
+          "columnsFrom": [
+            "circuit_device_row_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_model_sources": {
+      "name": "external_model_sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_type": {
+          "name": "source_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'revit_xlsx'"
+        }
+      },
+      "indexes": {
+        "external_model_sources_project_unique": {
+          "name": "external_model_sources_project_unique",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "external_model_sources_project_id_projects_id_fk": {
+          "name": "external_model_sources_project_id_projects_id_fk",
+          "tableFrom": "external_model_sources",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "external_room_mappings": {
+      "name": "external_room_mappings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "normalized_source_room_key": {
+          "name": "normalized_source_room_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_floor_name": {
+          "name": "source_floor_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_room_number": {
+          "name": "source_room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_room_name": {
+          "name": "source_room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_id": {
+          "name": "room_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_distribution_board_id": {
+          "name": "default_distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "external_room_mappings_source_key_unique": {
+          "name": "external_room_mappings_source_key_unique",
+          "columns": [
+            "source_id",
+            "normalized_source_room_key"
+          ],
+          "isUnique": true
+        },
+        "external_room_mappings_project_room_idx": {
+          "name": "external_room_mappings_project_room_idx",
+          "columns": [
+            "project_id",
+            "room_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "external_room_mappings_project_id_projects_id_fk": {
+          "name": "external_room_mappings_project_id_projects_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_source_id_external_model_sources_id_fk": {
+          "name": "external_room_mappings_source_id_external_model_sources_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "external_model_sources",
+          "columnsFrom": [
+            "source_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_room_id_rooms_id_fk": {
+          "name": "external_room_mappings_room_id_rooms_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "rooms",
+          "columnsFrom": [
+            "room_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk": {
+          "name": "external_room_mappings_default_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "external_room_mappings",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "default_distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "floors": {
+      "name": "floors",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "building_id": {
+          "name": "building_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "floors_project_id_projects_id_fk": {
+          "name": "floors_project_id_projects_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "floors_building_id_buildings_id_fk": {
+          "name": "floors_building_id_buildings_id_fk",
+          "tableFrom": "floors",
+          "tableTo": "buildings",
+          "columnsFrom": [
+            "building_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "global_devices": {
+      "name": "global_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "installed_power_per_unit_kw": {
+          "name": "installed_power_per_unit_kw",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "demand_factor": {
+          "name": "demand_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase_count": {
+          "name": "phase_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_factor": {
+          "name": "power_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_change_sets": {
+      "name": "project_change_sets",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_revision_id": {
+          "name": "project_revision_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "command_type": {
+          "name": "command_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_schema_version": {
+          "name": "payload_schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "forward_payload_json": {
+          "name": "forward_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "inverse_payload_json": {
+          "name": "inverse_payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_change_sets_revision_unique": {
+          "name": "project_change_sets_revision_unique",
+          "columns": [
+            "project_revision_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_change_sets_project_revision_id_project_revisions_id_fk": {
+          "name": "project_change_sets_project_revision_id_project_revisions_id_fk",
+          "tableFrom": "project_change_sets",
+          "tableTo": "project_revisions",
+          "columnsFrom": [
+            "project_revision_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_devices": {
+      "name": "project_devices",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "phase_type": {
+          "name": "phase_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'single_phase'"
+        },
+        "connection_kind": {
+          "name": "connection_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_group": {
+          "name": "cost_group",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "power_per_unit": {
+          "name": "power_per_unit",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "simultaneity_factor": {
+          "name": "simultaneity_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "cos_phi": {
+          "name": "cos_phi",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "remark": {
+          "name": "remark",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "project_devices_project_id_projects_id_fk": {
+          "name": "project_devices_project_id_projects_id_fk",
+          "tableFrom": "project_devices",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_history_stack_entries": {
+      "name": "project_history_stack_entries",
+      "columns": {
+        "change_set_id": {
+          "name": "change_set_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stack": {
+          "name": "stack",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_history_stack_entries_position_unique": {
+          "name": "project_history_stack_entries_position_unique",
+          "columns": [
+            "project_id",
+            "stack",
+            "position"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_history_stack_entries_change_set_id_project_change_sets_id_fk": {
+          "name": "project_history_stack_entries_change_set_id_project_change_sets_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "project_change_sets",
+          "columnsFrom": [
+            "change_set_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "project_history_stack_entries_project_id_projects_id_fk": {
+          "name": "project_history_stack_entries_project_id_projects_id_fk",
+          "tableFrom": "project_history_stack_entries",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "project_history_stack_entries_stack_check": {
+          "name": "project_history_stack_entries_stack_check",
+          "value": "\"project_history_stack_entries\".\"stack\" in ('undo', 'redo')"
+        }
+      }
+    },
+    "project_revisions": {
+      "name": "project_revisions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision_number": {
+          "name": "revision_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor_id": {
+          "name": "actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_revisions_project_number_unique": {
+          "name": "project_revisions_project_number_unique",
+          "columns": [
+            "project_id",
+            "revision_number"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_revisions_project_id_projects_id_fk": {
+          "name": "project_revisions_project_id_projects_id_fk",
+          "tableFrom": "project_revisions",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_snapshots": {
+      "name": "project_snapshots",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_revision": {
+          "name": "source_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "schema_version": {
+          "name": "schema_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'named'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "payload_json": {
+          "name": "payload_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload_sha256": {
+          "name": "payload_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at_iso": {
+          "name": "created_at_iso",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_by_actor_id": {
+          "name": "created_by_actor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_snapshots_project_created_idx": {
+          "name": "project_snapshots_project_created_idx",
+          "columns": [
+            "project_id",
+            "created_at_iso"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_kind_revision_idx": {
+          "name": "project_snapshots_project_kind_revision_idx",
+          "columns": [
+            "project_id",
+            "kind",
+            "source_revision"
+          ],
+          "isUnique": false
+        },
+        "project_snapshots_project_name_unique": {
+          "name": "project_snapshots_project_name_unique",
+          "columns": [
+            "project_id",
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_snapshots_project_id_projects_id_fk": {
+          "name": "project_snapshots_project_id_projects_id_fk",
+          "tableFrom": "project_snapshots",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "internal_project_number": {
+          "name": "internal_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_project_number": {
+          "name": "external_project_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "building_owner": {
+          "name": "building_owner",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_public_building": {
+          "name": "is_public_building",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "single_phase_voltage_v": {
+          "name": "single_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 230
+        },
+        "three_phase_voltage_v": {
+          "name": "three_phase_voltage_v",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 400
+        },
+        "enabled_distribution_board_supply_types": {
+          "name": "enabled_distribution_board_supply_types",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'[\"AV\",\"SV\",\"EV\",\"USV\",\"MSR\",\"SiBe\"]'"
+        },
+        "site_address": {
+          "name": "site_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "work_stage": {
+          "name": "work_stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_lead": {
+          "name": "project_lead",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_editor": {
+          "name": "project_editor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "current_revision": {
+          "name": "current_revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "rooms": {
+      "name": "rooms",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "floor_id": {
+          "name": "floor_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "room_number": {
+          "name": "room_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "room_name": {
+          "name": "room_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "area_m2": {
+          "name": "area_m2",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "rooms_project_id_projects_id_fk": {
+          "name": "rooms_project_id_projects_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "rooms_floor_id_floors_id_fk": {
+          "name": "rooms_floor_id_floors_id_fk",
+          "tableFrom": "rooms",
+          "tableTo": "floors",
+          "columnsFrom": [
+            "floor_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "users": {
+      "name": "users",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'user'"
+        },
+        "active": {
+          "name": "active",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "must_change_password": {
+          "name": "must_change_password",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(unixepoch())"
+        }
+      },
+      "indexes": {
+        "users_username_unique": {
+          "name": "users_username_unique",
+          "columns": [
+            "username"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/src/db/migrations/meta/_journal.json b/src/db/migrations/meta/_journal.json
index 0f6c303..0ab138e 100644
--- a/src/db/migrations/meta/_journal.json
+++ b/src/db/migrations/meta/_journal.json
@@ -106,6 +106,13 @@
       "when": 1790748107566,
       "tag": "0014_linear_xlsx_external_model",
       "breakpoints": true
+    },
+    {
+      "idx": 15,
+      "version": "6",
+      "when": 1790773066696,
+      "tag": "0015_wide_night_thrasher",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/src/db/repositories/external-export-batch.repository.ts b/src/db/repositories/external-export-batch.repository.ts
new file mode 100644
index 0000000..c8f7a7d
--- /dev/null
+++ b/src/db/repositories/external-export-batch.repository.ts
@@ -0,0 +1,18 @@
+import { desc, eq } from "drizzle-orm";
+import type { AppDatabase } from "../database-context.js";
+import { externalExportBatches } from "../schema/external-export-batches.js";
+
+export class ExternalExportBatchRepository {
+  constructor(private readonly database: AppDatabase) {}
+
+  append(batch: typeof externalExportBatches.$inferInsert) {
+    this.database.insert(externalExportBatches).values(batch).run();
+    return batch;
+  }
+
+  listByProject(projectId: string) {
+    return this.database.select().from(externalExportBatches)
+      .where(eq(externalExportBatches.projectId, projectId))
+      .orderBy(desc(externalExportBatches.exportedAtIso), desc(externalExportBatches.id)).all();
+  }
+}
diff --git a/src/db/schema/external-export-batches.ts b/src/db/schema/external-export-batches.ts
new file mode 100644
index 0000000..37e94d8
--- /dev/null
+++ b/src/db/schema/external-export-batches.ts
@@ -0,0 +1,24 @@
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
+import { projects } from "./projects.js";
+
+export const externalExportScopes = ["all", "deviating", "selected"] as const;
+export type ExternalExportScope = (typeof externalExportScopes)[number];
+
+export const externalExportBatches = sqliteTable(
+  "external_export_batches",
+  {
+    id: text("id").primaryKey(),
+    projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    projectRevision: integer("project_revision").notNull(),
+    importBatchId: text("import_batch_id").notNull(),
+    exportedAtIso: text("exported_at_iso").notNull(),
+    fileName: text("file_name").notNull(),
+    sha256: text("sha256").notNull(),
+    configurationSnapshot: text("configuration_snapshot", { mode: "json" }).$type<ExternalModelConfiguration>().notNull(),
+    configurationSha256: text("configuration_sha256").notNull(),
+    scope: text("scope", { enum: externalExportScopes }).notNull(),
+    objectCount: integer("object_count").notNull(),
+  },
+  (table) => [index("external_export_batches_project_exported_idx").on(table.projectId, table.exportedAtIso)]
+);
diff --git a/src/external-model/application/external-xlsx-return-projection.ts b/src/external-model/application/external-xlsx-return-projection.ts
new file mode 100644
index 0000000..a80125c
--- /dev/null
+++ b/src/external-model/application/external-xlsx-return-projection.ts
@@ -0,0 +1,135 @@
+import type { ExternalModelObjectSnapshot } from "../domain/external-model-contracts.js";
+import type { ExternalXlsxCircuitMode, ExternalXlsxReturnValues } from "../xlsx/external-xlsx-contracts.js";
+import type { CircuitGroupCategory } from "../../shared/constants/circuit-group.js";
+
+export interface ExternalReturnRowContext {
+  rowId: string;
+  displayName: string;
+  powerPerUnitKw: number;
+  cosPhi: number | null;
+  phaseType: string | null;
+  category: CircuitGroupCategory | null;
+  circuitIdentifier: string;
+  circuitVoltageV: number | null;
+  distributionBoardName: string;
+}
+
+export interface ExternalReturnProjection {
+  objectId: string;
+  worksharingId: string;
+  values: ExternalXlsxReturnValues;
+  differsFromImported: boolean;
+  warnings: string[];
+}
+
+export function getRevitBoardName(board: { name: string }) {
+  return board.name;
+}
+
+export function projectExternalXlsxReturn(input: {
+  object: ExternalModelObjectSnapshot;
+  row: ExternalReturnRowContext | null;
+  circuitMode: ExternalXlsxCircuitMode;
+  singlePhaseVoltageV: number;
+  threePhaseVoltageV: number;
+}): ExternalReturnProjection {
+  const { object, row } = input;
+  const planning = object.planningValues;
+  const warnings: string[] = [];
+  const category = row?.category ?? planning.category;
+  const phaseType = row?.phaseType ?? (category === "three_phase" ? "three_phase" : category ? "single_phase" : null);
+  const voltageV = row?.circuitVoltageV ?? defaultVoltage(category, input.singlePhaseVoltageV, input.threePhaseVoltageV);
+  const powerPerUnitW = row ? row.powerPerUnitKw * 1000 : planning.powerPerUnitW;
+  const electricalPowerW = powerPerUnitW === null
+    ? null
+    : roundNumber(planning.effectiveQuantity * powerPerUnitW, 6);
+  const cosPhi = row?.cosPhi ?? planning.cosPhi;
+  const currentA = calculateCurrent({ electricalPowerW, voltageV, cosPhi, phaseType });
+  if (electricalPowerW === null) warnings.push("Elektrische Leistung ist nicht berechenbar.");
+  if (voltageV === null) warnings.push("Spannung ist nicht bestimmbar.");
+  if (currentA === null) warnings.push("Stromstärke ist nicht berechenbar.");
+
+  const values: ExternalXlsxReturnValues = {
+    ...(input.circuitMode === "combined"
+      ? { circuitCombined: row ? `${getRevitBoardName({ name: row.distributionBoardName })}${row.circuitIdentifier}` : "" }
+      : {
+          boardName: row ? getRevitBoardName({ name: row.distributionBoardName }) : "",
+          circuitIdentifier: row?.circuitIdentifier ?? "",
+        }),
+    designation: row?.displayName ?? planning.displayName ?? "",
+    electricalPowerW,
+    voltageV,
+    currentA,
+  };
+  const source = object.acceptedSourceValues;
+  const sourceValues: ExternalXlsxReturnValues = input.circuitMode === "combined"
+    ? {
+        circuitCombined: source.circuitCombined,
+        designation: source.designation,
+        electricalPowerW: source.electricalPowerW,
+        voltageV: source.voltageV,
+        currentA: source.currentA,
+      }
+    : {
+        boardName: source.boardName,
+        circuitIdentifier: source.circuitIdentifier,
+        designation: source.designation,
+        electricalPowerW: source.electricalPowerW,
+        voltageV: source.voltageV,
+        currentA: source.currentA,
+      };
+
+  return {
+    objectId: object.id,
+    worksharingId: object.worksharingId,
+    values,
+    differsFromImported: Object.keys(values).some((key) =>
+      !sameScalar(values[key as keyof ExternalXlsxReturnValues], sourceValues[key as keyof ExternalXlsxReturnValues])
+    ),
+    warnings,
+  };
+}
+
+function defaultVoltage(category: CircuitGroupCategory | null, singlePhase: number, threePhase: number) {
+  if (category === "three_phase") return threePhase;
+  if (category === "lighting" || category === "single_phase") return singlePhase;
+  return null;
+}
+
+function calculateCurrent(input: { electricalPowerW: number | null; voltageV: number | null; cosPhi: number | null; phaseType: string | null }) {
+  if (
+    input.electricalPowerW === null ||
+    input.voltageV === null || input.voltageV <= 0 ||
+    input.cosPhi === null || input.cosPhi <= 0 ||
+    (input.phaseType !== "single_phase" && input.phaseType !== "three_phase")
+  ) return null;
+  const divisor = input.phaseType === "three_phase"
+    ? Math.sqrt(3) * input.voltageV * input.cosPhi
+    : input.voltageV * input.cosPhi;
+  return roundNumber(input.electricalPowerW / divisor, 2);
+}
+
+function sameScalar(left: string | number | boolean | null | undefined, right: string | number | boolean | null | undefined) {
+  const normalizedLeft = normalizeScalar(left);
+  const normalizedRight = normalizeScalar(right);
+  if (typeof normalizedLeft === "number" && typeof normalizedRight === "number") {
+    return Math.abs(normalizedLeft - normalizedRight) < 1e-9;
+  }
+  return normalizedLeft === normalizedRight;
+}
+
+function normalizeScalar(value: string | number | boolean | null | undefined): string | number | boolean {
+  if (value === null || value === undefined || value === "") return "";
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return "";
+    const numeric = Number(trimmed.replace(",", "."));
+    return Number.isFinite(numeric) ? numeric : trimmed;
+  }
+  return value;
+}
+
+function roundNumber(value: number, decimals: number) {
+  const factor = 10 ** decimals;
+  return Math.round((value + Number.EPSILON) * factor) / factor;
+}
diff --git a/src/frontend/components/revit-object-table.tsx b/src/frontend/components/revit-object-table.tsx
index c82d9c7..2fdee3e 100644
--- a/src/frontend/components/revit-object-table.tsx
+++ b/src/frontend/components/revit-object-table.tsx
@@ -1,8 +1,8 @@
 "use client";
 
 import { useEffect, useMemo, useState } from "react";
-import type { ExternalProjectObjectsDto } from "../types";
-import { getExternalProjectObjects, updateExternalProjectObjects } from "../utils/api";
+import type { ExternalProjectObjectsDto, ExternalReturnScopeDto } from "../types";
+import { createExternalReturnWorkbook, getExternalProjectObjects, updateExternalProjectObjects } from "../utils/api";
 
 const rowHeight = 44;
 const viewportHeight = 520;
@@ -23,6 +23,10 @@ export function RevitObjectTable({ projectId, onRevision }: { projectId: string;
   const [planningValue, setPlanningValue] = useState("");
   const [error, setError] = useState<string | null>(null);
   const [saving, setSaving] = useState(false);
+  const [returnScope, setReturnScope] = useState<ExternalReturnScopeDto>("all");
+  const [exporting, setExporting] = useState(false);
+  const [exportWarnings, setExportWarnings] = useState<string[]>([]);
+  const [exportMessage, setExportMessage] = useState<string | null>(null);
 
   async function load() { try { const loaded = await getExternalProjectObjects(projectId); setData(loaded); onRevision(loaded.currentRevision); } catch (value) { setError(value instanceof Error ? value.message : "Revit-Objekte konnten nicht geladen werden."); } }
   useEffect(() => { void load(); }, [projectId]); // eslint-disable-line react-hooks/exhaustive-deps
@@ -44,6 +48,7 @@ export function RevitObjectTable({ projectId, onRevision }: { projectId: string;
   const first = Math.max(0, Math.floor(scrollTop / rowHeight) - 5);
   const visible = rows.slice(first, first + Math.ceil(viewportHeight / rowHeight) + 10);
   const selectable = rows.filter((object) => object.circuitDeviceRowId === null);
+  const selectedHasLinkedObject = data?.objects.some((object) => selected.has(object.id) && object.circuitDeviceRowId !== null) ?? false;
 
   async function applyBulk() {
     if (!data || selected.size === 0) return;
@@ -64,10 +69,38 @@ export function RevitObjectTable({ projectId, onRevision }: { projectId: string;
     finally { setSaving(false); }
   }
 
+  async function exportReturnWorkbook() {
+    if (!data || (returnScope === "selected" && selected.size === 0)) return;
+    setExporting(true); setError(null); setExportWarnings([]); setExportMessage(null);
+    try {
+      const result = await createExternalReturnWorkbook(projectId, data.currentRevision, returnScope, [...selected]);
+      downloadBase64(result.contentBase64, result.fileName);
+      setExportWarnings(result.warnings);
+      setExportMessage(`${result.objectCount} Revit-Objekte wurden in ${result.fileName} geschrieben.`);
+    } catch (value) {
+      setError(value instanceof Error ? value.message : "Rückgabe-Excel konnte nicht erstellt werden.");
+    } finally {
+      setExporting(false);
+    }
+  }
+
   if (!data) return <section className="card mt-3"><div className="card-body">Revit-Objekte werden geladen …</div></section>;
   return <section className="card mt-3"><div className="card-body"><div className="d-flex justify-content-between align-items-start gap-3 flex-wrap mb-3"><div><h2 className="h5 mb-1">Revit-Objekte</h2><div className="text-secondary small">{rows.length} von {data.objects.length} · {selected.size} ausgewählt</div></div><div className="d-flex gap-2 flex-wrap"><input aria-label="Revit-Objekte suchen" className="form-control" placeholder="Suchen …" value={search} onChange={(event) => setSearch(event.target.value)} /><select aria-label="Verteiler filtern" className="form-select" value={boardFilter} onChange={(event) => setBoardFilter(event.target.value)}><option value="all">Alle Verteiler</option><option value="none">Ohne Verteiler</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select><select aria-label="Zuordnung filtern" className="form-select" value={assignmentFilter} onChange={(event) => setAssignmentFilter(event.target.value)}><option value="all">Alle Zuordnungen</option><option value="unassigned">Unzugeordnet</option><option value="linked">Mit Gerätezeile</option></select><select aria-label="Sortierung" className="form-select" value={sort} onChange={(event) => setSort(event.target.value as typeof sort)}><option value="family">Familie</option><option value="room">Raum</option><option value="worksharing">Worksharing-ID</option></select></div></div>
     {error ? <div className="alert alert-danger">{error}</div> : null}
-    <div className="border rounded mb-3" style={{ height: viewportHeight, overflowY: "auto" }} onScroll={(event) => setScrollTop(event.currentTarget.scrollTop)}><div style={{ height: rows.length * rowHeight, position: "relative" }}>{visible.map((object, index) => { const top = (first + index) * rowHeight; const linked = object.circuitDeviceRowId !== null; return <div className="d-grid align-items-center border-bottom px-2" key={object.id} style={{ gridTemplateColumns: "32px minmax(180px,2fr) minmax(120px,1fr) minmax(120px,1fr) minmax(130px,1fr) 100px", height: rowHeight, left: 0, position: "absolute", right: 0, top }}><input aria-label={`${object.familyAndType} auswählen`} checked={selected.has(object.id)} disabled={linked} type="checkbox" onChange={() => setSelected((current) => { const next = new Set(current); if (next.has(object.id)) next.delete(object.id); else next.add(object.id); return next; })} /><div className="text-truncate"><strong>{object.planningValues.displayName ?? object.familyAndType}</strong><div className="small text-secondary text-truncate">{object.familyAndType}</div></div><div className="text-truncate">{object.sourceRoomNumber} {object.sourceRoomName}</div><div className="text-truncate">{data.distributionBoards.find((board) => board.id === object.distributionBoardId)?.name ?? "Ohne Verteiler"}</div><div className="text-truncate">{object.selectionMarker || object.worksharingId}</div><span className={`badge ${linked ? "text-bg-success" : "text-bg-secondary"}`}>{linked ? "verknüpft" : "frei"}</span></div>; })}</div></div>
-    <div className="d-flex gap-2 flex-wrap align-items-end"><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(selectable.map((object) => object.id)))}>Sichtbare freie auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set())}>Auswahl leeren</button><label className="small">Verteiler<select className="form-select form-select-sm" value={bulkBoard} onChange={(event) => setBulkBoard(event.target.value)}><option value="">Unverändert</option><option value="none">Zuordnung lösen</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></label><label className="small">Projektgerät<select className="form-select form-select-sm" value={bulkDevice} onChange={(event) => setBulkDevice(event.target.value)}><option value="">Unverändert</option><option value="none">Verknüpfung lösen</option>{data.projectDevices.map((device) => <option value={device.id} key={device.id}>{device.name}</option>)}</select></label><label className="small">Leistung [W]<input className="form-control form-control-sm" inputMode="decimal" value={power} onChange={(event) => setPower(event.target.value)} /></label><label className="small">GZF<input className="form-control form-control-sm" inputMode="decimal" value={gzf} onChange={(event) => setGzf(event.target.value)} /></label><label className="small">Weiterer Planungswert<select className="form-select form-select-sm" value={planningField} onChange={(event) => setPlanningField(event.target.value)}><option value="">Unverändert</option><option value="displayName">Anzeigename</option><option value="category">Kategorie (lighting/single_phase/three_phase)</option><option value="connectionKind">Anschlussart</option><option value="effectiveQuantity">Wirksame Menge</option><option value="cosPhi">cosPhi</option><option value="costGroup">Kostengruppe</option><option value="remark">Bemerkung</option></select></label>{planningField ? <label className="small">Neuer Wert<input className="form-control form-control-sm" value={planningValue} onChange={(event) => setPlanningValue(event.target.value)} /></label> : null}<button className="btn btn-sm btn-primary" disabled={saving || selected.size === 0} type="button" onClick={() => void applyBulk()}>{saving ? "Wird gespeichert …" : "Sammeländerung anwenden"}</button></div>
+    <div className="border rounded p-3 mb-3"><div className="d-flex gap-2 align-items-end flex-wrap"><label className="small">Rückgabeumfang<select aria-label="Rückgabeumfang" className="form-select form-select-sm" value={returnScope} onChange={(event) => setReturnScope(event.target.value as ExternalReturnScopeDto)}><option value="all">Alle Objekte des letzten Imports</option><option value="deviating">Nur geänderte Objekte</option><option value="selected">Nur ausgewählte Objekte</option></select></label><button className="btn btn-sm btn-primary" disabled={exporting || (returnScope === "selected" && selected.size === 0)} type="button" onClick={() => void exportReturnWorkbook()}>{exporting ? "Rückgabe wird erstellt …" : "Rückgabe-Excel herunterladen"}</button></div>{exportMessage ? <div className="alert alert-success mt-3 mb-0">{exportMessage}</div> : null}{exportWarnings.length ? <div className="alert alert-warning mt-3 mb-0"><strong>Hinweise zur Rückgabe:</strong><ul className="mb-0">{exportWarnings.map((warning) => <li key={warning}>{warning}</li>)}</ul></div> : null}</div>
+    <div className="border rounded mb-3" style={{ height: viewportHeight, overflowY: "auto" }} onScroll={(event) => setScrollTop(event.currentTarget.scrollTop)}><div style={{ height: rows.length * rowHeight, position: "relative" }}>{visible.map((object, index) => { const top = (first + index) * rowHeight; const linked = object.circuitDeviceRowId !== null; return <div className="d-grid align-items-center border-bottom px-2" key={object.id} style={{ gridTemplateColumns: "32px minmax(180px,2fr) minmax(120px,1fr) minmax(120px,1fr) minmax(130px,1fr) 100px", height: rowHeight, left: 0, position: "absolute", right: 0, top }}><input aria-label={`${object.familyAndType} auswählen`} checked={selected.has(object.id)} type="checkbox" onChange={() => setSelected((current) => { const next = new Set(current); if (next.has(object.id)) next.delete(object.id); else next.add(object.id); return next; })} /><div className="text-truncate"><strong>{object.planningValues.displayName ?? object.familyAndType}</strong><div className="small text-secondary text-truncate">{object.familyAndType}</div></div><div className="text-truncate">{object.sourceRoomNumber} {object.sourceRoomName}</div><div className="text-truncate">{data.distributionBoards.find((board) => board.id === object.distributionBoardId)?.name ?? "Ohne Verteiler"}</div><div className="text-truncate">{object.selectionMarker || object.worksharingId}</div><span className={`badge ${linked ? "text-bg-success" : "text-bg-secondary"}`}>{linked ? "verknüpft" : "frei"}</span></div>; })}</div></div>
+    <div className="d-flex gap-2 flex-wrap align-items-end"><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(rows.map((object) => object.id)))}>Sichtbare für Rückgabe auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(selectable.map((object) => object.id)))}>Sichtbare freie auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set())}>Auswahl leeren</button><label className="small">Verteiler<select className="form-select form-select-sm" value={bulkBoard} onChange={(event) => setBulkBoard(event.target.value)}><option value="">Unverändert</option><option value="none">Zuordnung lösen</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></label><label className="small">Projektgerät<select className="form-select form-select-sm" value={bulkDevice} onChange={(event) => setBulkDevice(event.target.value)}><option value="">Unverändert</option><option value="none">Verknüpfung lösen</option>{data.projectDevices.map((device) => <option value={device.id} key={device.id}>{device.name}</option>)}</select></label><label className="small">Leistung [W]<input className="form-control form-control-sm" inputMode="decimal" value={power} onChange={(event) => setPower(event.target.value)} /></label><label className="small">GZF<input className="form-control form-control-sm" inputMode="decimal" value={gzf} onChange={(event) => setGzf(event.target.value)} /></label><label className="small">Weiterer Planungswert<select className="form-select form-select-sm" value={planningField} onChange={(event) => setPlanningField(event.target.value)}><option value="">Unverändert</option><option value="displayName">Anzeigename</option><option value="category">Kategorie (lighting/single_phase/three_phase)</option><option value="connectionKind">Anschlussart</option><option value="effectiveQuantity">Wirksame Menge</option><option value="cosPhi">cosPhi</option><option value="costGroup">Kostengruppe</option><option value="remark">Bemerkung</option></select></label>{planningField ? <label className="small">Neuer Wert<input className="form-control form-control-sm" value={planningValue} onChange={(event) => setPlanningValue(event.target.value)} /></label> : null}<button className="btn btn-sm btn-primary" disabled={saving || selected.size === 0 || selectedHasLinkedObject} title={selectedHasLinkedObject ? "Sammeländerungen sind nur für freie Revit-Objekte möglich." : undefined} type="button" onClick={() => void applyBulk()}>{saving ? "Wird gespeichert …" : "Sammeländerung anwenden"}</button></div>
   </div></section>;
 }
+
+function downloadBase64(contentBase64: string, fileName: string) {
+  const binary = atob(contentBase64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  const url = URL.createObjectURL(new Blob([bytes], { type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" }));
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = fileName;
+  anchor.click();
+  URL.revokeObjectURL(url);
+}
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index b1a6344..a4239b1 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -126,6 +126,29 @@ export interface ExternalProjectObjectsDto {
   objects: ExternalProjectObjectDto[];
 }
 
+export type ExternalReturnScopeDto = "all" | "deviating" | "selected";
+
+export interface ExternalReturnWorkbookDto {
+  fileName: string;
+  contentBase64: string;
+  sha256: string;
+  objectCount: number;
+  warnings: string[];
+}
+
+export interface ExternalExportBatchDto {
+  id: string;
+  projectId: string;
+  projectRevision: number;
+  importBatchId: string;
+  exportedAtIso: string;
+  fileName: string;
+  sha256: string;
+  configurationSha256: string;
+  scope: ExternalReturnScopeDto;
+  objectCount: number;
+}
+
 export interface ProjectDto {
   id: string;
   name: string;
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index b329f53..c873ef3 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -44,6 +44,8 @@ import type {
   ExternalInitialImportStatusDto,
   ApplyExternalInitialImportInput,
   ExternalProjectObjectsDto,
+  ExternalReturnScopeDto,
+  ExternalReturnWorkbookDto,
   CreateEstimateBalanceInput,
   EstimateBalanceCommandResultDto,
   EstimateBalanceDto,
@@ -245,6 +247,18 @@ export function updateExternalProjectObjects(projectId: string, expectedRevision
   return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects`, { method: "PUT", body: JSON.stringify({ expectedRevision, objectIds, patch }) });
 }
 
+export function createExternalReturnWorkbook(
+  projectId: string,
+  expectedRevision: number,
+  scope: ExternalReturnScopeDto,
+  selectedObjectIds: string[]
+) {
+  return request<ExternalReturnWorkbookDto>(`/api/projects/${projectId}/external-model/return-workbook`, {
+    method: "POST",
+    body: JSON.stringify({ expectedRevision, scope, selectedObjectIds }),
+  });
+}
+
 export function assignExternalProjectObjectsToRow(projectId: string, expectedRevision: number, objectIds: string[], rowId: string, confirmedConflictObjectIds: string[] = []) {
   return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects/assign-row`, {
     method: "POST",
diff --git a/src/server/composition/application-repositories.ts b/src/server/composition/application-repositories.ts
index a165a30..002a784 100644
--- a/src/server/composition/application-repositories.ts
+++ b/src/server/composition/application-repositories.ts
@@ -15,6 +15,7 @@ import { ProjectRepository } from "../../db/repositories/project.repository.js";
 import { RoomRepository } from "../../db/repositories/room.repository.js";
 import { ExternalModelConfigurationRepository } from "../../db/repositories/external-model-configuration.repository.js";
 import { ExternalModelStateRepository } from "../../db/repositories/external-model-state.repository.js";
+import { ExternalExportBatchRepository } from "../../db/repositories/external-export-batch.repository.js";
 import { DocumentBrandingRepository } from "../../db/repositories/document-branding.repository.js";
 import { UserRepository } from "../../db/repositories/user.repository.js";
 
@@ -39,5 +40,6 @@ export const roomRepository = new RoomRepository(db);
 export const externalModelConfigurationRepository =
   new ExternalModelConfigurationRepository(db);
 export const externalModelStateRepository = new ExternalModelStateRepository(db);
+export const externalExportBatchRepository = new ExternalExportBatchRepository(db);
 export const documentBrandingRepository = new DocumentBrandingRepository(db);
 export const userRepository = new UserRepository(db);
diff --git a/src/server/controllers/external-return-workbook.controller.ts b/src/server/controllers/external-return-workbook.controller.ts
new file mode 100644
index 0000000..0db6d81
--- /dev/null
+++ b/src/server/controllers/external-return-workbook.controller.ts
@@ -0,0 +1,180 @@
+import { createHash, randomUUID } from "node:crypto";
+import type { Request, Response } from "express";
+import type { CircuitGroupCategory } from "../../shared/constants/circuit-group.js";
+import type { ExternalExportScope } from "../../db/schema/external-export-batches.js";
+import { projectExternalXlsxReturn, type ExternalReturnRowContext } from "../../external-model/application/external-xlsx-return-projection.js";
+import { createExternalXlsxReturn } from "../../external-model/xlsx/external-xlsx-transport.js";
+import {
+  externalExportBatchRepository,
+  externalModelStateRepository,
+  projectRepository,
+} from "../composition/application-repositories.js";
+import { buildProjectCircuitTrees } from "./circuit-tree.controller.js";
+
+const exportScopes = new Set<ExternalExportScope>(["all", "deviating", "selected"]);
+
+export async function createExternalReturnWorkbook(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const scope = parseScope(req.body?.scope);
+    const selectedObjectIds = scope === "selected" ? parseSelectedIds(req.body?.selectedObjectIds) : [];
+    if (scope === "selected" && selectedObjectIds.length === 0) {
+      return res.status(400).json({ error: "Für die ausgewählte Rückgabe wurden keine Revit-Objekte markiert." });
+    }
+
+    const project = await projectRepository.findById(projectId);
+    if (!project) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    if (project.currentRevision !== expectedRevision) {
+      return res.status(409).json({
+        error: "Die Rückgabe ist wegen einer neueren Projektrevision ungültig.",
+        code: "PROJECT_REVISION_CONFLICT",
+        expectedRevision,
+        currentRevision: project.currentRevision,
+      });
+    }
+
+    const { state } = externalModelStateRepository.getByProject(projectId);
+    const importBatch = state.importBatches.at(-1);
+    if (!importBatch?.originalContentBase64 || !importBatch.configurationSnapshot) {
+      return res.status(409).json({
+        error: "Für die Rückgabe fehlt der letzte vollständige Revit-Import.",
+        code: "EXTERNAL_XLSX_IMPORT_REQUIRED",
+      });
+    }
+    const treeResult = await buildProjectCircuitTrees(projectId);
+    if (!treeResult || treeResult.currentRevision !== expectedRevision) {
+      return res.status(409).json({
+        error: "Die Rückgabe ist wegen einer neueren Projektrevision ungültig.",
+        code: "PROJECT_REVISION_CONFLICT",
+      });
+    }
+
+    const rowById = new Map<string, ExternalReturnRowContext>();
+    for (const tree of treeResult.trees) {
+      for (const section of tree.sections) {
+        for (const circuit of section.circuits) {
+          for (const row of circuit.deviceRows) {
+            rowById.set(row.id, {
+              rowId: row.id,
+              displayName: row.displayName,
+              powerPerUnitKw: row.powerPerUnit,
+              cosPhi: row.cosPhi ?? null,
+              phaseType: row.phaseType ?? null,
+              category: (section.category ?? null) as CircuitGroupCategory | null,
+              circuitIdentifier: circuit.equipmentIdentifier,
+              circuitVoltageV: circuit.voltage ?? null,
+              distributionBoardName: tree.distributionBoardName,
+            });
+          }
+        }
+      }
+    }
+
+    const projections = state.objects
+      .filter((object) => object.presenceStatus === "present" && object.lastSeenImportBatchId === importBatch.id)
+      .map((object) => projectExternalXlsxReturn({
+        object,
+        row: object.circuitDeviceRowId ? rowById.get(object.circuitDeviceRowId) ?? null : null,
+        circuitMode: importBatch.configurationSnapshot!.circuitMode,
+        singlePhaseVoltageV: project.singlePhaseVoltageV,
+        threePhaseVoltageV: project.threePhaseVoltageV,
+      }));
+    const projectionById = new Map(projections.map((projection) => [projection.objectId, projection]));
+    for (const objectId of selectedObjectIds) {
+      if (!projectionById.has(objectId)) {
+        return res.status(400).json({ error: "Ein ausgewähltes Revit-Objekt gehört nicht zum letzten Import." });
+      }
+    }
+    const selected = scope === "all"
+      ? projections
+      : scope === "deviating"
+        ? projections.filter((projection) => projection.differsFromImported)
+        : selectedObjectIds.map((id) => projectionById.get(id)!);
+    if (selected.length === 0) {
+      return res.status(400).json({ error: "Der gewählte Rückgabeumfang enthält keine Revit-Objekte." });
+    }
+
+    const result = await createExternalXlsxReturn({
+      fileName: importBatch.fileName,
+      bytes: Buffer.from(importBatch.originalContentBase64, "base64"),
+      configuration: importBatch.configurationSnapshot,
+      selectedWorksharingIds: selected.map((projection) => projection.worksharingId),
+      updates: selected.map((projection) => ({
+        worksharingId: projection.worksharingId,
+        values: projection.values,
+      })),
+    });
+    const fileName = `${safeFileName(project.name)}_Revit-Rueckgabe_${new Date().toISOString().slice(0, 10)}.xlsx`;
+    const sha256 = hash(result.bytes);
+    const configurationSha256 = hash(Buffer.from(JSON.stringify(importBatch.configurationSnapshot), "utf8"));
+    const currentProject = await projectRepository.findById(projectId);
+    if (!currentProject || currentProject.currentRevision !== expectedRevision) {
+      return res.status(409).json({
+        error: "Die Rückgabe ist wegen einer neueren Projektrevision ungültig.",
+        code: "PROJECT_REVISION_CONFLICT",
+        expectedRevision,
+        currentRevision: currentProject?.currentRevision ?? null,
+      });
+    }
+    externalExportBatchRepository.append({
+      id: randomUUID(),
+      projectId,
+      projectRevision: expectedRevision,
+      importBatchId: importBatch.id,
+      exportedAtIso: new Date().toISOString(),
+      fileName,
+      sha256,
+      configurationSnapshot: importBatch.configurationSnapshot,
+      configurationSha256,
+      scope,
+      objectCount: result.exportedObjectCount,
+    });
+
+    const projectionWarnings = selected.flatMap((projection) =>
+      projection.warnings.map((warning) => `${projection.worksharingId}: ${warning}`)
+    );
+    return res.json({
+      fileName,
+      contentBase64: Buffer.from(result.bytes).toString("base64"),
+      sha256,
+      objectCount: result.exportedObjectCount,
+      warnings: [...new Set([...result.issues.map((issue) => issue.message), ...projectionWarnings])],
+    });
+  } catch (error) {
+    return res.status(400).json({ error: error instanceof Error ? error.message : "Revit-Rückgabe fehlgeschlagen." });
+  }
+}
+
+export async function listExternalExportBatches(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  const project = await projectRepository.findById(projectId);
+  if (!project) return res.status(404).json({ error: "Projekt nicht gefunden." });
+  return res.json(externalExportBatchRepository.listByProject(projectId).map(({ configurationSnapshot: _configuration, ...batch }) => batch));
+}
+
+function parseExpectedRevision(value: unknown) {
+  if (!Number.isSafeInteger(value) || (value as number) < 0) throw new Error("Ungültige Projektrevision.");
+  return value as number;
+}
+
+function parseScope(value: unknown): ExternalExportScope {
+  if (typeof value !== "string" || !exportScopes.has(value as ExternalExportScope)) throw new Error("Ungültiger Rückgabeumfang.");
+  return value as ExternalExportScope;
+}
+
+function parseSelectedIds(value: unknown) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string") || new Set(value).size !== value.length) {
+    throw new Error("Ungültige Objektauswahl.");
+  }
+  return value as string[];
+}
+
+function safeFileName(value: string) {
+  return value.trim().replace(/[<>:"/\\|?*\u0000-\u001f]/g, "_") || "Projekt";
+}
+
+function hash(bytes: Uint8Array) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index f07d9b0..436ff52 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -64,6 +64,7 @@ import {
   planExternalInitialImport,
 } from "../controllers/external-initial-import.controller.js";
 import { assignExternalObjectsToNewCircuit, assignExternalObjectsToNewRow, assignExternalObjectsToRow, detachExternalObjectsFromRow, listExternalObjects, updateExternalObjects } from "../controllers/external-objects.controller.js";
+import { createExternalReturnWorkbook, listExternalExportBatches } from "../controllers/external-return-workbook.controller.js";
 
 export const projectRouter = Router();
 
@@ -97,6 +98,8 @@ projectRouter.post("/:projectId/external-model/objects/assign-row", assignExtern
 projectRouter.post("/:projectId/external-model/objects/assign-new-row", assignExternalObjectsToNewRow);
 projectRouter.post("/:projectId/external-model/objects/assign-new-circuit", assignExternalObjectsToNewCircuit);
 projectRouter.post("/:projectId/external-model/objects/detach-row", detachExternalObjectsFromRow);
+projectRouter.post("/:projectId/external-model/return-workbook", createExternalReturnWorkbook);
+projectRouter.get("/:projectId/external-model/export-batches", listExternalExportBatches);
 projectRouter.get("/:projectId/distribution-boards", listDistributionBoardsByProject);
 projectRouter.post("/:projectId/distribution-boards", createDistributionBoard);
 projectRouter.post(
diff --git a/tests/external-export-batch.repository.test.ts b/tests/external-export-batch.repository.test.ts
new file mode 100644
index 0000000..50278b6
--- /dev/null
+++ b/tests/external-export-batch.repository.test.ts
@@ -0,0 +1,40 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { ExternalExportBatchRepository } from "../src/db/repositories/external-export-batch.repository.js";
+import { projects } from "../src/db/schema/projects.js";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
+
+describe("external export batch repository", () => {
+  it("appends immutable audit metadata without changing the project revision", () => {
+    const context = createDatabaseContext(":memory:");
+    try {
+      migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+      context.db.insert(projects).values({ id: "project-1", name: "Projekt", currentRevision: 7 }).run();
+      const repository = new ExternalExportBatchRepository(context.db);
+      const configuration = createDefaultExternalModelConfiguration();
+      repository.append({
+        id: "export-1", projectId: "project-1", projectRevision: 7,
+        importBatchId: "historical-import-without-foreign-key", exportedAtIso: "2026-09-30T10:00:00.000Z",
+        fileName: "Projekt_Revit-Rueckgabe_2026-09-30.xlsx", sha256: "a".repeat(64),
+        configurationSnapshot: configuration, configurationSha256: "b".repeat(64), scope: "all", objectCount: 4,
+      });
+      configuration.columns.designation = "Nachträglich geändert";
+      repository.append({
+        id: "export-2", projectId: "project-1", projectRevision: 7,
+        importBatchId: "historical-import-without-foreign-key", exportedAtIso: "2026-09-30T11:00:00.000Z",
+        fileName: "Projekt_Revit-Rueckgabe_2026-09-30.xlsx", sha256: "c".repeat(64),
+        configurationSnapshot: configuration, configurationSha256: "d".repeat(64), scope: "selected", objectCount: 1,
+      });
+
+      const batches = repository.listByProject("project-1");
+      assert.deepEqual(batches.map((batch) => batch.id), ["export-2", "export-1"]);
+      assert.notEqual(batches[0]!.configurationSnapshot.columns.designation, batches[1]!.configurationSnapshot.columns.designation);
+      assert.equal(context.db.select({ revision: projects.currentRevision }).from(projects).get()!.revision, 7);
+    } finally {
+      context.close();
+    }
+  });
+});
diff --git a/tests/external-xlsx-return-projection.test.ts b/tests/external-xlsx-return-projection.test.ts
new file mode 100644
index 0000000..10c1980
--- /dev/null
+++ b/tests/external-xlsx-return-projection.test.ts
@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { projectExternalXlsxReturn } from "../src/external-model/application/external-xlsx-return-projection.js";
+import type { ExternalModelObjectSnapshot } from "../src/external-model/domain/external-model-contracts.js";
+
+function object(): ExternalModelObjectSnapshot {
+  return {
+    id: "object-1", projectId: "project-1", sourceId: "source-1",
+    worksharingId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee-ffffffff", ifcGuid: null,
+    deviceTypeId: "type-1", lastSeenImportBatchId: "batch-1", lastAcceptedImportBatchId: "batch-1",
+    acceptedSourceValues: { rowNumber: 2, roomNumber: "101", roomName: "Büro", familyAndType: "Steckdose", selectionMarker: "SD", socketCount: 2, sourceRemark: null, circuitCombined: "UV 1-2F1.1", boardName: "UV 1", circuitIdentifier: "-2F1.1", designation: "Steckdose", electricalPowerW: "240", voltageV: 230, currentA: "1,16" },
+    planningValues: { displayName: "Steckdose", category: "single_phase", connectionKind: "socket", effectiveQuantity: 2, powerPerUnitW: 120, simultaneityFactor: 1, cosPhi: 0.9, costGroup: null, remark: null },
+    overriddenFields: [], externalRoomMappingId: null, distributionBoardId: "board-1", linkedProjectDeviceId: null, circuitDeviceRowId: "row-1", presenceStatus: "present",
+  };
+}
+
+describe("external XLSX return projection", () => {
+  it("projects typed row values and compares normalized imported scalars", () => {
+    const result = projectExternalXlsxReturn({ object: object(), circuitMode: "combined", singlePhaseVoltageV: 230, threePhaseVoltageV: 400, row: { rowId: "row-1", displayName: "Steckdose", powerPerUnitKw: 0.12, cosPhi: 0.9, phaseType: "single_phase", category: "single_phase", circuitIdentifier: "-2F1.1", circuitVoltageV: 230, distributionBoardName: "UV 1" } });
+    assert.deepEqual(result.values, { circuitCombined: "UV 1-2F1.1", designation: "Steckdose", electricalPowerW: 240, voltageV: 230, currentA: 1.16 });
+    assert.equal(result.differsFromImported, false);
+    assert.deepEqual(result.warnings, []);
+  });
+
+  it("uses object planning without a row and leaves an uncomputable current empty", () => {
+    const input = object(); input.circuitDeviceRowId = null; input.planningValues.cosPhi = null;
+    const result = projectExternalXlsxReturn({ object: input, row: null, circuitMode: "separate", singlePhaseVoltageV: 230, threePhaseVoltageV: 400 });
+    assert.equal(result.values.boardName, "");
+    assert.equal(result.values.circuitIdentifier, "");
+    assert.equal(result.values.electricalPowerW, 240);
+    assert.equal(result.values.currentA, null);
+    assert.equal(result.differsFromImported, true);
+    assert.match(result.warnings.join(" "), /Stromstärke/);
+  });
+
+  it("uses three-phase current and object-specific effective quantity", () => {
+    const input = object(); input.planningValues.category = "three_phase"; input.planningValues.effectiveQuantity = 3;
+    const result = projectExternalXlsxReturn({ object: input, row: null, circuitMode: "combined", singlePhaseVoltageV: 230, threePhaseVoltageV: 400 });
+    assert.equal(result.values.electricalPowerW, 360);
+    assert.equal(result.values.voltageV, 400);
+    assert.equal(result.values.currentA, 0.58);
+  });
+});
diff --git a/tests/revit-xlsx-settings-api.test.ts b/tests/revit-xlsx-settings-api.test.ts
index 4f13b70..90161b3 100644
--- a/tests/revit-xlsx-settings-api.test.ts
+++ b/tests/revit-xlsx-settings-api.test.ts
@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { describe, it } from "node:test";
 import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
-import { applyExternalInitialImport, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getExternalProjectObjects, planExternalInitialImport, updateExternalModelConfiguration, updateExternalProjectObjects } from "../src/frontend/utils/api.js";
+import { applyExternalInitialImport, createExternalReturnWorkbook, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getExternalProjectObjects, planExternalInitialImport, updateExternalModelConfiguration, updateExternalProjectObjects } from "../src/frontend/utils/api.js";
 
 describe("Revit XLSX settings", () => {
   it("uses the project-scoped configuration endpoint with expectedRevision", async () => {
@@ -66,6 +66,8 @@ describe("Revit XLSX settings", () => {
     assert.match(wizard, /GZF 1/);
     assert.match(objectTable, /viewportHeight/);
     assert.match(objectTable, /Sammeländerung anwenden/);
+    assert.match(objectTable, /Rückgabe-Excel herunterladen/);
+    assert.match(objectTable, /Nur geänderte Objekte/);
   });
 
   it("loads one project object list and sends revision-safe bulk updates", async () => {
@@ -76,4 +78,16 @@ describe("Revit XLSX settings", () => {
     finally { globalThis.fetch = originalFetch; }
     assert.deepEqual(requests, [{ url: "/api/projects/project-1/external-model/objects", method: "GET", body: undefined }, { url: "/api/projects/project-1/external-model/objects", method: "PUT", body: { expectedRevision: 4, objectIds: ["object-1"], patch: { simultaneityFactor: 0.7 } } }]);
   });
+
+  it("creates a revision-safe return workbook for the requested scope", async () => {
+    const requests: Array<{ url: string; method: string; body: unknown }> = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => {
+      requests.push({ url: String(input), method: init?.method ?? "GET", body: init?.body ? JSON.parse(String(init.body)) : undefined });
+      return new Response(JSON.stringify({ fileName: "return.xlsx", contentBase64: "", sha256: "a".repeat(64), objectCount: 1, warnings: [] }), { status: 200, headers: { "Content-Type": "application/json" } });
+    };
+    try { await createExternalReturnWorkbook("project-1", 7, "selected", ["object-1"]); }
+    finally { globalThis.fetch = originalFetch; }
+    assert.deepEqual(requests, [{ url: "/api/projects/project-1/external-model/return-workbook", method: "POST", body: { expectedRevision: 7, scope: "selected", selectedObjectIds: ["object-1"] } }]);
+  });
 });

From 2581beee3c16d548f09f059f421113e326828a96 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 20:40:40 +0200
Subject: [PATCH 58/60] Add Linear XLSX follow-up import

---
 AGENTS.md                                     |   9 +-
 README.md                                     |  14 +-
 docs/circuit-list-editor-known-limitations.md |  13 +-
 docs/current-architecture.md                  |   5 +-
 .../revit-excel-integration-requirements.md   |   9 ++
 docs/spec/revit-excel-phase-14-plan.md        |  13 +-
 src/app/projects/[projectId]/revit/page.tsx   |   9 +-
 ...ow-up-import-project-command.repository.ts |  86 +++++++++++
 ...lete-missing-project-command.repository.ts |  59 ++++++++
 ...-follow-up-import-project-command.model.ts |  84 +++++++++++
 ...ct-delete-missing-project-command.model.ts |  54 +++++++
 ...-follow-up-import-project-command.store.ts |   6 +
 ...ct-delete-missing-project-command.store.ts |   3 +
 .../services/project-command.service.ts       |  18 ++-
 .../external-xlsx-follow-up-import.ts         | 120 +++++++++++++++
 .../external-xlsx-follow-up-target.ts         | 138 ++++++++++++++++++
 .../revit-follow-up-import-wizard.tsx         |  91 ++++++++++++
 .../components/revit-object-table.tsx         |  18 ++-
 src/frontend/types.ts                         |  29 ++++
 src/frontend/utils/api.ts                     |  19 +++
 .../composition/project-command-stores.ts     |  10 +-
 .../external-follow-up-import.controller.ts   |  83 +++++++++++
 .../external-initial-import.controller.ts     |   2 +-
 .../external-objects.controller.ts            |  34 +++++
 src/server/routes/project.routes.ts           |   6 +-
 ...-import-project-command.repository.test.ts |  98 +++++++++++++
 tests/external-xlsx-follow-up-import.test.ts  |  82 +++++++++++
 tests/revit-xlsx-settings-api.test.ts         |  33 ++++-
 28 files changed, 1114 insertions(+), 31 deletions(-)
 create mode 100644 src/db/repositories/external-follow-up-import-project-command.repository.ts
 create mode 100644 src/db/repositories/external-object-delete-missing-project-command.repository.ts
 create mode 100644 src/domain/models/external-follow-up-import-project-command.model.ts
 create mode 100644 src/domain/models/external-object-delete-missing-project-command.model.ts
 create mode 100644 src/domain/ports/external-follow-up-import-project-command.store.ts
 create mode 100644 src/domain/ports/external-object-delete-missing-project-command.store.ts
 create mode 100644 src/external-model/application/external-xlsx-follow-up-import.ts
 create mode 100644 src/external-model/application/external-xlsx-follow-up-target.ts
 create mode 100644 src/frontend/components/revit-follow-up-import-wizard.tsx
 create mode 100644 src/server/controllers/external-follow-up-import.controller.ts
 create mode 100644 tests/external-follow-up-import-project-command.repository.test.ts
 create mode 100644 tests/external-xlsx-follow-up-import.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index d438bae..e4b9b94 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -344,6 +344,13 @@ batch payloads. The Revit page filters and sorts it in the client and renders a
 virtualized window. `external-object.update-planning` applies multi-object
 board, ProjectDevice and planning-value changes as one persistent command;
 linked objects are excluded because they follow their CircuitDeviceRow board.
+R9 adds the complete Linear-XLSX follow-up import. It matches Worksharing-IDs
+exactly, separates source decisions from return deviations, updates accepted
+linked quantities atomically, retains missing objects and compacts every older
+batch to metadata. `external-import.apply-follow-up` stores complete inverse
+states, so Undo/Redo never parses Excel. A separately confirmed
+`external-model-object.delete-missing` command removes missing objects and
+adjusts linked row quantities; Undo restores objects, links and quantities.
 
 The target configuration has no independent version counter; `expectedRevision`
 invalidates stale plans, and each import batch stores a configuration copy.
@@ -597,7 +604,7 @@ Critical target rules:
   selected combined/separate mode block export.
 - Missing GZF defaults visibly to 1 without separate confirmation.
 - The corrected R2 return workbook was successfully imported into Linear on
-  2026-09-30; R3 through R6 are complete and R7 is the next package.
+  2026-09-30; R3 through R9 are complete and R10 is the next package.
 - All confirmed writes use typed project commands with `expectedRevision`,
   complete inverse data and the shared project-command transaction boundary.
 - Do not add automatic circuit planning, Revit circuit adoption, multi-source
diff --git a/README.md b/README.md
index d4aeae4..d1e9523 100644
--- a/README.md
+++ b/README.md
@@ -11,10 +11,10 @@ für mehrere gleichzeitig arbeitende Prozesse und ein vollständig unterstützte
 Produktionsdeployment fehlen weiterhin. Anmeldung und zwei feste Rollen sind
 vorhanden. Die Backend- und Persistenzgrundlage der bisherigen
 Revit-CSV-/IfcGUID-Anbindung ist durch den XLSX-Austausch des Linear-Plugins mit
-Worksharing-ID als externem Schlüssel ersetzt. R0 bis R6 sind abgeschlossen;
-die eigene Revit-Seite besitzt XLSX-Einstellungen und einen persistenten
-Erstimport sowie eine virtualisierte Objekttabelle mit Sammeländerungen.
-Editorzuordnung, Rückgabe und Folgeimport folgen in R7 bis R10.
+Worksharing-ID als externem Schlüssel ersetzt. R0 bis R9 sind abgeschlossen;
+die eigene Revit-Seite unterstützt Einstellungen, Erst- und Folgeimport,
+virtuelle Objektbearbeitung, Editorzuordnung und strukturtreue Rückgabe.
+R10 härtet den Ablauf Ende zu Ende und für große Datenmengen.
 
 ## Unterstützter Arbeitsablauf
 
@@ -41,9 +41,9 @@ Editorzuordnung, Rückgabe und Folgeimport folgen in R7 bis R10.
 - grobe Leistungsbilanzen für LPH 2/3 nach Kostengruppen führen, mit der
   detaillierten Bilanz vergleichen und einzelne Zeilen als Projektgerät
   übernehmen
-- Linear-XLSX-Dateien verlustarm lesen und schreiben; Revit-Seite,
-  Erstimport, Editorzuordnung, Rückgabe und Folgeimport werden gemäß
-  Phase-14-Plan in den nächsten Paketen angebunden
+- Linear-XLSX-Dateien verlustarm lesen und schreiben; Erst- und Folgeimporte
+  prüfen, Revit-Objekte zuordnen und geplante Werte strukturerhaltend an
+  Linear zurückgeben
 
 ## Technik
 
diff --git a/docs/circuit-list-editor-known-limitations.md b/docs/circuit-list-editor-known-limitations.md
index ee2d470..63bc7b3 100644
--- a/docs/circuit-list-editor-known-limitations.md
+++ b/docs/circuit-list-editor-known-limitations.md
@@ -9,14 +9,11 @@
 - Named and automatic logical project snapshots can be listed and restored
   through the project page with persistent Undo/Redo. Automatic snapshots are
   created every 25 revisions and only their newest 12 entries are retained.
-- The current Revit/CSV foundation and confirmed initial import are a legacy
-  starting point. The active Phase-14 plan replaces them with the Linear XLSX
-  exchange and exact Worksharing-ID identity.
-  R2 must pass a real Linear return-import check before database cutover in R3.
-  Existing-row assignment, move and detach plus creation of an external-only
-  row in an existing or newly created circuit have atomic persistent commands.
-  Their API planning and editor UI, follow-up import, conflict review and return
-  export are pending.
+- Die Linear-XLSX-Anbindung bis R9 ist umgesetzt: Erst- und Folgeimport,
+  Objektplanung und Editorzuordnung, strukturtreue Rückgabe sowie bestätigtes
+  Löschen fehlender Objekte verwenden persistente Commands. Offen ist die
+  R10-Härtung des gesamten Ablaufs mit mehreren Tausend synthetischen Objekten,
+  Messungen sowie Snapshot-/Transfer- und Neustarttests.
 - Persistence currently targets local SQLite; PostgreSQL is an architectural option, not an implemented runtime.
 - The global device library supports basic CRUD and copy operations, but has no
   versioning, permissions or controlled synchronization model.
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 4dfa96c..5e746fe 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -843,9 +843,8 @@ Referenzen gesperrt.
 ## Noch nicht unterstützt
 
 - Mehrbenutzerbetrieb und Konfliktauflösung
-- Linear-XLSX-Transport, eigene Revit-Seite, Editor-Oberfläche für die
-  Zuordnungslogik, Folgeimport und strukturtreuer Revit-Rückexport; Umsetzung
-  folgt dem R0–R10-Plan
+- R10-Härtung des Linear-XLSX-Ablaufs für große Datenmengen sowie
+  Ende-zu-Ende-Nachweise über Snapshot, Transfer und Neustart
 - vollständige elektrische Dimensionierung
 - Produktionsdeployment
 
diff --git a/docs/spec/revit-excel-integration-requirements.md b/docs/spec/revit-excel-integration-requirements.md
index ce80c46..bc86326 100644
--- a/docs/spec/revit-excel-integration-requirements.md
+++ b/docs/spec/revit-excel-integration-requirements.md
@@ -430,6 +430,15 @@ Unveränderte Objekte erzeugen keine unnötigen Objekt- oder Row-Änderungen.
 Der neue vollständige Batch wird letzter Batch; der zuvor letzte Batch wird
 auf Metadaten reduziert.
 
+Umsetzungsstand R9: Der sechsstufige Folgeimportwizard, die erneute
+Apply-Prüfung, die getrennte Rückgabeabweichungsanzeige und der atomare
+`external-import.apply-follow-up`-Command sind umgesetzt. Akzeptierte
+Mengenänderungen aktualisieren verknüpfte Row-Summen im selben Command.
+Fehlende Objekte bleiben zunächst samt Link und Menge erhalten und erscheinen
+in der virtuellen Objekttabelle als `fehlend`. Ihre gesondert bestätigte
+Löschung verwendet `external-model-object.delete-missing`; Undo stellt
+Objekte, Links und Row-Mengen exakt wieder her.
+
 ## 15. Commands, Persistenz und Sicherheit
 
 Projektbezogene Writes verwenden typisierte Commands mit vollständiger
diff --git a/docs/spec/revit-excel-phase-14-plan.md b/docs/spec/revit-excel-phase-14-plan.md
index 61d8f2d..d7e6cbe 100644
--- a/docs/spec/revit-excel-phase-14-plan.md
+++ b/docs/spec/revit-excel-phase-14-plan.md
@@ -17,7 +17,7 @@ Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
 | R6 | abgeschlossen | Projektweite kompakte Objektliste, clientseitige Filter/Sortierung, Virtualisierung und revisionierte Sammeländerungen. |
 | R7 | abgeschlossen | Gruppierter Editorbereich, drei Drag-and-drop-Ziele, Row-Indikator, ausdrückliches Lösen und atomare Löschübergänge mit exaktem Undo/Redo. |
 | R8 | abgeschlossen | Rückgabe-Excel für alle, abweichende oder ausgewählte Objekte und append-only Exportnachweis sind umgesetzt. |
-| R9 | offen | Vollständiger Folgeimport nach Worksharing-ID. |
+| R9 | abgeschlossen | Vollständiger Folgeimport nach exakter Worksharing-ID mit Quellentscheidungen, fehlenden Objekten, bestätigtem Löschen und persistentem Undo/Redo. |
 | R10 | offen | Ende-zu-Ende-Härtung, große Datenmengen und Abschlussdokumentation. |
 
 ## R0 – Audit
@@ -190,6 +190,17 @@ Revision, Importbatch, Konfigurationskopie und Prüfsummen protokolliert.
 - neuer letzter Vollbatch, vorheriger Batch auf Metadaten reduzieren;
 - ein persistenter Undo-Schritt ohne Excel-Parsing bei Undo/Redo.
 
+Umsetzungsstand vom 30.09.2026: Vorschau und Apply klassifizieren die vollständige
+XLSX nach exakter Worksharing-ID als neu, geändert, unverändert oder fehlend
+und weisen Rückgabefeldabweichungen getrennt aus. Der Wizard fordert
+Entscheidungen nur für fachliche Quelländerungen an. Apply überträgt und parst
+die Datei erneut, aktualisiert akzeptierte Mengen samt verknüpfter Row-Summe
+atomar und speichert den neuen Vollbatch; alle älteren Batches werden auf ihre
+Metadaten reduziert. Fehlende Objekte behalten zunächst Link und Menge. Eine
+gesondert bestätigte Aktion kann sie anschließend mit passender
+Row-Mengenänderung löschen. Beide Commands besitzen vollständige Inversen;
+Undo/Redo liest keine XLSX-Datei.
+
 ## R10 – Härtung
 
 Ende-zu-Ende-Test:
diff --git a/src/app/projects/[projectId]/revit/page.tsx b/src/app/projects/[projectId]/revit/page.tsx
index 46c3d5d..8c2735c 100644
--- a/src/app/projects/[projectId]/revit/page.tsx
+++ b/src/app/projects/[projectId]/revit/page.tsx
@@ -5,6 +5,7 @@ import { useParams } from "next/navigation";
 import { useEffect, useState } from "react";
 import { IconLink } from "../../../../frontend/components/icon-link";
 import { RevitInitialImportWizard } from "../../../../frontend/components/revit-initial-import-wizard";
+import { RevitFollowUpImportWizard } from "../../../../frontend/components/revit-follow-up-import-wizard";
 import { RevitObjectTable } from "../../../../frontend/components/revit-object-table";
 import { RevitXlsxSettingsModal } from "../../../../frontend/components/revit-xlsx-settings-modal";
 import type { ExternalModelConfiguration } from "../../../../external-model/configuration/external-model-configuration";
@@ -19,6 +20,7 @@ export default function RevitPage() {
   const [importStatus, setImportStatus] = useState<ExternalInitialImportStatusDto | null>(null);
   const [settingsOpen, setSettingsOpen] = useState(false);
   const [importOpen, setImportOpen] = useState(false);
+  const [followUpOpen, setFollowUpOpen] = useState(false);
   const [saving, setSaving] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
@@ -41,11 +43,12 @@ export default function RevitPage() {
   }
 
   return <main className="container py-4">
-    <div className="page-header"><div><div className="kicker">Projekt · Revit</div><h1>{project?.name ?? "Revit-Anbindung"}</h1><p className="text-secondary mb-0">Linear-XLSX austauschen und Revit-Objekte verwalten</p></div><div className="d-flex gap-2"><button className="btn btn-success btn-with-icon" disabled={!project || !snapshot || Boolean(importStatus?.imported)} onClick={() => setImportOpen(true)} type="button"><Upload size={16} />Erstimport</button><button className="btn btn-primary btn-with-icon" disabled={!project} onClick={() => setSettingsOpen(true)} type="button"><Settings size={16} />Einstellungen</button><IconLink href={`/projects/${projectId}`} icon={ArrowLeft} label="Zum Projekt" showLabel /></div></div>
+    <div className="page-header"><div><div className="kicker">Projekt · Revit</div><h1>{project?.name ?? "Revit-Anbindung"}</h1><p className="text-secondary mb-0">Linear-XLSX austauschen und Revit-Objekte verwalten</p></div><div className="d-flex gap-2"><button className="btn btn-success btn-with-icon" disabled={!project || !snapshot || Boolean(importStatus?.imported)} onClick={() => setImportOpen(true)} type="button"><Upload size={16} />Erstimport</button><button className="btn btn-success btn-with-icon" disabled={!project || !snapshot || !importStatus?.imported} onClick={() => setFollowUpOpen(true)} type="button"><Upload size={16} />Folgeimport</button><button className="btn btn-primary btn-with-icon" disabled={!project} onClick={() => setSettingsOpen(true)} type="button"><Settings size={16} />Einstellungen</button><IconLink href={`/projects/${projectId}`} icon={ArrowLeft} label="Zum Projekt" showLabel /></div></div>
     {error ? <div className="alert alert-danger">{error}</div> : null}
-    <div className="row g-3 mt-1"><div className="col-md-6"><section className="card h-100"><div className="card-body"><FileSpreadsheet className="mb-3" size={28} /><h2 className="h5">XLSX-Konfiguration</h2><p className="text-secondary">{snapshot ? "Die Linear-Spalten und das Tabellenlayout sind konfiguriert." : "Noch keine XLSX-Konfiguration gespeichert."}</p><span className={`badge ${snapshot ? "text-bg-success" : "text-bg-secondary"}`}>{snapshot ? "Konfiguriert" : "Offen"}</span></div></section></div><div className="col-md-6"><section className="card h-100"><div className="card-body"><h2 className="h5">Importstatus</h2>{importStatus?.imported ? <><p className="mb-1"><strong>{importStatus.objectCount} Revit-Objekte</strong>{importStatus.fileName ? ` aus ${importStatus.fileName}` : ""}</p><p className="text-secondary mb-0">Quelle: {importStatus.sourceName}</p></> : <p className="text-secondary mb-0">Noch kein Linear-XLSX-Import vorhanden.</p>}</div></section></div></div>
-    {importStatus?.imported ? <RevitObjectTable projectId={projectId} onRevision={(revision) => setProject((current) => current ? { ...current, currentRevision: revision } : current)} /> : null}
+    <div className="row g-3 mt-1"><div className="col-md-6"><section className="card h-100"><div className="card-body"><FileSpreadsheet className="mb-3" size={28} /><h2 className="h5">XLSX-Konfiguration</h2><p className="text-secondary">{snapshot ? "Die Linear-Spalten und das Tabellenlayout sind konfiguriert." : "Noch keine XLSX-Konfiguration gespeichert."}</p><span className={`badge ${snapshot ? "text-bg-success" : "text-bg-secondary"}`}>{snapshot ? "Konfiguriert" : "Offen"}</span></div></section></div><div className="col-md-6"><section className="card h-100"><div className="card-body"><h2 className="h5">Importstatus</h2>{importStatus?.imported ? <><p className="mb-1"><strong>{importStatus.objectCount} Revit-Objekte</strong>{importStatus.fileName ? ` aus ${importStatus.fileName}` : ""}</p><p className="text-secondary mb-0">Quelle: {importStatus.sourceName} · Fehlend: {importStatus.missingObjectCount}</p></> : <p className="text-secondary mb-0">Noch kein Linear-XLSX-Import vorhanden.</p>}</div></section></div></div>
+    {importStatus?.imported ? <RevitObjectTable key={project?.currentRevision} projectId={projectId} onRevision={(revision) => setProject((current) => current ? { ...current, currentRevision: revision } : current)} /> : null}
     {settingsOpen ? <RevitXlsxSettingsModal configuration={snapshot?.configuration ?? createDefaultRevitXlsxConfiguration()} isNewConfiguration={snapshot === null} isSaving={saving} onClose={() => setSettingsOpen(false)} onInspectSample={async (file, configuration) => { const result = await detectExternalModelWorkbook(projectId, file, configuration); return `Muster erkannt: ${result.sheetName}, ${result.columnCount} Spalten, ${result.objectCount} Objekte.`; }} onSave={save} /> : null}
     {importOpen && project && snapshot ? <RevitInitialImportWizard projectId={projectId} expectedRevision={project.currentRevision} initialConfiguration={snapshot.configuration} onClose={() => setImportOpen(false)} onImported={({ history }) => { setProject({ ...project, currentRevision: history.currentRevision }); setImportOpen(false); void Promise.all([getExternalInitialImportStatus(projectId), getExternalModelConfiguration(projectId)]).then(([status, configuration]) => { setImportStatus(status); setSnapshot(configuration.configuration); }); }} /> : null}
+    {followUpOpen && project && snapshot ? <RevitFollowUpImportWizard projectId={projectId} expectedRevision={project.currentRevision} initialConfiguration={snapshot.configuration} onClose={() => setFollowUpOpen(false)} onImported={({ history }) => { setProject({ ...project, currentRevision: history.currentRevision }); setFollowUpOpen(false); void Promise.all([getExternalInitialImportStatus(projectId), getExternalModelConfiguration(projectId)]).then(([status, configuration]) => { setImportStatus(status); setSnapshot(configuration.configuration); }); }} /> : null}
   </main>;
 }
diff --git a/src/db/repositories/external-follow-up-import-project-command.repository.ts b/src/db/repositories/external-follow-up-import-project-command.repository.ts
new file mode 100644
index 0000000..7303200
--- /dev/null
+++ b/src/db/repositories/external-follow-up-import-project-command.repository.ts
@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+import { and, eq, inArray } from "drizzle-orm";
+import { assertCircuitDeviceRowQuantity } from "../../domain/calculations/circuit-device-row-quantity.js";
+import { assertExternalFollowUpImportProjectCommand, invertExternalFollowUpImportProjectCommand } from "../../domain/models/external-follow-up-import-project-command.model.js";
+import type { ExternalFollowUpImportProjectCommandStore } from "../../domain/ports/external-follow-up-import-project-command.store.js";
+import type { CircuitDeviceRowSnapshot } from "../../domain/models/circuit-device-row-structure-project-command.model.js";
+import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
+import type { ExternalModelStateSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import type { AppDatabase } from "../database-context.js";
+import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
+import { circuitLists } from "../schema/circuit-lists.js";
+import { circuits } from "../schema/circuits.js";
+import { distributionBoards } from "../schema/distribution-boards.js";
+import { externalImportBatches } from "../schema/external-import-batches.js";
+import { externalModelConfigurations } from "../schema/external-model-configurations.js";
+import { externalModelObjects } from "../schema/external-model-objects.js";
+import { externalModelSources } from "../schema/external-model-sources.js";
+import { externalRoomMappings } from "../schema/external-room-mappings.js";
+import { projectDevices } from "../schema/project-devices.js";
+import { rooms } from "../schema/rooms.js";
+import { toCircuitDeviceRowSnapshot } from "./circuit-device-row-structure.persistence.js";
+import { ExternalModelStateRepository } from "./external-model-state.repository.js";
+import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+
+export class ExternalFollowUpImportProjectCommandRepository implements ExternalFollowUpImportProjectCommandStore {
+  constructor(private readonly database: AppDatabase) {}
+  execute(input: Parameters<ExternalFollowUpImportProjectCommandStore["execute"]>[0]) {
+    assertExternalFollowUpImportProjectCommand(input.command);
+    return executeProjectCommandTransaction(this.database, input, (tx) => {
+      const currentState = new ExternalModelStateRepository(tx).getByProject(input.projectId);
+      const currentConfiguration = tx.select().from(externalModelConfigurations).where(eq(externalModelConfigurations.projectId, input.projectId)).get();
+      if (!currentState.projectExists || !currentConfiguration || !same(currentState.state, input.command.payload.expectedState) || !same(currentConfiguration, input.command.payload.expectedConfiguration)) throw new Error("Revit-Zustand oder Konfiguration wurde zwischenzeitlich geändert.");
+      const rowIds = input.command.payload.rows.map(({ expected }) => expected.id);
+      const currentRows = rowIds.length ? tx.select().from(circuitDeviceRows).where(inArray(circuitDeviceRows.id, rowIds)).all() : [];
+      if (currentRows.length !== rowIds.length) throw new Error("Eine Gerätezeile des Folgeimports wurde nicht gefunden.");
+      const transitionById = new Map(input.command.payload.rows.map((transition) => [transition.expected.id, transition]));
+      for (const row of currentRows) if (!same(toCircuitDeviceRowSnapshot(row), transitionById.get(row.id)!.expected)) throw new Error("Eine Gerätezeile wurde zwischenzeitlich geändert.");
+      validateTarget(tx, input.projectId, input.expectedRevision, input.source, input.command.payload.targetConfiguration.configuration, input.command.payload.expectedState, input.command.payload.targetState, input.command.payload.rows);
+      for (const transition of input.command.payload.rows) {
+        const result = tx.update(circuitDeviceRows).set({ quantity: transition.target.quantity }).where(and(eq(circuitDeviceRows.id, transition.expected.id), eq(circuitDeviceRows.quantity, transition.expected.quantity))).run();
+        if (result.changes !== 1) throw new Error("Eine Gerätezeile wurde während des Folgeimports geändert.");
+      }
+      replaceConfiguration(tx, input.projectId, input.command.payload.targetConfiguration);
+      replaceState(tx, input.projectId, input.command.payload.targetState);
+      return invertExternalFollowUpImportProjectCommand(input.command);
+    });
+  }
+}
+
+function validateTarget(database: AppDatabase, projectId: string, expectedRevision: number, source: string, configuration: ExternalModelConfiguration, expectedState: ExternalModelStateSnapshot, target: ExternalModelStateSnapshot, rows: Array<{ expected: CircuitDeviceRowSnapshot; target: CircuitDeviceRowSnapshot }>) {
+  if (target.source?.projectId !== projectId) throw new Error("Der Revit-Folgeimport gehört zu einem anderen Projekt.");
+  const growing = target.importBatches.length > expectedState.importBatches.length;
+  const latest = growing ? target.importBatches.at(-1)! : expectedState.importBatches.at(-1)!;
+  if (source === "user" && (!growing || latest.appliedProjectRevision !== expectedRevision + 1)) throw new Error("Die Projektrevision des Folgeimports ist ungültig.");
+  if (growing) {
+    if (!same(latest.configurationSnapshot, configuration)) throw new Error("Die Konfigurationskopie des Folgeimports ist ungültig.");
+    const bytes = Buffer.from(latest.originalContentBase64!, "base64");
+    if (bytes.toString("base64") !== latest.originalContentBase64 || createHash("sha256").update(bytes).digest("hex") !== latest.sha256) throw new Error("Die Prüfsumme des Folgeimports ist ungültig.");
+  }
+  const roomIds = ids(database.select({ id: rooms.id }).from(rooms).where(eq(rooms.projectId, projectId)).all());
+  const boardIds = ids(database.select({ id: distributionBoards.id }).from(distributionBoards).where(eq(distributionBoards.projectId, projectId)).all());
+  const projectDeviceIds = ids(database.select({ id: projectDevices.id }).from(projectDevices).where(eq(projectDevices.projectId, projectId)).all());
+  const deviceTypeIds = new Set(configuration.deviceTypes.map((entry) => entry.id));
+  for (const mapping of target.roomMappings) { if (mapping.roomId && !roomIds.has(mapping.roomId)) throw new Error("Eine Raumzuordnung verweist auf ein anderes Projekt."); if (mapping.defaultDistributionBoardId && !boardIds.has(mapping.defaultDistributionBoardId)) throw new Error("Ein Standardverteiler verweist auf ein anderes Projekt."); }
+  for (const object of target.objects) { if (!deviceTypeIds.has(object.deviceTypeId)) throw new Error("Ein Revit-Objekt verweist auf eine unbekannte Geräteart."); if (object.distributionBoardId && !boardIds.has(object.distributionBoardId)) throw new Error("Ein Revit-Objekt verweist auf einen fremden Verteiler."); if (object.linkedProjectDeviceId && !projectDeviceIds.has(object.linkedProjectDeviceId)) throw new Error("Ein Revit-Objekt verweist auf ein fremdes Projektgerät."); }
+  assertRows(database, projectId, target, rows);
+}
+
+function assertRows(database: AppDatabase, projectId: string, target: ExternalModelStateSnapshot, rows: Array<{ expected: CircuitDeviceRowSnapshot; target: CircuitDeviceRowSnapshot }>) {
+  const linkedRowIds = [...new Set(target.objects.flatMap((object) => object.circuitDeviceRowId ? [object.circuitDeviceRowId] : []))];
+  const rowsToLoad = [...new Set([...linkedRowIds, ...rows.map(({ expected }) => expected.id)])];
+  if (!rowsToLoad.length) return;
+  const contexts = database.select({ row: circuitDeviceRows, projectId: circuitLists.projectId }).from(circuitDeviceRows).innerJoin(circuits, eq(circuits.id, circuitDeviceRows.circuitId)).innerJoin(circuitLists, eq(circuitLists.id, circuits.circuitListId)).where(inArray(circuitDeviceRows.id, rowsToLoad)).all();
+  if (contexts.length !== rowsToLoad.length || contexts.some((entry) => entry.projectId !== projectId)) throw new Error("Eine Gerätezeile gehört zu einem anderen Projekt.");
+  const transitionById = new Map(rows.map((transition) => [transition.expected.id, transition]));
+  for (const context of contexts) {
+    const current = toCircuitDeviceRowSnapshot(context.row);
+    const effective = transitionById.get(current.id)?.target ?? current;
+    assertCircuitDeviceRowQuantity({ quantity: effective.quantity, manualQuantity: effective.manualQuantity ?? effective.quantity, externalObjects: target.objects.filter((object) => object.circuitDeviceRowId === effective.id).map((object) => ({ effectiveQuantity: object.planningValues.effectiveQuantity })) });
+  }
+}
+function replaceConfiguration(database: AppDatabase, projectId: string, target: typeof externalModelConfigurations.$inferInsert) { database.delete(externalModelConfigurations).where(eq(externalModelConfigurations.projectId, projectId)).run(); database.insert(externalModelConfigurations).values(target).run(); }
+function replaceState(database: AppDatabase, projectId: string, target: ExternalModelStateSnapshot) { database.delete(externalModelSources).where(eq(externalModelSources.projectId, projectId)).run(); if (!target.source) return; database.insert(externalModelSources).values(target.source).run(); database.insert(externalImportBatches).values(target.importBatches.map(({ originalContentBase64, ...batch }) => ({ ...batch, originalBytes: originalContentBase64 === null ? null : Buffer.from(originalContentBase64, "base64") }))).run(); if (target.roomMappings.length) database.insert(externalRoomMappings).values(target.roomMappings).run(); if (target.objects.length) database.insert(externalModelObjects).values(target.objects).run(); }
+function ids(entries: Array<{ id: string }>) { return new Set(entries.map((entry) => entry.id)); }
+function same(left: unknown, right: unknown) { return canonical(left) === canonical(right); }
+function canonical(value: unknown): string { if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`; if (value !== null && typeof value === "object") { const record = value as Record<string, unknown>; return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`; } return JSON.stringify(value); }
diff --git a/src/db/repositories/external-object-delete-missing-project-command.repository.ts b/src/db/repositories/external-object-delete-missing-project-command.repository.ts
new file mode 100644
index 0000000..600c19a
--- /dev/null
+++ b/src/db/repositories/external-object-delete-missing-project-command.repository.ts
@@ -0,0 +1,59 @@
+import { and, eq, inArray } from "drizzle-orm";
+import { assertCircuitDeviceRowQuantity } from "../../domain/calculations/circuit-device-row-quantity.js";
+import { assertExternalObjectDeleteMissingProjectCommand, invertExternalObjectDeleteMissingProjectCommand } from "../../domain/models/external-object-delete-missing-project-command.model.js";
+import type { ExternalObjectDeleteMissingProjectCommandStore } from "../../domain/ports/external-object-delete-missing-project-command.store.js";
+import type { AppDatabase } from "../database-context.js";
+import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
+import { circuitLists } from "../schema/circuit-lists.js";
+import { circuits } from "../schema/circuits.js";
+import { externalModelObjects } from "../schema/external-model-objects.js";
+import { externalModelSources } from "../schema/external-model-sources.js";
+import { externalImportBatches } from "../schema/external-import-batches.js";
+import { externalRoomMappings } from "../schema/external-room-mappings.js";
+import { distributionBoards } from "../schema/distribution-boards.js";
+import { projectDevices } from "../schema/project-devices.js";
+import { toCircuitDeviceRowSnapshot } from "./circuit-device-row-structure.persistence.js";
+import { snapshotsEqual, toExternalObjectSnapshot } from "./external-object-assignment.persistence.js";
+import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+
+export class ExternalObjectDeleteMissingProjectCommandRepository implements ExternalObjectDeleteMissingProjectCommandStore {
+  constructor(private readonly database: AppDatabase) {}
+  execute(input: Parameters<ExternalObjectDeleteMissingProjectCommandStore["execute"]>[0]) {
+    assertExternalObjectDeleteMissingProjectCommand(input.command);
+    return executeProjectCommandTransaction(this.database, input, (tx) => {
+      const rowById = new Map(input.command.payload.rows.map((transition) => [transition.expected.id, transition]));
+      const rowIds = [...rowById.keys()];
+      const rowContexts = rowIds.length ? tx.select({ row: circuitDeviceRows, projectId: circuitLists.projectId }).from(circuitDeviceRows).innerJoin(circuits, eq(circuits.id, circuitDeviceRows.circuitId)).innerJoin(circuitLists, eq(circuitLists.id, circuits.circuitListId)).where(inArray(circuitDeviceRows.id, rowIds)).all() : [];
+      if (rowContexts.length !== rowIds.length || rowContexts.some((entry) => entry.projectId !== input.projectId || !snapshotsEqual(toCircuitDeviceRowSnapshot(entry.row), rowById.get(entry.row.id)!.expected))) throw new Error("Eine Gerätezeile wurde zwischenzeitlich geändert.");
+      const currentObjects = tx.select().from(externalModelObjects).where(eq(externalModelObjects.projectId, input.projectId)).all().map(toExternalObjectSnapshot);
+      const currentById = new Map(currentObjects.map((object) => [object.id, object]));
+      for (const transition of input.command.payload.objects) {
+        const current = currentById.get((transition.expected ?? transition.target)!.id) ?? null;
+        if (transition.expected === null ? current !== null : current === null || !snapshotsEqual(current, transition.expected)) throw new Error("Ein fehlendes Revit-Objekt wurde zwischenzeitlich geändert.");
+      }
+      const sourceIds = ids(tx.select({ id: externalModelSources.id }).from(externalModelSources).where(eq(externalModelSources.projectId, input.projectId)).all());
+      const batchIds = ids(tx.select({ id: externalImportBatches.id }).from(externalImportBatches).where(eq(externalImportBatches.projectId, input.projectId)).all());
+      const mappingIds = ids(tx.select({ id: externalRoomMappings.id }).from(externalRoomMappings).where(eq(externalRoomMappings.projectId, input.projectId)).all());
+      const boardIds = ids(tx.select({ id: distributionBoards.id }).from(distributionBoards).where(eq(distributionBoards.projectId, input.projectId)).all());
+      const deviceIds = ids(tx.select({ id: projectDevices.id }).from(projectDevices).where(eq(projectDevices.projectId, input.projectId)).all());
+      for (const { target } of input.command.payload.objects) if (target && (target.projectId !== input.projectId || !sourceIds.has(target.sourceId) || !batchIds.has(target.lastSeenImportBatchId) || !batchIds.has(target.lastAcceptedImportBatchId) || (target.externalRoomMappingId !== null && !mappingIds.has(target.externalRoomMappingId)) || (target.distributionBoardId !== null && !boardIds.has(target.distributionBoardId)) || (target.linkedProjectDeviceId !== null && !deviceIds.has(target.linkedProjectDeviceId)))) throw new Error("Ein wiederhergestelltes Revit-Objekt verweist auf ein anderes Projekt.");
+      const targetById = new Map(currentObjects.map((object) => [object.id, object]));
+      for (const transition of input.command.payload.objects) { const id = (transition.expected ?? transition.target)!.id; if (transition.target) targetById.set(id, transition.target); else targetById.delete(id); }
+      for (const transition of input.command.payload.rows) assertCircuitDeviceRowQuantity({ quantity: transition.target.quantity, manualQuantity: transition.target.manualQuantity ?? transition.target.quantity, externalObjects: [...targetById.values()].filter((object) => object.circuitDeviceRowId === transition.target.id).map((object) => ({ effectiveQuantity: object.planningValues.effectiveQuantity })) });
+      for (const transition of input.command.payload.rows) {
+        const result = tx.update(circuitDeviceRows).set({ quantity: transition.target.quantity }).where(and(eq(circuitDeviceRows.id, transition.expected.id), eq(circuitDeviceRows.quantity, transition.expected.quantity))).run();
+        if (result.changes !== 1) throw new Error("Eine Gerätezeile wurde während des Löschens geändert.");
+      }
+      for (const transition of input.command.payload.objects) {
+        const object = transition.expected ?? transition.target!;
+        if (transition.target === null) {
+          const result = tx.delete(externalModelObjects).where(and(eq(externalModelObjects.id, object.id), eq(externalModelObjects.projectId, input.projectId))).run();
+          if (result.changes !== 1) throw new Error("Ein fehlendes Revit-Objekt konnte nicht gelöscht werden.");
+        } else tx.insert(externalModelObjects).values(transition.target).run();
+      }
+      return invertExternalObjectDeleteMissingProjectCommand(input.command);
+    });
+  }
+}
+
+function ids(entries: Array<{ id: string }>) { return new Set(entries.map((entry) => entry.id)); }
diff --git a/src/domain/models/external-follow-up-import-project-command.model.ts b/src/domain/models/external-follow-up-import-project-command.model.ts
new file mode 100644
index 0000000..f9581a2
--- /dev/null
+++ b/src/domain/models/external-follow-up-import-project-command.model.ts
@@ -0,0 +1,84 @@
+import { assertExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
+import type { ExternalModelStateSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import type { ExternalModelConfigurationSnapshot } from "./external-model-configuration-project-command.model.js";
+import { assertCircuitDeviceRowInsertProjectCommand, circuitDeviceRowInsertCommandType, circuitDeviceRowStructureCommandSchemaVersion, type CircuitDeviceRowSnapshot } from "./circuit-device-row-structure-project-command.model.js";
+import type { SerializedProjectCommand } from "./project-command.model.js";
+import { parseExternalModelStateSnapshot } from "./project-state-snapshot.model.js";
+
+export const externalFollowUpImportCommandType = "external-import.apply-follow-up" as const;
+export const externalFollowUpImportCommandSchemaVersion = 1 as const;
+
+export interface ExternalFollowUpImportPayload {
+  expectedConfiguration: ExternalModelConfigurationSnapshot;
+  targetConfiguration: ExternalModelConfigurationSnapshot;
+  expectedState: ExternalModelStateSnapshot;
+  targetState: ExternalModelStateSnapshot;
+  rows: Array<{ expected: CircuitDeviceRowSnapshot; target: CircuitDeviceRowSnapshot }>;
+}
+
+export interface ExternalFollowUpImportProjectCommand extends SerializedProjectCommand<ExternalFollowUpImportPayload> {
+  schemaVersion: typeof externalFollowUpImportCommandSchemaVersion;
+  type: typeof externalFollowUpImportCommandType;
+}
+
+export function createExternalFollowUpImportProjectCommand(payload: ExternalFollowUpImportPayload): ExternalFollowUpImportProjectCommand {
+  const command: ExternalFollowUpImportProjectCommand = { schemaVersion: 1, type: externalFollowUpImportCommandType, payload: { ...payload, rows: payload.rows.map(({ expected, target }) => ({ expected: normalizeRow(expected), target: normalizeRow(target) })) } };
+  assertExternalFollowUpImportProjectCommand(command);
+  return command;
+}
+
+export function invertExternalFollowUpImportProjectCommand(command: ExternalFollowUpImportProjectCommand) {
+  return createExternalFollowUpImportProjectCommand({
+    expectedConfiguration: command.payload.targetConfiguration,
+    targetConfiguration: command.payload.expectedConfiguration,
+    expectedState: command.payload.targetState,
+    targetState: command.payload.expectedState,
+    rows: command.payload.rows.map(({ expected, target }) => ({ expected: target, target: expected })),
+  });
+}
+
+export function assertExternalFollowUpImportProjectCommand(command: SerializedProjectCommand<unknown>): asserts command is ExternalFollowUpImportProjectCommand {
+  if (command.schemaVersion !== 1 || command.type !== externalFollowUpImportCommandType || !isRecord(command.payload)) throw new Error("Nicht unterstützter Revit-Folgeimport-Command.");
+  if (Object.keys(command.payload).sort().join(",") !== "expectedConfiguration,expectedState,rows,targetConfiguration,targetState" || !Array.isArray(command.payload.rows)) throw new Error("Der Revit-Folgeimport-Command ist unvollständig.");
+  const expectedConfiguration = parseConfiguration(command.payload.expectedConfiguration);
+  const targetConfiguration = parseConfiguration(command.payload.targetConfiguration);
+  if (expectedConfiguration.id !== targetConfiguration.id || expectedConfiguration.projectId !== targetConfiguration.projectId) throw new Error("Der Folgeimport darf die Konfigurationsidentität nicht ändern.");
+  const expectedState = parseExternalModelStateSnapshot(command.payload.expectedState);
+  const targetState = parseExternalModelStateSnapshot(command.payload.targetState);
+  if (!expectedState.source || !targetState.source || expectedState.source.id !== targetState.source.id || expectedState.source.projectId !== targetState.source.projectId) throw new Error("Der Folgeimport benötigt dieselbe Revit-Quelle auf beiden Seiten.");
+  const batchDelta = targetState.importBatches.length - expectedState.importBatches.length;
+  if (Math.abs(batchDelta) !== 1) throw new Error("Der Folgeimport muss genau einen Importbatch hinzufügen oder entfernen.");
+  const larger = batchDelta > 0 ? targetState : expectedState;
+  const smaller = batchDelta > 0 ? expectedState : targetState;
+  const largerConfiguration = batchDelta > 0 ? targetConfiguration : expectedConfiguration;
+  const addedBatch = larger.importBatches.at(-1)!;
+  if (addedBatch.importKind !== "follow_up" || addedBatch.configurationSnapshot === null || addedBatch.originalContentBase64 === null || addedBatch.document === null) throw new Error("Der Folgeimport-Batch ist unvollständig.");
+  if (canonical(addedBatch.configurationSnapshot) !== canonical(largerConfiguration.configuration)) throw new Error("Die Konfigurationskopie des Folgeimports stimmt nicht mit dem Ziel überein.");
+  if (larger.importBatches.length !== smaller.importBatches.length + 1 || smaller.importBatches.some((batch, index) => !sameBatchMetadata(batch, larger.importBatches[index]))) throw new Error("Der Folgeimport darf bestehende Importbatch-Metadaten nicht verändern.");
+  const largerObjectById = new Map(larger.objects.map((object) => [object.id, object]));
+  for (const object of smaller.objects) {
+    const next = largerObjectById.get(object.id);
+    if (!next || next.worksharingId !== object.worksharingId || next.sourceId !== object.sourceId || next.circuitDeviceRowId !== object.circuitDeviceRowId || next.linkedProjectDeviceId !== object.linkedProjectDeviceId) throw new Error("Der Folgeimport darf bestehende Objektidentitäten oder Links nicht verändern.");
+  }
+  const smallerIds = new Set(smaller.objects.map((object) => object.id));
+  if (larger.objects.some((object) => !smallerIds.has(object.id) && (object.circuitDeviceRowId !== null || object.presenceStatus !== "present" || object.lastSeenImportBatchId !== addedBatch.id))) throw new Error("Neue Folgeimportobjekte müssen unverknüpft und vorhanden sein.");
+  if (larger.objects.filter((object) => object.presenceStatus === "present" && object.lastSeenImportBatchId === addedBatch.id).length !== addedBatch.objectCount) throw new Error("Die Objektzahl des Folgeimportbatches ist inkonsistent.");
+  const largerMappings = new Map(larger.roomMappings.map((mapping) => [mapping.id, mapping]));
+  if (smaller.roomMappings.some((mapping) => canonical(mapping) !== canonical(largerMappings.get(mapping.id)))) throw new Error("Der Folgeimport darf bestehende Raumzuordnungen nicht verändern.");
+  const rowIds = new Set<string>();
+  for (const transition of command.payload.rows) {
+    if (!isRecord(transition)) throw new Error("Ungültiger Gerätezeilenübergang im Folgeimport.");
+    const expected = parseRow(transition.expected); const target = parseRow(transition.target);
+    if (expected.id !== target.id || rowIds.has(expected.id) || expected.manualQuantity !== target.manualQuantity) throw new Error("Ungültige Gerätezeilenidentität im Folgeimport.");
+    const expectedRest = { ...expected, quantity: 0 }; const targetRest = { ...target, quantity: 0 };
+    if (canonical(expectedRest) !== canonical(targetRest) || expected.quantity === target.quantity) throw new Error("Der Folgeimport darf an Gerätezeilen nur die Gesamtmenge ändern.");
+    rowIds.add(expected.id);
+  }
+}
+
+function parseConfiguration(value: unknown): ExternalModelConfigurationSnapshot { if (!isRecord(value) || typeof value.id !== "string" || typeof value.projectId !== "string") throw new Error("Ungültige Revit-Konfiguration im Folgeimport."); assertExternalModelConfiguration(value.configuration); return value as unknown as ExternalModelConfigurationSnapshot; }
+function normalizeRow(row: CircuitDeviceRowSnapshot): CircuitDeviceRowSnapshot { return { ...row, manualQuantity: row.manualQuantity ?? row.quantity }; }
+function parseRow(value: unknown): CircuitDeviceRowSnapshot { const envelope = { schemaVersion: circuitDeviceRowStructureCommandSchemaVersion, type: circuitDeviceRowInsertCommandType, payload: { row: value } }; assertCircuitDeviceRowInsertProjectCommand(envelope); return envelope.payload.row; }
+function isRecord(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); }
+function canonical(value: unknown): string { if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`; if (isRecord(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`; return JSON.stringify(value); }
+function sameBatchMetadata(left: ExternalModelStateSnapshot["importBatches"][number], right: ExternalModelStateSnapshot["importBatches"][number] | undefined) { if (!right) return false; return left.id === right.id && left.projectId === right.projectId && left.sourceId === right.sourceId && left.importKind === right.importKind && left.importedAtIso === right.importedAtIso && left.fileName === right.fileName && left.sha256 === right.sha256 && left.objectCount === right.objectCount; }
diff --git a/src/domain/models/external-object-delete-missing-project-command.model.ts b/src/domain/models/external-object-delete-missing-project-command.model.ts
new file mode 100644
index 0000000..ddb7d63
--- /dev/null
+++ b/src/domain/models/external-object-delete-missing-project-command.model.ts
@@ -0,0 +1,54 @@
+import type { ExternalModelObjectSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import type { SerializedProjectCommand } from "./project-command.model.js";
+import { parseExternalModelStateSnapshot } from "./project-state-snapshot.model.js";
+import { assertCircuitDeviceRowInsertProjectCommand, circuitDeviceRowInsertCommandType, circuitDeviceRowStructureCommandSchemaVersion, type CircuitDeviceRowSnapshot } from "./circuit-device-row-structure-project-command.model.js";
+
+export const externalObjectDeleteMissingCommandType = "external-model-object.delete-missing" as const;
+type ObjectTransition = { expected: ExternalModelObjectSnapshot | null; target: ExternalModelObjectSnapshot | null };
+export interface ExternalObjectDeleteMissingProjectCommand extends SerializedProjectCommand<{ objects: ObjectTransition[]; rows: Array<{ expected: CircuitDeviceRowSnapshot; target: CircuitDeviceRowSnapshot }> }> {
+  schemaVersion: 1;
+  type: typeof externalObjectDeleteMissingCommandType;
+}
+
+export function createExternalObjectDeleteMissingProjectCommand(payload: ExternalObjectDeleteMissingProjectCommand["payload"]): ExternalObjectDeleteMissingProjectCommand {
+  const command: ExternalObjectDeleteMissingProjectCommand = { schemaVersion: 1, type: externalObjectDeleteMissingCommandType, payload };
+  assertExternalObjectDeleteMissingProjectCommand(command);
+  return command;
+}
+
+export function invertExternalObjectDeleteMissingProjectCommand(command: ExternalObjectDeleteMissingProjectCommand) {
+  return createExternalObjectDeleteMissingProjectCommand({
+    objects: command.payload.objects.map(({ expected, target }) => ({ expected: target, target: expected })),
+    rows: command.payload.rows.map(({ expected, target }) => ({ expected: target, target: expected })),
+  });
+}
+
+export function assertExternalObjectDeleteMissingProjectCommand(command: SerializedProjectCommand<unknown>): asserts command is ExternalObjectDeleteMissingProjectCommand {
+  if (command.schemaVersion !== 1 || command.type !== externalObjectDeleteMissingCommandType || !isRecord(command.payload) || !Array.isArray(command.payload.objects) || !Array.isArray(command.payload.rows) || command.payload.objects.length === 0) throw new Error("Nicht unterstützter Command zum Löschen fehlender Revit-Objekte.");
+  const objectIds = new Set<string>();
+  let deletion: boolean | null = null;
+  for (const transition of command.payload.objects) {
+    if (!isRecord(transition) || (transition.expected === null) === (transition.target === null)) throw new Error("Ungültiger Löschübergang für ein Revit-Objekt.");
+    const object = parseObject(transition.expected ?? transition.target);
+    if (object.presenceStatus !== "missing" || objectIds.has(object.id)) throw new Error("Nur eindeutig fehlende Revit-Objekte dürfen gelöscht werden.");
+    const nextDeletion = transition.target === null;
+    if (deletion !== null && deletion !== nextDeletion) throw new Error("Löschen und Wiederherstellen dürfen nicht gemischt werden.");
+    deletion = nextDeletion;
+    objectIds.add(object.id);
+  }
+  const affectedRowIds = new Set(command.payload.objects.flatMap(({ expected, target }) => (expected ?? target)!.circuitDeviceRowId ? [(expected ?? target)!.circuitDeviceRowId!] : []));
+  const rowIds = new Set<string>();
+  for (const transition of command.payload.rows) {
+    if (!isRecord(transition)) throw new Error("Ungültiger Gerätezeilenübergang.");
+    const expected = parseRow(transition.expected); const target = parseRow(transition.target);
+    if (expected.id !== target.id || rowIds.has(expected.id) || expected.manualQuantity !== target.manualQuantity) throw new Error("Ungültige Gerätezeilenidentität.");
+    if (canonical({ ...expected, quantity: 0 }) !== canonical({ ...target, quantity: 0 }) || expected.quantity === target.quantity) throw new Error("Beim Löschen fehlender Objekte darf nur die Gesamtmenge geändert werden.");
+    rowIds.add(expected.id);
+  }
+  if (canonical([...affectedRowIds].sort()) !== canonical([...rowIds].sort())) throw new Error("Die Mengenübergänge der betroffenen Gerätezeilen sind unvollständig.");
+}
+
+function parseObject(value: unknown) { return parseExternalModelStateSnapshot({ source: null, importBatches: [], roomMappings: [], objects: [value] }).objects[0]!; }
+function parseRow(value: unknown) { const envelope = { schemaVersion: circuitDeviceRowStructureCommandSchemaVersion, type: circuitDeviceRowInsertCommandType, payload: { row: value } }; assertCircuitDeviceRowInsertProjectCommand(envelope); return envelope.payload.row; }
+function isRecord(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); }
+function canonical(value: unknown): string { if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`; if (isRecord(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`; return JSON.stringify(value); }
diff --git a/src/domain/ports/external-follow-up-import-project-command.store.ts b/src/domain/ports/external-follow-up-import-project-command.store.ts
new file mode 100644
index 0000000..d39efc9
--- /dev/null
+++ b/src/domain/ports/external-follow-up-import-project-command.store.ts
@@ -0,0 +1,6 @@
+import type { ExternalFollowUpImportProjectCommand } from "../models/external-follow-up-import-project-command.model.js";
+import type { AppendedProjectRevision, ProjectRevisionSource } from "./project-revision.store.js";
+
+export interface ExternalFollowUpImportProjectCommandStore {
+  execute(input: { projectId: string; expectedRevision: number; source: ProjectRevisionSource; description?: string; actorId?: string; historyTargetChangeSetId?: string; command: ExternalFollowUpImportProjectCommand }): { revision: AppendedProjectRevision; inverse: ExternalFollowUpImportProjectCommand };
+}
diff --git a/src/domain/ports/external-object-delete-missing-project-command.store.ts b/src/domain/ports/external-object-delete-missing-project-command.store.ts
new file mode 100644
index 0000000..d6f2e8f
--- /dev/null
+++ b/src/domain/ports/external-object-delete-missing-project-command.store.ts
@@ -0,0 +1,3 @@
+import type { ExternalObjectDeleteMissingProjectCommand } from "../models/external-object-delete-missing-project-command.model.js";
+import type { AppendedProjectRevision, ProjectRevisionSource } from "./project-revision.store.js";
+export interface ExternalObjectDeleteMissingProjectCommandStore { execute(input: { projectId: string; expectedRevision: number; source: ProjectRevisionSource; description?: string; actorId?: string; historyTargetChangeSetId?: string; command: ExternalObjectDeleteMissingProjectCommand }): { revision: AppendedProjectRevision; inverse: ExternalObjectDeleteMissingProjectCommand }; }
diff --git a/src/domain/services/project-command.service.ts b/src/domain/services/project-command.service.ts
index ca99c5f..960ee64 100644
--- a/src/domain/services/project-command.service.ts
+++ b/src/domain/services/project-command.service.ts
@@ -182,8 +182,12 @@ import {
   externalInitialImportCommandType,
 } from "../models/external-initial-import-project-command.model.js";
 import type { ExternalInitialImportProjectCommandStore } from "../ports/external-initial-import-project-command.store.js";
+import { assertExternalFollowUpImportProjectCommand, externalFollowUpImportCommandType } from "../models/external-follow-up-import-project-command.model.js";
+import type { ExternalFollowUpImportProjectCommandStore } from "../ports/external-follow-up-import-project-command.store.js";
 import { assertExternalObjectPlanningUpdateProjectCommand, externalObjectPlanningUpdateCommandType } from "../models/external-object-planning-project-command.model.js";
 import type { ExternalObjectPlanningProjectCommandStore } from "../ports/external-object-planning-project-command.store.js";
+import { assertExternalObjectDeleteMissingProjectCommand, externalObjectDeleteMissingCommandType } from "../models/external-object-delete-missing-project-command.model.js";
+import type { ExternalObjectDeleteMissingProjectCommandStore } from "../ports/external-object-delete-missing-project-command.store.js";
 import {
   assertExternalObjectRowAssignmentProjectCommand,
   externalObjectRowAssignmentCommandType,
@@ -251,7 +255,9 @@ export class ProjectCommandService implements ProjectCommandExecutor {
     private readonly externalObjectNewCircuitStore?: ExternalObjectNewCircuitProjectCommandStore,
     private readonly estimateBalanceStore?: EstimateBalanceProjectCommandStore,
     private readonly externalInitialImportStore?: ExternalInitialImportProjectCommandStore,
-    private readonly externalObjectPlanningStore?: ExternalObjectPlanningProjectCommandStore
+    private readonly externalObjectPlanningStore?: ExternalObjectPlanningProjectCommandStore,
+    private readonly externalFollowUpImportStore?: ExternalFollowUpImportProjectCommandStore,
+    private readonly externalObjectDeleteMissingStore?: ExternalObjectDeleteMissingProjectCommandStore
   ) {}
 
   executeUser(
@@ -650,11 +656,21 @@ export class ProjectCommandService implements ProjectCommandExecutor {
           command: input.command,
         }).revision;
       }
+      case externalFollowUpImportCommandType: {
+        assertExternalFollowUpImportProjectCommand(input.command);
+        if (!this.externalFollowUpImportStore) throw new Error("External follow-up import store is not available.");
+        return this.externalFollowUpImportStore.execute({ ...input, command: input.command }).revision;
+      }
       case externalObjectPlanningUpdateCommandType: {
         assertExternalObjectPlanningUpdateProjectCommand(input.command);
         if (!this.externalObjectPlanningStore) throw new Error("External object planning store is not available.");
         return this.externalObjectPlanningStore.execute({ ...input, command: input.command }).revision;
       }
+      case externalObjectDeleteMissingCommandType: {
+        assertExternalObjectDeleteMissingProjectCommand(input.command);
+        if (!this.externalObjectDeleteMissingStore) throw new Error("External missing-object delete store is not available.");
+        return this.externalObjectDeleteMissingStore.execute({ ...input, command: input.command }).revision;
+      }
       case externalObjectRowAssignmentCommandType: {
         assertExternalObjectRowAssignmentProjectCommand(input.command);
         if (!this.externalObjectRowAssignmentStore) {
diff --git a/src/external-model/application/external-xlsx-follow-up-import.ts b/src/external-model/application/external-xlsx-follow-up-import.ts
new file mode 100644
index 0000000..9e0293a
--- /dev/null
+++ b/src/external-model/application/external-xlsx-follow-up-import.ts
@@ -0,0 +1,120 @@
+import type { ExternalModelConfiguration } from "../configuration/external-model-configuration.js";
+import type { ExternalModelObjectSnapshot, ExternalModelObjectSourceValues, ExternalModelStateSnapshot } from "../domain/external-model-contracts.js";
+import type { ExternalXlsxReturnValues, ExternalXlsxScalar } from "../xlsx/external-xlsx-contracts.js";
+import { createExternalXlsxInitialImportPlan, type ExternalInitialImportCatalogs, type ExternalInitialImportPlan, type ExternalInitialImportProjectedObject } from "./external-xlsx-initial-import.js";
+
+export const externalSourceDecisionFields = ["ifcGuid", "roomNumber", "roomName", "familyAndType", "selectionMarker", "socketCount", "sourceRemark"] as const;
+export type ExternalSourceDecisionField = (typeof externalSourceDecisionFields)[number];
+
+export interface ExternalFollowUpChange {
+  objectId: string;
+  worksharingId: string;
+  familyAndType: string;
+  changedFields: ExternalSourceDecisionField[];
+  previousQuantity: number;
+  suggestedQuantity: number;
+  circuitDeviceRowId: string | null;
+}
+
+export interface ExternalXlsxFollowUpPlan extends ExternalInitialImportPlan {
+  newObjectCount: number;
+  changedObjectCount: number;
+  unchangedObjectCount: number;
+  missingObjectCount: number;
+  returnDeviationCount: number;
+  newObjectWorksharingIds: string[];
+  newSourceRoomKeys: string[];
+  newFamilyAndTypes: string[];
+  changes: ExternalFollowUpChange[];
+  missingObjects: Array<{ objectId: string; worksharingId: string; familyAndType: string; circuitDeviceRowId: string | null }>;
+  returnDeviations: Array<{ objectId: string; worksharingId: string; fields: string[] }>;
+}
+
+export async function createExternalXlsxFollowUpImportPlan(input: {
+  fileName: string;
+  bytes: Uint8Array;
+  configuration: ExternalModelConfiguration;
+  catalogs: ExternalInitialImportCatalogs;
+  currentState: ExternalModelStateSnapshot;
+  currentReturnValuesByObjectId: ReadonlyMap<string, ExternalXlsxReturnValues>;
+}): Promise<{ plan: ExternalXlsxFollowUpPlan; document: Awaited<ReturnType<typeof createExternalXlsxInitialImportPlan>>["document"] }> {
+  if (!input.currentState.source || input.currentState.importBatches.length === 0) throw new Error("Für den Folgeimport fehlt ein bestehender Revit-Import.");
+  const parsed = await createExternalXlsxInitialImportPlan(input);
+  const existingByWorksharingId = new Map(input.currentState.objects.map((object) => [object.worksharingId, object]));
+  const incomingByWorksharingId = new Map(parsed.plan.objects.map((object) => [object.worksharingId, object]));
+  const newObjects: ExternalInitialImportProjectedObject[] = [];
+  const changes: ExternalFollowUpChange[] = [];
+  let unchangedObjectCount = 0;
+  const returnDeviations: ExternalXlsxFollowUpPlan["returnDeviations"] = [];
+
+  for (const incoming of parsed.plan.objects) {
+    const existing = existingByWorksharingId.get(incoming.worksharingId);
+    if (!existing) { newObjects.push(incoming); continue; }
+    const changedFields = changedSourceFields(existing, incoming);
+    if (changedFields.length) {
+      changes.push({
+        objectId: existing.id,
+        worksharingId: existing.worksharingId,
+        familyAndType: incoming.sourceValues.familyAndType,
+        changedFields,
+        previousQuantity: existing.planningValues.effectiveQuantity,
+        suggestedQuantity: incoming.suggestedPlanningValues.effectiveQuantity,
+        circuitDeviceRowId: existing.circuitDeviceRowId,
+      });
+    } else unchangedObjectCount += 1;
+    const returnFields = changedReturnFields(input.currentReturnValuesByObjectId.get(existing.id), incoming.sourceValues);
+    if (returnFields.length) returnDeviations.push({ objectId: existing.id, worksharingId: existing.worksharingId, fields: returnFields });
+  }
+
+  const missingObjects = input.currentState.objects
+    .filter((object) => !incomingByWorksharingId.has(object.worksharingId))
+    .map((object) => ({ objectId: object.id, worksharingId: object.worksharingId, familyAndType: object.acceptedSourceValues.familyAndType, circuitDeviceRowId: object.circuitDeviceRowId }));
+  const existingRoomKeys = new Set(input.currentState.roomMappings.map((mapping) => mapping.normalizedSourceRoomKey));
+  const newSourceRoomKeys = parsed.plan.sourceRooms.map((room) => room.sourceRoomKey).filter((key) => !existingRoomKeys.has(key));
+  const newFamilyAndTypes = [...new Set(newObjects.map((object) => object.sourceValues.familyAndType))].sort((a, b) => a.localeCompare(b, "de"));
+  return {
+    document: parsed.document,
+    plan: {
+      ...parsed.plan,
+      newObjectCount: newObjects.length,
+      changedObjectCount: changes.length,
+      unchangedObjectCount,
+      missingObjectCount: missingObjects.length,
+      returnDeviationCount: returnDeviations.length,
+      newObjectWorksharingIds: newObjects.map((object) => object.worksharingId),
+      newSourceRoomKeys,
+      newFamilyAndTypes,
+      changes,
+      missingObjects,
+      returnDeviations,
+    },
+  };
+}
+
+function changedSourceFields(existing: ExternalModelObjectSnapshot, incoming: ExternalInitialImportProjectedObject) {
+  const fields: ExternalSourceDecisionField[] = [];
+  if (!sameScalar(existing.ifcGuid, incoming.ifcGuid)) fields.push("ifcGuid");
+  for (const field of externalSourceDecisionFields.slice(1) as readonly (keyof ExternalModelObjectSourceValues)[]) {
+    if (!sameScalar(existing.acceptedSourceValues[field], incoming.sourceValues[field])) fields.push(field as ExternalSourceDecisionField);
+  }
+  return fields;
+}
+
+function changedReturnFields(expected: ExternalXlsxReturnValues | undefined, incoming: ExternalModelObjectSourceValues) {
+  if (!expected) return [];
+  const fields = ["circuitCombined", "boardName", "circuitIdentifier", "designation", "electricalPowerW", "voltageV", "currentA"] as const;
+  return fields.filter((field) => !sameScalar(expected[field], incoming[field]));
+}
+
+function sameScalar(left: ExternalXlsxScalar | undefined, right: ExternalXlsxScalar | undefined) {
+  return normalize(left) === normalize(right);
+}
+
+function normalize(value: ExternalXlsxScalar | undefined): string | number | boolean {
+  if (value === null || value === undefined || value === "") return "";
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  const numeric = Number(trimmed.replace(",", "."));
+  return Number.isFinite(numeric) ? numeric : trimmed;
+}
diff --git a/src/external-model/application/external-xlsx-follow-up-target.ts b/src/external-model/application/external-xlsx-follow-up-target.ts
new file mode 100644
index 0000000..db62b52
--- /dev/null
+++ b/src/external-model/application/external-xlsx-follow-up-target.ts
@@ -0,0 +1,138 @@
+import type { CircuitDeviceRowSnapshot } from "../../domain/models/circuit-device-row-structure-project-command.model.js";
+import type { ExternalModelConfiguration } from "../configuration/external-model-configuration.js";
+import type { ExternalModelObjectSnapshot, ExternalModelObjectSourceValues, ExternalModelStateSnapshot } from "../domain/external-model-contracts.js";
+import type { ExternalXlsxDocument } from "../xlsx/external-xlsx-contracts.js";
+import type { ExternalFamilyProjectDeviceDecision, ExternalRoomDecision } from "./external-xlsx-initial-import-target.js";
+import type { ExternalSourceDecisionField, ExternalXlsxFollowUpPlan } from "./external-xlsx-follow-up-import.js";
+
+export interface ExternalSourceChangeDecision { objectId: string; accept: boolean; }
+export interface ExternalRowQuantityTransition { expected: CircuitDeviceRowSnapshot; target: CircuitDeviceRowSnapshot; }
+
+export function buildExternalXlsxFollowUpTarget(input: {
+  projectId: string;
+  expectedRevision: number;
+  importedAtIso: string;
+  configuration: ExternalModelConfiguration;
+  originalContentBase64: string;
+  document: ExternalXlsxDocument;
+  plan: ExternalXlsxFollowUpPlan;
+  currentState: ExternalModelStateSnapshot;
+  sourceChangeDecisions: ExternalSourceChangeDecision[];
+  roomDecisions: ExternalRoomDecision[];
+  familyProjectDeviceDecisions: ExternalFamilyProjectDeviceDecision[];
+  objectsWithoutRoomDefaultDistributionBoardId: string | null;
+  rowsById: ReadonlyMap<string, CircuitDeviceRowSnapshot>;
+  createId: () => string;
+}): { targetState: ExternalModelStateSnapshot; rowTransitions: ExternalRowQuantityTransition[] } {
+  const source = input.currentState.source;
+  if (!source || source.projectId !== input.projectId) throw new Error("Für den Folgeimport fehlt die Revit-Quelle.");
+  const decisions = exactDecisionMap(input.plan.changes.map((change) => change.objectId), input.sourceChangeDecisions, (decision) => decision.objectId, "Quelländerung");
+  const newRoomSet = new Set(input.plan.newSourceRoomKeys);
+  const roomDecisions = exactDecisionMap(input.plan.newSourceRoomKeys, input.roomDecisions, (decision) => decision.sourceRoomKey, "Quellraum");
+  const newFamilySet = new Set(input.plan.newFamilyAndTypes);
+  const familyDecisions = exactDecisionMap(input.plan.newFamilyAndTypes, input.familyProjectDeviceDecisions, (decision) => decision.familyAndType, "Familie und Typ");
+  const batchId = input.createId();
+  const oldMappings = input.currentState.roomMappings.map((mapping) => ({ ...mapping }));
+  const mappingByKey = new Map(oldMappings.map((mapping) => [mapping.normalizedSourceRoomKey, mapping]));
+  const newObjectIds = new Set(input.plan.newObjectWorksharingIds);
+  const neededRoomKeys = new Set(input.plan.objects.filter((object) => newObjectIds.has(object.worksharingId)).map((object) => object.sourceRoomKey).filter((key): key is string => key !== null));
+  for (const change of input.plan.changes) {
+    if (!decisions.get(change.objectId)!.accept || !change.changedFields.some((field) => field === "roomNumber" || field === "roomName")) continue;
+    const key = input.plan.objects.find((object) => object.worksharingId === change.worksharingId)?.sourceRoomKey;
+    if (key) neededRoomKeys.add(key);
+  }
+  for (const room of input.plan.sourceRooms.filter((candidate) => newRoomSet.has(candidate.sourceRoomKey) && neededRoomKeys.has(candidate.sourceRoomKey))) {
+    const decision = roomDecisions.get(room.sourceRoomKey)!;
+    const mapping = { id: input.createId(), projectId: input.projectId, sourceId: source.id, normalizedSourceRoomKey: room.sourceRoomKey, sourceFloorName: null, sourceRoomNumber: room.roomNumber, sourceRoomName: room.roomName, roomId: decision.roomId, defaultDistributionBoardId: decision.defaultDistributionBoardId };
+    oldMappings.push(mapping); mappingByKey.set(mapping.normalizedSourceRoomKey, mapping);
+  }
+  const incomingById = new Map(input.plan.objects.map((object) => [object.worksharingId, object]));
+  const existingByWorksharingId = new Map(input.currentState.objects.map((object) => [object.worksharingId, object]));
+  const changedById = new Map(input.plan.changes.map((change) => [change.objectId, change]));
+  const quantityDeltaByRow = new Map<string, number>();
+  const objects: ExternalModelObjectSnapshot[] = [];
+
+  for (const existing of input.currentState.objects) {
+    const incoming = incomingById.get(existing.worksharingId);
+    if (!incoming) { objects.push({ ...existing, presenceStatus: "missing" }); continue; }
+    const change = changedById.get(existing.id);
+    const accept = change ? decisions.get(existing.id)!.accept : false;
+    if (accept && incoming.issues.some((issue) => issue === "unknown-family-and-type" || issue === "invalid-quantity")) throw new Error("Eine akzeptierte Quelländerung besitzt keine gültige Familien- oder Mengenregel.");
+    const planningValues = { ...existing.planningValues };
+    let deviceTypeId = existing.deviceTypeId;
+    let externalRoomMappingId = existing.externalRoomMappingId;
+    let distributionBoardId = existing.distributionBoardId;
+    let ifcGuid = existing.ifcGuid;
+    if (accept && change) {
+      const fields = new Set<ExternalSourceDecisionField>(change.changedFields);
+      if (fields.has("ifcGuid")) ifcGuid = incoming.ifcGuid;
+      if (fields.has("familyAndType")) {
+        const rule = input.configuration.familyTypeRules.find((candidate) => candidate.exactFamilyAndType === incoming.sourceValues.familyAndType);
+        if (!rule) throw new Error("Eine geänderte Familie ist nicht klassifiziert.");
+        deviceTypeId = rule.deviceTypeId;
+        const type = input.configuration.deviceTypes.find((candidate) => candidate.id === rule.deviceTypeId)!;
+        if (!existing.overriddenFields.includes("category")) planningValues.category = type.category;
+      }
+      if (fields.has("selectionMarker") && !existing.overriddenFields.includes("displayName")) planningValues.displayName = scalarText(incoming.sourceValues.selectionMarker) || incoming.sourceValues.familyAndType;
+      if (fields.has("sourceRemark") && !existing.overriddenFields.includes("remark")) planningValues.remark = scalarText(incoming.sourceValues.sourceRemark) || null;
+      if (fields.has("socketCount") && !existing.overriddenFields.includes("effectiveQuantity")) planningValues.effectiveQuantity = incoming.suggestedPlanningValues.effectiveQuantity;
+      if (fields.has("roomNumber") || fields.has("roomName")) {
+        const oldMapping = existing.externalRoomMappingId ? oldMappings.find((mapping) => mapping.id === existing.externalRoomMappingId) : null;
+        const nextMapping = incoming.sourceRoomKey ? mappingByKey.get(incoming.sourceRoomKey) ?? null : null;
+        externalRoomMappingId = nextMapping?.id ?? null;
+        if (!existing.circuitDeviceRowId && (existing.distributionBoardId === null || existing.distributionBoardId === oldMapping?.defaultDistributionBoardId)) distributionBoardId = nextMapping?.defaultDistributionBoardId ?? input.objectsWithoutRoomDefaultDistributionBoardId;
+      }
+    }
+    if (existing.circuitDeviceRowId && planningValues.effectiveQuantity !== existing.planningValues.effectiveQuantity) {
+      quantityDeltaByRow.set(existing.circuitDeviceRowId, (quantityDeltaByRow.get(existing.circuitDeviceRowId) ?? 0) + planningValues.effectiveQuantity - existing.planningValues.effectiveQuantity);
+    }
+    objects.push({
+      ...existing,
+      ifcGuid, deviceTypeId, externalRoomMappingId, distributionBoardId,
+      lastSeenImportBatchId: batchId,
+      lastAcceptedImportBatchId: change && !accept ? existing.lastAcceptedImportBatchId : batchId,
+      acceptedSourceValues: mergeAcceptedSource(existing.acceptedSourceValues, incoming.sourceValues, accept),
+      planningValues,
+      presenceStatus: "present",
+    });
+  }
+
+  for (const incoming of input.plan.objects.filter((object) => !existingByWorksharingId.has(object.worksharingId))) {
+    if (incoming.issues.some((issue) => issue === "unknown-family-and-type" || issue === "invalid-quantity")) throw new Error("Ein neues Revit-Objekt besitzt keine gültige Familien- oder Mengenregel.");
+    const rule = input.configuration.familyTypeRules.find((candidate) => candidate.exactFamilyAndType === incoming.sourceValues.familyAndType);
+    if (!rule) throw new Error("Eine neue Familie ist nicht klassifiziert.");
+    const mapping = incoming.sourceRoomKey ? mappingByKey.get(incoming.sourceRoomKey) ?? null : null;
+    objects.push({
+      id: input.createId(), projectId: input.projectId, sourceId: source.id, worksharingId: incoming.worksharingId, ifcGuid: incoming.ifcGuid,
+      deviceTypeId: rule.deviceTypeId, lastSeenImportBatchId: batchId, lastAcceptedImportBatchId: batchId,
+      acceptedSourceValues: incoming.sourceValues, planningValues: incoming.suggestedPlanningValues, overriddenFields: [],
+      externalRoomMappingId: mapping?.id ?? null,
+      distributionBoardId: mapping?.defaultDistributionBoardId ?? input.objectsWithoutRoomDefaultDistributionBoardId,
+      linkedProjectDeviceId: newFamilySet.has(incoming.sourceValues.familyAndType) ? familyDecisions.get(incoming.sourceValues.familyAndType)!.projectDeviceId : null,
+      circuitDeviceRowId: null, presenceStatus: "present",
+    });
+  }
+  const rowTransitions = [...quantityDeltaByRow].map(([rowId, delta]) => {
+    const expected = input.rowsById.get(rowId);
+    if (!expected) throw new Error("Eine verknüpfte Gerätezeile wurde nicht gefunden.");
+    return { expected, target: { ...expected, quantity: expected.quantity + delta } };
+  });
+  const previousBatches = input.currentState.importBatches.map((batch) => ({ ...batch, appliedProjectRevision: null, configurationSnapshot: null, originalContentBase64: null, document: null }));
+  return {
+    targetState: {
+      source: { ...source },
+      importBatches: [...previousBatches, { id: batchId, projectId: input.projectId, sourceId: source.id, importKind: "follow_up", importedAtIso: input.importedAtIso, fileName: input.plan.fileName, sha256: input.plan.sha256, objectCount: input.plan.objectCount, appliedProjectRevision: input.expectedRevision + 1, configurationSnapshot: input.configuration, originalContentBase64: input.originalContentBase64, document: input.document }],
+      roomMappings: oldMappings,
+      objects,
+    },
+    rowTransitions,
+  };
+}
+
+const returnFields = new Set<keyof ExternalModelObjectSourceValues>(["rowNumber", "circuitCombined", "boardName", "circuitIdentifier", "designation", "electricalPowerW", "voltageV", "currentA"]);
+function mergeAcceptedSource(previous: ExternalModelObjectSourceValues, incoming: ExternalModelObjectSourceValues, acceptSourceChanges: boolean) {
+  if (acceptSourceChanges) return incoming;
+  return Object.fromEntries(Object.keys(previous).map((key) => [key, returnFields.has(key as keyof ExternalModelObjectSourceValues) ? incoming[key as keyof ExternalModelObjectSourceValues] : previous[key as keyof ExternalModelObjectSourceValues]])) as unknown as ExternalModelObjectSourceValues;
+}
+function scalarText(value: string | number | boolean | null) { return value === null ? "" : String(value).trim(); }
+function exactDecisionMap<T>(expectedKeys: string[], decisions: T[], keyOf: (decision: T) => string, label: string) { const expected = new Set(expectedKeys); const result = new Map<string, T>(); for (const decision of decisions) { const key = keyOf(decision); if (!expected.has(key) || result.has(key)) throw new Error(`${label}-Entscheidungen sind unvollständig oder doppelt.`); result.set(key, decision); } if (result.size !== expected.size) throw new Error(`${label}-Entscheidungen sind unvollständig oder doppelt.`); return result; }
diff --git a/src/frontend/components/revit-follow-up-import-wizard.tsx b/src/frontend/components/revit-follow-up-import-wizard.tsx
new file mode 100644
index 0000000..8b561c5
--- /dev/null
+++ b/src/frontend/components/revit-follow-up-import-wizard.tsx
@@ -0,0 +1,91 @@
+"use client";
+
+import { useState, type FormEvent } from "react";
+import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration";
+import type { ExternalFollowUpImportPlanDto, ProjectHistoryStateDto } from "../types";
+import { applyExternalFollowUpImport, planExternalFollowUpImport } from "../utils/api";
+import { createClientId } from "../utils/client-id";
+import { FormModal } from "./form-modal";
+
+const steps = ["Vorschau", "Quelländerungen", "Neue Räume", "Familienregeln", "Projektgeräte", "Bestätigung"];
+const fieldLabels: Record<string, string> = { ifcGuid: "IfcGUID", roomNumber: "Raumnummer", roomName: "Raumname", familyAndType: "Familie und Typ", selectionMarker: "Auswahlkenner", socketCount: "Anzahl", sourceRemark: "Bemerkung" };
+
+export function RevitFollowUpImportWizard({ projectId, expectedRevision, initialConfiguration, onClose, onImported }: { projectId: string; expectedRevision: number; initialConfiguration: ExternalModelConfiguration; onClose: () => void; onImported: (result: { history: ProjectHistoryStateDto; objectCount: number }) => void }) {
+  const [step, setStep] = useState(0);
+  const [file, setFile] = useState<File | null>(null);
+  const [configuration, setConfiguration] = useState(() => structuredClone(initialConfiguration));
+  const [plan, setPlan] = useState<ExternalFollowUpImportPlanDto | null>(null);
+  const [accepted, setAccepted] = useState<Record<string, boolean>>({});
+  const [roomIds, setRoomIds] = useState<Record<string, string>>({});
+  const [boardIds, setBoardIds] = useState<Record<string, string>>({});
+  const [deviceIds, setDeviceIds] = useState<Record<string, string>>({});
+  const [noRoomBoardId, setNoRoomBoardId] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  async function loadPlan(nextFile: File, nextConfiguration = configuration) {
+    setBusy(true); setError(null);
+    try {
+      const loaded = await planExternalFollowUpImport(projectId, nextFile, nextConfiguration, expectedRevision);
+      setPlan(loaded);
+      setAccepted((current) => Object.fromEntries(loaded.changes.map((change) => [change.objectId, current[change.objectId] ?? true])));
+      setRoomIds((current) => Object.fromEntries(loaded.newSourceRoomKeys.map((key) => { const room = loaded.sourceRooms.find((candidate) => candidate.sourceRoomKey === key)!; return [key, current[key] ?? room.suggestedRoomId ?? ""]; })));
+      setBoardIds((current) => Object.fromEntries(loaded.newSourceRoomKeys.map((key) => [key, current[key] ?? ""])));
+      setDeviceIds((current) => Object.fromEntries(loaded.newFamilyAndTypes.map((family) => [family, current[family] ?? ""])));
+    } catch (value) { setError(value instanceof Error ? value.message : "Folgeimport-Vorschau fehlgeschlagen."); setPlan(null); }
+    finally { setBusy(false); }
+  }
+
+  async function addRule(familyAndType: string, category: "lighting" | "single_phase" | "three_phase", quantityRule: "one" | "socketCount", deviceTypeId?: string) {
+    if (!file) return;
+    const next = structuredClone(configuration);
+    const targetTypeId = deviceTypeId ?? createClientId();
+    if (!deviceTypeId) next.deviceTypes.push({ id: targetTypeId, name: familyAndType, category, defaults: { powerPerUnitW: null, simultaneityFactor: 1, cosPhi: null, costGroup: null } });
+    next.familyTypeRules.push({ id: createClientId(), exactFamilyAndType: familyAndType, deviceTypeId: targetTypeId, quantityRule });
+    setConfiguration(next); await loadPlan(file, next);
+  }
+
+  async function toggleQuantityRule(familyAndType: string) {
+    if (!file) return;
+    const next = structuredClone(configuration);
+    const rule = next.familyTypeRules.find((candidate) => candidate.exactFamilyAndType === familyAndType);
+    if (!rule) return;
+    rule.quantityRule = rule.quantityRule === "one" ? "socketCount" : "one";
+    setConfiguration(next); await loadPlan(file, next);
+  }
+
+  async function submit(event: FormEvent) {
+    event.preventDefault();
+    if (step < steps.length - 1) { setStep(step + 1); return; }
+    if (!file || !plan) return;
+    setBusy(true); setError(null);
+    try {
+      const result = await applyExternalFollowUpImport(projectId, file, {
+        expectedRevision, expectedSha256: plan.sha256, configuration, objectsWithoutRoomDefaultDistributionBoardId: noRoomBoardId || null,
+        sourceChangeDecisions: plan.changes.map((change) => ({ objectId: change.objectId, accept: accepted[change.objectId] ?? false })),
+        roomDecisions: plan.newSourceRoomKeys.map((sourceRoomKey) => ({ sourceRoomKey, roomId: roomIds[sourceRoomKey] || null, defaultDistributionBoardId: boardIds[sourceRoomKey] || null })),
+        familyProjectDeviceDecisions: plan.newFamilyAndTypes.map((familyAndType) => ({ familyAndType, projectDeviceId: deviceIds[familyAndType] || null })),
+      });
+      onImported({ history: result.history, objectCount: result.import.objectCount });
+    } catch (value) { setError(value instanceof Error ? value.message : "Folgeimport fehlgeschlagen."); }
+    finally { setBusy(false); }
+  }
+
+  const relevantUnknownFamilies = plan?.familyGroups.filter((family) => !family.classified && (plan.newFamilyAndTypes.includes(family.familyAndType) || plan.changes.some((change) => accepted[change.objectId] && change.familyAndType === family.familyAndType))) ?? [];
+  const relevantInvalidQuantity = plan?.objects.some((object) => object.issues.includes("invalid-quantity") && (plan.newObjectWorksharingIds.includes(object.worksharingId) || plan.changes.some((change) => change.worksharingId === object.worksharingId && accepted[change.objectId]))) ?? false;
+  const invalidQuantityFamilies = plan ? [...new Set(plan.objects.filter((object) => object.issues.includes("invalid-quantity") && (plan.newObjectWorksharingIds.includes(object.worksharingId) || plan.changes.some((change) => change.worksharingId === object.worksharingId && accepted[change.objectId]))).map((object) => object.sourceValues.familyAndType))] : [];
+  const blocked = !plan || relevantUnknownFamilies.length > 0 || relevantInvalidQuantity;
+  return <FormModal dialogSize="viewport" title="Linear-XLSX-Folgeimport" description={`Schritt ${step + 1} von ${steps.length}: ${steps[step]}`} isSaving={busy} onClose={onClose} onSubmit={(event) => void submit(event)} submitDisabled={blocked} submitLabel={step === steps.length - 1 ? "Folgeimport übernehmen" : "Weiter"}>
+    <div className="d-flex gap-2 flex-wrap mb-3">{steps.map((label, index) => <span className={`badge ${index === step ? "text-bg-primary" : index < step ? "text-bg-success" : "text-bg-secondary"}`} key={label}>{index + 1}. {label}</span>)}</div>
+    {error ? <div className="alert alert-danger">{error}</div> : null}
+    {step === 0 ? <div className="row g-3"><div className="col-12"><label className="form-label" htmlFor="follow-up-xlsx">Vollständige Linear-XLSX-Datei</label><input accept=".xlsx" className="form-control" id="follow-up-xlsx" type="file" onChange={(event) => { const selected = event.target.files?.[0] ?? null; setFile(selected); if (selected) void loadPlan(selected); }} /></div>{plan ? <><Count label="Neu" value={plan.newObjectCount} /><Count label="Geändert" value={plan.changedObjectCount} /><Count label="Unverändert" value={plan.unchangedObjectCount} /><Count label="Fehlend" value={plan.missingObjectCount} /><div className="col-12 text-secondary small">{plan.returnDeviationCount} Objekte enthalten Rückgabefelder, die in Revit noch nicht aktualisiert sind.</div>{plan.warnings.length ? <div className="col-12"><div className="alert alert-warning mb-0">{plan.warnings.map((warning) => <div key={warning}>{warning}</div>)}</div></div> : null}</> : null}</div> : null}
+    {step === 1 && plan ? <div><p className="text-secondary">Nur fachliche Quelländerungen benötigen eine Entscheidung. Abweichende Rückgabefelder werden lediglich als „in Revit noch nicht aktualisiert“ gemeldet.</p>{plan.changes.length ? plan.changes.map((change) => <label className="border rounded p-2 mb-2 d-flex gap-2" key={change.objectId}><input checked={accepted[change.objectId] ?? true} type="checkbox" onChange={(event) => setAccepted({ ...accepted, [change.objectId]: event.target.checked })} /><span><strong>{change.familyAndType}</strong> · {change.worksharingId}<br /><span className="small text-secondary">{change.changedFields.map((field) => fieldLabels[field] ?? field).join(", ")}{change.previousQuantity !== change.suggestedQuantity ? ` · Menge ${change.previousQuantity} → ${change.suggestedQuantity}` : ""}</span></span></label>) : <div className="alert alert-info">Keine fachlichen Quelländerungen.</div>}{plan.missingObjects.length ? <div className="alert alert-warning">{plan.missingObjects.length} fehlende Objekte werden markiert. Links und Mengen bleiben bestehen.</div> : null}</div> : null}
+    {step === 2 && plan ? <div><p className="text-secondary">Nur neue, tatsächlich übernommene Quellräume benötigen eine Zuordnung.</p>{plan.newSourceRoomKeys.map((key) => { const room = plan.sourceRooms.find((candidate) => candidate.sourceRoomKey === key)!; return <div className="row g-2 mb-2" key={key}><div className="col-md-4"><strong>{room.roomNumber || "–"}</strong> {room.roomName}</div><div className="col-md-4"><select className="form-select" value={roomIds[key] ?? ""} onChange={(event) => setRoomIds({ ...roomIds, [key]: event.target.value })}><option value="">Kein Projektraum</option>{plan.existing.rooms.map((candidate) => <option value={candidate.id} key={candidate.id}>{candidate.roomNumber} · {candidate.roomName}</option>)}</select></div><div className="col-md-4"><select className="form-select" value={boardIds[key] ?? ""} onChange={(event) => setBoardIds({ ...boardIds, [key]: event.target.value })}><option value="">Kein Standardverteiler</option>{plan.existing.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></div></div>; })}<label className="form-label">Standardverteiler für neue Objekte ohne Raum<select className="form-select" value={noRoomBoardId} onChange={(event) => setNoRoomBoardId(event.target.value)}><option value="">Kein Standardverteiler</option>{plan.existing.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></label></div> : null}
+    {step === 3 && plan ? <div><p className="text-secondary">Unbekannte Familien müssen nur für neue Objekte oder akzeptierte Familienänderungen klassifiziert werden.</p>{relevantUnknownFamilies.map((family) => <div className="border rounded p-2 mb-2" key={family.familyAndType}><strong>{family.familyAndType}</strong><div className="d-flex gap-2 flex-wrap mt-2">{configuration.deviceTypes.flatMap((type) => [<button className="btn btn-sm btn-outline-secondary" key={`${type.id}-one`} type="button" onClick={() => void addRule(family.familyAndType, type.category, "one", type.id)}>{type.name} · Menge 1</button>, <button className="btn btn-sm btn-outline-secondary" key={`${type.id}-socket`} type="button" onClick={() => void addRule(family.familyAndType, type.category, "socketCount", type.id)}>{type.name} · XLSX-Anzahl</button>])}<button className="btn btn-sm btn-outline-primary" type="button" onClick={() => void addRule(family.familyAndType, "single_phase", "one")}>Neue 1-phasige Geräteart</button><button className="btn btn-sm btn-outline-primary" type="button" onClick={() => void addRule(family.familyAndType, "single_phase", "socketCount")}>Neu · XLSX-Anzahl</button></div></div>)}{!relevantUnknownFamilies.length ? <div className="alert alert-success">Alle benötigten Familien sind klassifiziert.</div> : null}{relevantInvalidQuantity ? <div className="alert alert-danger">Mindestens eine übernommene Mengenangabe ist ungültig.{invalidQuantityFamilies.map((family) => <button className="btn btn-sm btn-outline-danger ms-2" key={family} type="button" onClick={() => void toggleQuantityRule(family)}>Mengenregel für {family} wechseln</button>)}</div> : null}</div> : null}
+    {step === 4 && plan ? <div><p className="text-secondary">Neue Revit-Objekte können familienweise mit einem vorhandenen Projektgerät verknüpft werden.</p>{plan.newFamilyAndTypes.map((family) => <div className="row g-2 align-items-center mb-2" key={family}><div className="col-md-5">{family}</div><div className="col-md-7"><select className="form-select" value={deviceIds[family] ?? ""} onChange={(event) => setDeviceIds({ ...deviceIds, [family]: event.target.value })}><option value="">Kein Projektgerät</option>{plan.existing.projectDevices.map((device) => <option value={device.id} key={device.id}>{device.name} · {device.displayName}</option>)}</select></div></div>)}</div> : null}
+    {step === 5 && plan ? <div className="alert alert-info"><strong>{plan.objectCount} Objekte im vollständigen Import.</strong><br />Neu: {plan.newObjectCount}, fachlich geändert: {plan.changedObjectCount}, fehlend: {plan.missingObjectCount}. Fehlende Objekte werden nicht gelöst oder gelöscht. Apply liest die Datei erneut; Undo und Redo verwenden ausschließlich die gespeicherten Zustände.</div> : null}
+    {step > 0 ? <button className="btn btn-link px-0 mt-3" disabled={busy} onClick={() => setStep(step - 1)} type="button">Zurück</button> : null}
+  </FormModal>;
+}
+
+function Count({ label, value }: { label: string; value: number }) { return <div className="col-6 col-md-3"><strong>{value}</strong><div className="text-secondary small">{label}</div></div>; }
diff --git a/src/frontend/components/revit-object-table.tsx b/src/frontend/components/revit-object-table.tsx
index 2fdee3e..d2a02d0 100644
--- a/src/frontend/components/revit-object-table.tsx
+++ b/src/frontend/components/revit-object-table.tsx
@@ -2,7 +2,7 @@
 
 import { useEffect, useMemo, useState } from "react";
 import type { ExternalProjectObjectsDto, ExternalReturnScopeDto } from "../types";
-import { createExternalReturnWorkbook, getExternalProjectObjects, updateExternalProjectObjects } from "../utils/api";
+import { createExternalReturnWorkbook, deleteMissingExternalProjectObjects, getExternalProjectObjects, updateExternalProjectObjects } from "../utils/api";
 
 const rowHeight = 44;
 const viewportHeight = 520;
@@ -48,7 +48,10 @@ export function RevitObjectTable({ projectId, onRevision }: { projectId: string;
   const first = Math.max(0, Math.floor(scrollTop / rowHeight) - 5);
   const visible = rows.slice(first, first + Math.ceil(viewportHeight / rowHeight) + 10);
   const selectable = rows.filter((object) => object.circuitDeviceRowId === null);
+  const returnSelectable = rows.filter((object) => object.presenceStatus === "present");
   const selectedHasLinkedObject = data?.objects.some((object) => selected.has(object.id) && object.circuitDeviceRowId !== null) ?? false;
+  const selectedMissing = data?.objects.filter((object) => selected.has(object.id) && object.presenceStatus === "missing") ?? [];
+  const selectionContainsPresentObject = data?.objects.some((object) => selected.has(object.id) && object.presenceStatus === "present") ?? false;
 
   async function applyBulk() {
     if (!data || selected.size === 0) return;
@@ -84,12 +87,21 @@ export function RevitObjectTable({ projectId, onRevision }: { projectId: string;
     }
   }
 
+  async function deleteMissing() {
+    if (!data || selectedMissing.length === 0 || selectionContainsPresentObject) return;
+    if (!window.confirm(`${selectedMissing.length} fehlende Revit-Objekte wirklich löschen? Verknüpfte Mengen werden angepasst. Undo stellt Objekte, Links und Mengen wieder her.`)) return;
+    setSaving(true); setError(null);
+    try { const result = await deleteMissingExternalProjectObjects(projectId, data.currentRevision, selectedMissing.map((object) => object.id)); onRevision(result.history.currentRevision); setSelected(new Set()); await load(); }
+    catch (value) { setError(value instanceof Error ? value.message : "Fehlende Revit-Objekte konnten nicht gelöscht werden."); }
+    finally { setSaving(false); }
+  }
+
   if (!data) return <section className="card mt-3"><div className="card-body">Revit-Objekte werden geladen …</div></section>;
   return <section className="card mt-3"><div className="card-body"><div className="d-flex justify-content-between align-items-start gap-3 flex-wrap mb-3"><div><h2 className="h5 mb-1">Revit-Objekte</h2><div className="text-secondary small">{rows.length} von {data.objects.length} · {selected.size} ausgewählt</div></div><div className="d-flex gap-2 flex-wrap"><input aria-label="Revit-Objekte suchen" className="form-control" placeholder="Suchen …" value={search} onChange={(event) => setSearch(event.target.value)} /><select aria-label="Verteiler filtern" className="form-select" value={boardFilter} onChange={(event) => setBoardFilter(event.target.value)}><option value="all">Alle Verteiler</option><option value="none">Ohne Verteiler</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select><select aria-label="Zuordnung filtern" className="form-select" value={assignmentFilter} onChange={(event) => setAssignmentFilter(event.target.value)}><option value="all">Alle Zuordnungen</option><option value="unassigned">Unzugeordnet</option><option value="linked">Mit Gerätezeile</option></select><select aria-label="Sortierung" className="form-select" value={sort} onChange={(event) => setSort(event.target.value as typeof sort)}><option value="family">Familie</option><option value="room">Raum</option><option value="worksharing">Worksharing-ID</option></select></div></div>
     {error ? <div className="alert alert-danger">{error}</div> : null}
     <div className="border rounded p-3 mb-3"><div className="d-flex gap-2 align-items-end flex-wrap"><label className="small">Rückgabeumfang<select aria-label="Rückgabeumfang" className="form-select form-select-sm" value={returnScope} onChange={(event) => setReturnScope(event.target.value as ExternalReturnScopeDto)}><option value="all">Alle Objekte des letzten Imports</option><option value="deviating">Nur geänderte Objekte</option><option value="selected">Nur ausgewählte Objekte</option></select></label><button className="btn btn-sm btn-primary" disabled={exporting || (returnScope === "selected" && selected.size === 0)} type="button" onClick={() => void exportReturnWorkbook()}>{exporting ? "Rückgabe wird erstellt …" : "Rückgabe-Excel herunterladen"}</button></div>{exportMessage ? <div className="alert alert-success mt-3 mb-0">{exportMessage}</div> : null}{exportWarnings.length ? <div className="alert alert-warning mt-3 mb-0"><strong>Hinweise zur Rückgabe:</strong><ul className="mb-0">{exportWarnings.map((warning) => <li key={warning}>{warning}</li>)}</ul></div> : null}</div>
-    <div className="border rounded mb-3" style={{ height: viewportHeight, overflowY: "auto" }} onScroll={(event) => setScrollTop(event.currentTarget.scrollTop)}><div style={{ height: rows.length * rowHeight, position: "relative" }}>{visible.map((object, index) => { const top = (first + index) * rowHeight; const linked = object.circuitDeviceRowId !== null; return <div className="d-grid align-items-center border-bottom px-2" key={object.id} style={{ gridTemplateColumns: "32px minmax(180px,2fr) minmax(120px,1fr) minmax(120px,1fr) minmax(130px,1fr) 100px", height: rowHeight, left: 0, position: "absolute", right: 0, top }}><input aria-label={`${object.familyAndType} auswählen`} checked={selected.has(object.id)} type="checkbox" onChange={() => setSelected((current) => { const next = new Set(current); if (next.has(object.id)) next.delete(object.id); else next.add(object.id); return next; })} /><div className="text-truncate"><strong>{object.planningValues.displayName ?? object.familyAndType}</strong><div className="small text-secondary text-truncate">{object.familyAndType}</div></div><div className="text-truncate">{object.sourceRoomNumber} {object.sourceRoomName}</div><div className="text-truncate">{data.distributionBoards.find((board) => board.id === object.distributionBoardId)?.name ?? "Ohne Verteiler"}</div><div className="text-truncate">{object.selectionMarker || object.worksharingId}</div><span className={`badge ${linked ? "text-bg-success" : "text-bg-secondary"}`}>{linked ? "verknüpft" : "frei"}</span></div>; })}</div></div>
-    <div className="d-flex gap-2 flex-wrap align-items-end"><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(rows.map((object) => object.id)))}>Sichtbare für Rückgabe auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(selectable.map((object) => object.id)))}>Sichtbare freie auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set())}>Auswahl leeren</button><label className="small">Verteiler<select className="form-select form-select-sm" value={bulkBoard} onChange={(event) => setBulkBoard(event.target.value)}><option value="">Unverändert</option><option value="none">Zuordnung lösen</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></label><label className="small">Projektgerät<select className="form-select form-select-sm" value={bulkDevice} onChange={(event) => setBulkDevice(event.target.value)}><option value="">Unverändert</option><option value="none">Verknüpfung lösen</option>{data.projectDevices.map((device) => <option value={device.id} key={device.id}>{device.name}</option>)}</select></label><label className="small">Leistung [W]<input className="form-control form-control-sm" inputMode="decimal" value={power} onChange={(event) => setPower(event.target.value)} /></label><label className="small">GZF<input className="form-control form-control-sm" inputMode="decimal" value={gzf} onChange={(event) => setGzf(event.target.value)} /></label><label className="small">Weiterer Planungswert<select className="form-select form-select-sm" value={planningField} onChange={(event) => setPlanningField(event.target.value)}><option value="">Unverändert</option><option value="displayName">Anzeigename</option><option value="category">Kategorie (lighting/single_phase/three_phase)</option><option value="connectionKind">Anschlussart</option><option value="effectiveQuantity">Wirksame Menge</option><option value="cosPhi">cosPhi</option><option value="costGroup">Kostengruppe</option><option value="remark">Bemerkung</option></select></label>{planningField ? <label className="small">Neuer Wert<input className="form-control form-control-sm" value={planningValue} onChange={(event) => setPlanningValue(event.target.value)} /></label> : null}<button className="btn btn-sm btn-primary" disabled={saving || selected.size === 0 || selectedHasLinkedObject} title={selectedHasLinkedObject ? "Sammeländerungen sind nur für freie Revit-Objekte möglich." : undefined} type="button" onClick={() => void applyBulk()}>{saving ? "Wird gespeichert …" : "Sammeländerung anwenden"}</button></div>
+    <div className="border rounded mb-3" style={{ height: viewportHeight, overflowY: "auto" }} onScroll={(event) => setScrollTop(event.currentTarget.scrollTop)}><div style={{ height: rows.length * rowHeight, position: "relative" }}>{visible.map((object, index) => { const top = (first + index) * rowHeight; const linked = object.circuitDeviceRowId !== null; const missing = object.presenceStatus === "missing"; return <div className="d-grid align-items-center border-bottom px-2" key={object.id} style={{ gridTemplateColumns: "32px minmax(180px,2fr) minmax(120px,1fr) minmax(120px,1fr) minmax(130px,1fr) 100px", height: rowHeight, left: 0, position: "absolute", right: 0, top }}><input aria-label={`${object.familyAndType} auswählen`} checked={selected.has(object.id)} type="checkbox" onChange={() => setSelected((current) => { const next = new Set(current); if (next.has(object.id)) next.delete(object.id); else next.add(object.id); return next; })} /><div className="text-truncate"><strong>{object.planningValues.displayName ?? object.familyAndType}</strong><div className="small text-secondary text-truncate">{object.familyAndType}</div></div><div className="text-truncate">{object.sourceRoomNumber} {object.sourceRoomName}</div><div className="text-truncate">{data.distributionBoards.find((board) => board.id === object.distributionBoardId)?.name ?? "Ohne Verteiler"}</div><div className="text-truncate">{object.selectionMarker || object.worksharingId}</div><span className={`badge ${missing ? "text-bg-warning" : linked ? "text-bg-success" : "text-bg-secondary"}`}>{missing ? "fehlend" : linked ? "verknüpft" : "frei"}</span></div>; })}</div></div>
+    <div className="d-flex gap-2 flex-wrap align-items-end"><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(returnSelectable.map((object) => object.id)))}>Sichtbare für Rückgabe auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set(selectable.map((object) => object.id)))}>Sichtbare freie auswählen</button><button className="btn btn-sm btn-outline-secondary" type="button" onClick={() => setSelected(new Set())}>Auswahl leeren</button><button className="btn btn-sm btn-danger" disabled={saving || selectedMissing.length === 0 || selectionContainsPresentObject} type="button" onClick={() => void deleteMissing()}>Ausgewählte fehlende löschen</button><label className="small">Verteiler<select className="form-select form-select-sm" value={bulkBoard} onChange={(event) => setBulkBoard(event.target.value)}><option value="">Unverändert</option><option value="none">Zuordnung lösen</option>{data.distributionBoards.map((board) => <option value={board.id} key={board.id}>{board.name}</option>)}</select></label><label className="small">Projektgerät<select className="form-select form-select-sm" value={bulkDevice} onChange={(event) => setBulkDevice(event.target.value)}><option value="">Unverändert</option><option value="none">Verknüpfung lösen</option>{data.projectDevices.map((device) => <option value={device.id} key={device.id}>{device.name}</option>)}</select></label><label className="small">Leistung [W]<input className="form-control form-control-sm" inputMode="decimal" value={power} onChange={(event) => setPower(event.target.value)} /></label><label className="small">GZF<input className="form-control form-control-sm" inputMode="decimal" value={gzf} onChange={(event) => setGzf(event.target.value)} /></label><label className="small">Weiterer Planungswert<select className="form-select form-select-sm" value={planningField} onChange={(event) => setPlanningField(event.target.value)}><option value="">Unverändert</option><option value="displayName">Anzeigename</option><option value="category">Kategorie (lighting/single_phase/three_phase)</option><option value="connectionKind">Anschlussart</option><option value="effectiveQuantity">Wirksame Menge</option><option value="cosPhi">cosPhi</option><option value="costGroup">Kostengruppe</option><option value="remark">Bemerkung</option></select></label>{planningField ? <label className="small">Neuer Wert<input className="form-control form-control-sm" value={planningValue} onChange={(event) => setPlanningValue(event.target.value)} /></label> : null}<button className="btn btn-sm btn-primary" disabled={saving || selected.size === 0 || selectedHasLinkedObject} title={selectedHasLinkedObject ? "Sammeländerungen sind nur für freie Revit-Objekte möglich." : undefined} type="button" onClick={() => void applyBulk()}>{saving ? "Wird gespeichert …" : "Sammeländerung anwenden"}</button></div>
   </div></section>;
 }
 
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index a4239b1..78b8227 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -99,6 +99,7 @@ export interface ExternalInitialImportStatusDto {
   imported: boolean;
   sourceName: string | null;
   objectCount: number;
+  missingObjectCount: number;
   importedAtIso: string | null;
   fileName: string | null;
 }
@@ -111,6 +112,34 @@ export interface ExternalInitialImportResultDto extends ProjectCommandResultDto
   };
 }
 
+export interface ExternalFollowUpImportPlanDto extends ExternalInitialImportPlanDto {
+  newObjectCount: number;
+  changedObjectCount: number;
+  unchangedObjectCount: number;
+  missingObjectCount: number;
+  returnDeviationCount: number;
+  newObjectWorksharingIds: string[];
+  newSourceRoomKeys: string[];
+  newFamilyAndTypes: string[];
+  changes: Array<{ objectId: string; worksharingId: string; familyAndType: string; changedFields: string[]; previousQuantity: number; suggestedQuantity: number; circuitDeviceRowId: string | null }>;
+  missingObjects: Array<{ objectId: string; worksharingId: string; familyAndType: string; circuitDeviceRowId: string | null }>;
+  returnDeviations: Array<{ objectId: string; worksharingId: string; fields: string[] }>;
+}
+
+export interface ApplyExternalFollowUpImportInput {
+  expectedRevision: number;
+  expectedSha256: string;
+  configuration: ExternalModelConfiguration;
+  objectsWithoutRoomDefaultDistributionBoardId: string | null;
+  sourceChangeDecisions: Array<{ objectId: string; accept: boolean }>;
+  roomDecisions: Array<{ sourceRoomKey: string; roomId: string | null; defaultDistributionBoardId: string | null }>;
+  familyProjectDeviceDecisions: Array<{ familyAndType: string; projectDeviceId: string | null }>;
+}
+
+export interface ExternalFollowUpImportResultDto extends ProjectCommandResultDto {
+  import: { importBatchId: string; objectCount: number; newObjectCount: number; changedObjectCount: number; missingObjectCount: number };
+}
+
 export interface ExternalProjectObjectDto {
   id: string; worksharingId: string; ifcGuid: string | null; deviceTypeId: string;
   familyAndType: string; selectionMarker: string; sourceCircuitIdentifier: string;
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index c873ef3..a793a95 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -41,6 +41,9 @@ import type {
   ExternalModelConfigurationSnapshotDto,
   ExternalInitialImportPlanDto,
   ExternalInitialImportResultDto,
+  ExternalFollowUpImportPlanDto,
+  ExternalFollowUpImportResultDto,
+  ApplyExternalFollowUpImportInput,
   ExternalInitialImportStatusDto,
   ApplyExternalInitialImportInput,
   ExternalProjectObjectsDto,
@@ -232,6 +235,18 @@ export async function applyExternalInitialImport(
   });
 }
 
+export async function planExternalFollowUpImport(projectId: string, file: File, configuration: ExternalModelConfiguration, expectedRevision: number) {
+  return request<ExternalFollowUpImportPlanDto>(`/api/projects/${projectId}/external-model/follow-up-import/plan`, {
+    method: "POST", body: JSON.stringify({ fileName: file.name, contentBase64: await fileToBase64(file), configuration, expectedRevision }),
+  });
+}
+
+export async function applyExternalFollowUpImport(projectId: string, file: File, input: ApplyExternalFollowUpImportInput) {
+  return request<ExternalFollowUpImportResultDto>(`/api/projects/${projectId}/external-model/follow-up-import/apply`, {
+    method: "POST", body: JSON.stringify({ ...input, fileName: file.name, contentBase64: await fileToBase64(file) }),
+  });
+}
+
 async function fileToBase64(file: File) {
   const bytes = new Uint8Array(await file.arrayBuffer());
   let binary = "";
@@ -247,6 +262,10 @@ export function updateExternalProjectObjects(projectId: string, expectedRevision
   return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects`, { method: "PUT", body: JSON.stringify({ expectedRevision, objectIds, patch }) });
 }
 
+export function deleteMissingExternalProjectObjects(projectId: string, expectedRevision: number, objectIds: string[]) {
+  return request<ProjectCommandResultDto>(`/api/projects/${projectId}/external-model/objects/delete-missing`, { method: "POST", body: JSON.stringify({ expectedRevision, objectIds, confirmed: true }) });
+}
+
 export function createExternalReturnWorkbook(
   projectId: string,
   expectedRevision: number,
diff --git a/src/server/composition/project-command-stores.ts b/src/server/composition/project-command-stores.ts
index 669e25d..e2cc30a 100644
--- a/src/server/composition/project-command-stores.ts
+++ b/src/server/composition/project-command-stores.ts
@@ -24,7 +24,9 @@ import { ProjectStateRestoreCommandRepository } from "../../db/repositories/proj
 import { ProjectCommandService } from "../../domain/services/project-command.service.js";
 import { ExternalModelConfigurationProjectCommandRepository } from "../../db/repositories/external-model-configuration-project-command.repository.js";
 import { ExternalInitialImportProjectCommandRepository } from "../../db/repositories/external-initial-import-project-command.repository.js";
+import { ExternalFollowUpImportProjectCommandRepository } from "../../db/repositories/external-follow-up-import-project-command.repository.js";
 import { ExternalObjectPlanningProjectCommandRepository } from "../../db/repositories/external-object-planning-project-command.repository.js";
+import { ExternalObjectDeleteMissingProjectCommandRepository } from "../../db/repositories/external-object-delete-missing-project-command.repository.js";
 import { ExternalObjectRowAssignmentProjectCommandRepository } from "../../db/repositories/external-object-row-assignment-project-command.repository.js";
 import { ExternalObjectNewRowProjectCommandRepository } from "../../db/repositories/external-object-new-row-project-command.repository.js";
 import { ExternalObjectNewCircuitProjectCommandRepository } from "../../db/repositories/external-object-new-circuit-project-command.repository.js";
@@ -76,8 +78,12 @@ export const externalModelConfigurationProjectCommandStore =
   new ExternalModelConfigurationProjectCommandRepository(db);
 export const externalInitialImportProjectCommandStore =
   new ExternalInitialImportProjectCommandRepository(db);
+export const externalFollowUpImportProjectCommandStore =
+  new ExternalFollowUpImportProjectCommandRepository(db);
 export const externalObjectPlanningProjectCommandStore =
   new ExternalObjectPlanningProjectCommandRepository(db);
+export const externalObjectDeleteMissingProjectCommandStore =
+  new ExternalObjectDeleteMissingProjectCommandRepository(db);
 export const externalObjectRowAssignmentProjectCommandStore =
   new ExternalObjectRowAssignmentProjectCommandRepository(db);
 export const externalObjectNewRowProjectCommandStore =
@@ -115,5 +121,7 @@ export const projectCommandService = new ProjectCommandService(
   externalObjectNewCircuitProjectCommandStore,
   estimateBalanceProjectCommandStore,
   externalInitialImportProjectCommandStore,
-  externalObjectPlanningProjectCommandStore
+  externalObjectPlanningProjectCommandStore,
+  externalFollowUpImportProjectCommandStore,
+  externalObjectDeleteMissingProjectCommandStore
 );
diff --git a/src/server/controllers/external-follow-up-import.controller.ts b/src/server/controllers/external-follow-up-import.controller.ts
new file mode 100644
index 0000000..8e70c5b
--- /dev/null
+++ b/src/server/controllers/external-follow-up-import.controller.ts
@@ -0,0 +1,83 @@
+import { randomUUID } from "node:crypto";
+import type { Request, Response } from "express";
+import type { CircuitDeviceRowSnapshot } from "../../domain/models/circuit-device-row-structure-project-command.model.js";
+import { createExternalFollowUpImportProjectCommand } from "../../domain/models/external-follow-up-import-project-command.model.js";
+import { createExternalXlsxFollowUpImportPlan } from "../../external-model/application/external-xlsx-follow-up-import.js";
+import { buildExternalXlsxFollowUpTarget } from "../../external-model/application/external-xlsx-follow-up-target.js";
+import { projectExternalXlsxReturn, type ExternalReturnRowContext } from "../../external-model/application/external-xlsx-return-projection.js";
+import { assertExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
+import { distributionBoardRepository, externalModelConfigurationRepository, externalModelStateRepository, floorRepository, projectDeviceRepository, projectRepository, roomRepository } from "../composition/application-repositories.js";
+import { projectCommandService } from "../composition/project-command-stores.js";
+import { buildProjectCircuitTrees } from "./circuit-tree.controller.js";
+import { respondWithProjectCommandError } from "./project-command.controller.js";
+
+export async function planExternalFollowUpImport(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const context = await loadContext(projectId, expectedRevision, req.body?.configuration);
+    const { plan } = await createExternalXlsxFollowUpImportPlan({
+      fileName: requiredString(req.body?.fileName, "Dateiname"), bytes: decodeBase64(req.body?.contentBase64), configuration: context.configuration,
+      catalogs: await loadCatalogs(projectId), currentState: context.state, currentReturnValuesByObjectId: context.returnValues,
+    });
+    return res.json(plan);
+  } catch (error) { return res.status(400).json({ error: error instanceof Error ? error.message : "Folgeimport-Vorschau fehlgeschlagen." }); }
+}
+
+export async function applyExternalFollowUpImport(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const context = await loadContext(projectId, expectedRevision, req.body?.configuration);
+    const bytes = decodeBase64(req.body?.contentBase64);
+    const { plan, document } = await createExternalXlsxFollowUpImportPlan({
+      fileName: requiredString(req.body?.fileName, "Dateiname"), bytes, configuration: context.configuration,
+      catalogs: await loadCatalogs(projectId), currentState: context.state, currentReturnValuesByObjectId: context.returnValues,
+    });
+    if (plan.sha256 !== req.body?.expectedSha256) return res.status(409).json({ error: "Die XLSX-Datei stimmt nicht mehr mit der geprüften Vorschau überein.", code: "EXTERNAL_XLSX_FILE_CHANGED" });
+    const built = buildExternalXlsxFollowUpTarget({
+      projectId, expectedRevision, importedAtIso: new Date().toISOString(), configuration: context.configuration,
+      originalContentBase64: String(req.body.contentBase64), document, plan, currentState: context.state,
+      sourceChangeDecisions: requireArray(req.body?.sourceChangeDecisions, "Quelländerungsentscheidungen"),
+      roomDecisions: requireArray(req.body?.roomDecisions, "Raumentscheidungen"),
+      familyProjectDeviceDecisions: requireArray(req.body?.familyProjectDeviceDecisions, "ProjectDevice-Entscheidungen"),
+      objectsWithoutRoomDefaultDistributionBoardId: nullableString(req.body?.objectsWithoutRoomDefaultDistributionBoardId, "Standardverteiler ohne Raum"),
+      rowsById: context.rowsById, createId: randomUUID,
+    });
+    const targetConfiguration = { ...context.configurationSnapshot, configuration: context.configuration };
+    const result = projectCommandService.executeUser({
+      projectId, expectedRevision, description: `Revit-Folgeimport ${plan.fileName}`,
+      command: createExternalFollowUpImportProjectCommand({ expectedConfiguration: context.configurationSnapshot, targetConfiguration, expectedState: context.state, targetState: built.targetState, rows: built.rowTransitions }),
+    });
+    return res.status(201).json({ ...result, import: { importBatchId: built.targetState.importBatches.at(-1)!.id, objectCount: plan.objectCount, newObjectCount: plan.newObjectCount, changedObjectCount: plan.changedObjectCount, missingObjectCount: plan.missingObjectCount } });
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+async function loadContext(projectId: string, expectedRevision: number, configurationValue: unknown) {
+  const [project, treeResult] = await Promise.all([projectRepository.findById(projectId), buildProjectCircuitTrees(projectId)]);
+  if (!project || !treeResult) throw new Error("Projekt nicht gefunden.");
+  if (project.currentRevision !== expectedRevision || treeResult.currentRevision !== expectedRevision) throw new Error("Der Folgeimportplan ist wegen einer neueren Projektrevision ungültig.");
+  const stored = externalModelConfigurationRepository.getByProject(projectId);
+  if (!stored.configuration) throw new Error("Für das Projekt ist keine Revit-XLSX-Konfiguration gespeichert.");
+  assertExternalModelConfiguration(configurationValue);
+  const stateResult = externalModelStateRepository.getByProject(projectId);
+  if (!stateResult.state.source) throw new Error("Für den Folgeimport fehlt ein bestehender Revit-Import.");
+  const rowContexts = createRowContexts(treeResult);
+  const returnValues = new Map(stateResult.state.objects.map((object) => [object.id, projectExternalXlsxReturn({ object, row: object.circuitDeviceRowId ? rowContexts.get(object.circuitDeviceRowId)?.returnContext ?? null : null, circuitMode: configurationValue.circuitMode, singlePhaseVoltageV: project.singlePhaseVoltageV, threePhaseVoltageV: project.threePhaseVoltageV }).values]));
+  return { configuration: configurationValue, configurationSnapshot: stored.configuration, state: stateResult.state, returnValues, rowsById: new Map([...rowContexts].map(([id, value]) => [id, value.snapshot])) };
+}
+
+function createRowContexts(treeResult: NonNullable<Awaited<ReturnType<typeof buildProjectCircuitTrees>>>) {
+  const result = new Map<string, { returnContext: ExternalReturnRowContext; snapshot: CircuitDeviceRowSnapshot }>();
+  for (const tree of treeResult.trees) for (const section of tree.sections) for (const circuit of section.circuits) for (const row of circuit.deviceRows) result.set(row.id, {
+    returnContext: { rowId: row.id, displayName: row.displayName, powerPerUnitKw: row.powerPerUnit, cosPhi: row.cosPhi ?? null, phaseType: row.phaseType ?? null, category: section.category ?? null, circuitIdentifier: circuit.equipmentIdentifier, circuitVoltageV: circuit.voltage ?? null, distributionBoardName: tree.distributionBoardName },
+    snapshot: { id: row.id, circuitId: circuit.id, linkedProjectDeviceId: row.linkedProjectDeviceId ?? null, sortOrder: row.sortOrder, name: row.name, displayName: row.displayName, phaseType: row.phaseType ?? null, connectionKind: row.connectionKind ?? null, costGroup: row.costGroup ?? null, category: row.category ?? null, level: row.level ?? null, roomId: row.roomId ?? null, roomNumberSnapshot: row.roomNumberSnapshot ?? null, roomNameSnapshot: row.roomNameSnapshot ?? null, quantity: row.quantity, manualQuantity: row.manualQuantity, powerPerUnit: row.powerPerUnit, simultaneityFactor: row.simultaneityFactor, cosPhi: row.cosPhi ?? null, remark: row.remark ?? null, overriddenFields: row.overriddenFields ?? null },
+  });
+  return result;
+}
+async function loadCatalogs(projectId: string) { const [floors, rooms, distributionBoards, projectDevices] = await Promise.all([floorRepository.listByProject(projectId), roomRepository.listByProject(projectId), distributionBoardRepository.listByProject(projectId), projectDeviceRepository.listByProject(projectId)]); return { floors, rooms, distributionBoards, projectDevices }; }
+function parseExpectedRevision(value: unknown) { if (!Number.isSafeInteger(value) || (value as number) < 0) throw new Error("Ungültige Projektrevision."); return value as number; }
+function decodeBase64(value: unknown) { if (typeof value !== "string" || !/^[A-Za-z0-9+/]*={0,2}$/.test(value) || value.length % 4 !== 0) throw new Error("XLSX-Inhalt ist nicht gültig Base64-kodiert."); const bytes = Buffer.from(value, "base64"); if (bytes.toString("base64") !== value) throw new Error("XLSX-Inhalt ist nicht kanonisch Base64-kodiert."); return bytes; }
+function requiredString(value: unknown, label: string) { if (typeof value !== "string" || !value.trim()) throw new Error(`${label} fehlt.`); return value.trim(); }
+function nullableString(value: unknown, label: string) { if (value === null || value === undefined || value === "") return null; if (typeof value !== "string") throw new Error(`${label} ist ungültig.`); return value; }
+function requireArray<T>(value: unknown, label: string): T[] { if (!Array.isArray(value)) throw new Error(`${label} fehlen.`); return value as T[]; }
diff --git a/src/server/controllers/external-initial-import.controller.ts b/src/server/controllers/external-initial-import.controller.ts
index 53227f4..25eb284 100644
--- a/src/server/controllers/external-initial-import.controller.ts
+++ b/src/server/controllers/external-initial-import.controller.ts
@@ -13,7 +13,7 @@ export function getExternalInitialImportStatus(req: Request, res: Response) {
   const result = externalModelStateRepository.getByProject(projectId);
   if (!result.projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
   const batch = result.state.importBatches.at(-1) ?? null;
-  return res.json({ imported: result.state.source !== null, sourceName: result.state.source?.name ?? null, objectCount: result.state.objects.length, importedAtIso: batch?.importedAtIso ?? null, fileName: batch?.fileName ?? null });
+  return res.json({ imported: result.state.source !== null, sourceName: result.state.source?.name ?? null, objectCount: batch?.objectCount ?? result.state.objects.length, missingObjectCount: result.state.objects.filter((object) => object.presenceStatus === "missing").length, importedAtIso: batch?.importedAtIso ?? null, fileName: batch?.fileName ?? null });
 }
 
 export async function planExternalInitialImport(req: Request, res: Response) {
diff --git a/src/server/controllers/external-objects.controller.ts b/src/server/controllers/external-objects.controller.ts
index 8e90673..a381faa 100644
--- a/src/server/controllers/external-objects.controller.ts
+++ b/src/server/controllers/external-objects.controller.ts
@@ -1,6 +1,7 @@
 import type { Request, Response } from "express";
 import { randomUUID } from "node:crypto";
 import { createExternalObjectPlanningUpdateProjectCommand } from "../../domain/models/external-object-planning-project-command.model.js";
+import { createExternalObjectDeleteMissingProjectCommand } from "../../domain/models/external-object-delete-missing-project-command.model.js";
 import { createExternalObjectRowAssignmentProjectCommand } from "../../domain/models/external-object-row-assignment-project-command.model.js";
 import type { CircuitDeviceRowSnapshot } from "../../domain/models/circuit-device-row-structure-project-command.model.js";
 import type { ExternalModelObjectPlanningValues } from "../../external-model/domain/external-model-contracts.js";
@@ -57,6 +58,39 @@ export function updateExternalObjects(req: Request, res: Response) {
   } catch (error) { return respondWithProjectCommandError(error, res); }
 }
 
+export async function deleteMissingExternalObjects(req: Request, res: Response) {
+  const projectId = String(req.params.projectId ?? "");
+  try {
+    const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+    const objectIds = parseObjectIds(req.body?.objectIds);
+    if (req.body?.confirmed !== true) throw new Error("Das Löschen fehlender Revit-Objekte muss bestätigt werden.");
+    const { state, projectExists } = externalModelStateRepository.getByProject(projectId);
+    if (!projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+    const byId = new Map(state.objects.map((object) => [object.id, object]));
+    const selected = objectIds.map((id) => {
+      const object = byId.get(id);
+      if (!object || object.presenceStatus !== "missing") throw new Error("Nur im letzten Import fehlende Revit-Objekte dürfen gelöscht werden.");
+      return object;
+    });
+    const treeResult = await buildProjectCircuitTrees(projectId);
+    const quantitiesByRowId = new Map<string, number>();
+    for (const object of selected) if (object.circuitDeviceRowId) quantitiesByRowId.set(object.circuitDeviceRowId, (quantitiesByRowId.get(object.circuitDeviceRowId) ?? 0) + object.planningValues.effectiveQuantity);
+    const rows = [...quantitiesByRowId].map(([rowId, removedQuantity]) => {
+      const location = findRow(treeResult, rowId);
+      if (!location) throw new Error("Eine verknüpfte Gerätezeile wurde nicht gefunden.");
+      const expected = toRowSnapshot(location.row, location.circuitId);
+      return { expected, target: { ...expected, quantity: expected.quantity - removedQuantity } };
+    });
+    const result = projectCommandService.executeUser({
+      projectId,
+      expectedRevision,
+      description: `${selected.length} fehlende Revit-Objekte gelöscht`,
+      command: createExternalObjectDeleteMissingProjectCommand({ objects: selected.map((expected) => ({ expected, target: null })), rows }),
+    });
+    return res.json(result);
+  } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
 export async function assignExternalObjectsToRow(req: Request, res: Response) {
   const projectId = String(req.params.projectId ?? "");
   try {
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index 436ff52..5d83ee0 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -63,8 +63,9 @@ import {
   getExternalInitialImportStatus,
   planExternalInitialImport,
 } from "../controllers/external-initial-import.controller.js";
-import { assignExternalObjectsToNewCircuit, assignExternalObjectsToNewRow, assignExternalObjectsToRow, detachExternalObjectsFromRow, listExternalObjects, updateExternalObjects } from "../controllers/external-objects.controller.js";
+import { assignExternalObjectsToNewCircuit, assignExternalObjectsToNewRow, assignExternalObjectsToRow, deleteMissingExternalObjects, detachExternalObjectsFromRow, listExternalObjects, updateExternalObjects } from "../controllers/external-objects.controller.js";
 import { createExternalReturnWorkbook, listExternalExportBatches } from "../controllers/external-return-workbook.controller.js";
+import { applyExternalFollowUpImport, planExternalFollowUpImport } from "../controllers/external-follow-up-import.controller.js";
 
 export const projectRouter = Router();
 
@@ -92,8 +93,11 @@ projectRouter.post("/:projectId/external-model/configuration/detect", detectExte
 projectRouter.get("/:projectId/external-model/import-status", getExternalInitialImportStatus);
 projectRouter.post("/:projectId/external-model/initial-import/plan", planExternalInitialImport);
 projectRouter.post("/:projectId/external-model/initial-import/apply", applyExternalInitialImport);
+projectRouter.post("/:projectId/external-model/follow-up-import/plan", planExternalFollowUpImport);
+projectRouter.post("/:projectId/external-model/follow-up-import/apply", applyExternalFollowUpImport);
 projectRouter.get("/:projectId/external-model/objects", listExternalObjects);
 projectRouter.put("/:projectId/external-model/objects", updateExternalObjects);
+projectRouter.post("/:projectId/external-model/objects/delete-missing", deleteMissingExternalObjects);
 projectRouter.post("/:projectId/external-model/objects/assign-row", assignExternalObjectsToRow);
 projectRouter.post("/:projectId/external-model/objects/assign-new-row", assignExternalObjectsToNewRow);
 projectRouter.post("/:projectId/external-model/objects/assign-new-circuit", assignExternalObjectsToNewCircuit);
diff --git a/tests/external-follow-up-import-project-command.repository.test.ts b/tests/external-follow-up-import-project-command.repository.test.ts
new file mode 100644
index 0000000..8d4acf4
--- /dev/null
+++ b/tests/external-follow-up-import-project-command.repository.test.ts
@@ -0,0 +1,98 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import ExcelJS from "exceljs";
+import { eq } from "drizzle-orm";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { ExternalFollowUpImportProjectCommandRepository } from "../src/db/repositories/external-follow-up-import-project-command.repository.js";
+import { ExternalInitialImportProjectCommandRepository } from "../src/db/repositories/external-initial-import-project-command.repository.js";
+import { ExternalModelStateRepository } from "../src/db/repositories/external-model-state.repository.js";
+import { toCircuitDeviceRowSnapshot } from "../src/db/repositories/circuit-device-row-structure.persistence.js";
+import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
+import { circuitLists } from "../src/db/schema/circuit-lists.js";
+import { circuitSections } from "../src/db/schema/circuit-sections.js";
+import { circuits } from "../src/db/schema/circuits.js";
+import { distributionBoards } from "../src/db/schema/distribution-boards.js";
+import { externalModelConfigurations } from "../src/db/schema/external-model-configurations.js";
+import { externalModelObjects } from "../src/db/schema/external-model-objects.js";
+import { projects } from "../src/db/schema/projects.js";
+import { createExternalFollowUpImportProjectCommand } from "../src/domain/models/external-follow-up-import-project-command.model.js";
+import { createExternalObjectDeleteMissingProjectCommand } from "../src/domain/models/external-object-delete-missing-project-command.model.js";
+import { ExternalObjectDeleteMissingProjectCommandRepository } from "../src/db/repositories/external-object-delete-missing-project-command.repository.js";
+import { createEmptyExternalModelState, createExternalInitialImportProjectCommand } from "../src/domain/models/external-initial-import-project-command.model.js";
+import { createExternalXlsxFollowUpImportPlan } from "../src/external-model/application/external-xlsx-follow-up-import.js";
+import { buildExternalXlsxFollowUpTarget } from "../src/external-model/application/external-xlsx-follow-up-target.js";
+import { createExternalXlsxInitialImportPlan } from "../src/external-model/application/external-xlsx-initial-import.js";
+import { buildExternalXlsxInitialImportTarget } from "../src/external-model/application/external-xlsx-initial-import-target.js";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
+import { createRevitXlsxFixture, externalXlsxTestConfiguration, firstWorksharingId } from "./fixtures/revit-xlsx-fixtures.js";
+
+const deviceTypeA = "10000000-0000-4000-8000-000000000001";
+const deviceTypeB = "10000000-0000-4000-8000-000000000002";
+const configuration = { ...createDefaultExternalModelConfiguration(), ...externalXlsxTestConfiguration, deviceTypes: [{ id: deviceTypeA, name: "Steckdose", category: "single_phase" as const, defaults: { powerPerUnitW: null, simultaneityFactor: 1, cosPhi: 0.9, costGroup: null } }, { id: deviceTypeB, name: "Leuchte", category: "lighting" as const, defaults: { powerPerUnitW: 40, simultaneityFactor: 1, cosPhi: null, costGroup: null } }], familyTypeRules: [{ id: "20000000-0000-4000-8000-000000000001", exactFamilyAndType: "Steckdose: Standard", deviceTypeId: deviceTypeA, quantityRule: "socketCount" as const }, { id: "20000000-0000-4000-8000-000000000002", exactFamilyAndType: "Leuchte: Decke", deviceTypeId: deviceTypeB, quantityRule: "one" as const }] };
+const catalogs = { floors: [], rooms: [], distributionBoards: [], projectDevices: [] };
+
+describe("external follow-up import project command", () => {
+  it("commits object and row quantities atomically and restores exact batches on undo and redo", async () => {
+    const context = createDatabaseContext(":memory:");
+    try {
+      migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+      context.db.insert(projects).values({ id: "project-1", name: "Projekt" }).run();
+      context.db.insert(distributionBoards).values({ id: "board-1", projectId: "project-1", name: "UV 1" }).run();
+      context.db.insert(circuitLists).values({ id: "list-1", projectId: "project-1", distributionBoardId: "board-1", name: "Liste" }).run();
+      context.db.insert(circuitSections).values({ id: "section-1", circuitListId: "list-1", key: "single-1", displayName: "1-phasig", prefix: "-2F1.", sortOrder: 10, category: "single_phase", groupNumber: 1 }).run();
+      context.db.insert(circuits).values({ id: "circuit-1", circuitListId: "list-1", sectionId: "section-1", equipmentIdentifier: "-2F1.1", sortOrder: 10, voltage: 230 }).run();
+      context.db.insert(circuitDeviceRows).values({ id: "row-1", circuitId: "circuit-1", sortOrder: 10, name: "Steckdose", displayName: "Steckdose", phaseType: "single_phase", category: "single_phase", quantity: 3, manualQuantity: 1, powerPerUnit: 0.125, simultaneityFactor: 1, cosPhi: 0.9 }).run();
+      const configurationSnapshot = { id: "config-1", projectId: "project-1", configuration };
+      context.db.insert(externalModelConfigurations).values(configurationSnapshot).run();
+      const initialBytes = await createRevitXlsxFixture();
+      const initialParsed = await createExternalXlsxInitialImportPlan({ fileName: "initial.xlsx", bytes: initialBytes, configuration, catalogs });
+      let sequence = 0;
+      const initialState = buildExternalXlsxInitialImportTarget({ projectId: "project-1", expectedRevision: 0, sourceName: "Revit", importedAtIso: "2026-09-30T08:00:00.000Z", configuration, originalContentBase64: Buffer.from(initialBytes).toString("base64"), document: initialParsed.document, plan: initialParsed.plan, roomDecisions: initialParsed.plan.sourceRooms.map((room) => ({ sourceRoomKey: room.sourceRoomKey, roomId: null, defaultDistributionBoardId: null })), familyProjectDeviceDecisions: initialParsed.plan.familyGroups.map((family) => ({ familyAndType: family.familyAndType, projectDeviceId: null })), objectsWithoutRoomDefaultDistributionBoardId: null, createId: () => `30000000-0000-4000-8000-${String(++sequence).padStart(12, "0")}` });
+      new ExternalInitialImportProjectCommandRepository(context.db).execute({ projectId: "project-1", expectedRevision: 0, source: "user", command: createExternalInitialImportProjectCommand(configurationSnapshot, configurationSnapshot, createEmptyExternalModelState(), initialState) });
+      const importedFirst = new ExternalModelStateRepository(context.db).getByProject("project-1").state.objects.find((object) => object.worksharingId === firstWorksharingId)!;
+      context.db.update(externalModelObjects).set({ circuitDeviceRowId: "row-1" }).where(eq(externalModelObjects.id, importedFirst.id)).run();
+
+      const workbook = new ExcelJS.Workbook(); await workbook.xlsx.load(initialBytes); workbook.worksheets[0]!.getCell(3, 6).value = 3;
+      const followBytes = new Uint8Array(await workbook.xlsx.writeBuffer());
+      const current = new ExternalModelStateRepository(context.db).getByProject("project-1").state;
+      const returnValues = new Map(current.objects.map((object) => [object.id, { circuitCombined: object.acceptedSourceValues.circuitCombined, boardName: object.acceptedSourceValues.boardName, circuitIdentifier: object.acceptedSourceValues.circuitIdentifier, designation: object.acceptedSourceValues.designation, electricalPowerW: object.acceptedSourceValues.electricalPowerW, voltageV: object.acceptedSourceValues.voltageV, currentA: object.acceptedSourceValues.currentA }]));
+      const followParsed = await createExternalXlsxFollowUpImportPlan({ fileName: "follow.xlsx", bytes: followBytes, configuration, catalogs, currentState: current, currentReturnValuesByObjectId: returnValues });
+      const expectedRow = toCircuitDeviceRowSnapshot(context.db.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, "row-1")).get()!);
+      const built = buildExternalXlsxFollowUpTarget({ projectId: "project-1", expectedRevision: 1, importedAtIso: "2026-09-30T09:00:00.000Z", configuration, originalContentBase64: Buffer.from(followBytes).toString("base64"), document: followParsed.document, plan: followParsed.plan, currentState: current, sourceChangeDecisions: followParsed.plan.changes.map((change) => ({ objectId: change.objectId, accept: true })), roomDecisions: [], familyProjectDeviceDecisions: [], objectsWithoutRoomDefaultDistributionBoardId: null, rowsById: new Map([["row-1", expectedRow]]), createId: () => `40000000-0000-4000-8000-${String(++sequence).padStart(12, "0")}` });
+      const repository = new ExternalFollowUpImportProjectCommandRepository(context.db);
+      const commandWithoutRequiredRowTransition = createExternalFollowUpImportProjectCommand({ expectedConfiguration: configurationSnapshot, targetConfiguration: configurationSnapshot, expectedState: current, targetState: built.targetState, rows: [] });
+      assert.throws(
+        () => repository.execute({ projectId: "project-1", expectedRevision: 1, source: "user", command: commandWithoutRequiredRowTransition }),
+        /Materialized quantity 3 does not match manual and external quantity 4/,
+      );
+      assert.equal(context.db.select().from(circuitDeviceRows).get()!.quantity, 3);
+      const applied = repository.execute({ projectId: "project-1", expectedRevision: 1, source: "user", command: createExternalFollowUpImportProjectCommand({ expectedConfiguration: configurationSnapshot, targetConfiguration: configurationSnapshot, expectedState: current, targetState: built.targetState, rows: built.rowTransitions }) });
+      assert.equal(context.db.select().from(circuitDeviceRows).get()!.quantity, 4);
+      let state = new ExternalModelStateRepository(context.db).getByProject("project-1").state;
+      assert.equal(state.importBatches.length, 2); assert.equal(state.importBatches[0]!.document, null); assert.equal(state.objects.find((object) => object.worksharingId === firstWorksharingId)!.planningValues.effectiveQuantity, 3);
+
+      const undone = repository.execute({ projectId: "project-1", expectedRevision: 2, source: "undo", historyTargetChangeSetId: applied.revision.changeSetId, command: applied.inverse });
+      assert.equal(context.db.select().from(circuitDeviceRows).get()!.quantity, 3);
+      state = new ExternalModelStateRepository(context.db).getByProject("project-1").state;
+      assert.equal(state.importBatches.length, 1); assert.ok(state.importBatches[0]!.document);
+      repository.execute({ projectId: "project-1", expectedRevision: 3, source: "redo", historyTargetChangeSetId: applied.revision.changeSetId, command: undone.inverse });
+      assert.equal(context.db.select().from(circuitDeviceRows).get()!.quantity, 4);
+
+      context.db.update(externalModelObjects).set({ presenceStatus: "missing" }).where(eq(externalModelObjects.id, importedFirst.id)).run();
+      const missingObject = new ExternalModelStateRepository(context.db).getByProject("project-1").state.objects.find((object) => object.id === importedFirst.id)!;
+      const rowBeforeDelete = toCircuitDeviceRowSnapshot(context.db.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, "row-1")).get()!);
+      const deleteRepository = new ExternalObjectDeleteMissingProjectCommandRepository(context.db);
+      const deleted = deleteRepository.execute({ projectId: "project-1", expectedRevision: 4, source: "user", command: createExternalObjectDeleteMissingProjectCommand({ objects: [{ expected: missingObject, target: null }], rows: [{ expected: rowBeforeDelete, target: { ...rowBeforeDelete, quantity: 1 } }] }) });
+      assert.equal(context.db.select().from(circuitDeviceRows).get()!.quantity, 1);
+      assert.equal(context.db.select().from(externalModelObjects).where(eq(externalModelObjects.id, importedFirst.id)).get(), undefined);
+      const foreignRestore = createExternalObjectDeleteMissingProjectCommand({ objects: [{ expected: null, target: { ...missingObject, projectId: "project-2" } }], rows: deleted.inverse.payload.rows });
+      assert.throws(() => deleteRepository.execute({ projectId: "project-1", expectedRevision: 5, source: "user", command: foreignRestore }), /anderes Projekt/);
+      deleteRepository.execute({ projectId: "project-1", expectedRevision: 5, source: "undo", historyTargetChangeSetId: deleted.revision.changeSetId, command: deleted.inverse });
+      assert.equal(context.db.select().from(circuitDeviceRows).get()!.quantity, 4);
+      assert.equal(context.db.select().from(externalModelObjects).where(eq(externalModelObjects.id, importedFirst.id)).get()!.circuitDeviceRowId, "row-1");
+    } finally { context.close(); }
+  });
+});
+
diff --git a/tests/external-xlsx-follow-up-import.test.ts b/tests/external-xlsx-follow-up-import.test.ts
new file mode 100644
index 0000000..70cb7d9
--- /dev/null
+++ b/tests/external-xlsx-follow-up-import.test.ts
@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import ExcelJS from "exceljs";
+import { createExternalXlsxFollowUpImportPlan } from "../src/external-model/application/external-xlsx-follow-up-import.js";
+import { buildExternalXlsxFollowUpTarget } from "../src/external-model/application/external-xlsx-follow-up-target.js";
+import { createExternalXlsxInitialImportPlan } from "../src/external-model/application/external-xlsx-initial-import.js";
+import { buildExternalXlsxInitialImportTarget } from "../src/external-model/application/external-xlsx-initial-import-target.js";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
+import type { ExternalXlsxReturnValues } from "../src/external-model/xlsx/external-xlsx-contracts.js";
+import { createRevitXlsxFixture, externalXlsxTestConfiguration, firstWorksharingId, secondWorksharingId } from "./fixtures/revit-xlsx-fixtures.js";
+
+const deviceTypeA = "10000000-0000-4000-8000-000000000001";
+const deviceTypeB = "10000000-0000-4000-8000-000000000002";
+const newWorksharingId = "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE-00000003";
+const catalogs = { floors: [], rooms: [], distributionBoards: [], projectDevices: [] };
+const configuration = { ...createDefaultExternalModelConfiguration(), ...externalXlsxTestConfiguration, deviceTypes: [{ id: deviceTypeA, name: "Steckdose", category: "single_phase" as const, defaults: { powerPerUnitW: null, simultaneityFactor: 1, cosPhi: 0.9, costGroup: null } }, { id: deviceTypeB, name: "Leuchte", category: "lighting" as const, defaults: { powerPerUnitW: 40, simultaneityFactor: 1, cosPhi: null, costGroup: null } }], familyTypeRules: [{ id: "20000000-0000-4000-8000-000000000001", exactFamilyAndType: "Steckdose: Standard", deviceTypeId: deviceTypeA, quantityRule: "socketCount" as const }, { id: "20000000-0000-4000-8000-000000000002", exactFamilyAndType: "Leuchte: Decke", deviceTypeId: deviceTypeB, quantityRule: "one" as const }] };
+
+async function initialState() {
+  const bytes = await createRevitXlsxFixture();
+  const { plan, document } = await createExternalXlsxInitialImportPlan({ fileName: "initial.xlsx", bytes, configuration, catalogs });
+  let sequence = 0;
+  const state = buildExternalXlsxInitialImportTarget({ projectId: "project-1", expectedRevision: 0, sourceName: "Revit", importedAtIso: "2026-09-30T08:00:00.000Z", configuration, originalContentBase64: Buffer.from(bytes).toString("base64"), document, plan, roomDecisions: plan.sourceRooms.map((room) => ({ sourceRoomKey: room.sourceRoomKey, roomId: null, defaultDistributionBoardId: null })), familyProjectDeviceDecisions: plan.familyGroups.map((family) => ({ familyAndType: family.familyAndType, projectDeviceId: null })), objectsWithoutRoomDefaultDistributionBoardId: null, createId: () => `30000000-0000-4000-8000-${String(++sequence).padStart(12, "0")}` });
+  const missing = structuredClone(state.objects[1]!); missing.id = "30000000-0000-4000-8000-999999999999"; missing.worksharingId = "AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE-00000099";
+  state.objects.push(missing);
+  return state;
+}
+
+async function changedWorkbook(firstId = firstWorksharingId) {
+  const workbook = new ExcelJS.Workbook(); await workbook.xlsx.load(await createRevitXlsxFixture());
+  const sheet = workbook.worksheets[0]!;
+  sheet.getCell(3, 1).value = firstId; sheet.getCell(3, 6).value = 3;
+  sheet.getCell(5, 1).value = newWorksharingId; sheet.getCell(5, 2).value = "Leuchte neu"; sheet.getCell(5, 5).value = "Leuchte: Decke"; sheet.getCell(5, 6).value = 1;
+  return new Uint8Array(await workbook.xlsx.writeBuffer());
+}
+
+function currentReturns(state: Awaited<ReturnType<typeof initialState>>) {
+  const map = new Map<string, ExternalXlsxReturnValues>();
+  for (const object of state.objects) map.set(object.id, { circuitCombined: object.acceptedSourceValues.circuitCombined, boardName: object.acceptedSourceValues.boardName, circuitIdentifier: object.acceptedSourceValues.circuitIdentifier, designation: object.acceptedSourceValues.designation, electricalPowerW: object.acceptedSourceValues.electricalPowerW, voltageV: object.acceptedSourceValues.voltageV, currentA: object.acceptedSourceValues.currentA });
+  map.set(state.objects[0]!.id, { ...map.get(state.objects[0]!.id)!, designation: "Noch nicht in Revit" });
+  return map;
+}
+
+describe("Linear XLSX follow-up import", () => {
+  it("classifies new, changed, unchanged, missing and return-deviating objects with exact IDs", async () => {
+    const state = await initialState();
+    const bytes = await changedWorkbook();
+    const { plan } = await createExternalXlsxFollowUpImportPlan({ fileName: "follow-up.xlsx", bytes, configuration, catalogs, currentState: state, currentReturnValuesByObjectId: currentReturns(state) });
+    assert.deepEqual({ new: plan.newObjectCount, changed: plan.changedObjectCount, unchanged: plan.unchangedObjectCount, missing: plan.missingObjectCount, returnDeviation: plan.returnDeviationCount }, { new: 1, changed: 1, unchanged: 1, missing: 1, returnDeviation: 1 });
+    assert.deepEqual(plan.changes[0]!.changedFields, ["socketCount"]);
+    assert.equal(plan.missingObjects[0]!.worksharingId.endsWith("99"), true);
+
+    const caseChanged = await createExternalXlsxFollowUpImportPlan({ fileName: "follow-up.xlsx", bytes: await changedWorkbook(firstWorksharingId.toLowerCase()), configuration, catalogs, currentState: state, currentReturnValuesByObjectId: currentReturns(state) });
+    assert.equal(caseChanged.plan.newObjectCount, 2);
+    assert.equal(caseChanged.plan.missingObjectCount, 2);
+  });
+
+  it("updates accepted quantities and row totals while preserving missing links and compacting old batches", async () => {
+    const state = await initialState();
+    const first = state.objects.find((object) => object.worksharingId === firstWorksharingId)!;
+    first.circuitDeviceRowId = "row-1";
+    const bytes = await changedWorkbook();
+    const { plan, document } = await createExternalXlsxFollowUpImportPlan({ fileName: "follow-up.xlsx", bytes, configuration, catalogs, currentState: state, currentReturnValuesByObjectId: currentReturns(state) });
+    let sequence = 0;
+    const row = { id: "row-1", circuitId: "circuit-1", linkedProjectDeviceId: null, sortOrder: 10, name: "Steckdose", displayName: "Steckdose", phaseType: "single_phase", connectionKind: null, costGroup: null, category: "single_phase", level: null, roomId: null, roomNumberSnapshot: null, roomNameSnapshot: null, quantity: 3, manualQuantity: 1, powerPerUnit: 0.125, simultaneityFactor: 1, cosPhi: 0.9, remark: null, overriddenFields: null };
+    const built = buildExternalXlsxFollowUpTarget({ projectId: "project-1", expectedRevision: 1, importedAtIso: "2026-09-30T09:00:00.000Z", configuration, originalContentBase64: Buffer.from(bytes).toString("base64"), document, plan, currentState: state, sourceChangeDecisions: plan.changes.map((change) => ({ objectId: change.objectId, accept: true })), roomDecisions: plan.newSourceRoomKeys.map((sourceRoomKey) => ({ sourceRoomKey, roomId: null, defaultDistributionBoardId: null })), familyProjectDeviceDecisions: plan.newFamilyAndTypes.map((familyAndType) => ({ familyAndType, projectDeviceId: null })), objectsWithoutRoomDefaultDistributionBoardId: null, rowsById: new Map([[row.id, row]]), createId: () => `40000000-0000-4000-8000-${String(++sequence).padStart(12, "0")}` });
+    assert.equal(built.rowTransitions[0]!.target.quantity, 4);
+    assert.equal(built.targetState.objects.find((object) => object.id === first.id)!.planningValues.effectiveQuantity, 3);
+    const missing = built.targetState.objects.find((object) => object.worksharingId.endsWith("99"))!;
+    assert.equal(missing.presenceStatus, "missing");
+    assert.equal(missing.circuitDeviceRowId, null);
+    assert.equal(built.targetState.importBatches[0]!.originalContentBase64, null);
+    assert.ok(built.targetState.importBatches[1]!.originalContentBase64);
+
+    const rejected = buildExternalXlsxFollowUpTarget({ projectId: "project-1", expectedRevision: 1, importedAtIso: "2026-09-30T09:00:00.000Z", configuration, originalContentBase64: Buffer.from(bytes).toString("base64"), document, plan, currentState: state, sourceChangeDecisions: plan.changes.map((change) => ({ objectId: change.objectId, accept: false })), roomDecisions: plan.newSourceRoomKeys.map((sourceRoomKey) => ({ sourceRoomKey, roomId: null, defaultDistributionBoardId: null })), familyProjectDeviceDecisions: plan.newFamilyAndTypes.map((familyAndType) => ({ familyAndType, projectDeviceId: null })), objectsWithoutRoomDefaultDistributionBoardId: null, rowsById: new Map([[row.id, row]]), createId: () => `50000000-0000-4000-8000-${String(++sequence).padStart(12, "0")}` });
+    const rejectedObject = rejected.targetState.objects.find((object) => object.id === first.id)!;
+    assert.equal(rejectedObject.planningValues.effectiveQuantity, first.planningValues.effectiveQuantity);
+    assert.equal(rejectedObject.lastAcceptedImportBatchId, first.lastAcceptedImportBatchId);
+    assert.notEqual(rejectedObject.lastSeenImportBatchId, first.lastSeenImportBatchId);
+    assert.equal(rejected.rowTransitions.length, 0);
+  });
+});
+
diff --git a/tests/revit-xlsx-settings-api.test.ts b/tests/revit-xlsx-settings-api.test.ts
index 90161b3..a7d20da 100644
--- a/tests/revit-xlsx-settings-api.test.ts
+++ b/tests/revit-xlsx-settings-api.test.ts
@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { describe, it } from "node:test";
 import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
-import { applyExternalInitialImport, createExternalReturnWorkbook, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getExternalProjectObjects, planExternalInitialImport, updateExternalModelConfiguration, updateExternalProjectObjects } from "../src/frontend/utils/api.js";
+import { applyExternalFollowUpImport, applyExternalInitialImport, createExternalReturnWorkbook, deleteMissingExternalProjectObjects, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getExternalProjectObjects, planExternalFollowUpImport, planExternalInitialImport, updateExternalModelConfiguration, updateExternalProjectObjects } from "../src/frontend/utils/api.js";
 
 describe("Revit XLSX settings", () => {
   it("uses the project-scoped configuration endpoint with expectedRevision", async () => {
@@ -53,6 +53,7 @@ describe("Revit XLSX settings", () => {
     const revitPage = readFileSync("src/app/projects/[projectId]/revit/page.tsx", "utf8");
     const settings = readFileSync("src/frontend/components/revit-xlsx-settings-modal.tsx", "utf8");
     const wizard = readFileSync("src/frontend/components/revit-initial-import-wizard.tsx", "utf8");
+    const followUpWizard = readFileSync("src/frontend/components/revit-follow-up-import-wizard.tsx", "utf8");
     const objectTable = readFileSync("src/frontend/components/revit-object-table.tsx", "utf8");
     assert.match(projectPage, /href={`\/projects\/\$\{projectId\}\/revit`}/);
     assert.doesNotMatch(projectPage, /RevitCsvModal|Revit-CSV/);
@@ -64,10 +65,23 @@ describe("Revit XLSX settings", () => {
     assert.match(wizard, /Schritt.*von/);
     assert.match(wizard, /keine Gerätezeilen, Stromkreise oder BMKs/);
     assert.match(wizard, /GZF 1/);
+    assert.match(revitPage, /Folgeimport/);
+    assert.match(followUpWizard, /in Revit noch nicht aktualisiert/);
+    assert.match(followUpWizard, /Fehlende Objekte werden nicht gelöst oder gelöscht/);
     assert.match(objectTable, /viewportHeight/);
     assert.match(objectTable, /Sammeländerung anwenden/);
     assert.match(objectTable, /Rückgabe-Excel herunterladen/);
     assert.match(objectTable, /Nur geänderte Objekte/);
+    assert.match(objectTable, /Ausgewählte fehlende löschen/);
+  });
+
+  it("deletes missing objects only after explicit confirmation", async () => {
+    const requests: Array<{ url: string; method: string; body: unknown }> = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => { requests.push({ url: String(input), method: init?.method ?? "GET", body: init?.body ? JSON.parse(String(init.body)) : undefined }); return new Response(JSON.stringify({ history: { currentRevision: 6 } }), { status: 200, headers: { "Content-Type": "application/json" } }); };
+    try { await deleteMissingExternalProjectObjects("project-1", 5, ["object-1"]); }
+    finally { globalThis.fetch = originalFetch; }
+    assert.deepEqual(requests, [{ url: "/api/projects/project-1/external-model/objects/delete-missing", method: "POST", body: { expectedRevision: 5, objectIds: ["object-1"], confirmed: true } }]);
   });
 
   it("loads one project object list and sends revision-safe bulk updates", async () => {
@@ -90,4 +104,21 @@ describe("Revit XLSX settings", () => {
     finally { globalThis.fetch = originalFetch; }
     assert.deepEqual(requests, [{ url: "/api/projects/project-1/external-model/return-workbook", method: "POST", body: { expectedRevision: 7, scope: "selected", selectedObjectIds: ["object-1"] } }]);
   });
+
+  it("previews and retransmits the complete workbook for follow-up apply", async () => {
+    const requests: Array<{ url: string; method: string; body: Record<string, unknown> | undefined }> = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (input, init) => { requests.push({ url: String(input), method: init?.method ?? "GET", body: init?.body ? JSON.parse(String(init.body)) : undefined }); return new Response(JSON.stringify({ history: { currentRevision: 10 }, import: { objectCount: 2 } }), { status: 200, headers: { "Content-Type": "application/json" } }); };
+    try {
+      const configuration = createDefaultExternalModelConfiguration();
+      const file = new File([new Uint8Array([1, 2])], "follow.xlsx");
+      await planExternalFollowUpImport("project-1", file, configuration, 9);
+      await applyExternalFollowUpImport("project-1", file, { expectedRevision: 9, expectedSha256: "a".repeat(64), configuration, objectsWithoutRoomDefaultDistributionBoardId: null, sourceChangeDecisions: [], roomDecisions: [], familyProjectDeviceDecisions: [] });
+    } finally { globalThis.fetch = originalFetch; }
+    assert.equal(requests[0].url, "/api/projects/project-1/external-model/follow-up-import/plan");
+    assert.equal(requests[1].url, "/api/projects/project-1/external-model/follow-up-import/apply");
+    assert.equal(requests[0].body?.contentBase64, "AQI=");
+    assert.equal(requests[1].body?.contentBase64, "AQI=");
+    assert.equal(requests[1].body?.expectedRevision, 9);
+  });
 });

From 4ff01b2ccdbd3fdcfe7e281cbe98ee481298cd08 Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 21:02:20 +0200
Subject: [PATCH 59/60] Harden Linear XLSX end to end

---
 AGENTS.md                                     |   8 +-
 README.md                                     |   4 +-
 docs/README.md                                |   4 +-
 docs/building-structure.md                    |   2 +-
 docs/circuit-list-editor-api.md               |  61 +++---
 docs/circuit-list-editor-known-limitations.md |   8 +-
 docs/current-architecture.md                  | 183 ++----------------
 docs/print-view.md                            |   5 +-
 ...history-and-external-model-architecture.md |  10 +-
 docs/revit-requirements-llm-context.md        |  12 +-
 docs/spec/07-implementation-phases-todo.md    |   3 +
 docs/spec/08-current-product-backlog.md       |   6 +-
 .../revit-excel-integration-requirements.md   |   8 +
 docs/spec/revit-excel-phase-14-plan.md        |  11 +-
 docs/spec/revit-excel-r10-validation.md       |  60 ++++++
 .../batched-insert.persistence.ts             |  15 ++
 ...ow-up-import-project-command.repository.ts |   3 +-
 ...itial-import-project-command.repository.ts |   7 +-
 ...roject-state-restore-command.repository.ts |   9 +-
 .../project-transfer.repository.ts            |   5 +-
 .../components/revit-object-table-model.ts    |  25 +++
 .../components/revit-object-table.tsx         |  18 +-
 tests/batched-insert.persistence.test.ts      |  20 ++
 tests/fixtures/revit-xlsx-fixtures.ts         |  26 +++
 tests/revit-xlsx-end-to-end.test.ts           | 143 ++++++++++++++
 tests/revit-xlsx-scale.test.ts                | 112 +++++++++++
 26 files changed, 522 insertions(+), 246 deletions(-)
 create mode 100644 docs/spec/revit-excel-r10-validation.md
 create mode 100644 src/db/repositories/batched-insert.persistence.ts
 create mode 100644 src/frontend/components/revit-object-table-model.ts
 create mode 100644 tests/batched-insert.persistence.test.ts
 create mode 100644 tests/revit-xlsx-end-to-end.test.ts
 create mode 100644 tests/revit-xlsx-scale.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index e4b9b94..75fdcf3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -351,6 +351,12 @@ batch to metadata. `external-import.apply-follow-up` stores complete inverse
 states, so Undo/Redo never parses Excel. A separately confirmed
 `external-model-object.delete-missing` command removes missing objects and
 adjusts linked row quantities; Undo restores objects, links and quantities.
+R10 verifies the complete path through return workbook, follow-up import,
+snapshot restore, portable duplicate and restart-safe Undo/Redo. A 5,000-object
+synthetic workbook covers parser, command/snapshot size, transactions and the
+client-side virtual window. Complete external-state inserts use bounded batches
+inside their existing transaction for initial/follow-up import, restore and
+duplicate. See `docs/spec/revit-excel-r10-validation.md`.
 
 The target configuration has no independent version counter; `expectedRevision`
 invalidates stale plans, and each import batch stores a configuration copy.
@@ -604,7 +610,7 @@ Critical target rules:
   selected combined/separate mode block export.
 - Missing GZF defaults visibly to 1 without separate confirmation.
 - The corrected R2 return workbook was successfully imported into Linear on
-  2026-09-30; R3 through R9 are complete and R10 is the next package.
+  2026-09-30; R3 through R10 and Phase 14 are complete.
 - All confirmed writes use typed project commands with `expectedRevision`,
   complete inverse data and the shared project-command transaction boundary.
 - Do not add automatic circuit planning, Revit circuit adoption, multi-source
diff --git a/README.md b/README.md
index d1e9523..51a3860 100644
--- a/README.md
+++ b/README.md
@@ -11,10 +11,10 @@ für mehrere gleichzeitig arbeitende Prozesse und ein vollständig unterstützte
 Produktionsdeployment fehlen weiterhin. Anmeldung und zwei feste Rollen sind
 vorhanden. Die Backend- und Persistenzgrundlage der bisherigen
 Revit-CSV-/IfcGUID-Anbindung ist durch den XLSX-Austausch des Linear-Plugins mit
-Worksharing-ID als externem Schlüssel ersetzt. R0 bis R9 sind abgeschlossen;
+Worksharing-ID als externem Schlüssel ersetzt. R0 bis R10 sind abgeschlossen;
 die eigene Revit-Seite unterstützt Einstellungen, Erst- und Folgeimport,
 virtuelle Objektbearbeitung, Editorzuordnung und strukturtreue Rückgabe.
-R10 härtet den Ablauf Ende zu Ende und für große Datenmengen.
+Die Phase-14-Kette ist Ende zu Ende und mit 5.000 synthetischen Objekten geprüft.
 
 ## Unterstützter Arbeitsablauf
 
diff --git a/docs/README.md b/docs/README.md
index 90c5fc3..be55461 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -31,7 +31,7 @@ ausdrücklich getrennt und dürfen nicht als bereits implementiert verstanden we
 - [Entwicklungs- und Contributor-Workflow](development-workflow.md)
 - [Deployment und Betrieb](deployment.md)
 
-## Aktive Revit-Umstellung
+## Revit / Linear XLSX
 
 - [Projektversionen und externer Modellaustausch](project-history-and-external-model-architecture.md)
 - [Revit-Integration über Linear-Excel](spec/revit-excel-integration-requirements.md) –
@@ -39,6 +39,8 @@ ausdrücklich getrennt und dürfen nicht als bereits implementiert verstanden we
 - [Phase-14-Plan R0–R10](spec/revit-excel-phase-14-plan.md) – Status,
   Paketgrenzen und Linear-Freigabepunkt nach R2
 - [R0-Bestandsaudit](spec/revit-excel-r0-audit.md)
+- [R10-Abnahme](spec/revit-excel-r10-validation.md) – Ende-zu-Ende- und
+  5.000-Objekte-Nachweis
 - [LLM-Kontext für Phase 14](revit-requirements-llm-context.md)
 
 ## Zukunftsarchitektur
diff --git a/docs/building-structure.md b/docs/building-structure.md
index 9db2c91..2264b3f 100644
--- a/docs/building-structure.md
+++ b/docs/building-structure.md
@@ -101,7 +101,7 @@ bleiben.
 ## Offen
 
 - Revit: Eine Übernahme des Gebäudes aus Revit ist derzeit nicht geplant. Die
-  aktive Phase 14 verwendet Linear-XLSX; das Modell steht der expliziten
+  abgeschlossene Phase 14 verwendet Linear-XLSX; das Modell steht der expliziten
   Raumzuordnung im Importwizard nicht im Weg.
 - Raumflächen werden derzeit ausschließlich manuell gepflegt. Ein späterer
   Revit-Abgleich muss die Phase-14-Regeln mit externem Modellzustand, Vorschau
diff --git a/docs/circuit-list-editor-api.md b/docs/circuit-list-editor-api.md
index de724aa..c88e4aa 100644
--- a/docs/circuit-list-editor-api.md
+++ b/docs/circuit-list-editor-api.md
@@ -67,8 +67,9 @@ Prüfsumme; Ersetzen übernimmt die Grobbilanzen atomar und mit Undo/Redo,
 Duplizieren vergibt neue IDs. Transferformat 1 bleibt ohne Grobbilanzen
 importierbar.
 
-Das aktuelle Projekt-Snapshot-Schema 9 enthält die logischen Einspeisungsverweise
-der Verteilungen; Versionen 1–8 werden mit leeren Verweisen hochgestuft. Schema 8
+Das aktuelle Projekt-Snapshot-Schema 10 enthält Linear-XLSX-Zustand und die in
+Schema 9 eingeführten logischen Einspeisungsverweise der Verteilungen;
+Versionen 1–8 werden mit leeren Verweisen hochgestuft. Schema 8
 enthält außerdem die optionale Netto-Raumfläche `rooms[].areaM2`.
 Snapshot-Versionen 1–7 werden dafür mit
 `areaM2 = null` hochgestuft. Restore, Export und Import erhalten vorhandene
@@ -485,40 +486,32 @@ read nor write project data; applying a result uses `circuit.update` through
 
 Full request example and calculation rules: `docs/cable-sizing-module.md`.
 
-## Revit CSV Foundation
+## Revit / Linear XLSX
 
-- `GET /projects/:projectId/external-csv/configuration`
-  - returns the complete versioned project configuration or `null`
-- `PUT /projects/:projectId/external-csv/configuration`
-  - request: `expectedRevision` and the complete validated configuration
-  - executes `external-csv-configuration.update`
-  - returns configuration, revision and project history state
-- `POST /projects/:projectId/external-csv/preview`
-  - request: file name and Base64-encoded CSV content up to 18 MB
-  - requires a stored project configuration
-  - returns transport metadata, SHA-256, row classifications, suspect row
-    numbers and mapped source values for every recognized IFC object
-  - does not persist a draft, mutate project state or create a revision
-- `POST /projects/:projectId/external-csv/initial-import/plan`
-  - reparses the file and returns grouped room/family decisions plus current
-    room, distribution-board and ProjectDevice catalogs
-  - is stateless and rejects an already imported external source
-- `POST /projects/:projectId/external-csv/initial-import/apply`
-  - requires the expected revision, configuration version, file hash and one
-    decision for every room and exact family/type group
-  - reparses the file, blocks unknown family/type values and executes
-    `external-import.apply-initial` as one undoable project revision
-  - creates no Circuit or CircuitDeviceRow
-- `GET /projects/:projectId/circuit-lists/:circuitListId/external-objects`
-  - resolves the circuit list's distribution board server-side
-  - returns only external objects assigned to that board, with unassigned
-    objects first, their source room/marker values and current row-link status
-  - returns an empty list when the optional Revit import does not exist
-  - is read-only and exposes no stored command payloads or import bytes
+- `GET|PUT /projects/:projectId/external-model/configuration` reads or writes
+  the complete XLSX configuration. PUT requires `expectedRevision`.
+- `POST /projects/:projectId/external-model/configuration/detect` detects the
+  sheet layout and columns from an uploaded `.xlsx` sample without persisting.
+- `GET /projects/:projectId/external-model/import-status` returns the latest
+  batch metadata, object count and current missing-object count.
+- `POST .../initial-import/plan|apply` provides the stateless initial plan and
+  its confirmed atomic application. Apply retransmits and reparses the XLSX.
+- `POST .../follow-up-import/plan|apply` classifies exact Worksharing-ID
+  additions, source changes, unchanged and missing objects. Apply requires the
+  preview hash and source decisions and updates linked row quantities atomically.
+- `GET|PUT .../external-model/objects` loads one compact project list and
+  applies revision-safe multi-object planning changes.
+- `POST .../objects/assign-row|assign-new-row|assign-new-circuit|detach-row`
+  changes external-object row assignments through persistent commands.
+- `POST .../objects/delete-missing` requires `confirmed: true`, deletes only
+  objects marked missing and adjusts linked row quantities in the same command.
+- `POST .../external-model/return-workbook` creates the structure-preserving
+  return XLSX for all, deviating or selected objects.
+- `GET .../external-model/export-batches` returns append-only export metadata.
 
-Parser errors expose stable codes such as `header-not-found`,
-`ambiguous-header`, `invalid-ifc-guid` and `duplicate-ifc-guid`. The confirmed
-import uploads and parses the file again and verifies its hash.
+Uploads accept only `.xlsx` up to 10 MiB. Worksharing-IDs are exact and
+case-sensitive; IfcGUID is optional and non-unique. Undo/Redo uses persisted
+command states and never reparses workbook bytes.
 
 ## Document Branding (print view)
 
diff --git a/docs/circuit-list-editor-known-limitations.md b/docs/circuit-list-editor-known-limitations.md
index 63bc7b3..f9fecb5 100644
--- a/docs/circuit-list-editor-known-limitations.md
+++ b/docs/circuit-list-editor-known-limitations.md
@@ -9,11 +9,11 @@
 - Named and automatic logical project snapshots can be listed and restored
   through the project page with persistent Undo/Redo. Automatic snapshots are
   created every 25 revisions and only their newest 12 entries are retained.
-- Die Linear-XLSX-Anbindung bis R9 ist umgesetzt: Erst- und Folgeimport,
+- Die Linear-XLSX-Anbindung bis R10 ist umgesetzt: Erst- und Folgeimport,
   Objektplanung und Editorzuordnung, strukturtreue Rückgabe sowie bestätigtes
-  Löschen fehlender Objekte verwenden persistente Commands. Offen ist die
-  R10-Härtung des gesamten Ablaufs mit mehreren Tausend synthetischen Objekten,
-  Messungen sowie Snapshot-/Transfer- und Neustarttests.
+  Löschen fehlender Objekte verwenden persistente Commands. Die vollständige
+  Kette ist mit 5.000 synthetischen Objekten sowie Snapshot-, Transfer- und
+  Neustarttests geprüft.
 - Persistence currently targets local SQLite; PostgreSQL is an architectural option, not an implemented runtime.
 - The global device library supports basic CRUD and copy operations, but has no
   versioning, permissions or controlled synchronization model.
diff --git a/docs/current-architecture.md b/docs/current-architecture.md
index 5e746fe..d7f28cb 100644
--- a/docs/current-architecture.md
+++ b/docs/current-architecture.md
@@ -626,7 +626,7 @@ Oberfläche: `/projects/:projectId/grobbilanz`. Details:
   `toLowerCase()` gegen das vollständige Register der Stromkreisliste und wird
   von jedem Anlage-/Umbenennungspfad für Stromkreise und Verteilerkomponenten
   aufgerufen, auch dort, wo zuvor kein Vorab-Check existierte. Snapshot- und
-  Transfer-Integration verwenden aktuell Snapshot-Schema 9. Persistente
+  Transfer-Integration verwenden aktuell Snapshot-Schema 10. Persistente
   Insert/Delete/Update-Commands für veränderliche Verteilerkomponenten,
   Gruppen einschließlich befüllter Unterbäume sowie vollständige
   Gruppensortierung sind integriert. Der Editor zeigt die geschützte Struktur
@@ -643,7 +643,7 @@ PostgreSQL ist bewusst nicht implementiert. Die Domainregeln und
 Transaktionsgrenzen sollen portabel bleiben; Schema und Betriebsmodell benötigen
 bei einem späteren Wechsel trotzdem einen eigenen PostgreSQL-Adapter.
 
-## Revit-Anbindung: Linear-XLSX-Erstimport nach R5
+## Revit-Anbindung: Linear-XLSX nach R10
 
 R3 hat den Backend- und Persistenz-Cutover abgeschlossen. Migration `0014`
 entfernt die alten externen CSV-Entwicklungsdaten, nachdem verknüpfte
@@ -678,173 +678,32 @@ derselben Transaktion. Er erzeugt weder CircuitDeviceRows noch Circuits oder
 BMKs. Seine vollständige Inverse macht Undo/Redo nach Neustart möglich, ohne
 Workbookbytes erneut einzulesen oder zu parsen.
 
-### Historische Ausgangslage vor R3
+R6 bis R9 ergänzen die einmal geladene, clientseitig gefilterte und
+virtualisierte Projektobjektliste, revisionierte Sammelplanung, atomare
+Zuordnung im Stromkreislisteneditor, strukturtreue Rückgabe und den
+vollständigen Folgeimport. Der Folgeimport trennt fachliche Quelländerungen
+von noch nicht nach Revit übernommenen Rückgabewerten, aktualisiert akzeptierte
+Mengen samt Row-Summe und markiert fehlende Objekte ohne ihren Link zu lösen.
+Eine gesondert bestätigte Aktion löscht fehlende Objekte samt Mengenübergang;
+Undo stellt Objekt, Link und Menge wieder her.
 
-Der folgende Text beschreibt den Stand nach R1 und ist keine aktuelle
-Laufzeitdokumentation mehr.
+R10 weist den Ablauf über Rückgabe, Folgeimport, Snapshot-Restore,
+Projektduplikat und Undo/Redo nach Datenbankneustart nach. Persistenzpfade für
+vollständige externe Zustände schreiben große Mengen in begrenzten
+SQLite-Blöcken. Der synthetische Abnahmetest verarbeitet 5.000 Objekte; Details
+und Messwerte stehen in
+[R10-Abnahme](spec/revit-excel-r10-validation.md).
 
-Der nachfolgende Abschnitt beschreibt den am Ende von R1 noch vorhandenen
-Legacy-Laufzeitpfad. Er verwendet CSV und IfcGUID und ist die geprüfte
-Ausgangslage für den schrittweisen Cutover; er darf nicht erweitert werden.
-Das verbindliche Ziel ist der XLSX-Austausch des Linear-Plugins mit exakter,
-case-sensitiver Worksharing-ID. Details:
-[Excel-Anforderungen](spec/revit-excel-integration-requirements.md) und
-[R0–R10-Plan](spec/revit-excel-phase-14-plan.md).
+## Historische CSV-Unterlagen
 
-Der reine Adapter unter `src/external-model/csv` validiert die projektweite
-Transport- und Mappingkonfiguration und parst UTF-8-CSV verlustarm in eine
-klassifizierte Zellmatrix. Er erkennt Metadaten, Header, Passthrough-, Objekt-
-und Verdachtszeilen, prüft IFCGUIDs und serialisiert unveränderte Revit-Exporte
-einschließlich BOM, CRLF und Quotierung bytegleich zurück. Der lokale Befehl
-`npm run revit:verify-reference` prüft die bereitgestellte Referenzdatei.
-
-`external_csv_configurations` enthält höchstens eine versionierte Konfiguration
-je Projekt. `external-csv-configuration.update` schreibt Anlage, Änderung oder
-Entfernung zusammen mit Revision und persistentem Undo/Redo. Snapshot-Schema 5–8,
-Restore und portabler Projekttransfer enthalten diesen Zustand; beim Duplizieren
-werden Konfigurations-UUID und Projektlink remapped.
-
-Migration `0003` ergänzt die relationale Grundlage für genau eine implizite
-`revit_csv`-Quelle je Projekt, geordnete Importbatches, normalisierte
-Quellraummappings und über `(sourceId, ifcGuid)` eindeutige externe Objekte.
-Batches halten Konfigurationssnapshot, Originalbytes und die klassifizierte
-Zellmatrix zusammen. Migration `0004` ergänzt die monotone projektweite
-Konfigurationsversion am Batch, getrennt von der Schema-Version des
-Konfigurationsformats. Quellwerte, lokale Planungswerte und Override-Metadaten
-der Objekte sind getrennt; optionale Links auf Raum, Verteilung, ProjectDevice
-und CircuitDeviceRow bleiben nullable. `ExternalModelStateRepository` liest den
-vollständigen Zustand deterministisch und unterscheidet unbekannte von noch
-nicht importierten Projekten. Der letzte bestätigte Batch wird aus der
-Batchreihenfolge abgeleitet statt redundant an der Quelle gespeichert.
-Snapshot/Transfer v5 erfasst zusätzlich `manualQuantity`; Version 4 wird mit
-dem bisherigen Gesamtwert als manuellem Anteil hochgestuft. Originalbytes,
-Matrix und alle internen Links werden weiterhin vollständig erfasst,
-stellt sie in Fremdschlüsselreihenfolge wieder her und remappt beim
-Projektduplikat jede interne UUID; IFCGUID und Quelltransport bleiben
-unverändert. `external-import.apply-initial` ist die atomare Schreibgrenze für
-einen bestätigten Erstimport. Vor dem Insert prüft sie den aktuellen
-Konfigurationsstand, SHA-256 und Base64-Kanonizität, parst die Originalbytes
-erneut, vergleicht Matrix, vollständige IFCGUID-Menge und Quellwerte und
-validiert alle Raum-, Verteiler- und ProjectDevice-Links gegen das Projekt.
-Nicht explizit als Override markierte Planungswerte müssen dem regelbasierten
-Vorschlag entsprechen. Der Command erzeugt und verknüpft ausdrücklich keine
-CircuitDeviceRow; Undo entfernt den vollständigen unveränderten Importzustand,
-Redo verwendet dieselben UUIDs und Bytes. Bloße Vorschau und Importplanung
-erzeugen weiterhin keine dieser Zeilen.
-
-Migration `0005` trennt bei `CircuitDeviceRow` den manuellen Mengenanteil vom
-weiterhin materialisierten Gesamtwert. Bestehende Daten werden mit
-`manualQuantity = quantity` übernommen. Die Fachregel für spätere externe
-Zuordnungs-Commands lautet `quantity = manualQuantity + Summe der
-effectiveQuantity aller verknüpften ExternalModelObjects`; Link und beide
-Mengenwerte müssen innerhalb desselben Projekt-Commands wechseln.
-`external-object.update-row-assignment` ist diese atomare Schreibgrenze für
-bestehende Gerätezeilen. Sie weist mehrere externe Einzelobjekte zu, verschiebt
-sie zwischen vorhandenen Rows oder löst ihre Links. Vor dem Schreiben werden
-die vollständigen erwarteten Row- und Objektsnapshots, Projektzugehörigkeit,
-Verteilung, Gruppenkategorie, Raum und Selektionskennzeichen geprüft.
-Abweichende lokale Planungswerte benötigen eine explizite Konfliktbestätigung;
-unterschiedliche Räume, Kategorien oder Selektionskennzeichen werden nicht
-still zusammengeführt. Alle betroffenen materialisierten Mengen werden aus dem
-unveränderten manuellen Anteil und sämtlichen Ziel-Objektlinks validiert. Die
-Gegenrichtung enthält dieselben vollständigen Snapshots und funktioniert nach
-Neustart; beim Lösen des letzten Objekts bleibt die Row bestehen.
-`external-object.assign-to-new-row` fügt unzugeordnete Objekte atomar als neue
-Gerätezeile in einen vorhandenen Stromkreis ein. Der manuelle Anteil dieser Row
-ist null; Gesamtmenge, Raum, Verteilung, Kategorie, Selektionskennzeichen und
-Planungswerte werden vor dem Schreiben geprüft. Undo löst exakt diese Objekte
-und löscht die erzeugte Row nur, wenn sie und ihre Linkmenge unverändert sind.
-Der Löschbefehl ist ausschließlich für die Projekthistorie zugelassen; eine
-normale spätere Trennung lässt die Row gemäß der allgemeinen Zuordnungsregel
-bestehen.
-`external-object.assign-to-new-circuit` erzeugt einen neuen Stromkreis mit
-vorab festgeschriebenem BMK, abgeleiteter Projektspannung, genau einer
-externen Row und verpflichtendem Standardschutz zusammen mit den Objektlinks.
-Verteilungs-, Gruppen-, Raum-, Mengen- und Planungsregeln werden vor dem Insert
-gegen den aktuellen Projektstand geprüft. Der historische Gegenbefehl ist kein
-allgemeiner Löschpfad: Er entfernt den vollständigen Circuit-Teilbaum nur bei
-unverändertem Snapshot und unveränderter Objektlinkmenge. Redo verwendet exakt
-dieselben IDs, dasselbe BMK und denselben Schutzsnapshot.
-Die drei Zuordnungsadapter teilen sich
-`external-object-assignment.persistence.ts` für Snapshotvergleich,
-Kompatibilitätsregeln und link-sichere Updates.
-`GET /api/projects/:projectId/circuit-lists/:circuitListId/external-objects`
-liefert die verteilungsbezogene Read-Projektion für den späteren Editor-Drawer.
-Die CircuitList bestimmt den Verteiler serverseitig; die Antwort enthält nur
-dessen externe Objekte, sortiert unzugeordnet vor zugeordnet, sowie kompakte
-Quell-, Raum-, Planungs- und Linkangaben. Originalbytes und vollständige
-Command-Snapshots werden nicht an diese Oberfläche gegeben. Ohne optionalen
-Revit-Import ist die Projektion leer.
-`GET` und `PUT /api/projects/:projectId/external-csv/configuration` lesen oder
-ändern die Konfiguration; der PUT plant Identität und nächsten
-Konfigurationsstand serverseitig und verwendet den typisierten Command.
-`POST /api/projects/:projectId/external-csv/preview` nimmt Dateiname und
-Base64-kodierte CSV bis 18 MB entgegen. Der zustandsfreie Service liefert Hash,
-Dialekt, Header, Klassifikationszahlen, Verdachtszeilen und gemappte
-Objektquellwerte. Er schreibt weder Entwurf noch Projektdaten.
-`POST /api/projects/:projectId/external-csv/initial-import/plan` verwendet
-denselben begrenzten Transport, setzt eine gespeicherte Konfiguration und einen
-noch leeren externen Projektzustand voraus und bleibt ebenfalls zustandsfrei.
-Die Antwort gruppiert Quellräume, schlägt bei genau einer identischen
-Raumnummer den vorhandenen Raum vor, gruppiert exakte Familie-und-Typ-Werte,
-liefert regelbasierte Objektplanungswerte und Konfliktzahlen und enthält die
-vorhandenen Ebenen, Räume, Verteilungen und ProjectDevices als Auswahlkataloge.
-Unbekannte Familien, ungültige Leistungen/Mengen und Objekte ohne Raum bleiben
-sichtbare Warnungen; es wird keine Entscheidung automatisch bestätigt.
-`POST /api/projects/:projectId/external-csv/initial-import/apply` nimmt Datei,
-erwarteten Hash, Konfigurationsversion und Projektrevision erneut entgegen.
-Vollständige Entscheidungen ordnen jeden Quellraum optional einem vorhandenen
-Raum und einer Standardverteilung sowie jede exakte Familiengruppe optional
-einem vorhandenen ProjectDevice zu. Unklassifizierte Familien oder fehlende
-Gruppenentscheidungen blockieren. Der Server parst und plant erneut, erzeugt
-stabile interne UUIDs und übergibt den vollständigen Zustand an
-`external-import.apply-initial`; CSV-Stromkreiswerte bleiben reine Quellwerte
-und alle `circuitDeviceRowId` bleiben `null`.
-Die Projektseite öffnet über „Revit-CSV“ ein deutsches Modal für Dialekt,
-Spaltenzuordnung, zusätzliche Quellfelder und exakte Familie-und-Typ-Regeln.
-Nach dem revisionierten Speichern kann eine lokale CSV gewählt und über den
-zustandsfreien Endpunkt geprüft werden. Die Oberfläche zeigt Kennzahlen und nur
-die ersten 25 erkannten Objekte; die vollständigen Objekte bleiben in der
-Response verfügbar, ohne alle Zeilen in den DOM einzufügen. Der anschließende
-Erstimport-Wizard gruppiert Quellräume und exakte Familie-und-Typ-Werte. Er
-zeigt eindeutige, mehrdeutige und neue Raumtreffer, lässt vorhandene Räume,
-Standardverteilungen und ProjectDevices explizit zuordnen und blockiert die
-Übernahme bei unklassifizierten Familien. Erst nach einem Bestätigungsdialog
-wird der vollständige Import als eine persistente, rückgängig machbare
-Projektrevision angewendet. Dabei entstehen keine Stromkreise oder Gerätezeilen.
-Fehlende Räume und ProjectDevices können direkt aus der jeweiligen Gruppe über
-die regulären Projektformulare angelegt werden. Revit-Werte befüllen diese
-Formulare vor, werden aber vor dem Speichern sichtbar vom Nutzer bestätigt.
-Die Kataloganlage ist jeweils ein eigener Projekt-Command; der Wizard übernimmt
-den neuen Datensatz anschließend in seinen lokalen Auswahlkatalog und markiert
-ihn für die betroffene Gruppe.
-
-### Freigegebener Zielpfad ab R2
-
-R2 ersetzt zunächst nur den Transportadapter und endet mit einem realen
-Linear-Rückimporttest. R3 bleibt bis zu dessen Freigabe gesperrt. Scheitert der
-ExcelJS-Roundtrip, wird vor R3 ein Adapter vorgeschlagen, der die Original-XLSX
-direkt auf OOXML-Ebene ändert.
-
-Der Zielzustand verwendet Worksharing-ID als exakten, case-sensitiven externen
-Schlüssel; IfcGUID bleibt optional. Die Konfiguration hat keinen eigenen
-Versionszähler. `expectedRevision` bindet Vorschau und Apply, Importbatches
-speichern eine Konfigurationskopie. Nur der letzte Batch hält Workbook und
-Matrix vollständig, ältere Batches nur Metadaten. Apply parst die erneut
-übertragene Datei, Undo/Redo arbeitet nur auf persistierten Zuständen.
-
-Die eigene Route `/projects/:projectId/revit` lädt eine kompakte Objektliste
-einmal und stellt sie clientseitig gefiltert, sortiert und virtualisiert dar.
-Verknüpfte Objekte folgen dem Verteiler ihrer Row. Row-, Circuit- und
-Gruppenlöschungen lösen externe Links nach Warnung im selben Command; Undo
-stellt sie wieder her. Raum- und Verteilerlöschungen bleiben bei externen
-Referenzen gesperrt.
+Der vor R3 vorhandene CSV-/IfcGUID-Laufzeitpfad ist entfernt. Seine damalige
+Ausgangslage bleibt ausschließlich im [R0-Audit](spec/revit-excel-r0-audit.md)
+und in den als abgelöst markierten CSV-Spezifikationen nachvollziehbar. Alte
+CSV-Snapshots und CSV-History werden weiterhin ausdrücklich abgelehnt.
 
 ## Noch nicht unterstützt
 
 - Mehrbenutzerbetrieb und Konfliktauflösung
-- R10-Härtung des Linear-XLSX-Ablaufs für große Datenmengen sowie
-  Ende-zu-Ende-Nachweise über Snapshot, Transfer und Neustart
 - vollständige elektrische Dimensionierung
 - Produktionsdeployment
 
diff --git a/docs/print-view.md b/docs/print-view.md
index ecc00e2..04b266d 100644
--- a/docs/print-view.md
+++ b/docs/print-view.md
@@ -131,8 +131,9 @@ ihren Wert.
 Vor dem Anwenden der additiven Migrationen einschließlich `0012` eine verifizierte
 Datenbanksicherung mit `npm run db:backup` erstellen. Die neuen Projekt- und
 Verteilerfelder bleiben bei bestehenden Datensätzen zunächst leer (`null`).
-Snapshot-Schema 9 enthält zusätzlich die logischen Einspeisungsverweise; die
-unterstützten Versionen 1–8 werden mit leeren Verweisen hochgestuft. Restore und
+Snapshot-Schema 10 enthält den aktuellen Projektzustand; die in Schema 9
+eingeführten Einspeisungsverweise werden in den unterstützten Versionen 1–8
+mit leeren Verweisen hochgestuft. Restore und
 Projektkopie erhalten beziehungsweise remappen die neuen Angaben. Globale
 Büroangaben und Logo gehören zur Datenbanksicherung, nicht
 zum logischen Projektsnapshot oder Projekttransfer.
diff --git a/docs/project-history-and-external-model-architecture.md b/docs/project-history-and-external-model-architecture.md
index 91b82ca..3629c23 100644
--- a/docs/project-history-and-external-model-architecture.md
+++ b/docs/project-history-and-external-model-architecture.md
@@ -116,8 +116,8 @@ Implemented automatic-snapshot policy:
 
 Phase 14 is active and follows the
 [Linear-Excel requirements](spec/revit-excel-integration-requirements.md) and
-[R0–R10 plan](spec/revit-excel-phase-14-plan.md). The existing CSV/IFCGUID
-runtime is a legacy starting point for the cutover, not the target model.
+[R0–R10 plan](spec/revit-excel-phase-14-plan.md). The CSV/IFCGUID runtime has
+been removed; the implemented runtime uses Linear XLSX and exact Worksharing-ID.
 
 External model exchange should use explicit staging and link entities instead of writing imported rows directly into circuits.
 
@@ -152,6 +152,12 @@ Required behavior:
 - Missing objects and duplicate/conflicting Worksharing-IDs are reported,
   never silently reassigned.
 
+R10 verifies the complete implemented path through initial import, planning,
+row assignment, return workbook, follow-up import, snapshot restore, portable
+duplicate and restart-safe Undo/Redo. Large state replacement uses bounded
+SQLite insert batches so imports, restores and duplicates do not exceed the
+driver's SQL-variable limit.
+
 The project configuration has no separate revision counter. Stateless plans
 and apply requests bind to `expectedRevision`; every applied import batch holds
 its configuration copy. Apply reparses the retransmitted workbook. Undo and
diff --git a/docs/revit-requirements-llm-context.md b/docs/revit-requirements-llm-context.md
index 3782150..b9f84b2 100644
--- a/docs/revit-requirements-llm-context.md
+++ b/docs/revit-requirements-llm-context.md
@@ -1,15 +1,17 @@
 # LLM-Kontext für die Revit-Integration
 
-Die frühere offene Revit-/CSV-Anforderungsplanung ist abgeschlossen und
-abgelöst. Für Arbeiten an Phase 14 sind vollständig zu lesen:
+Die frühere Revit-/CSV-Anforderungsplanung ist abgelöst und Phase 14 ist mit
+R10 abgeschlossen. Für Arbeiten an der Linear-XLSX-Anbindung sind vollständig
+zu lesen:
 
 - [Revit-Integration über Linear-Excel](spec/revit-excel-integration-requirements.md)
 - [R0–R10-Plan](spec/revit-excel-phase-14-plan.md)
 - [R0-Bestandsaudit](spec/revit-excel-r0-audit.md)
+- [R10-Abnahme](spec/revit-excel-r10-validation.md)
 - [Aktuelle Systemarchitektur](current-architecture.md)
 - [Projekt-History und externer Modellzustand](project-history-and-external-model-architecture.md)
 
 Bei Widersprüchen gilt das Anforderungsdokument. CSV, IfcGUID als Schlüssel,
-Dynamo, Revit-API und JSON-Transport sind keine Zielpfade. Der derzeit noch im
-Code vorhandene CSV-Stand ist ausschließlich die in R1 dokumentierte
-Legacy-Ausgangslage für den schrittweisen Cutover.
+Dynamo, Revit-API und JSON-Transport sind keine Zielpfade. Der CSV-Laufzeitpfad
+ist entfernt; alte CSV-Snapshots und CSV-History werden mit einer deutschen
+Migrationsmeldung abgelehnt.
diff --git a/docs/spec/07-implementation-phases-todo.md b/docs/spec/07-implementation-phases-todo.md
index 0043ef2..5968766 100644
--- a/docs/spec/07-implementation-phases-todo.md
+++ b/docs/spec/07-implementation-phases-todo.md
@@ -532,6 +532,9 @@ Acceptance criteria:
 
 ## Phase 14: External Model Round-Trip
 
+Status: abgeschlossen am 30.09.2026 mit R10. Siehe
+[R10-Abnahme](revit-excel-r10-validation.md).
+
 Status: R0 ist mit Korrekturen freigegeben; R1 stellt die Dokumentation auf
 Linear-XLSX und Worksharing-ID um. Die frühere CSV-Planung 14.0–14.6 ist
 abgelöst und wird nicht fortgeschrieben.
diff --git a/docs/spec/08-current-product-backlog.md b/docs/spec/08-current-product-backlog.md
index 6d1eae4..dda8fbb 100644
--- a/docs/spec/08-current-product-backlog.md
+++ b/docs/spec/08-current-product-backlog.md
@@ -162,7 +162,7 @@ ProjectDevices and device rows (#20).
 3. [x] Snapshot-to-revision descriptions and history presentation.
 4. [x] Distribution-board power summary and project column layout.
 
-The Revit/Linear-XLSX round-trip is now the separately planned active Phase 14.
-It uses exact Worksharing-ID identity and must not be inferred from these
-unrelated backlog tasks. See
+The Revit/Linear-XLSX round-trip was completed separately in Phase 14. It uses
+exact Worksharing-ID identity and must not be inferred from these unrelated
+backlog tasks. See
 [the R0–R10 plan](revit-excel-phase-14-plan.md).
diff --git a/docs/spec/revit-excel-integration-requirements.md b/docs/spec/revit-excel-integration-requirements.md
index bc86326..effceb6 100644
--- a/docs/spec/revit-excel-integration-requirements.md
+++ b/docs/spec/revit-excel-integration-requirements.md
@@ -478,6 +478,14 @@ synthetischen großen Workbooks. Die virtualisierte Tabelle rendert nur den
 sichtbaren Ausschnitt, während Filterung, Sortierung und Auswahl auf der einmal
 geladenen kompakten Liste arbeiten.
 
+Umsetzungsstand R10: Die vollständige Kette ist mit dateibasierter SQLite-
+Persistenz und Neustart getestet. Der synthetische Lasttest verarbeitet 5.000
+Objekte, misst Transport, Planung, Transaktionen, Command-/Snapshotgröße,
+Heap und Clientprojektion und prüft Restore sowie Projektduplikat. Große
+Zustandsersetzungen verwenden begrenzte Insertblöcke innerhalb derselben
+atomaren Transaktion. Die Ergebnisse sind in der
+[R10-Abnahme](revit-excel-r10-validation.md) dokumentiert.
+
 Jedes Paket R1–R10 führt fokussierte Tests sowie aus:
 
 ```text
diff --git a/docs/spec/revit-excel-phase-14-plan.md b/docs/spec/revit-excel-phase-14-plan.md
index d7e6cbe..5039852 100644
--- a/docs/spec/revit-excel-phase-14-plan.md
+++ b/docs/spec/revit-excel-phase-14-plan.md
@@ -18,7 +18,7 @@ Der alte CSV-Plan 14.0–14.6 ist abgelöst und wird nicht fortgeschrieben.
 | R7 | abgeschlossen | Gruppierter Editorbereich, drei Drag-and-drop-Ziele, Row-Indikator, ausdrückliches Lösen und atomare Löschübergänge mit exaktem Undo/Redo. |
 | R8 | abgeschlossen | Rückgabe-Excel für alle, abweichende oder ausgewählte Objekte und append-only Exportnachweis sind umgesetzt. |
 | R9 | abgeschlossen | Vollständiger Folgeimport nach exakter Worksharing-ID mit Quellentscheidungen, fehlenden Objekten, bestätigtem Löschen und persistentem Undo/Redo. |
-| R10 | offen | Ende-zu-Ende-Härtung, große Datenmengen und Abschlussdokumentation. |
+| R10 | abgeschlossen | Ende-zu-Ende-Kette, 5.000-Objekte-Lasttest, gebatchte Zustandspersistenz und Abschlussdokumentation. |
 
 ## R0 – Audit
 
@@ -214,6 +214,15 @@ Zusätzlich: mehrere Tausend synthetische Objekte, virtualisierte UI,
 Speicher-/Payload-/Transaktionsmessungen, Löschwarnungen samt Link-Inversen,
 alte CSV-Ablehnungen und Dokumentation auf den ausgelieferten Stand.
 
+Umsetzungsstand vom 30.09.2026: Der dateibasierte Integrationstest deckt die
+vollständige Kette bis zu Undo/Redo nach einem Datenbankneustart ab. Ein
+synthetisches Workbook mit 5.000 Objekten durchläuft Erst- und Folgeimport,
+Snapshot-Restore, Projektduplikat sowie die extrahierte Clientfilter- und
+Virtualisierungslogik. Die dabei gefundene SQLite-Grenze ungebatchter Inserts
+ist für alle vollständigen External-Model-Zustandspfade behoben. Messwerte und
+Abnahme stehen in [R10-Abnahme](revit-excel-r10-validation.md). Phase 14 ist
+damit abgeschlossen.
+
 ## Pflichtprüfungen je Paket R1–R10
 
 ```text
diff --git a/docs/spec/revit-excel-r10-validation.md b/docs/spec/revit-excel-r10-validation.md
new file mode 100644
index 0000000..0bdc392
--- /dev/null
+++ b/docs/spec/revit-excel-r10-validation.md
@@ -0,0 +1,60 @@
+# R10-Abnahme der Linear-XLSX-Anbindung
+
+Stand: 30.09.2026. R10 schließt Phase 14 mit synthetischen, reproduzierbaren
+Integrations- und Lasttests ab. Die reale Musterdatei wird dafür nicht benötigt
+und bleibt unversioniert.
+
+## Ende-zu-Ende-Nachweis
+
+`tests/revit-xlsx-end-to-end.test.ts` verwendet eine dateibasierte SQLite-
+Datenbank und prüft in einer Kette:
+
+```text
+Erstimport → Objektplanung → Row-Zuordnung → Rückgabe-XLSX
+  → Folgeimport → Snapshot/Restore → Projektduplikat
+  → Datenbankneustart → Undo → Redo
+```
+
+Der Test bestätigt insbesondere die materialisierte Row-Menge, die Reduktion
+des älteren Importbatches auf Metadaten, das Remapping aller internen UUIDs im
+Duplikat und parserfreies Undo/Redo nach dem Neustart.
+
+## Last- und Größenmessung
+
+`tests/revit-xlsx-scale.test.ts` erzeugt 5.000 synthetische Objekte in einer
+Linear-kompatiblen XLSX. Der Test misst Erst- und Folgeimport, Command- und
+Snapshotgröße, Heap-Wachstum sowie clientseitiges Filtern, Sortieren und das
+virtuelle Fenster. Er führt außerdem Snapshot-Restore und Projektduplikat mit
+dem vollständigen Zustand aus.
+
+Messung auf der Entwicklungsumgebung am 30.09.2026:
+
+| Messwert | Ergebnis |
+| --- | ---: |
+| Objekte | 5.000 |
+| XLSX-Datei | 191.019 Bytes |
+| Erstimport-Command | 15.598.253 Bytes |
+| logischer Projektsnapshot | 15.598.071 Bytes |
+| XLSX-Erstplanung | 6.831 ms |
+| atomare Erstimporttransaktion | 672 ms |
+| XLSX-Folgeplanung | 6.303 ms |
+| atomare Folgeimporttransaktion | 887 ms |
+| Clientfilter, Sortierung und Fenster | 37 ms |
+| Heap-Zuwachs des erfolgreichen Gesamtlaufs | 154.125.568 Bytes |
+
+Der Heap-Wert ist wegen Garbage Collection und der absichtlich verwendeten
+In-Memory-Datenbank nicht deterministisch. Wiederholte Auditläufe lagen unter
+der Testobergrenze von 768 MiB. Das virtuelle Fenster enthält bei 520 px Höhe
+maximal 22 statt 5.000 Zeilen.
+
+## Gefundene und behobene Grenze
+
+Der erste 5.000-Objekte-Lauf scheiterte an einem ungebatchten SQLite-
+Mehrfach-Insert. `insertManyInBatches` begrenzt nun die Insertblöcke für
+Erstimport, Folgeimport, Snapshot-Restore und Projektduplikat. Alle Blöcke
+bleiben Teil der jeweiligen bestehenden Transaktion; ein Fehler rollt weiterhin
+die gesamte Operation zurück.
+
+Die vorhandenen Tests decken außerdem die deutschen Ablehnungen alter
+CSV-Snapshots und CSV-History, Löschwarnungen, atomare Link-Inversen und den
+Schutz referenzierter Räume und Verteiler ab.
diff --git a/src/db/repositories/batched-insert.persistence.ts b/src/db/repositories/batched-insert.persistence.ts
new file mode 100644
index 0000000..1dea2e1
--- /dev/null
+++ b/src/db/repositories/batched-insert.persistence.ts
@@ -0,0 +1,15 @@
+import type { AppDatabase } from "../database-context.js";
+
+const defaultInsertBatchSize = 200;
+
+export function insertManyInBatches<TTable extends Parameters<AppDatabase["insert"]>[0]>(
+  database: AppDatabase,
+  table: TTable,
+  values: readonly unknown[],
+  batchSize = defaultInsertBatchSize
+) {
+  if (!Number.isSafeInteger(batchSize) || batchSize < 1) throw new Error("Insert batch size must be a positive integer.");
+  for (let index = 0; index < values.length; index += batchSize) {
+    database.insert(table).values(values.slice(index, index + batchSize) as never).run();
+  }
+}
diff --git a/src/db/repositories/external-follow-up-import-project-command.repository.ts b/src/db/repositories/external-follow-up-import-project-command.repository.ts
index 7303200..f0b3078 100644
--- a/src/db/repositories/external-follow-up-import-project-command.repository.ts
+++ b/src/db/repositories/external-follow-up-import-project-command.repository.ts
@@ -21,6 +21,7 @@ import { rooms } from "../schema/rooms.js";
 import { toCircuitDeviceRowSnapshot } from "./circuit-device-row-structure.persistence.js";
 import { ExternalModelStateRepository } from "./external-model-state.repository.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { insertManyInBatches } from "./batched-insert.persistence.js";
 
 export class ExternalFollowUpImportProjectCommandRepository implements ExternalFollowUpImportProjectCommandStore {
   constructor(private readonly database: AppDatabase) {}
@@ -80,7 +81,7 @@ function assertRows(database: AppDatabase, projectId: string, target: ExternalMo
   }
 }
 function replaceConfiguration(database: AppDatabase, projectId: string, target: typeof externalModelConfigurations.$inferInsert) { database.delete(externalModelConfigurations).where(eq(externalModelConfigurations.projectId, projectId)).run(); database.insert(externalModelConfigurations).values(target).run(); }
-function replaceState(database: AppDatabase, projectId: string, target: ExternalModelStateSnapshot) { database.delete(externalModelSources).where(eq(externalModelSources.projectId, projectId)).run(); if (!target.source) return; database.insert(externalModelSources).values(target.source).run(); database.insert(externalImportBatches).values(target.importBatches.map(({ originalContentBase64, ...batch }) => ({ ...batch, originalBytes: originalContentBase64 === null ? null : Buffer.from(originalContentBase64, "base64") }))).run(); if (target.roomMappings.length) database.insert(externalRoomMappings).values(target.roomMappings).run(); if (target.objects.length) database.insert(externalModelObjects).values(target.objects).run(); }
+function replaceState(database: AppDatabase, projectId: string, target: ExternalModelStateSnapshot) { database.delete(externalModelSources).where(eq(externalModelSources.projectId, projectId)).run(); if (!target.source) return; database.insert(externalModelSources).values(target.source).run(); insertManyInBatches(database, externalImportBatches, target.importBatches.map(({ originalContentBase64, ...batch }) => ({ ...batch, originalBytes: originalContentBase64 === null ? null : Buffer.from(originalContentBase64, "base64") }))); insertManyInBatches(database, externalRoomMappings, target.roomMappings); insertManyInBatches(database, externalModelObjects, target.objects); }
 function ids(entries: Array<{ id: string }>) { return new Set(entries.map((entry) => entry.id)); }
 function same(left: unknown, right: unknown) { return canonical(left) === canonical(right); }
 function canonical(value: unknown): string { if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`; if (value !== null && typeof value === "object") { const record = value as Record<string, unknown>; return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`; } return JSON.stringify(value); }
diff --git a/src/db/repositories/external-initial-import-project-command.repository.ts b/src/db/repositories/external-initial-import-project-command.repository.ts
index 70a249b..ede8875 100644
--- a/src/db/repositories/external-initial-import-project-command.repository.ts
+++ b/src/db/repositories/external-initial-import-project-command.repository.ts
@@ -20,6 +20,7 @@ import { projects } from "../schema/projects.js";
 import { rooms } from "../schema/rooms.js";
 import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
 import { ExternalModelStateRepository } from "./external-model-state.repository.js";
+import { insertManyInBatches } from "./batched-insert.persistence.js";
 
 export class ExternalInitialImportProjectCommandRepository implements ExternalInitialImportProjectCommandStore {
   constructor(private readonly database: AppDatabase) {}
@@ -76,9 +77,9 @@ function replaceState(database: AppDatabase, projectId: string, target: External
   database.delete(externalModelSources).where(eq(externalModelSources.projectId, projectId)).run();
   if (!target.source) return;
   database.insert(externalModelSources).values(target.source).run();
-  database.insert(externalImportBatches).values(target.importBatches.map(({ originalContentBase64, ...batch }) => ({ ...batch, originalBytes: originalContentBase64 === null ? null : Buffer.from(originalContentBase64, "base64") }))).run();
-  if (target.roomMappings.length) database.insert(externalRoomMappings).values(target.roomMappings).run();
-  if (target.objects.length) database.insert(externalModelObjects).values(target.objects).run();
+  insertManyInBatches(database, externalImportBatches, target.importBatches.map(({ originalContentBase64, ...batch }) => ({ ...batch, originalBytes: originalContentBase64 === null ? null : Buffer.from(originalContentBase64, "base64") })));
+  insertManyInBatches(database, externalRoomMappings, target.roomMappings);
+  insertManyInBatches(database, externalModelObjects, target.objects);
 }
 
 function decodeCanonicalBase64(value: string) { const bytes = Buffer.from(value, "base64"); if (bytes.toString("base64") !== value) throw new Error("Der XLSX-Inhalt ist nicht kanonisch Base64-kodiert."); return bytes; }
diff --git a/src/db/repositories/project-state-restore-command.repository.ts b/src/db/repositories/project-state-restore-command.repository.ts
index 006b742..2386bf6 100644
--- a/src/db/repositories/project-state-restore-command.repository.ts
+++ b/src/db/repositories/project-state-restore-command.repository.ts
@@ -45,6 +45,7 @@ import { executeProjectCommandTransaction } from "./project-command-transaction.
 import {
   readProjectStateSnapshot,
 } from "./project-state-snapshot.persistence.js";
+import { insertManyInBatches } from "./batched-insert.persistence.js";
 
 export class ProjectStateRestoreCommandRepository
   implements ProjectStateRestoreCommandStore
@@ -428,11 +429,5 @@ function insertMany<TTable extends Parameters<AppDatabase["insert"]>[0]>(
   table: TTable,
   values: unknown[]
 ) {
-  if (values.length === 0) {
-    return;
-  }
-  database
-    .insert(table)
-    .values(values as never)
-    .run();
+  insertManyInBatches(database, table, values);
 }
diff --git a/src/db/repositories/project-transfer.repository.ts b/src/db/repositories/project-transfer.repository.ts
index fc73db5..c203388 100644
--- a/src/db/repositories/project-transfer.repository.ts
+++ b/src/db/repositories/project-transfer.repository.ts
@@ -37,6 +37,7 @@ import {
   readProjectStateSnapshot,
 } from "./project-state-snapshot.persistence.js";
 import { serializeProjectStateSnapshot } from "../../domain/models/project-state-snapshot.model.js";
+import { insertManyInBatches } from "./batched-insert.persistence.js";
 
 export class ProjectTransferRepository implements ProjectTransferStore {
   constructor(private readonly database: AppDatabase) {}
@@ -256,7 +257,5 @@ function insertMany<TTable extends Parameters<AppDatabase["insert"]>[0]>(
   table: TTable,
   values: unknown[]
 ) {
-  if (values.length > 0) {
-    database.insert(table).values(values as never).run();
-  }
+  insertManyInBatches(database, table, values);
 }
diff --git a/src/frontend/components/revit-object-table-model.ts b/src/frontend/components/revit-object-table-model.ts
new file mode 100644
index 0000000..2618ccc
--- /dev/null
+++ b/src/frontend/components/revit-object-table-model.ts
@@ -0,0 +1,25 @@
+import type { ExternalProjectObjectDto } from "../types";
+
+export type RevitObjectSort = "family" | "room" | "worksharing";
+
+export function filterAndSortRevitObjects(
+  objects: readonly ExternalProjectObjectDto[],
+  input: { search: string; boardFilter: string; assignmentFilter: string; sort: RevitObjectSort }
+) {
+  const needle = input.search.trim().toLocaleLowerCase("de-DE");
+  return objects.filter((object) => {
+    if (input.boardFilter !== "all" && (input.boardFilter === "none" ? object.distributionBoardId !== null : object.distributionBoardId !== input.boardFilter)) return false;
+    if (input.assignmentFilter === "unassigned" && object.circuitDeviceRowId !== null) return false;
+    if (input.assignmentFilter === "linked" && object.circuitDeviceRowId === null) return false;
+    return !needle || [object.worksharingId, object.familyAndType, object.selectionMarker, object.sourceRoomNumber, object.sourceRoomName, object.planningValues.displayName ?? ""].some((value) => value.toLocaleLowerCase("de-DE").includes(needle));
+  }).sort((leftObject, rightObject) => {
+    const left = input.sort === "family" ? leftObject.familyAndType : input.sort === "room" ? `${leftObject.sourceRoomNumber}\u0000${leftObject.sourceRoomName}` : leftObject.worksharingId;
+    const right = input.sort === "family" ? rightObject.familyAndType : input.sort === "room" ? `${rightObject.sourceRoomNumber}\u0000${rightObject.sourceRoomName}` : rightObject.worksharingId;
+    return left.localeCompare(right, "de", { numeric: true }) || leftObject.worksharingId.localeCompare(rightObject.worksharingId);
+  });
+}
+
+export function createVirtualRevitObjectWindow<T>(rows: readonly T[], scrollTop: number, rowHeight: number, viewportHeight: number, overscan = 5) {
+  const first = Math.max(0, Math.floor(scrollTop / rowHeight) - overscan);
+  return { first, rows: rows.slice(first, first + Math.ceil(viewportHeight / rowHeight) + overscan * 2) };
+}
diff --git a/src/frontend/components/revit-object-table.tsx b/src/frontend/components/revit-object-table.tsx
index d2a02d0..2ab56c9 100644
--- a/src/frontend/components/revit-object-table.tsx
+++ b/src/frontend/components/revit-object-table.tsx
@@ -3,6 +3,7 @@
 import { useEffect, useMemo, useState } from "react";
 import type { ExternalProjectObjectsDto, ExternalReturnScopeDto } from "../types";
 import { createExternalReturnWorkbook, deleteMissingExternalProjectObjects, getExternalProjectObjects, updateExternalProjectObjects } from "../utils/api";
+import { createVirtualRevitObjectWindow, filterAndSortRevitObjects, type RevitObjectSort } from "./revit-object-table-model";
 
 const rowHeight = 44;
 const viewportHeight = 520;
@@ -12,7 +13,7 @@ export function RevitObjectTable({ projectId, onRevision }: { projectId: string;
   const [search, setSearch] = useState("");
   const [boardFilter, setBoardFilter] = useState("all");
   const [assignmentFilter, setAssignmentFilter] = useState("all");
-  const [sort, setSort] = useState<"family" | "room" | "worksharing">("family");
+  const [sort, setSort] = useState<RevitObjectSort>("family");
   const [selected, setSelected] = useState<Set<string>>(new Set());
   const [scrollTop, setScrollTop] = useState(0);
   const [bulkBoard, setBulkBoard] = useState("");
@@ -33,20 +34,9 @@ export function RevitObjectTable({ projectId, onRevision }: { projectId: string;
 
   const rows = useMemo(() => {
     if (!data) return [];
-    const needle = search.trim().toLocaleLowerCase("de-DE");
-    return data.objects.filter((object) => {
-      if (boardFilter !== "all" && (boardFilter === "none" ? object.distributionBoardId !== null : object.distributionBoardId !== boardFilter)) return false;
-      if (assignmentFilter === "unassigned" && object.circuitDeviceRowId !== null) return false;
-      if (assignmentFilter === "linked" && object.circuitDeviceRowId === null) return false;
-      return !needle || [object.worksharingId, object.familyAndType, object.selectionMarker, object.sourceRoomNumber, object.sourceRoomName, object.planningValues.displayName ?? ""].some((value) => value.toLocaleLowerCase("de-DE").includes(needle));
-    }).sort((a, b) => {
-      const left = sort === "family" ? a.familyAndType : sort === "room" ? `${a.sourceRoomNumber}\u0000${a.sourceRoomName}` : a.worksharingId;
-      const right = sort === "family" ? b.familyAndType : sort === "room" ? `${b.sourceRoomNumber}\u0000${b.sourceRoomName}` : b.worksharingId;
-      return left.localeCompare(right, "de", { numeric: true }) || a.worksharingId.localeCompare(b.worksharingId);
-    });
+    return filterAndSortRevitObjects(data.objects, { search, boardFilter, assignmentFilter, sort });
   }, [data, search, boardFilter, assignmentFilter, sort]);
-  const first = Math.max(0, Math.floor(scrollTop / rowHeight) - 5);
-  const visible = rows.slice(first, first + Math.ceil(viewportHeight / rowHeight) + 10);
+  const { first, rows: visible } = createVirtualRevitObjectWindow(rows, scrollTop, rowHeight, viewportHeight);
   const selectable = rows.filter((object) => object.circuitDeviceRowId === null);
   const returnSelectable = rows.filter((object) => object.presenceStatus === "present");
   const selectedHasLinkedObject = data?.objects.some((object) => selected.has(object.id) && object.circuitDeviceRowId !== null) ?? false;
diff --git a/tests/batched-insert.persistence.test.ts b/tests/batched-insert.persistence.test.ts
new file mode 100644
index 0000000..e7b2127
--- /dev/null
+++ b/tests/batched-insert.persistence.test.ts
@@ -0,0 +1,20 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { insertManyInBatches } from "../src/db/repositories/batched-insert.persistence.js";
+import { projects } from "../src/db/schema/projects.js";
+
+describe("batched SQLite inserts", () => {
+  it("keeps every batch inside the caller transaction", () => {
+    const context = createDatabaseContext(":memory:");
+    try {
+      migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+      const values = Array.from({ length: 401 }, (_, index) => ({ id: `project-${index}`, name: `Projekt ${index}` }));
+      values[400] = { id: "project-0", name: "Duplikat" };
+      assert.throws(() => context.db.transaction((tx) => insertManyInBatches(tx, projects, values)));
+      assert.equal(context.db.select().from(projects).all().length, 0);
+    } finally { context.close(); }
+  });
+});
diff --git a/tests/fixtures/revit-xlsx-fixtures.ts b/tests/fixtures/revit-xlsx-fixtures.ts
index 48e3cbd..a4afd7f 100644
--- a/tests/fixtures/revit-xlsx-fixtures.ts
+++ b/tests/fixtures/revit-xlsx-fixtures.ts
@@ -122,6 +122,32 @@ export async function createRevitXlsxFixture(options?: {
   return new Uint8Array(await workbook.xlsx.writeBuffer());
 }
 
+export async function createLargeRevitXlsxFixture(objectCount: number) {
+  const workbook = new ExcelJS.Workbook();
+  const worksheet = workbook.addWorksheet("Linear Export");
+  worksheet.addRow([
+    "Worksharing-ID", "CAx_Auswahlkenner", "MEP-Raum: Nummer", "MEP-Raum: Name",
+    "Familie und Typ", "CAX_AnzahlObjekte", "CAx_Anmerkung", "kbp_Stromkreisnummer",
+    "kbp-E-Verteiler", "kbp-E-Stromkreis", "kbp-E-Bezeichnung",
+    "kbp-E-Elektrische Leistung", "kbp-E-Spannung", "kbp-E-Stromstärke", "IfcGUID",
+  ]);
+  worksheet.addRow([]);
+  for (let index = 0; index < objectCount; index += 1) {
+    const suffix = String(index + 1).padStart(8, "0");
+    worksheet.addRow([
+      `AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE-${suffix}`,
+      `Steckdose ${index + 1}`,
+      String(100 + (index % 250)),
+      `Raum ${index % 250}`,
+      "Steckdose: Standard",
+      (index % 4) + 1,
+      null, null, null, null, null, null, null, null,
+      `IFC-${suffix}`,
+    ]);
+  }
+  return new Uint8Array(await workbook.xlsx.writeBuffer());
+}
+
 function setRowValues(
   worksheet: ExcelJS.Worksheet,
   rowNumber: number,
diff --git a/tests/revit-xlsx-end-to-end.test.ts b/tests/revit-xlsx-end-to-end.test.ts
new file mode 100644
index 0000000..45569be
--- /dev/null
+++ b/tests/revit-xlsx-end-to-end.test.ts
@@ -0,0 +1,143 @@
+import assert from "node:assert/strict";
+import { existsSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { describe, it } from "node:test";
+import ExcelJS from "exceljs";
+import { eq } from "drizzle-orm";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { ExternalFollowUpImportProjectCommandRepository } from "../src/db/repositories/external-follow-up-import-project-command.repository.js";
+import { ExternalInitialImportProjectCommandRepository } from "../src/db/repositories/external-initial-import-project-command.repository.js";
+import { ExternalModelStateRepository } from "../src/db/repositories/external-model-state.repository.js";
+import { ExternalObjectPlanningProjectCommandRepository } from "../src/db/repositories/external-object-planning-project-command.repository.js";
+import { ExternalObjectRowAssignmentProjectCommandRepository } from "../src/db/repositories/external-object-row-assignment-project-command.repository.js";
+import { ProjectHistoryRepository } from "../src/db/repositories/project-history.repository.js";
+import { ProjectSnapshotRepository } from "../src/db/repositories/project-snapshot.repository.js";
+import { ProjectStateRestoreCommandRepository } from "../src/db/repositories/project-state-restore-command.repository.js";
+import { ProjectTransferRepository } from "../src/db/repositories/project-transfer.repository.js";
+import { readProjectStateSnapshot } from "../src/db/repositories/project-state-snapshot.persistence.js";
+import { toCircuitDeviceRowSnapshot } from "../src/db/repositories/circuit-device-row-structure.persistence.js";
+import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
+import { circuitLists } from "../src/db/schema/circuit-lists.js";
+import { circuitProtectionDevices } from "../src/db/schema/circuit-protection-devices.js";
+import { circuitSections } from "../src/db/schema/circuit-sections.js";
+import { circuits } from "../src/db/schema/circuits.js";
+import { distributionBoards } from "../src/db/schema/distribution-boards.js";
+import { externalModelConfigurations } from "../src/db/schema/external-model-configurations.js";
+import { projects } from "../src/db/schema/projects.js";
+import { createExternalFollowUpImportProjectCommand } from "../src/domain/models/external-follow-up-import-project-command.model.js";
+import { createEmptyExternalModelState, createExternalInitialImportProjectCommand } from "../src/domain/models/external-initial-import-project-command.model.js";
+import { createExternalObjectPlanningUpdateProjectCommand } from "../src/domain/models/external-object-planning-project-command.model.js";
+import { createExternalObjectRowAssignmentProjectCommand } from "../src/domain/models/external-object-row-assignment-project-command.model.js";
+import { assertProjectStateRestoreCommand } from "../src/domain/models/project-state-restore-command.model.js";
+import { createExternalXlsxFollowUpImportPlan } from "../src/external-model/application/external-xlsx-follow-up-import.js";
+import { buildExternalXlsxFollowUpTarget } from "../src/external-model/application/external-xlsx-follow-up-target.js";
+import { buildExternalXlsxInitialImportTarget } from "../src/external-model/application/external-xlsx-initial-import-target.js";
+import { createExternalXlsxInitialImportPlan } from "../src/external-model/application/external-xlsx-initial-import.js";
+import { projectExternalXlsxReturn } from "../src/external-model/application/external-xlsx-return-projection.js";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
+import { createExternalXlsxReturn } from "../src/external-model/xlsx/external-xlsx-transport.js";
+import { createRevitXlsxFixture, externalXlsxTestConfiguration, firstWorksharingId, secondWorksharingId } from "./fixtures/revit-xlsx-fixtures.js";
+
+const projectId = "project-e2e";
+const boardId = "board-e2e";
+const listId = "list-e2e";
+const sectionId = "section-e2e";
+const circuitId = "circuit-e2e";
+const rowId = "row-e2e";
+const deviceTypeA = "10000000-0000-4000-8000-000000000001";
+const deviceTypeB = "10000000-0000-4000-8000-000000000002";
+const configuration = { ...createDefaultExternalModelConfiguration(), ...externalXlsxTestConfiguration, deviceTypes: [{ id: deviceTypeA, name: "Steckdose", category: "single_phase" as const, defaults: { powerPerUnitW: 125, simultaneityFactor: 1, cosPhi: 0.9, costGroup: "440" } }, { id: deviceTypeB, name: "Leuchte", category: "lighting" as const, defaults: { powerPerUnitW: 40, simultaneityFactor: 0.8, cosPhi: null, costGroup: null } }], familyTypeRules: [{ id: "20000000-0000-4000-8000-000000000001", exactFamilyAndType: "Steckdose: Standard", deviceTypeId: deviceTypeA, quantityRule: "socketCount" as const }, { id: "20000000-0000-4000-8000-000000000002", exactFamilyAndType: "Leuchte: Decke", deviceTypeId: deviceTypeB, quantityRule: "one" as const }] };
+
+describe("Linear XLSX end-to-end", () => {
+  it("survives return, follow-up, snapshot restore, duplicate and restart undo/redo", async () => {
+    const databasePath = path.join(tmpdir(), `leistungsbilanz-r10-${randomUUID()}.sqlite`);
+    let context = createDatabaseContext(databasePath);
+    try {
+      migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+      seedProject(context.db);
+      const configurationSnapshot = { id: "config-e2e", projectId, configuration };
+      context.db.insert(externalModelConfigurations).values(configurationSnapshot).run();
+
+      const initialBytes = await createRevitXlsxFixture();
+      const initial = await createExternalXlsxInitialImportPlan({ fileName: "initial.xlsx", bytes: initialBytes, configuration, catalogs: emptyCatalogs() });
+      let sequence = 0;
+      const initialState = buildExternalXlsxInitialImportTarget({ projectId, expectedRevision: 0, sourceName: "Revit", importedAtIso: "2026-09-30T08:00:00.000Z", configuration, originalContentBase64: Buffer.from(initialBytes).toString("base64"), document: initial.document, plan: initial.plan, roomDecisions: initial.plan.sourceRooms.map((room) => ({ sourceRoomKey: room.sourceRoomKey, roomId: null, defaultDistributionBoardId: boardId })), familyProjectDeviceDecisions: initial.plan.familyGroups.map((family) => ({ familyAndType: family.familyAndType, projectDeviceId: null })), objectsWithoutRoomDefaultDistributionBoardId: boardId, createId: () => nextId("3", ++sequence) });
+      new ExternalInitialImportProjectCommandRepository(context.db).execute({ projectId, expectedRevision: 0, source: "user", command: createExternalInitialImportProjectCommand(configurationSnapshot, configurationSnapshot, createEmptyExternalModelState(), initialState) });
+
+      let state = new ExternalModelStateRepository(context.db).getByProject(projectId).state;
+      const first = state.objects.find((object) => object.worksharingId === firstWorksharingId)!;
+      const plannedFirst = { ...first, planningValues: { ...first.planningValues, remark: "Geprüft" }, overriddenFields: [...first.overriddenFields, "remark" as const] };
+      new ExternalObjectPlanningProjectCommandRepository(context.db).execute({ projectId, expectedRevision: 1, source: "user", command: createExternalObjectPlanningUpdateProjectCommand([{ expected: first, target: plannedFirst }]) });
+
+      const rowBeforeAssignment = currentRow(context.db);
+      const assignedFirst = { ...plannedFirst, distributionBoardId: boardId, circuitDeviceRowId: rowId };
+      new ExternalObjectRowAssignmentProjectCommandRepository(context.db).execute({ projectId, expectedRevision: 2, source: "user", command: createExternalObjectRowAssignmentProjectCommand({ rows: [{ expected: rowBeforeAssignment, target: { ...rowBeforeAssignment, quantity: 3 } }], objects: [{ expected: plannedFirst, target: assignedFirst }], confirmedConflictObjectIds: [first.id] }) });
+
+      state = new ExternalModelStateRepository(context.db).getByProject(projectId).state;
+      const projected = state.objects.map((object) => projectExternalXlsxReturn({ object, row: object.circuitDeviceRowId ? { rowId, displayName: "Steckdose", powerPerUnitKw: 0.125, cosPhi: 0.9, phaseType: "single_phase", category: "single_phase", circuitIdentifier: "-2F1.1", circuitVoltageV: 230, distributionBoardName: "UV 1" } : null, circuitMode: configuration.circuitMode, singlePhaseVoltageV: 230, threePhaseVoltageV: 400 }));
+      const latestBatch = state.importBatches.at(-1)!;
+      const returned = await createExternalXlsxReturn({ fileName: latestBatch.fileName, bytes: Buffer.from(latestBatch.originalContentBase64!, "base64"), configuration, selectedWorksharingIds: projected.map((entry) => entry.worksharingId), updates: projected.map((entry) => ({ worksharingId: entry.worksharingId, values: entry.values })) });
+      const workbook = new ExcelJS.Workbook(); await workbook.xlsx.load(returned.bytes); workbook.worksheets[0]!.getCell(3, 6).value = 3;
+      const followBytes = new Uint8Array(await workbook.xlsx.writeBuffer());
+      const returnValues = new Map(projected.map((entry) => [entry.objectId, entry.values]));
+      const follow = await createExternalXlsxFollowUpImportPlan({ fileName: "follow.xlsx", bytes: followBytes, configuration, catalogs: emptyCatalogs(), currentState: state, currentReturnValuesByObjectId: returnValues });
+      const built = buildExternalXlsxFollowUpTarget({ projectId, expectedRevision: 3, importedAtIso: "2026-09-30T09:00:00.000Z", configuration, originalContentBase64: Buffer.from(followBytes).toString("base64"), document: follow.document, plan: follow.plan, currentState: state, sourceChangeDecisions: follow.plan.changes.map((change) => ({ objectId: change.objectId, accept: true })), roomDecisions: follow.plan.newSourceRoomKeys.map((sourceRoomKey) => ({ sourceRoomKey, roomId: null, defaultDistributionBoardId: boardId })), familyProjectDeviceDecisions: follow.plan.newFamilyAndTypes.map((familyAndType) => ({ familyAndType, projectDeviceId: null })), objectsWithoutRoomDefaultDistributionBoardId: boardId, rowsById: new Map([[rowId, currentRow(context.db)]]), createId: () => nextId("4", ++sequence) });
+      new ExternalFollowUpImportProjectCommandRepository(context.db).execute({ projectId, expectedRevision: 3, source: "user", command: createExternalFollowUpImportProjectCommand({ expectedConfiguration: configurationSnapshot, targetConfiguration: configurationSnapshot, expectedState: state, targetState: built.targetState, rows: built.rowTransitions }) });
+      assert.equal(currentRow(context.db).quantity, 4);
+      state = new ExternalModelStateRepository(context.db).getByProject(projectId).state;
+      assert.equal(state.importBatches.length, 2);
+      assert.equal(state.importBatches[0]!.originalContentBase64, null);
+
+      const snapshot = new ProjectSnapshotRepository(context.db).createNamed({ projectId, expectedRevision: 4, name: "Nach Folgeimport" });
+      assert.ok(snapshot);
+      const second = state.objects.find((object) => object.worksharingId === secondWorksharingId)!;
+      const changedSecond = { ...second, planningValues: { ...second.planningValues, simultaneityFactor: 0.55 }, overriddenFields: [...second.overriddenFields, "simultaneityFactor" as const] };
+      new ExternalObjectPlanningProjectCommandRepository(context.db).execute({ projectId, expectedRevision: 4, source: "user", command: createExternalObjectPlanningUpdateProjectCommand([{ expected: second, target: changedSecond }]) });
+      const prepared = new ProjectSnapshotRepository(context.db).prepareRestore(projectId, snapshot.id);
+      assert.ok(prepared);
+      new ProjectStateRestoreCommandRepository(context.db).execute({ projectId, expectedRevision: 5, source: "restore", command: prepared.command });
+
+      const transferRepository = new ProjectTransferRepository(context.db);
+      const transfer = transferRepository.exportProject(projectId);
+      assert.ok(transfer);
+      const duplicate = transferRepository.importDuplicate(transfer);
+      const duplicateState = readProjectStateSnapshot(context.db, duplicate.projectId)!.state;
+      const restoredState = readProjectStateSnapshot(context.db, projectId)!.state;
+      assert.deepEqual(duplicateState.externalModel.objects.map((object) => object.worksharingId).sort(), restoredState.externalModel.objects.map((object) => object.worksharingId).sort());
+      assert.notEqual(duplicateState.externalModel.objects[0]!.id, restoredState.externalModel.objects[0]!.id);
+      assert.equal(duplicateState.externalModel.importBatches.at(-1)!.configurationSnapshot!.deviceTypes[0]!.id, duplicateState.externalModelConfiguration!.configuration.deviceTypes[0]!.id);
+
+      context.close();
+      context = createDatabaseContext(databasePath);
+      const history = new ProjectHistoryRepository(context.db);
+      const undo = history.getNextCommand(projectId, "undo");
+      assert.ok(undo); assertProjectStateRestoreCommand(undo.command);
+      new ProjectStateRestoreCommandRepository(context.db).execute({ projectId, expectedRevision: 6, source: "undo", historyTargetChangeSetId: undo.changeSetId, command: undo.command });
+      assert.equal(new ExternalModelStateRepository(context.db).getByProject(projectId).state.objects.find((object) => object.worksharingId === secondWorksharingId)!.planningValues.simultaneityFactor, 0.55);
+      const redo = history.getNextCommand(projectId, "redo");
+      assert.ok(redo); assertProjectStateRestoreCommand(redo.command);
+      new ProjectStateRestoreCommandRepository(context.db).execute({ projectId, expectedRevision: 7, source: "redo", historyTargetChangeSetId: redo.changeSetId, command: redo.command });
+      assert.equal(new ExternalModelStateRepository(context.db).getByProject(projectId).state.objects.find((object) => object.worksharingId === secondWorksharingId)!.planningValues.simultaneityFactor, 0.8);
+      assert.equal(currentRow(context.db).quantity, 4);
+    } finally {
+      context.close();
+      for (const file of [databasePath, `${databasePath}-wal`, `${databasePath}-shm`]) if (existsSync(file)) unlinkSync(file);
+    }
+  });
+});
+
+function seedProject(database: ReturnType<typeof createDatabaseContext>["db"]) {
+  database.insert(projects).values({ id: projectId, name: "R10 Projekt" }).run();
+  database.insert(distributionBoards).values({ id: boardId, projectId, name: "UV 1" }).run();
+  database.insert(circuitLists).values({ id: listId, projectId, distributionBoardId: boardId, name: "Liste" }).run();
+  database.insert(circuitSections).values({ id: sectionId, circuitListId: listId, key: "single-1", displayName: "1-phasig", prefix: "-2F1.", sortOrder: 10, category: "single_phase", groupNumber: 1 }).run();
+  database.insert(circuits).values({ id: circuitId, circuitListId: listId, sectionId, equipmentIdentifier: "-2F1.1", sortOrder: 10, voltage: 230 }).run();
+  database.insert(circuitProtectionDevices).values({ circuitId, type: "LS", ratedCurrentA: 16, fuseUtilizationCategory: null, tripCharacteristic: "B", rcdType: null, ratedResidualCurrentMa: null }).run();
+  database.insert(circuitDeviceRows).values({ id: rowId, circuitId, sortOrder: 10, name: "Steckdose", displayName: "Steckdose", phaseType: "single_phase", category: "single_phase", quantity: 1, manualQuantity: 1, powerPerUnit: 0.125, simultaneityFactor: 1, cosPhi: 0.9 }).run();
+}
+function currentRow(database: ReturnType<typeof createDatabaseContext>["db"]) { return toCircuitDeviceRowSnapshot(database.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, rowId)).get()!); }
+function emptyCatalogs() { return { floors: [], rooms: [], distributionBoards: [{ id: boardId, name: "UV 1" }], projectDevices: [] }; }
+function nextId(prefix: string, sequence: number) { return `${prefix}0000000-0000-4000-8000-${String(sequence).padStart(12, "0")}`; }
diff --git a/tests/revit-xlsx-scale.test.ts b/tests/revit-xlsx-scale.test.ts
new file mode 100644
index 0000000..386916f
--- /dev/null
+++ b/tests/revit-xlsx-scale.test.ts
@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { describe, it } from "node:test";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { ExternalInitialImportProjectCommandRepository } from "../src/db/repositories/external-initial-import-project-command.repository.js";
+import { ExternalFollowUpImportProjectCommandRepository } from "../src/db/repositories/external-follow-up-import-project-command.repository.js";
+import { ExternalModelStateRepository } from "../src/db/repositories/external-model-state.repository.js";
+import { ProjectSnapshotRepository } from "../src/db/repositories/project-snapshot.repository.js";
+import { ProjectStateRestoreCommandRepository } from "../src/db/repositories/project-state-restore-command.repository.js";
+import { ProjectTransferRepository } from "../src/db/repositories/project-transfer.repository.js";
+import { readProjectStateSnapshot } from "../src/db/repositories/project-state-snapshot.persistence.js";
+import { externalModelConfigurations } from "../src/db/schema/external-model-configurations.js";
+import { projects } from "../src/db/schema/projects.js";
+import { createEmptyExternalModelState, createExternalInitialImportProjectCommand } from "../src/domain/models/external-initial-import-project-command.model.js";
+import { createExternalFollowUpImportProjectCommand } from "../src/domain/models/external-follow-up-import-project-command.model.js";
+import { createExternalXlsxFollowUpImportPlan } from "../src/external-model/application/external-xlsx-follow-up-import.js";
+import { buildExternalXlsxFollowUpTarget } from "../src/external-model/application/external-xlsx-follow-up-target.js";
+import { buildExternalXlsxInitialImportTarget } from "../src/external-model/application/external-xlsx-initial-import-target.js";
+import { createExternalXlsxInitialImportPlan } from "../src/external-model/application/external-xlsx-initial-import.js";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
+import { createVirtualRevitObjectWindow, filterAndSortRevitObjects } from "../src/frontend/components/revit-object-table-model.js";
+import type { ExternalProjectObjectDto } from "../src/frontend/types.js";
+import { createLargeRevitXlsxFixture, externalXlsxTestConfiguration } from "./fixtures/revit-xlsx-fixtures.js";
+
+const objectCount = 5_000;
+const deviceTypeId = "10000000-0000-4000-8000-000000000001";
+const configuration = {
+  ...createDefaultExternalModelConfiguration(),
+  ...externalXlsxTestConfiguration,
+  deviceTypes: [{ id: deviceTypeId, name: "Steckdose", category: "single_phase" as const, defaults: { powerPerUnitW: 125, simultaneityFactor: 1, cosPhi: 0.9, costGroup: "440" } }],
+  familyTypeRules: [{ id: "20000000-0000-4000-8000-000000000001", exactFamilyAndType: "Steckdose: Standard", deviceTypeId, quantityRule: "socketCount" as const }],
+};
+
+describe("Linear XLSX scale", () => {
+  it("imports, persists, filters and virtualizes 5,000 synthetic objects within bounded resources", async () => {
+    const heapBefore = process.memoryUsage().heapUsed;
+    const bytes = await createLargeRevitXlsxFixture(objectCount);
+    const parseStarted = performance.now();
+    const { plan, document } = await createExternalXlsxInitialImportPlan({ fileName: "large.xlsx", bytes, configuration, catalogs: { floors: [], rooms: [], distributionBoards: [], projectDevices: [] } });
+    const parseMs = performance.now() - parseStarted;
+    assert.equal(plan.objectCount, objectCount);
+    assert.ok(bytes.byteLength < 10 * 1024 * 1024);
+
+    let sequence = 0;
+    const target = buildExternalXlsxInitialImportTarget({ projectId: "project-scale", expectedRevision: 0, sourceName: "Revit", importedAtIso: "2026-09-30T12:00:00.000Z", configuration, originalContentBase64: Buffer.from(bytes).toString("base64"), document, plan, roomDecisions: plan.sourceRooms.map((room) => ({ sourceRoomKey: room.sourceRoomKey, roomId: null, defaultDistributionBoardId: null })), familyProjectDeviceDecisions: plan.familyGroups.map((family) => ({ familyAndType: family.familyAndType, projectDeviceId: null })), objectsWithoutRoomDefaultDistributionBoardId: null, createId: () => `30000000-0000-4000-8000-${String(++sequence).padStart(12, "0")}` });
+    const configurationSnapshot = { id: "config-scale", projectId: "project-scale", configuration };
+    const command = createExternalInitialImportProjectCommand(configurationSnapshot, configurationSnapshot, createEmptyExternalModelState(), target);
+    const commandBytes = Buffer.byteLength(JSON.stringify(command));
+
+    const context = createDatabaseContext(":memory:");
+    try {
+      migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+      context.db.insert(projects).values({ id: "project-scale", name: "Lasttest" }).run();
+      context.db.insert(externalModelConfigurations).values(configurationSnapshot).run();
+      const transactionStarted = performance.now();
+      new ExternalInitialImportProjectCommandRepository(context.db).execute({ projectId: "project-scale", expectedRevision: 0, source: "user", command });
+      const transactionMs = performance.now() - transactionStarted;
+      let snapshot = readProjectStateSnapshot(context.db, "project-scale");
+      assert.ok(snapshot);
+      assert.equal(snapshot.state.externalModel.objects.length, objectCount);
+
+      const currentState = new ExternalModelStateRepository(context.db).getByProject("project-scale").state;
+      const returnValues = new Map(currentState.objects.map((object) => [object.id, { circuitCombined: object.acceptedSourceValues.circuitCombined, boardName: object.acceptedSourceValues.boardName, circuitIdentifier: object.acceptedSourceValues.circuitIdentifier, designation: object.acceptedSourceValues.designation, electricalPowerW: object.acceptedSourceValues.electricalPowerW, voltageV: object.acceptedSourceValues.voltageV, currentA: object.acceptedSourceValues.currentA }]));
+      const followParseStarted = performance.now();
+      const follow = await createExternalXlsxFollowUpImportPlan({ fileName: "large-follow.xlsx", bytes, configuration, catalogs: { floors: [], rooms: [], distributionBoards: [], projectDevices: [] }, currentState, currentReturnValuesByObjectId: returnValues });
+      const followParseMs = performance.now() - followParseStarted;
+      const followTarget = buildExternalXlsxFollowUpTarget({ projectId: "project-scale", expectedRevision: 1, importedAtIso: "2026-09-30T13:00:00.000Z", configuration, originalContentBase64: Buffer.from(bytes).toString("base64"), document: follow.document, plan: follow.plan, currentState, sourceChangeDecisions: [], roomDecisions: [], familyProjectDeviceDecisions: [], objectsWithoutRoomDefaultDistributionBoardId: null, rowsById: new Map(), createId: () => `40000000-0000-4000-8000-${String(++sequence).padStart(12, "0")}` });
+      const followCommand = createExternalFollowUpImportProjectCommand({ expectedConfiguration: configurationSnapshot, targetConfiguration: configurationSnapshot, expectedState: currentState, targetState: followTarget.targetState, rows: followTarget.rowTransitions });
+      const followTransactionStarted = performance.now();
+      new ExternalFollowUpImportProjectCommandRepository(context.db).execute({ projectId: "project-scale", expectedRevision: 1, source: "user", command: followCommand });
+      const followTransactionMs = performance.now() - followTransactionStarted;
+      const followedState = new ExternalModelStateRepository(context.db).getByProject("project-scale").state;
+      assert.equal(followedState.importBatches.length, 2);
+      assert.equal(followedState.importBatches[0]!.document, null);
+      assert.equal(followedState.objects.length, objectCount);
+
+      const namedSnapshot = new ProjectSnapshotRepository(context.db).createNamed({ projectId: "project-scale", expectedRevision: 2, name: "Lasttest" });
+      assert.ok(namedSnapshot);
+      const preparedRestore = new ProjectSnapshotRepository(context.db).prepareRestore("project-scale", namedSnapshot.id);
+      assert.ok(preparedRestore);
+      new ProjectStateRestoreCommandRepository(context.db).execute({ projectId: "project-scale", expectedRevision: 2, source: "restore", command: preparedRestore.command });
+      const transferRepository = new ProjectTransferRepository(context.db);
+      const transfer = transferRepository.exportProject("project-scale");
+      assert.ok(transfer);
+      const duplicate = transferRepository.importDuplicate(transfer);
+      assert.equal(readProjectStateSnapshot(context.db, duplicate.projectId)!.state.externalModel.objects.length, objectCount);
+      snapshot = readProjectStateSnapshot(context.db, "project-scale");
+      assert.ok(snapshot);
+
+      const clientRows: ExternalProjectObjectDto[] = target.objects.map((object) => ({ id: object.id, worksharingId: object.worksharingId, ifcGuid: object.ifcGuid, deviceTypeId: object.deviceTypeId, familyAndType: object.acceptedSourceValues.familyAndType, selectionMarker: String(object.acceptedSourceValues.selectionMarker ?? ""), sourceCircuitIdentifier: "", sourceRoomNumber: String(object.acceptedSourceValues.roomNumber ?? ""), sourceRoomName: String(object.acceptedSourceValues.roomName ?? ""), roomId: null, distributionBoardId: object.distributionBoardId, linkedProjectDeviceId: object.linkedProjectDeviceId, circuitDeviceRowId: object.circuitDeviceRowId, presenceStatus: object.presenceStatus, planningValues: object.planningValues }));
+      const clientStarted = performance.now();
+      const filtered = filterAndSortRevitObjects(clientRows, { search: "Raum 42", boardFilter: "all", assignmentFilter: "all", sort: "worksharing" });
+      const window = createVirtualRevitObjectWindow(filtered, 4_400, 44, 520);
+      const clientMs = performance.now() - clientStarted;
+      assert.ok(filtered.length > 0);
+      assert.ok(window.rows.length <= 22);
+
+      const heapDeltaBytes = Math.max(0, process.memoryUsage().heapUsed - heapBefore);
+      const snapshotBytes = Buffer.byteLength(snapshot.payloadJson);
+      assert.ok(parseMs < 15_000, `XLSX parse took ${parseMs.toFixed(0)} ms`);
+      assert.ok(transactionMs < 15_000, `Import transaction took ${transactionMs.toFixed(0)} ms`);
+      assert.ok(followParseMs < 15_000, `Follow-up parse took ${followParseMs.toFixed(0)} ms`);
+      assert.ok(followTransactionMs < 15_000, `Follow-up transaction took ${followTransactionMs.toFixed(0)} ms`);
+      assert.ok(clientMs < 1_000, `Client projection took ${clientMs.toFixed(0)} ms`);
+      assert.ok(heapDeltaBytes < 768 * 1024 * 1024, `Heap grew by ${heapDeltaBytes} bytes`);
+      assert.ok(commandBytes < 100 * 1024 * 1024);
+      console.info("R10 scale metrics", { objectCount, workbookBytes: bytes.byteLength, commandBytes, snapshotBytes, parseMs: Math.round(parseMs), transactionMs: Math.round(transactionMs), followParseMs: Math.round(followParseMs), followTransactionMs: Math.round(followTransactionMs), clientMs: Math.round(clientMs), heapDeltaBytes });
+    } finally { context.close(); }
+  });
+});

From 431f9ff0590e5507d90fac53869dcf8b8df6f67e Mon Sep 17 00:00:00 2001
From: Julian Appel <kontakt@julianappel.de>
Date: Wed, 30 Sep 2026 21:19:16 +0200
Subject: [PATCH 60/60] Normalize external model state comparisons

---
 ...ow-up-import-project-command.repository.ts |  3 ++-
 ...itial-import-project-command.repository.ts |  5 ++--
 .../domain/external-model-state-comparison.ts | 27 +++++++++++++++++++
 ...-import-project-command.repository.test.ts |  1 +
 tests/external-xlsx-initial-import.test.ts    |  1 +
 5 files changed, 34 insertions(+), 3 deletions(-)
 create mode 100644 src/external-model/domain/external-model-state-comparison.ts

diff --git a/src/db/repositories/external-follow-up-import-project-command.repository.ts b/src/db/repositories/external-follow-up-import-project-command.repository.ts
index f0b3078..e87e1af 100644
--- a/src/db/repositories/external-follow-up-import-project-command.repository.ts
+++ b/src/db/repositories/external-follow-up-import-project-command.repository.ts
@@ -6,6 +6,7 @@ import type { ExternalFollowUpImportProjectCommandStore } from "../../domain/por
 import type { CircuitDeviceRowSnapshot } from "../../domain/models/circuit-device-row-structure-project-command.model.js";
 import type { ExternalModelConfiguration } from "../../external-model/configuration/external-model-configuration.js";
 import type { ExternalModelStateSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import { externalModelStatesEqual } from "../../external-model/domain/external-model-state-comparison.js";
 import type { AppDatabase } from "../database-context.js";
 import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
 import { circuitLists } from "../schema/circuit-lists.js";
@@ -30,7 +31,7 @@ export class ExternalFollowUpImportProjectCommandRepository implements ExternalF
     return executeProjectCommandTransaction(this.database, input, (tx) => {
       const currentState = new ExternalModelStateRepository(tx).getByProject(input.projectId);
       const currentConfiguration = tx.select().from(externalModelConfigurations).where(eq(externalModelConfigurations.projectId, input.projectId)).get();
-      if (!currentState.projectExists || !currentConfiguration || !same(currentState.state, input.command.payload.expectedState) || !same(currentConfiguration, input.command.payload.expectedConfiguration)) throw new Error("Revit-Zustand oder Konfiguration wurde zwischenzeitlich geändert.");
+      if (!currentState.projectExists || !currentConfiguration || !externalModelStatesEqual(currentState.state, input.command.payload.expectedState) || !same(currentConfiguration, input.command.payload.expectedConfiguration)) throw new Error("Revit-Zustand oder Konfiguration wurde zwischenzeitlich geändert.");
       const rowIds = input.command.payload.rows.map(({ expected }) => expected.id);
       const currentRows = rowIds.length ? tx.select().from(circuitDeviceRows).where(inArray(circuitDeviceRows.id, rowIds)).all() : [];
       if (currentRows.length !== rowIds.length) throw new Error("Eine Gerätezeile des Folgeimports wurde nicht gefunden.");
diff --git a/src/db/repositories/external-initial-import-project-command.repository.ts b/src/db/repositories/external-initial-import-project-command.repository.ts
index ede8875..501cb10 100644
--- a/src/db/repositories/external-initial-import-project-command.repository.ts
+++ b/src/db/repositories/external-initial-import-project-command.repository.ts
@@ -8,6 +8,7 @@ import {
 import type { ExternalModelConfigurationSnapshot } from "../../domain/models/external-model-configuration-project-command.model.js";
 import type { ExternalInitialImportProjectCommandStore } from "../../domain/ports/external-initial-import-project-command.store.js";
 import type { ExternalModelStateSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import { externalModelStatesEqual } from "../../external-model/domain/external-model-state-comparison.js";
 import type { AppDatabase } from "../database-context.js";
 import { distributionBoards } from "../schema/distribution-boards.js";
 import { externalImportBatches } from "../schema/external-import-batches.js";
@@ -32,7 +33,7 @@ export class ExternalInitialImportProjectCommandRepository implements ExternalIn
       if (!currentStateResult.projectExists) throw new Error("Projekt nicht gefunden.");
       const currentConfiguration = tx.select().from(externalModelConfigurations).where(eq(externalModelConfigurations.projectId, input.projectId)).get() ?? null;
       const payload = input.command.payload;
-      if (!same(payload.expectedState, currentStateResult.state) || !same(payload.expectedConfiguration, currentConfiguration)) {
+      if (!externalModelStatesEqual(payload.expectedState, currentStateResult.state) || !same(payload.expectedConfiguration, currentConfiguration)) {
         throw new Error("Revit-Zustand oder Konfiguration wurde zwischenzeitlich geändert.");
       }
       if (!isEmptyExternalModelState(payload.targetState)) validateTarget(tx, input.projectId, input.expectedRevision, input.source, payload.targetConfiguration, payload.targetState);
@@ -40,7 +41,7 @@ export class ExternalInitialImportProjectCommandRepository implements ExternalIn
       replaceState(tx, input.projectId, payload.targetState);
       const persistedState = new ExternalModelStateRepository(tx).getByProject(input.projectId).state;
       const persistedConfiguration = tx.select().from(externalModelConfigurations).where(eq(externalModelConfigurations.projectId, input.projectId)).get() ?? null;
-      if (!same(payload.targetState, persistedState) || !same(payload.targetConfiguration, persistedConfiguration)) throw new Error("Gespeicherter Revit-Erstimport weicht vom Zielzustand ab.");
+      if (!externalModelStatesEqual(payload.targetState, persistedState) || !same(payload.targetConfiguration, persistedConfiguration)) throw new Error("Gespeicherter Revit-Erstimport weicht vom Zielzustand ab.");
       return createExternalInitialImportProjectCommand(payload.targetConfiguration, currentConfiguration, payload.targetState, currentStateResult.state);
     });
   }
diff --git a/src/external-model/domain/external-model-state-comparison.ts b/src/external-model/domain/external-model-state-comparison.ts
new file mode 100644
index 0000000..ff851f0
--- /dev/null
+++ b/src/external-model/domain/external-model-state-comparison.ts
@@ -0,0 +1,27 @@
+import type { ExternalModelStateSnapshot } from "./external-model-contracts.js";
+
+export function externalModelStatesEqual(left: ExternalModelStateSnapshot, right: ExternalModelStateSnapshot) {
+  return canonical(normalize(left)) === canonical(normalize(right));
+}
+
+function normalize(state: ExternalModelStateSnapshot): ExternalModelStateSnapshot {
+  return {
+    ...state,
+    importBatches: [...state.importBatches].sort((left, right) => compareNullableNumber(left.appliedProjectRevision, right.appliedProjectRevision) || compareText(left.id, right.id)),
+    roomMappings: [...state.roomMappings].sort((left, right) => compareText(left.normalizedSourceRoomKey, right.normalizedSourceRoomKey) || compareText(left.id, right.id)),
+    objects: [...state.objects].sort((left, right) => compareText(left.worksharingId, right.worksharingId) || compareText(left.id, right.id)),
+  };
+}
+
+function compareNullableNumber(left: number | null, right: number | null) {
+  if (left === right) return 0;
+  if (left === null) return -1;
+  if (right === null) return 1;
+  return left - right;
+}
+function compareText(left: string, right: string) { return left < right ? -1 : left > right ? 1 : 0; }
+function canonical(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object") { const record = value as Record<string, unknown>; return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`; }
+  return JSON.stringify(value);
+}
diff --git a/tests/external-follow-up-import-project-command.repository.test.ts b/tests/external-follow-up-import-project-command.repository.test.ts
index 8d4acf4..fcb6ae7 100644
--- a/tests/external-follow-up-import-project-command.repository.test.ts
+++ b/tests/external-follow-up-import-project-command.repository.test.ts
@@ -61,6 +61,7 @@ describe("external follow-up import project command", () => {
       const followParsed = await createExternalXlsxFollowUpImportPlan({ fileName: "follow.xlsx", bytes: followBytes, configuration, catalogs, currentState: current, currentReturnValuesByObjectId: returnValues });
       const expectedRow = toCircuitDeviceRowSnapshot(context.db.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, "row-1")).get()!);
       const built = buildExternalXlsxFollowUpTarget({ projectId: "project-1", expectedRevision: 1, importedAtIso: "2026-09-30T09:00:00.000Z", configuration, originalContentBase64: Buffer.from(followBytes).toString("base64"), document: followParsed.document, plan: followParsed.plan, currentState: current, sourceChangeDecisions: followParsed.plan.changes.map((change) => ({ objectId: change.objectId, accept: true })), roomDecisions: [], familyProjectDeviceDecisions: [], objectsWithoutRoomDefaultDistributionBoardId: null, rowsById: new Map([["row-1", expectedRow]]), createId: () => `40000000-0000-4000-8000-${String(++sequence).padStart(12, "0")}` });
+      built.targetState.objects.reverse();
       const repository = new ExternalFollowUpImportProjectCommandRepository(context.db);
       const commandWithoutRequiredRowTransition = createExternalFollowUpImportProjectCommand({ expectedConfiguration: configurationSnapshot, targetConfiguration: configurationSnapshot, expectedState: current, targetState: built.targetState, rows: [] });
       assert.throws(
diff --git a/tests/external-xlsx-initial-import.test.ts b/tests/external-xlsx-initial-import.test.ts
index 75af423..df17e23 100644
--- a/tests/external-xlsx-initial-import.test.ts
+++ b/tests/external-xlsx-initial-import.test.ts
@@ -57,6 +57,7 @@ describe("Linear XLSX initial import", () => {
       const { plan, document } = await createExternalXlsxInitialImportPlan({ fileName: "linear.xlsx", bytes, configuration, catalogs: { floors: [], rooms: [], distributionBoards: [], projectDevices: [] } });
       let sequence = 0;
       const target = buildExternalXlsxInitialImportTarget({ projectId: "project-1", expectedRevision: 0, sourceName: "Revit", importedAtIso: "2026-09-30T10:00:00.000Z", configuration, originalContentBase64: Buffer.from(bytes).toString("base64"), document, plan, roomDecisions: plan.sourceRooms.map((room) => ({ sourceRoomKey: room.sourceRoomKey, roomId: null, defaultDistributionBoardId: null })), familyProjectDeviceDecisions: plan.familyGroups.map((family) => ({ familyAndType: family.familyAndType, projectDeviceId: null })), objectsWithoutRoomDefaultDistributionBoardId: null, createId: () => `30000000-0000-4000-8000-${String(++sequence).padStart(12, "0")}` });
+      target.objects.reverse();
       const repository = new ExternalInitialImportProjectCommandRepository(context.db);
       const inserted = repository.execute({ projectId: "project-1", expectedRevision: 0, source: "user", command: createExternalInitialImportProjectCommand(configurationSnapshot, configurationSnapshot, createEmptyExternalModelState(), target) });
       assert.equal(inserted.revision.revisionNumber, 1);