Add Revit Dynamo diagnostic scripts

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>

.gitignore

@@ -4,3 +4,4 @@ dist/
 data/*.db
 data/backups/*.db
 .codex/*.log
+dynamo/output/

Dockerfile

@@ -1,10 +1,17 @@
-FROM node:22
+FROM node:24
 WORKDIR /app
 
 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

README.md

@@ -62,15 +62,29 @@ 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:
 
-- Node.js 22
+- Node.js 24
 - npm
 
 ```powershell

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

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

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
 

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(),
+    }

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(),
+    }

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.

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",

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",
@@ -10,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",
@@ -40,7 +46,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",

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 });
+}

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) {

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).*)",
+  ],
 };

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 {