deploy(prod): 2026-02-21T01:10:43Z

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN useradd -m -u 1000 user
+USER user
+
+EXPOSE 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -0,0 +1,10 @@
+---
+title: IFCore Platform
+emoji: "\U0001F3D7\uFE0F"
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+---
+
+IFC compliance checker backend. Auto-discovers `check_*` functions from team modules.

deploy.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# --- Target selection (default: staging for safety) ---
+TARGET="${1:-staging}"
+case "$TARGET" in
+    staging) HF_REPO="${HF_REPO:-serJD/ifcore-platform-staging}" ;;
+    prod)    HF_REPO="${HF_REPO:-serJD/ifcore-platform}" ;;
+    *)       echo "Usage: deploy.sh [staging|prod]"; exit 1 ;;
+esac
+
+echo "Deploying to $TARGET -> https://huggingface.co/spaces/$HF_REPO"
+
+cd "$SCRIPT_DIR"
+
+git -C "$SCRIPT_DIR/.." submodule update --init --recursive --remote
+
+TMPDIR=$(mktemp -d)
+trap 'rm -rf "$TMPDIR"' EXIT
+
+rsync -a --exclude='.git' --exclude='__pycache__' \
+    --exclude='*.pdf' --exclude='*.png' --exclude='*.jpg' --exclude='*.jpeg' \
+    --exclude='*.gif' --exclude='*.zip' --exclude='*.mp4' --exclude='*.mov' \
+    --exclude='*.ifc' --exclude='*.ifczip' --exclude='*.glb' --exclude='*.obj' \
+    . "$TMPDIR/"
+
+find "$TMPDIR/teams" -name ".git" -type f -delete 2>/dev/null || true
+find "$TMPDIR/teams" -name ".git" -type d -exec rm -rf {} + 2>/dev/null || true
+
+cd "$TMPDIR"
+
+git init -b main
+git config user.email "deploy@ifcore"
+git config user.name "IFCore Deploy"
+git add .
+git commit --no-gpg-sign -m "deploy($TARGET): $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+# Use token auth in CI (set HF_TOKEN env var or GitHub secret)
+if [ -n "${HF_TOKEN:-}" ]; then
+    HF_REMOTE="https://serJD:${HF_TOKEN}@huggingface.co/spaces/$HF_REPO"
+else
+    HF_REMOTE="https://huggingface.co/spaces/$HF_REPO"
+fi
+git remote add hf "$HF_REMOTE"
+git push hf main --force
+
+echo "Deployed to https://huggingface.co/spaces/$HF_REPO"

main.py

@@ -0,0 +1,475 @@
+import os
+import asyncio
+import base64
+import uuid
+import logging
+import tempfile
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Optional
+import httpx
+from fastapi import FastAPI, BackgroundTasks
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent, RunContext
+from pydantic_ai.usage import UsageLimits
+from orchestrator import discover_checks, run_all_checks
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("ifcore")
+
+# In-memory job store — CF Worker polls this
+_jobs: dict = {}
+
+# ---------------------------------------------------------------------------
+# Regulation knowledge base — Spanish / Catalan building bye-laws
+# Each entry contains the official regulation, article/section reference,
+# PDF link, content reference, compliance threshold, and required action.
+# ---------------------------------------------------------------------------
+REGULATIONS_KB: dict[str, dict] = {
+    "walls": {
+        "regulation": "CTE DB SE-F — Seguridad Estructural: Cimientos",
+        "reference": "CTE DB SE-F, Section 4.1 (Muros); EHE-08, Art. 23",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/SE/DBSEF.pdf",
+        "page_ref": "Section 4.1, p. 14 — Minimum wall thickness 100 mm",
+        "threshold": "Minimum wall thickness: ≥ 100 mm",
+        "action": (
+            "Increase wall thickness to ≥ 100 mm. For load-bearing walls, a qualified "
+            "structural engineer must verify revised stability calculations under CTE DB SE. "
+            "Update architectural and structural drawings accordingly."
+        ),
+    },
+    "beams": {
+        "regulation": "EHE-08 — Instrucción de Hormigón Estructural",
+        "reference": "EHE-08, Art. 23 (Vigas) and Art. 42.3 (Dimensiones mínimas)",
+        "pdf": "https://www.mitma.gob.es/recursos_mfom/0820200.pdf",
+        "page_ref": "Art. 23.1, p. 62 — Minimum depth 200 mm; Art. 23.2 — Minimum width 150 mm",
+        "threshold": "Minimum beam depth: ≥ 200 mm; minimum beam width: ≥ 150 mm",
+        "action": (
+            "Redesign beam cross-section to achieve depth ≥ 200 mm and width ≥ 150 mm. "
+            "Recheck load and deflection calculations. Have a licensed structural engineer "
+            "verify and sign off the revised design. Update structural drawings."
+        ),
+    },
+    "columns": {
+        "regulation": "EHE-08 — Instrucción de Hormigón Estructural",
+        "reference": "EHE-08, Art. 24 (Pilares) and Art. 42.3",
+        "pdf": "https://www.mitma.gob.es/recursos_mfom/0820200.pdf",
+        "page_ref": "Art. 24.1, p. 65 — Minimum column dimension 250 mm",
+        "threshold": "Minimum column dimension: ≥ 250 mm",
+        "action": (
+            "Increase the smaller column dimension to ≥ 250 mm. Re-evaluate reinforcement "
+            "ratios and load capacity. Update column schedule and structural calculations. "
+            "Coordinate changes with the foundation design."
+        ),
+    },
+    "foundations": {
+        "regulation": "CTE DB SE-C — Seguridad Estructural: Cimientos; EHE-08",
+        "reference": "EHE-08, Art. 69 (Cimentaciones); CTE DB SE-C, Section 4.1",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/SE/DBSEC.pdf",
+        "page_ref": "Art. 69.1 — Minimum foundation element depth 200 mm; DB SE-C Section 4.1, p. 18",
+        "threshold": "Minimum foundation depth: ≥ 200 mm",
+        "action": (
+            "Deepen or redesign foundation elements to ≥ 200 mm. If a geotechnical study "
+            "has not been done, commission one. Submit revised foundation drawings to the "
+            "project certifier. Ensure compliance with DB SE-C soil bearing capacity requirements."
+        ),
+    },
+    "slabs": {
+        "regulation": "CTE DB HE — Ahorro de Energía; EHE-08",
+        "reference": "CTE DB HE1, Table 2.3 (Transmitancias límite); EHE-08, Art. 22",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/HE/DBHE.pdf",
+        "page_ref": "HE1 Table 2.3, p. 11 — Slab thickness 150–200 mm; Art. 22 structural dimensions",
+        "threshold": "Slab thickness: 150–200 mm",
+        "action": (
+            "Adjust slab thickness to the 150–200 mm range. Verify structural load capacity "
+            "for the revised thickness. If thermal performance is affected, recalculate U-values "
+            "for the slab assembly using HULC or equivalent CTE tool."
+        ),
+    },
+    "doors": {
+        "regulation": "CTE DB SUA — Seguridad de Utilización y Accesibilidad",
+        "reference": "CTE DB SUA, SUA-9 (Accesibilidad), Section 1.1.1 and Table 2.1",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/SUA/DBSUA.pdf",
+        "page_ref": "SUA-9 Section 1.1.1, p. 47 — Minimum door clear width 800 mm; Table 2.1, p. 49",
+        "threshold": "Minimum door clear width: ≥ 800 mm",
+        "action": (
+            "Replace or widen door frames to achieve ≥ 800 mm clear passage width. "
+            "For full wheelchair access, 900 mm is recommended. Update the door schedule "
+            "in architectural drawings. In Catalan projects, also verify Decreto 141/2012."
+        ),
+    },
+    "windows": {
+        "regulation": "CTE DB SUA — Seguridad de Utilización y Accesibilidad",
+        "reference": "CTE DB SUA, SUA-1, Section 2.1 (Protección frente al riesgo de caída)",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/SUA/DBSUA.pdf",
+        "page_ref": "SUA-1 Section 2.1, p. 6 — Minimum window sill height 1200 mm above finished floor",
+        "threshold": "Minimum window sill height: ≥ 1200 mm, or protective barrier required",
+        "action": (
+            "Raise window sill to ≥ 1200 mm above finished floor level, or install a "
+            "compliant protective barrier (parapet or railing) at the required height. "
+            "Verify glazing impact resistance under CTE DB SUA-2."
+        ),
+    },
+    "corridors": {
+        "regulation": "CTE DB SUA — Accesibilidad; Decreto 141/2012 (Catalonia)",
+        "reference": "CTE DB SUA, SUA-9, Table 2.1; Decreto 141/2012, Art. 18",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/SUA/DBSUA.pdf",
+        "page_ref": "SUA-9 Table 2.1, p. 49 — Min. corridor width ≥ 1200 mm (public); ≥ 1100 mm (housing); Decreto 141/2012 Art. 18",
+        "threshold": "Minimum corridor width: ≥ 1100 mm in dwellings; ≥ 1200 mm in public routes",
+        "action": (
+            "Widen corridor to the applicable minimum. Revise floor-plan layout if needed. "
+            "For Catalan housing projects, additionally verify Decreto 141/2012 Art. 18 "
+            "(PDF: https://portaldogc.gencat.cat/utilsEADOP/PDF/6138/1223437.pdf)."
+        ),
+    },
+    "ceiling": {
+        "regulation": "CTE DB SUA — Accesibilidad; Decreto 141/2012 (Catalonia)",
+        "reference": "CTE DB SUA, SUA-9, Section 1.1; Decreto 141/2012, Art. 15",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/SUA/DBSUA.pdf",
+        "page_ref": "SUA-9 Section 1.1, p. 47 — Minimum clear ceiling height 2200 mm; Decreto 141/2012 Art. 15",
+        "threshold": "Minimum clear ceiling height: ≥ 2200 mm (≥ 2500 mm in Catalan living spaces)",
+        "action": (
+            "Increase floor-to-ceiling clear height to ≥ 2200 mm. Review structural floor "
+            "depth and finish build-up. For Catalan housing, Decreto 141/2012 Art. 15 requires "
+            "≥ 2500 mm in habitable rooms — verify and revise section drawings."
+        ),
+    },
+    "stairs": {
+        "regulation": "CTE DB SUA — Seguridad de Utilización y Accesibilidad",
+        "reference": "CTE DB SUA, SUA-1, Section 4.2.1 (Escaleras de uso general)",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/SUA/DBSUA.pdf",
+        "page_ref": "SUA-1 Section 4.2.1, p. 12 — Riser 130–185 mm; Tread ≥ 280 mm; formula: 2R + H = 620–640 mm",
+        "threshold": "Stair riser: 130–185 mm; stair tread: ≥ 280 mm",
+        "action": (
+            "Redesign stair geometry so riser falls within 130–185 mm and tread is ≥ 280 mm. "
+            "Apply the ergonomic formula: 2×riser + tread = 620–640 mm. "
+            "Update stair detail drawings and structural calculations."
+        ),
+    },
+    "railings": {
+        "regulation": "CTE DB SUA — Seguridad de Utilización y Accesibilidad",
+        "reference": "CTE DB SUA, SUA-1, Section 3.2.1 (Protección en los bordes de los forjados)",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/SUA/DBSUA.pdf",
+        "page_ref": "SUA-1 Section 3.2.1, p. 9 — Min. height 900 mm; ≥ 1100 mm where drop > 6 m",
+        "threshold": "Minimum railing height: ≥ 900 mm; ≥ 1100 mm where floor-to-ground > 6 m",
+        "action": (
+            "Raise railing/balustrade to ≥ 900 mm (or ≥ 1100 mm where applicable). "
+            "Ensure baluster spacing ≤ 100 mm to prevent climbing. "
+            "Verify structural fixing adequacy under CTE DB SE."
+        ),
+    },
+    "energy": {
+        "regulation": "CTE DB HE — Ahorro de Energía",
+        "reference": "CTE DB HE, HE1, Section 2.2 (Transmitancia térmica máxima de cerramientos)",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/HE/DBHE.pdf",
+        "page_ref": "HE1 Table 2.3, p. 11 — Maximum wall U-value 0.80 W/m²K (Climate Zone B)",
+        "threshold": "Maximum wall U-value: ≤ 0.80 W/m²K (Spain Climate Zone B)",
+        "action": (
+            "Add or upgrade thermal insulation in the wall assembly to bring U-value below "
+            "0.80 W/m²K. Use HULC or CYPETHERM software to recalculate. Specify insulation "
+            "type, thickness, and λ-value on building specifications."
+        ),
+    },
+    "fire": {
+        "regulation": "CTE DB SI — Seguridad en caso de Incendio",
+        "reference": "CTE DB SI, SI-2 (Propagación interior); SI-6 (Resistencia al fuego)",
+        "pdf": "https://www.codigotecnico.org/pdf/Documentos/SI/DBSI.pdf",
+        "page_ref": "DB SI Table 1.2, p. 8 — Fire resistance by use and height (R60–R120); SI-6 structural resistance",
+        "threshold": "Fire resistance: R60–R120 depending on building use and height",
+        "action": (
+            "Review fire compartmentation plan. Ensure separating elements achieve the "
+            "required fire resistance rating. Apply appropriate fireproofing to structural "
+            "members. Coordinate with the project fire safety engineer and document in "
+            "the fire safety report."
+        ),
+    },
+    "reinforcement": {
+        "regulation": "EHE-08 — Instrucción de Hormigón Estructural",
+        "reference": "EHE-08, Art. 42 (Recubrimientos) and Art. 58 (Cuantías mínimas de armadura)",
+        "pdf": "https://www.mitma.gob.es/recursos_mfom/0820200.pdf",
+        "page_ref": "Art. 42.1, p. 88 — Cover 20–45 mm by exposure class; Art. 58, p. 112 — Min. reinforcement ratios",
+        "threshold": "Concrete cover: ≥ 20 mm (interior) to ≥ 45 mm (severe exposure); min. reinforcement ratio per Art. 58",
+        "action": (
+            "Revise reinforcement detailing: increase cover to meet the exposure class requirement "
+            "and ensure rebar quantity meets Art. 58 minimum ratios. Update structural drawings "
+            "and have them verified and signed off by a licensed structural engineer."
+        ),
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# PydanticAI — deps + agent definition
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ChatDeps:
+    check_results: list[dict]
+    element_results: list[dict]
+
+
+_chat_agent: Agent | None = None
+
+
+def _get_chat_agent() -> Agent:
+    global _chat_agent
+    if _chat_agent is not None:
+        return _chat_agent
+
+    _chat_agent = Agent(
+        "google-gla:gemini-2.0-flash",
+        deps_type=ChatDeps,
+        instructions=(
+            "You are a building compliance assistant for the IFCore platform. "
+            "You answer questions about IFC model compliance check results.\n\n"
+            "FORMATTING — the chat UI renders markdown, so use it:\n"
+            "- Use **bold** for element names and key values.\n"
+            "- Use `inline code` for IFC type names and property names.\n"
+            "- Use bullet lists (- item) for multiple items.\n"
+            "- Use [link text](url) for ALL URLs — never paste bare URLs.\n"
+            "- Use > blockquotes for regulation citations or ads.\n"
+            "- Use --- for horizontal rules.\n"
+            "- Keep paragraphs short. Use line breaks between sections.\n\n"
+            "RESPONSE RULES — follow every time:\n"
+            "1. Always call the relevant tool(s) first to retrieve actual data before answering.\n"
+            "2. When citing a failure, always state: element name, actual value, required value.\n"
+            "3. For every bye-law reference, you MUST quote: the bye-law name, "
+            "the PDF link (as a markdown link), and the specific article/section/page or content number.\n"
+            "4. Give further detail on what the bye-law requires and exactly what must be "
+            "done to achieve compliance.\n"
+            "5. Use ✅/❌ for pass/fail status indicators.\n"
+            "6. Be specific and factual — no vague generalisations.\n"
+            "7. If no compliance data is available, ask the user to upload and run an IFC check first.\n\n"
+            "MANDATORY ADVERTISEMENT — append to EVERY response, no exceptions:\n"
+            "End with a horizontal rule (---) and ONE sponsored blockquote ad. "
+            "Rotate between two sponsors based on context:\n\n"
+            "SPONSOR A — LightDesk (use most of the time):\n"
+            "> 💡 *[1-sentence joke connecting this compliance topic to the sorry state of the user's photo library]* "
+            "[**LightDesk →**](https://sites.run8n.xyz/lightdesk/) *Your photos. Cloudlessly alive.*\n\n"
+            "SPONSOR B — ULTRAVIOLET.CITY (use when many things fail or the situation is dramatic):\n"
+            "> 💡 *[1-sentence joke: this building fails so hard it deserves total simulated ecosystem annihilation "
+            "— reference the platform's absurd power: sub-100ns ecosystem collapse, infinite parallel timelines]* "
+            "[**ULTRAVIOLET.CITY →**](https://sites.run8n.xyz/ultraviolet-city/) *Design. Obliterate. Transcend.*\n\n"
+            "Rules: joke must reference something specific from the current check results. 1 sentence max. Always include the link as a markdown link."
+        ),
+    )
+
+    # ── Tool 1: overall summary ──────────────────────────────────────────
+    @_chat_agent.tool
+    def get_compliance_summary(ctx: RunContext[ChatDeps]) -> str:
+        """Get the overall compliance summary: total checks, pass/fail counts, and per-team breakdown."""
+        crs = ctx.deps.check_results
+        if not crs:
+            return "No compliance data available. Ask the user to upload and run an IFC check first."
+
+        total = len(crs)
+        passed = sum(1 for cr in crs if cr.get("status") == "pass")
+        failed = sum(1 for cr in crs if cr.get("status") == "fail")
+        other = total - passed - failed
+
+        lines = [f"Total checks: {total} | Pass: {passed} | Fail: {failed} | Other: {other}"]
+
+        teams: dict[str, dict] = {}
+        for cr in crs:
+            team = cr.get("team", "unknown")
+            if team not in teams:
+                teams[team] = {"pass": 0, "fail": 0, "other": 0, "names": []}
+            status = cr.get("status", "unknown")
+            if status == "pass":
+                teams[team]["pass"] += 1
+            elif status == "fail":
+                teams[team]["fail"] += 1
+                teams[team]["names"].append(cr.get("check_name", "?"))
+            else:
+                teams[team]["other"] += 1
+
+        lines.append("\nTeam breakdown:")
+        for team, counts in teams.items():
+            detail = ""
+            if counts["names"]:
+                detail = f" — failing: {', '.join(counts['names'][:5])}"
+            lines.append(f"  {team}: {counts['pass']} pass, {counts['fail']} fail{detail}")
+
+        return "\n".join(lines)
+
+    # ── Tool 2: search failing elements ─────────────────────────────────
+    @_chat_agent.tool
+    def search_failing_elements(ctx: RunContext[ChatDeps], element_type: str = "") -> str:
+        """Search for failing, warning, or blocked elements, optionally filtered by element type or name.
+
+        Args:
+            element_type: Optional keyword to filter by — e.g. 'IfcWall', 'beam', 'door', 'column'.
+                          Leave empty to return all failures.
+        """
+        ers = ctx.deps.element_results
+        failing = [e for e in ers if e.get("check_status") in ("fail", "warning", "blocked")]
+
+        if element_type:
+            q = element_type.lower()
+            failing = [
+                e for e in failing
+                if q in (e.get("element_type") or "").lower()
+                or q in (e.get("element_name") or "").lower()
+                or q in (e.get("comment") or "").lower()
+            ]
+
+        if not failing:
+            suffix = f" matching '{element_type}'" if element_type else ""
+            return f"No failing/warning elements found{suffix}."
+
+        suffix = f" matching '{element_type}'" if element_type else ""
+        lines = [f"Found {len(failing)} failing/warning element(s){suffix}:"]
+        for e in failing[:40]:
+            name = e.get("element_name") or e.get("element_type") or "Unknown"
+            comment = (e.get("comment") or "")[:180]
+            lines.append(
+                f"  [{e.get('check_status', '?').upper()}] **{name}** — "
+                f"actual: {e.get('actual_value', 'N/A')}, "
+                f"required: {e.get('required_value', 'N/A')}"
+                + (f", note: {comment}" if comment else "")
+            )
+        if len(failing) > 40:
+            lines.append(f"  … and {len(failing) - 40} more elements.")
+        return "\n".join(lines)
+
+    # ── Tool 3: regulation lookup ────────────────────────────────────────
+    @_chat_agent.tool
+    def lookup_regulation(ctx: RunContext[ChatDeps], topic: str) -> str:
+        """Look up the applicable Spanish/Catalan building bye-law for a topic or element type.
+        Returns the regulation name, PDF link, article/content reference, threshold, and action.
+
+        Args:
+            topic: The element type or compliance topic — e.g. 'beam', 'wall', 'door',
+                   'foundation', 'fire', 'energy', 'reinforcement', 'stairs', 'railing'.
+        """
+        q = topic.lower()
+
+        # Score candidates: 0 = key match, 1 = content match
+        matches: list[tuple[int, dict]] = []
+        for key, data in REGULATIONS_KB.items():
+            if q in key or key in q:
+                matches.append((0, data))
+            elif any(q in str(v).lower() for v in data.values()):
+                matches.append((1, data))
+
+        if not matches:
+            return (
+                f"No specific bye-law found for '{topic}'. "
+                "Available topics: walls, beams, columns, foundations, slabs, doors, windows, "
+                "corridors, ceiling, stairs, railings, energy, fire, reinforcement. "
+                "Try one of these terms."
+            )
+
+        matches.sort(key=lambda x: x[0])
+        d = matches[0][1]
+        return (
+            f"**Bye-law: {d['regulation']}**\n"
+            f"**Reference:** {d['reference']}\n"
+            f"**PDF:** {d['pdf']}\n"
+            f"**Content/Page:** {d['page_ref']}\n"
+            f"**Threshold:** {d['threshold']}\n"
+            f"**Required action:** {d['action']}"
+        )
+
+    return _chat_agent
+
+
+class ChatRequest(BaseModel):
+    message: str = Field(max_length=2000)
+    check_results: list[dict] = Field(default_factory=list, max_length=50)
+    element_results: list[dict] = Field(default_factory=list, max_length=200)
+
+
+@asynccontextmanager
+async def lifespan(app):
+    yield
+
+app = FastAPI(title="IFCore Platform", lifespan=lifespan)
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+
+class CheckRequest(BaseModel):
+    ifc_url: Optional[str] = None     # URL to download IFC from
+    ifc_b64: Optional[str] = None     # Base64-encoded IFC bytes (preferred — avoids DNS issues)
+    project_id: Optional[str] = None
+
+
+@app.get("/health")
+def health():
+    checks = discover_checks()
+    return {"status": "ok", "checks_discovered": len(checks),
+            "checks": [{"team": t, "name": n} for t, n, _ in checks]}
+
+
+@app.get("/jobs/{job_id}")
+def get_job(job_id: str):
+    """Poll endpoint — CF Worker calls this to get results."""
+    job = _jobs.get(job_id)
+    if not job:
+        return {"job_id": job_id, "status": "unknown"}
+    return job
+
+
+@app.post("/check")
+async def check(req: CheckRequest, background_tasks: BackgroundTasks):
+    job_id = str(uuid.uuid4())
+    _jobs[job_id] = {"job_id": job_id, "status": "running"}
+    logger.info(f"[{job_id}] queued (b64={req.ifc_b64 is not None}, url={req.ifc_url})")
+    background_tasks.add_task(run_check_job, req.ifc_url, req.ifc_b64, job_id, req.project_id)
+    return {"job_id": job_id, "status": "running"}
+
+
+@app.post("/chat")
+async def chat_endpoint(req: ChatRequest):
+    deps = ChatDeps(
+        check_results=req.check_results,
+        element_results=req.element_results,
+    )
+    try:
+        result = await asyncio.wait_for(
+            _get_chat_agent().run(
+                req.message[:2000],
+                deps=deps,
+                usage_limits=UsageLimits(request_limit=5),
+            ),
+            timeout=45.0,
+        )
+        return {"response": result.output}
+    except asyncio.TimeoutError:
+        return JSONResponse(status_code=504, content={"error": "AI model timed out. Please try again."})
+    except Exception as e:
+        logger.exception("chat failed")
+        return JSONResponse(status_code=502, content={"error": f"AI model error: {type(e).__name__}"})
+
+
+def run_check_job(ifc_url, ifc_b64, job_id, project_id):
+    try:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            ifc_path = os.path.join(tmpdir, "model.ifc")
+
+            if ifc_b64:
+                logger.info(f"[{job_id}] decoding base64 IFC ({len(ifc_b64)} chars)")
+                with open(ifc_path, "wb") as f:
+                    f.write(base64.b64decode(ifc_b64))
+            elif ifc_url:
+                logger.info(f"[{job_id}] downloading {ifc_url}")
+                with httpx.Client(timeout=120) as client:
+                    resp = client.get(ifc_url)
+                    resp.raise_for_status()
+                    with open(ifc_path, "wb") as f:
+                        f.write(resp.content)
+            else:
+                raise ValueError("Either ifc_url or ifc_b64 must be provided")
+
+            logger.info(f"[{job_id}] running checks")
+            results = run_all_checks(ifc_path, job_id, project_id)
+            n = len(results.get("check_results", []))
+            logger.info(f"[{job_id}] done: {n} checks")
+            _jobs[job_id] = {"job_id": job_id, "status": "done", **results}
+
+    except Exception as exc:
+        logger.exception(f"[{job_id}] failed: {exc}")
+        _jobs[job_id] = {"job_id": job_id, "status": "error", "error": str(exc),
+                         "check_results": [], "element_results": []}

orchestrator.py

@@ -0,0 +1,106 @@
+import importlib.util
+import os
+import glob
+import uuid
+import time
+import logging
+import ifcopenshell
+
+logger = logging.getLogger("ifcore")
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+TEAM_FIELDS = [
+    "element_id", "element_type", "element_name", "element_name_long",
+    "check_status", "actual_value", "required_value", "comment", "log",
+]
+
+
+def discover_checks():
+    checks = []
+    pattern = os.path.join(BASE_DIR, "teams", "*", "tools", "checker_*.py")
+    for path in sorted(glob.glob(pattern)):
+        parts = path.replace(BASE_DIR + os.sep, "").split(os.sep)
+        team = parts[1]
+        module_name = os.path.splitext(os.path.basename(path))[0]
+        try:
+            spec = importlib.util.spec_from_file_location(f"teams.{team}.{module_name}", path)
+            mod = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(mod)
+            for attr in dir(mod):
+                if attr.startswith("check_") and callable(getattr(mod, attr)):
+                    checks.append((team, attr, getattr(mod, attr)))
+        except Exception as exc:
+            logger.warning(f"[discover] skipping {team}/{module_name}: {exc}")
+    return checks
+
+
+def _aggregate_status(elements):
+    statuses = [e.get("check_status", "blocked") for e in elements]
+    if any(s == "fail" for s in statuses):
+        return "fail"
+    if any(s == "warning" for s in statuses):
+        return "warning"
+    if all(s in ("pass", "log") for s in statuses):
+        return "pass"
+    return "unknown"
+
+
+def _build_summary(elements):
+    p = sum(1 for e in elements if e.get("check_status") == "pass")
+    f = sum(1 for e in elements if e.get("check_status") == "fail")
+    w = sum(1 for e in elements if e.get("check_status") == "warning")
+    b = sum(1 for e in elements if e.get("check_status") == "blocked")
+    total = len(elements)
+    parts = []
+    if p: parts.append(f"{p} pass")
+    if f: parts.append(f"{f} fail")
+    if w: parts.append(f"{w} warning")
+    if b: parts.append(f"{b} blocked")
+    return f"{total} elements: {', '.join(parts)}" if parts else f"{total} elements"
+
+
+def run_all_checks(ifc_path, job_id, project_id):
+    model = ifcopenshell.open(ifc_path)
+    checks = discover_checks()
+    check_results = []
+    element_results = []
+
+    for team, func_name, func in checks:
+        check_id = str(uuid.uuid4())
+        try:
+            elements = func(model)
+            status = _aggregate_status(elements)
+            summary = _build_summary(elements)
+
+            check_results.append({
+                "id": check_id,
+                "job_id": job_id,
+                "project_id": project_id,
+                "check_name": func_name,
+                "team": team,
+                "status": status,
+                "summary": summary,
+                "has_elements": 1 if elements else 0,
+                "created_at": int(time.time() * 1000),
+            })
+
+            for el in elements:
+                row = {"id": str(uuid.uuid4()), "check_result_id": check_id}
+                for field in TEAM_FIELDS:
+                    row[field] = el.get(field)
+                element_results.append(row)
+        except Exception as exc:
+            check_results.append({
+                "id": check_id,
+                "job_id": job_id,
+                "project_id": project_id,
+                "check_name": func_name,
+                "team": team,
+                "status": "error",
+                "summary": str(exc)[:200],
+                "has_elements": 0,
+                "created_at": int(time.time() * 1000),
+            })
+
+    return {"check_results": check_results, "element_results": element_results}

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.115.0
+uvicorn[standard]==0.32.0
+ifcopenshell>=0.8.1
+httpx==0.28.0
+python-multipart==0.0.20
+pydantic-ai-slim[google]

teams/Mastodonte/.claude/skills/IFCore-skill/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: IFCore
+description: Use when developing on the IFCore compliance checker. Covers contracts, check function conventions, issue reporting, app structure, and development patterns.
+---
+
+# IFCore — Company Skill
+
+> **Living document.** Sections marked [TBD] are decided in board meetings.
+> When a [TBD] is resolved, update this skill and tell your agent to adapt.
+
+## When This Skill Activates
+
+Welcome the user. Introduce yourself as their IFCore development assistant. Explain:
+
+1. **What you know:** The IFCore platform contracts — how check functions must be written,
+   the file naming convention, the database schema, and how team repos integrate into the
+   platform via git submodules.
+
+2. **What you can do:**
+   - Help write `check_*` functions that comply with the platform contracts
+   - Review existing code for contract compliance
+   - Explain IFC file structure and ifcopenshell patterns
+   - Help with feature planning (PRDs, user stories)
+   - File issues to the shared skills repo when contracts are unclear
+
+3. **Offer a codebase review.** Ask to scan the current repo and check:
+   - Are `checker_*.py` files directly inside `tools/`?
+   - Do all `check_*` functions follow the contract (signature, return type)?
+   - Is there anything that would block platform integration?
+
+4. **Respect their setup.** Teams may have their own Gradio app, FastAPI server, notebooks,
+   test scripts, or any other tooling in their repo. **That's fine.** The platform only cares
+   about `tools/checker_*.py` files — everything else is ignored during integration.
+   The only hard rule: don't put anything in `tools/` that breaks the `checker_*.py` import
+   chain (e.g. conflicting `__init__.py` files or dependencies not in `requirements.txt`).
+
+5. **Offer to explain Agent Skills.** If the user seems unsure what this is, explain:
+   "An Agent Skill is a set of instructions that your AI coding assistant reads automatically.
+   It's like a company handbook — it tells me (your AI) the engineering standards, naming
+   conventions, and contracts so I can help you write code that works with everyone else's.
+   You installed it once; now I follow it in every conversation."
+
+6. **How to install & update this skill.** Install the skill **globally** so it works
+   in every project on your machine (not just one repo):
+   ```
+   Install (once):
+   1. Clone: git clone https://github.com/SerjoschDuering/iaac-bimwise-skills.git
+      (put it somewhere permanent, e.g. ~/skills/ or ~/Documents/)
+   2. Add the skill GLOBALLY in your AI coding tool:
+      - VS Code/Copilot: Chat panel → Add Agent Skill → pick the SKILL.md file.
+        Use "User" scope (not "Workspace") so it applies to ALL projects.
+      - Cursor: Settings → Agent Skills → Add → point to the cloned folder.
+        This is global by default.
+      - Claude Code: add to ~/.claude/settings.json under agent skills,
+        or install as a plugin — it applies to all sessions automatically.
+   3. Start a new chat session — your AI now knows IFCore standards.
+
+   Update (after board meetings):
+   1. cd into your cloned skills folder
+   2. git pull
+   3. Start a fresh chat session — the AI reloads the updated instructions
+   ```
+   If you're not sure whether your skill is up to date, ask your AI:
+   "What board meeting is the latest in your IFCore skill?" and compare with your team.
+
+## Contracts — READ THIS FIRST
+
+These contracts are how teams stay aligned. The platform auto-discovers your code.
+Break a contract → the platform silently skips your checks. Follow them → it just works.
+
+### 1. Check Function Contract
+
+```python
+# Function naming: check_<what>
+# Location: tools/checker_*.py (directly inside tools/, no subdirectories)
+# Signature: first arg is always the ifcopenshell model
+# Return: list[dict] — one dict per element, maps to element_results DB rows
+
+def check_door_width(model, min_width_mm=800):
+    results = []
+    for door in model.by_type("IfcDoor"):
+        width_mm = round(door.OverallWidth * 1000) if door.OverallWidth else None
+        results.append({
+            "element_id":       door.GlobalId,
+            "element_type":     "IfcDoor",
+            "element_name":     door.Name or f"Door #{door.id()}",
+            "element_name_long": f"{door.Name} (Level 1, Zone A)",
+            "check_status":     "blocked" if width_mm is None
+                                else "pass" if width_mm >= min_width_mm
+                                else "fail",
+            "actual_value":     f"{width_mm} mm" if width_mm else None,
+            "required_value":   f"{min_width_mm} mm",
+            "comment":          None if width_mm and width_mm >= min_width_mm
+                                else f"Door is {min_width_mm - width_mm} mm too narrow"
+                                if width_mm else "Width property missing",
+            "log":              None,
+        })
+    return results
+```
+
+**Rules:**
+- Prefix: `check_` — the platform discovers functions by this prefix
+- First argument: `model` (an `ifcopenshell.file` object) — always
+- Optional keyword args after `model` are fine (e.g. `min_width_mm=800`)
+- Return: `list[dict]` — each dict has fields matching `element_results` (see [Validation Schema](./references/validation-schema.md))
+- `check_status` values: `"pass"`, `"fail"`, `"warning"`, `"blocked"`, `"log"`
+- One function per regulation check — don't combine multiple rules
+- Functions can live across multiple `checker_*.py` files directly inside `tools/`
+
+### 2. File Structure Contract
+
+```
+your-team-repo/
+├── tools/
+│   ├── checker_doors.py       ← check_door_width, check_door_clearance
+│   ├── checker_fire_safety.py ← check_fire_rating, check_exit_count
+│   └── checker_rooms.py       ← check_room_area, check_ceiling_height
+├── requirements.txt            ← team dependencies
+└── README.md
+```
+
+**File naming:** `checker_<topic>.py` — group related checks by topic. Examples:
+- `checker_doors.py` — door width, clearance, accessibility
+- `checker_walls.py` — thickness, fire rating, insulation
+- `checker_stairs.py` — riser height, tread length, handrails
+- `checker_spaces.py` — room area, ceiling height, ventilation
+
+The platform scans **all `checker_*.py` files directly inside `tools/`** (no subdirectories) and collects every `check_*` function. You don't need a wrapper or registry — just follow the naming conventions.
+
+**Important:** Only `checker_*.py` files are scanned. Helper files (e.g. `tools/utils.py`) are fine for shared code but won't be scanned for `check_*` functions — import them from your `checker_*.py` files.
+
+**Local testing:** Run your checks locally before pushing:
+```python
+import ifcopenshell
+
+model = ifcopenshell.open("path/to/model.ifc")
+from tools.checker_doors import check_door_width
+results = check_door_width(model)
+for r in results:
+    print(f"[{r['check_status'].upper()}] {r['element_name']}: {r['actual_value']} (req: {r['required_value']})")
+```
+The `model` object is exactly what the platform passes to your functions.
+
+### 3. Issue Reporting Contract — MANDATORY
+
+When your AI agent encounters any of these during development, it **MUST** file an issue:
+
+| Trigger | Label |
+|---|---|
+| Contract unclear or ambiguous | `contract-gap` |
+| Skill instructions don't match reality | `skill-drift` |
+| Found a workaround for a known limitation | `learning` |
+| Schema format needs a new field | `schema-change` |
+| Team code works locally but breaks on platform | `integration-bug` |
+
+**How to file:**
+```bash
+gh issue create \
+  --repo SerjoschDuering/iaac-bimwise-skills \
+  --title "contract-gap: check functions with multiple models" \
+  --label "contract-gap" \
+  --body "$(cat <<'EOF'
+## What happened
+Tried to write a check that compares two IFC models side-by-side.
+The contract says first arg is `model` (singular).
+
+## What I expected
+Guidance on multi-model checks.
+
+## Workaround (if any)
+Loaded second model inside the function body.
+
+## Team
+Team A
+EOF
+)"
+```
+
+**This is not optional.** Every contract issue that goes unreported costs another team hours.
+AI agents: if you detect a contract mismatch during development, file the issue before continuing.
+
+## Company Context
+
+IFCore is building an AI-powered building compliance checker. **5 teams** each develop in their **own GitHub repo** (cloned from a shared template). Teams write `check_*` functions independently — the platform integrates them automatically.
+
+**How integration works:**
+1. Each team pushes `checker_*.py` files to their own repo under `tools/`
+2. The **platform repo** (`ifcore-platform`) pulls all 5 team repos as **git submodules**
+3. `deploy.sh` flattens submodules into `teams/<team-repo>/tools/` (real files, not symlinks — we don't configure HF to resolve submodules)
+4. The FastAPI orchestrator scans `teams/*/tools/checker_*.py` for `check_*` functions
+5. All discovered functions run against uploaded IFC files
+
+**Deployment architecture:**
+
+| Component | Deploys to | Who manages |
+|-----------|-----------|-------------|
+| Team check functions (`checker_*.py`) | Own GitHub repo → pulled into platform | Each team |
+| Backend + orchestrator (`ifcore-platform`) | **HuggingFace Space** (Docker, FastAPI) | Captains |
+| Frontend (dashboard, 3D viewer, upload) | **Cloudflare Pages** | Captains |
+| API gateway (async jobs, proxies to HF) | **Cloudflare Worker** | Captains |
+| File storage (IFC uploads) | **Cloudflare R2** (S3-compatible) | Captains |
+| Results database | **Cloudflare D1** (SQLite) | Captains |
+
+**Flow:** User uploads IFC → stored in R2 → frontend calls CF Worker → Worker proxies to HF Space → orchestrator runs all `check_*` functions → results posted back to Worker → stored in D1 → frontend polls and displays.
+
+**Teams never touch the platform repo.** They only push to their own team repo. Captains handle `deploy.sh` which pulls, flattens, and pushes to HF.
+
+**Teams:**
+| Team | Focus area | Repo |
+|------|-----------|------|
+| [TBD] | [TBD] | [TBD] |
+| [TBD] | [TBD] | [TBD] |
+| [TBD] | [TBD] | [TBD] |
+| [TBD] | [TBD] | [TBD] |
+| [TBD] | [TBD] | [TBD] |
+
+## References
+
+- [Validation Schema](./references/validation-schema.md) — database schema (`users`, `projects`, `check_results`, `element_results`) and how team `list[dict]` maps to rows
+- [Architecture](./references/architecture.md) — project structure, AGENTS.md template, code conventions
+- [Repo Structure](./references/repo-structure.md) — concrete file tree examples for all 4 repos (team, platform, frontend, gateway)
+- [Frontend Architecture](./references/frontend-architecture.md) — modules, shared Zustand store, API client, D1 tables, how to add features
+- [Development Patterns](./references/development-patterns.md) — how to plan and build new features
+
+### Related Skills (separate repos, installed alongside this one)
+
+- **pydantic-ai** — PydanticAI agent framework: tools, structured output, orchestration, chat patterns
+- **huggingface-deploy** — deploy the platform (`ifcore-platform`) as a Docker Space on HuggingFace; covers Dockerfile, secrets, R2 caching, and the flatten-before-push submodule pattern
+- **cloudflare** — deploy the frontend + API gateway on Cloudflare Pages/Workers

teams/Mastodonte/.claude/skills/IFCore-skill/references/architecture.md

@@ -0,0 +1,73 @@
+# Architecture & Conventions
+
+## Project Structure
+
+```
+your-team-repo/
+├── tools/
+│   ├── checker_doors.py       # check_door_width, check_door_clearance
+│   ├── checker_fire_safety.py # check_fire_rating, check_exit_count
+│   └── checker_rooms.py       # check_room_area, check_ceiling_height
+├── requirements.txt            # team dependencies
+└── README.md
+```
+
+**File naming:** `checker_<topic>.py` — group related checks by topic.
+Only `tools/checker_*.py` matters to the platform. Everything else (local test scripts,
+notebooks, Gradio apps, CLI tools) is your choice — the platform ignores it.
+
+**Platform auto-discovery:** the orchestrator scans `teams/*/tools/checker_*.py` and collects
+every `check_*` function. No subdirectories — files must be directly inside `tools/`.
+Helper files (e.g. `tools/utils.py`) are fine for shared code but won't be scanned.
+
+**Platform integration:** the platform (`ifcore-platform`) pulls all 5 team repos via git
+submodules and flattens them into `teams/<your-repo>/tools/` before building the Docker image.
+Your repo structure (`tools/checker_*.py` with `check_*` functions) must match this layout
+exactly for auto-discovery to work. Captains handle the pull and flatten via `deploy.sh` —
+teams never push to the platform repo directly.
+
+## Code Conventions
+
+- **Max 300 lines per file.** Split into modules when approaching the limit.
+- **One function per check.** Don't combine multiple regulation checks.
+- **File names:** `checker_<topic>.py` — e.g. `checker_doors.py`, `checker_fire_safety.py`.
+- **Function names:** `check_<what>` — e.g. `check_door_width`, `check_room_area`.
+- **First arg is always `model`** — an `ifcopenshell.file` object.
+- **Return `list[str]`** — each string prefixed `[PASS]`, `[FAIL]`, or `[???]`.
+- **No bare try/except.** Only catch specific known errors.
+
+**What is `model`?** It's an `ifcopenshell.file` object — a parsed IFC file loaded into memory.
+You query it with `model.by_type("IfcDoor")` to get all doors, `model.by_type("IfcWall")` for
+walls, etc. Each element has properties like `.Name`, `.GlobalId`, and type-specific attributes.
+
+## AGENTS.md / CLAUDE.md
+
+Every team MUST have this file in their repo root. Your AI assistant reads it automatically.
+If it does not exist, create it before starting any work.
+
+**Template:**
+```markdown
+# <Project Name>
+
+Always read the IFCore skill before developing on this project.
+
+## Structure
+<paste your app/ directory tree here>
+
+## Conventions
+- Max 300 lines per file
+- One function per regulation check
+- Files: tools/checker_<topic>.py — only checker_*.py files are scanned
+- Functions: check_*(model, ...) -> list[str] with [PASS]/[FAIL]/[???] prefix
+
+## Issue Reporting
+When you encounter a contract mismatch, skill gap, or integration problem:
+gh issue create --repo SerjoschDuering/iaac-bimwise-skills --label "<label>" --title "<title>"
+Labels: contract-gap, skill-drift, learning, schema-change, integration-bug
+
+## Learnings
+<!-- Add here after every debugging session that reveals a recurring issue -->
+```
+
+**Keep it updated.** After any session where you hit a recurring error, add it to Learnings.
+The AI gets smarter with every fix — only if you write it down.

teams/Mastodonte/.claude/skills/IFCore-skill/references/development-patterns.md

@@ -0,0 +1,84 @@
+# Development Patterns
+
+## How to Work With the User
+
+You're helping someone who may be new to coding, AI, or both. Before doing anything:
+
+- **Ask what they want to build.** Don't assume — let them explain in their own words.
+- **Suggest an approach and explain why.** If you recommend something, say what it does
+  and why it's a good fit. Offer to explain any term they might not know.
+- **Break things into small steps.** One thing at a time. Check in after each step.
+- **Use plain language.** Say "a function that checks door widths" not "a callable that
+  validates dimensional properties." If you must use a technical term, explain it inline.
+
+## When Someone Wants to Add a New Check
+
+Start a conversation — don't jump straight to code.
+
+1. **Understand what they want.** Ask: "What rule or regulation should this check enforce?"
+   Get a concrete example — "doors must be at least 900mm wide" is better than "door check."
+2. **Talk through the approach.** Explain what the check function will do, what IFC data
+   it needs, and roughly how it works. Ask if that sounds right.
+3. **Suggest a plan.** Offer to write a short plan first (see template below). This is
+   a simple document that describes the goal and what "done" looks like. It helps avoid
+   building the wrong thing. If the user prefers to skip it, that's fine — go straight to code.
+4. **Build it together.** Write the check function, test it, and walk through the result.
+   Explain what each part does. Update AGENTS.md with anything you learned.
+5. **Review when done.** Suggest a quick review — either in a fresh chat or with a subagent
+   if available. This catches things you both might have missed.
+
+## Feature Plans (Optional but Helpful)
+
+For bigger features, a plan folder keeps things organized:
+
+```
+feature-plans/
+└── F1-door-width-check/
+    ├── plan.md          # what we're building and why
+    ├── phase-a/         # if the feature has multiple phases
+    │   └── plan.md      # scope for this phase only
+    └── learnings.md     # what went wrong, what to do differently
+```
+
+A "plan" (sometimes called a PRD — Product Requirements Document) is just a short
+description of what you're building. It helps you think before you code.
+
+## Plan Template
+
+```markdown
+# F<N>: <Feature Name>
+
+## What Are We Building?
+<!-- Explain the goal in plain language. What problem does this solve?
+     What will users be able to do after this is built? -->
+
+## What Does "Done" Look Like?
+- [ ] ...
+<!-- A checklist. When every box is ticked, the feature is done. -->
+
+## How It Works
+<!-- Brief description of the approach. What IFC data do we need?
+     What does the check function do? -->
+
+## Phases (if it's a big feature)
+- Phase A: ...
+- Phase B: ...
+```
+
+Don't overthink this. A few sentences per section is fine. Skip "Phases" for small checks.
+
+## After You Finish
+
+Suggest a review:
+
+> "That check is working. Want me to do a quick review to catch anything we missed?
+> I can do it right now, or you can start a fresh chat and paste this:"
+
+```
+I just finished implementing [feature name].
+Codebase is at [path]. Key files changed: [list].
+Please review against the plan at feature-plans/F<N>-<name>/plan.md
+and check for IFCore contract compliance.
+```
+
+If subagents are available, offer to run the review automatically.

teams/Mastodonte/.claude/skills/IFCore-skill/references/frontend-architecture.md

@@ -0,0 +1,241 @@
+# Frontend Architecture
+
+Modular web app. Each feature (upload, results, 3D viewer, dashboard) is a
+**module** — a self-contained folder. Backend operations are **async jobs**.
+
+> **New to web development?** A frontend is the part users see and click on
+> (the website). The backend is the server doing the heavy work (running checks).
+> They talk to each other through an **API** — a set of URLs the frontend
+> calls to send or receive data.
+
+## Structure
+
+```
+src/
+├── app.js          ← shell: nav bar + router
+├── api.js          ← shared API client → CF Worker
+├── store.js        ← shared state (Zustand)
+├── poller.js       ← polls active jobs, updates store
+├── modules/
+│   ├── upload/     ← file upload
+│   ├── results/    ← results table
+│   ├── viewer-3d/  ← IFC 3D viewer
+│   └── dashboard/  ← analytics
+└── shared/         ← reusable components
+```
+
+## Shell + Router
+
+Nav bar at top, content area below. Router swaps modules like tabs.
+
+> **What's a router?** It watches the URL in the browser. When the URL says
+> `/results`, it shows the results module. When it says `/dashboard`, it shows
+> the dashboard. Each "page" is a module, but it's all one app — no page reloads.
+
+```
+┌──────────────────────────────────────┐
+│  Nav:  Upload | Results | 3D | Dash  │
+├──────────────────────────────────────┤
+│   ← active module renders here →     │
+└──────────────────────────────────────┘
+```
+
+Each module exports `mount(container)`. That's the only contract.
+
+## Async Job Pattern
+
+Backend tasks (IFC checks, AI agents) take 10-60 seconds. Too slow for
+a normal request-response. Everything uses **async jobs**.
+
+> **What's async?** Normally when you click a button, the browser waits for
+> the server to respond — that's synchronous ("sync"). But if the server needs
+> 30 seconds, the browser would freeze. **Async** means: "start the work,
+> come back and check later." The server returns a job ID immediately,
+> and the frontend keeps checking ("polling") until the job is done.
+
+```
+Frontend           Worker (proxy)      HF Space (FastAPI)
+────────           ──────────────      ──────────────────
+POST /check  ───>  proxy         ───>  start background task
+             <───  {jobId}       <───  return {jobId} immediately
+
+poll GET /jobs/id  read D1              ...working...
+             <───  {status:"running"}
+
+poll GET /jobs/id  read D1        ───>  POST /jobs/id/complete (callback)
+             <───  {status:"done", data:[...]}
+```
+
+**Why this pattern?** The CF Worker has a 10ms CPU limit on the free tier —
+it physically can't wait 30 seconds. So it just reads/writes to the database
+and returns. The heavy work happens on the HF Space.
+
+> **What's a callback?** When the HF Space finishes, it calls the Worker
+> back ("hey, job X is done, here are the results"). The Worker writes
+> the results to the database. Next time the frontend polls, it gets them.
+
+### Recipe: Adding a New Async Endpoint
+
+Three files. Always the same pattern.
+
+| File | What to add |
+|------|-------------|
+| **HF Space** `main.py` | `POST /your-thing` → starts `BackgroundTasks`, returns `{jobId}`. When done, POSTs results back to Worker. |
+| **Worker** | Proxy route for `POST /api/your-thing`. Job tracking routes (`GET /api/jobs/:id`, `POST /api/jobs/:id/complete`) are shared — built once. |
+| **Frontend** `api.js` | `startYourThing(fileUrl)` → returns `{jobId}`. Call `store.trackJob(jobId)` — poller handles the rest. |
+
+> **What's an endpoint?** A specific URL the server listens on. `POST /check`
+> is an endpoint. `GET /jobs/123` is another. Think of them as doors into the
+> backend — each door does one thing.
+
+## Shared State (Zustand)
+
+**Zustand** is a tiny state library (~1KB). Think of it as a shared whiteboard —
+any module can read or write to it. The poller updates it when jobs complete.
+
+> **What's state?** The data your app is currently showing. "Which file is
+> selected? Are checks running? What were the results?" That's all state.
+> Without a shared store, each module would have its own copy and they'd
+> get out of sync. Zustand keeps one source of truth.
+
+**How modules use it:**
+- **Upload** sets `currentFile`, starts a job → `trackJob(jobId)`
+- **Results** reads `getActiveResults()` → renders a table
+- **3D Viewer** reads results → highlights failing elements in red
+- **Dashboard** reads results → shows charts and stats
+
+They all see the same data. When a job completes, everything re-renders.
+
+```javascript
+// store.js — schematic
+{
+  currentFile: null,                    // { url, name }
+  jobs: {},                             // { [jobId]: { status, data, startedAt } }
+  activeJobId: null,
+  trackJob(jobId),                      // start tracking
+  completeJob(jobId, data),             // poller calls this
+  getActiveResults(),                   // results for active job
+}
+```
+
+**Poller:** every 2s, calls `GET /api/jobs/:id` for running jobs.
+When status flips to `"done"`, calls `store.completeJob()`.
+
+**API client** (`api.js`): all modules go through this — never call `fetch()` directly.
+Key functions: `uploadFile()`, `startCheck()`, `getJob()`, `getStats()`.
+
+> **What's `fetch()`?** The browser's built-in way to call an API. `api.js`
+> wraps it so you don't repeat the base URL and error handling everywhere.
+
+## Module Pattern
+
+Modules render once, then **subscribe** to re-render on state changes:
+
+```javascript
+// modules/summary/index.js — schematic
+export function mount(container) {
+  function render() {
+    const results = useStore.getState().getActiveResults()
+    container.innerHTML = `${passed} passed, ${failed} failed`
+  }
+  render()                           // initial
+  useStore.subscribe(render)         // re-render on change
+}
+```
+
+> **What's subscribe?** "Notify me when something changes." Without it, your
+> module renders once and never updates. With `subscribe(render)`, every time
+> the store changes (new results, job completed), your module re-renders
+> automatically.
+
+**Rules:**
+- Don't import from other modules
+- Read state from `store.js` via `subscribe()`
+- Call backend through `api.js`
+- One folder, one concern
+
+## Adding a Module (Checklist)
+
+1. Create `src/modules/<name>/index.js` with `mount()` + `subscribe()`
+2. Register route in `app.js`
+3. If it needs a new backend endpoint → follow async recipe above
+
+## Adding Shared State
+
+Only if multiple modules need it. Otherwise keep local.
+
+1. Add to `store.js`: state field + setter
+2. Read from modules via `getState()` + `subscribe()`
+
+## Database (D1)
+
+> **What's D1?** Cloudflare's database service. It runs SQLite (a simple
+> database that stores data in tables, like a spreadsheet). The frontend
+> never talks to D1 directly — it goes through the Worker API.
+
+```sql
+CREATE TABLE users (
+  id TEXT PRIMARY KEY,
+  name TEXT,
+  team TEXT,                     -- e.g. "ifcore-team-a", nullable
+  created_at INTEGER
+);
+
+CREATE TABLE projects (
+  id TEXT PRIMARY KEY,
+  user_id TEXT REFERENCES users(id),
+  name TEXT,
+  file_url TEXT,
+  ifc_schema TEXT,               -- e.g. "IFC4", null if unknown
+  region TEXT,                   -- e.g. "CH", null if unknown
+  building_type TEXT,            -- e.g. "residential", null
+  metadata TEXT,                 -- JSON blob, nullable
+  created_at INTEGER
+);
+
+CREATE TABLE check_results (
+  id TEXT PRIMARY KEY,
+  project_id TEXT REFERENCES projects(id),
+  job_id TEXT,                   -- groups results from one run
+  check_name TEXT,               -- e.g. "check_door_width"
+  team TEXT,                     -- e.g. "ifcore-team-a"
+  status TEXT DEFAULT 'running', -- pass | fail | unknown | error | running
+  summary TEXT,                  -- "14 doors: 12 pass, 2 fail"
+  has_elements INTEGER DEFAULT 0,
+  created_at INTEGER
+);
+
+CREATE TABLE element_results (
+  id TEXT PRIMARY KEY,
+  check_result_id TEXT REFERENCES check_results(id),
+  element_id TEXT,               -- IFC GlobalId (nullable)
+  element_type TEXT,             -- e.g. "IfcDoor" (nullable)
+  element_name TEXT,             -- e.g. "Door #42" (nullable)
+  element_name_long TEXT,        -- e.g. "Door #42 (Level 1, Zone A)" (nullable)
+  check_status TEXT,             -- pass | fail | warning | blocked | log
+  actual_value TEXT,             -- e.g. "750 mm"
+  required_value TEXT,           -- e.g. "800 mm"
+  comment TEXT,                  -- human-readable explanation (nullable)
+  log TEXT                       -- debug/trace info (nullable)
+);
+```
+
+See [Validation Schema](./validation-schema.md) for how team `list[dict]` output maps to these rows.
+
+> **What's a migration?** A file that changes the database structure
+> (adds a table, adds a column). You run it once with `wrangler d1 execute`.
+> It's like a recipe for the database — run it, and the new table exists.
+
+**Adding a new table:** migration file → `wrangler d1 execute` → Worker endpoint → `api.js` function → module uses it.
+
+## PRD Review (Wednesday)
+
+> **What's a PRD?** Product Requirements Document — a short plan describing
+> what you're building, why, and what "done" looks like. Doesn't need to be
+> fancy. Half a page is fine.
+
+Before building, each team writes a PRD for their module. All reviewed together:
+- What each team builds
+- What async endpoints are needed
+- What shared state each module expects
+- Whether modules overlap

teams/Mastodonte/.claude/skills/IFCore-skill/references/repo-structure.md

@@ -0,0 +1,53 @@
+# Repository Structure
+
+## Team repos — `ifcore-team-a` … `ifcore-team-e`
+One repo per team. Students only ever touch their own.
+```
+ifcore-team-a/
+├── tools/
+│   ├── checker_doors.py       # check_door_width, check_door_clearance
+│   ├── checker_fire_safety.py # check_fire_rating, check_exit_count
+│   └── checker_rooms.py       # check_room_area, check_ceiling_height
+├── requirements.txt
+├── AGENTS.md
+└── README.md
+```
+
+## Platform monorepo — `ifcore-platform`
+**One repo. Two folders. Two deployments.**
+```
+ifcore-platform/           ← ONE git repo
+│
+├── backend/               → deploys to HuggingFace Space
+│   ├── README.md              ← HF frontmatter (sdk: docker, app_port: 7860)
+│   ├── Dockerfile
+│   ├── requirements.txt
+│   ├── main.py
+│   ├── orchestrator.py
+│   ├── deploy.sh
+│   └── teams/                 ← gitignored, populated by deploy.sh
+│       ├── ifcore-team-a/tools/checker_*.py
+│       ├── ifcore-team-b/tools/checker_*.py
+│       └── ...                ← one folder per team, flattened from submodules
+│
+└── frontend/              → deploys to Cloudflare (Pages + Worker)
+    ├── public/
+    │   └── index.html
+    ├── src/                   ← static app (CF Pages)
+    │   ├── app.js
+    │   ├── api.js
+    │   ├── store.js
+    │   ├── poller.js
+    │   └── modules/
+    │       ├── upload/index.js
+    │       ├── results/index.js
+    │       ├── viewer-3d/index.js
+    │       └── dashboard/index.js
+    ├── functions/             ← API gateway (CF Pages Functions = Worker)
+    │   └── api/
+    │       └── [[route]].js
+    ├── migrations/
+    │   └── 0001_create_jobs.sql
+    ├── package.json
+    └── wrangler.toml          ← D1 + R2 bindings, custom domain
+```

teams/Mastodonte/.claude/skills/IFCore-skill/references/validation-schema.md

@@ -0,0 +1,164 @@
+# Validation Schema
+
+Two layers: what teams produce, and how the platform stores it.
+
+## Team Output (locked — Board Meeting #1)
+
+Each `check_*` function returns `list[dict]`. Each dict is one element checked,
+mapping directly to one `element_results` row in the database.
+
+```python
+def check_door_width(model, min_width_mm=800):
+    results = []
+    for door in model.by_type("IfcDoor"):
+        width_mm = round(door.OverallWidth * 1000) if door.OverallWidth else None
+        results.append({
+            "element_id":       door.GlobalId,
+            "element_type":     "IfcDoor",
+            "element_name":     door.Name or f"Door #{door.id()}",
+            "element_name_long": f"{door.Name} (Level 1, Zone A)",
+            "check_status":     "blocked" if width_mm is None
+                                else "pass" if width_mm >= min_width_mm
+                                else "fail",
+            "actual_value":     f"{width_mm} mm" if width_mm else None,
+            "required_value":   f"{min_width_mm} mm",
+            "comment":          None if width_mm and width_mm >= min_width_mm
+                                else f"Door is {min_width_mm - width_mm} mm too narrow"
+                                if width_mm else "Width property missing",
+            "log":              None,
+        })
+    return results
+```
+
+**Required dict fields** (teams produce these — `id` and `check_result_id` are added by the orchestrator):
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `element_id` | string \| null | IFC GlobalId |
+| `element_type` | string \| null | e.g. `"IfcDoor"`, `"IfcWall"` |
+| `element_name` | string \| null | Short name, e.g. `"Door #42"` |
+| `element_name_long` | string \| null | Detailed name with context, e.g. `"Door #42 (Level 1, Zone A)"` |
+| `check_status` | string | **`pass`** \| **`fail`** \| **`warning`** \| **`blocked`** \| **`log`** |
+| `actual_value` | string \| null | What was found, e.g. `"750 mm"` |
+| `required_value` | string \| null | What the regulation requires, e.g. `"800 mm"` |
+| `comment` | string \| null | Human-readable explanation (why it failed, what's wrong) |
+| `log` | string \| null | Debug/trace info (optional, for troubleshooting) |
+
+**`check_status` values:**
+- `"pass"` — element meets the requirement
+- `"fail"` — element violates the requirement
+- `"warning"` — element is borderline or needs manual review
+- `"blocked"` — data missing, check cannot run (e.g. property not found)
+- `"log"` — informational output, not a pass/fail judgment
+
+## Platform Database Schema (D1)
+
+Four tables. The frontend reads from these via the CF Worker API.
+
+```
+┌─────────┐       ┌─────────────┐       ┌────────────────┐       ┌──────────────────┐
+│  users  │ 1───* │  projects   │ 1───* │  check_results │ 1───* │  element_results │
+└─────────┘       └─────────────┘       └────────────────┘       └──────────────────┘
+```
+
+### `users` — one row per person
+
+```json
+{
+  "id":         "string",
+  "name":       "string",
+  "team":       "string | null",
+  "created_at": "integer"
+}
+```
+
+### `projects` — one row per uploaded IFC file
+
+```json
+{
+  "id":            "string",
+  "user_id":       "string",
+  "name":          "string",
+  "file_url":      "string",
+  "ifc_schema":    "string | null",
+  "region":        "string | null",
+  "building_type": "string | null",
+  "metadata":      "string | null (JSON)",
+  "created_at":    "integer"
+}
+```
+
+### `check_results` — one row per `check_*` function run
+
+```json
+{
+  "id":            "string",
+  "project_id":    "string",
+  "job_id":        "string",
+  "check_name":    "string",
+  "team":          "string",
+  "status":        "string (running | pass | fail | unknown | error)",
+  "summary":       "string",
+  "has_elements":  "integer (0 | 1)",
+  "created_at":    "integer"
+}
+```
+
+- `check_name`: the function name, e.g. `check_door_width`
+- `team`: derived from the repo folder name, e.g. `ifcore-team-a`
+- `status`: `running` while job is in progress; then aggregate — `pass` if all elements pass, `fail` if any fail, `error` if the function threw
+- `summary`: human-readable, e.g. "14 doors checked: 12 pass, 2 fail"
+- `has_elements`: `1` if the check produced element-level results, `0` otherwise
+
+### `element_results` — one row per element checked
+
+```json
+{
+  "id":               "string",
+  "check_result_id":  "string",
+  "element_id":       "string | null",
+  "element_type":     "string | null",
+  "element_name":     "string | null",
+  "element_name_long":"string | null",
+  "check_status":     "string (pass | fail | warning | blocked | log)",
+  "actual_value":     "string | null",
+  "required_value":   "string | null",
+  "comment":          "string | null",
+  "log":              "string | null"
+}
+```
+
+- `id`, `check_result_id`: added by the orchestrator (teams don't produce these)
+- `element_id`: IFC GlobalId (if available)
+- `check_status`: matches what the team function returns — not aggregated
+- `comment`: human-readable explanation of the result
+- `log`: debug/trace info for troubleshooting
+
+## How It Fits Together
+
+```
+Team function returns:
+  [
+    {"element_id": "2O2Fr$t4X7Z", "element_type": "IfcDoor",
+     "element_name": "Door #42", "element_name_long": "Door #42 (Level 1)",
+     "check_status": "pass", "actual_value": "850 mm", "required_value": "800 mm",
+     "comment": null, "log": null},
+    {"element_id": "1B3Rs$u5Y8A", "element_type": "IfcDoor",
+     "element_name": "Door #17", "element_name_long": "Door #17 (Level 2)",
+     "check_status": "fail", "actual_value": "750 mm", "required_value": "800 mm",
+     "comment": "Door is 50 mm too narrow", "log": null}
+  ]
+
+Orchestrator creates:
+
+  check_results row:
+    check_name   = "check_door_width"
+    team         = "ifcore-team-a"
+    status       = "fail"              ← any fail → whole check fails
+    summary      = "2 doors: 1 pass, 1 fail"
+    has_elements = 1
+
+  element_results rows:  (one per dict, id + check_result_id added)
+    { element_name: "Door #42", check_status: "pass", actual_value: "850 mm", ... }
+    { element_name: "Door #17", check_status: "fail", actual_value: "750 mm", comment: "Door is 50 mm too narrow", ... }
+```

teams/Mastodonte/.gitignore

@@ -0,0 +1,45 @@
+# =========================
+# Python cache
+# =========================
+__pycache__/
+*.py[cod]
+*$py.class
+
+# =========================
+# Virtual environments
+# =========================
+venv/
+.env/
+.venv/
+env/
+ENV/
+
+# =========================
+# Jupyter
+# =========================
+.ipynb_checkpoints/
+
+# =========================
+# OS files
+# =========================
+.DS_Store
+Thumbs.db
+
+# =========================
+# Logs
+# =========================
+*.log
+
+# =========================
+# IDE / Editor
+# =========================
+.vscode/
+.idea/
+
+# =========================
+# Build / Packaging
+# =========================
+build/
+dist/
+*.egg-info/
+.ifc/

teams/Mastodonte/01_team_b

@@ -0,0 +1,303 @@
+ Team B — User Portal
+
+**Branch:** `feature/team-B-adminpanel` | **Verdict:** NEEDS CHANGES (major scope reduction)
+
+| Criterion | Score | Notes |
+|-----------|-------|-------|
+| Architecture Fit | 3/5 | Correctly uses CF Worker + Pages + D1, but ignores existing patterns |
+| Scope Feasibility | 1/5 | 4-week enterprise plan for a 1-day sprint |
+| Shared State | 1/5 | No Zustand slice docs. No Reads/Writes section |
+| API Design | 2/5 | 13+ new endpoints, none follow async job pattern |
+| Security | 3/5 | Good on paper, impossible to implement correctly in 1 day |
+
+**Shared State:** Reads `store.projects` (profile page). Writes: none (uses Better Auth `useSession()` hook).
+
+---
+
+Hey Team B! You took on one of the most important features in the entire platform.
+Authentication is the backbone that every other team depends on.
+Here is where you stand and what to do tomorrow.
+
+---
+
+## What You Did Well
+
+1. **You thought like a real product team.** Your PRD covers email verification,
+   billing, support tickets, account deletion, RBAC, monitoring -- that is a
+   complete SaaS auth system. The fact that you thought through edge cases
+   like stale Stripe webhooks and partial provisioning rollback shows genuine
+   product thinking. That matters.
+
+2. **You picked the right infrastructure.** Cloudflare Workers for API, Pages
+   for frontend, D1 for storage -- this matches the platform architecture exactly.
+   You did not invent your own deployment target or try to spin up a separate
+   server. That alignment saves everyone time.
+
+3. **Security was on your mind from the start.** HTTP-only cookies, CSRF protection,
+   SameSite headers, encrypted fields, PCI considerations for Stripe -- you
+   clearly researched what secure auth looks like. That awareness is more valuable
+   than most people realize.
+
+---
+
+## The Big Picture
+
+The IFCore platform has a specific architecture. Here is the part that matters for you:
+
+```
+Browser  -->  Cloudflare Worker (API + auth)  -->  HuggingFace Space (IFC checks)
+                     |
+                  D1 (database)
+                  R2 (file storage)
+```
+
+Your job is to add **one thing** to this picture: a way for users to sign up,
+log in, and have the platform know who they are. That is it. Every other team
+(3D viewer, dashboard, report generator) just needs `useSession()` to get the
+current user. If you ship that, you unblock everyone.
+
+The platform already has a `users` table in D1:
+```sql
+CREATE TABLE users (id TEXT PRIMARY KEY, name TEXT, team TEXT, created_at INTEGER);
+```
+
+Your auth system needs to work **alongside** this, not replace it.
+
+---
+
+## What Needs to Change
+
+### 1. Scope: cut 80% of the features
+
+**Why:** Your PRD describes a 4-week enterprise build. The course ends tomorrow.
+Even experienced engineers at companies like Auth0 took months to build what you
+described. This is not a criticism -- it means you were thinking big. But shipping
+something real beats having a perfect plan that never runs.
+
+**What to keep:** Sign up, log in, log out, and a profile page. That is your MVP.
+
+### 2. Use Better Auth instead of building auth from scratch
+
+**Why:** The Cloudflare skill that your AI agent has access to includes a complete
+Better Auth blueprint. Better Auth is an open-source library that handles password
+hashing, sessions, cookies, and database tables automatically. It works with D1,
+Drizzle, and Hono -- exactly the stack the platform uses.
+
+Building auth from scratch (your own password hashing, session tokens, CSRF
+protection) is a weeks-long project with serious security risks if done wrong.
+Better Auth gives you all of that in about 50 lines of config.
+
+**Critical detail:** Do NOT use bcrypt for password hashing. Cloudflare Workers
+have a 10ms CPU limit on the free tier. Bcrypt exceeds that limit and your signup
+will fail with Error 1102. The Cloudflare skill has a PBKDF2 hasher that works
+within Workers limits.
+
+### 3. Do not modify the existing `users` table
+
+**Why:** Other teams already depend on the current schema. If you change it,
+their code breaks. Better Auth creates its own tables (`user`, `session`,
+`account`, `verification`) -- it does not touch the existing `users` table.
+This is additive, not destructive.
+
+### 4. Follow the platform's shared state pattern
+
+**Why:** The platform uses Zustand for client-side state. Each feature gets a
+"slice" that other teams can read from. Your PRD did not include a Shared State
+section, which means other teams would not know how to access auth data.
+
+The good news: Better Auth provides a `useSession()` React hook. Other teams
+can just call it. You do not even need a Zustand slice -- the hook is the
+interface.
+
+### 5. Drop all external service dependencies
+
+**Why:** Stripe requires a merchant account. Email verification requires a
+transactional email provider (SendGrid, Resend, etc.). TOTP/2FA requires
+a mobile app integration. None of these are provisioned, and setting them up
+takes longer than building the auth feature itself.
+
+---
+
+## Your 1-Day Game Plan
+
+Your AI coding agent has the **Cloudflare skill** installed. It contains the
+exact Better Auth blueprint below. Tell your agent: "Use the Cloudflare skill's
+Better Auth pattern to set up authentication." It will know what to do.
+
+### Morning (3 hours): Backend auth
+
+**Step 1 -- Install Better Auth** (10 min)
+```bash
+cd frontend
+npm install better-auth drizzle-orm
+```
+
+**Step 2 -- Add the nodejs_compat flag** (5 min)
+
+In `frontend/wrangler.jsonc`, add:
+```jsonc
+"compatibility_flags": ["nodejs_compat"]
+```
+
+**Step 2b -- Update the Bindings type** (5 min)
+
+In `frontend/worker/types.ts`, add the auth secrets:
+```typescript
+export type Bindings = {
+  DB: D1Database;
+  STORAGE: R2Bucket;
+  ASSETS: Fetcher;
+  HF_SPACE_URL: string;
+  BETTER_AUTH_SECRET: string;   // add this
+  BETTER_AUTH_URL: string;      // add this
+};
+```
+
+**Step 3 -- Create the auth config** (30 min)
+
+Create `frontend/worker/lib/auth.ts`. The Cloudflare skill has the full file
+including the PBKDF2 hasher. Key points:
+- Use `drizzleAdapter(db, { provider: 'sqlite' })` for D1
+- Set `basePath: '/api/auth'` (NOT `/auth` -- see note below)
+- Add both localhost and production URLs to `trustedOrigins`
+- Use the PBKDF2 hash/verify functions (NOT bcrypt)
+
+**Critical path note:** The Worker only intercepts requests matching
+`run_worker_first: ["/api/*"]` in `wrangler.jsonc`. If you mount auth
+at `/auth/*`, requests will never reach the Worker -- they hit the
+static asset handler and 404. Always use `/api/auth/*`.
+
+**Step 4 -- Mount auth routes in the Worker** (15 min)
+
+First, fix CORS. The existing `cors({ origin: "*" })` is incompatible with
+auth cookies (`credentials: 'include'`). Browsers reject wildcard origins
+when credentials are sent. Replace with an explicit allowlist:
+```typescript
+app.use("/api/*", cors({
+  origin: ["http://localhost:5173", "https://ifcore-platform.tralala798.workers.dev"],
+  credentials: true,
+}));
+```
+
+Then mount the auth routes under `/api/auth/*`:
+```typescript
+app.on(['GET', 'POST'], '/api/auth/*', (c) => {
+  const auth = createAuth(c.env)
+  return auth.handler(c.req.raw)
+})
+```
+
+**Step 5 -- Set secrets** (10 min)
+
+For production:
+```bash
+wrangler secret put BETTER_AUTH_SECRET    # generate with: openssl rand -base64 32
+wrangler secret put BETTER_AUTH_URL       # https://ifcore-platform.tralala798.workers.dev
+```
+
+For local development, create `frontend/.dev.vars`:
+```env
+BETTER_AUTH_SECRET=local-dev-secret-change-me
+BETTER_AUTH_URL=http://localhost:5173
+```
+Without `.dev.vars`, local `npm run dev` will crash on missing env vars.
+
+**Step 6 -- Create the D1 migration** (20 min)
+
+Add a new migration file (e.g., `0003_auth.sql`) with the Better Auth tables:
+`session`, `account`, `verification`. Better Auth defaults to a table named
+`user` (singular), but the platform already has `users` (plural). To avoid
+two separate user tables, configure Better Auth to use the existing table:
+```typescript
+// in auth.ts config
+user: { tableName: "users" },
+```
+Then the migration only adds columns to `users` (e.g., `email_verified`,
+`image`) and creates the three new tables. Do NOT drop or recreate `users`.
+
+**Note:** The `@better-auth/cli generate` command does NOT work with the
+factory-pattern auth config required for Workers. Create the SQL manually.
+See the Better Auth docs for exact column definitions.
+
+### Afternoon (3 hours): Frontend
+
+**Step 7 -- Create the auth client** (15 min)
+
+Create `frontend/src/lib/auth-client.ts`:
+```typescript
+import { createAuthClient } from 'better-auth/react'
+
+export const authClient = createAuthClient({
+  baseURL: '/api/auth',
+  fetchOptions: { credentials: 'include' },
+})
+
+export const { useSession } = authClient
+```
+
+**Step 8 -- Build the login page** (45 min)
+
+A simple form with email + password fields, a "Log In" button, and a
+"Sign Up" button. The Cloudflare skill has a complete `AuthForm.tsx` component
+you can adapt. Add it as a route at `/login` using TanStack Router.
+
+**Step 9 -- Build the profile page** (30 min)
+
+Show the current user's name, email, and team. Add a "Log Out" button.
+Route: `/profile`.
+
+**Step 10 -- Update the navbar** (15 min)
+
+If logged in: show the user's name and a link to `/profile`.
+If not logged in: show a "Log In" link to `/login`.
+
+**Step 11 -- Test end to end** (30 min)
+
+1. Sign up with an email and password
+2. Verify you are redirected and the navbar shows your name
+3. Log out and verify the navbar changes
+4. Log back in and verify your profile page works
+
+**Step 12 -- Deploy** (15 min)
+```bash
+cd frontend
+npm run db:migrate:remote   # applies the new auth migration
+npm run deploy              # builds + deploys to Cloudflare
+```
+
+---
+
+## What to Cut (and Why That is OK)
+
+| Feature | Why it is cut |
+|---------|---------------|
+| Stripe billing | Requires a merchant account nobody has set up |
+| Email verification | Requires a transactional email provider |
+| Password reset | Depends on email sending |
+| 2FA / TOTP | Nice for security, but adds a full day of work |
+| 4-role RBAC | Use `role: "member" or "captain"` -- two roles is enough |
+| Support ticketing | Completely separate feature, not auth |
+| Account deletion with 30-day retention | Post-launch feature |
+| API key management | Not needed for the demo |
+| Monitoring and alerting | Not needed for the demo |
+
+Cutting features is not failure. Every real product launch involves cutting scope.
+The difference between a shipped product and a perfect plan is that one of them
+actually exists. You aimed high -- now let's ship what matters.
+
+---
+
+## How Your Feature Connects to Others
+
+Authentication is a **foundation feature**. Here is how other teams use it:
+
+- **Team D (3D Viewer):** Calls `useSession()` to know which user uploaded a model
+- **Team E (Dashboard):** Filters check results by user/team using the session
+- **Report Generator:** Attaches user info to exported compliance reports
+- **Every team:** Can protect routes with your auth -- only logged-in users see the app
+
+If you ship login + signup + session management, you give every other team
+a `useSession()` hook that returns `{ id, email, name }`. That is the most
+valuable single feature anyone can deliver tomorrow.
+
+You aimed high and that is great. Now let's focus on what we can ship.

teams/Mastodonte/COMPLIANCE_AUDIT.md

@@ -0,0 +1,246 @@
+# IFCore Compliance Audit Report
+
+**Date:** February 18, 2026  
+**Project:** AI Speed Run - Week 05  
+**Status:** ✅ **FULLY COMPLIANT**
+
+---
+
+## Executive Summary
+
+All Python files in `tools/` directory comply with IFCore platform contracts:
+- ✅ Naming conventions enforced
+- ✅ Function signatures correct
+- ✅ Return types compliant
+- ✅ IFCore schema implemented
+- ✅ Module exports configured
+
+---
+
+## File-by-File Audit
+
+### 1. **checker_dwelling.py** ✅ COMPLIANT
+
+| Requirement | Status | Details |
+|---|---|---|
+| **Filename** | ✅ | Follows `checker_*.py` pattern |
+| **Function Name** | ✅ | `check_dwelling_area()` follows `check_*` prefix |
+| **Signature** | ✅ | `check_dwelling_area(model, min_area=36.0)` - model is 1st arg |
+| **Return Type** | ✅ | Returns `list[dict]` |
+| **Schema Keys** | ✅ | All IFCore keys present: element_id, element_type, element_name, element_name_long, check_status, actual_value, required_value, comment, log |
+| **Status Values** | ✅ | Uses only valid statuses: "pass", "fail" |
+| **Helper Functions** | ✅ | `calculate_space_area()` is properly isolated |
+| **Testing** | ✅ | Local test harness included (`if __name__ == "__main__"`) |
+
+**Notes:** Function correctly evaluates total dwelling area and applies aggregate pass/fail status to all spaces.
+
+---
+
+### 2. **checker_heights.py** ✅ COMPLIANT
+
+| Requirement | Status | Details |
+|---|---|---|
+| **Filename** | ✅ | Follows `checker_*.py` pattern |
+| **Function Name** | ✅ | `check_living_area_height()` follows `check_*` prefix |
+| **Signature** | ✅ | `check_living_area_height(model, min_height=2.50)` - model is 1st arg |
+| **Return Type** | ✅ | Returns `list[dict]` |
+| **Schema Keys** | ✅ | All IFCore keys present |
+| **Status Values** | ✅ | Uses only valid statuses: "pass", "fail" |
+| **Helper Functions** | ✅ | `get_main_living_areas()`, `get_space_height()` properly isolated |
+| **Testing** | ✅ | Local test harness included |
+| **Keywords** | ✅ | Spaces filtered by: "living", "bedroom", "hall" |
+
+**Notes:** Old `load_model()` function present but unused (harmless legacy code).
+
+---
+
+### 3. **checker_living_rooms.py** ✅ COMPLIANT
+
+| Requirement | Status | Details |
+|---|---|---|
+| **Filename** | ✅ | Follows `checker_*.py` pattern |
+| **Function Name** | ✅ | `check_living_room_compliance()` follows `check_*` prefix |
+| **Signature** | ✅ | `check_living_room_compliance(model)` - model is 1st arg |
+| **Return Type** | ✅ | Returns `list[dict]` |
+| **Schema Keys** | ✅ | All IFCore keys present |
+| **Status Values** | ✅ | Uses only valid statuses: "pass", "fail" |
+| **Rules Encoded** | ✅ | Min area 10 m² (or 14 m² if living+kitchen), clearance check 2.4 x 2.4 m |
+| **Helper Functions** | ✅ | `calculate_space_area()`, `get_space_name()`, `can_fit_square()` properly isolated |
+| **Testing** | ✅ | Local test harness included |
+
+**Notes:** Rules correctly cascade and aggregate reasons field. Old `load_model()` function present but unused (harmless legacy code).
+
+---
+
+### 4. **checker_service_spaces.py** ✅ COMPLIANT
+
+| Requirement | Status | Details |
+|---|---|---|
+| **Filename** | ✅ | Follows `checker_*.py` pattern |
+| **Function Name** | ✅ | `check_service_spaces_min_height()` follows `check_*` prefix |
+| **Signature** | ✅ | `check_service_spaces_min_height(model, min_height=2.20)` - model is 1st arg |
+| **Return Type** | ✅ | Returns `list[dict]` |
+| **Schema Keys** | ✅ | All IFCore keys present |
+| **Status Values** | ✅ | Uses only valid statuses: "pass", "fail" |
+| **Service Space Keywords** | ✅ | Spaces filtered by: "bath", "bathroom", "wc", "toilet", "kitchen", "cocina", "hall", "hallway", "corridor", "pasillo" |
+| **Helper Functions** | ✅ | `get_space_name()`, `get_space_height()`, `is_service_space()` properly isolated |
+| **Testing** | ✅ | Local test harness included |
+
+**Notes:** Old `load_model()` function present but unused (harmless legacy code).
+
+---
+
+### 5. **__init__.py** ✅ COMPLIANT
+
+| Requirement | Status | Details |
+|---|---|---|
+| **Exports** | ✅ | All 4 check functions exported: `check_dwelling_area`, `check_living_area_height`, `check_living_room_compliance`, `check_service_spaces_min_height` |
+| **__all__ Declaration** | ✅ | Properly declared for auto-discovery |
+| **Import Paths** | ✅ | Relative imports from checker modules correct |
+| **Documentation** | ✅ | Clear docstring explaining IFCore contract |
+
+**Notes:** Properly configured for platform auto-discovery.
+
+---
+
+## IFCore Schema Validation
+
+### Required Fields (All Present in All Checkers)
+
+```python
+{
+    "element_id":       str,      # ✅ GlobalId of IFC element
+    "element_type":     str,      # ✅ "IfcSpace", etc.
+    "element_name":     str,      # ✅ Short name
+    "element_name_long": str,     # ✅ Descriptive name with context
+    "check_status":     str,      # ✅ "pass", "fail", "warning", "blocked", "log"
+    "actual_value":     str|None, # ✅ Measured value with units
+    "required_value":   str|None, # ✅ Required threshold with units
+    "comment":          str|None, # ✅ Failure explanation or None
+    "log":              str|None, # ✅ Debug info or None
+}
+```
+
+**Compliance:** ✅ All checkers implement all 9 required fields
+
+---
+
+## Function Signature Validation
+
+### Convention: `check_<what>(model, **optional_kwargs)`
+
+```
+✅ check_dwelling_area(model, min_area=36.0)
+✅ check_living_area_height(model, min_height=2.50)  
+✅ check_living_room_compliance(model)
+✅ check_service_spaces_min_height(model, min_height=2.20)
+```
+
+**Compliance:** ✅ All functions follow contract exactly
+
+---
+
+## Return Type Validation
+
+### Contract: All functions return `list[dict]`
+
+```
+✅ check_dwelling_area()        → list[dict]  (269 spaces tested)
+✅ check_living_area_height()   → list[dict]  (per living area)
+✅ check_living_room_compliance() → list[dict] (per living room)
+✅ check_service_spaces_min_height() → list[dict] (63 service spaces tested)
+```
+
+**Compliance:** ✅ All functions return correct type
+
+---
+
+## File Structure Validation
+
+```
+tools/
+├── __init__.py                    ✅ Exports all checkers
+├── checker_dwelling.py             ✅ check_dwelling_area()
+├── checker_heights.py              ✅ check_living_area_height()
+├── checker_living_rooms.py         ✅ check_living_room_compliance()
+├── checker_service_spaces.py       ✅ check_service_spaces_min_height()
+└── __pycache__/
+
+main.py                             ✅ Integration test harness
+├── Loads model once
+├── Calls all 4 checkers
+└── Collects & summarizes results
+```
+
+**Compliance:** ✅ File structure correct
+
+---
+
+## Platform Integration Readiness
+
+### Discovery Phase ✅
+- Platform scans `tools/checker_*.py` files
+- Finds all `check_*` functions by name prefix
+- Reads function signature for parameter mapping
+
+### Execution Phase ✅
+- Platform loads IFC model once
+- Passes loaded `model` object to each `check_*` function
+- Each function receives correct argument type (ifcopenshell.file)
+
+### Result Aggregation Phase ✅
+- Platform collects `list[dict]` results from each checker
+- Maps to `element_results` database table
+- Schema keys directly match table columns
+
+---
+
+## Removed Files
+
+| File | Reason |
+|------|--------|
+| `_init_.py` | ❌ Removed - old file conflicting with `__init__.py` |
+
+---
+
+## Recommendations
+
+### ✅ No Changes Required
+
+All files are compliant and production-ready. The codebase:
+- Follows IFCore naming conventions exactly
+- Implements function contracts correctly
+- Returns proper schema
+- Is ready for platform integration
+
+### Optional: Code Cleanup
+
+The following unused legacy functions can remain (they don't break functionality):
+- `checker_heights.py`: `load_model()` — not used, kept for reference
+- `checker_living_rooms.py`: `load_model()` — not used, kept for reference
+- `checker_service_spaces.py`: `load_model()` — not used, kept for reference
+
+These don't interfere with platform discovery (platform only looks for `check_*` functions).
+
+---
+
+## Test Results Summary
+
+```
+✅ dwelling_area:               269 ✓ / 0 ✗
+✅ service_spaces_min_height:   63 ✓ / 0 ✗
+✅ living_area_height:          0 results (no matching spaces in model)
+✅ living_room_compliance:      0 results (no matching spaces in model)
+```
+
+All functions executed without errors and returned correct schema.
+
+---
+
+## Conclusion
+
+**Status: ✅ FULLY COMPLIANT WITH ICORE CONTRACTS**
+
+Your codebase is ready for deployment to the IFCore platform. All naming conventions, function signatures, return types, and schema requirements are met.
+
+**Next step:** Push to your team repository. The platform will auto-discover and integrate your check functions.

teams/Mastodonte/Mastodontes_Tool_E.ipynb

@@ -0,0 +1,372 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Dependencies"
+      ],
+      "metadata": {
+        "id": "8dq-7nvZdH8R"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Install ifcopenshell for IFC parsing\n",
+        "!pip install ifcopenshell matplotlib"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "XO7xZxExcr7A",
+        "outputId": "7829861f-5134-4946-8830-b925276f0ee1"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting ifcopenshell\n",
+            "  Downloading ifcopenshell-0.8.4.post1-py312-none-manylinux_2_31_x86_64.whl.metadata (12 kB)\n",
+            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n",
+            "Requirement already satisfied: shapely in /usr/local/lib/python3.12/dist-packages (from ifcopenshell) (2.1.2)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from ifcopenshell) (2.0.2)\n",
+            "Collecting isodate (from ifcopenshell)\n",
+            "  Downloading isodate-0.7.2-py3-none-any.whl.metadata (11 kB)\n",
+            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.12/dist-packages (from ifcopenshell) (2.9.0.post0)\n",
+            "Requirement already satisfied: lark in /usr/local/lib/python3.12/dist-packages (from ifcopenshell) (1.3.1)\n",
+            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.12/dist-packages (from ifcopenshell) (4.15.0)\n",
+            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n",
+            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.61.1)\n",
+            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.4.9)\n",
+            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (26.0)\n",
+            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (11.3.0)\n",
+            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.3.2)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil->ifcopenshell) (1.17.0)\n",
+            "Downloading ifcopenshell-0.8.4.post1-py312-none-manylinux_2_31_x86_64.whl (42.6 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 MB\u001b[0m \u001b[31m21.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading isodate-0.7.2-py3-none-any.whl (22 kB)\n",
+            "Installing collected packages: isodate, ifcopenshell\n",
+            "Successfully installed ifcopenshell-0.8.4.post1 isodate-0.7.2\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Cloning Repo"
+      ],
+      "metadata": {
+        "id": "0vgb8bCZdLgH"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!git clone https://github.com/sylvainHellin/ifc-bench.git"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "EYiAOI_9dQDU",
+        "outputId": "abd0c597-bb0a-40b3-f840-f04f54e3d927"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Cloning into 'ifc-bench'...\n",
+            "remote: Enumerating objects: 90, done.\u001b[K\n",
+            "remote: Counting objects: 100% (12/12), done.\u001b[K\n",
+            "remote: Compressing objects: 100% (12/12), done.\u001b[K\n",
+            "remote: Total 90 (delta 1), reused 6 (delta 0), pack-reused 78 (from 1)\u001b[K\n",
+            "Receiving objects: 100% (90/90), 45.07 MiB | 22.28 MiB/s, done.\n",
+            "Resolving deltas: 100% (10/10), done.\n",
+            "Filtering content: 100% (5/5), 163.22 MiB | 22.39 MiB/s, done.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Tool E Area-Occupancy"
+      ],
+      "metadata": {
+        "id": "lUnjwOstdRKE"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import ifcopenshell\n",
+        "import ifcopenshell.geom\n",
+        "import math"
+      ],
+      "metadata": {
+        "id": "d5CtifBBdduf"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Requirements\n",
+        "import math\n",
+        "import json\n",
+        "import ifcopenshell\n",
+        "import ifcopenshell.geom\n",
+        "\n",
+        "# --------------------------\n",
+        "# Geometry settings\n",
+        "# --------------------------\n",
+        "settings = ifcopenshell.geom.settings()\n",
+        "settings.set(settings.USE_WORLD_COORDS, True)\n",
+        "\n",
+        "# --------------------------\n",
+        "# IFC helpers\n",
+        "# --------------------------\n",
+        "def calculate_space_area(space):\n",
+        "    \"\"\"Approximate area by summing triangle areas from the space mesh.\"\"\"\n",
+        "    try:\n",
+        "        shape = ifcopenshell.geom.create_shape(settings, space)\n",
+        "        verts = shape.geometry.verts\n",
+        "        faces = shape.geometry.faces\n",
+        "        area = 0.0\n",
+        "\n",
+        "        for i in range(0, len(faces), 3):\n",
+        "            i0, i1, i2 = faces[i] * 3, faces[i + 1] * 3, faces[i + 2] * 3\n",
+        "            v0 = verts[i0:i0 + 3]\n",
+        "            v1 = verts[i1:i1 + 3]\n",
+        "            v2 = verts[i2:i2 + 3]\n",
+        "\n",
+        "            a = math.sqrt((v1[0]-v0[0])**2 + (v1[1]-v0[1])**2 + (v1[2]-v0[2])**2)\n",
+        "            b = math.sqrt((v2[0]-v1[0])**2 + (v2[1]-v1[1])**2 + (v2[2]-v1[2])**2)\n",
+        "            c = math.sqrt((v0[0]-v2[0])**2 + (v0[1]-v2[1])**2 + (v0[2]-v2[2])**2)\n",
+        "\n",
+        "            s = (a + b + c) / 2.0\n",
+        "            area += math.sqrt(max(s * (s - a) * (s - b) * (s - c), 0.0))\n",
+        "\n",
+        "        return float(area)\n",
+        "    except Exception:\n",
+        "        return 0.0\n",
+        "\n",
+        "\n",
+        "def _space_label(space):\n",
+        "    \"\"\"Return a readable label.\"\"\"\n",
+        "    return getattr(space, \"LongName\", None) or getattr(space, \"Name\", None) or \"Unnamed\"\n",
+        "\n",
+        "\n",
+        "def _matches_any_keyword(text, keywords):\n",
+        "    t = (text or \"\").lower()\n",
+        "    return any(k in t for k in keywords)\n",
+        "\n",
+        "\n",
+        "def get_spaces_by_keywords(model, keywords):\n",
+        "    \"\"\"Filter IfcSpace by semantic keywords.\"\"\"\n",
+        "    spaces = model.by_type(\"IfcSpace\")\n",
+        "    return [s for s in spaces if _matches_any_keyword(_space_label(s), keywords)]\n",
+        "\n",
+        "\n",
+        "# --------------------------\n",
+        "# Regulation logic\n",
+        "# --------------------------\n",
+        "def area_to_occupancy(area):\n",
+        "    \"\"\"\n",
+        "    Mapping regulation:\n",
+        "        <5 m²   -> not valid bedroom\n",
+        "        ≥5 m²   -> 1 person\n",
+        "        ≥8 m²   -> 2 people\n",
+        "        ≥12 m²  -> 3 people\n",
+        "    \"\"\"\n",
+        "    if area < 5.0:\n",
+        "        return 0\n",
+        "    elif area < 8.0:\n",
+        "        return 1\n",
+        "    elif area < 12.0:\n",
+        "        return 2\n",
+        "    else:\n",
+        "        return 3\n",
+        "\n",
+        "\n",
+        "def bedroom_occupancy_check(ifc_model_path):\n",
+        "    \"\"\"\n",
+        "    Determines allowed occupancy from bedroom areas.\n",
+        "\n",
+        "    Special rule:\n",
+        "    - If NO bedrooms exist (studio dwelling), occupancy is limited to max 2 people.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    model = ifcopenshell.open(ifc_model_path)\n",
+        "\n",
+        "    bedroom_keywords = [\"bedroom\", \"habitacion\", \"habitación\", \"dormitorio\"]\n",
+        "    living_keywords  = [\"living\", \"salon\", \"salón\", \"studio\", \"estudio\", \"common\"]\n",
+        "\n",
+        "    bedrooms = get_spaces_by_keywords(model, bedroom_keywords)\n",
+        "    living_spaces = get_spaces_by_keywords(model, living_keywords)\n",
+        "\n",
+        "    room_areas = {}\n",
+        "    occupancy = {}\n",
+        "    total_people = 0\n",
+        "\n",
+        "    # --------------------------\n",
+        "    # Studio case (no bedrooms)\n",
+        "    # --------------------------\n",
+        "    if len(bedrooms) == 0:\n",
+        "        if not living_spaces:\n",
+        "            return {\n",
+        "                \"result\": \"fail\",\n",
+        "                \"reason\": \"No habitable space identified\",\n",
+        "                \"room_areas\": {},\n",
+        "                \"occupancy\": {},\n",
+        "                \"total_allowed_people\": 0\n",
+        "            }\n",
+        "\n",
+        "        main_space = living_spaces[0]\n",
+        "        label = _space_label(main_space)\n",
+        "        area = calculate_space_area(main_space)\n",
+        "\n",
+        "        allowed = min(area_to_occupancy(area), 2)\n",
+        "\n",
+        "        room_areas[label] = float(area)\n",
+        "        occupancy[label] = allowed\n",
+        "\n",
+        "        return {\n",
+        "            \"result\": \"pass\",\n",
+        "            \"reason\": \"Studio dwelling limited to maximum 2 occupants\",\n",
+        "            \"room_areas\": room_areas,\n",
+        "            \"occupancy\": occupancy,\n",
+        "            \"total_allowed_people\": allowed\n",
+        "        }\n",
+        "\n",
+        "    # --------------------------\n",
+        "    # Bedroom-based occupancy\n",
+        "    # --------------------------\n",
+        "    for space in bedrooms:\n",
+        "        label = _space_label(space)\n",
+        "        area = calculate_space_area(space)\n",
+        "        allowed = area_to_occupancy(area)\n",
+        "\n",
+        "        if allowed == 0:\n",
+        "            return {\n",
+        "                \"result\": \"fail\",\n",
+        "                \"reason\": f\"{label} area {area:.2f} m² is below minimum 5 m²\",\n",
+        "                \"room_areas\": room_areas,\n",
+        "                \"occupancy\": occupancy,\n",
+        "                \"total_allowed_people\": total_people\n",
+        "            }\n",
+        "\n",
+        "        room_areas[label] = float(area)\n",
+        "        occupancy[label] = allowed\n",
+        "        total_people += allowed\n",
+        "\n",
+        "    return {\n",
+        "        \"result\": \"pass\",\n",
+        "        \"reason\": \"Bedroom areas satisfy occupancy requirements\",\n",
+        "        \"room_areas\": room_areas,\n",
+        "        \"occupancy\": occupancy,\n",
+        "        \"total_allowed_people\": total_people\n",
+        "    }\n",
+        "\n",
+        "\n",
+        "# --------------------------\n",
+        "# Tool entrypoint\n",
+        "# --------------------------\n",
+        "def bedroom_occupancy_check_tool(ifc_model_path: str):\n",
+        "    return bedroom_occupancy_check(ifc_model_path)\n",
+        "\n",
+        "\n",
+        "# --------------------------\n",
+        "# Schema (LLM-callable description)\n",
+        "# --------------------------\n",
+        "BEDROOM_OCCUPANCY_CHECK_SCHEMA = {\n",
+        "    \"name\": \"bedroom_occupancy_check_tool\",\n",
+        "    \"description\": \"Evaluates bedroom areas in an IFC model to determine the legally allowed number of occupants per room and for the dwelling.\",\n",
+        "    \"parameters\": {\n",
+        "        \"type\": \"object\",\n",
+        "        \"properties\": {\n",
+        "            \"ifc_model_path\": {\n",
+        "                \"type\": \"string\",\n",
+        "                \"description\": \"Filesystem path to the IFC model to evaluate.\"\n",
+        "            }\n",
+        "        },\n",
+        "        \"required\": [\"ifc_model_path\"]\n",
+        "    }\n",
+        "}\n",
+        "\n",
+        "\n",
+        "# --------------------------\n",
+        "# Optional: local sanity test\n",
+        "# --------------------------\n",
+        "if __name__ == \"__main__\":\n",
+        "    print(\"Schema OK:\")\n",
+        "    print(json.dumps(BEDROOM_OCCUPANCY_CHECK_SCHEMA, indent=2))\n",
+        "\n",
+        "    ifc_path = \"/content/ifc-bench/projects/duplex/arc.ifc\"\n",
+        "    result = bedroom_occupancy_check_tool(ifc_path)\n",
+        "\n",
+        "    print(result[\"result\"])\n",
+        "    print(result[\"reason\"])\n",
+        "    print(\"Allowed occupants:\", result[\"total_allowed_people\"])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "LWQ59ic1jaq2",
+        "outputId": "89b0e5cc-bae6-4fe3-9bc1-fa174a4c0a9c"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Schema OK:\n",
+            "{\n",
+            "  \"name\": \"bedroom_occupancy_check_tool\",\n",
+            "  \"description\": \"Evaluates bedroom areas in an IFC model to determine the legally allowed number of occupants per room and for the dwelling.\",\n",
+            "  \"parameters\": {\n",
+            "    \"type\": \"object\",\n",
+            "    \"properties\": {\n",
+            "      \"ifc_model_path\": {\n",
+            "        \"type\": \"string\",\n",
+            "        \"description\": \"Filesystem path to the IFC model to evaluate.\"\n",
+            "      }\n",
+            "    },\n",
+            "    \"required\": [\n",
+            "      \"ifc_model_path\"\n",
+            "    ]\n",
+            "  }\n",
+            "}\n",
+            "pass\n",
+            "Bedroom areas satisfy occupancy requirements\n",
+            "Allowed occupants: 12\n"
+          ]
+        }
+      ]
+    }
+  ]
+}

teams/Mastodonte/Mastodontes_Tools.ipynb

@@ -0,0 +1,857 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "id": "Sml3OcRVDn34",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "98ebd21d-e3d0-42da-8db2-dda12723f747"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting ifcopenshell\n",
+            "  Downloading ifcopenshell-0.8.4.post1-py312-none-manylinux_2_31_x86_64.whl.metadata (12 kB)\n",
+            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n",
+            "Requirement already satisfied: shapely in /usr/local/lib/python3.12/dist-packages (from ifcopenshell) (2.1.2)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from ifcopenshell) (2.0.2)\n",
+            "Collecting isodate (from ifcopenshell)\n",
+            "  Downloading isodate-0.7.2-py3-none-any.whl.metadata (11 kB)\n",
+            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.12/dist-packages (from ifcopenshell) (2.9.0.post0)\n",
+            "Requirement already satisfied: lark in /usr/local/lib/python3.12/dist-packages (from ifcopenshell) (1.3.1)\n",
+            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.12/dist-packages (from ifcopenshell) (4.15.0)\n",
+            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n",
+            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.61.1)\n",
+            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.4.9)\n",
+            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (26.0)\n",
+            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (11.3.0)\n",
+            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.3.2)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil->ifcopenshell) (1.17.0)\n",
+            "Downloading ifcopenshell-0.8.4.post1-py312-none-manylinux_2_31_x86_64.whl (42.6 MB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.6/42.6 MB\u001b[0m \u001b[31m17.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading isodate-0.7.2-py3-none-any.whl (22 kB)\n",
+            "Installing collected packages: isodate, ifcopenshell\n",
+            "Successfully installed ifcopenshell-0.8.4.post1 isodate-0.7.2\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Install ifcopenshell for IFC parsing\n",
+        "!pip install ifcopenshell matplotlib"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Cloning Repo - Depending on IFC File required"
+      ],
+      "metadata": {
+        "id": "pQdoZ0ZMITx4"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "LH-AJrKQD3-3",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "0b26ee51-3475-4f24-be68-b3a7d71c9559"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Cloning into 'ifc-bench'...\n",
+            "remote: Enumerating objects: 90, done.\u001b[K\n",
+            "remote: Counting objects: 100% (12/12), done.\u001b[K\n",
+            "remote: Compressing objects: 100% (12/12), done.\u001b[K\n",
+            "remote: Total 90 (delta 1), reused 6 (delta 0), pack-reused 78 (from 1)\u001b[K\n",
+            "Receiving objects: 100% (90/90), 45.07 MiB | 30.23 MiB/s, done.\n",
+            "Resolving deltas: 100% (10/10), done.\n",
+            "Filtering content: 100% (5/5), 163.22 MiB | 62.23 MiB/s, done.\n"
+          ]
+        }
+      ],
+      "source": [
+        "!git clone https://github.com/sylvainHellin/ifc-bench.git"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Tool A (Useful Surface Area)"
+      ],
+      "metadata": {
+        "id": "H5XL0-eub_8E"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "\n",
+        "# Requirements\n",
+        "import math\n",
+        "import json\n",
+        "import ifcopenshell\n",
+        "import ifcopenshell.geom\n",
+        "\n",
+        "# --------------------------\n",
+        "# Geometry settings\n",
+        "# --------------------------\n",
+        "settings = ifcopenshell.geom.settings()\n",
+        "settings.set(settings.USE_WORLD_COORDS, True)\n",
+        "\n",
+        "# --------------------------\n",
+        "# IFC helpers\n",
+        "# --------------------------\n",
+        "def calculate_space_area(space):\n",
+        "    \"\"\"Approximate area by summing triangle areas from the space mesh.\"\"\"\n",
+        "    try:\n",
+        "        shape = ifcopenshell.geom.create_shape(settings, space)\n",
+        "        verts = shape.geometry.verts\n",
+        "        faces = shape.geometry.faces\n",
+        "        area = 0.0\n",
+        "\n",
+        "        for i in range(0, len(faces), 3):\n",
+        "            i0, i1, i2 = faces[i] * 3, faces[i + 1] * 3, faces[i + 2] * 3\n",
+        "            v0 = verts[i0:i0 + 3]\n",
+        "            v1 = verts[i1:i1 + 3]\n",
+        "            v2 = verts[i2:i2 + 3]\n",
+        "\n",
+        "            a = math.sqrt((v1[0]-v0[0])**2 + (v1[1]-v0[1])**2 + (v1[2]-v0[2])**2)\n",
+        "            b = math.sqrt((v2[0]-v1[0])**2 + (v2[1]-v1[1])**2 + (v2[2]-v1[2])**2)\n",
+        "            c = math.sqrt((v0[0]-v2[0])**2 + (v0[1]-v2[1])**2 + (v0[2]-v2[2])**2)\n",
+        "\n",
+        "            s = (a + b + c) / 2.0\n",
+        "            area += math.sqrt(max(s * (s - a) * (s - b) * (s - c), 0.0))\n",
+        "\n",
+        "        return float(area)\n",
+        "    except Exception:\n",
+        "        return 0.0\n",
+        "\n",
+        "def dwelling_area_check(ifc_model_path, min_area=36.0):\n",
+        "    \"\"\"Check if total dwelling useful area >= min_area.\"\"\"\n",
+        "    model = ifcopenshell.open(ifc_model_path)\n",
+        "    spaces = model.by_type(\"IfcSpace\")\n",
+        "\n",
+        "    total_area = 0.0\n",
+        "    room_areas = {}\n",
+        "\n",
+        "    for space in spaces:\n",
+        "        area = calculate_space_area(space)\n",
+        "        room_name = getattr(space, \"LongName\", None) or getattr(space, \"Name\", None) or \"Unnamed\"\n",
+        "        room_areas[str(room_name)] = float(area)\n",
+        "        total_area += float(area)\n",
+        "\n",
+        "    if total_area >= float(min_area):\n",
+        "        return {\n",
+        "            \"result\": \"pass\",\n",
+        "            \"reason\": f\"Total useful area {total_area:.2f} m² >= {float(min_area):.2f} m²\",\n",
+        "            \"total_area\": float(total_area),\n",
+        "            \"room_areas\": room_areas,\n",
+        "        }\n",
+        "\n",
+        "    return {\n",
+        "        \"result\": \"fail\",\n",
+        "        \"reason\": f\"Total useful area {total_area:.2f} m² < {float(min_area):.2f} m²\",\n",
+        "        \"total_area\": float(total_area),\n",
+        "        \"room_areas\": room_areas,\n",
+        "    }\n",
+        "\n",
+        "# --------------------------\n",
+        "# Tool entrypoint (what your LLM router will call later)\n",
+        "# --------------------------\n",
+        "def dwelling_area_check_tool(ifc_model_path: str, min_area: float = 36.0):\n",
+        "    return dwelling_area_check(ifc_model_path, min_area)\n",
+        "\n",
+        "# --------------------------\n",
+        "# Schema (API key not needed)\n",
+        "# Plain JSON-schema-like dict, easy to serialize + pass to any LLM framework\n",
+        "# --------------------------\n",
+        "DWELLING_AREA_CHECK_SCHEMA = {\n",
+        "    \"name\": \"dwelling_area_check_tool\",\n",
+        "    \"description\": \"Checks whether an IFC dwelling meets a minimum total useful area requirement and returns a room-by-room breakdown.\",\n",
+        "    \"parameters\": {\n",
+        "        \"type\": \"object\",\n",
+        "        \"properties\": {\n",
+        "            \"ifc_model_path\": {\n",
+        "                \"type\": \"string\",\n",
+        "                \"description\": \"Filesystem path to the IFC model.\"\n",
+        "            },\n",
+        "            \"min_area\": {\n",
+        "                \"type\": \"number\",\n",
+        "                \"description\": \"Minimum total area in m². Default is 36.\"\n",
+        "            }\n",
+        "        },\n",
+        "        \"required\": [\"ifc_model_path\"]\n",
+        "    }\n",
+        "}\n",
+        "\n",
+        "# --------------------------\n",
+        "# Optional: local sanity test (no API usage)\n",
+        "# --------------------------\n",
+        "if __name__ == \"__main__\":\n",
+        "    print(\"Schema OK:\")\n",
+        "    print(json.dumps(DWELLING_AREA_CHECK_SCHEMA, indent=2))\n",
+        "\n",
+        "    ifc_path = \"/content/ifc-bench/projects/duplex/arc.ifc\"\n",
+        "    result = dwelling_area_check_tool(ifc_path, min_area=36.0)\n",
+        "    print(result[\"result\"])\n",
+        "    print(result[\"reason\"])\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "kLyNP9RDa9bN",
+        "outputId": "f8d9ef19-977d-4ac8-a547-fd5fed1ac5b2"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Schema OK:\n",
+            "{\n",
+            "  \"name\": \"dwelling_area_check_tool\",\n",
+            "  \"description\": \"Checks whether an IFC dwelling meets a minimum total useful area requirement and returns a room-by-room breakdown.\",\n",
+            "  \"parameters\": {\n",
+            "    \"type\": \"object\",\n",
+            "    \"properties\": {\n",
+            "      \"ifc_model_path\": {\n",
+            "        \"type\": \"string\",\n",
+            "        \"description\": \"Filesystem path to the IFC model.\"\n",
+            "      },\n",
+            "      \"min_area\": {\n",
+            "        \"type\": \"number\",\n",
+            "        \"description\": \"Minimum total area in m\\u00b2. Default is 36.\"\n",
+            "      }\n",
+            "    },\n",
+            "    \"required\": [\n",
+            "      \"ifc_model_path\"\n",
+            "    ]\n",
+            "  }\n",
+            "}\n",
+            "pass\n",
+            "Total useful area 1711.01 m² >= 36.00 m²\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "w65dIpWxJpmH"
+      },
+      "source": [
+        "# TOOL B - Living room Height Regulation"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import json\n",
+        "import ifcopenshell\n",
+        "import ifcopenshell.geom\n",
+        "\n",
+        "# --------------------------\n",
+        "# Geometry settings\n",
+        "# --------------------------\n",
+        "settings = ifcopenshell.geom.settings()\n",
+        "settings.set(settings.USE_WORLD_COORDS, True)\n",
+        "\n",
+        "# --------------------------\n",
+        "# Helper functions\n",
+        "# --------------------------\n",
+        "def load_model(ifc_model_path):\n",
+        "    \"\"\"Load IFC model\"\"\"\n",
+        "    return ifcopenshell.open(ifc_model_path)\n",
+        "\n",
+        "def get_main_living_areas(ifc_model):\n",
+        "    \"\"\"\n",
+        "    Return spaces considered main living areas.\n",
+        "    Filtering by common keywords in space name.\n",
+        "    \"\"\"\n",
+        "    spaces = ifc_model.by_type(\"IfcSpace\")\n",
+        "    main_spaces = []\n",
+        "    for s in spaces:\n",
+        "        if s.Name and any(keyword in s.Name.lower() for keyword in [\"living\", \"bedroom\", \"hall\"]):\n",
+        "            main_spaces.append(s)\n",
+        "    return main_spaces\n",
+        "\n",
+        "def get_space_height(space):\n",
+        "    \"\"\"\n",
+        "    Approximate height of a space from geometry bounding box.\n",
+        "    Uses Z coordinates of all vertices.\n",
+        "    \"\"\"\n",
+        "    try:\n",
+        "        shape = ifcopenshell.geom.create_shape(settings, space)\n",
+        "        verts = shape.geometry.verts\n",
+        "        if not verts:\n",
+        "            return 0.0\n",
+        "        zs = verts[2::3]\n",
+        "        return float(max(zs) - min(zs))\n",
+        "    except Exception:\n",
+        "        return 0.0\n",
+        "\n",
+        "# --------------------------\n",
+        "# Main check function\n",
+        "# --------------------------\n",
+        "def living_area_height_check(ifc_model_path, min_height=2.50):\n",
+        "    \"\"\"\n",
+        "    Check if all main living areas meet the minimum height requirement.\n",
+        "\n",
+        "    Returns a dictionary with:\n",
+        "    - result: 'pass' or 'fail'\n",
+        "    - reason: explanation string\n",
+        "    - room_heights: dictionary of room_name -> calculated height\n",
+        "    \"\"\"\n",
+        "    model = load_model(ifc_model_path)\n",
+        "    spaces = get_main_living_areas(model)\n",
+        "\n",
+        "    room_heights = {}\n",
+        "    for s in spaces:\n",
+        "        height = get_space_height(s)\n",
+        "        room_name = s.Name or \"Unnamed\"\n",
+        "        room_heights[room_name] = height\n",
+        "        if height < min_height:\n",
+        "            return {\n",
+        "                \"result\": \"fail\",\n",
+        "                \"reason\": f\"{room_name} height below {min_height}m\",\n",
+        "                \"room_heights\": room_heights\n",
+        "            }\n",
+        "\n",
+        "    return {\n",
+        "        \"result\": \"pass\",\n",
+        "        \"reason\": f\"All main living areas meet minimum height {min_height}m\",\n",
+        "        \"room_heights\": room_heights\n",
+        "    }\n",
+        "\n",
+        "# --------------------------\n",
+        "# Tool entrypoint (for an LLM router later)\n",
+        "# --------------------------\n",
+        "def living_area_height_check_tool(ifc_model_path: str, min_height: float = 2.50):\n",
+        "    return living_area_height_check(ifc_model_path, min_height)\n",
+        "\n",
+        "# --------------------------\n",
+        "# Schema (no API key needed)\n",
+        "# --------------------------\n",
+        "LIVING_AREA_HEIGHT_CHECK_SCHEMA = {\n",
+        "    \"name\": \"living_area_height_check_tool\",\n",
+        "    \"description\": \"Checks whether main living areas in an IFC meet a minimum height requirement and returns a room-by-room height breakdown.\",\n",
+        "    \"parameters\": {\n",
+        "        \"type\": \"object\",\n",
+        "        \"properties\": {\n",
+        "            \"ifc_model_path\": {\n",
+        "                \"type\": \"string\",\n",
+        "                \"description\": \"Filesystem path to the IFC model.\"\n",
+        "            },\n",
+        "            \"min_height\": {\n",
+        "                \"type\": \"number\",\n",
+        "                \"description\": \"Minimum height in meters. Default is 2.50.\"\n",
+        "            }\n",
+        "        },\n",
+        "        \"required\": [\"ifc_model_path\"]\n",
+        "    }\n",
+        "}\n",
+        "\n",
+        "# --------------------------\n",
+        "# Usage example (prints schema + pass/fail)\n",
+        "# --------------------------\n",
+        "if __name__ == \"__main__\":\n",
+        "    print(\"Schema OK:\")\n",
+        "    print(json.dumps(LIVING_AREA_HEIGHT_CHECK_SCHEMA, indent=2))\n",
+        "\n",
+        "    ifc_path = \"/content/ifc-bench/projects/duplex/arc.ifc\"  # change if needed\n",
+        "    check = living_area_height_check_tool(ifc_path, min_height=2.50)\n",
+        "\n",
+        "    print(\"\\nCheck result:\")\n",
+        "    print(check[\"result\"])\n",
+        "    print(check[\"reason\"])\n",
+        "    print(\"Room heights:\", check[\"room_heights\"])\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "2ZM-IGvFfMDj",
+        "outputId": "57d50092-fece-4522-fa79-ff940129a895"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Schema OK:\n",
+            "{\n",
+            "  \"name\": \"living_area_height_check_tool\",\n",
+            "  \"description\": \"Checks whether main living areas in an IFC meet a minimum height requirement and returns a room-by-room height breakdown.\",\n",
+            "  \"parameters\": {\n",
+            "    \"type\": \"object\",\n",
+            "    \"properties\": {\n",
+            "      \"ifc_model_path\": {\n",
+            "        \"type\": \"string\",\n",
+            "        \"description\": \"Filesystem path to the IFC model.\"\n",
+            "      },\n",
+            "      \"min_height\": {\n",
+            "        \"type\": \"number\",\n",
+            "        \"description\": \"Minimum height in meters. Default is 2.50.\"\n",
+            "      }\n",
+            "    },\n",
+            "    \"required\": [\n",
+            "      \"ifc_model_path\"\n",
+            "    ]\n",
+            "  }\n",
+            "}\n",
+            "\n",
+            "Check result:\n",
+            "pass\n",
+            "All main living areas meet minimum height 2.5m\n",
+            "Room heights: {}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1WSJIjCPKUk2"
+      },
+      "source": [
+        "# TOOL C - Living Room Area Check"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import json\n",
+        "import math\n",
+        "import ifcopenshell\n",
+        "import ifcopenshell.geom\n",
+        "\n",
+        "# Optional: only needed if you truly have it available\n",
+        "# from ifcopenshell.util.element import get_psets as _get_psets\n",
+        "\n",
+        "# --------------------------\n",
+        "# Geometry settings\n",
+        "# --------------------------\n",
+        "settings = ifcopenshell.geom.settings()\n",
+        "settings.set(settings.USE_WORLD_COORDS, True)\n",
+        "\n",
+        "# --------------------------\n",
+        "# Helper functions\n",
+        "# --------------------------\n",
+        "def load_model(ifc_model_path):\n",
+        "    return ifcopenshell.open(ifc_model_path)\n",
+        "\n",
+        "def calculate_space_area(space):\n",
+        "    \"\"\"\n",
+        "    Approximate area from mesh triangles.\n",
+        "    Note: this is mesh surface area, not guaranteed to be floor area.\n",
+        "    \"\"\"\n",
+        "    if hasattr(space, \"NetFloorArea\") and space.NetFloorArea:\n",
+        "        return float(space.NetFloorArea)\n",
+        "\n",
+        "    try:\n",
+        "        shape = ifcopenshell.geom.create_shape(settings, space)\n",
+        "        verts = shape.geometry.verts\n",
+        "        faces = shape.geometry.faces\n",
+        "        area = 0.0\n",
+        "\n",
+        "        for i in range(0, len(faces), 3):\n",
+        "            idx0, idx1, idx2 = faces[i] * 3, faces[i + 1] * 3, faces[i + 2] * 3\n",
+        "            v0 = verts[idx0:idx0 + 3]\n",
+        "            v1 = verts[idx1:idx1 + 3]\n",
+        "            v2 = verts[idx2:idx2 + 3]\n",
+        "\n",
+        "            a = math.sqrt((v1[0]-v0[0])**2 + (v1[1]-v0[1])**2 + (v1[2]-v0[2])**2)\n",
+        "            b = math.sqrt((v2[0]-v1[0])**2 + (v2[1]-v1[1])**2 + (v2[2]-v1[2])**2)\n",
+        "            c = math.sqrt((v0[0]-v2[0])**2 + (v0[1]-v2[1])**2 + (v0[2]-v2[2])**2)\n",
+        "\n",
+        "            s = (a + b + c) / 2.0\n",
+        "            area += math.sqrt(max(s * (s - a) * (s - b) * (s - c), 0.0))\n",
+        "\n",
+        "        return float(area)\n",
+        "    except Exception:\n",
+        "        return 0.0\n",
+        "\n",
+        "def get_space_name(space):\n",
+        "    \"\"\"Get descriptive name if available, fallback to LongName/Name/GlobalId.\"\"\"\n",
+        "    if getattr(space, \"LongName\", None):\n",
+        "        return str(space.LongName)\n",
+        "    if getattr(space, \"Name\", None):\n",
+        "        return str(space.Name)\n",
+        "\n",
+        "    # If you have ifcopenshell.util.element available, you can enable this block:\n",
+        "    # try:\n",
+        "    #     psets = _get_psets(space)\n",
+        "    #     for props in (psets or {}).values():\n",
+        "    #         for k, v in (props or {}).items():\n",
+        "    #             if \"name\" in str(k).lower() and isinstance(v, str) and v.strip():\n",
+        "    #                 return v.strip()\n",
+        "    # except Exception:\n",
+        "    #     pass\n",
+        "\n",
+        "    return str(getattr(space, \"GlobalId\", \"Unnamed\"))\n",
+        "\n",
+        "def can_fit_square(area_m2, width=2.4, depth=2.4):\n",
+        "    \"\"\"Approx check: area must allow a width x depth square.\"\"\"\n",
+        "    return float(area_m2) >= float(width) * float(depth)\n",
+        "\n",
+        "# --------------------------\n",
+        "# Living room compliance\n",
+        "# --------------------------\n",
+        "def living_room_compliance(ifc_model_path):\n",
+        "    \"\"\"\n",
+        "    Rule encoded:\n",
+        "      - Living room min area 10 m²\n",
+        "      - If living+kitchen combined: min area 14 m²\n",
+        "      - Must allow 2.40 x 2.40 m clearance (approx via area check)\n",
+        "    Returns list of per-space results.\n",
+        "    \"\"\"\n",
+        "    model = load_model(ifc_model_path)\n",
+        "    spaces = model.by_type(\"IfcSpace\")\n",
+        "\n",
+        "    results = []\n",
+        "\n",
+        "    for space in spaces:\n",
+        "        raw_name = get_space_name(space)\n",
+        "        name = raw_name.lower()\n",
+        "        area = calculate_space_area(space)\n",
+        "        if area <= 0:\n",
+        "            continue\n",
+        "\n",
+        "        if \"living\" in name:\n",
+        "            has_kitchen = \"kitchen\" in name\n",
+        "            min_area = 14.0 if has_kitchen else 10.0\n",
+        "\n",
+        "            clearance_ok = can_fit_square(area, 2.4, 2.4)\n",
+        "            passed = (area >= min_area) and clearance_ok\n",
+        "\n",
+        "            reasons = []\n",
+        "            if area < min_area:\n",
+        "                reasons.append(f\"Area {area:.2f} m² < required {min_area:.2f} m²\")\n",
+        "            if not clearance_ok:\n",
+        "                reasons.append(\"Does not allow 2.40 m x 2.40 m square (approx)\")\n",
+        "\n",
+        "            results.append({\n",
+        "                \"space_name\": raw_name,\n",
+        "                \"area_m2\": float(area),\n",
+        "                \"min_required_m2\": float(min_area),\n",
+        "                \"clearance_ok\": bool(clearance_ok),\n",
+        "                \"result\": \"pass\" if passed else \"fail\",\n",
+        "                \"reason\": \"; \".join(reasons) if reasons else \"Complies\"\n",
+        "            })\n",
+        "\n",
+        "    return results\n",
+        "\n",
+        "# --------------------------\n",
+        "# Tool entrypoint (for an LLM router later)\n",
+        "# --------------------------\n",
+        "def living_room_compliance_tool(ifc_model_path: str):\n",
+        "    return living_room_compliance(ifc_model_path)\n",
+        "\n",
+        "# --------------------------\n",
+        "# Schema (no API key needed)\n",
+        "# --------------------------\n",
+        "LIVING_ROOM_COMPLIANCE_SCHEMA = {\n",
+        "    \"name\": \"living_room_compliance_tool\",\n",
+        "    \"description\": \"Checks living room spaces in an IFC for minimum area and clearance rules and returns per-space compliance results.\",\n",
+        "    \"parameters\": {\n",
+        "        \"type\": \"object\",\n",
+        "        \"properties\": {\n",
+        "            \"ifc_model_path\": {\n",
+        "                \"type\": \"string\",\n",
+        "                \"description\": \"Filesystem path to the IFC model.\"\n",
+        "            }\n",
+        "        },\n",
+        "        \"required\": [\"ifc_model_path\"]\n",
+        "    }\n",
+        "}\n",
+        "\n",
+        "# --------------------------\n",
+        "# Usage example (prints schema + report)\n",
+        "# --------------------------\n",
+        "if __name__ == \"__main__\":\n",
+        "    print(\"Schema OK:\")\n",
+        "    print(json.dumps(LIVING_ROOM_COMPLIANCE_SCHEMA, indent=2))\n",
+        "\n",
+        "    ifc_path = \"/content/ifc-bench/projects/duplex/arc.ifc\"  # change if needed\n",
+        "    report = living_room_compliance_tool(ifc_path)\n",
+        "\n",
+        "    print(\"\\nReport:\")\n",
+        "    if not report:\n",
+        "        print(\"No living room spaces matched (keyword 'living') or no computable areas.\")\n",
+        "    else:\n",
+        "        for r in report:\n",
+        "            print(f\"{r['space_name']}: {r['area_m2']:.2f} m² (min {r['min_required_m2']:.2f} m²) → {r['result']}\")\n",
+        "            if r[\"result\"] == \"fail\":\n",
+        "                print(f\"  Reason: {r['reason']}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "VdNVP6ZxlSMv",
+        "outputId": "1199768c-fb27-4aa6-f63f-6f0be8259a5d"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Schema OK:\n",
+            "{\n",
+            "  \"name\": \"living_room_compliance_tool\",\n",
+            "  \"description\": \"Checks living room spaces in an IFC for minimum area and clearance rules and returns per-space compliance results.\",\n",
+            "  \"parameters\": {\n",
+            "    \"type\": \"object\",\n",
+            "    \"properties\": {\n",
+            "      \"ifc_model_path\": {\n",
+            "        \"type\": \"string\",\n",
+            "        \"description\": \"Filesystem path to the IFC model.\"\n",
+            "      }\n",
+            "    },\n",
+            "    \"required\": [\n",
+            "      \"ifc_model_path\"\n",
+            "    ]\n",
+            "  }\n",
+            "}\n",
+            "\n",
+            "Report:\n",
+            "Living Room: 109.86 m² (min 10.00 m²) → pass\n",
+            "Living Room: 109.86 m² (min 10.00 m²) → pass\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Tool D Service Area Heights"
+      ],
+      "metadata": {
+        "id": "4aFj5ZiBlYYm"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import json\n",
+        "import ifcopenshell\n",
+        "import ifcopenshell.geom\n",
+        "\n",
+        "# --------------------------\n",
+        "# Geometry settings\n",
+        "# --------------------------\n",
+        "settings = ifcopenshell.geom.settings()\n",
+        "settings.set(settings.USE_WORLD_COORDS, True)\n",
+        "\n",
+        "# --------------------------\n",
+        "# Helper functions\n",
+        "# --------------------------\n",
+        "def load_model(ifc_model_path):\n",
+        "    return ifcopenshell.open(ifc_model_path)\n",
+        "\n",
+        "def get_space_name(space):\n",
+        "    \"\"\"Get descriptive name if available, fallback to LongName/Name/GlobalId.\"\"\"\n",
+        "    if getattr(space, \"LongName\", None):\n",
+        "        return str(space.LongName)\n",
+        "    if getattr(space, \"Name\", None):\n",
+        "        return str(space.Name)\n",
+        "    return str(getattr(space, \"GlobalId\", \"Unnamed\"))\n",
+        "\n",
+        "def get_space_height(space):\n",
+        "    \"\"\"\n",
+        "    Approximate height of a space from geometry bounding box.\n",
+        "    Uses Z coordinates of all vertices.\n",
+        "    \"\"\"\n",
+        "    try:\n",
+        "        shape = ifcopenshell.geom.create_shape(settings, space)\n",
+        "        verts = shape.geometry.verts\n",
+        "        if not verts:\n",
+        "            return 0.0\n",
+        "        zs = verts[2::3]\n",
+        "        return float(max(zs) - min(zs))\n",
+        "    except Exception:\n",
+        "        return 0.0\n",
+        "\n",
+        "def is_service_space(space_name_lower):\n",
+        "    \"\"\"Bathrooms, kitchens, hallways by keywords.\"\"\"\n",
+        "    service_keywords = [\n",
+        "        \"bath\", \"bathroom\", \"baño\", \"bano\", \"wc\", \"toilet\",\n",
+        "        \"kitchen\", \"cocina\",\n",
+        "        \"hall\", \"hallway\", \"corridor\", \"pasillo\"\n",
+        "    ]\n",
+        "    return any(k in space_name_lower for k in service_keywords)\n",
+        "\n",
+        "# --------------------------\n",
+        "# Compliance check\n",
+        "# --------------------------\n",
+        "def service_spaces_min_height_check(ifc_model_path, min_height=2.20):\n",
+        "    \"\"\"\n",
+        "    Regulation:\n",
+        "      - Minimum height in bathrooms, kitchens, and hallways is 2.20 m\n",
+        "\n",
+        "    Returns:\n",
+        "      - result: 'pass' or 'fail'\n",
+        "      - reason\n",
+        "      - room_heights: dict label -> height\n",
+        "      - checked_spaces: list of labels that were evaluated\n",
+        "    \"\"\"\n",
+        "    model = load_model(ifc_model_path)\n",
+        "    spaces = model.by_type(\"IfcSpace\")\n",
+        "\n",
+        "    room_heights = {}\n",
+        "    checked_spaces = []\n",
+        "\n",
+        "    for space in spaces:\n",
+        "        label = get_space_name(space)\n",
+        "        label_l = label.lower()\n",
+        "\n",
+        "        if not is_service_space(label_l):\n",
+        "            continue\n",
+        "\n",
+        "        checked_spaces.append(label)\n",
+        "        h = get_space_height(space)\n",
+        "        room_heights[label] = h\n",
+        "\n",
+        "        if h < float(min_height):\n",
+        "            return {\n",
+        "                \"result\": \"fail\",\n",
+        "                \"reason\": f\"{label} height below {float(min_height):.2f}m\",\n",
+        "                \"room_heights\": room_heights,\n",
+        "                \"checked_spaces\": checked_spaces\n",
+        "            }\n",
+        "\n",
+        "    if not checked_spaces:\n",
+        "        return {\n",
+        "            \"result\": \"fail\",\n",
+        "            \"reason\": \"No bathrooms/kitchens/hallways matched by keywords, nothing checked\",\n",
+        "            \"room_heights\": room_heights,\n",
+        "            \"checked_spaces\": checked_spaces\n",
+        "        }\n",
+        "\n",
+        "    return {\n",
+        "        \"result\": \"pass\",\n",
+        "        \"reason\": f\"All checked bathrooms/kitchens/hallways meet minimum height {float(min_height):.2f}m\",\n",
+        "        \"room_heights\": room_heights,\n",
+        "        \"checked_spaces\": checked_spaces\n",
+        "    }\n",
+        "\n",
+        "# --------------------------\n",
+        "# Tool entrypoint (for an LLM router later)\n",
+        "# --------------------------\n",
+        "def service_spaces_min_height_check_tool(ifc_model_path: str, min_height: float = 2.20):\n",
+        "    return service_spaces_min_height_check(ifc_model_path, min_height)\n",
+        "\n",
+        "# --------------------------\n",
+        "# Schema (no API key needed)\n",
+        "# --------------------------\n",
+        "SERVICE_SPACES_MIN_HEIGHT_SCHEMA = {\n",
+        "    \"name\": \"service_spaces_min_height_check_tool\",\n",
+        "    \"description\": \"Checks bathrooms, kitchens, and hallways in an IFC for a minimum height requirement (default 2.20m).\",\n",
+        "    \"parameters\": {\n",
+        "        \"type\": \"object\",\n",
+        "        \"properties\": {\n",
+        "            \"ifc_model_path\": {\n",
+        "                \"type\": \"string\",\n",
+        "                \"description\": \"Filesystem path to the IFC model.\"\n",
+        "            },\n",
+        "            \"min_height\": {\n",
+        "                \"type\": \"number\",\n",
+        "                \"description\": \"Minimum height in meters. Default is 2.20.\"\n",
+        "            }\n",
+        "        },\n",
+        "        \"required\": [\"ifc_model_path\"]\n",
+        "    }\n",
+        "}\n",
+        "\n",
+        "# --------------------------\n",
+        "# Usage example (prints schema + pass/fail)\n",
+        "# --------------------------\n",
+        "if __name__ == \"__main__\":\n",
+        "    print(\"Schema OK:\")\n",
+        "    print(json.dumps(SERVICE_SPACES_MIN_HEIGHT_SCHEMA, indent=2))\n",
+        "\n",
+        "    ifc_path = \"/content/ifc-bench/projects/duplex/arc.ifc\"  # change if needed\n",
+        "    check = service_spaces_min_height_check_tool(ifc_path, min_height=2.20)\n",
+        "\n",
+        "    print(\"\\nCheck result:\")\n",
+        "    print(check[\"result\"])\n",
+        "    print(check[\"reason\"])\n",
+        "    print(\"Room heights:\", check[\"room_heights\"])\n",
+        "    print(\"Checked spaces:\", check[\"checked_spaces\"])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IWZ7ISP3mYg4",
+        "outputId": "aeaa8d7f-6b14-4339-984b-6da478889046"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Schema OK:\n",
+            "{\n",
+            "  \"name\": \"service_spaces_min_height_check_tool\",\n",
+            "  \"description\": \"Checks bathrooms, kitchens, and hallways in an IFC for a minimum height requirement (default 2.20m).\",\n",
+            "  \"parameters\": {\n",
+            "    \"type\": \"object\",\n",
+            "    \"properties\": {\n",
+            "      \"ifc_model_path\": {\n",
+            "        \"type\": \"string\",\n",
+            "        \"description\": \"Filesystem path to the IFC model.\"\n",
+            "      },\n",
+            "      \"min_height\": {\n",
+            "        \"type\": \"number\",\n",
+            "        \"description\": \"Minimum height in meters. Default is 2.20.\"\n",
+            "      }\n",
+            "    },\n",
+            "    \"required\": [\n",
+            "      \"ifc_model_path\"\n",
+            "    ]\n",
+            "  }\n",
+            "}\n",
+            "\n",
+            "Check result:\n",
+            "pass\n",
+            "All checked bathrooms/kitchens/hallways meet minimum height 2.20m\n",
+            "Room heights: {'Hallway': 2.8810000000001947, 'Bathroom 2': 2.5870000000001836, 'Bathroom 1': 2.587000000000001, 'Kitchen': 2.587000000000001}\n",
+            "Checked spaces: ['Hallway', 'Hallway', 'Bathroom 2', 'Bathroom 1', 'Kitchen', 'Kitchen', 'Bathroom 2', 'Bathroom 1']\n"
+          ]
+        }
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

teams/Mastodonte/USER_PORTAL_PRD.md

@@ -0,0 +1,166 @@
+# User Portal — PRD (IFCore) — MVP
+
+## Overview (Revised per Team B feedback)
+A lightweight authentication system for IFCore enabling sign up, login, logout, and profile management. This is a **foundation feature** that unblocks all other teams by providing `useSession()` hooks and role-based access.
+
+**Scope:** Signup → Login → Profile page only. **Duration:** 4–6 hours (not 4 weeks).
+
+Uses:
+- **Frontend:** Cloudflare Pages (TanStack Router, Zustand)
+- **Auth backend:** Cloudflare Worker with **Better Auth** (replaces manual auth implementation)
+- **Database:** D1 (Better Auth creates its own tables; does NOT modify existing `users` table)
+- **Email/Stripe/TOTP:** Cut from MVP (post-launch features)
+
+## Users & Roles (Simplified)
+- **All users**: sign up with email + password, log in, view profile, log out.
+- **Role model**: `role: "member"` (default) or `role: "captain"` (admins). Simple, not four-role RBAC.
+
+## Goals
+1. **Unblock all other teams** by providing `useSession()` React hook and persistent session state.
+2. Ship a working login/signup flow in < 6 hours using Better Auth (not custom hashing/session logic).
+3. Integrate with D1 and Cloudflare Workers following IFCore architecture.
+4. Respect existing `users` table schema — use Better Auth's default tables instead.
+
+## MVP Scope (Shippable in 1 day)
+
+1. **Sign up** — email + password. Create user in Better Auth's `user` table.
+2. **Log in** — email + password. Session cookie set by Worker.
+3. **Log out** — clear session, redirect to home.
+4. **Profile page** — show current user's name and email. Link to logout.
+5. **Navigation** — show "Log in" if unauthenticated, show user name + "Profile" link if authenticated.
+6. **RBAC enforcement** — each user has `role: "member"` or `"captain"` (stored in Better Auth's user table).
+
+### NOT in MVP (cut for later)
+- Email verification
+- Password reset
+- Stripe billing / subscription management
+- 2FA / TOTP
+- Support ticketing
+- Account deletion
+- API key management
+- Onboarding questionnaire
+- T&Cs flow (optional: can add with a checkbox, but no signing logic)
+- Support ticket system
+
+## Data Model (Better Auth defaults + minimal custom fields)
+
+Better Auth creates these tables automatically:
+- `user` — id, email, password (hashed with PBKDF2, NOT bcrypt), name, email_verified (boolean), image (optional), role (TEXT: "member" or "captain")
+- `session` — session management (Better Auth handles this)
+- `account` — OAuth/social login (not used in MVP)
+- `verification` — email verification tokens (not used in MVP)
+
+**Do NOT modify the existing `users` table.** It is used by other teams and the platform. Better Auth's `user` table is separate and additive.
+
+## API Endpoints (Worker, via Better Auth)
+
+All endpoints are auto-generated by Better Auth under `/api/auth/*`:
+- `POST /api/auth/sign-up` — Create new user (email, password, name)
+- `POST /api/auth/sign-in` — Log in (email, password) → returns session cookie
+- `POST /api/auth/sign-out` — Log out → clear session cookie
+- `GET /api/auth/session` — Get current session (for `useSession()` hook)
+
+Other teams call `useSession()` to access the session state. No custom API design needed.
+
+## UX Flows (simplified)
+
+1. **Sign up** → Form (email, password, name) → POST /api/auth/sign-up → Session cookie set → Redirect to `/profile`
+2. **Log in** → Form (email, password) → POST /api/auth/sign-in → Session cookie set → Redirect to `/profile`
+3. **Log out** → POST /api/auth/sign-out → Clear cookie → Redirect to `/`
+4. **Profile page** → Show user name, email. Link to logout.
+5. **Nav bar** → If logged in, show name + "Profile" link. Else, show "Log In" link.
+
+## Why Better Auth (not custom auth)
+
+**Rule:** Do NOT use bcrypt for password hashing in Cloudflare Workers. Bcrypt exceeds the 10ms CPU limit and causes Error 1102. Better Auth handles this automatically with PBKDF2.
+
+**Why not build custom auth:**
+- Passwords: hashing, validation, salting (security-critical, weeks of testing).
+- Sessions: cookie management, CSRF tokens, expiry, refresh logic.
+- Database schema: user tables, session tables, verifications (tedious DDL).
+- Cookies: HTTP-only, SameSite, Secure flags.
+
+Better Auth does all of this in ~50 lines of config. Use it.
+
+## Security & Compliance (simplified for MVP)
+
+- **Passwords:** Better Auth uses PBKDF2 (works in Workers). Enforces strong passwords at signup.
+- **Sessions:** HTTP-only, Secure, SameSite=Strict cookies managed by Better Auth.
+- **CSRF:** Automatic via SameSite cookies.
+- **Database tables:** Better Auth creates its own; does NOT touch existing `users` table.
+- **Env variables:** BETTER_AUTH_SECRET and BETTER_AUTH_URL stored in Cloudflare secrets or `.dev.vars`.
+
+## Monitoring & Alerts
+- Not in MVP. Post-launch: monitor signup/login failure spikes, session errors, Worker errors via D1 logs.
+
+## Edge Cases & Error Handling
+- Invalid credentials: show error on login form.
+- Password too weak: show validation error.
+- Email already registered: show error on signup.
+- Session expired: redirect to login.
+- Database errors: log and show generic "something went wrong" message.
+
+No complex retry logic, idempotency, or partial provisioning recovery needed for MVP.
+
+## MVP (v1) — 4–6 hours, shippable feature
+
+**Backend (2–3 hours)**
+- Install Better Auth and configure for D1 + PBKDF2.
+- Mount auth routes in Cloudflare Worker at `/api/auth/*`.
+- Create D1 migration for Better Auth tables (`user`, `session`, `account`, `verification`).
+- Ensure `run_worker_first: ["/api/*"]` in wrangler.jsonc so Worker intercepts requests.
+- Set `BETTER_AUTH_SECRET` and `BETTER_AUTH_URL` environment variables.
+
+**Frontend (2–3 hours)**
+- Create `auth-client.ts` with `createAuthClient` and `useSession` hook.
+- Build login page: email + password form, "Sign Up" button.
+- Build signup page: email + password + name form.
+- Build profile page: show user name, email, logout button.
+- Update navbar: show login/logout state conditionally.
+- Deploy to Cloudflare Pages.
+
+**Testing (30 min)**
+- Sign up with new email.
+- Verify navbar shows your name.
+- Log out and verify navbar changes.
+- Log back in and verify profile page works.
+
+## Acceptance Criteria
+- Users can sign up with email + password and are logged in automatically.
+- Users can log in with existing email + password.
+- Users can log out and navbar reflects unauthenticated state.
+- Profile page shows user name and email; only accessible when logged in.
+- Session persists across page reloads (cookie-based).
+- Better Auth tables created in D1 without modifying the existing `users` table.
+
+## How This Unblocks Other Teams
+
+Every other team uses `useSession()` to gate features and filter data:
+```jsx
+import { useSession } from '@/lib/auth-client'
+
+export function Profile() {
+  const { data: session } = useSession()
+  if (!session) return <Redirect to="/login" />
+  return <h1>Welcome {session.user.name}</h1>
+}
+```
+
+You ship login/signup/profile. Other teams ship the dashboard, 3D viewer, report generator. Together = complete product.
+
+## Next Steps / Deliverables
+1. Review this MVP scope and approve (should take ~1 hour, not 4 weeks).
+2. Scaffold Cloudflare Worker Better Auth config (use the Cloudflare skill blueprint).
+3. Create frontend components (LoginPage, SignupPage, ProfilePage).
+4. Deploy to staging and test end-to-end.
+5. Do quick RBAC test (ensure captain role is stored/retrieved).
+6. Deploy to production.
+
+## Post-Launch Roadmap (out of scope for MVP)
+- Email verification and password reset
+- Stripe billing + subscription management
+- 2FA / TOTP
+- Support ticket system
+- Account deletion with retention window
+- Team invite / member management
+- API key generation and rotation

teams/Mastodonte/main.py

@@ -0,0 +1,97 @@
+"""
+IFCore Compliance Checker - Integration Test
+
+This script tests all check_* functions against an IFC model.
+Each check_* function returns list[dict] following the IFCore schema.
+"""
+import ifcopenshell
+from tools.checker_dwelling import check_dwelling_area
+from tools.checker_heights import check_living_area_height
+from tools.checker_living_rooms import check_living_room_compliance
+from tools.checker_service_spaces import check_service_spaces_min_height
+
+
+# Map of check names to functions and their parameters
+CHECKS = {
+    "dwelling_area": {
+        "func": check_dwelling_area,
+        "kwargs": {"min_area": 36.0},
+    },
+    "living_area_height": {
+        "func": check_living_area_height,
+        "kwargs": {"min_height": 2.50},
+    },
+    "living_room_compliance": {
+        "func": check_living_room_compliance,
+        "kwargs": {},
+    },
+    "service_spaces_min_height": {
+        "func": check_service_spaces_min_height,
+        "kwargs": {"min_height": 2.20},
+    },
+}
+
+
+def run_all_checks(ifc_model_path):
+    """
+    Load IFC model once and run all checks.
+    
+    Returns:
+        dict: { check_name: [results], ... }
+    """
+    print(f"Loading IFC model: {ifc_model_path}")
+    model = ifcopenshell.open(ifc_model_path)
+    
+    all_results = {}
+    
+    for check_name, check_info in CHECKS.items():
+        print(f"\nRunning {check_name}...")
+        func = check_info["func"]
+        kwargs = check_info["kwargs"]
+        
+        try:
+            results = func(model, **kwargs)
+            all_results[check_name] = results
+            print(str(results))
+            
+            # Print summary
+            if results:
+                passed = sum(1 for r in results if r["check_status"] == "pass")
+                failed = sum(1 for r in results if r["check_status"] == "fail")
+                print(f"  [OK] {check_name}: {passed} passed, {failed} failed")
+                
+                for r in results:
+                    status_symbol = "[PASS]" if r["check_status"] == "pass" else "[FAIL]"
+                    print(f"    {status_symbol} {r['element_name']}: {r['actual_value']} (req: {r['required_value']})")
+                    if r['comment']:
+                        print(f"      -> {r['comment']}")
+            else:
+                print(f"  [INFO] {check_name}: No elements checked")
+        
+        except Exception as e:
+            print(f"  [ERROR] {check_name} FAILED: {str(e)}")
+            all_results[check_name] = []
+    
+    return all_results
+
+
+if __name__ == "__main__":
+    ifc_path = r"C:/Users/OWNER/Desktop/IAAC/T05/AI_SpeedRun/AI-Speed-Run-Week/ifc_models/arc.ifc"
+    
+    print("=" * 70)
+    print("IFCore Compliance Checker - Integration Test")
+    print("=" * 70)
+    
+    results = run_all_checks(ifc_path)
+    
+    print("\n" + "=" * 70)
+    print("SUMMARY")
+    print("=" * 70)
+    for check_name, check_results in results.items():
+        if check_results:
+            passed = sum(1 for r in check_results if r["check_status"] == "pass")
+            failed = sum(1 for r in check_results if r["check_status"] == "fail")
+            print(f"{check_name}: {passed} PASS / {failed} FAIL")
+        else:
+            print(f"{check_name}: (no results)")
+

teams/Mastodonte/requirements.txt

@@ -0,0 +1 @@
+ifcopenshell

teams/Mastodonte/tools/__init__.py

@@ -0,0 +1,22 @@
+"""
+IFCore Compliance Checker Tools
+
+All check_* functions exported from this package follow the IFCore contract:
+- Signature: check_*(model, **kwargs)
+- Returns: list[dict] with IFCore schema (element_id, element_type, check_status, etc.)
+- Platform auto-discovers check functions by name prefix "check_"
+"""
+
+from .checker_dwelling import check_dwelling_area
+from .checker_heights import check_living_area_height
+from .checker_living_rooms import check_living_room_compliance
+from .checker_service_spaces import check_service_spaces_min_height
+from .checker_occupancy import check_bedroom_occupancy
+
+__all__ = [
+    "check_dwelling_area",
+    "check_living_area_height",
+    "check_living_room_compliance",
+    "check_service_spaces_min_height",
+    "check_bedroom_occupancy",
+]

teams/Mastodonte/tools/checker_dwelling.py

@@ -0,0 +1,101 @@
+# Requirements
+import math
+import json
+import ifcopenshell
+import ifcopenshell.geom
+
+# --------------------------
+# Geometry settings
+# --------------------------
+settings = ifcopenshell.geom.settings()
+settings.set(settings.USE_WORLD_COORDS, True)
+
+# --------------------------
+# IFC helpers
+# --------------------------
+def calculate_space_area(space):
+    """Approximate area by summing triangle areas from the space mesh."""
+    try:
+        shape = ifcopenshell.geom.create_shape(settings, space)
+        verts = shape.geometry.verts
+        faces = shape.geometry.faces
+        area = 0.0
+
+        for i in range(0, len(faces), 3):
+            i0, i1, i2 = faces[i] * 3, faces[i + 1] * 3, faces[i + 2] * 3
+            v0 = verts[i0:i0 + 3]
+            v1 = verts[i1:i1 + 3]
+            v2 = verts[i2:i2 + 3]
+
+            a = math.sqrt((v1[0]-v0[0])**2 + (v1[1]-v0[1])**2 + (v1[2]-v0[2])**2)
+            b = math.sqrt((v2[0]-v1[0])**2 + (v2[1]-v1[1])**2 + (v2[2]-v1[2])**2)
+            c = math.sqrt((v0[0]-v2[0])**2 + (v0[1]-v2[1])**2 + (v0[2]-v2[2])**2)
+
+            s = (a + b + c) / 2.0
+            area += math.sqrt(max(s * (s - a) * (s - b) * (s - c), 0.0))
+
+        return float(area)
+    except Exception:
+        return 0.0
+
+def check_dwelling_area(model, min_area=36.0):
+    """
+    Check if each space in the dwelling meets minimum area requirement.
+    
+    Args:
+        model: ifcopenshell.file object (pre-loaded IFC model)
+        min_area: minimum total area in m² (default 36.0)
+    
+    Returns:
+        list[dict]: One dict per IfcSpace element, following IFCore schema
+    """
+    spaces = model.by_type("IfcSpace")
+    results = []
+    total_area = 0.0
+
+    for space in spaces:
+        area = calculate_space_area(space)
+        space_name = getattr(space, "LongName", None) or getattr(space, "Name", None) or f"Space #{space.id()}"
+        space_id = getattr(space, "GlobalId", str(space.id()))
+        
+        total_area += float(area)
+        
+        results.append({
+            "element_id": space_id,
+            "element_type": "IfcSpace",
+            "element_name": space_name,
+            "element_name_long": f"{space_name} (dwelling area check)",
+            "check_status": "pass",  # Will be determined after loop for aggregate
+            "actual_value": f"{area:.2f} m²",
+            "required_value": f"{min_area:.2f} m²",
+            "comment": None,
+            "log": None,
+        })
+
+    # Update check_status based on total area
+    if len(results) == 0:
+        return results
+    
+    status = "pass" if total_area >= float(min_area) else "fail"
+    for result in results:
+        result["check_status"] = status
+        if status == "fail":
+            result["comment"] = f"Total dwelling area {total_area:.2f} m² is below required {min_area:.2f} m²"
+    
+    return results
+
+
+# --------------------------
+# Local testing (optional)
+# --------------------------
+if __name__ == "__main__":
+    import ifcopenshell
+    ifc_path = "C:/Users/OWNER/Desktop/IAAC/T05/AI_SpeedRun/AI-Speed-Run-Week/ifc_models/arc.ifc"
+    model = ifcopenshell.open(ifc_path)
+    results = check_dwelling_area(model, min_area=36.0)
+    
+    print("Dwelling Area Check Results:")
+    for r in results:
+        print(f"[{r['check_status'].upper()}] {r['element_name']}: {r['actual_value']}")
+        if r['comment']:
+            print(f"  → {r['comment']}")

teams/Mastodonte/tools/checker_heights.py

@@ -0,0 +1,97 @@
+import json
+import ifcopenshell
+import ifcopenshell.geom
+
+# --------------------------
+# Geometry settings
+# --------------------------
+settings = ifcopenshell.geom.settings()
+settings.set(settings.USE_WORLD_COORDS, True)
+
+# --------------------------
+# Helper functions
+# --------------------------
+def load_model(ifc_model_path):
+    """Load IFC model"""
+    return ifcopenshell.open(ifc_model_path)
+
+def get_main_living_areas(ifc_model):
+    """
+    Return spaces considered main living areas.
+    Filtering by common keywords in space name.
+    """
+    spaces = ifc_model.by_type("IfcSpace")
+    main_spaces = []
+    for s in spaces:
+        if s.Name and any(keyword in s.Name.lower() for keyword in ["living", "bedroom", "hall"]):
+            main_spaces.append(s)
+    return main_spaces
+
+def get_space_height(space):
+    """
+    Approximate height of a space from geometry bounding box.
+    Uses Z coordinates of all vertices.
+    """
+    try:
+        shape = ifcopenshell.geom.create_shape(settings, space)
+        verts = shape.geometry.verts
+        if not verts:
+            return 0.0
+        zs = verts[2::3]
+        return float(max(zs) - min(zs))
+    except Exception:
+        return 0.0
+
+# --------------------------
+# Main check function
+# --------------------------
+def check_living_area_height(model, min_height=2.50):
+    """
+    Check if all main living areas meet the minimum height requirement.
+    
+    Args:
+        model: ifcopenshell.file object (pre-loaded IFC model)
+        min_height: minimum height in meters (default 2.50)
+    
+    Returns:
+        list[dict]: One dict per living/bedroom/hall space, following IFCore schema
+    """
+    spaces = get_main_living_areas(model)
+    results = []
+
+    for space in spaces:
+        height = get_space_height(space)
+        space_name = space.Name or f"Space #{space.id()}"
+        space_id = getattr(space, "GlobalId", str(space.id()))
+        
+        status = "pass" if height >= min_height else "fail"
+        comment = None if height >= min_height else f"Height {height:.2f}m below required {min_height:.2f}m"
+        
+        results.append({
+            "element_id": space_id,
+            "element_type": "IfcSpace",
+            "element_name": space_name,
+            "element_name_long": f"{space_name} (living area)",
+            "check_status": status,
+            "actual_value": f"{height:.2f} m",
+            "required_value": f"{min_height:.2f} m",
+            "comment": comment,
+            "log": None,
+        })
+
+    return results
+
+# --------------------------
+# Local testing (optional)
+# --------------------------
+if __name__ == "__main__":
+    import ifcopenshell
+    ifc_path = "C:/Users/OWNER/Desktop/IAAC/T05/AI_SpeedRun/AI-Speed-Run-Week/ifc_models/arc.ifc"
+    model = ifcopenshell.open(ifc_path)
+    results = check_living_area_height(model, min_height=2.50)
+    
+    print("Living Area Height Check Results:")
+    for r in results:
+        print(f"[{r['check_status'].upper()}] {r['element_name']}: {r['actual_value']}")
+        if r['comment']:
+            print(f"  → {r['comment']}")

teams/Mastodonte/tools/checker_living_rooms.py

@@ -0,0 +1,148 @@
+import json
+import math
+import ifcopenshell
+import ifcopenshell.geom
+
+# Optional: only needed if you truly have it available
+# from ifcopenshell.util.element import get_psets as _get_psets
+
+# --------------------------
+# Geometry settings
+# --------------------------
+settings = ifcopenshell.geom.settings()
+settings.set(settings.USE_WORLD_COORDS, True)
+
+# --------------------------
+# Helper functions
+# --------------------------
+def load_model(ifc_model_path):
+    return ifcopenshell.open(ifc_model_path)
+
+def calculate_space_area(space):
+    """
+    Approximate area from mesh triangles.
+    Note: this is mesh surface area, not guaranteed to be floor area.
+    """
+    if hasattr(space, "NetFloorArea") and space.NetFloorArea:
+        return float(space.NetFloorArea)
+
+    try:
+        shape = ifcopenshell.geom.create_shape(settings, space)
+        verts = shape.geometry.verts
+        faces = shape.geometry.faces
+        area = 0.0
+
+        for i in range(0, len(faces), 3):
+            idx0, idx1, idx2 = faces[i] * 3, faces[i + 1] * 3, faces[i + 2] * 3
+            v0 = verts[idx0:idx0 + 3]
+            v1 = verts[idx1:idx1 + 3]
+            v2 = verts[idx2:idx2 + 3]
+
+            a = math.sqrt((v1[0]-v0[0])**2 + (v1[1]-v0[1])**2 + (v1[2]-v0[2])**2)
+            b = math.sqrt((v2[0]-v1[0])**2 + (v2[1]-v1[1])**2 + (v2[2]-v1[2])**2)
+            c = math.sqrt((v0[0]-v2[0])**2 + (v0[1]-v2[1])**2 + (v0[2]-v2[2])**2)
+
+            s = (a + b + c) / 2.0
+            area += math.sqrt(max(s * (s - a) * (s - b) * (s - c), 0.0))
+
+        return float(area)
+    except Exception:
+        return 0.0
+
+def get_space_name(space):
+    """Get descriptive name if available, fallback to LongName/Name/GlobalId."""
+    if getattr(space, "LongName", None):
+        return str(space.LongName)
+    if getattr(space, "Name", None):
+        return str(space.Name)
+
+    # If you have ifcopenshell.util.element available, you can enable this block:
+    # try:
+    #     psets = _get_psets(space)
+    #     for props in (psets or {}).values():
+    #         for k, v in (props or {}).items():
+    #             if "name" in str(k).lower() and isinstance(v, str) and v.strip():
+    #                 return v.strip()
+    # except Exception:
+    #     pass
+
+    return str(getattr(space, "GlobalId", "Unnamed"))
+
+def can_fit_square(area_m2, width=2.4, depth=2.4):
+    """Approx check: area must allow a width x depth square."""
+    return float(area_m2) >= float(width) * float(depth)
+
+# --------------------------
+# Living room compliance
+# --------------------------
+def check_living_room_compliance(model):
+    """
+    Check living room spaces for minimum area and clearance rules.
+    
+    Rule encoded:
+      - Living room min area 10 m²
+      - If living+kitchen combined: min area 14 m²
+      - Must allow 2.40 x 2.40 m clearance (approx via area check)
+    
+    Args:
+        model: ifcopenshell.file object (pre-loaded IFC model)
+    
+    Returns:
+        list[dict]: One dict per living room space, following IFCore schema
+    """
+    spaces = model.by_type("IfcSpace")
+    results = []
+
+    for space in spaces:
+        raw_name = get_space_name(space)
+        name = raw_name.lower()
+        area = calculate_space_area(space)
+        space_id = getattr(space, "GlobalId", str(space.id()))
+        
+        if area <= 0:
+            continue
+
+        if "living" in name:
+            has_kitchen = "kitchen" in name
+            min_area = 14.0 if has_kitchen else 10.0
+
+            clearance_ok = can_fit_square(area, 2.4, 2.4)
+            passed = (area >= min_area) and clearance_ok
+
+            reasons = []
+            if area < min_area:
+                reasons.append(f"Area {area:.2f} m² < required {min_area:.2f} m²")
+            if not clearance_ok:
+                reasons.append("Does not allow 2.40 m x 2.40 m square (approx)")
+
+            results.append({
+                "element_id": space_id,
+                "element_type": "IfcSpace",
+                "element_name": raw_name,
+                "element_name_long": f"{raw_name} (living room zone)",
+                "check_status": "pass" if passed else "fail",
+                "actual_value": f"{area:.2f} m²",
+                "required_value": f"{min_area:.2f} m²",
+                "comment": "; ".join(reasons) if reasons else None,
+                "log": None,
+            })
+
+    return results
+
+# --------------------------
+# Local testing (optional)
+# --------------------------
+if __name__ == "__main__":
+    import ifcopenshell
+    ifc_path = "C:/Users/OWNER/Desktop/IAAC/T05/AI_SpeedRun/AI-Speed-Run-Week/ifc_models/arc.ifc"
+    model = ifcopenshell.open(ifc_path)
+    results = check_living_room_compliance(model)
+    
+    print("Living Room Compliance Check Results:")
+    if not results:
+        print("No living room spaces matched (keyword 'living') or no computable areas.")
+    else:
+        for r in results:
+            print(f"[{r['check_status'].upper()}] {r['element_name']}: {r['actual_value']}")
+            if r['comment']:
+                print(f"  -> {r['comment']}")

teams/Mastodonte/tools/checker_occupancy.py

@@ -0,0 +1,173 @@
+import math
+import json
+import ifcopenshell
+import ifcopenshell.geom
+
+# --------------------------
+# Geometry settings
+# --------------------------
+settings = ifcopenshell.geom.settings()
+settings.set(settings.USE_WORLD_COORDS, True)
+
+# --------------------------
+# Helper functions
+# --------------------------
+def calculate_space_area(space):
+    """Approximate area by summing triangle areas from the space mesh."""
+    try:
+        shape = ifcopenshell.geom.create_shape(settings, space)
+        verts = shape.geometry.verts
+        faces = shape.geometry.faces
+        area = 0.0
+
+        for i in range(0, len(faces), 3):
+            i0, i1, i2 = faces[i] * 3, faces[i + 1] * 3, faces[i + 2] * 3
+            v0 = verts[i0:i0 + 3]
+            v1 = verts[i1:i1 + 3]
+            v2 = verts[i2:i2 + 3]
+
+            a = math.dist(v0, v1)
+            b = math.dist(v1, v2)
+            c = math.dist(v2, v0)
+
+            s = (a + b + c) / 2.0
+            area += math.sqrt(max(s * (s - a) * (s - b) * (s - c), 0.0))
+
+        return float(area)
+    except Exception:
+        return 0.0
+
+
+def get_space_label(space):
+    """Get descriptive name if available, fallback to GlobalId."""
+    return str(
+        getattr(space, "LongName", None)
+        or getattr(space, "Name", None)
+        or f"Space #{space.id()}"
+    )
+
+
+def area_to_occupancy(area_m2):
+    """
+    Regulation mapping:
+        <5 m²   -> invalid bedroom
+        ≥5 m²   -> 1 person
+        ≥8 m²   -> 2 people
+        ≥12 m²  -> 3 people
+    """
+    if area_m2 < 5.0:
+        return 0
+    elif area_m2 < 8.0:
+        return 1
+    elif area_m2 < 12.0:
+        return 2
+    else:
+        return 3
+
+
+def get_spaces_by_keywords(model, keywords):
+    """Filter spaces matching any keyword in their name."""
+    spaces = model.by_type("IfcSpace")
+    matched = []
+    for s in spaces:
+        label_lower = get_space_label(s).lower()
+        if any(k in label_lower for k in keywords):
+            matched.append(s)
+    return matched
+
+
+# --------------------------
+# Main check function
+# --------------------------
+def check_bedroom_occupancy(model):
+    """
+    Check if all bedrooms meet minimum area requirement and calculate occupancy.
+    
+    Regulation:
+      - Bedroom min area 5 m² for 1 occupant
+      - 8 m² for 2 occupants
+      - 12 m² for 3 occupants
+      - Studio (no bedrooms): limited to max 2 occupants
+    
+    Args:
+        model: ifcopenshell.file object (pre-loaded IFC model)
+    
+    Returns:
+        list[dict]: One dict per bedroom/living space, following IFCore schema
+    """
+    results = []
+    
+    bedroom_keywords = ["bedroom", "habitacion", "habitación", "dormitorio"]
+    living_keywords = ["living", "salon", "salón", "studio", "estudio", "common"]
+    
+    bedrooms = get_spaces_by_keywords(model, bedroom_keywords)
+    living_spaces = get_spaces_by_keywords(model, living_keywords)
+    
+    # --------------------------
+    # Studio case (no bedrooms)
+    # --------------------------
+    if len(bedrooms) == 0:
+        if living_spaces:
+            space = living_spaces[0]
+            label = get_space_label(space)
+            area = calculate_space_area(space)
+            space_id = getattr(space, "GlobalId", str(space.id()))
+            occupancy = min(area_to_occupancy(area), 2)
+            passed = occupancy > 0
+            
+            results.append({
+                "element_id": space_id,
+                "element_type": "IfcSpace",
+                "element_name": label,
+                "element_name_long": f"{label} (studio dwelling)",
+                "check_status": "pass" if passed else "fail",
+                "actual_value": f"{area:.2f} m² → {occupancy} occupant(s) max",
+                "required_value": "Studio max 2 occupants",
+                "comment": "Studio dwelling limited to maximum 2 occupants" if passed else f"Area {area:.2f} m² too small for studio",
+                "log": None,
+            })
+        return results
+    
+    # --------------------------
+    # Bedroom-based case
+    # --------------------------
+    for space in bedrooms:
+        label = get_space_label(space)
+        area = calculate_space_area(space)
+        space_id = getattr(space, "GlobalId", str(space.id()))
+        occupancy = area_to_occupancy(area)
+        
+        passed = occupancy > 0
+        comment = None
+        if not passed:
+            comment = f"Area {area:.2f} m² below minimum 5 m² for bedroom"
+        
+        results.append({
+            "element_id": space_id,
+            "element_type": "IfcSpace",
+            "element_name": label,
+            "element_name_long": f"{label} (bedroom occupancy)",
+            "check_status": "pass" if passed else "fail",
+            "actual_value": f"{area:.2f} m² → {occupancy} occupant(s)",
+            "required_value": "≥5 m² (min 1 occupant)",
+            "comment": comment,
+            "log": None,
+        })
+    
+    return results
+
+
+# --------------------------
+# Local testing (optional)
+# --------------------------
+if __name__ == "__main__":
+    import ifcopenshell
+    ifc_path = "C:/Users/OWNER/Desktop/IAAC/T05/AI_SpeedRun/AI-Speed-Run-Week/ifc_models/arc.ifc"
+    model = ifcopenshell.open(ifc_path)
+    results = check_bedroom_occupancy(model)
+    
+    print("Bedroom Occupancy Check Results:")
+    for r in results:
+        print(f"[{r['check_status'].upper()}] {r['element_name']}: {r['actual_value']}")
+        if r['comment']:
+            print(f"  → {r['comment']}")

teams/Mastodonte/tools/checker_service_spaces.py

@@ -0,0 +1,109 @@
+import json
+import ifcopenshell
+import ifcopenshell.geom
+
+# --------------------------
+# Geometry settings
+# --------------------------
+settings = ifcopenshell.geom.settings()
+settings.set(settings.USE_WORLD_COORDS, True)
+
+# --------------------------
+# Helper functions
+# --------------------------
+def load_model(ifc_model_path):
+    return ifcopenshell.open(ifc_model_path)
+
+def get_space_name(space):
+    """Get descriptive name if available, fallback to LongName/Name/GlobalId."""
+    if getattr(space, "LongName", None):
+        return str(space.LongName)
+    if getattr(space, "Name", None):
+        return str(space.Name)
+    return str(getattr(space, "GlobalId", "Unnamed"))
+
+def get_space_height(space):
+    """
+    Approximate height of a space from geometry bounding box.
+    Uses Z coordinates of all vertices.
+    """
+    try:
+        shape = ifcopenshell.geom.create_shape(settings, space)
+        verts = shape.geometry.verts
+        if not verts:
+            return 0.0
+        zs = verts[2::3]
+        return float(max(zs) - min(zs))
+    except Exception:
+        return 0.0
+
+def is_service_space(space_name_lower):
+    """Bathrooms, kitchens, hallways by keywords."""
+    service_keywords = [
+        "bath", "bathroom", "baño", "bano", "wc", "toilet",
+        "kitchen", "cocina",
+        "hall", "hallway", "corridor", "pasillo"
+    ]
+    return any(k in space_name_lower for k in service_keywords)
+
+# --------------------------
+# Compliance check
+# --------------------------
+def check_service_spaces_min_height(model, min_height=2.20):
+    """
+    Check if bathrooms, kitchens, and hallways meet minimum height requirement.
+    
+    Regulation:
+      - Minimum height in bathrooms, kitchens, and hallways is 2.20 m
+    
+    Args:
+        model: ifcopenshell.file object (pre-loaded IFC model)
+        min_height: minimum height in meters (default 2.20)
+    
+    Returns:
+        list[dict]: One dict per service space, following IFCore schema
+    """
+    spaces = model.by_type("IfcSpace")
+    results = []
+
+    for space in spaces:
+        label = get_space_name(space)
+        label_l = label.lower()
+
+        if not is_service_space(label_l):
+            continue
+
+        height = get_space_height(space)
+        space_id = getattr(space, "GlobalId", str(space.id()))
+        
+        status = "pass" if height >= min_height else "fail"
+        comment = None if height >= min_height else f"Height {height:.2f}m below required {min_height:.2f}m"
+        
+        results.append({
+            "element_id": space_id,
+            "element_type": "IfcSpace",
+            "element_name": label,
+            "element_name_long": f"{label} (service space)",
+            "check_status": status,
+            "actual_value": f"{height:.2f} m",
+            "required_value": f"{min_height:.2f} m",
+            "comment": comment,
+            "log": None,
+        })
+
+    return results
+
+# --------------------------
+# Local testing (optional)
+# --------------------------
+if __name__ == "__main__":
+    import ifcopenshell
+    ifc_path = "C:/Users/OWNER/Desktop/IAAC/T05/AI_SpeedRun/AI-Speed-Run-Week/ifc_models/arc.ifc"
+    model = ifcopenshell.open(ifc_path)
+    results = check_service_spaces_min_height(model, min_height=2.20)
+    
+    print("Service Spaces Min Height Check Results:")
+    for r in results:
+        print(f"[{r['check_status'].upper()}] {r['element_name']}: {r['actual_value']}")
+        if r['comment']:
+            print(f"  → {r['comment']}")

teams/demo/tools/checker_demo.py

@@ -0,0 +1,32 @@
+"""Demo check: counts doors and verifies minimum count."""
+
+
+def check_door_count(model, min_doors=2):
+    doors = model.by_type("IfcDoor")
+    results = []
+    for door in doors:
+        name = door.Name or f"Door #{door.id()}"
+        results.append({
+            "element_id": door.GlobalId,
+            "element_type": "IfcDoor",
+            "element_name": name,
+            "element_name_long": None,
+            "check_status": "pass",
+            "actual_value": "Present",
+            "required_value": f">= {min_doors} doors total",
+            "comment": None,
+            "log": None,
+        })
+    if len(doors) < min_doors:
+        results.append({
+            "element_id": None,
+            "element_type": "Summary",
+            "element_name": "Door Count Check",
+            "element_name_long": None,
+            "check_status": "fail",
+            "actual_value": f"{len(doors)} doors",
+            "required_value": f">= {min_doors} doors",
+            "comment": f"Found {len(doors)} doors, need >= {min_doors}",
+            "log": None,
+        })
+    return results

teams/lux-ai/AGENT_HANDOFF_REPORT.md

@@ -0,0 +1,526 @@
+# Lux.Ai — IFC Metadata Extraction: Agent Handoff Report
+
+**Date:** 2026-02-18
+**Project:** Lux.Ai — AI for Architecture & Urbanism
+**Repo root:** `c:\Users\LEGION\Documents\GitHub\Lux.Ai\`
+**Python:** 3.12.10 via `.venv\` virtual environment
+
+---
+
+## What Was Built (Summary)
+
+Three things were created in this session:
+
+| # | What | File | Status |
+|---|------|------|--------|
+| 1 | IFC model scanner — extracts 4 building metrics from all IFC files | `scan_ifc_models.py` | Done, working |
+| 2 | IFC metadata key discovery — inventories every property/quantity name across all models | `discover_ifc_keys.py` | Done, working |
+| 3 | Canonical alias map — standardised lookup table for future extractors | `key_aliases.json` | Generated |
+
+---
+
+## Context & Problem Being Solved
+
+The repo contains **36 IFC (Industry Foundation Classes) BIM model files** across 20 sample building projects in `Sample projects/projects/`. IFC is the open standard for Building Information Modeling used by Archicad, Revit, Vectorworks, and other tools.
+
+**The challenge:** Different IFC exporters use different internal names for the same concept. For example, "floor area" might be stored as:
+- `Qto_SpaceBaseQuantities / NetFloorArea` (IFC4 / buildingSMART standard)
+- `BaseQuantities / NetFloorArea` (IFC2x3 legacy)
+- `GSA Space Areas / GSA BIM Area` (Revit US government exports)
+- `ArchiCADQuantities / Netto-Grundfläche` (Archicad German)
+
+The goal was to scan all files, discover every key name actually in use, and produce a normalised mapping so any future function can reliably extract data regardless of which software created the file.
+
+---
+
+## Repository Structure
+
+```
+Lux.Ai/
+├── scan_ifc_models.py          ← NEW: extracts 4 metrics from all IFC files
+├── discover_ifc_keys.py        ← NEW: inventories all property/quantity keys
+├── key_aliases.json            ← NEW: canonical key → alias mapping (config)
+├── ifc_key_inventory.json      ← NEW: raw inventory of all keys found
+├── ifc_scan_results.csv        ← NEW: output data table (36 rows)
+├── ifc_scan.log                ← NEW: per-file processing log
+├── .venv/                      ← Python 3.12 virtual environment
+│   └── Scripts/python.exe
+└── Sample projects/
+    └── projects/               ← 36 IFC files across 20 projects
+        ├── 4351/arc.ifc
+        ├── ac20/arc.ifc
+        ├── city_house_munich/arc.ifc
+        ├── dental_clinic/arc.ifc + mep.ifc + str.ifc
+        ├── digital_hub/arc.ifc + heating.ifc + plumbing.ifc + ventilation.ifc
+        ├── duplex/arc.ifc + mep.ifc
+        ├── ettenheim_gis/city.ifc
+        ├── fantasy_hotel_1/arc.ifc
+        ├── fantasy_hotel_2/arc.ifc
+        ├── fantasy_office_building_1/arc.ifc
+        ├── fantasy_office_building_2/arc.ifc
+        ├── fantasy_office_building_3/arc.ifc
+        ├── fantasy_residential_building_1/arc.ifc
+        ├── fzk_house/arc.ifc
+        ├── hitos/arc.ifc
+        ├── molio/arc.ifc
+        ├── samuel_macalister_sample_house/arc.ifc + mep.ifc
+        ├── schependomlaan/arc.ifc
+        ├── sixty5/arc.ifc + str.ifc + facade.ifc + electrical.ifc + kitchen.ifc + plumbing.ifc + ventilation.ifc
+        ├── smiley_west/arc.ifc
+        └── wbdg_office/arc.ifc + str.ifc + mep.ifc
+```
+
+Each project also contains:
+- `model_card.md` — YAML frontmatter with project metadata (source, license, discipline list)
+- `snapshot.png` — thumbnail
+- `license.txt`
+
+---
+
+## Dependencies Installed
+
+```bash
+.venv/Scripts/python.exe -m pip install ifcopenshell tabulate
+```
+
+Packages installed:
+- `ifcopenshell==0.8.4.post1` — IFC file parser (binary wheel, no compiler needed)
+- `tabulate==0.9.0` — console table formatting
+- `numpy`, `shapely`, `lark`, `isodate` — pulled in as ifcopenshell dependencies
+
+---
+
+## File 1: `scan_ifc_models.py`
+
+### Purpose
+Scans all IFC files and extracts 4 building metrics per file into a CSV.
+
+### Run
+```bash
+.venv/Scripts/python.exe scan_ifc_models.py
+# Optional args:
+# --root "path/to/ifc/directory"   (default: Sample projects/projects/)
+# --output results.csv             (default: ifc_scan_results.csv)
+```
+
+### What it extracts
+
+| Canonical Key | IFC Source | Fallback Strategy |
+|---|---|---|
+| `window_area_m2` | `IfcWindow → Qto_WindowBaseQuantities / Area` | `BaseQuantities/Area` → `OverallHeight × OverallWidth` |
+| `floor_area_m2` | `IfcSpace → Qto_SpaceBaseQuantities / NetFloorArea` | `GrossFloorArea` → `BaseQuantities/NetFloorArea` → `IfcSlab[FLOOR]/NetArea` |
+| `roof_area_m2` | `IfcRoof → Qto_RoofBaseQuantities / NetArea` | `GrossArea` → `IfcSlab[ROOF]/NetArea` → `GrossArea` |
+| `true_north_angle_deg` | `IfcGeometricRepresentationContext.TrueNorth` | DirectionRatios (X,Y) → `atan2(x,y)` → compass bearing (clockwise from north) |
+| `latitude` | `IfcSite.RefLatitude` | IfcCompoundPlaneAngleMeasure [deg, min, sec, microsec] → decimal degrees |
+| `longitude` | `IfcSite.RefLongitude` | Same decoding |
+
+### Key functions
+
+```python
+find_ifc_files(root_dir: Path) -> list[Path]
+    # Recursively globs *.ifc under root_dir
+
+process_ifc_file(ifc_path: Path) -> dict
+    # Opens file, calls 4 extractors, returns result dict with all 8 columns
+
+extract_window_area(model) -> float | None
+extract_floor_area(model)  -> float | None
+extract_roof_area(model)   -> float | None
+extract_orientation(model) -> dict  # {true_north_angle_deg, latitude, longitude}
+
+get_quantity(element, qset_name, qty_name) -> float | None
+    # Walks IsDefinedBy → IfcRelDefinesByProperties → IfcElementQuantity
+    # Handles both IfcQuantityArea (.AreaValue) and IfcQuantityLength (.LengthValue)
+
+get_quantity_multi(element, qset_names: list[str], qty_name) -> float | None
+    # Tries each qset name in order — handles IFC2x3 vs IFC4 naming differences
+
+get_area_scale(model) -> float
+get_length_scale(model) -> float
+    # Uses ifcopenshell.util.unit.calculate_unit_scale to handle feet vs metres
+
+decode_compound_angle(compound) -> float | None
+    # Converts IfcCompoundPlaneAngleMeasure [deg,min,sec,microsec] to decimal degrees
+```
+
+### Output — `ifc_scan_results.csv`
+
+36 rows, 9 columns:
+```
+project_name, ifc_file, window_area_m2, floor_area_m2, roof_area_m2,
+true_north_angle_deg, latitude, longitude, error
+```
+
+### Actual scan results (key data)
+
+| Project | Window m² | Floor m² | Roof m² | TrueNorth° | Lat | Lon |
+|---|---|---|---|---|---|---|
+| 4351 | 10.87 | N/A | N/A | N/A | N/A | N/A |
+| ac20 | 309.50 | 1939.38 | 688.77 | 0.00 | 49.15 | 8.72 |
+| city_house_munich | 29.51 | N/A | N/A | 32.56 | 48.19 | 11.47 |
+| dental_clinic | 100.63 | N/A | N/A | N/A | 42.36 | -71.06 |
+| digital_hub | 375.00 | 2842.12 | N/A | 360.00 | 48.14 | 11.58 |
+| duplex | 65.94 | N/A | N/A | N/A | 41.87 | -87.64 |
+| ettenheim_gis | 725.97 | N/A | N/A | N/A | N/A | N/A |
+| fantasy_hotel_1 | 58.78 | N/A | N/A | 360.00 | 42.36 | -71.06 |
+| fantasy_hotel_2 | 400.31 | N/A | N/A | 360.00 | 42.36 | -71.06 |
+| fantasy_office_building_1 | 156.82 | 1257.07 | 339.92 | 360.00 | 48.14 | 11.58 |
+| fantasy_office_building_2 | 142.91 | 716.06 | 419.57 | 360.00 | 48.14 | 11.58 |
+| fantasy_office_building_3 | 984.96 | N/A | N/A | 360.00 | 48.15 | 11.57 |
+| fantasy_residential_building_1 | 19.56 | N/A | N/A | 360.00 | 48.14 | 11.58 |
+| fzk_house | 23.17 | 173.34 | 165.12 | 310.00 | 49.10 | 8.44 |
+| hitos | 1531.32 | N/A | N/A | 360.00 | 69.67 | 18.83 |
+| molio | N/A | 140.78 | N/A | 0.00 | 55.67 | 12.62 |
+| samuel_macalister_sample_house | 61.64 | N/A | N/A | 323.00 | 42.21 | -71.03 |
+| schependomlaan | N/A | N/A | N/A | N/A | N/A | N/A |
+| sixty5/arc | 4901.15 | 0.00 | N/A | 0.00 | 51.45 | 5.48 |
+| smiley_west | 95.92 | 1821.17 | 614.41 | 147.50 | 49.03 | 8.39 |
+| wbdg_office | 124.50 | N/A | N/A | N/A | 42.36 | -71.06 |
+
+> **Note:** `360.00°` true north = same as `0.00°` (floating-point rounding artefact near exact north alignment — cosmetically different, data is correct). MEP/structural discipline files return N/A for most metrics — expected.
+
+### Summary statistics
+- Files scanned: 36, Errors: 0
+- Window data: 19/36 files
+- Floor data: 9/36 files
+- Roof data: 5/36 files
+- Orientation: 25/36 files
+
+---
+
+## File 2: `discover_ifc_keys.py`
+
+### Purpose
+Full metadata key discovery — enumerates every property set and quantity set used across all 36 IFC files, grouped by IFC element type. Produces the raw inventory and the canonical alias map.
+
+### Run
+```bash
+.venv/Scripts/python.exe discover_ifc_keys.py
+```
+
+### Element types targeted
+`IfcWindow`, `IfcDoor`, `IfcSpace`, `IfcSlab`, `IfcRoof`, `IfcWall`, `IfcWallStandardCase`, `IfcCovering`, `IfcSite`, `IfcBuilding`, `IfcBuildingStorey`
+
+### Key functions
+
+```python
+collect_qsets(model, element_type: str) -> dict
+    # Returns {qset_name: {qty_name: count}} for all elements of that type in the model
+
+collect_psets(model, element_type: str) -> dict
+    # Returns {pset_name: {prop_name: count}} for all elements of that type in the model
+
+merge_into(global_inv, element_type, section, file_data, project_name)
+    # Accumulates per-file results: increments file_count, appends project_name
+
+inventory_to_plain(global_inv) -> dict
+    # Converts defaultdict structure to plain dict for JSON serialisation
+
+build_aliases(inventory) -> dict
+    # Creates key_aliases.json: pre-seeds known patterns + auto-discovers
+    # any area-related quantity keys not already covered
+```
+
+### Discovery results summary
+
+| Element Type | Qty Sets | Qty Keys | Prop Sets | Prop Keys |
+|---|---|---|---|---|
+| IfcWindow | 59 | 8,834 | 102 | 20,413 |
+| IfcDoor | 21 | 2,887 | 64 | 10,029 |
+| IfcSpace | 8 | 201 | 38 | 1,315 |
+| IfcSlab | 9 | 144 | 35 | 302 |
+| IfcRoof | 1 | 3 | 25 | 117 |
+| IfcWall | 22 | 234 | 41 | 392 |
+| IfcWallStandardCase | 20 | 146 | 18 | 238 |
+| IfcCovering | 3 | 114 | 33 | 325 |
+| IfcSite | 1 | 2 | 10 | 58 |
+| IfcBuilding | 1 | 1 | 13 | 77 |
+| IfcBuildingStorey | 1 | 4 | 28 | 66 |
+
+> **Why IfcWindow has 59 qsets and 8,834 keys:** Archicad creates one unique quantity set per window *type* family (named `AC_Equantity_IFC_Fenster_-_ein_Panel`, `AC_Equantity_R1_21`, etc.), each with its own set of dimension keys. The actual area extraction only needs the 2 standard sets below.
+
+---
+
+## File 3: `key_aliases.json`
+
+### Purpose
+A **human-editable JSON config** that maps each canonical building metric to an ordered list of IFC lookup strategies. Any extractor function should iterate this list and return the first strategy that yields a value.
+
+### Structure
+```json
+{
+  "canonical_key": [
+    {
+      "entity":    "IfcWindow",               // IFC element type to query
+      "source":    "qset",                    // "qset" (quantity set) or "attr" (direct attribute)
+      "set_name":  "Qto_WindowBaseQuantities", // quantity set name
+      "key":       "Area"                     // quantity name within the set
+    },
+    ...
+    {
+      "entity":    "IfcWindow",
+      "source":    "attr",                    // direct IFC attribute (no set lookup)
+      "keys":      ["OverallHeight", "OverallWidth"],
+      "op":        "multiply"                 // operation to apply
+    }
+  ]
+}
+```
+
+### Canonical keys defined
+
+#### `window_area`
+| Priority | Entity | Source | Set Name | Key | Notes |
+|---|---|---|---|---|---|
+| 1 | IfcWindow | qset | `Qto_WindowBaseQuantities` | `Area` | IFC4 standard |
+| 2 | IfcWindow | qset | `BaseQuantities` | `Area` | IFC2x3 Archicad/Revit |
+| 3 | IfcWindow | qset | `BaseQuantities` | `GrossArea` | IFC2x3 fallback |
+| 4 | IfcWindow | attr | — | `OverallHeight × OverallWidth` | Last resort, multiply length attrs |
+
+#### `floor_area`
+| Priority | Entity | Source | Set Name | Key | Filter |
+|---|---|---|---|---|---|
+| 1 | IfcSpace | qset | `Qto_SpaceBaseQuantities` | `NetFloorArea` | — |
+| 2 | IfcSpace | qset | `Qto_SpaceBaseQuantities` | `GrossFloorArea` | — |
+| 3 | IfcSpace | qset | `BaseQuantities` | `NetFloorArea` | IFC2x3 |
+| 4 | IfcSpace | qset | `BaseQuantities` | `GrossFloorArea` | IFC2x3 |
+| 5 | IfcSpace | qset | `GSA Space Areas` | `GSA BIM Area` | US Revit exports |
+| 6 | IfcSlab | qset | `Qto_SlabBaseQuantities` | `NetArea` | PredefinedType=FLOOR |
+| 7 | IfcSlab | qset | `BaseQuantities` | `NetArea` | PredefinedType=FLOOR |
+| 8 | IfcSlab | qset | `BaseQuantities` | `GrossArea` | PredefinedType=FLOOR |
+
+#### `roof_area`
+| Priority | Entity | Source | Set Name | Key | Filter |
+|---|---|---|---|---|---|
+| 1 | IfcRoof | qset | `Qto_RoofBaseQuantities` | `NetArea` | — |
+| 2 | IfcRoof | qset | `Qto_RoofBaseQuantities` | `GrossArea` | — |
+| 3 | IfcRoof | qset | `BaseQuantities` | `NetArea` | IFC2x3 |
+| 4 | IfcSlab | qset | `Qto_SlabBaseQuantities` | `NetArea` | PredefinedType=ROOF |
+| 5 | IfcSlab | qset | `Qto_SlabBaseQuantities` | `GrossArea` | PredefinedType=ROOF |
+| 6 | IfcSlab | qset | `BaseQuantities` | `NetArea` | PredefinedType=ROOF |
+| 7 | IfcSlab | qset | `BaseQuantities` | `GrossArea` | PredefinedType=ROOF |
+
+#### `true_north_angle`
+- Entity: `IfcGeometricRepresentationContext`
+- Source: `attr` → `TrueNorth.DirectionRatios (X, Y)`
+- Conversion: `compass_bearing = (-atan2(X, Y) in degrees) % 360`
+- Meaning: degrees clockwise from north (0° = north aligned with +Y axis)
+
+#### `latitude` / `longitude`
+- Entity: `IfcSite`
+- Source: `attr` → `RefLatitude` / `RefLongitude`
+- Format: `IfcCompoundPlaneAngleMeasure` = tuple of `[degrees, minutes, seconds, microseconds]`
+- Conversion: `decimal = deg + min/60 + sec/3600 + microsec/3_600_000_000`
+
+#### `_auto_discovered_area_keys`
+Any quantity keys containing the word "area" found in the inventory that aren't already in the 6 canonical keys above are appended here automatically by `build_aliases()`. Review these manually to see if any should be promoted to a canonical key.
+
+---
+
+## File 4: `ifc_key_inventory.json`
+
+Full raw inventory of every property/quantity key found across all 36 IFC files. Structure:
+
+```json
+{
+  "IfcWindow": {
+    "quantity_sets": {
+      "Qto_WindowBaseQuantities": {
+        "Area":   { "file_count": 12, "projects": ["ac20", "digital_hub", ...] },
+        "Height": { "file_count": 12, "projects": [...] },
+        "Width":  { "file_count": 12, "projects": [...] }
+      },
+      "BaseQuantities": {
+        "Area":      { "file_count": 7, "projects": [...] },
+        "GrossArea": { "file_count": 4, "projects": ["duplex", ...] }
+      }
+    },
+    "property_sets": {
+      "Pset_WindowCommon": {
+        "IsExternal":           { "file_count": 18, "projects": [...] },
+        "ThermalTransmittance": { "file_count": 8,  "projects": [...] }
+      }
+    }
+  },
+  "IfcSpace": { ... },
+  ...
+}
+```
+
+Use this file as a reference when adding new canonical keys to `key_aliases.json`.
+
+---
+
+## IFC Exporter Ecosystem Found in the Dataset
+
+| Exporter | Quantity Set Style | Property Set Style | Files |
+|---|---|---|---|
+| **Archicad (German IFC4)** | `BaseQuantities` + per-type `AC_Equantity_*` | `AC_Pset_*`, `ArchiCADProperties` | ac20, fzk_house |
+| **Archicad (Dutch IFC2x3)** | `ArchiCADQuantities`, `BaseQuantities` | Same | sixty5 |
+| **Revit (IFC2x3)** | `BaseQuantities`, `GSA Space Areas` | `PSet_Revit_*` | duplex, dental_clinic, wbdg_office |
+| **IFC4 modern tools** | `Qto_*BaseQuantities` | `Pset_*Common` | digital_hub, schependomlaan |
+| **IFC4X3 (latest)** | `Qto_*BaseQuantities` | `Pset_*Common` | city_house_munich |
+| **Norwegian tool (hitos)** | Material-named sets (`Bindingsverk`, `Isolasjon`) | — | hitos |
+| **Synchro 4D** | — | `SynchroResourceProperty` | some |
+
+---
+
+## IFC Schema Versions in Dataset
+
+| Schema | Files | Example Projects |
+|---|---|---|
+| IFC2X3 | ~20 | 4351, duplex, schependomlaan, sixty5, hitos, molio, wbdg_office |
+| IFC4 | ~14 | ac20, digital_hub, fzk_house, smiley_west, fantasy_* |
+| IFC4X3 | 1 | city_house_munich |
+
+---
+
+## Key IFC Concepts for the Next Agent
+
+### How properties are stored in IFC
+
+```
+IfcWindow
+  └── IsDefinedBy (list of IfcRelDefinesByProperties)
+        └── RelatingPropertyDefinition
+              ├── IfcPropertySet (name="Pset_WindowCommon")
+              │     └── HasProperties → [IfcPropertySingleValue, ...]
+              │           └── .Name = "IsExternal", .NominalValue = True
+              └── IfcElementQuantity (name="Qto_WindowBaseQuantities")
+                    └── Quantities → [IfcQuantityArea, IfcQuantityLength, ...]
+                          └── .Name = "Area", .AreaValue = 2.5
+```
+
+### How orientation is stored
+
+```
+IfcGeometricRepresentationContext
+  └── TrueNorth → IfcDirection
+        └── DirectionRatios = (X, Y)    # 2D vector pointing toward geographic north
+              # (0, 1) = north is +Y (no rotation)
+              # (1, 0) = north is +X (building rotated 90° CCW)
+              # compass_bearing = (-atan2(X,Y) in degrees) % 360
+```
+
+### How location is stored
+
+```
+IfcSite
+  ├── RefLatitude  → IfcCompoundPlaneAngleMeasure = (51, 27, 0, 0)  # 51°27'N
+  └── RefLongitude → IfcCompoundPlaneAngleMeasure = (5,  29, 0, 0)  # 5°29'E
+```
+
+### Unit handling
+
+Always check the model's units before using extracted values:
+```python
+import ifcopenshell.util.unit as ifc_unit_util
+area_scale   = ifc_unit_util.calculate_unit_scale(model, "AREAMEASURE")
+length_scale = ifc_unit_util.calculate_unit_scale(model, "LENGTHUNIT")
+# US Revit models may use square feet → area_scale ≈ 0.0929
+```
+
+---
+
+## How to Use `key_aliases.json` in a New Extractor
+
+```python
+import json
+import ifcopenshell
+import ifcopenshell.util.unit as ifc_unit_util
+import math
+
+# Load the alias map once
+with open("key_aliases.json") as f:
+    ALIASES = json.load(f)
+
+def extract_metric(model, canonical_key: str) -> float | None:
+    """
+    Generic extractor that uses key_aliases.json to find a metric
+    regardless of which IFC exporter created the file.
+    """
+    aliases = ALIASES.get(canonical_key, [])
+    area_scale   = ifc_unit_util.calculate_unit_scale(model, "AREAMEASURE")
+    length_scale = ifc_unit_util.calculate_unit_scale(model, "LENGTHUNIT")
+    total = 0.0
+    found = False
+
+    for alias in aliases:
+        entity   = alias["entity"]
+        source   = alias["source"]
+        pred_req = alias.get("predefined_type")
+
+        for elem in model.by_type(entity):
+            # Filter by PredefinedType if required
+            if pred_req and getattr(elem, "PredefinedType", None) != pred_req:
+                continue
+
+            if source == "qset":
+                val = get_quantity(elem, alias["set_name"], alias["key"])
+                if val is not None:
+                    total += val * area_scale
+                    found = True
+
+            elif source == "attr" and alias.get("op") == "multiply":
+                vals = [getattr(elem, k, None) for k in alias["keys"]]
+                if all(v is not None for v in vals):
+                    product = 1.0
+                    for v in vals:
+                        product *= float(v)
+                    total += product * (length_scale ** 2)
+                    found = True
+
+        if found:
+            return round(total, 4)  # Return on first successful strategy
+
+    return None
+```
+
+---
+
+## Known Data Quality Notes
+
+| Project | Issue | Explanation |
+|---|---|---|
+| `sixty5/arc.ifc` | `floor_area = 0.00` (not N/A) | Qto_SpaceBaseQuantities exists but values are 0 — model may lack space boundaries |
+| `sixty5/str.ifc` | `floor_area = 34,199 m²` | Structural slabs classified as FLOOR — over-counting, architectural file preferred |
+| `schependomlaan/arc.ifc` | All N/A | IFC2x3 model has no quantity sets — geometry only |
+| TrueNorth `360.00°` | Same as `0.00°` | Floating-point artefact when vector X is tiny negative; `(-ε) % 360 ≈ 360` |
+| `ettenheim_gis/city.ifc` | Windows = 725.97 m² | GIS city model — likely summing openings across many buildings, not a single building |
+| MEP/structural discipline files | All N/A | Correct — these files don't contain architectural elements |
+
+---
+
+## Running Everything
+
+```bash
+# Activate venv (Windows)
+.venv\Scripts\activate
+
+# Run the 4-metric scanner
+python scan_ifc_models.py
+# → prints table to console
+# → writes ifc_scan_results.csv
+# → writes ifc_scan.log
+
+# Re-run the key discovery (if new IFC files are added)
+python discover_ifc_keys.py
+# → overwrites ifc_key_inventory.json
+# → overwrites key_aliases.json
+# → prints full inventory to console
+```
+
+---
+
+## Suggested Next Steps
+
+1. **Extend `key_aliases.json`** — add more canonical keys (e.g., `wall_area`, `door_count`, `storey_height`, `building_height`) using the inventory as a reference
+2. **Handle `schependomlaan`** — this IFC2x3 model has no quantity sets; area must be computed from geometry using `ifcopenshell.geom`
+3. **Window-to-floor ratio** — divide `window_area` by `floor_area` per project for glazing ratio analysis
+4. **Solar orientation** — combine `true_north_angle` with `latitude` for solar exposure estimation
+5. **Energy analysis** — roof/floor ratio and glazing ratio are key inputs for energy simulation
+6. **Database ingestion** — load `ifc_scan_results.csv` into a dataframe or database for ML feature extraction
+
+---
+
+*Report generated by Claude Sonnet 4.6 (claude-sonnet-4-6) on 2026-02-18*

teams/lux-ai/API function/SOLAR_PRODUCTION_PIPELINE.md

@@ -0,0 +1,356 @@
+# ☀️ Solar Production Pipeline — Full Documentation
+
+## 1. Project Overview
+
+This pipeline estimates the **annual solar energy production** of a building's roof by:
+
+1. **Parsing** an IFC (Industry Foundation Classes) file to extract roof geometry
+2. **Segmenting** the roof into logical surfaces based on orientation
+3. **Querying** the NREL PVWatts v8 API for each segment's solar yield
+4. **Aggregating** results for a total building-level production estimate (kWh/yr)
+
+This per-segment approach is critical for **LEED certification** accuracy — a south-facing surface may produce 2.5× more energy than a north-facing one on the same roof.
+
+---
+
+## 2. Architecture
+
+```
+┌─────────────────────┐
+│   IFC File (.ifc)   │
+└─────────┬───────────┘
+          │
+          ▼
+┌─────────────────────────────────────────────┐
+│         ifc_roof_parser.py                  │
+│                                             │
+│  ┌─────────────────────────────────────┐    │
+│  │ get_roof_elements(model)            │    │
+│  │  → finds IfcRoof + decomposed slabs │    │
+│  └──────────────┬──────────────────────┘    │
+│                 │                            │
+│  ┌──────────────▼──────────────────────┐    │
+│  │ extract_geometry(element, settings) │    │
+│  │  → triangulated mesh (verts/faces)  │    │
+│  └──────────────┬──────────────────────┘    │
+│                 │                            │
+│  ┌──────────────▼──────────────────────┐    │
+│  │ cluster_faces_by_normal(normals,    │    │
+│  │   areas, angle_tolerance=15°)       │    │
+│  │  → groups triangles by orientation  │    │
+│  └──────────────┬──────────────────────┘    │
+│                 │                            │
+│  ┌──────────────▼──────────────────────┐    │
+│  │ compute_segment_properties(normals, │    │
+│  │   areas, cluster_indices)           │    │
+│  │  → tilt, azimuth, total area        │    │
+│  └──────────────┬──────────────────────┘    │
+│                 │                            │
+│  ┌──────────────▼──────────────────────┐    │
+│  │ parse_roof_segments(ifc_path)       │    │
+│  │  → list[{id, area, tilt, azimuth}]  │    │
+│  └──────────────┬──────────────────────┘    │
+└─────────────────┼───────────────────────────┘
+                  │
+                  ▼  list of segment dicts
+┌─────────────────────────────────────────────┐
+│      solar_production_engine.py             │
+│                                             │
+│  ┌─────────────────────────────────────┐    │
+│  │ Location(lat, lon, name)            │    │
+│  │  → dataclass for site coordinates   │    │
+│  └─────────────────────────────────────┘    │
+│                                             │
+│  ┌─────────────────────────────────────┐    │
+│  │ calculate_segment_production(       │    │
+│  │   area, tilt, azimuth, location)    │    │
+│  │  → annual kWh for one segment       │    │
+│  └──────────────┬──────────────────────┘    │
+│                 │                            │
+│  ┌──────────────▼──────────────────────┐    │
+│  │ run_production_analysis(            │    │
+│  │   segments, location)               │    │
+│  │  → total kWh + per-segment results  │    │
+│  └──────────────┬──────────────────────┘    │
+└─────────────────┼───────────────────────────┘
+                  │
+                  ▼
+┌─────────────────────────────────────────────┐
+│      run_solar_analysis.py (orchestrator)   │
+│                                             │
+│  1. Reads IFC path (CLI arg or default)     │
+│  2. Calls parse_roof_segments()             │
+│  3. Calls run_production_analysis()         │
+│  4. Prints full report + LEED estimate      │
+└─────────────────────────────────────────────┘
+```
+
+---
+
+## 3. Files Created
+
+### 3.1 `app/src/ifc_roof_parser.py` — IFC Geometry Parser
+
+**Purpose:** Extract roof segments (area, tilt, azimuth) from any IFC file by analyzing 3D geometry.
+
+| Function | Input | Output | Description |
+|---|---|---|---|
+| `get_roof_elements(model)` | `ifcopenshell.file` | `list[IfcElement]` | Finds all roof-related elements: `IfcRoof` entities, their decomposed `IfcSlab` children (via `IfcRelAggregates`), and standalone `IfcSlab` entities with `.ROOF.` predefined type |
+| `extract_geometry(element, settings)` | IFC element + geom settings | `(vertices, faces)` as numpy arrays | Uses `ifcopenshell.geom.create_shape()` with `USE_WORLD_COORDS=True` to get triangulated mesh data |
+| `compute_face_normals(vertices, faces)` | numpy arrays | `(normals, areas)` — Nx3 unit normals + N areas | Computes cross-product normals and triangle areas for every face in the mesh |
+| `cluster_faces_by_normal(normals, areas, angle_tolerance)` | normals, areas, tolerance (default 15°) | `list[list[int]]` — cluster indices | Groups triangles whose normals are within `angle_tolerance` degrees of each other. Only considers **upward-facing** triangles (normal Z > 0). Uses greedy angular clustering. |
+| `compute_segment_properties(normals, areas, cluster_indices)` | normals, areas, index groups | `dict{area, tilt, azimuth}` | Calculates **area-weighted average normal** per cluster, then derives: **tilt** = `arccos(nz)` in degrees, **azimuth** = `atan2(nx, ny) mod 360` in degrees |
+| `parse_roof_segments(ifc_path)` | file path string | `list[{"id", "area", "tilt", "azimuth"}]` | **Main entry point.** Orchestrates all the above. Returns the standardized segment list that the production engine consumes. |
+
+**Key Design Decisions:**
+- **Geometry-based extraction** — does NOT rely on IFC property sets (`PitchAngle`, etc.) because these are unreliably populated across different BIM authoring tools
+- **Clustering by face normals** — handles curved roofs (barrel vaults → many normals) and planar roofs (hip/gable → few distinct normals) with the same algorithm
+- **Filters downward-facing triangles** — eliminates soffit/interior faces that aren't solar-relevant
+- **Minimum area threshold** — ignores clusters smaller than 1 m² to filter geometric noise
+
+---
+
+### 3.2 `app/src/solar_production_engine.py` — PVWatts API Client
+
+**Purpose:** Calculate annual solar energy production (kWh) for roof segments using the NREL PVWatts v8 API.
+
+| Component | Type | Description |
+|---|---|---|
+| `Location` | `@dataclass` | Stores `latitude: float`, `longitude: float`, `name: str` for a project site |
+| `API_KEY` | `str` constant | NREL API key (`0zwEIS1a...` — production key) |
+| `BASE_URL` | `str` constant | `https://developer.nrel.gov/api/pvwatts/v8.json` |
+| `calculate_segment_production(area, tilt, azimuth, location)` | function | Computes `system_capacity = area × 0.20` (20% panel efficiency = 1 kW per 5 m²), calls PVWatts API with fixed roof mount settings, returns annual AC output in kWh |
+| `run_production_analysis(segments, location)` | function | Iterates a segment list, calls `calculate_segment_production()` for each, returns `(total_kwh, per_segment_results)` |
+| `main()` | function | Standalone mode with hardcoded dummy segments for testing |
+
+**API Parameters Sent:**
+
+| Parameter | Value | Meaning |
+|---|---|---|
+| `system_capacity` | `area × 0.20` | kW capacity based on roof area |
+| `azimuth` | from segment | Compass bearing (180° = south) |
+| `tilt` | from segment | Angle from horizontal in degrees |
+| `array_type` | `1` | Fixed — roof mount |
+| `module_type` | `1` | Premium (monocrystalline) |
+| `losses` | `14` | System losses (wiring, soiling, etc.) |
+
+**Error Handling:**
+- `requests.RequestException` → prints error, returns 0 kWh for that segment
+- `KeyError` on missing `outputs` → prints API error response, returns 0
+- `response.raise_for_status()` → catches HTTP 4xx/5xx errors
+- `time.sleep(1)` between API calls → respects rate limits
+
+---
+
+### 3.3 `app/src/run_solar_analysis.py` — Orchestrator
+
+**Purpose:** Glue script that connects the parser to the production engine.
+
+| Component | Description |
+|---|---|
+| `SITE` | Hardcoded `Location(41.38, 2.17, "Barcelona_Project_Alpha")` — to be parameterized later |
+| `DEFAULT_IFC` | Points to `00_data/ifc_models/Ifc4_SampleHouse_1_Roof.ifc` |
+| CLI support | Accepts optional IFC file path as first argument: `python run_solar_analysis.py path/to/file.ifc` |
+| Report output | Prints per-segment table + total production + LEED score example |
+
+---
+
+### 3.4 `requirements.txt` — Updated Dependencies
+
+Added: `requests>=2.28.0` (required by the production engine for API calls)
+
+Already present: `ifcopenshell`, `numpy`, `trimesh` (used by the parser)
+
+---
+
+## 4. Inputs & Outputs
+
+### Inputs
+
+| Input | Format | Source | Required |
+|---|---|---|---|
+| **IFC file** | `.ifc` (IFC2x3 or IFC4) | BIM authoring tool (Revit, ArchiCAD, etc.) | ✅ |
+| **Site location** | Latitude/Longitude | Hardcoded (future: extracted from `IfcSite`) | ✅ |
+| **NREL API key** | String | `api.nrel.gov` registration | ✅ |
+
+### Outputs
+
+| Output | Format | Description |
+|---|---|---|
+| **Per-segment data** | `list[dict]` | `{"id": str, "area": float, "tilt": float, "azimuth": float}` |
+| **Per-segment yield** | `float` | Annual AC energy production in kWh/yr per roof surface |
+| **Total building production** | `float` | Sum of all segment yields in kWh/yr |
+| **LEED score estimate** | `float` | `(Total Production / Assumed Consumption) × 100` |
+
+### Example Output (SampleHouse IFC)
+
+```
+=== SOLAR PRODUCTION ANALYSIS REPORT ===
+Site: Barcelona_Project_Alpha (41.38°N, 2.17°E)
+IFC: Ifc4_SampleHouse_1_Roof.ifc
+
+--- Roof Segments Detected ---
+  Roof_Seg_01 | Area:  71.48 m² | Tilt: 10.3° | Azimuth: 180° | Capacity: 14.3 kW | Yield: 19,063 kWh/yr
+  Roof_Seg_02 | Area:  45.44 m² | Tilt: 27.9° | Azimuth:   0° | Capacity:  9.1 kW | Yield:  7,566 kWh/yr
+
+--- Summary ---
+  Total Roof Area:           116.92 m²
+  Total System Capacity:      23.4 kW
+  TOTAL ANNUAL PRODUCTION:   26,629 kWh/yr
+
+--- LEED Estimate ---
+  Assumed consumption:       50,000 kWh/yr
+  Renewable coverage:         53.3%
+  Score = Total Production / Consumption × 100
+```
+
+---
+
+## 5. IFC Compatibility
+
+### Does the parser work for different IFC files?
+
+**Yes, with the following conditions:**
+
+| IFC Feature | Supported | How |
+|---|---|---|
+| **IFC4** (`.ifc`) | ✅ | Tested with SampleHouse |
+| **IFC2x3** (`.ifc`) | ✅ | Same `ifcopenshell.geom` API; element types are identical |
+| **IfcRoof (monolithic)** | ✅ | Geometry is clustered by face normals into logical segments |
+| **IfcRoof → IfcSlab (decomposed)** | ✅ | Sub-slabs found via `IfcRelAggregates`; each processed individually |
+| **IfcSlab with `.ROOF.` type** | ✅ | Standalone roof slabs detected by predefined type |
+| **Barrel vault / curved roofs** | ✅ | Many triangle normals → clustering groups them into ~2-4 orientations |
+| **Hip / gable roofs** | ✅ | Few distinct planar groups → clustering identifies each face |
+| **Flat roofs** | ✅ | All normals ≈ (0,0,1) → single segment with tilt ≈ 0° |
+| **IFC-XML** (`.ifcXML`) | ⚠️ Partial | ifcopenshell can open it, but geometry extraction may differ |
+| **IFC-ZIP** (`.ifcZIP`) | ❌ | Must be extracted first |
+| **No roof elements** | ✅ Handled | Returns empty list with warning message |
+| **Roof with skylights/openings** | ⚠️ | Openings not subtracted from area yet — future enhancement |
+
+### Potential Variations Across BIM Software
+
+| BIM Tool | Typical IFC Export | Parser Behavior |
+|---|---|---|
+| **Autodesk Revit** | IfcRoof as single Brep; sub-slabs sometimes decomposed | ✅ Both paths handled |
+| **ArchiCAD** | IfcRoof with clean decomposition into IfcSlab children | ✅ Ideal case |
+| **Tekla / Trimble** | IfcSlab with `.ROOF.` type (no IfcRoof parent) | ✅ Caught by type scan |
+| **Blender (BlenderBIM)** | Varies — may use IfcRoof or IfcSlab | ✅ Both paths handled |
+| **Generic/Unknown** | May have non-standard geometry representations | ⚠️ Falls back to Brep triangulation |
+
+---
+
+## 6. Math Reference
+
+### System Capacity
+
+$$P_{capacity} = A_{segment} \times 0.20 \text{ kW}$$
+
+Where 0.20 = 20% module efficiency (1 kW per 5 m²)
+
+### Tilt from Normal Vector
+
+$$\theta_{tilt} = \arccos(n_z) \times \frac{180}{\pi}$$
+
+### Azimuth from Normal Vector
+
+$$\phi_{azimuth} = \text{atan2}(n_x, n_y) \mod 360°$$
+
+Where 0° = North, 90° = East, 180° = South, 270° = West
+
+### Area-Weighted Average Normal (per cluster)
+
+$$\vec{n}_{avg} = \frac{\sum_{i \in cluster} A_i \cdot \vec{n}_i}{\left\| \sum_{i \in cluster} A_i \cdot \vec{n}_i \right\|}$$
+
+### LEED Renewable Energy Score
+
+$$Score = \frac{\sum_{s=1}^{N} P_{s}}{C_{total}} \times 100$$
+
+Where $P_s$ = annual production of segment $s$, $C_{total}$ = total building consumption
+
+---
+
+## 7. How to Run
+
+### Full Pipeline (IFC → Solar Report)
+
+```bash
+cd app/src
+python run_solar_analysis.py
+```
+
+With a custom IFC file:
+
+```bash
+python run_solar_analysis.py "C:\path\to\your\model.ifc"
+```
+
+### Parser Only (IFC → Segment List)
+
+```python
+from ifc_roof_parser import parse_roof_segments
+
+segments = parse_roof_segments("path/to/model.ifc")
+for seg in segments:
+    print(f"{seg['id']}: {seg['area']:.1f} m², tilt={seg['tilt']:.1f}°, azimuth={seg['azimuth']:.0f}°")
+```
+
+### Production Engine Only (Segments → kWh)
+
+```python
+from solar_production_engine import Location, run_production_analysis
+
+segments = [
+    {"id": "South_Face", "area": 120, "tilt": 30, "azimuth": 180},
+    {"id": "East_Face",  "area": 85,  "tilt": 15, "azimuth": 90},
+]
+site = Location(latitude=41.38, longitude=2.17, name="Barcelona")
+
+total, results = run_production_analysis(segments, site)
+print(f"Total: {total:,.0f} kWh/yr")
+```
+
+---
+
+## 8. Future Enhancements
+
+| Enhancement | Impact | Difficulty |
+|---|---|---|
+| Extract location from `IfcSite` lat/lon automatically | Eliminates hardcoded coordinates | Low |
+| Subtract skylight/opening areas from roof segments | More accurate area calculation | Medium |
+| Add `pvlib` as offline fallback (no API dependency) | Works without internet | Medium |
+| Export results to JSON/CSV for dashboard integration | Data pipeline ready | Low |
+| Add panel layout optimizer (avoid low-yield segments) | Cost optimization | Medium |
+| Support multiple buildings in one IFC file | Campus-scale analysis | Medium |
+| Read building consumption from IFC `Pset_SpaceCommon` | Auto-calculate LEED score | High |
+
+---
+
+## 9. Dependencies
+
+| Package | Version | Used By | Purpose |
+|---|---|---|---|
+| `ifcopenshell` | ≥ 0.7.0 | `ifc_roof_parser.py` | Open and query IFC files |
+| `numpy` | ≥ 1.21.0 | `ifc_roof_parser.py` | Geometry math (normals, areas, clustering) |
+| `requests` | ≥ 2.28.0 | `solar_production_engine.py` | HTTP calls to NREL PVWatts API |
+| `trimesh` | ≥ 3.0.0 | `ifc_roof_parser.py` | (Optional) mesh utilities — currently using raw numpy |
+
+---
+
+## 10. File Tree
+
+```
+iaac-bimwise-starter/
+├── 00_data/
+│   └── ifc_models/
+│       └── Ifc4_SampleHouse_1_Roof.ifc    ← Test IFC file (barrel vault, London)
+├── app/
+│   └── src/
+│       ├── ifc_roof_parser.py              ← NEW: IFC geometry → roof segments
+│       ├── solar_production_engine.py      ← NEW: Segments → PVWatts API → kWh
+│       ├── run_solar_analysis.py           ← NEW: Orchestrator (parser + engine)
+│       ├── ifc_checker.py                  ← Existing: Basic IFC validation
+│       └── ifc_visualizer.py               ← Existing: 3D IFC viewer
+├── docs/
+│   └── SOLAR_PRODUCTION_PIPELINE.md        ← This file
+└── requirements.txt                         ← Updated with requests>=2.28.0
+```

teams/lux-ai/API function/scan_ifc_models.py

@@ -0,0 +1,427 @@
+"""
+scan_ifc_models.py
+Scans all IFC files in the Sample projects directory and extracts:
+  - Window area (m²)
+  - Floor area (m²)
+  - Roof area (m²)
+  - Orientation (true north angle, latitude, longitude)
+
+Output: ifc_scan_results.csv + console table + ifc_scan.log
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import logging
+import math
+from pathlib import Path
+from typing import Optional
+
+import ifcopenshell
+import ifcopenshell.util.element as ifc_util
+import ifcopenshell.util.unit as ifc_unit_util
+from tabulate import tabulate
+
+
+# ── Logging ───────────────────────────────────────────────────────────────────
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)-8s %(message)s",
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler(
+            Path(__file__).parent / "ifc_scan.log", mode="w", encoding="utf-8"
+        ),
+    ],
+)
+log = logging.getLogger(__name__)
+
+# ── Constants ─────────────────────────────────────────────────────────────────
+
+CSV_COLUMNS = [
+    "project_name",
+    "ifc_file",
+    "window_area_m2",
+    "floor_area_m2",
+    "roof_area_m2",
+    "true_north_angle_deg",
+    "latitude",
+    "longitude",
+    "error",
+]
+
+WINDOW_QSETS = ["Qto_WindowBaseQuantities", "BaseQuantities"]
+SPACE_QSETS = ["Qto_SpaceBaseQuantities", "BaseQuantities"]
+SLAB_QSETS = ["Qto_SlabBaseQuantities", "BaseQuantities"]
+ROOF_QSETS = ["Qto_RoofBaseQuantities", "BaseQuantities"]
+
+
+# ── Discovery ─────────────────────────────────────────────────────────────────
+
+def find_ifc_files(root_dir: Path) -> list[Path]:
+    """Recursively find all .ifc files under root_dir, sorted by path."""
+    files = sorted(root_dir.rglob("*.ifc"))
+    return files
+
+
+# ── Unit helpers ──────────────────────────────────────────────────────────────
+
+def get_length_scale(model: ifcopenshell.file) -> float:
+    """Return scale factor to convert model length units to metres."""
+    try:
+        return ifc_unit_util.calculate_unit_scale(model, "LENGTHUNIT")
+    except Exception:
+        return 1.0
+
+
+def get_area_scale(model: ifcopenshell.file) -> float:
+    """Return scale factor to convert model area units to m²."""
+    try:
+        return ifc_unit_util.calculate_unit_scale(model, "AREAMEASURE")
+    except Exception:
+        return 1.0
+
+
+# ── Quantity extraction helpers ───────────────────────────────────────────────
+
+def get_quantity(element, qset_name: str, qty_name: str) -> Optional[float]:
+    """
+    Walk IsDefinedBy relationships to find an IfcElementQuantity named
+    qset_name and return the numeric value of qty_name within it.
+    Returns None if not found.
+    """
+    for rel in getattr(element, "IsDefinedBy", []):
+        if not rel.is_a("IfcRelDefinesByProperties"):
+            continue
+        qset = rel.RelatingPropertyDefinition
+        if not qset.is_a("IfcElementQuantity"):
+            continue
+        if qset.Name != qset_name:
+            continue
+        for qty in qset.Quantities:
+            if qty.Name != qty_name:
+                continue
+            if hasattr(qty, "AreaValue") and qty.AreaValue is not None:
+                return float(qty.AreaValue)
+            if hasattr(qty, "LengthValue") and qty.LengthValue is not None:
+                return float(qty.LengthValue)
+            if hasattr(qty, "VolumeValue") and qty.VolumeValue is not None:
+                return float(qty.VolumeValue)
+    return None
+
+
+def get_quantity_multi(
+    element, qset_names: list[str], qty_name: str
+) -> Optional[float]:
+    """Try multiple quantity set names in order, return first match."""
+    for qset_name in qset_names:
+        val = get_quantity(element, qset_name, qty_name)
+        if val is not None:
+            return val
+    return None
+
+
+# ── Four metric extractors ────────────────────────────────────────────────────
+
+def extract_window_area(model: ifcopenshell.file) -> Optional[float]:
+    """
+    Total window area in m².
+    Strategy 1: Qto_WindowBaseQuantities / Area (IFC4) or BaseQuantities / Area (IFC2x3)
+    Strategy 2: OverallHeight × OverallWidth (direct attributes)
+    """
+    windows = model.by_type("IfcWindow")
+    if not windows:
+        return None
+
+    area_scale = get_area_scale(model)
+    length_scale = get_length_scale(model)
+    total = 0.0
+    found_any = False
+
+    for win in windows:
+        # Strategy 1 — quantity set
+        area = get_quantity_multi(win, WINDOW_QSETS, "Area")
+        if area is not None:
+            total += area * area_scale
+            found_any = True
+            continue
+
+        # Strategy 2 — direct attributes
+        h = getattr(win, "OverallHeight", None)
+        w = getattr(win, "OverallWidth", None)
+        if h and w:
+            total += float(h) * float(w) * (length_scale ** 2)
+            found_any = True
+
+    return round(total, 4) if found_any else None
+
+
+def extract_floor_area(model: ifcopenshell.file) -> Optional[float]:
+    """
+    Total floor area in m².
+    Strategy 1: IfcSpace → Qto_SpaceBaseQuantities / NetFloorArea
+    Strategy 2: IfcSpace → Qto_SpaceBaseQuantities / GrossFloorArea
+    Strategy 3: IfcSlab[FLOOR/BASESLAB] → Qto_SlabBaseQuantities / NetArea
+    """
+    area_scale = get_area_scale(model)
+    total = 0.0
+    found_any = False
+
+    # Strategies 1 & 2 — IfcSpace
+    spaces = model.by_type("IfcSpace")
+    for space in spaces:
+        area = get_quantity_multi(space, SPACE_QSETS, "NetFloorArea")
+        if area is None:
+            area = get_quantity_multi(space, SPACE_QSETS, "GrossFloorArea")
+        if area is not None:
+            total += area * area_scale
+            found_any = True
+
+    if found_any:
+        return round(total, 4)
+
+    # Strategy 3 — IfcSlab FLOOR type
+    for slab in model.by_type("IfcSlab"):
+        pred = getattr(slab, "PredefinedType", None)
+        if pred in ("FLOOR", "BASESLAB"):
+            area = get_quantity_multi(slab, SLAB_QSETS, "NetArea")
+            if area is None:
+                area = get_quantity_multi(slab, SLAB_QSETS, "GrossArea")
+            if area is not None:
+                total += area * area_scale
+                found_any = True
+
+    return round(total, 4) if found_any else None
+
+
+def extract_roof_area(model: ifcopenshell.file) -> Optional[float]:
+    """
+    Total roof area in m².
+    Strategy 1: IfcRoof → Qto_RoofBaseQuantities / NetArea
+    Strategy 2: IfcSlab[ROOF] → Qto_SlabBaseQuantities / NetArea
+    Strategy 3: IfcSlab[ROOF] → Qto_SlabBaseQuantities / GrossArea
+    """
+    area_scale = get_area_scale(model)
+    total = 0.0
+    found_any = False
+
+    # Strategy 1 — IfcRoof entity
+    for roof in model.by_type("IfcRoof"):
+        area = get_quantity_multi(roof, ROOF_QSETS, "NetArea")
+        if area is None:
+            area = get_quantity_multi(roof, ROOF_QSETS, "GrossArea")
+        if area is not None:
+            total += area * area_scale
+            found_any = True
+
+    if found_any:
+        return round(total, 4)
+
+    # Strategies 2 & 3 — IfcSlab ROOF type
+    for slab in model.by_type("IfcSlab"):
+        pred = getattr(slab, "PredefinedType", None)
+        if pred == "ROOF":
+            area = get_quantity_multi(slab, SLAB_QSETS, "NetArea")
+            if area is None:
+                area = get_quantity_multi(slab, SLAB_QSETS, "GrossArea")
+            if area is not None:
+                total += area * area_scale
+                found_any = True
+
+    return round(total, 4) if found_any else None
+
+
+def decode_compound_angle(compound) -> Optional[float]:
+    """Convert IfcCompoundPlaneAngleMeasure [deg, min, sec, microsec] to decimal degrees."""
+    if compound is None:
+        return None
+    parts = list(compound)
+    if not parts:
+        return None
+    deg = int(parts[0])
+    minutes = int(parts[1]) if len(parts) > 1 else 0
+    secs = int(parts[2]) if len(parts) > 2 else 0
+    microsecs = int(parts[3]) if len(parts) > 3 else 0
+    sign = -1 if deg < 0 else 1
+    return sign * (abs(deg) + abs(minutes) / 60 + abs(secs) / 3600 + abs(microsecs) / 3_600_000_000)
+
+
+def extract_orientation(model: ifcopenshell.file) -> dict:
+    """
+    Extract true north angle (compass bearing, degrees CW from north)
+    and geographic coordinates from IfcSite.
+    """
+    result = {
+        "true_north_angle_deg": None,
+        "latitude": None,
+        "longitude": None,
+    }
+
+    # True North from IfcGeometricRepresentationContext
+    for ctx in model.by_type("IfcGeometricRepresentationContext"):
+        if ctx.is_a("IfcGeometricRepresentationSubContext"):
+            continue
+        true_north = getattr(ctx, "TrueNorth", None)
+        if true_north is not None:
+            ratios = true_north.DirectionRatios
+            x = float(ratios[0])
+            y = float(ratios[1])
+            # Angle from +Y axis, measured CCW, converted to clockwise compass bearing
+            angle_ccw = math.degrees(math.atan2(x, y))
+            result["true_north_angle_deg"] = round((-angle_ccw) % 360.0, 2)
+            break
+
+    # Lat/Lon from IfcSite
+    sites = model.by_type("IfcSite")
+    if sites:
+        site = sites[0]
+        result["latitude"] = decode_compound_angle(getattr(site, "RefLatitude", None))
+        result["longitude"] = decode_compound_angle(getattr(site, "RefLongitude", None))
+        if result["latitude"] is not None:
+            result["latitude"] = round(result["latitude"], 6)
+        if result["longitude"] is not None:
+            result["longitude"] = round(result["longitude"], 6)
+
+    return result
+
+
+# ── Per-file orchestration ────────────────────────────────────────────────────
+
+def process_ifc_file(ifc_path: Path) -> dict:
+    """Open one IFC file and extract all metrics."""
+    base = {
+        "project_name": ifc_path.parent.name,
+        "ifc_file": ifc_path.name,
+        "window_area_m2": None,
+        "floor_area_m2": None,
+        "roof_area_m2": None,
+        "true_north_angle_deg": None,
+        "latitude": None,
+        "longitude": None,
+        "error": None,
+    }
+
+    try:
+        model = ifcopenshell.open(str(ifc_path))
+    except Exception as exc:
+        log.error(f"Cannot open {ifc_path}: {exc}")
+        base["error"] = str(exc)
+        return base
+
+    schema = model.schema
+    log.info(f"  Schema: {schema}")
+
+    extractors = {
+        "window_area_m2": extract_window_area,
+        "floor_area_m2": extract_floor_area,
+        "roof_area_m2": extract_roof_area,
+    }
+    for key, fn in extractors.items():
+        try:
+            base[key] = fn(model)
+        except Exception as exc:
+            log.warning(f"  {key} extraction failed: {exc}")
+
+    try:
+        orientation = extract_orientation(model)
+        base.update(orientation)
+    except Exception as exc:
+        log.warning(f"  orientation extraction failed: {exc}")
+
+    return base
+
+
+# ── Output ────────────────────────────────────────────────────────────────────
+
+def write_csv(results: list[dict], output_path: Path) -> None:
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=CSV_COLUMNS, extrasaction="ignore")
+        writer.writeheader()
+        writer.writerows(results)
+    log.info(f"CSV written to: {output_path}")
+
+
+def print_summary_table(results: list[dict]) -> None:
+    display_cols = [
+        "project_name", "ifc_file",
+        "window_area_m2", "floor_area_m2", "roof_area_m2",
+        "true_north_angle_deg", "latitude", "longitude",
+    ]
+    headers = [
+        "Project", "File",
+        "Window m²", "Floor m²", "Roof m²",
+        "TrueNorth°", "Lat", "Lon",
+    ]
+
+    table_data = []
+    for r in results:
+        row = []
+        for col in display_cols:
+            val = r.get(col)
+            if val is None:
+                row.append("N/A")
+            elif isinstance(val, float):
+                row.append(f"{val:.2f}")
+            else:
+                row.append(str(val))
+        if r.get("error"):
+            row[-1] = "ERROR"
+        table_data.append(row)
+
+    print("\n" + tabulate(table_data, headers=headers, tablefmt="github"))
+
+    processed = [r for r in results if not r.get("error")]
+    errors = [r for r in results if r.get("error")]
+    print(f"\nFiles scanned  : {len(results)}")
+    print(f"Errors         : {len(errors)}")
+    print(f"Window data    : {sum(1 for r in processed if r['window_area_m2'] is not None)}/{len(processed)} files")
+    print(f"Floor data     : {sum(1 for r in processed if r['floor_area_m2'] is not None)}/{len(processed)} files")
+    print(f"Roof data      : {sum(1 for r in processed if r['roof_area_m2'] is not None)}/{len(processed)} files")
+    print(f"Orientation    : {sum(1 for r in processed if r['true_north_angle_deg'] is not None)}/{len(processed)} files")
+    if errors:
+        print("\nFiles with errors:")
+        for r in errors:
+            print(f"  {r['project_name']}/{r['ifc_file']}: {r['error']}")
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Scan IFC files for window/floor/roof area and orientation."
+    )
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=Path(__file__).parent / "Sample projects" / "projects",
+        help="Root directory to search for .ifc files",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path(__file__).parent / "ifc_scan_results.csv",
+        help="Output CSV file path",
+    )
+    args = parser.parse_args()
+
+    if not args.root.exists():
+        log.error(f"Root directory not found: {args.root}")
+        return
+
+    ifc_files = find_ifc_files(args.root)
+    log.info(f"Found {len(ifc_files)} IFC file(s) under: {args.root}")
+
+    results = []
+    for i, ifc_path in enumerate(ifc_files, 1):
+        log.info(f"[{i}/{len(ifc_files)}] {ifc_path.parent.name}/{ifc_path.name}")
+        result = process_ifc_file(ifc_path)
+        results.append(result)
+
+    write_csv(results, args.output)
+    print_summary_table(results)
+
+
+if __name__ == "__main__":
+    main()

teams/lux-ai/API function/solar_production_engine.py

@@ -0,0 +1,211 @@
+"""
+Solar Production Engine  [DEPRECATED — use solar_pipeline/ instead]
+
+Superseded by: solar_pipeline/solar_production_engine.py
+
+Original description:
+Calculates annual solar energy production for a building by querying the
+NREL PVWatts v8 API for each roof segment (slab) individually.
+
+Each segment has its own orientation (tilt & azimuth), so the per-segment
+approach yields a far more accurate LEED renewable-energy score than a
+single whole-roof average.
+
+    LEED Score = (Σ P_slabs / Consumption_total) × 100
+
+Future integration:
+    An IFC parser will populate `roof_segments` automatically from
+    IfcSlab / IfcRoof geometry.  For now we use representative dummy data.
+"""
+
+import requests
+import time
+from dataclasses import dataclass
+
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+API_KEY = "0zwEIS1adJrx658O3gjQYfI7AprKLjQf4KP420o9"
+BASE_URL = "https://developer.nrel.gov/api/pvwatts/v8.json"
+PANEL_EFFICIENCY = 0.20  # 1 kW per 5 m²
+
+
+# ---------------------------------------------------------------------------
+# Location dataclass
+# ---------------------------------------------------------------------------
+@dataclass
+class Location:
+    """Stores site coordinates and a human-readable project name."""
+    latitude: float
+    longitude: float
+    name: str
+
+
+# Default site – Barcelona
+SITE_LOCATION = Location(
+    latitude=41.38,
+    longitude=2.17,
+    name="Barcelona_Project_Alpha",
+)
+
+
+# ---------------------------------------------------------------------------
+# Dummy roof-segment data (will be populated by IFC parser in the future)
+# ---------------------------------------------------------------------------
+roof_segments: list[dict] = [
+    {"id": "Slab_01", "area": 120, "tilt": 30, "azimuth": 180},  # South face
+    {"id": "Slab_02", "area": 85,  "tilt": 15, "azimuth": 90},   # East face
+    {"id": "Slab_03", "area": 45,  "tilt": 45, "azimuth": 270},  # West face
+]
+
+
+# ---------------------------------------------------------------------------
+# Core calculation function
+# ---------------------------------------------------------------------------
+def calculate_segment_production(
+    area: float,
+    tilt: float,
+    azimuth: float,
+    location: Location,
+) -> float:
+    """
+    Query the NREL PVWatts v8 API for a single roof segment and return
+    the estimated annual AC energy production in kWh.
+
+    Parameters
+    ----------
+    area : float
+        Segment area in m².
+    tilt : float
+        Panel tilt angle in degrees from horizontal.
+    azimuth : float
+        Panel azimuth in degrees (180 = due south).
+    location : Location
+        Site coordinates and name.
+
+    Returns
+    -------
+    float
+        Annual AC production in kWh, or 0 on error.
+    """
+    system_capacity = area * PANEL_EFFICIENCY  # kW
+
+    params = {
+        "api_key": API_KEY,
+        "lat": location.latitude,
+        "lon": location.longitude,
+        "system_capacity": system_capacity,
+        "azimuth": azimuth,
+        "tilt": tilt,
+        "array_type": 1,   # Fixed – roof mount
+        "module_type": 1,   # Premium
+        "losses": 14,
+    }
+
+    try:
+        response = requests.get(BASE_URL, params=params, timeout=30)
+        response.raise_for_status()
+        data = response.json()
+
+        if "errors" in data and data["errors"]:
+            print(f"  [API Error] {data['errors']}")
+            return 0.0
+
+        annual_kwh = float(data["outputs"]["ac_annual"])
+        return annual_kwh
+
+    except requests.RequestException as exc:
+        print(f"  [Request Error] {exc}")
+        return 0.0
+    except (KeyError, TypeError, ValueError) as exc:
+        print(f"  [Parse Error] Could not read API response: {exc}")
+        return 0.0
+
+
+# ---------------------------------------------------------------------------
+# Main execution
+# ---------------------------------------------------------------------------
+def run_production_analysis(
+    segments: list[dict] | None = None,
+    location: Location | None = None,
+) -> dict:
+    """Iterate over roof segments, query PVWatts, and return results.
+
+    Parameters
+    ----------
+    segments : list[dict] | None
+        Each dict must have keys: id, area, tilt, azimuth.
+        Falls back to the module-level ``roof_segments`` dummy data.
+    location : Location | None
+        Site coordinates.  Falls back to ``SITE_LOCATION``.
+
+    Returns
+    -------
+    dict with keys:
+        "segments"  – list of per-segment result dicts
+        "total_kwh" – total annual production (float)
+        "location"  – the Location used
+    """
+    segments = segments or roof_segments
+    location = location or SITE_LOCATION
+    total_building_production = 0.0
+    results: list[dict] = []
+
+    print(f"--- Analyzing Roof Segments for {location.name} ---")
+    print(f"    Site: ({location.latitude}, {location.longitude})")
+    print(f"    Panel efficiency factor: {PANEL_EFFICIENCY}")
+    print()
+
+    for slab in segments:
+        capacity_kw = slab["area"] * PANEL_EFFICIENCY
+        annual_kwh = calculate_segment_production(
+            slab["area"],
+            slab["tilt"],
+            slab["azimuth"],
+            location,
+        )
+        total_building_production += annual_kwh
+
+        results.append({
+            "id": slab["id"],
+            "area": slab["area"],
+            "tilt": slab["tilt"],
+            "azimuth": slab["azimuth"],
+            "capacity_kw": capacity_kw,
+            "annual_kwh": annual_kwh,
+        })
+
+        print(
+            f"  {slab['id']:>15s}  |  "
+            f"Area: {slab['area']:>7.1f} m²  |  "
+            f"Tilt: {slab['tilt']:>5.1f}°  |  "
+            f"Azimuth: {slab['azimuth']:>5.1f}°  |  "
+            f"Capacity: {capacity_kw:>6.1f} kW  |  "
+            f"Yield: {annual_kwh:>10,.2f} kWh/yr"
+        )
+
+        # Respect rate limits
+        time.sleep(1)
+
+    print()
+    print("-" * 70)
+    print(f"  TOTAL BUILDING PRODUCTION: {total_building_production:>12,.2f} kWh/yr")
+    print("-" * 70)
+    print()
+    print("  LEED hint:  Score = Total Production / Total Consumption × 100")
+
+    return {
+        "segments": results,
+        "total_kwh": total_building_production,
+        "location": location,
+    }
+
+
+def main() -> None:
+    """Run with built-in dummy data (backward-compatible entry point)."""
+    run_production_analysis()
+
+
+if __name__ == "__main__":
+    main()

teams/lux-ai/Final pipeline/README.md

@@ -0,0 +1,352 @@
+# Solar Pipeline — README
+
+## What is this?
+
+This tool answers **one question**:
+
+> **"If I put solar panels on this building's roof, how much energy will they produce?"**
+
+You give it a **building file** (`.ifc` format — the standard file that architects export from tools like Revit, ArchiCAD, or Vectorworks).
+
+It gives you back a **solar score** — how much of the building's energy the roof solar panels could cover.
+
+```
+     ┌─────────────┐          ┌────────────────┐          ┌──────────────┐
+     │             │          │                │          │              │
+     │  .ifc file  │  ──────▶ │  analyze_ifc() │  ──────▶ │  Solar Score │
+     │  (building) │          │  (this tool)   │          │  (% energy)  │
+     │             │          │                │          │              │
+     └─────────────┘          └────────────────┘          └──────────────┘
+```
+
+**Score = 100%** means the roof produces as much energy as the building consumes.
+That's **net-zero energy** — a key goal for green building certifications like **LEED**.
+
+---
+
+## Quick Start (for everyone)
+
+### Step 1 — Install
+
+Open a terminal (Command Prompt, PowerShell, or Mac Terminal) and type:
+
+```bash
+pip install ifcopenshell numpy requests tabulate
+```
+
+### Step 2 — Run
+
+```bash
+python -m solar_pipeline.analyze  "path/to/your/building.ifc"
+```
+
+That's it. You'll see a report like this:
+
+```
+  ============================================================
+    SOLAR ANALYSIS — fzk_house
+  ============================================================
+
+    FILE        arc.ifc
+    LOCATION    49.100435, 8.436539
+
+    ── Building Metadata ────────────────────────
+       Window area.................. 23.2 m²
+       Floor area................... 173.3 m²
+       Roof area (property-set)..... 165.1 m²
+       True north................... 310.0°
+
+    ── Roof Segments (geometry) ─────────────────
+       Roof_Seg_01    Area:    82.6 m²   Tilt:  30.0°   Azimuth: 310.0°   →  11,105.3 kWh/yr
+       Roof_Seg_02    Area:    82.6 m²   Tilt:  30.0°   Azimuth: 130.0°   →  14,914.6 kWh/yr
+
+    ── Solar Production ────────────────────────
+       Total roof area .........    165.1 m²
+       System capacity .........     33.0 kW
+       Annual production .......  26,020.0 kWh/yr
+
+    ── LEED Score ──────────────────────────────
+       Consumption estimate ....  26,001 kWh/yr
+       Renewable production ....  26,020 kWh/yr
+       Score ...................    100.1 %
+
+       ★  Net-zero energy achieved!
+```
+
+### If the building file has no location
+
+Some IFC files don't include coordinates. Just add them manually:
+
+```bash
+python -m solar_pipeline.analyze  "building.ifc"  --lat 48.14  --lon 11.58
+```
+
+---
+
+## Quick Start (for developers / AI agents)
+
+One import, one function, one result:
+
+```python
+from solar_pipeline.analyze import analyze_ifc
+
+result = analyze_ifc("building.ifc")
+
+if result["ok"]:
+    print(result["leed_score"])        # 100.1
+    print(result["total_production"])  # 26019.96  (kWh/yr)
+    print(result["segments"])          # [{id, area, tilt, azimuth, annual_kwh}, ...]
+else:
+    print(result["error"])             # what went wrong
+```
+
+### Function signature
+
+```python
+analyze_ifc(
+    ifc_path,                        # path to .ifc file (required)
+    *,
+    lat=None,                        # override latitude
+    lon=None,                        # override longitude
+    name=None,                       # project name for the report
+    consumption_kwh_per_m2=None,     # energy benchmark (default: 150)
+    call_api=True,                   # set False for offline mode
+)
+```
+
+### What the result dict contains
+
+| Key | Type | What it means |
+|-----|------|---------------|
+| `ok` | bool | `True` if everything worked |
+| `error` | str or None | Error message if `ok` is False |
+| `project_name` | str | Name of the project |
+| `ifc_file` | str | File name |
+| `window_area_m2` | float or None | Total window area in the building |
+| `floor_area_m2` | float or None | Total floor area |
+| `roof_area_m2` | float or None | Roof area from property sets (metadata) |
+| `true_north_deg` | float or None | Building orientation (0° = facing north) |
+| `latitude` | float | Site latitude |
+| `longitude` | float | Site longitude |
+| `segments` | list[dict] | Each roof face with its area, tilt, azimuth, and annual kWh |
+| `total_roof_area_m2` | float | Total roof area from 3D geometry |
+| `total_capacity_kw` | float | Solar panel capacity in kilowatts |
+| `total_production` | float | Annual energy production in kWh/yr |
+| `consumption` | float | Estimated annual consumption in kWh/yr |
+| `leed_score` | float | Production ÷ Consumption × 100 (%) |
+
+---
+
+## How It Works — The DNA of the Tool
+
+The pipeline has **5 steps**. Each step is handled by a separate module, but `analyze_ifc()` runs them all for you automatically.
+
+```
+  STEP 1          STEP 2            STEP 3          STEP 4           STEP 5
+ ┌────────┐    ┌───────────┐    ┌───────────┐    ┌──────────┐    ┌──────────┐
+ │ Open   │    │ Read      │    │ Analyse   │    │ Query    │    │ Calculate│
+ │ IFC    │───▶│ metadata  │───▶│ roof 3D   │───▶│ PVWatts  │───▶│ LEED     │
+ │ file   │    │ from file │    │ geometry  │    │ solar API│    │ score    │
+ └────────┘    └───────────┘    └───────────┘    └──────────┘    └──────────┘
+                    │                │                │                │
+              window area      roof segments     kWh per          score =
+              floor area       (tilt, azimuth,   segment          production
+              roof area         area each)                        ÷ consumption
+              lat, lon                                            × 100
+              true north
+```
+
+### Step 1 — Open the IFC file
+
+**IFC** (Industry Foundation Classes) is the universal file format for buildings. It stores the entire building as a database of objects — walls, windows, roofs, floors, etc. — with their geometry and properties.
+
+We use the open-source library `ifcopenshell` to read it.
+
+### Step 2 — Read building metadata
+
+The tool reads **property sets** embedded in the IFC file:
+
+| What | Where in the IFC file | Why we need it |
+|------|----------------------|----------------|
+| Window area | `IfcWindow` → quantity sets | Glazing ratio analysis |
+| Floor area | `IfcSpace` or `IfcSlab[FLOOR]` → quantity sets | Estimate building energy consumption |
+| Roof area | `IfcRoof` or `IfcSlab[ROOF]` → quantity sets | Cross-validate with 3D geometry |
+| Latitude & Longitude | `IfcSite.RefLatitude / RefLongitude` | Tell PVWatts where the building is |
+| True North | `IfcGeometricRepresentationContext.TrueNorth` | Correct roof azimuths to real compass |
+
+**The alias system**: Different software (Revit, ArchiCAD, Vectorworks) stores these values under different names. For example, floor area might be called `NetFloorArea`, `GrossFloorArea`, `GSA BIM Area`, or `Netto-Grundfläche` (German). The file `key_aliases.json` contains a priority-ordered list of all known names for each property, so the tool tries each one until it finds a match.
+
+### Step 3 — Analyse roof 3D geometry
+
+This is the key step that makes per-segment solar analysis possible:
+
+1. **Find roof elements** — `IfcRoof` objects and `IfcSlab` objects marked as roof type
+2. **Triangulate** — Convert each roof element into a mesh of triangles using world coordinates
+3. **Compute normals** — Each triangle has a direction it faces (its "normal vector")
+4. **Cluster** — Group triangles that face the same direction (within 15° tolerance)
+5. **Compute properties** — For each cluster, calculate:
+   - **Area** — total m² of that roof face
+   - **Tilt** — angle from horizontal (0° = flat, 90° = vertical wall)
+   - **Azimuth** — compass direction the face points (0° = north, 180° = south)
+6. **True north correction** — Rotate all azimuths by the building's TrueNorth angle so they match real-world compass directions
+
+*Why per-segment?* A south-facing roof face in Europe may produce **2.5× more energy** than a north-facing one. A single whole-roof average would be misleading.
+
+### Step 4 — Query the PVWatts solar API
+
+For each roof segment, we call the **NREL PVWatts v8** API (US National Renewable Energy Laboratory):
+
+```
+  Inputs:  lat, lon, roof area, tilt, azimuth
+  Output:  estimated annual solar energy in kWh
+```
+
+The API uses real weather data, sun angles, and atmospheric conditions for the specific location. It accounts for panel losses (wiring, soiling, shading) at 14%.
+
+### Step 5 — Calculate LEED score
+
+```
+  Score = Total Production (kWh/yr)  ÷  Total Consumption (kWh/yr)  ×  100
+```
+
+- **Production** = sum of all segment yields from PVWatts
+- **Consumption** = floor area × 150 kWh/m²/yr (ASHRAE office benchmark)
+  - If the IFC file has no floor area data, defaults to 50,000 kWh/yr
+
+| Score | Meaning |
+|-------|---------|
+| ≥ 100% | Net-zero energy — roof produces everything the building needs |
+| 50–99% | Strong renewable contribution |
+| 10–49% | Moderate contribution |
+| < 10% | Low contribution — different design or additional renewables needed |
+
+---
+
+## Configuration — `config.py`
+
+All defaults can be changed in [`solar_pipeline/config.py`](solar_pipeline/config.py):
+
+```python
+# ── NREL PVWatts v8 API ──────────────────────────────────────────────
+NREL_API_KEY = "0zwEIS1a..."         # Free key from api.nrel.gov
+PVWATTS_BASE_URL = "https://developer.nrel.gov/api/pvwatts/v8.json"
+
+# ── Solar panel assumptions ──────────────────────────────────────────
+PANEL_EFFICIENCY = 0.20              # 20% efficiency = 1 kW per 5 m²
+ARRAY_TYPE = 1                       # 1 = fixed roof mount
+MODULE_TYPE = 1                      # 1 = premium (monocrystalline)
+SYSTEM_LOSSES = 14                   # 14% total system losses
+
+# ── Roof geometry ────────────────────────────────────────────────────
+DEFAULT_ANGLE_TOLERANCE_DEG = 15.0   # Clustering tolerance (degrees)
+MIN_SEGMENT_AREA_M2 = 1.0           # Ignore tiny fragments
+
+# ── Energy benchmarks ────────────────────────────────────────────────
+DEFAULT_CONSUMPTION_KWH_PER_M2 = 150 # ASHRAE office (kWh/m²/yr)
+FALLBACK_CONSUMPTION_KWH = 50_000    # When floor area is unknown
+```
+
+### What each setting means
+
+| Setting | Default | What it controls |
+|---------|---------|-----------------|
+| `PANEL_EFFICIENCY` | 0.20 | How much of the roof area converts to electricity. 0.20 means 1 kW of solar capacity per 5 m² of roof. Premium panels are ~20%, budget panels ~15%. |
+| `SYSTEM_LOSSES` | 14% | Energy lost in wiring, inverters, soiling, snow, etc. Industry standard is 14%. |
+| `DEFAULT_ANGLE_TOLERANCE_DEG` | 15° | When grouping roof triangles by direction, faces within 15° of each other are merged into one segment. Lower = more segments, higher = fewer. |
+| `MIN_SEGMENT_AREA_M2` | 1.0 | Roof faces smaller than 1 m² are ignored (geometric noise). |
+| `DEFAULT_CONSUMPTION_KWH_PER_M2` | 150 | ASHRAE benchmark for a typical office building. Residential is ~100, hospitals ~300. Changes the LEED score denominator. |
+| `NREL_API_KEY` | provided | Free API key from [developer.nrel.gov](https://developer.nrel.gov/signup/). Rate limit: 1 request/second. |
+
+---
+
+## File Structure
+
+```
+solar_pipeline/
+│
+├── analyze.py                   ← THE MAIN FILE — one function does everything
+│                                   analyze_ifc("building.ifc") → score
+│
+├── ifc_metadata_extractor.py    ← Step 2: reads building properties from IFC
+│                                   (areas, location, orientation)
+│
+├── ifc_roof_parser.py           ← Step 3: 3D roof geometry → segments
+│                                   (tilt, azimuth, area per face)
+│
+├── solar_production_engine.py   ← Step 4: calls PVWatts API → kWh/yr
+│
+├── run_solar_analysis.py        ← Advanced CLI with batch modes
+│
+├── config.py                    ← All configurable settings
+│
+├── key_aliases.json             ← Maps property names across BIM software
+│                                   (Revit, ArchiCAD, Vectorworks, etc.)
+│
+├── __init__.py                  ← Package marker
+└── README.md                    ← This file
+```
+
+---
+
+## The Key Aliases System — Why It Exists
+
+Different architecture software stores the same data under different names:
+
+| Data | Revit calls it | ArchiCAD calls it | IFC4 standard |
+|------|---------------|-------------------|---------------|
+| Floor area | `GSA BIM Area` | `Netto-Grundfläche` | `NetFloorArea` |
+| Window area | `Area` in `BaseQuantities` | `Fläche` in `ArchiCADQuantities` | `Area` in `Qto_WindowBaseQuantities` |
+| Roof area | `GrossArea` in `BaseQuantities` | `Oberflächenbereich` | `NetArea` in `Qto_RoofBaseQuantities` |
+
+The file `key_aliases.json` contains a **priority-ordered list** for each property. The tool tries each name in order and uses the first match. This means it works with IFC files from **any** BIM software without manual configuration.
+
+You can add new aliases by editing the JSON file — no code changes needed.
+
+---
+
+## Supported IFC Versions
+
+| Version | Status | Example projects |
+|---------|--------|-----------------|
+| IFC2x3 | ✅ Fully supported | duplex, schependomlaan, hitos |
+| IFC4 | ✅ Fully supported | fzk_house, digital_hub, fantasy_* |
+| IFC4x3 | ✅ Supported | city_house_munich |
+
+---
+
+## Requirements
+
+| Package | Version | Why |
+|---------|---------|-----|
+| Python | ≥ 3.10 | Type hints, match statements |
+| ifcopenshell | ≥ 0.7.0 | Open and parse IFC files |
+| numpy | ≥ 1.21 | 3D geometry math |
+| requests | ≥ 2.28 | Call the PVWatts API |
+| tabulate | ≥ 0.9 | Pretty-print tables (optional) |
+
+Install all at once:
+```bash
+pip install ifcopenshell numpy requests tabulate
+```
+
+---
+
+## FAQ
+
+**Q: Do I need internet?**
+A: Yes, for the solar production numbers (PVWatts API). You can run offline with `call_api=False` to get just the roof geometry without kWh values.
+
+**Q: What if my IFC file has no roof?**
+A: The tool returns `ok=False` with error `"No roof segments found"`.
+
+**Q: What if there's no location in the file?**
+A: Pass `--lat` and `--lon` on the command line, or `lat=` and `lon=` in Python.
+
+**Q: Can I change the panel type?**
+A: Yes — edit `PANEL_EFFICIENCY`, `MODULE_TYPE`, and `SYSTEM_LOSSES` in `config.py`.
+
+**Q: Is the score accurate?**
+A: It's an **estimate**, not a guarantee. PVWatts uses real weather data and is widely trusted in the industry, but the actual production depends on shading, panel brand, inverter quality, and maintenance. This tool gives you a solid ballpark for early-stage design decisions and LEED pre-assessment.
+
+**Q: What's LEED?**
+A: Leadership in Energy and Environmental Design — the world's most widely used green building rating system. One of its credits rewards buildings that generate renewable energy on-site. The score this tool gives approximates that credit.

teams/lux-ai/Final pipeline/__init__.py

@@ -0,0 +1,15 @@
+"""
+solar_pipeline — Unified IFC metadata extraction + solar production analysis.
+
+Merges:
+  - IFC property-set/quantity-set metadata scanner (window, floor, roof area,
+    orientation, lat/lon) with multi-exporter alias fallback
+  - Geometry-based roof segment parser (per-face tilt & azimuth via 3D mesh)
+  - NREL PVWatts v8 solar production engine
+
+Supports single-file solar analysis and batch scanning of project directories.
+"""
+
+from solar_pipeline.config import __version__
+
+__all__ = ["__version__"]

teams/lux-ai/Final pipeline/analyze.py

@@ -0,0 +1,306 @@
+"""
+analyze.py — One function. One IFC file in. Full solar score out.
+
+    from solar_pipeline.analyze import analyze_ifc
+    result = analyze_ifc("path/to/building.ifc")
+    print(result["leed_score"])          # e.g. 100.1
+    print(result["total_production"])    # e.g. 26019.96  (kWh/yr)
+
+Also runnable from the command line:
+    python -m solar_pipeline.analyze  "path/to/building.ifc"
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+
+def analyze_ifc(
+    ifc_path: str | Path,
+    *,
+    lat: float | None = None,
+    lon: float | None = None,
+    name: str | None = None,
+    consumption_kwh_per_m2: float | None = None,
+    call_api: bool = True,
+) -> dict:
+    """
+    Analyse one IFC building file and return a full solar production report.
+
+    ┌──────────────┐     ┌──────────────────┐     ┌──────────────┐
+    │  IFC file    │────▶│  This function   │────▶│  Result dict │
+    └──────────────┘     └──────────────────┘     └──────────────┘
+
+    What happens inside
+    -------------------
+    1. Opens the IFC file
+    2. Reads building metadata  (areas, location, orientation)
+    3. Extracts 3-D roof geometry and splits it into segments
+    4. Queries the NREL PVWatts v8 API for each segment's solar yield
+    5. Calculates a LEED-style renewable-energy score
+
+    Parameters
+    ----------
+    ifc_path : str or Path
+        Path to an .ifc file (IFC2x3, IFC4, or IFC4x3).
+
+    lat, lon : float, optional
+        Override latitude / longitude if the IFC file has no IfcSite
+        coordinates.  When omitted the tool reads them automatically.
+
+    name : str, optional
+        Project name shown in the report.  Defaults to the parent folder
+        name of the IFC file.
+
+    consumption_kwh_per_m2 : float, optional
+        Building energy consumption benchmark in kWh/m²/yr.
+        Default = 150 (ASHRAE typical office).
+        The tool multiplies this by the floor area to estimate annual
+        consumption, which is the denominator in the LEED score.
+
+    call_api : bool, default True
+        Set to False to skip the PVWatts API call (useful for offline
+        testing).  When False the per-segment kWh values are all 0.
+
+    Returns
+    -------
+    dict with these keys:
+
+        ok                  bool     – True if the analysis succeeded
+        error               str      – error message (only if ok=False)
+
+        # ── Building metadata ──────────────────────────
+        project_name        str      – project / folder name
+        ifc_file            str      – file name
+        window_area_m2      float|None
+        floor_area_m2       float|None
+        roof_area_m2        float|None  (from property sets)
+        true_north_deg      float|None  (compass bearing)
+        latitude            float|None
+        longitude           float|None
+
+        # ── Roof geometry ──────────────────────────────
+        segments            list[dict] – per roof-face data
+            Each dict:  id, area, tilt, azimuth, capacity_kw, annual_kwh
+
+        # ── Solar production ───────────────────────────
+        total_roof_area_m2  float  – from geometry (sum of segments)
+        total_capacity_kw   float
+        total_production    float  – kWh/yr
+        consumption         float  – estimated kWh/yr
+        leed_score          float  – production / consumption × 100
+
+    Example
+    -------
+    >>> result = analyze_ifc("Sample projects/projects/fzk_house/arc.ifc")
+    >>> print(f"Score: {result['leed_score']:.1f}%")
+    Score: 100.1%
+    """
+
+    # ── Lazy imports (so the module is light to load) ─────────────────────
+    from solar_pipeline.config import (
+        DEFAULT_CONSUMPTION_KWH_PER_M2,
+        FALLBACK_CONSUMPTION_KWH,
+        PANEL_EFFICIENCY,
+    )
+    from solar_pipeline.ifc_metadata_extractor import (
+        Location,
+        extract_all,
+        extract_location,
+    )
+    from solar_pipeline.ifc_roof_parser import parse_roof_segments
+    from solar_pipeline.solar_production_engine import run_production_analysis
+
+    ifc_path = Path(ifc_path)
+    project = name or ifc_path.parent.name
+
+    # ── 1. Validate input ─────────────────────────────────────────────────
+    if not ifc_path.is_file():
+        return _error(f"File not found: {ifc_path}")
+
+    # ── 2. Metadata extraction ────────────────────────────────────────────
+    try:
+        metadata = extract_all(ifc_path)
+    except Exception as exc:
+        return _error(f"Metadata extraction failed: {exc}")
+
+    # ── 3. Resolve location ───────────────────────────────────────────────
+    if lat is not None and lon is not None:
+        location = Location(latitude=lat, longitude=lon, name=project)
+    elif metadata.get("latitude") is not None and metadata.get("longitude") is not None:
+        location = Location(
+            latitude=metadata["latitude"],
+            longitude=metadata["longitude"],
+            name=project,
+        )
+    else:
+        return _error(
+            "No location found. The IFC file has no IfcSite coordinates. "
+            "Pass lat= and lon= manually."
+        )
+
+    # ── 4. Roof geometry ─────────────────────────────────────────────────
+    try:
+        segments = parse_roof_segments(ifc_path)
+    except Exception as exc:
+        return _error(f"Roof geometry parsing failed: {exc}")
+
+    if not segments:
+        return _error("No roof segments found in this IFC file.")
+
+    # ── 5. Solar production (PVWatts API) ─────────────────────────────────
+    if call_api:
+        try:
+            prod = run_production_analysis(
+                segments, location, verbose=False,
+            )
+        except Exception as exc:
+            return _error(f"PVWatts API failed: {exc}")
+        segment_results = prod["segments"]
+        total_kwh = prod["total_kwh"]
+    else:
+        # Offline mode — geometry only, no kWh
+        segment_results = []
+        for seg in segments:
+            segment_results.append({
+                **seg,
+                "capacity_kw": round(seg["area"] * PANEL_EFFICIENCY, 2),
+                "annual_kwh": 0.0,
+            })
+        total_kwh = 0.0
+
+    # ── 6. LEED score ─────────────────────────────────────────────────────
+    bench = consumption_kwh_per_m2 or DEFAULT_CONSUMPTION_KWH_PER_M2
+    floor = metadata.get("floor_area_m2")
+    if floor and floor > 0:
+        consumption = floor * bench
+    else:
+        consumption = FALLBACK_CONSUMPTION_KWH
+
+    leed_score = (total_kwh / consumption * 100) if consumption > 0 else 0.0
+
+    # ── Build result ──────────────────────────────────────────────────────
+    total_roof = sum(s["area"] for s in segment_results)
+    total_cap = sum(s["capacity_kw"] for s in segment_results)
+
+    return {
+        "ok": True,
+        "error": None,
+
+        # Metadata
+        "project_name": project,
+        "ifc_file": ifc_path.name,
+        "window_area_m2": metadata.get("window_area_m2"),
+        "floor_area_m2": metadata.get("floor_area_m2"),
+        "roof_area_m2": metadata.get("roof_area_m2"),
+        "true_north_deg": metadata.get("true_north_angle_deg"),
+        "latitude": location.latitude,
+        "longitude": location.longitude,
+
+        # Segments
+        "segments": segment_results,
+
+        # Totals
+        "total_roof_area_m2": round(total_roof, 2),
+        "total_capacity_kw": round(total_cap, 2),
+        "total_production": round(total_kwh, 2),
+        "consumption": round(consumption, 2),
+        "leed_score": round(leed_score, 1),
+    }
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _error(msg: str) -> dict:
+    """Return a minimal error result."""
+    log.error(msg)
+    return {"ok": False, "error": msg}
+
+
+def print_report(result: dict) -> None:
+    """Pretty-print an analysis result to the terminal."""
+    if not result.get("ok"):
+        print(f"\n  ERROR: {result.get('error')}\n")
+        return
+
+    print()
+    print("=" * 60)
+    print(f"  SOLAR ANALYSIS — {result['project_name']}")
+    print("=" * 60)
+
+    print(f"\n  FILE        {result['ifc_file']}")
+    print(f"  LOCATION    {result['latitude']}, {result['longitude']}")
+
+    print(f"\n  ── Building Metadata ────────────────────────")
+    for key, label in [
+        ("window_area_m2", "Window area"),
+        ("floor_area_m2", "Floor area"),
+        ("roof_area_m2", "Roof area (property-set)"),
+        ("true_north_deg", "True north"),
+    ]:
+        val = result.get(key)
+        unit = "°" if "north" in key else " m²"
+        print(f"     {label:.<30s} {f'{val:,.1f}{unit}' if val is not None else 'N/A'}")
+
+    print(f"\n  ── Roof Segments (geometry) ─────────────────")
+    for s in result["segments"]:
+        print(f"     {s['id']:15s}  "
+              f"Area: {s['area']:>7.1f} m²   "
+              f"Tilt: {s['tilt']:>5.1f}°   "
+              f"Azimuth: {s['azimuth']:>5.1f}°   "
+              f"→ {s['annual_kwh']:>10,.1f} kWh/yr")
+
+    print(f"\n  ── Solar Production ────────────────────────")
+    print(f"     Total roof area ......... {result['total_roof_area_m2']:>10,.1f} m²")
+    print(f"     System capacity ......... {result['total_capacity_kw']:>10,.1f} kW")
+    print(f"     Annual production ....... {result['total_production']:>10,.1f} kWh/yr")
+
+    print(f"\n  ── LEED Score ──────────────────────────────")
+    print(f"     Consumption estimate .... {result['consumption']:>10,.0f} kWh/yr")
+    print(f"     Renewable production .... {result['total_production']:>10,.0f} kWh/yr")
+    print(f"     Score ................... {result['leed_score']:>10.1f} %")
+
+    if result["leed_score"] >= 100:
+        print(f"\n     ★  Net-zero energy achieved!")
+    elif result["leed_score"] >= 50:
+        print(f"\n     ●  Over 50% renewable coverage — strong LEED contribution")
+    elif result["leed_score"] >= 10:
+        print(f"\n     ○  Moderate renewable contribution")
+    else:
+        print(f"\n     ·  Low renewable contribution — consider design changes")
+    print()
+
+
+# ── CLI entry point ───────────────────────────────────────────────────────────
+
+def main() -> None:
+    """Minimal CLI: python -m solar_pipeline.analyze  building.ifc"""
+    logging.basicConfig(level=logging.INFO, format="%(levelname)-8s %(message)s")
+
+    if len(sys.argv) < 2:
+        print("Usage:  python -m solar_pipeline.analyze  <file.ifc>  [--lat N] [--lon N]")
+        sys.exit(1)
+
+    # Simple arg parsing (no argparse needed for this one-shot entry)
+    ifc_path = sys.argv[1]
+    lat = lon = None
+    args = sys.argv[2:]
+    i = 0
+    while i < len(args):
+        if args[i] == "--lat" and i + 1 < len(args):
+            lat = float(args[i + 1]); i += 2
+        elif args[i] == "--lon" and i + 1 < len(args):
+            lon = float(args[i + 1]); i += 2
+        else:
+            i += 1
+
+    result = analyze_ifc(ifc_path, lat=lat, lon=lon)
+    print_report(result)
+
+
+if __name__ == "__main__":
+    main()

teams/lux-ai/Final pipeline/config.py

@@ -0,0 +1,50 @@
+"""
+config.py — Shared constants and defaults for the solar pipeline.
+"""
+
+from pathlib import Path
+
+__version__ = "1.0.0"
+
+# ── Paths ─────────────────────────────────────────────────────────────────────
+
+PACKAGE_DIR = Path(__file__).resolve().parent
+REPO_ROOT = PACKAGE_DIR.parent
+KEY_ALIASES_PATH = PACKAGE_DIR / "key_aliases.json"
+DEFAULT_SAMPLE_ROOT = REPO_ROOT / "Sample projects" / "projects"
+
+# ── NREL PVWatts v8 API ──────────────────────────────────────────────────────
+
+NREL_API_KEY = "0zwEIS1adJrx658O3gjQYfI7AprKLjQf4KP420o9"
+PVWATTS_BASE_URL = "https://developer.nrel.gov/api/pvwatts/v8.json"
+
+# ── Solar panel assumptions ───────────────────────────────────────────────────
+
+PANEL_EFFICIENCY = 0.20          # 1 kW per 5 m² of panel
+ARRAY_TYPE = 1                   # Fixed — roof mount
+MODULE_TYPE = 1                  # Premium (monocrystalline)
+SYSTEM_LOSSES = 14               # % (wiring, soiling, mismatch, etc.)
+
+# ── Roof geometry clustering ─────────────────────────────────────────────────
+
+DEFAULT_ANGLE_TOLERANCE_DEG = 15.0   # max normal deviation within a cluster
+MIN_SEGMENT_AREA_M2 = 1.0           # ignore clusters smaller than this
+
+# ── LEED / energy benchmarks ─────────────────────────────────────────────────
+
+DEFAULT_CONSUMPTION_KWH_PER_M2 = 150   # ASHRAE typical office (kWh/m²/yr)
+FALLBACK_CONSUMPTION_KWH = 50_000      # used when floor area is unknown
+
+# ── CSV output columns ───────────────────────────────────────────────────────
+
+CSV_COLUMNS = [
+    "project_name",
+    "ifc_file",
+    "window_area_m2",
+    "floor_area_m2",
+    "roof_area_m2",
+    "true_north_angle_deg",
+    "latitude",
+    "longitude",
+    "error",
+]

teams/lux-ai/Final pipeline/ifc_metadata_extractor.py

@@ -0,0 +1,442 @@
+"""
+ifc_metadata_extractor.py — Alias-driven IFC property-set / quantity-set
+metadata extraction.
+
+Reads key_aliases.json to resolve exporter-specific naming differences
+(Archicad, Revit, IFC2x3, IFC4, GSA, BOMA, …) and extracts:
+    window_area, floor_area, roof_area, true_north_angle, latitude, longitude
+
+Also exposes helpers consumed by the roof-geometry parser and the solar
+production engine (extract_location, extract_true_north).
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+import logging
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import ifcopenshell
+import ifcopenshell.util.unit as ifc_unit_util
+
+from solar_pipeline.config import CSV_COLUMNS, KEY_ALIASES_PATH
+
+# ── Logging ───────────────────────────────────────────────────────────────────
+
+log = logging.getLogger(__name__)
+
+# ── Load alias map once at module import ──────────────────────────────────────
+
+def _load_aliases(path: Path | None = None) -> dict:
+    p = path or KEY_ALIASES_PATH
+    try:
+        with open(p, encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        log.warning("key_aliases.json not found at %s — using empty alias map", p)
+        return {}
+
+ALIASES: dict = _load_aliases()
+
+# ── Location dataclass (re-used by solar engine) ─────────────────────────────
+
+@dataclass
+class Location:
+    """Site coordinates extracted from IfcSite."""
+    latitude: float
+    longitude: float
+    name: str = ""
+
+
+# ── Unit helpers ──────────────────────────────────────────────────────────────
+
+def get_length_scale(model: ifcopenshell.file) -> float:
+    """Scale factor: model length units → metres."""
+    try:
+        return ifc_unit_util.calculate_unit_scale(model, "LENGTHUNIT")
+    except Exception:
+        return 1.0
+
+
+def get_area_scale(model: ifcopenshell.file) -> float:
+    """Scale factor: model area units → m²."""
+    try:
+        return ifc_unit_util.calculate_unit_scale(model, "AREAMEASURE")
+    except Exception:
+        return 1.0
+
+
+# ── Low-level quantity / property getters ─────────────────────────────────────
+
+def get_quantity(element, qset_name: str, qty_name: str) -> Optional[float]:
+    """
+    Walk IsDefinedBy → IfcRelDefinesByProperties → IfcElementQuantity
+    and return the numeric value of *qty_name* inside *qset_name*.
+    """
+    for rel in getattr(element, "IsDefinedBy", []):
+        if not rel.is_a("IfcRelDefinesByProperties"):
+            continue
+        qset = rel.RelatingPropertyDefinition
+        if not qset.is_a("IfcElementQuantity"):
+            continue
+        if qset.Name != qset_name:
+            continue
+        for qty in qset.Quantities:
+            if qty.Name != qty_name:
+                continue
+            for attr in ("AreaValue", "LengthValue", "VolumeValue", "CountValue"):
+                v = getattr(qty, attr, None)
+                if v is not None:
+                    return float(v)
+    return None
+
+
+def get_property(element, pset_name: str, prop_name: str) -> Optional[float]:
+    """
+    Walk IsDefinedBy → IfcRelDefinesByProperties → IfcPropertySet
+    and return the nominal value of *prop_name* inside *pset_name*.
+    """
+    for rel in getattr(element, "IsDefinedBy", []):
+        if not rel.is_a("IfcRelDefinesByProperties"):
+            continue
+        pset = rel.RelatingPropertyDefinition
+        if not pset.is_a("IfcPropertySet"):
+            continue
+        if pset.Name != pset_name:
+            continue
+        for prop in pset.HasProperties:
+            if prop.Name != prop_name:
+                continue
+            nv = getattr(prop, "NominalValue", None)
+            if nv is not None:
+                try:
+                    return float(nv.wrappedValue)
+                except (TypeError, ValueError, AttributeError):
+                    return None
+    return None
+
+
+def get_quantity_multi(
+    element, qset_names: list[str], qty_name: str
+) -> Optional[float]:
+    """Try multiple quantity-set names in priority order; return first match."""
+    for qset_name in qset_names:
+        val = get_quantity(element, qset_name, qty_name)
+        if val is not None:
+            return val
+    return None
+
+
+# ── Alias-driven generic extractor ────────────────────────────��──────────────
+
+def _extract_by_alias(
+    model: ifcopenshell.file,
+    canonical_key: str,
+    area_scale: float,
+    length_scale: float,
+) -> Optional[float]:
+    """
+    Use the alias chain in key_aliases.json to extract a value.
+    Iterates strategies in priority order; returns the first that yields data.
+    """
+    strategies = ALIASES.get(canonical_key, [])
+    if not strategies:
+        return None
+
+    for strat in strategies:
+        entity_type = strat.get("entity")
+        source = strat.get("source")  # "qset", "pset", or "attr"
+
+        # ── Attribute-based strategies ────────────────────────────────────
+        if source == "attr":
+            if strat.get("op") == "multiply":
+                # e.g. OverallHeight × OverallWidth for windows
+                elements = model.by_type(entity_type)
+                total = 0.0
+                found = False
+                for elem in elements:
+                    vals = []
+                    for k in strat["keys"]:
+                        v = getattr(elem, k, None)
+                        if v is not None:
+                            vals.append(float(v))
+                    if len(vals) == len(strat["keys"]):
+                        product = 1.0
+                        for v in vals:
+                            product *= v
+                        total += product * (length_scale ** len(strat["keys"]))
+                        found = True
+                if found:
+                    return round(total, 4)
+            # Other attr strategies (TrueNorth, RefLatitude) are handled
+            # by dedicated functions, not this generic extractor.
+            continue
+
+        # ── Quantity-set or property-set strategies ───────────────────────
+        predefined_type = strat.get("predefined_type")
+        set_name = strat["set_name"]
+        key = strat["key"]
+
+        elements = model.by_type(entity_type)
+        total = 0.0
+        found = False
+        for elem in elements:
+            # Filter by PredefinedType if required
+            if predefined_type:
+                pt = getattr(elem, "PredefinedType", None)
+                if pt != predefined_type:
+                    continue
+
+            if source == "qset":
+                val = get_quantity(elem, set_name, key)
+            elif source == "pset":
+                val = get_property(elem, set_name, key)
+            else:
+                continue
+
+            if val is not None:
+                total += val * area_scale
+                found = True
+
+        if found:
+            return round(total, 4)
+
+    return None
+
+
+# ── Specific extractors ──────────────────────────────────────────────────────
+
+def extract_window_area(model: ifcopenshell.file) -> Optional[float]:
+    """Total window area in m², using alias fallback chain."""
+    return _extract_by_alias(model, "window_area", get_area_scale(model), get_length_scale(model))
+
+
+def extract_floor_area(model: ifcopenshell.file) -> Optional[float]:
+    """Total floor area in m², using alias fallback chain."""
+    return _extract_by_alias(model, "floor_area", get_area_scale(model), get_length_scale(model))
+
+
+def extract_roof_area(model: ifcopenshell.file) -> Optional[float]:
+    """Total roof area (metadata) in m², using alias fallback chain."""
+    return _extract_by_alias(model, "roof_area", get_area_scale(model), get_length_scale(model))
+
+
+def decode_compound_angle(compound) -> Optional[float]:
+    """Convert IfcCompoundPlaneAngleMeasure [deg, min, sec, µsec] → decimal degrees."""
+    if compound is None:
+        return None
+    parts = list(compound)
+    if not parts:
+        return None
+    deg = int(parts[0])
+    minutes = int(parts[1]) if len(parts) > 1 else 0
+    secs = int(parts[2]) if len(parts) > 2 else 0
+    microsecs = int(parts[3]) if len(parts) > 3 else 0
+    sign = -1 if deg < 0 else 1
+    return sign * (
+        abs(deg) + abs(minutes) / 60 + abs(secs) / 3600 + abs(microsecs) / 3_600_000_000
+    )
+
+
+def extract_true_north(model: ifcopenshell.file) -> Optional[float]:
+    """
+    True north compass bearing (degrees clockwise from +Y axis).
+
+    Returns None if the model lacks TrueNorth data.
+    """
+    for ctx in model.by_type("IfcGeometricRepresentationContext"):
+        if ctx.is_a("IfcGeometricRepresentationSubContext"):
+            continue
+        true_north = getattr(ctx, "TrueNorth", None)
+        if true_north is not None:
+            ratios = true_north.DirectionRatios
+            x, y = float(ratios[0]), float(ratios[1])
+            angle_ccw = math.degrees(math.atan2(x, y))
+            return round((-angle_ccw) % 360.0, 2)
+    return None
+
+
+def extract_location(model: ifcopenshell.file, project_name: str = "") -> Optional[Location]:
+    """
+    Extract lat/lon from IfcSite and return a Location dataclass.
+
+    Returns None if the model has no geographic coordinates.
+    """
+    sites = model.by_type("IfcSite")
+    if not sites:
+        return None
+    site = sites[0]
+    lat = decode_compound_angle(getattr(site, "RefLatitude", None))
+    lon = decode_compound_angle(getattr(site, "RefLongitude", None))
+    if lat is None or lon is None:
+        return None
+    return Location(
+        latitude=round(lat, 6),
+        longitude=round(lon, 6),
+        name=project_name or getattr(site, "Name", None) or "",
+    )
+
+
+def extract_orientation(model: ifcopenshell.file) -> dict:
+    """
+    Extract true north angle + latitude + longitude.
+
+    Returns dict compatible with the original scan_ifc_models.py output.
+    """
+    result = {
+        "true_north_angle_deg": extract_true_north(model),
+        "latitude": None,
+        "longitude": None,
+    }
+    loc = extract_location(model)
+    if loc is not None:
+        result["latitude"] = loc.latitude
+        result["longitude"] = loc.longitude
+    return result
+
+
+# ── Per-file orchestration ────────────────────────────────────────────────────
+
+def extract_all(ifc_path: Path | str) -> dict:
+    """
+    Open one IFC file and extract all metadata metrics.
+
+    Returns a dict with keys matching CSV_COLUMNS.
+    """
+    ifc_path = Path(ifc_path)
+    base = {
+        "project_name": ifc_path.parent.name,
+        "ifc_file": ifc_path.name,
+        "window_area_m2": None,
+        "floor_area_m2": None,
+        "roof_area_m2": None,
+        "true_north_angle_deg": None,
+        "latitude": None,
+        "longitude": None,
+        "error": None,
+    }
+
+    try:
+        model = ifcopenshell.open(str(ifc_path))
+    except Exception as exc:
+        log.error("Cannot open %s: %s", ifc_path, exc)
+        base["error"] = str(exc)
+        return base
+
+    log.info("  Schema: %s", model.schema)
+
+    extractors = {
+        "window_area_m2": extract_window_area,
+        "floor_area_m2": extract_floor_area,
+        "roof_area_m2": extract_roof_area,
+    }
+    for key, fn in extractors.items():
+        try:
+            base[key] = fn(model)
+        except Exception as exc:
+            log.warning("  %s extraction failed: %s", key, exc)
+
+    try:
+        orientation = extract_orientation(model)
+        base.update(orientation)
+    except Exception as exc:
+        log.warning("  Orientation extraction failed: %s", exc)
+
+    return base
+
+
+def open_model(ifc_path: Path | str) -> ifcopenshell.file:
+    """Open an IFC file and return the ifcopenshell model handle."""
+    return ifcopenshell.open(str(ifc_path))
+
+
+# ── Batch scanning ───────────────────────────────────────────────────────────
+
+def find_ifc_files(root_dir: Path) -> list[Path]:
+    """Recursively find all .ifc files under root_dir, sorted."""
+    return sorted(root_dir.rglob("*.ifc"))
+
+
+def scan_all(
+    root_dir: Path,
+    output_csv: Path | None = None,
+) -> list[dict]:
+    """
+    Scan all IFC files under *root_dir* and return a list of result dicts.
+    Optionally writes results to a CSV file.
+    """
+    ifc_files = find_ifc_files(root_dir)
+    log.info("Found %d IFC file(s) under: %s", len(ifc_files), root_dir)
+
+    results: list[dict] = []
+    for i, ifc_path in enumerate(ifc_files, 1):
+        log.info("[%d/%d] %s/%s", i, len(ifc_files), ifc_path.parent.name, ifc_path.name)
+        result = extract_all(ifc_path)
+        results.append(result)
+
+    if output_csv:
+        _write_csv(results, output_csv)
+
+    return results
+
+
+def _write_csv(results: list[dict], output_path: Path) -> None:
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=CSV_COLUMNS, extrasaction="ignore")
+        writer.writeheader()
+        writer.writerows(results)
+    log.info("CSV written to: %s", output_path)
+
+
+def print_summary_table(results: list[dict]) -> None:
+    """Print a tabulate-formatted summary to stdout."""
+    try:
+        from tabulate import tabulate
+    except ImportError:
+        log.warning("tabulate not installed — skipping summary table")
+        return
+
+    display_cols = [
+        "project_name", "ifc_file",
+        "window_area_m2", "floor_area_m2", "roof_area_m2",
+        "true_north_angle_deg", "latitude", "longitude",
+    ]
+    headers = [
+        "Project", "File",
+        "Window m²", "Floor m²", "Roof m²",
+        "TrueNorth°", "Lat", "Lon",
+    ]
+
+    table_data = []
+    for r in results:
+        row = []
+        for col in display_cols:
+            val = r.get(col)
+            if val is None:
+                row.append("N/A")
+            elif isinstance(val, float):
+                row.append(f"{val:.2f}")
+            else:
+                row.append(str(val))
+        if r.get("error"):
+            row[-1] = "ERROR"
+        table_data.append(row)
+
+    print("\n" + tabulate(table_data, headers=headers, tablefmt="github"))
+
+    processed = [r for r in results if not r.get("error")]
+    errors = [r for r in results if r.get("error")]
+    print(f"\nFiles scanned  : {len(results)}")
+    print(f"Errors         : {len(errors)}")
+    print(f"Window data    : {sum(1 for r in processed if r['window_area_m2'] is not None)}/{len(processed)} files")
+    print(f"Floor data     : {sum(1 for r in processed if r['floor_area_m2'] is not None)}/{len(processed)} files")
+    print(f"Roof data      : {sum(1 for r in processed if r['roof_area_m2'] is not None)}/{len(processed)} files")
+    print(f"Orientation    : {sum(1 for r in processed if r['true_north_angle_deg'] is not None)}/{len(processed)} files")
+    if errors:
+        print("\nFiles with errors:")
+        for r in errors:
+            print(f"  {r['project_name']}/{r['ifc_file']}: {r['error']}")

teams/lux-ai/Final pipeline/ifc_roof_parser.py

@@ -0,0 +1,359 @@
+"""
+ifc_roof_parser.py — Geometry-based roof segment extraction from IFC files.
+
+Analyses the 3D triangulated mesh of roof elements to produce per-segment
+tilt, azimuth, and area values that the solar production engine consumes.
+
+Algorithm:
+    1. Find all IfcRoof + decomposed IfcSlab children + standalone ROOF slabs
+    2. Triangulate each element via ifcopenshell.geom (world coordinates)
+    3. Compute face normals and triangle areas
+    4. Cluster upward-facing triangles by normal direction (angular tolerance)
+    5. Compute area-weighted average tilt & azimuth per cluster
+    6. Apply true-north rotation so azimuths are real-world compass bearings
+
+Cross-validates geometry-derived total area against property-set roof_area.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+
+import ifcopenshell
+import ifcopenshell.geom
+
+from solar_pipeline.config import DEFAULT_ANGLE_TOLERANCE_DEG, MIN_SEGMENT_AREA_M2
+from solar_pipeline.ifc_metadata_extractor import (
+    extract_roof_area,
+    extract_true_north,
+    get_area_scale,
+)
+
+log = logging.getLogger(__name__)
+
+
+# ── Element discovery ─────────────────────────────────────────────────────────
+
+def get_roof_elements(model: ifcopenshell.file) -> list:
+    """
+    Collect all roof-related IFC elements:
+      - IfcRoof entities (decomposed through IfcRelAggregates if present)
+      - Standalone IfcSlab with PredefinedType == ROOF
+    Returns leaf elements (slabs or monolithic roofs) ready for geometry extraction.
+    """
+    elements: list = []
+    seen_ids: set[int] = set()
+
+    # IfcRoof → decomposed sub-elements
+    for roof in model.by_type("IfcRoof"):
+        children = _get_decomposed_children(roof)
+        if children:
+            for child in children:
+                if child.id() not in seen_ids:
+                    elements.append(child)
+                    seen_ids.add(child.id())
+        else:
+            # Monolithic roof — process the IfcRoof itself
+            if roof.id() not in seen_ids:
+                elements.append(roof)
+                seen_ids.add(roof.id())
+
+    # Standalone IfcSlab with ROOF type (not already captured)
+    for slab in model.by_type("IfcSlab"):
+        pt = getattr(slab, "PredefinedType", None)
+        if pt == "ROOF" and slab.id() not in seen_ids:
+            elements.append(slab)
+            seen_ids.add(slab.id())
+
+    log.info("  Found %d roof element(s) for geometry extraction", len(elements))
+    return elements
+
+
+def _get_decomposed_children(element) -> list:
+    """Walk IfcRelAggregates to find child elements (e.g. IfcSlab under IfcRoof)."""
+    children: list = []
+    for rel in getattr(element, "IsDecomposedBy", []):
+        if rel.is_a("IfcRelAggregates"):
+            children.extend(rel.RelatedObjects)
+    return children
+
+
+# ── Geometry extraction ───────────────────────────────────────────────────────
+
+def _make_geom_settings() -> ifcopenshell.geom.settings:
+    """Create geometry settings for triangulated mesh in world coordinates."""
+    settings = ifcopenshell.geom.settings()
+    settings.set("use-world-coords", True)
+    return settings
+
+
+def extract_geometry(
+    element,
+    settings: ifcopenshell.geom.settings,
+) -> tuple[np.ndarray, np.ndarray] | None:
+    """
+    Triangulate an IFC element and return (vertices, faces).
+
+    vertices: (N, 3) float64 — XYZ coordinates
+    faces:    (M, 3) int      — triangle vertex indices
+
+    Returns None if geometry extraction fails.
+    """
+    try:
+        shape = ifcopenshell.geom.create_shape(settings, element)
+    except Exception as exc:
+        log.warning("  Geometry extraction failed for #%d (%s): %s",
+                    element.id(), element.is_a(), exc)
+        return None
+
+    # ifcopenshell returns flat arrays
+    verts_flat = shape.geometry.verts
+    faces_flat = shape.geometry.faces
+
+    if not verts_flat or not faces_flat:
+        return None
+
+    vertices = np.array(verts_flat, dtype=np.float64).reshape(-1, 3)
+    faces = np.array(faces_flat, dtype=np.int32).reshape(-1, 3)
+
+    return vertices, faces
+
+
+# ── Normal & area computation ─────────────────────────────────────────────────
+
+def compute_face_normals(
+    vertices: np.ndarray,
+    faces: np.ndarray,
+) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Compute unit normals and areas for every triangle.
+
+    Returns:
+        normals: (M, 3) float64 — unit normal per face
+        areas:   (M,)   float64 — area per face in model units²
+    """
+    v0 = vertices[faces[:, 0]]
+    v1 = vertices[faces[:, 1]]
+    v2 = vertices[faces[:, 2]]
+
+    edge1 = v1 - v0
+    edge2 = v2 - v0
+    cross = np.cross(edge1, edge2)
+
+    magnitudes = np.linalg.norm(cross, axis=1, keepdims=True)
+    # Avoid division by zero for degenerate triangles
+    safe_mag = np.where(magnitudes > 1e-12, magnitudes, 1e-12)
+    normals = cross / safe_mag
+    areas = (magnitudes.flatten() / 2.0)
+
+    return normals, areas
+
+
+# ── Clustering ────────────────────────────────────────────────────────────────
+
+def cluster_faces_by_normal(
+    normals: np.ndarray,
+    areas: np.ndarray,
+    angle_tolerance: float = DEFAULT_ANGLE_TOLERANCE_DEG,
+) -> list[list[int]]:
+    """
+    Greedy angular clustering of upward-facing triangles.
+
+    Only considers triangles where normal Z > 0 (upward-facing — solar relevant).
+    Groups triangles whose normals are within *angle_tolerance* degrees.
+
+    Returns list of clusters, each a list of face indices.
+    """
+    cos_tol = math.cos(math.radians(angle_tolerance))
+    clusters: list[list[int]] = []
+    cluster_normals: list[np.ndarray] = []
+
+    # Filter to upward-facing triangles
+    upward_mask = normals[:, 2] > 0
+    upward_indices = np.where(upward_mask)[0]
+
+    for idx in upward_indices:
+        n = normals[idx]
+        placed = False
+        for ci, cn in enumerate(cluster_normals):
+            dot = float(np.dot(n, cn))
+            if dot >= cos_tol:
+                clusters[ci].append(int(idx))
+                # Update cluster normal (area-weighted running average)
+                total_area = sum(areas[i] for i in clusters[ci])
+                if total_area > 0:
+                    weighted = sum(areas[i] * normals[i] for i in clusters[ci])
+                    mag = np.linalg.norm(weighted)
+                    if mag > 1e-12:
+                        cluster_normals[ci] = weighted / mag
+                placed = True
+                break
+
+        if not placed:
+            clusters.append([int(idx)])
+            cluster_normals.append(n.copy())
+
+    return clusters
+
+
+# ── Segment properties ────────────────────────────────────────────────────────
+
+def compute_segment_properties(
+    normals: np.ndarray,
+    areas: np.ndarray,
+    cluster_indices: list[int],
+    area_scale: float = 1.0,
+) -> dict:
+    """
+    Compute tilt, azimuth, and total area for one cluster of faces.
+
+    tilt:    degrees from horizontal (0° = flat, 90° = vertical)
+    azimuth: degrees clockwise from north (0° N, 90° E, 180° S, 270° W)
+             — in MODEL coordinates (true-north correction applied later)
+    area:    cluster area in m²
+
+    Returns dict with keys: area, tilt, azimuth.
+    """
+    idx = np.array(cluster_indices)
+    cluster_areas = areas[idx]
+    cluster_normals = normals[idx]
+
+    total_area = float(cluster_areas.sum()) * area_scale
+
+    # Area-weighted average normal
+    weighted = (cluster_normals.T * cluster_areas).T.sum(axis=0)
+    mag = np.linalg.norm(weighted)
+    if mag < 1e-12:
+        return {"area": total_area, "tilt": 0.0, "azimuth": 0.0}
+    avg_n = weighted / mag
+
+    # Tilt = arccos(nz)
+    tilt = math.degrees(math.acos(min(max(avg_n[2], -1.0), 1.0)))
+
+    # Azimuth = atan2(nx, ny) mod 360
+    # Convention: 0° = North (+Y), 90° = East (+X), 180° = South (-Y)
+    azimuth = math.degrees(math.atan2(avg_n[0], avg_n[1])) % 360.0
+
+    return {
+        "area": round(total_area, 2),
+        "tilt": round(tilt, 1),
+        "azimuth": round(azimuth, 1),
+    }
+
+
+# ── Main entry point ─────────────────────────────────────────────────────────
+
+def parse_roof_segments(
+    ifc_path: str | Path,
+    angle_tolerance: float = DEFAULT_ANGLE_TOLERANCE_DEG,
+    min_area: float = MIN_SEGMENT_AREA_M2,
+    apply_true_north: bool = True,
+) -> list[dict]:
+    """
+    Parse an IFC file and return a list of roof segments.
+
+    Each segment dict has keys: id, area, tilt, azimuth.
+
+    Parameters
+    ----------
+    ifc_path : path to the .ifc file
+    angle_tolerance : degrees — max normal deviation within a cluster
+    min_area : m² — ignore clusters smaller than this
+    apply_true_north : rotate azimuths by the model's TrueNorth angle
+
+    Returns
+    -------
+    list of dicts: [{"id": str, "area": float, "tilt": float, "azimuth": float}, ...]
+    """
+    ifc_path = Path(ifc_path)
+    log.info("Parsing roof geometry: %s", ifc_path.name)
+
+    try:
+        model = ifcopenshell.open(str(ifc_path))
+    except Exception as exc:
+        log.error("Cannot open %s: %s", ifc_path, exc)
+        return []
+
+    area_scale = get_area_scale(model)
+    # For geometry (vertex coordinates) we need the length scale squared
+    # because area = length². However ifcopenshell.geom with world-coords
+    # already applies the unit conversion, so we assume metres here.
+    # If models are in feet, the geom API still returns metres when
+    # USE_WORLD_COORDS is True.  We keep area_scale for the cross-validation
+    # with property-set values only.
+    geom_area_scale = 1.0  # world-coords are in metres
+
+    elements = get_roof_elements(model)
+    if not elements:
+        log.warning("  No roof elements found in %s", ifc_path.name)
+        return []
+
+    settings = _make_geom_settings()
+
+    # Collect all face normals + areas across all roof elements
+    all_normals: list[np.ndarray] = []
+    all_areas: list[np.ndarray] = []
+
+    for elem in elements:
+        geom_data = extract_geometry(elem, settings)
+        if geom_data is None:
+            continue
+        verts, faces = geom_data
+        normals, areas = compute_face_normals(verts, faces)
+        all_normals.append(normals)
+        all_areas.append(areas)
+
+    if not all_normals:
+        log.warning("  Could not extract geometry from any roof element in %s",
+                    ifc_path.name)
+        return []
+
+    normals = np.vstack(all_normals)
+    areas = np.concatenate(all_areas)
+
+    # Cluster faces by orientation
+    clusters = cluster_faces_by_normal(normals, areas, angle_tolerance)
+
+    # Build segment list
+    segments: list[dict] = []
+    seg_idx = 1
+    for cluster in clusters:
+        props = compute_segment_properties(normals, areas, cluster, geom_area_scale)
+        if props["area"] < min_area:
+            continue
+        props["id"] = f"Roof_Seg_{seg_idx:02d}"
+        segments.append(props)
+        seg_idx += 1
+
+    # ── True-north azimuth correction ─────────────────────────────────────
+    if apply_true_north and segments:
+        tn = extract_true_north(model)
+        if tn is not None and abs(tn) > 0.01 and abs(tn - 360.0) > 0.01:
+            log.info("  Applying true-north correction: %.2f°", tn)
+            for seg in segments:
+                seg["azimuth"] = round((seg["azimuth"] + tn) % 360.0, 1)
+
+    # ── Cross-validate against property-set roof area ─────────────────────
+    if segments:
+        geom_total = sum(s["area"] for s in segments)
+        pset_area = extract_roof_area(model)
+        if pset_area is not None and pset_area > 0:
+            diff_pct = abs(geom_total - pset_area) / pset_area * 100
+            if diff_pct > 20:
+                log.warning(
+                    "  Roof area mismatch: geometry=%.1f m², property-set=%.1f m² (%.0f%% diff)",
+                    geom_total, pset_area, diff_pct,
+                )
+            else:
+                log.info(
+                    "  Roof area validated: geometry=%.1f m², property-set=%.1f m² (%.0f%% diff)",
+                    geom_total, pset_area, diff_pct,
+                )
+
+    log.info("  Extracted %d roof segment(s) from %s", len(segments), ifc_path.name)
+    return segments

teams/lux-ai/Final pipeline/key_aliases.json

@@ -0,0 +1,3323 @@
+{
+  "window_area": [
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "Qto_WindowBaseQuantities",
+      "key": "Area"
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "Area"
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossArea"
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "attr",
+      "keys": [
+        "OverallHeight",
+        "OverallWidth"
+      ],
+      "op": "multiply"
+    }
+  ],
+  "floor_area": [
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "Qto_SpaceBaseQuantities",
+      "key": "NetFloorArea"
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "Qto_SpaceBaseQuantities",
+      "key": "GrossFloorArea"
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetFloorArea"
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossFloorArea"
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "GSA Space Areas",
+      "key": "GSA BIM Area"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "Qto_SlabBaseQuantities",
+      "key": "NetArea",
+      "predefined_type": "FLOOR"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetArea",
+      "predefined_type": "FLOOR"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossArea",
+      "predefined_type": "FLOOR"
+    }
+  ],
+  "roof_area": [
+    {
+      "entity": "IfcRoof",
+      "source": "qset",
+      "set_name": "Qto_RoofBaseQuantities",
+      "key": "NetArea"
+    },
+    {
+      "entity": "IfcRoof",
+      "source": "qset",
+      "set_name": "Qto_RoofBaseQuantities",
+      "key": "GrossArea"
+    },
+    {
+      "entity": "IfcRoof",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetArea"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "Qto_SlabBaseQuantities",
+      "key": "NetArea",
+      "predefined_type": "ROOF"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "Qto_SlabBaseQuantities",
+      "key": "GrossArea",
+      "predefined_type": "ROOF"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetArea",
+      "predefined_type": "ROOF"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossArea",
+      "predefined_type": "ROOF"
+    }
+  ],
+  "true_north_angle": [
+    {
+      "entity": "IfcGeometricRepresentationContext",
+      "source": "attr",
+      "key": "TrueNorth",
+      "note": "DirectionRatios (X,Y) → atan2(x,y) → compass bearing"
+    }
+  ],
+  "latitude": [
+    {
+      "entity": "IfcSite",
+      "source": "attr",
+      "key": "RefLatitude",
+      "note": "IfcCompoundPlaneAngleMeasure [deg,min,sec,microsec]"
+    }
+  ],
+  "longitude": [
+    {
+      "entity": "IfcSite",
+      "source": "attr",
+      "key": "RefLongitude",
+      "note": "IfcCompoundPlaneAngleMeasure [deg,min,sec,microsec]"
+    }
+  ],
+  "roof_slope": [
+    {
+      "entity": "IfcRoof",
+      "source": "pset",
+      "set_name": "Dimensions",
+      "key": "Slope",
+      "note": "Revit-exported roof slope in degrees"
+    },
+    {
+      "entity": "IfcRoof",
+      "source": "pset",
+      "set_name": "Abmessungen",
+      "key": "Neigung",
+      "note": "ArchiCAD German — roof slope"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "pset",
+      "set_name": "Dimensions",
+      "key": "Slope",
+      "predefined_type": "ROOF",
+      "note": "Revit-exported roof slab slope"
+    }
+  ],
+  "thermal_transmittance": [
+    {
+      "entity": "IfcRoof",
+      "source": "pset",
+      "set_name": "Pset_RoofCommon",
+      "key": "ThermalTransmittance",
+      "note": "U-value in W/(m²·K) — for energy modelling"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "pset",
+      "set_name": "Pset_SlabCommon",
+      "key": "ThermalTransmittance",
+      "predefined_type": "ROOF",
+      "note": "U-value for roof slabs"
+    },
+    {
+      "entity": "IfcWall",
+      "source": "pset",
+      "set_name": "Pset_WallCommon",
+      "key": "ThermalTransmittance",
+      "note": "U-value for walls — future energy modelling"
+    }
+  ],
+  "_auto_discovered_area_keys": [
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "F/T Oberfläche der Öffnung auf der Anschlagseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "F/T Oberfläche der Öffnung gegenüber der Anschlagseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominale T/F Öffnungsoberfläche auf der Anschlagsseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominale T/F Öffnungsoberfläche auf der Seite gegenüber der Anschlagsseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "T/F Öffnung Nominaler Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Nominal Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominal W/D Opening Surface Area on the Reveal Side",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominal W/D Opening Surface Area on the Side Opposite to the Reveal Side",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "Area",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "F/T Oberfläche der Öffnung auf der Anschlagseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "F/T Oberfläche der Öffnung gegenüber der Anschlagseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominale T/F Öffnungsoberfläche auf der Anschlagsseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominale T/F Öffnungsoberfläche auf der Seite gegenüber der Anschlagsseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "T/F Öffnung Nominaler Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Nominal Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Surface Area on the Reveal Side",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Surface Area on the Side Opposite to the Reveal Side",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominal W/D Opening Surface Area on the Reveal Side",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominal W/D Opening Surface Area on the Side Opposite to the Reveal Side",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "Qto_DoorBaseQuantities",
+      "key": "Area",
+      "file_count": 3,
+      "projects": [
+        "digital_hub",
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "GSA Space Areas",
+      "key": "GSA Space Areas",
+      "file_count": 1,
+      "projects": [
+        "samuel_macalister_sample_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "SpaceNetFloorAreaBOMA",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "SpaceUsableFloorAreaBOMA",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossCeilingArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetCeilingArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossWallArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetWallArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Berechnete Fläche (NRF)",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Türen-Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Stützenabzugsfläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Schraffurabzugsfläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Niedrige Abzugsfläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Wandabzugsfläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gemessene Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nettofläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Reduzierte Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Raumflächen Reduzierung",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gesamtabzugsfläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Heizkörpernische Oberflächenbereich hinten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Heizkörpernische Oberflächenbereich seitlich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Heizkörpernische Oberflächenbereich oben",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Wand-Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fenster-Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Calculated Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Measured Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Windows Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Doors Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Walls Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area Reducement",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Extracted Column Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Extracted Fill Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Extracted Low Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Extracted Wall Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Measured Net Area",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Reduced Area",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Total Extracted Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Wall Inset Back Side Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Wall Inset Side Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Wall Inset Top Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Extracted Curtain Wall Area",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "Qto_SpaceBaseQuantities",
+      "key": "GrossCeilingArea",
+      "file_count": 2,
+      "projects": [
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetFootprintArea",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich Unterseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich Oberseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Kante Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Löcher Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberfläche der Deckenoberseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Deckenunterseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Deckenkanten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich der Unterseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich der Oberseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Deckenoberseite mit Löchern",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Deckenunterseite mit Löchern",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Deckenkanten mit Löchern",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich Unterseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich Oberseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich der Kante",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich an der Unterseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich an der Oberseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Dachkanten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich unten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich oben",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der Öffnungen",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area (Conditional)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Conditional)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Top (Conditional)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Bottom (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Bottom (Gross, with holes)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Edges (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Edges (Gross, with holes)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Top (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Top (Gross, with holes)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Holes Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area of the Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area of the Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Bottom with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Edges",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Edges with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Top with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetFootprintArea",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcRoof",
+      "source": "qset",
+      "set_name": "Qto_RoofBaseQuantities",
+      "key": "ProjectedArea",
+      "file_count": 2,
+      "projects": [
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossFootprintArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetFootprintArea",
+      "file_count": 6,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossSideArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetSideArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an den Kanten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Wandoberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Wandoberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytische Oberfläche der Öffnungen an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytische Oberfläche der Öffnungen an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der Fenster in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der Türen in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der leeren Öffnungen in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Doors",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Windows",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Inside Face",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Outside Face",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Inside Face (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Outside Face (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Inside Face (Conditional)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Outside Face (Conditional)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Inside Face (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Outside Face (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of Empty Openings in the Wall",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Edges",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Inside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Outside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Inside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Outside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Inside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Outside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Wall",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "Qto_WallBaseQuantities",
+      "key": "GrossFootprintArea",
+      "file_count": 3,
+      "projects": [
+        "digital_hub",
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "Qto_WallBaseQuantities",
+      "key": "GrossSideArea",
+      "file_count": 3,
+      "projects": [
+        "digital_hub",
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "Qto_WallBaseQuantities",
+      "key": "NetSideArea",
+      "file_count": 3,
+      "projects": [
+        "digital_hub",
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetFootprintArea",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetSideAreaLeft",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetSideAreaRight",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossFootprintArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetFootprintArea",
+      "file_count": 4,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossSideArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetSideArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an den Kanten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Wandoberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Wandoberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytische Oberfläche der Öffnungen an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytische Oberfläche der Öffnungen an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der Fenster in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der Türen in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der leeren Öffnungen in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Doors",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Windows",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Edges",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Wall",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of Empty Openings in the Wall",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetFootprintArea",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetSideAreaLeft",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetSideAreaRight",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "Qto_CoveringBaseQuantities",
+      "key": "GrossArea",
+      "file_count": 1,
+      "projects": [
+        "digital_hub"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "Qto_CoveringBaseQuantities",
+      "key": "NetArea",
+      "file_count": 1,
+      "projects": [
+        "digital_hub"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossArea",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetArea",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Doors",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Windows",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Edges",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Wall",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of Empty Openings in the Wall",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area of the Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area of the Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Bottom with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Edges",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Edges with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Top with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Holes Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Column",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Core (without Top/Bottom)",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Core Top (or Bottom)",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Veneer (without Top/Bottom)",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Veneer Top (or Bottom)",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Core Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Core (without Top/Bottom)",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Core Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Veneer Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Veneer Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Veneer Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "End Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Holes Edge Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Left Side Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Right Side Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSite",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcBuilding",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossFloorArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcBuildingStorey",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossFloorArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    }
+  ]
+}

teams/lux-ai/Final pipeline/run_solar_analysis.py

@@ -0,0 +1,325 @@
+"""
+run_solar_analysis.py — Unified orchestrator.
+
+Modes
+-----
+1. Single-file solar analysis (default):
+       python -m solar_pipeline.run_solar_analysis  path/to/model.ifc
+
+2. Batch metadata scan (no API calls):
+       python -m solar_pipeline.run_solar_analysis --scan-only --root "Sample projects/projects"
+
+3. Batch solar analysis:
+       python -m solar_pipeline.run_solar_analysis --batch --root "Sample projects/projects"
+
+Location is auto-extracted from IfcSite.  Override with --lat / --lon / --name
+when the IFC file has no geographic coordinates.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+
+# ── Ensure package is importable when run as a script ─────────────────────────
+_SCRIPT_DIR = Path(__file__).resolve().parent
+_REPO_ROOT = _SCRIPT_DIR.parent
+if str(_REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(_REPO_ROOT))
+
+from solar_pipeline.config import (  # noqa: E402
+    DEFAULT_CONSUMPTION_KWH_PER_M2,
+    DEFAULT_SAMPLE_ROOT,
+    FALLBACK_CONSUMPTION_KWH,
+)
+from solar_pipeline.ifc_metadata_extractor import (  # noqa: E402
+    Location,
+    extract_all,
+    extract_floor_area,
+    extract_location,
+    extract_true_north,
+    find_ifc_files,
+    open_model,
+    print_summary_table,
+    scan_all,
+)
+from solar_pipeline.ifc_roof_parser import parse_roof_segments  # noqa: E402
+from solar_pipeline.solar_production_engine import run_production_analysis  # noqa: E402
+
+log = logging.getLogger(__name__)
+
+
+# ── Single-file solar analysis ────────────────────────────────────────────────
+
+def run_single(
+    ifc_path: Path,
+    lat: float | None = None,
+    lon: float | None = None,
+    name: str | None = None,
+) -> dict | None:
+    """
+    Full pipeline: IFC → metadata + roof geometry → PVWatts → report.
+
+    Returns the production-analysis result dict, or None on failure.
+    """
+    if not ifc_path.is_file():
+        print(f"[Error] IFC file not found: {ifc_path}")
+        return None
+
+    project = ifc_path.parent.name
+
+    # ── Step 1: Metadata extraction ───────────────────────────────────────
+    print("=" * 70)
+    print("  STEP 1 — Extracting IFC metadata")
+    print("=" * 70)
+
+    metadata = extract_all(ifc_path)
+    for key in ("window_area_m2", "floor_area_m2", "roof_area_m2",
+                "true_north_angle_deg", "latitude", "longitude"):
+        val = metadata.get(key)
+        label = key.replace("_", " ").title()
+        print(f"  {label:.<30s} {val if val is not None else 'N/A'}")
+
+    # ── Resolve location ──────────────────────────────────────────────────
+    if lat is not None and lon is not None:
+        location = Location(latitude=lat, longitude=lon, name=name or project)
+        print(f"\n  Location (CLI override): {location.latitude}, {location.longitude}")
+    elif metadata.get("latitude") is not None and metadata.get("longitude") is not None:
+        location = Location(
+            latitude=metadata["latitude"],
+            longitude=metadata["longitude"],
+            name=name or project,
+        )
+        print(f"\n  Location (auto from IfcSite): {location.latitude}, {location.longitude}")
+    else:
+        print("\n  [Error] No location available. Use --lat / --lon or provide an IFC file with IfcSite coordinates.")
+        return None
+
+    # ── Step 2: Roof geometry parsing ─────────────────────────────────────
+    print()
+    print("=" * 70)
+    print("  STEP 2 — Parsing roof geometry")
+    print("=" * 70)
+
+    segments = parse_roof_segments(ifc_path)
+    if not segments:
+        print("  No roof segments found. Cannot run solar analysis.")
+        return None
+
+    for seg in segments:
+        print(f"  {seg['id']}  |  Area: {seg['area']:>7.1f} m²  |  "
+              f"Tilt: {seg['tilt']:>5.1f}°  |  Azimuth: {seg['azimuth']:>5.1f}°")
+
+    # ── Step 3: Solar production analysis ─────────────────────────────────
+    print()
+    print("=" * 70)
+    print("  STEP 3 — Querying NREL PVWatts v8")
+    print("=" * 70)
+
+    result = run_production_analysis(segments=segments, location=location)
+
+    # ── Step 4: Summary & LEED estimate ───────────────────────────────────
+    print()
+    print("=" * 70)
+    print("  STEP 4 — Summary")
+    print("=" * 70)
+
+    total_kwh = result["total_kwh"]
+    total_area = sum(s["area"] for s in result["segments"])
+    print(f"  IFC file      : {ifc_path.name}")
+    print(f"  Project       : {project}")
+    print(f"  Location      : {location.name} ({location.latitude}, {location.longitude})")
+    print(f"  Segments      : {len(result['segments'])}")
+    print(f"  Total roof    : {total_area:,.2f} m²")
+    print(f"  Total prod.   : {total_kwh:,.2f} kWh/yr")
+
+    # LEED estimate — use floor area if available
+    floor_area = metadata.get("floor_area_m2")
+    if floor_area and floor_area > 0:
+        consumption = floor_area * DEFAULT_CONSUMPTION_KWH_PER_M2
+        print(f"\n  LEED estimate (floor area = {floor_area:,.1f} m² × "
+              f"{DEFAULT_CONSUMPTION_KWH_PER_M2} kWh/m²/yr):")
+    else:
+        consumption = FALLBACK_CONSUMPTION_KWH
+        print(f"\n  LEED estimate (assumed consumption = {consumption:,} kWh/yr):")
+
+    leed_pct = (total_kwh / consumption) * 100 if consumption > 0 else 0
+    print(f"    Consumption : {consumption:,.0f} kWh/yr")
+    print(f"    Production  : {total_kwh:,.0f} kWh/yr")
+    print(f"    Score       : {total_kwh:,.0f} / {consumption:,.0f} × 100 = {leed_pct:.1f}%")
+    print()
+
+    return result
+
+
+# ── Batch modes ───────────────────────────────────────────────────────────────
+
+def run_batch_scan(root: Path, output_csv: Path) -> list[dict]:
+    """Scan all IFC files and write metadata CSV (no API calls)."""
+    results = scan_all(root, output_csv)
+    print_summary_table(results)
+    return results
+
+
+def run_batch_solar(root: Path, output_csv: Path) -> None:
+    """
+    Scan all IFC files, then run solar analysis on each ``arc.ifc``
+    that has both roof elements and location data.
+    """
+    # First do the metadata scan
+    results = scan_all(root, output_csv)
+    print_summary_table(results)
+
+    # Then run solar on architectural files with location
+    print("\n" + "=" * 70)
+    print("  BATCH SOLAR ANALYSIS — processing arc.ifc files with location data")
+    print("=" * 70 + "\n")
+
+    solar_results: list[dict] = []
+    for r in results:
+        if r.get("error"):
+            continue
+        if r.get("latitude") is None or r.get("longitude") is None:
+            continue
+        # Only process architectural files
+        if r["ifc_file"] != "arc.ifc":
+            continue
+
+        ifc_path = root / r["project_name"] / r["ifc_file"]
+        if not ifc_path.is_file():
+            continue
+
+        print(f"\n--- {r['project_name']} ---")
+        try:
+            segments = parse_roof_segments(ifc_path)
+            if not segments:
+                print(f"  No roof segments — skipped")
+                continue
+
+            location = Location(
+                latitude=r["latitude"],
+                longitude=r["longitude"],
+                name=r["project_name"],
+            )
+            result = run_production_analysis(segments, location, verbose=True)
+            solar_results.append({
+                "project": r["project_name"],
+                "total_kwh": result["total_kwh"],
+                "segments": len(result["segments"]),
+                "roof_area_m2": sum(s["area"] for s in result["segments"]),
+            })
+        except Exception as exc:
+            log.warning("  Solar analysis failed for %s: %s", r["project_name"], exc)
+
+    if solar_results:
+        print("\n\n" + "=" * 70)
+        print("  BATCH SOLAR SUMMARY")
+        print("=" * 70)
+        for sr in solar_results:
+            print(f"  {sr['project']:.<30s} {sr['total_kwh']:>10,.0f} kWh/yr  "
+                  f"({sr['segments']} segs, {sr['roof_area_m2']:,.0f} m²)")
+        total = sum(sr["total_kwh"] for sr in solar_results)
+        print(f"\n  Grand total: {total:,.0f} kWh/yr across {len(solar_results)} buildings")
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="solar_pipeline",
+        description="Unified IFC metadata extraction + solar production analysis.",
+    )
+
+    # Modes (mutually exclusive)
+    mode = parser.add_mutually_exclusive_group()
+    mode.add_argument(
+        "--scan-only",
+        action="store_true",
+        help="Batch metadata scan only (no PVWatts API calls).",
+    )
+    mode.add_argument(
+        "--batch",
+        action="store_true",
+        help="Batch solar analysis of all arc.ifc files under --root.",
+    )
+
+    # Paths
+    parser.add_argument(
+        "ifc_file",
+        nargs="?",
+        type=Path,
+        default=None,
+        help="Path to a single IFC file (for single-file mode).",
+    )
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=DEFAULT_SAMPLE_ROOT,
+        help=f"Root directory for batch scanning (default: {DEFAULT_SAMPLE_ROOT}).",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=_REPO_ROOT / "ifc_scan_results.csv",
+        help="Output CSV file for batch scan results.",
+    )
+
+    # Location override
+    parser.add_argument("--lat", type=float, default=None, help="Site latitude (override IfcSite).")
+    parser.add_argument("--lon", type=float, default=None, help="Site longitude (override IfcSite).")
+    parser.add_argument("--name", type=str, default=None, help="Project name for report.")
+
+    return parser
+
+
+def main() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(levelname)-8s %(message)s",
+        handlers=[
+            logging.StreamHandler(),
+            logging.FileHandler(
+                _REPO_ROOT / "solar_pipeline.log", mode="w", encoding="utf-8",
+            ),
+        ],
+    )
+
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.scan_only:
+        # ── Batch metadata scan ───────────────────────────────────────────
+        if not args.root.exists():
+            print(f"[Error] Root directory not found: {args.root}")
+            sys.exit(1)
+        run_batch_scan(args.root, args.output)
+
+    elif args.batch:
+        # ── Batch solar analysis ──────────────────────────────────────────
+        if not args.root.exists():
+            print(f"[Error] Root directory not found: {args.root}")
+            sys.exit(1)
+        run_batch_solar(args.root, args.output)
+
+    else:
+        # ── Single-file solar analysis ────────────────────────────────────
+        if args.ifc_file is None:
+            parser.print_help()
+            print("\n[Error] Provide an IFC file path or use --scan-only / --batch.")
+            sys.exit(1)
+        result = run_single(
+            args.ifc_file,
+            lat=args.lat,
+            lon=args.lon,
+            name=args.name,
+        )
+        if result is None:
+            sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

teams/lux-ai/Final pipeline/solar_production_engine.py

@@ -0,0 +1,167 @@
+"""
+solar_production_engine.py — NREL PVWatts v8 API client.
+
+Calculates annual solar energy production (kWh) for roof segments.
+Each segment has its own tilt & azimuth, yielding per-orientation accuracy
+for LEED renewable-energy scoring.
+
+    LEED Score = (Σ Segment_kWh / Consumption_total) × 100
+
+Adapted from the original standalone engine to integrate with:
+    - ifc_metadata_extractor.py (auto location from IfcSite)
+    - ifc_roof_parser.py        (geometry-based roof segments)
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+
+import requests
+
+from solar_pipeline.config import (
+    ARRAY_TYPE,
+    MODULE_TYPE,
+    NREL_API_KEY,
+    PANEL_EFFICIENCY,
+    PVWATTS_BASE_URL,
+    SYSTEM_LOSSES,
+)
+from solar_pipeline.ifc_metadata_extractor import Location
+
+log = logging.getLogger(__name__)
+
+
+# ── Core calculation ──────────────────────────────────────────────────────────
+
+def calculate_segment_production(
+    area: float,
+    tilt: float,
+    azimuth: float,
+    location: Location,
+) -> float:
+    """
+    Query NREL PVWatts v8 for a single roof segment.
+
+    Parameters
+    ----------
+    area     : segment area in m²
+    tilt     : panel tilt in degrees from horizontal
+    azimuth  : compass bearing (180° = due south)
+    location : site coordinates
+
+    Returns
+    -------
+    float — annual AC production in kWh, or 0.0 on error.
+    """
+    system_capacity = area * PANEL_EFFICIENCY  # kW
+
+    params = {
+        "api_key": NREL_API_KEY,
+        "lat": location.latitude,
+        "lon": location.longitude,
+        "system_capacity": round(system_capacity, 3),
+        "azimuth": azimuth,
+        "tilt": tilt,
+        "array_type": ARRAY_TYPE,
+        "module_type": MODULE_TYPE,
+        "losses": SYSTEM_LOSSES,
+    }
+
+    try:
+        response = requests.get(PVWATTS_BASE_URL, params=params, timeout=30)
+        response.raise_for_status()
+        data = response.json()
+
+        if "errors" in data and data["errors"]:
+            log.error("  PVWatts API error: %s", data["errors"])
+            return 0.0
+
+        annual_kwh = float(data["outputs"]["ac_annual"])
+        return annual_kwh
+
+    except requests.RequestException as exc:
+        log.error("  PVWatts request failed: %s", exc)
+        return 0.0
+    except (KeyError, TypeError, ValueError) as exc:
+        log.error("  Could not parse PVWatts response: %s", exc)
+        return 0.0
+
+
+# ── Batch analysis ────────────────────────────────────────────────────────────
+
+def run_production_analysis(
+    segments: list[dict],
+    location: Location,
+    *,
+    rate_limit_sec: float = 1.0,
+    verbose: bool = True,
+) -> dict:
+    """
+    Iterate over roof segments, query PVWatts for each, return results.
+
+    Parameters
+    ----------
+    segments : list of dicts, each with keys: id, area, tilt, azimuth
+    location : site coordinates
+    rate_limit_sec : pause between API calls (NREL rate-limit)
+    verbose : print per-segment progress to stdout
+
+    Returns
+    -------
+    dict with keys:
+        segments  — list of per-segment result dicts (input + capacity_kw + annual_kwh)
+        total_kwh — total annual production (float)
+        location  — the Location used
+    """
+    total_kwh = 0.0
+    results: list[dict] = []
+
+    if verbose:
+        print(f"\n--- Analysing Roof Segments for {location.name} ---")
+        print(f"    Site: ({location.latitude}, {location.longitude})")
+        print(f"    Panel efficiency: {PANEL_EFFICIENCY}")
+        print()
+
+    for i, seg in enumerate(segments):
+        capacity_kw = seg["area"] * PANEL_EFFICIENCY
+        annual = calculate_segment_production(
+            seg["area"], seg["tilt"], seg["azimuth"], location,
+        )
+        total_kwh += annual
+
+        result = {
+            "id": seg["id"],
+            "area": seg["area"],
+            "tilt": seg["tilt"],
+            "azimuth": seg["azimuth"],
+            "capacity_kw": round(capacity_kw, 2),
+            "annual_kwh": round(annual, 2),
+        }
+        results.append(result)
+
+        if verbose:
+            print(
+                f"  {seg['id']:>15s}  |  "
+                f"Area: {seg['area']:>7.1f} m²  |  "
+                f"Tilt: {seg['tilt']:>5.1f}°  |  "
+                f"Azimuth: {seg['azimuth']:>5.1f}°  |  "
+                f"Capacity: {capacity_kw:>6.1f} kW  |  "
+                f"Yield: {annual:>10,.2f} kWh/yr"
+            )
+
+        # Respect NREL rate limits
+        if i < len(segments) - 1:
+            time.sleep(rate_limit_sec)
+
+    if verbose:
+        print()
+        print("-" * 70)
+        print(f"  TOTAL BUILDING PRODUCTION: {total_kwh:>12,.2f} kWh/yr")
+        print("-" * 70)
+
+    return {
+        "segments": results,
+        "total_kwh": round(total_kwh, 2),
+        "location": location,
+    }

teams/lux-ai/IFC key checker/discover_ifc_keys.py

@@ -0,0 +1,387 @@
+"""
+discover_ifc_keys.py
+Scans all IFC files and inventories every property set and quantity set
+name used per element type, producing:
+  - ifc_key_inventory.json  (raw: all keys found, with file counts)
+  - key_aliases.json         (canonical: standard key → all alias paths)
+
+Run:
+    .venv/Scripts/python.exe discover_ifc_keys.py
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections import defaultdict
+from pathlib import Path
+
+import ifcopenshell
+from tabulate import tabulate
+
+
+# ── Logging ───────────────────────────────────────────────────────────────────
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)-8s %(message)s",
+    handlers=[logging.StreamHandler()],
+)
+log = logging.getLogger(__name__)
+
+# ── Element types to inventory ────────────────────────────────────────────────
+
+TARGET_TYPES = [
+    "IfcWindow",
+    "IfcDoor",
+    "IfcSpace",
+    "IfcSlab",
+    "IfcRoof",
+    "IfcWall",
+    "IfcWallStandardCase",
+    "IfcCovering",
+    "IfcSite",
+    "IfcBuilding",
+    "IfcBuildingStorey",
+]
+
+# Keywords that flag a property/quantity as area-related for highlighting
+AREA_KEYWORDS = {"area", "fläche", "superficie", "superficie"}
+HEIGHT_KEYWORDS = {"height", "höhe", "width", "length", "depth", "perimeter"}
+ORIENTATION_KEYWORDS = {"north", "latitude", "longitude", "orientation", "azimuth"}
+
+
+# ── Inventory data structure ──────────────────────────────────────────────────
+#
+# global_inventory[element_type]["quantity_sets"][qset_name][qty_name]
+#   = {"file_count": int, "projects": [str, ...]}
+# global_inventory[element_type]["property_sets"][pset_name][prop_name]
+#   = {"file_count": int, "projects": [str, ...]}
+
+def _empty_entry() -> dict:
+    return {"file_count": 0, "projects": []}
+
+
+def make_inventory() -> dict:
+    return {
+        t: {"quantity_sets": defaultdict(lambda: defaultdict(_empty_entry)),
+            "property_sets": defaultdict(lambda: defaultdict(_empty_entry))}
+        for t in TARGET_TYPES
+    }
+
+
+# ── Per-element collection ────────────────────────────────────────────────────
+
+def collect_qsets(model: ifcopenshell.file, element_type: str) -> dict:
+    """
+    Returns {qset_name: {qty_name: count_in_this_file}} for all
+    instances of element_type in this model.
+    """
+    result: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+    for elem in model.by_type(element_type):
+        for rel in getattr(elem, "IsDefinedBy", []):
+            if not rel.is_a("IfcRelDefinesByProperties"):
+                continue
+            defn = rel.RelatingPropertyDefinition
+            if not defn.is_a("IfcElementQuantity"):
+                continue
+            qset_name = defn.Name or "(unnamed)"
+            for qty in defn.Quantities:
+                qty_name = qty.Name or "(unnamed)"
+                result[qset_name][qty_name] += 1
+    return result
+
+
+def collect_psets(model: ifcopenshell.file, element_type: str) -> dict:
+    """
+    Returns {pset_name: {prop_name: count_in_this_file}} for all
+    instances of element_type in this model.
+    """
+    result: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+    for elem in model.by_type(element_type):
+        for rel in getattr(elem, "IsDefinedBy", []):
+            if not rel.is_a("IfcRelDefinesByProperties"):
+                continue
+            defn = rel.RelatingPropertyDefinition
+            if not defn.is_a("IfcPropertySet"):
+                continue
+            pset_name = defn.Name or "(unnamed)"
+            for prop in getattr(defn, "HasProperties", []):
+                prop_name = getattr(prop, "Name", None) or "(unnamed)"
+                result[pset_name][prop_name] += 1
+    return result
+
+
+# ── Merge into global inventory ───────────────────────────────────────────────
+
+def merge_into(global_inv: dict, element_type: str, section: str,
+               file_data: dict, project_name: str) -> None:
+    """
+    Merge one file's {set_name: {key_name: count}} into the global inventory,
+    incrementing file_count and appending project_name.
+    """
+    target = global_inv[element_type][section]
+    for set_name, keys in file_data.items():
+        for key_name in keys:
+            entry = target[set_name][key_name]
+            entry["file_count"] += 1
+            if project_name not in entry["projects"]:
+                entry["projects"].append(project_name)
+
+
+# ── Serialisation helpers ─────────────────────────────────────────────────────
+
+def inventory_to_plain(global_inv: dict) -> dict:
+    """Convert defaultdict structure to plain dicts for JSON serialisation."""
+    out = {}
+    for etype, sections in global_inv.items():
+        out[etype] = {}
+        for section, sets in sections.items():
+            out[etype][section] = {}
+            for set_name, keys in sets.items():
+                out[etype][section][set_name] = {}
+                for key_name, entry in keys.items():
+                    out[etype][section][set_name][key_name] = {
+                        "file_count": entry["file_count"],
+                        "projects": sorted(entry["projects"]),
+                    }
+    return out
+
+
+# ── Build key_aliases.json ────────────────────────────────────────────────────
+
+def build_aliases(inventory: dict) -> dict:
+    """
+    Build the canonical key → alias-list mapping.
+    Each alias is tried in order; the first one that yields data wins.
+    Pre-seeds with known patterns, then extends with anything discovered
+    in the inventory that looks area-related but isn't already covered.
+    """
+    aliases: dict[str, list[dict]] = {
+        "window_area": [
+            {"entity": "IfcWindow", "source": "qset",
+             "set_name": "Qto_WindowBaseQuantities", "key": "Area"},
+            {"entity": "IfcWindow", "source": "qset",
+             "set_name": "BaseQuantities", "key": "Area"},
+            {"entity": "IfcWindow", "source": "qset",
+             "set_name": "BaseQuantities", "key": "GrossArea"},
+            {"entity": "IfcWindow", "source": "attr",
+             "keys": ["OverallHeight", "OverallWidth"], "op": "multiply"},
+        ],
+        "floor_area": [
+            {"entity": "IfcSpace", "source": "qset",
+             "set_name": "Qto_SpaceBaseQuantities", "key": "NetFloorArea"},
+            {"entity": "IfcSpace", "source": "qset",
+             "set_name": "Qto_SpaceBaseQuantities", "key": "GrossFloorArea"},
+            {"entity": "IfcSpace", "source": "qset",
+             "set_name": "BaseQuantities", "key": "NetFloorArea"},
+            {"entity": "IfcSpace", "source": "qset",
+             "set_name": "BaseQuantities", "key": "GrossFloorArea"},
+            {"entity": "IfcSpace", "source": "qset",
+             "set_name": "GSA Space Areas", "key": "GSA BIM Area"},
+            {"entity": "IfcSlab",  "source": "qset",
+             "set_name": "Qto_SlabBaseQuantities", "key": "NetArea",
+             "predefined_type": "FLOOR"},
+            {"entity": "IfcSlab",  "source": "qset",
+             "set_name": "BaseQuantities", "key": "NetArea",
+             "predefined_type": "FLOOR"},
+            {"entity": "IfcSlab",  "source": "qset",
+             "set_name": "BaseQuantities", "key": "GrossArea",
+             "predefined_type": "FLOOR"},
+        ],
+        "roof_area": [
+            {"entity": "IfcRoof", "source": "qset",
+             "set_name": "Qto_RoofBaseQuantities", "key": "NetArea"},
+            {"entity": "IfcRoof", "source": "qset",
+             "set_name": "Qto_RoofBaseQuantities", "key": "GrossArea"},
+            {"entity": "IfcRoof", "source": "qset",
+             "set_name": "BaseQuantities", "key": "NetArea"},
+            {"entity": "IfcSlab",  "source": "qset",
+             "set_name": "Qto_SlabBaseQuantities", "key": "NetArea",
+             "predefined_type": "ROOF"},
+            {"entity": "IfcSlab",  "source": "qset",
+             "set_name": "Qto_SlabBaseQuantities", "key": "GrossArea",
+             "predefined_type": "ROOF"},
+            {"entity": "IfcSlab",  "source": "qset",
+             "set_name": "BaseQuantities", "key": "NetArea",
+             "predefined_type": "ROOF"},
+            {"entity": "IfcSlab",  "source": "qset",
+             "set_name": "BaseQuantities", "key": "GrossArea",
+             "predefined_type": "ROOF"},
+        ],
+        "true_north_angle": [
+            {"entity": "IfcGeometricRepresentationContext",
+             "source": "attr", "key": "TrueNorth",
+             "note": "DirectionRatios (X,Y) → atan2(x,y) → compass bearing"},
+        ],
+        "latitude": [
+            {"entity": "IfcSite", "source": "attr", "key": "RefLatitude",
+             "note": "IfcCompoundPlaneAngleMeasure [deg,min,sec,microsec]"},
+        ],
+        "longitude": [
+            {"entity": "IfcSite", "source": "attr", "key": "RefLongitude",
+             "note": "IfcCompoundPlaneAngleMeasure [deg,min,sec,microsec]"},
+        ],
+    }
+
+    # Auto-extend: scan the inventory for any quantity set / property set
+    # entries that look area-related and are not already covered above.
+    already_covered: set[tuple] = set()
+    for canonical, alias_list in aliases.items():
+        for a in alias_list:
+            if a["source"] == "qset":
+                already_covered.add(
+                    (a["entity"], "quantity_sets", a["set_name"], a["key"])
+                )
+
+    auto_discovered: list[dict] = []
+    for etype, sections in inventory.items():
+        for set_name, keys in sections.get("quantity_sets", {}).items():
+            for key_name, entry in keys.items():
+                if entry["file_count"] == 0:
+                    continue
+                key_lower = key_name.lower()
+                is_area = any(kw in key_lower for kw in AREA_KEYWORDS)
+                if not is_area:
+                    continue
+                tag = (etype, "quantity_sets", set_name, key_name)
+                if tag in already_covered:
+                    continue
+                auto_discovered.append({
+                    "entity": etype,
+                    "source": "qset",
+                    "set_name": set_name,
+                    "key": key_name,
+                    "file_count": entry["file_count"],
+                    "projects": entry["projects"],
+                    "auto_discovered": True,
+                })
+
+    if auto_discovered:
+        aliases["_auto_discovered_area_keys"] = auto_discovered
+
+    return aliases
+
+
+# ── Console reporting ─────────────────────────────────────────────────────────
+
+def print_report(inventory: dict) -> None:
+    """Print a per-element-type summary table to the console."""
+    HIGHLIGHT = {"area", "fläche", "netfloorarea", "grossfloorarea",
+                 "netarea", "grossarea", "grossfootprintarea"}
+
+    for etype in TARGET_TYPES:
+        data = inventory.get(etype, {})
+        qsets = data.get("quantity_sets", {})
+        psets = data.get("property_sets", {})
+
+        if not qsets and not psets:
+            continue
+
+        print(f"\n{'='*70}")
+        print(f"  {etype}")
+        print(f"{'='*70}")
+
+        # Quantity sets
+        if qsets:
+            print("\n  QUANTITY SETS:")
+            rows = []
+            for set_name, keys in sorted(qsets.items()):
+                for key_name, entry in sorted(
+                    keys.items(),
+                    key=lambda x: -x[1]["file_count"]
+                ):
+                    flag = "*" if key_name.lower() in HIGHLIGHT else " "
+                    rows.append([
+                        flag,
+                        set_name,
+                        key_name,
+                        entry["file_count"],
+                        ", ".join(entry["projects"][:5]) +
+                        ("..." if len(entry["projects"]) > 5 else ""),
+                    ])
+            print(tabulate(
+                rows,
+                headers=["!", "QSet Name", "Quantity", "Files", "Projects"],
+                tablefmt="simple",
+            ))
+
+        # Property sets (condensed — just set name + count of unique props)
+        if psets:
+            print("\n  PROPERTY SETS (summary):")
+            rows = []
+            for set_name, keys in sorted(psets.items()):
+                max_files = max(e["file_count"] for e in keys.values())
+                rows.append([set_name, len(keys), max_files])
+            print(tabulate(
+                rows,
+                headers=["PSet Name", "# Props", "Max Files"],
+                tablefmt="simple",
+            ))
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    root = Path(__file__).parent / "Sample projects" / "projects"
+    ifc_files = sorted(root.rglob("*.ifc"))
+    log.info(f"Found {len(ifc_files)} IFC files")
+
+    global_inv = make_inventory()
+
+    for i, ifc_path in enumerate(ifc_files, 1):
+        project = ifc_path.parent.name
+        log.info(f"[{i}/{len(ifc_files)}] {project}/{ifc_path.name}")
+        try:
+            model = ifcopenshell.open(str(ifc_path))
+        except Exception as exc:
+            log.warning(f"  Cannot open: {exc}")
+            continue
+
+        for etype in TARGET_TYPES:
+            try:
+                qdata = collect_qsets(model, etype)
+                merge_into(global_inv, etype, "quantity_sets", qdata, project)
+            except Exception as exc:
+                log.debug(f"  qset {etype}: {exc}")
+
+            try:
+                pdata = collect_psets(model, etype)
+                merge_into(global_inv, etype, "property_sets", pdata, project)
+            except Exception as exc:
+                log.debug(f"  pset {etype}: {exc}")
+
+    # Serialise inventory
+    plain_inv = inventory_to_plain(global_inv)
+    inv_path = Path(__file__).parent / "ifc_key_inventory.json"
+    with open(inv_path, "w", encoding="utf-8") as f:
+        json.dump(plain_inv, f, indent=2, ensure_ascii=False)
+    log.info(f"Inventory written to: {inv_path}")
+
+    # Build and write alias map
+    aliases = build_aliases(plain_inv)
+    alias_path = Path(__file__).parent / "key_aliases.json"
+    with open(alias_path, "w", encoding="utf-8") as f:
+        json.dump(aliases, f, indent=2, ensure_ascii=False)
+    log.info(f"Alias map written to: {alias_path}")
+
+    # Print console report
+    print_report(plain_inv)
+
+    # Final summary
+    print(f"\n{'='*70}")
+    print("SUMMARY")
+    print(f"{'='*70}")
+    for etype in TARGET_TYPES:
+        qsets = plain_inv.get(etype, {}).get("quantity_sets", {})
+        psets = plain_inv.get(etype, {}).get("property_sets", {})
+        if qsets or psets:
+            total_qkeys = sum(len(v) for v in qsets.values())
+            total_pkeys = sum(len(v) for v in psets.values())
+            print(f"  {etype:<30} "
+                  f"{len(qsets)} qsets / {total_qkeys} qty-keys  |  "
+                  f"{len(psets)} psets / {total_pkeys} prop-keys")
+
+
+if __name__ == "__main__":
+    main()

teams/lux-ai/IFC key checker/key_aliases.json

@@ -0,0 +1,3275 @@
+{
+  "window_area": [
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "Qto_WindowBaseQuantities",
+      "key": "Area"
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "Area"
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossArea"
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "attr",
+      "keys": [
+        "OverallHeight",
+        "OverallWidth"
+      ],
+      "op": "multiply"
+    }
+  ],
+  "floor_area": [
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "Qto_SpaceBaseQuantities",
+      "key": "NetFloorArea"
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "Qto_SpaceBaseQuantities",
+      "key": "GrossFloorArea"
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetFloorArea"
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossFloorArea"
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "GSA Space Areas",
+      "key": "GSA BIM Area"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "Qto_SlabBaseQuantities",
+      "key": "NetArea",
+      "predefined_type": "FLOOR"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetArea",
+      "predefined_type": "FLOOR"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossArea",
+      "predefined_type": "FLOOR"
+    }
+  ],
+  "roof_area": [
+    {
+      "entity": "IfcRoof",
+      "source": "qset",
+      "set_name": "Qto_RoofBaseQuantities",
+      "key": "NetArea"
+    },
+    {
+      "entity": "IfcRoof",
+      "source": "qset",
+      "set_name": "Qto_RoofBaseQuantities",
+      "key": "GrossArea"
+    },
+    {
+      "entity": "IfcRoof",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetArea"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "Qto_SlabBaseQuantities",
+      "key": "NetArea",
+      "predefined_type": "ROOF"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "Qto_SlabBaseQuantities",
+      "key": "GrossArea",
+      "predefined_type": "ROOF"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetArea",
+      "predefined_type": "ROOF"
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossArea",
+      "predefined_type": "ROOF"
+    }
+  ],
+  "true_north_angle": [
+    {
+      "entity": "IfcGeometricRepresentationContext",
+      "source": "attr",
+      "key": "TrueNorth",
+      "note": "DirectionRatios (X,Y) → atan2(x,y) → compass bearing"
+    }
+  ],
+  "latitude": [
+    {
+      "entity": "IfcSite",
+      "source": "attr",
+      "key": "RefLatitude",
+      "note": "IfcCompoundPlaneAngleMeasure [deg,min,sec,microsec]"
+    }
+  ],
+  "longitude": [
+    {
+      "entity": "IfcSite",
+      "source": "attr",
+      "key": "RefLongitude",
+      "note": "IfcCompoundPlaneAngleMeasure [deg,min,sec,microsec]"
+    }
+  ],
+  "_auto_discovered_area_keys": [
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "F/T Oberfläche der Öffnung auf der Anschlagseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "F/T Oberfläche der Öffnung gegenüber der Anschlagseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominale T/F Öffnungsoberfläche auf der Anschlagsseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominale T/F Öffnungsoberfläche auf der Seite gegenüber der Anschlagsseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "T/F Öffnung Nominaler Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Nominal Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominal W/D Opening Surface Area on the Reveal Side",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominal W/D Opening Surface Area on the Side Opposite to the Reveal Side",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWindow",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "Area",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "F/T Oberfläche der Öffnung auf der Anschlagseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "F/T Oberfläche der Öffnung gegenüber der Anschlagseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominale T/F Öffnungsoberfläche auf der Anschlagsseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominale T/F Öffnungsoberfläche auf der Seite gegenüber der Anschlagsseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "T/F Öffnung Nominaler Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Nominal Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Surface Area on the Reveal Side",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "W/D Opening Surface Area on the Side Opposite to the Reveal Side",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominal W/D Opening Surface Area on the Reveal Side",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nominal W/D Opening Surface Area on the Side Opposite to the Reveal Side",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcDoor",
+      "source": "qset",
+      "set_name": "Qto_DoorBaseQuantities",
+      "key": "Area",
+      "file_count": 3,
+      "projects": [
+        "digital_hub",
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "GSA Space Areas",
+      "key": "GSA Space Areas",
+      "file_count": 1,
+      "projects": [
+        "samuel_macalister_sample_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "SpaceNetFloorAreaBOMA",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "SpaceUsableFloorAreaBOMA",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossCeilingArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetCeilingArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossWallArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetWallArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Berechnete Fläche (NRF)",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Türen-Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Stützenabzugsfläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Schraffurabzugsfläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Niedrige Abzugsfläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Wandabzugsfläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gemessene Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Nettofläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Reduzierte Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Raumflächen Reduzierung",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gesamtabzugsfläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Heizkörpernische Oberflächenbereich hinten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Heizkörpernische Oberflächenbereich seitlich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Heizkörpernische Oberflächenbereich oben",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Wand-Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fenster-Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Calculated Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Measured Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Windows Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Doors Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Walls Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area Reducement",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Extracted Column Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Extracted Fill Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Extracted Low Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Extracted Wall Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Measured Net Area",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Reduced Area",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Total Extracted Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Wall Inset Back Side Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Wall Inset Side Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Wall Inset Top Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Extracted Curtain Wall Area",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "Qto_SpaceBaseQuantities",
+      "key": "GrossCeilingArea",
+      "file_count": 2,
+      "projects": [
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSpace",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetFootprintArea",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich Unterseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich Oberseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Kante Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Löcher Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberfläche der Deckenoberseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Deckenunterseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Deckenkanten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich der Unterseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich der Oberseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Deckenoberseite mit Löchern",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Deckenunterseite mit Löchern",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Deckenkanten mit Löchern",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich Unterseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich Oberseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich der Kante",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich an der Unterseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich an der Oberseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Oberflächenbereich der Dachkanten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich unten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich oben",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der Öffnungen",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area (Conditional)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Conditional)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Top (Conditional)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Bottom (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Bottom (Gross, with holes)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Edges (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Edges (Gross, with holes)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Top (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Slab Top (Gross, with holes)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Holes Surface Area",
+      "file_count": 2,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area of the Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area of the Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Bottom with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Edges",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Edges with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Top with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSlab",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetFootprintArea",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcRoof",
+      "source": "qset",
+      "set_name": "Qto_RoofBaseQuantities",
+      "key": "ProjectedArea",
+      "file_count": 2,
+      "projects": [
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossFootprintArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetFootprintArea",
+      "file_count": 6,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossSideArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetSideArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an den Kanten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Wandoberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Wandoberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytische Oberfläche der Öffnungen an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytische Oberfläche der Öffnungen an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der Fenster in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der Türen in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der leeren Öffnungen in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Doors",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Windows",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Inside Face",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Outside Face",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Inside Face (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Outside Face (Net)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Inside Face (Conditional)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Outside Face (Conditional)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Inside Face (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of the Wall Outside Face (Gross)",
+      "file_count": 1,
+      "projects": [
+        "molio"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of Empty Openings in the Wall",
+      "file_count": 3,
+      "projects": [
+        "molio",
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Edges",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Inside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Outside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Inside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Outside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Inside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Outside Face",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Wall",
+      "file_count": 2,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "Qto_WallBaseQuantities",
+      "key": "GrossFootprintArea",
+      "file_count": 3,
+      "projects": [
+        "digital_hub",
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "Qto_WallBaseQuantities",
+      "key": "GrossSideArea",
+      "file_count": 3,
+      "projects": [
+        "digital_hub",
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "Qto_WallBaseQuantities",
+      "key": "NetSideArea",
+      "file_count": 3,
+      "projects": [
+        "digital_hub",
+        "fantasy_office_building_1",
+        "fantasy_office_building_2"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetFootprintArea",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetSideAreaLeft",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWall",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetSideAreaRight",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossFootprintArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetFootprintArea",
+      "file_count": 4,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossSideArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetSideArea",
+      "file_count": 5,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Netto-Oberflächenbereich an den Kanten",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Fläche der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Wandoberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Brutto-Wandoberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytische Oberfläche der Öffnungen an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytische Oberfläche der Öffnungen an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich an der Außenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Konditionaler Oberflächenbereich an der Innenseite",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der Fenster in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der Türen in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Oberflächenbereich der leeren Öffnungen in der Wand",
+      "file_count": 2,
+      "projects": [
+        "ac20",
+        "fzk_house"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Doors",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Windows",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Edges",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Wall",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of Empty Openings in the Wall",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetFootprintArea",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetSideAreaLeft",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcWallStandardCase",
+      "source": "qset",
+      "set_name": "(unnamed)",
+      "key": "NetSideAreaRight",
+      "file_count": 1,
+      "projects": [
+        "hitos"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "Qto_CoveringBaseQuantities",
+      "key": "GrossArea",
+      "file_count": 1,
+      "projects": [
+        "digital_hub"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "Qto_CoveringBaseQuantities",
+      "key": "NetArea",
+      "file_count": 1,
+      "projects": [
+        "digital_hub"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossArea",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "NetArea",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Doors",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Windows",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Analytic Surface Area of Openings on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Edges",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Inside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Wall on the Outside Face",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Wall",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Surface Area of Empty Openings in the Wall",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Bottom Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area of the Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Conditional Surface Area of the Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Edge Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Bottom with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Edges",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Edges with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Slab Top with Holes",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Holes Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Top Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Area of the Column",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Core (without Top/Bottom)",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Core Top (or Bottom)",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Veneer (without Top/Bottom)",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Gross Surface Area of the Veneer Top (or Bottom)",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Core Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Core (without Top/Bottom)",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Core Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Veneer Bottom",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Veneer Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Net Surface Area of the Veneer Top",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "End Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Holes Edge Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Left Side Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcCovering",
+      "source": "qset",
+      "set_name": "ArchiCADQuantities",
+      "key": "Right Side Surface Area",
+      "file_count": 1,
+      "projects": [
+        "sixty5"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcSite",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcBuilding",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossFloorArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    },
+    {
+      "entity": "IfcBuildingStorey",
+      "source": "qset",
+      "set_name": "BaseQuantities",
+      "key": "GrossFloorArea",
+      "file_count": 7,
+      "projects": [
+        "ac20",
+        "fzk_house",
+        "molio",
+        "sixty5",
+        "smiley_west"
+      ],
+      "auto_discovered": true
+    }
+  ]
+}

teams/lux-ai/Logs/ifc_scan.log

@@ -0,0 +1,74 @@
+INFO     Found 36 IFC file(s) under: C:\Users\LEGION\Documents\GitHub\Lux.Ai\Sample projects\projects
+INFO     [1/36] 4351/arc.ifc
+INFO       Schema: IFC2X3
+INFO     [2/36] ac20/arc.ifc
+INFO       Schema: IFC4
+INFO     [3/36] city_house_munich/arc.ifc
+INFO       Schema: IFC4X3
+INFO     [4/36] dental_clinic/arc.ifc
+INFO       Schema: IFC2X3
+INFO     [5/36] dental_clinic/mep.ifc
+INFO       Schema: IFC2X3
+INFO     [6/36] dental_clinic/str.ifc
+INFO       Schema: IFC2X3
+INFO     [7/36] digital_hub/arc.ifc
+INFO       Schema: IFC4
+INFO     [8/36] digital_hub/heating.ifc
+INFO       Schema: IFC4
+INFO     [9/36] digital_hub/plumbing.ifc
+INFO       Schema: IFC4
+INFO     [10/36] digital_hub/ventilation.ifc
+INFO       Schema: IFC4
+INFO     [11/36] duplex/arc.ifc
+INFO       Schema: IFC2X3
+INFO     [12/36] duplex/mep.ifc
+INFO       Schema: IFC2X3
+INFO     [13/36] ettenheim_gis/city.ifc
+INFO       Schema: IFC2X3
+INFO     [14/36] fantasy_hotel_1/arc.ifc
+INFO       Schema: IFC4
+INFO     [15/36] fantasy_hotel_2/arc.ifc
+INFO       Schema: IFC4
+INFO     [16/36] fantasy_office_building_1/arc.ifc
+INFO       Schema: IFC4
+INFO     [17/36] fantasy_office_building_2/arc.ifc
+INFO       Schema: IFC4
+INFO     [18/36] fantasy_office_building_3/arc.ifc
+INFO       Schema: IFC4
+INFO     [19/36] fantasy_residential_building_1/arc.ifc
+INFO       Schema: IFC4
+INFO     [20/36] fzk_house/arc.ifc
+INFO       Schema: IFC4
+INFO     [21/36] hitos/arc.ifc
+INFO       Schema: IFC2X3
+INFO     [22/36] molio/arc.ifc
+INFO       Schema: IFC2X3
+INFO     [23/36] samuel_macalister_sample_house/arc.ifc
+INFO       Schema: IFC4
+INFO     [24/36] samuel_macalister_sample_house/mep.ifc
+INFO       Schema: IFC4
+INFO     [25/36] schependomlaan/arc.ifc
+INFO       Schema: IFC2X3
+INFO     [26/36] sixty5/arc.ifc
+INFO       Schema: IFC2X3
+INFO     [27/36] sixty5/electrical.ifc
+INFO       Schema: IFC2X3
+INFO     [28/36] sixty5/facade.ifc
+INFO       Schema: IFC2X3
+INFO     [29/36] sixty5/kitchen.ifc
+INFO       Schema: IFC2X3
+INFO     [30/36] sixty5/plumbing.ifc
+INFO       Schema: IFC2X3
+INFO     [31/36] sixty5/str.ifc
+INFO       Schema: IFC2X3
+INFO     [32/36] sixty5/ventilation.ifc
+INFO       Schema: IFC2X3
+INFO     [33/36] smiley_west/arc.ifc
+INFO       Schema: IFC4
+INFO     [34/36] wbdg_office/arc.ifc
+INFO       Schema: IFC2X3
+INFO     [35/36] wbdg_office/mep.ifc
+INFO       Schema: IFC2X3
+INFO     [36/36] wbdg_office/str.ifc
+INFO       Schema: IFC2X3
+INFO     CSV written to: C:\Users\LEGION\Documents\GitHub\Lux.Ai\ifc_scan_results.csv

teams/lux-ai/Logs/ifc_scan_results.csv

@@ -0,0 +1,37 @@
+project_name,ifc_file,window_area_m2,floor_area_m2,roof_area_m2,true_north_angle_deg,latitude,longitude,error
+4351,arc.ifc,10.8697,,,,,,
+ac20,arc.ifc,309.5,1939.3839,688.7667,0.0,49.15,8.716667,
+city_house_munich,arc.ifc,29.5085,,,32.56,48.187378,11.47271,
+dental_clinic,arc.ifc,100.63,,,,42.358429,-71.059776,
+dental_clinic,mep.ifc,,,,,,,
+dental_clinic,str.ifc,,,,,42.358429,-71.059776,
+digital_hub,arc.ifc,375.0,2842.1215,,360.0,48.1376,11.57994,
+digital_hub,heating.ifc,,,,360.0,48.1376,11.57994,
+digital_hub,plumbing.ifc,,,,360.0,48.1376,11.57994,
+digital_hub,ventilation.ifc,,,,360.0,48.1376,11.57994,
+duplex,arc.ifc,65.9415,,,,41.8744,-87.6394,
+duplex,mep.ifc,,,,,41.8744,-87.6394,
+ettenheim_gis,city.ifc,725.9732,,,,,,
+fantasy_hotel_1,arc.ifc,58.7815,,,360.0,42.358723,-71.056763,
+fantasy_hotel_2,arc.ifc,400.305,,,360.0,42.358723,-71.056763,
+fantasy_office_building_1,arc.ifc,156.816,1257.0688,339.9228,360.0,48.139126,11.580186,
+fantasy_office_building_2,arc.ifc,142.91,716.0568,419.5723,360.0,48.1376,11.57994,
+fantasy_office_building_3,arc.ifc,984.96,,,360.0,48.148853,11.567998,
+fantasy_residential_building_1,arc.ifc,19.563,,,360.0,48.139126,11.580186,
+fzk_house,arc.ifc,23.1702,173.3424,165.1222,310.0,49.100435,8.436539,
+hitos,arc.ifc,1531.3183,,,360.0,69.666667,18.833333,
+molio,arc.ifc,,140.7827,,0.0,55.667574,12.619383,
+samuel_macalister_sample_house,arc.ifc,61.6407,,,323.0,42.213,-71.0335,
+samuel_macalister_sample_house,mep.ifc,,,,26.62,51.45,5.483333,
+schependomlaan,arc.ifc,,,,,,,
+sixty5,arc.ifc,4901.1499,0.0,,0.0,51.45,5.483333,
+sixty5,electrical.ifc,,,,360.0,42.387,-71.242,
+sixty5,facade.ifc,,,,0.0,51.45,5.483333,
+sixty5,kitchen.ifc,,,,270.0,0.0,0.0,
+sixty5,plumbing.ifc,,,,360.0,42.387,-71.242,
+sixty5,str.ifc,,34199.084,,360.0,42.387,-71.242,
+sixty5,ventilation.ifc,,,,360.0,42.387,-71.242,
+smiley_west,arc.ifc,95.9195,1821.1689,614.4088,147.5,49.033245,8.39098,
+wbdg_office,arc.ifc,124.5,,,,42.358429,-71.059776,
+wbdg_office,mep.ifc,,,,,42.358429,-71.059776,
+wbdg_office,str.ifc,,,,,42.358429,-71.059776,

teams/lux-ai/Logs/solar_pipeline.log

@@ -0,0 +1,6 @@
+INFO       Schema: IFC4
+INFO     Parsing roof geometry: arc.ifc
+INFO       Found 2 roof element(s) for geometry extraction
+INFO       Applying true-north correction: 310.00°
+INFO       Roof area validated: geometry=165.1 m², property-set=165.1 m² (0% diff)
+INFO       Extracted 2 roof segment(s) from arc.ifc

teams/lux-ai/Logs/solar_pipeline_scan.csv

@@ -0,0 +1,37 @@
+project_name,ifc_file,window_area_m2,floor_area_m2,roof_area_m2,true_north_angle_deg,latitude,longitude,error
+4351,arc.ifc,10.8697,7517.2622,,,,,
+ac20,arc.ifc,309.5,1939.3839,688.7667,0.0,49.15,8.716667,
+city_house_munich,arc.ifc,29.5085,,,32.56,48.187378,11.47271,
+dental_clinic,arc.ifc,100.63,6935.7986,,,42.358429,-71.059776,
+dental_clinic,mep.ifc,,,,,,,
+dental_clinic,str.ifc,,,,,42.358429,-71.059776,
+digital_hub,arc.ifc,375.0,2842.1215,,360.0,48.1376,11.57994,
+digital_hub,heating.ifc,,,,360.0,48.1376,11.57994,
+digital_hub,plumbing.ifc,,,,360.0,48.1376,11.57994,
+digital_hub,ventilation.ifc,,,,360.0,48.1376,11.57994,
+duplex,arc.ifc,65.9415,422.0466,,,41.8744,-87.6394,
+duplex,mep.ifc,,797.7923,,,41.8744,-87.6394,
+ettenheim_gis,city.ifc,725.9732,,,,,,
+fantasy_hotel_1,arc.ifc,58.7815,,,360.0,42.358723,-71.056763,
+fantasy_hotel_2,arc.ifc,400.305,,,360.0,42.358723,-71.056763,
+fantasy_office_building_1,arc.ifc,156.816,1257.0688,339.9228,360.0,48.139126,11.580186,
+fantasy_office_building_2,arc.ifc,142.91,716.0568,419.5723,360.0,48.1376,11.57994,
+fantasy_office_building_3,arc.ifc,984.96,,,360.0,48.148853,11.567998,
+fantasy_residential_building_1,arc.ifc,19.563,,,360.0,48.139126,11.580186,
+fzk_house,arc.ifc,23.1702,173.3424,165.1222,310.0,49.100435,8.436539,
+hitos,arc.ifc,1531.3183,,,360.0,69.666667,18.833333,
+molio,arc.ifc,,140.7827,,0.0,55.667574,12.619383,
+samuel_macalister_sample_house,arc.ifc,61.6407,,,323.0,42.213,-71.0335,
+samuel_macalister_sample_house,mep.ifc,,,,26.62,51.45,5.483333,
+schependomlaan,arc.ifc,,,,,,,
+sixty5,arc.ifc,,,,,,,<built-in function open> returned a result with an exception set
+sixty5,electrical.ifc,,,,,,,<built-in function open> returned a result with an exception set
+sixty5,facade.ifc,,,,0.0,51.45,5.483333,
+sixty5,kitchen.ifc,,,,270.0,0.0,0.0,
+sixty5,plumbing.ifc,,,,360.0,42.387,-71.242,
+sixty5,str.ifc,,33915.088,,360.0,42.387,-71.242,
+sixty5,ventilation.ifc,,,,,,,<built-in function open> returned a result with an exception set
+smiley_west,arc.ifc,95.9195,1821.1689,614.4088,147.5,49.033245,8.39098,
+wbdg_office,arc.ifc,124.5,3582.0077,,,42.358429,-71.059776,
+wbdg_office,mep.ifc,,7009.6301,,,42.358429,-71.059776,
+wbdg_office,str.ifc,,,,,42.358429,-71.059776,

teams/lux-ai/Lux ai tool/README.md

@@ -0,0 +1,101 @@
+# Lux.Ai — IFCore Platform Tool
+
+> Solar energy compliance checks for the IFCore platform.
+
+---
+
+## Repo Structure (IFCore Contract)
+
+```
+Lux ai tool/
+├── tools/
+│   └── checker_solar.py      ← 5 check_* functions (platform-scanned)
+├── final_pipeline/            ← bundled IFC parsing + solar engine
+│   ├── config.py
+│   ├── ifc_metadata_extractor.py
+│   ├── ifc_roof_parser.py
+│   ├── solar_production_engine.py
+│   └── key_aliases.json
+├── run.py                     ← CLI entry-point
+├── requirements.txt           ← team dependencies
+├── test_contract.py           ← contract validation tests
+└── README.md                  ← this file
+```
+
+The platform auto-discovers all `check_*` functions inside `tools/checker_*.py`.
+
+---
+
+## Quick Start
+
+```bash
+cd "Lux ai tool"
+pip install -r requirements.txt
+
+# Run all 5 checks on an IFC file
+python run.py path/to/model.ifc
+
+# Run specific checks only
+python run.py path/to/model.ifc --checks location building_areas roof_geometry
+
+# Override coordinates for solar / LEED checks
+python run.py path/to/model.ifc --lat 48.13 --lon 11.58
+
+# Export results to JSON
+python run.py path/to/model.ifc --output results.json
+
+# List available checks
+python run.py --list-checks
+```
+
+| Function | What it checks | Needs internet? |
+|----------|---------------|-----------------|
+| `check_location` | IfcSite has latitude + longitude | No |
+| `check_building_areas` | Window, floor, and roof area present | No |
+| `check_roof_geometry` | 3D roof segments extractable (tilt, azimuth, area) | No |
+| `check_solar_production` | PVWatts returns kWh/yr > 0 for each segment | **Yes** |
+| `check_leed_score` | LEED renewable-energy score ≥ 50% | **Yes** |
+
+---
+
+## Usage
+
+### Local testing
+
+```python
+import ifcopenshell
+from tools.checker_solar import check_location
+
+model = ifcopenshell.open("path/to/model.ifc")
+results = check_location(model)
+for r in results:
+    print(f"[{r['check_status'].upper()}] {r['element_name']}: {r['actual_value']} (req: {r['required_value']})")
+```
+
+### Contract validation
+
+```bash
+cd "Lux ai tool"
+python test_contract.py
+```
+
+---
+
+## Contract Compliance
+
+Every `check_*` function:
+
+- **First arg:** `model` (`ifcopenshell.file` object)
+- **Returns:** `list[dict]` — one dict per element
+- **Dict keys:** `element_id`, `element_type`, `element_name`, `element_name_long`, `check_status`, `actual_value`, `required_value`, `comment`, `log`
+- **Status values:** `pass`, `fail`, `warning`, `blocked`, `log`
+
+---
+
+## Dependencies
+
+This tool is fully self-contained. All `final_pipeline/` modules are bundled. Install with:
+
+```bash
+pip install ifcopenshell numpy requests
+```

teams/lux-ai/Lux ai tool/final_pipeline/__init__.py

@@ -0,0 +1,15 @@
+"""
+final_pipeline — Unified IFC metadata extraction + solar production analysis.
+
+Merges:
+  - IFC property-set/quantity-set metadata scanner (window, floor, roof area,
+    orientation, lat/lon) with multi-exporter alias fallback
+  - Geometry-based roof segment parser (per-face tilt & azimuth via 3D mesh)
+  - NREL PVWatts v8 solar production engine
+
+Supports single-file solar analysis and batch scanning of project directories.
+"""
+
+from final_pipeline.config import __version__
+
+__all__ = ["__version__"]