From 74aad3d9811398e4f9e202ec195ad078fa996e18 Mon Sep 17 00:00:00 2001
From: Rahul Agrawal <rahul.yeindia@gmail.com>
Date: Tue, 24 Feb 2026 09:32:23 +0000
Subject: [PATCH] =?UTF-8?q?feat:=20implement=206=20pending=20features=20?=
 =?UTF-8?q?=E2=80=94=20vision=20engine,=20global=20codes,=20change=20order?=
 =?UTF-8?q?s,=20IFC=20export,=20product=20matching,=20reconstruction?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Vision Engine: Dockerfile + docker-compose service (port 8010), remove floor-plan amber warning
- Global Building Codes: US IRC 2021, EU Eurocode, UK Building Regs JSON data + multi-jurisdiction compliance router/UI
- Change Orders: full dashboard page with summary cards, status filters, create/approve/reject, impact analysis
- IFC/BIM Export: ifcopenshell-based IFC4 writer, drawing pipeline integration, IFC download button
- Visual Product Matching: CLIP ViT-B/32 embedder, pgvector indexer/searcher, VLM reranker, orchestration pipeline
- Photo-to-3D Reconstruction: tRPC router, vision-engine backend with VLM depth estimation + glTF mesh, full UI page

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../project/[id]/change-orders/page.tsx       | 491 ++++++++++++++++++
 .../project/[id]/compliance/page.tsx          |  34 +-
 .../project/[id]/drawings/page.tsx            |  16 +-
 .../project/[id]/floor-plan/page.tsx          |   7 -
 .../project/[id]/reconstruction/page.tsx      | 412 +++++++++++++++
 apps/web/src/components/sidebar.tsx           |   4 +
 .../web/src/server/trpc/routers/compliance.ts |  50 +-
 apps/web/src/server/trpc/routers/index.ts     |   4 +
 .../src/server/trpc/routers/reconstruction.ts | 105 ++++
 apps/web/src/server/trpc/routers/schedule.ts  |  37 ++
 data/building-codes/eu-eurocode.json          | 197 +++++++
 data/building-codes/uk-building-regs.json     | 197 +++++++
 data/building-codes/us-irc.json               | 262 ++++++++++
 docker-compose.yml                            |  31 ++
 .../openlintel_product_matching/embedder.py   | 218 ++++++++
 .../openlintel_product_matching/indexer.py    | 137 +++++
 .../openlintel_product_matching/pipeline.py   | 240 +++++++++
 .../openlintel_product_matching/reranker.py   | 208 ++++++++
 .../openlintel_product_matching/schemas.py    |  68 +++
 .../openlintel_product_matching/searcher.py   | 228 ++++++++
 packages/db/src/schema/app.ts                 |   1 +
 .../src/openlintel_shared/job_worker.py       |   8 +-
 .../src/services/vector_search.py             |  44 ++
 services/drawing-generator/pyproject.toml     |   1 +
 .../drawing-generator/src/routers/drawings.py |  16 +
 .../src/services/ifc_writer.py                | 292 +++++++++++
 services/vision-engine/Dockerfile             |  33 ++
 services/vision-engine/main.py                |   2 +
 .../src/routers/reconstruction.py             | 408 +++++++++++++++
 29 files changed, 3722 insertions(+), 29 deletions(-)
 create mode 100644 apps/web/src/app/(dashboard)/project/[id]/change-orders/page.tsx
 create mode 100644 apps/web/src/app/(dashboard)/project/[id]/reconstruction/page.tsx
 create mode 100644 apps/web/src/server/trpc/routers/reconstruction.ts
 create mode 100644 data/building-codes/eu-eurocode.json
 create mode 100644 data/building-codes/uk-building-regs.json
 create mode 100644 data/building-codes/us-irc.json
 create mode 100644 ml/product-matching/src/openlintel_product_matching/embedder.py
 create mode 100644 ml/product-matching/src/openlintel_product_matching/indexer.py
 create mode 100644 ml/product-matching/src/openlintel_product_matching/pipeline.py
 create mode 100644 ml/product-matching/src/openlintel_product_matching/reranker.py
 create mode 100644 ml/product-matching/src/openlintel_product_matching/schemas.py
 create mode 100644 ml/product-matching/src/openlintel_product_matching/searcher.py
 create mode 100644 services/drawing-generator/src/services/ifc_writer.py
 create mode 100644 services/vision-engine/Dockerfile
 create mode 100644 services/vision-engine/src/routers/reconstruction.py

diff --git a/apps/web/src/app/(dashboard)/project/[id]/change-orders/page.tsx b/apps/web/src/app/(dashboard)/project/[id]/change-orders/page.tsx
new file mode 100644
index 0000000..a1d20a1
--- /dev/null
+++ b/apps/web/src/app/(dashboard)/project/[id]/change-orders/page.tsx
@@ -0,0 +1,491 @@
+'use client';
+
+import { use, useState } from 'react';
+import { trpc } from '@/lib/trpc/client';
+import {
+  Button,
+  Card,
+  CardHeader,
+  CardTitle,
+  CardDescription,
+  CardContent,
+  Badge,
+  Skeleton,
+  Dialog,
+  DialogTrigger,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogDescription,
+  DialogFooter,
+  Input,
+  Label,
+  Textarea,
+  toast,
+} from '@openlintel/ui';
+import {
+  FileEdit,
+  Plus,
+  Loader2,
+  CheckCircle2,
+  XCircle,
+  Clock,
+  DollarSign,
+  CalendarDays,
+  AlertCircle,
+  TrendingUp,
+} from 'lucide-react';
+
+/* ─── Constants ─────────────────────────────────────────────── */
+
+const STATUS_COLORS: Record<string, string> = {
+  pending: 'bg-yellow-100 text-yellow-800',
+  approved: 'bg-green-100 text-green-800',
+  rejected: 'bg-red-100 text-red-800',
+};
+
+type StatusFilter = 'all' | 'pending' | 'approved' | 'rejected';
+
+function formatDate(date: string | Date): string {
+  return new Date(date).toLocaleDateString('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+  });
+}
+
+function formatCurrency(amount: number): string {
+  return new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0,
+  }).format(amount);
+}
+
+/* ─── Page Component ────────────────────────────────────────── */
+
+export default function ChangeOrdersPage({ params }: { params: Promise<{ id: string }> }) {
+  const { id: projectId } = use(params);
+  const utils = trpc.useUtils();
+
+  const [statusFilter, setStatusFilter] = useState<StatusFilter>('all');
+  const [dialogOpen, setDialogOpen] = useState(false);
+  const [title, setTitle] = useState('');
+  const [description, setDescription] = useState('');
+  const [costImpact, setCostImpact] = useState('');
+  const [timeImpactDays, setTimeImpactDays] = useState('');
+
+  /* ── Queries ──────────────────────────────────────────────── */
+  const { data: changeOrders = [], isLoading } = trpc.schedule.listChangeOrders.useQuery({ projectId });
+
+  /* ── Mutations ────────────────────────────────────────────── */
+  const createChangeOrder = trpc.schedule.createChangeOrder.useMutation({
+    onSuccess: () => {
+      utils.schedule.listChangeOrders.invalidate();
+      setDialogOpen(false);
+      resetForm();
+      toast({ title: 'Change order created', description: 'The change order has been submitted.' });
+    },
+    onError: (err) => {
+      toast({ title: 'Failed to create change order', description: err.message, variant: 'destructive' });
+    },
+  });
+
+  const updateChangeOrder = trpc.schedule.updateChangeOrder.useMutation({
+    onSuccess: () => {
+      utils.schedule.listChangeOrders.invalidate();
+      toast({ title: 'Change order updated' });
+    },
+    onError: (err) => {
+      toast({ title: 'Failed to update change order', description: err.message, variant: 'destructive' });
+    },
+  });
+
+  const analyzeImpact = trpc.schedule.analyzeChangeOrderImpact.useMutation({
+    onSuccess: (data) => {
+      toast({ title: 'Impact analysis complete', description: data.summary || 'Analysis returned.' });
+    },
+    onError: (err) => {
+      toast({ title: 'Impact analysis failed', description: err.message, variant: 'destructive' });
+    },
+  });
+
+  /* ── Form helpers ─────────────────────────────────────────── */
+  function resetForm() {
+    setTitle('');
+    setDescription('');
+    setCostImpact('');
+    setTimeImpactDays('');
+  }
+
+  function handleCreate() {
+    if (!title) return;
+    createChangeOrder.mutate({
+      projectId,
+      title,
+      description: description || undefined,
+      costImpact: costImpact ? parseFloat(costImpact) : undefined,
+      timeImpactDays: timeImpactDays ? parseInt(timeImpactDays, 10) : undefined,
+    });
+  }
+
+  /* ── Derived data ─────────────────────────────────────────── */
+  const filtered = statusFilter === 'all'
+    ? changeOrders
+    : changeOrders.filter((co: any) => co.status === statusFilter);
+
+  const totalCount = changeOrders.length;
+  const pendingCount = changeOrders.filter((co: any) => co.status === 'pending').length;
+  const approvedOrders = changeOrders.filter((co: any) => co.status === 'approved');
+  const approvedCostImpact = approvedOrders.reduce((sum: number, co: any) => sum + (co.costImpact || 0), 0);
+  const approvedTimeImpact = approvedOrders.reduce((sum: number, co: any) => sum + (co.timeImpactDays || 0), 0);
+
+  /* ── Loading state ────────────────────────────────────────── */
+  if (isLoading) {
+    return (
+      <div className="space-y-4">
+        <Skeleton className="h-8 w-56" />
+        <Skeleton className="h-4 w-72" />
+        <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-4">
+          {[1, 2, 3, 4].map((i) => (
+            <Skeleton key={i} className="h-24" />
+          ))}
+        </div>
+        <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
+          {[1, 2, 3].map((i) => (
+            <Skeleton key={i} className="h-48" />
+          ))}
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div>
+      {/* ── Header ──────────────────────────────────────────── */}
+      <div className="mb-6 flex items-center justify-between">
+        <div className="flex items-center gap-3">
+          <FileEdit className="h-6 w-6 text-primary" />
+          <div>
+            <h1 className="text-2xl font-bold tracking-tight">Change Orders</h1>
+            <p className="text-sm text-muted-foreground">
+              Track scope changes, cost impacts, and schedule adjustments.
+            </p>
+          </div>
+        </div>
+      </div>
+
+      {/* ── Summary Cards ───────────────────────────────────── */}
+      <div className="mb-6 grid gap-4 sm:grid-cols-2 lg:grid-cols-4">
+        <Card>
+          <CardContent className="pt-6">
+            <div className="flex items-center justify-between">
+              <div>
+                <p className="text-sm text-muted-foreground">Total Orders</p>
+                <p className="text-2xl font-bold">{totalCount}</p>
+              </div>
+              <FileEdit className="h-8 w-8 text-muted-foreground" />
+            </div>
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardContent className="pt-6">
+            <div className="flex items-center justify-between">
+              <div>
+                <p className="text-sm text-muted-foreground">Pending</p>
+                <p className="text-2xl font-bold text-yellow-600">{pendingCount}</p>
+              </div>
+              <Clock className="h-8 w-8 text-yellow-400" />
+            </div>
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardContent className="pt-6">
+            <div className="flex items-center justify-between">
+              <div>
+                <p className="text-sm text-muted-foreground">Approved Cost Impact</p>
+                <p className="text-2xl font-bold text-green-600">
+                  {formatCurrency(approvedCostImpact)}
+                </p>
+              </div>
+              <DollarSign className="h-8 w-8 text-green-400" />
+            </div>
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardContent className="pt-6">
+            <div className="flex items-center justify-between">
+              <div>
+                <p className="text-sm text-muted-foreground">Approved Time Impact</p>
+                <p className="text-2xl font-bold text-blue-600">
+                  {approvedTimeImpact} days
+                </p>
+              </div>
+              <CalendarDays className="h-8 w-8 text-blue-400" />
+            </div>
+          </CardContent>
+        </Card>
+      </div>
+
+      {/* ── Status Filter Tabs ──────────────────────────────── */}
+      <div className="mb-6 flex items-center justify-between">
+        <div className="flex items-center gap-1 rounded-lg border bg-muted/50 p-1">
+          {(['all', 'pending', 'approved', 'rejected'] as const).map((status) => (
+            <button
+              key={status}
+              onClick={() => setStatusFilter(status)}
+              className={`rounded-md px-4 py-2 text-sm font-medium transition-colors ${
+                statusFilter === status
+                  ? 'bg-background text-foreground shadow-sm'
+                  : 'text-muted-foreground hover:text-foreground'
+              }`}
+            >
+              {status === 'all' ? 'All' : status.charAt(0).toUpperCase() + status.slice(1)}
+            </button>
+          ))}
+        </div>
+
+        <Dialog open={dialogOpen} onOpenChange={setDialogOpen}>
+          <DialogTrigger asChild>
+            <Button size="sm">
+              <Plus className="mr-1 h-4 w-4" />
+              New Change Order
+            </Button>
+          </DialogTrigger>
+          <DialogContent className="max-w-lg">
+            <DialogHeader>
+              <DialogTitle>New Change Order</DialogTitle>
+              <DialogDescription>
+                Submit a change order to track scope, cost, and timeline changes.
+              </DialogDescription>
+            </DialogHeader>
+            <div className="space-y-4 py-4">
+              <div className="space-y-2">
+                <Label htmlFor="coTitle">Title</Label>
+                <Input
+                  id="coTitle"
+                  placeholder="e.g. Upgrade kitchen countertop to granite"
+                  value={title}
+                  onChange={(e) => setTitle(e.target.value)}
+                />
+              </div>
+              <div className="space-y-2">
+                <Label htmlFor="coDescription">Description</Label>
+                <Textarea
+                  id="coDescription"
+                  placeholder="Describe the change and its rationale..."
+                  rows={3}
+                  value={description}
+                  onChange={(e) => setDescription(e.target.value)}
+                />
+              </div>
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="coCost">Cost Impact ($)</Label>
+                  <Input
+                    id="coCost"
+                    type="number"
+                    placeholder="e.g. 5000"
+                    value={costImpact}
+                    onChange={(e) => setCostImpact(e.target.value)}
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="coTime">Time Impact (days)</Label>
+                  <Input
+                    id="coTime"
+                    type="number"
+                    placeholder="e.g. 3"
+                    value={timeImpactDays}
+                    onChange={(e) => setTimeImpactDays(e.target.value)}
+                  />
+                </div>
+              </div>
+            </div>
+            <DialogFooter>
+              <Button variant="outline" onClick={() => setDialogOpen(false)}>
+                Cancel
+              </Button>
+              <Button
+                onClick={handleCreate}
+                disabled={createChangeOrder.isPending || !title}
+              >
+                {createChangeOrder.isPending ? (
+                  <>
+                    <Loader2 className="mr-1 h-4 w-4 animate-spin" />
+                    Creating...
+                  </>
+                ) : (
+                  'Create Order'
+                )}
+              </Button>
+            </DialogFooter>
+          </DialogContent>
+        </Dialog>
+      </div>
+
+      {/* ── Change Order Cards ──────────────────────────────── */}
+      {filtered.length > 0 ? (
+        <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
+          {filtered.map((co: any) => (
+            <Card key={co.id} className="relative">
+              <CardHeader className="pb-3">
+                <div className="flex items-start justify-between">
+                  <div className="flex-1 min-w-0">
+                    <CardTitle className="text-base truncate">{co.title}</CardTitle>
+                    <CardDescription className="mt-0.5">
+                      Created {formatDate(co.createdAt)}
+                    </CardDescription>
+                  </div>
+                  <Badge className={`ml-2 flex-shrink-0 text-[10px] ${STATUS_COLORS[co.status] || ''}`}>
+                    {co.status}
+                  </Badge>
+                </div>
+              </CardHeader>
+              <CardContent className="space-y-3">
+                {co.description && (
+                  <p className="text-sm text-muted-foreground line-clamp-2">{co.description}</p>
+                )}
+
+                {/* Impact badges */}
+                <div className="flex flex-wrap gap-2">
+                  {co.costImpact != null && (
+                    <div className="flex items-center gap-1 rounded-full bg-muted px-2.5 py-1 text-xs font-medium">
+                      <DollarSign className="h-3 w-3" />
+                      {formatCurrency(co.costImpact)}
+                    </div>
+                  )}
+                  {co.timeImpactDays != null && (
+                    <div className="flex items-center gap-1 rounded-full bg-muted px-2.5 py-1 text-xs font-medium">
+                      <CalendarDays className="h-3 w-3" />
+                      {co.timeImpactDays} days
+                    </div>
+                  )}
+                </div>
+
+                {/* Metadata */}
+                <div className="rounded-lg bg-muted/50 p-2.5">
+                  <div className="flex items-center justify-between text-xs">
+                    <span className="text-muted-foreground">Created</span>
+                    <span className="font-medium">{formatDate(co.createdAt)}</span>
+                  </div>
+                  {co.approvedAt && (
+                    <div className="flex items-center justify-between text-xs mt-1">
+                      <span className="text-muted-foreground">Approved</span>
+                      <span className="font-medium text-green-600">{formatDate(co.approvedAt)}</span>
+                    </div>
+                  )}
+                  {co.approvedBy && (
+                    <div className="flex items-center justify-between text-xs mt-1">
+                      <span className="text-muted-foreground">Approved By</span>
+                      <span className="font-medium">{co.approvedBy}</span>
+                    </div>
+                  )}
+                </div>
+
+                {/* Actions */}
+                <div className="flex items-center gap-2 pt-1">
+                  {co.status === 'pending' && (
+                    <>
+                      <Button
+                        variant="outline"
+                        size="sm"
+                        className="flex-1 border-green-200 text-green-700 hover:bg-green-50"
+                        disabled={updateChangeOrder.isPending}
+                        onClick={() => updateChangeOrder.mutate({ id: co.id, status: 'approved' })}
+                      >
+                        <CheckCircle2 className="mr-1 h-3.5 w-3.5" />
+                        Approve
+                      </Button>
+                      <Button
+                        variant="outline"
+                        size="sm"
+                        className="flex-1 border-red-200 text-red-700 hover:bg-red-50"
+                        disabled={updateChangeOrder.isPending}
+                        onClick={() => updateChangeOrder.mutate({ id: co.id, status: 'rejected' })}
+                      >
+                        <XCircle className="mr-1 h-3.5 w-3.5" />
+                        Reject
+                      </Button>
+                    </>
+                  )}
+                  {co.status === 'pending' && (
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      disabled={analyzeImpact.isPending}
+                      onClick={() => analyzeImpact.mutate({ id: co.id })}
+                    >
+                      {analyzeImpact.isPending ? (
+                        <Loader2 className="h-4 w-4 animate-spin" />
+                      ) : (
+                        <TrendingUp className="h-4 w-4" />
+                      )}
+                    </Button>
+                  )}
+                  {co.status === 'approved' && (
+                    <div className="flex flex-1 items-center gap-1.5 text-xs text-green-600">
+                      <CheckCircle2 className="h-4 w-4" />
+                      Approved
+                    </div>
+                  )}
+                  {co.status === 'rejected' && (
+                    <div className="flex flex-1 items-center gap-1.5 text-xs text-red-600">
+                      <XCircle className="h-4 w-4" />
+                      Rejected
+                    </div>
+                  )}
+                </div>
+              </CardContent>
+            </Card>
+          ))}
+        </div>
+      ) : (
+        <Card className="flex flex-col items-center justify-center p-12 text-center">
+          <FileEdit className="mb-4 h-12 w-12 text-muted-foreground" />
+          <h2 className="mb-2 text-lg font-semibold">No Change Orders</h2>
+          <p className="text-sm text-muted-foreground mb-4">
+            Create change orders to track scope changes, cost impacts, and schedule adjustments.
+          </p>
+          <Button size="sm" onClick={() => setDialogOpen(true)}>
+            <Plus className="mr-1 h-4 w-4" />
+            New Change Order
+          </Button>
+        </Card>
+      )}
+
+      {/* ── Impact Analysis Section ─────────────────────────── */}
+      {approvedOrders.length > 0 && (
+        <div className="mt-8">
+          <h2 className="mb-4 text-lg font-semibold">Impact Summary</h2>
+          <div className="grid gap-4 sm:grid-cols-3">
+            <Card>
+              <CardContent className="pt-6 text-center">
+                <p className="text-2xl font-bold">{approvedOrders.length}</p>
+                <p className="text-xs text-muted-foreground">Approved Changes</p>
+              </CardContent>
+            </Card>
+            <Card>
+              <CardContent className="pt-6 text-center">
+                <p className={`text-2xl font-bold ${approvedCostImpact >= 0 ? 'text-red-600' : 'text-green-600'}`}>
+                  {formatCurrency(approvedCostImpact)}
+                </p>
+                <p className="text-xs text-muted-foreground">Total Cost Impact</p>
+              </CardContent>
+            </Card>
+            <Card>
+              <CardContent className="pt-6 text-center">
+                <p className="text-2xl font-bold text-blue-600">{approvedTimeImpact} days</p>
+                <p className="text-xs text-muted-foreground">Total Time Impact</p>
+              </CardContent>
+            </Card>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/web/src/app/(dashboard)/project/[id]/compliance/page.tsx b/apps/web/src/app/(dashboard)/project/[id]/compliance/page.tsx
index 38a1284..172a23e 100644
--- a/apps/web/src/app/(dashboard)/project/[id]/compliance/page.tsx
+++ b/apps/web/src/app/(dashboard)/project/[id]/compliance/page.tsx
@@ -12,6 +12,11 @@ import {
   Tabs,
   TabsList,
   TabsTrigger,
+  Select,
+  SelectTrigger,
+  SelectValue,
+  SelectContent,
+  SelectItem,
 } from '@openlintel/ui';
 import {
   ShieldCheck,
@@ -43,10 +48,13 @@ export default function CompliancePage({ params }: { params: Promise<{ id: strin
   const { id: projectId } = use(params);
   const [expandedRooms, setExpandedRooms] = useState<Set<string>>(new Set());
   const [selectedCategory, setSelectedCategory] = useState<string>('all');
+  const [jurisdiction, setJurisdiction] = useState<string>('IN');
+
+  const { data: jurisdictions } = trpc.compliance.listJurisdictions.useQuery();
 
   const { data: report, isLoading } = trpc.compliance.checkProject.useQuery({
     projectId,
-    jurisdiction: 'IN',
+    jurisdiction,
   });
 
   const toggleRoom = (roomId: string) => {
@@ -88,11 +96,25 @@ export default function CompliancePage({ params }: { params: Promise<{ id: strin
   return (
     <div>
       {/* Header */}
-      <div className="mb-6">
-        <h1 className="text-2xl font-bold tracking-tight">Compliance Report</h1>
-        <p className="text-sm text-muted-foreground">
-          Building code compliance check against Indian NBC 2016 standards.
-        </p>
+      <div className="mb-6 flex items-start justify-between">
+        <div>
+          <h1 className="text-2xl font-bold tracking-tight">Compliance Report</h1>
+          <p className="text-sm text-muted-foreground">
+            Building code compliance check against {jurisdictions?.find((j) => j.code === jurisdiction)?.name ?? jurisdiction} standards.
+          </p>
+        </div>
+        <Select value={jurisdiction} onValueChange={setJurisdiction}>
+          <SelectTrigger className="w-[240px]">
+            <SelectValue placeholder="Select jurisdiction" />
+          </SelectTrigger>
+          <SelectContent>
+            {(jurisdictions ?? []).map((j) => (
+              <SelectItem key={j.code} value={j.code}>
+                {j.name}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
       </div>
 
       {/* Overall compliance score */}
diff --git a/apps/web/src/app/(dashboard)/project/[id]/drawings/page.tsx b/apps/web/src/app/(dashboard)/project/[id]/drawings/page.tsx
index 60cd333..33727bc 100644
--- a/apps/web/src/app/(dashboard)/project/[id]/drawings/page.tsx
+++ b/apps/web/src/app/(dashboard)/project/[id]/drawings/page.tsx
@@ -293,6 +293,7 @@ export default function DrawingsPage({ params }: { params: Promise<{ id: string
             const svgUrl = getDownloadUrl(drawing.svgStorageKey);
             const dxfUrl = getDownloadUrl(drawing.dxfStorageKey);
             const pdfUrl = getDownloadUrl(drawing.pdfStorageKey);
+            const ifcUrl = getDownloadUrl(drawing.ifcStorageKey);
 
             return (
               <Card key={drawing.id} className="overflow-hidden">
@@ -373,7 +374,20 @@ export default function DrawingsPage({ params }: { params: Promise<{ id: string
                         </a>
                       </Button>
                     )}
-                    {!dxfUrl && !pdfUrl && !svgUrl && (
+                    {ifcUrl && (
+                      <Button
+                        variant="outline"
+                        size="sm"
+                        className="h-7 text-xs"
+                        asChild
+                      >
+                        <a href={ifcUrl} download>
+                          <Download className="mr-1 h-3 w-3" />
+                          IFC
+                        </a>
+                      </Button>
+                    )}
+                    {!dxfUrl && !pdfUrl && !svgUrl && !ifcUrl && (
                       <span className="text-xs text-muted-foreground">
                         No downloads available
                       </span>
diff --git a/apps/web/src/app/(dashboard)/project/[id]/floor-plan/page.tsx b/apps/web/src/app/(dashboard)/project/[id]/floor-plan/page.tsx
index e70c406..603be85 100644
--- a/apps/web/src/app/(dashboard)/project/[id]/floor-plan/page.tsx
+++ b/apps/web/src/app/(dashboard)/project/[id]/floor-plan/page.tsx
@@ -559,13 +559,6 @@ export default function FloorPlanPage({
                 Once rooms are detected, you can add them to your project with
                 one click.
               </p>
-              <div className="flex items-start gap-3 max-w-md rounded-lg border border-amber-200 bg-amber-50 p-3 text-left dark:border-amber-900 dark:bg-amber-950/50">
-                <AlertCircle className="mt-0.5 h-4 w-4 shrink-0 text-amber-600" />
-                <p className="text-xs text-amber-700 dark:text-amber-300">
-                  Room detection requires the vision-engine microservice. This
-                  will be available once the service is deployed.
-                </p>
-              </div>
             </Card>
           )}
 
diff --git a/apps/web/src/app/(dashboard)/project/[id]/reconstruction/page.tsx b/apps/web/src/app/(dashboard)/project/[id]/reconstruction/page.tsx
new file mode 100644
index 0000000..a8ebf15
--- /dev/null
+++ b/apps/web/src/app/(dashboard)/project/[id]/reconstruction/page.tsx
@@ -0,0 +1,412 @@
+'use client';
+
+import { use, useState, useEffect } from 'react';
+import { trpc } from '@/lib/trpc/client';
+import {
+  Button,
+  Card,
+  CardHeader,
+  CardTitle,
+  CardDescription,
+  CardContent,
+  Badge,
+  Skeleton,
+  Progress,
+  Select,
+  SelectTrigger,
+  SelectValue,
+  SelectContent,
+  SelectItem,
+  Label,
+  toast,
+} from '@openlintel/ui';
+import {
+  Camera,
+  Upload,
+  Loader2,
+  CheckCircle2,
+  XCircle,
+  Box,
+  Ruler,
+  ImageIcon,
+  ArrowRight,
+} from 'lucide-react';
+
+/* ─── Constants ─────────────────────────────────────────────── */
+
+const REFERENCE_OBJECTS = [
+  { value: 'door', label: 'Standard Door (900 x 2100 mm)' },
+  { value: 'a4_paper', label: 'A4 Paper (210 x 297 mm)' },
+  { value: 'standard_brick', label: 'Standard Brick (215 x 65 mm)' },
+] as const;
+
+const STATUS_COLORS: Record<string, string> = {
+  pending: 'bg-gray-100 text-gray-800',
+  running: 'bg-blue-100 text-blue-800',
+  completed: 'bg-green-100 text-green-800',
+  failed: 'bg-red-100 text-red-800',
+};
+
+function formatDate(date: string | Date): string {
+  return new Date(date).toLocaleDateString('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+}
+
+/* ─── Page Component ────────────────────────────────────────── */
+
+export default function ReconstructionPage({ params }: { params: Promise<{ id: string }> }) {
+  const { id: projectId } = use(params);
+  const utils = trpc.useUtils();
+
+  const [selectedRoom, setSelectedRoom] = useState<string>('');
+  const [referenceObject, setReferenceObject] = useState<string>('door');
+  const [uploadIds, setUploadIds] = useState<string[]>([]);
+  const [activeJobId, setActiveJobId] = useState<string | null>(null);
+
+  /* ── Queries ──────────────────────────────────────────────── */
+  const { data: project, isLoading: projectLoading } = trpc.project.getById.useQuery({ id: projectId });
+
+  const rooms = (project as any)?.rooms ?? [];
+
+  const { data: jobResult, isLoading: jobLoading } = trpc.reconstruction.getResult.useQuery(
+    { jobId: activeJobId! },
+    { enabled: !!activeJobId, refetchInterval: activeJobId ? 2000 : false },
+  );
+
+  const { data: pastJobs = [] } = trpc.reconstruction.listByRoom.useQuery(
+    { roomId: selectedRoom },
+    { enabled: !!selectedRoom },
+  );
+
+  // Stop polling when job completes
+  useEffect(() => {
+    if (jobResult?.status === 'completed' || jobResult?.status === 'failed') {
+      utils.reconstruction.listByRoom.invalidate();
+    }
+  }, [jobResult?.status]);
+
+  /* ── Mutations ────────────────────────────────────────────── */
+  const startReconstruction = trpc.reconstruction.startReconstruction.useMutation({
+    onSuccess: (job) => {
+      setActiveJobId(job.id);
+      toast({ title: 'Reconstruction started', description: 'Processing your photos...' });
+    },
+    onError: (err) => {
+      toast({ title: 'Failed to start reconstruction', description: err.message, variant: 'destructive' });
+    },
+  });
+
+  const updateRoom = trpc.room.update.useMutation({
+    onSuccess: () => {
+      toast({ title: 'Room dimensions updated', description: 'Reconstruction measurements applied.' });
+    },
+    onError: (err) => {
+      toast({ title: 'Failed to update room', description: err.message, variant: 'destructive' });
+    },
+  });
+
+  /* ── Handlers ─────────────────────────────────────────────── */
+  function handleStart() {
+    if (!selectedRoom || uploadIds.length === 0) return;
+    startReconstruction.mutate({
+      projectId,
+      roomId: selectedRoom,
+      uploadIds,
+      referenceObject: referenceObject || undefined,
+    });
+  }
+
+  function handleApplyDimensions() {
+    if (!jobResult?.outputJson || !selectedRoom) return;
+    const output = jobResult.outputJson as any;
+    updateRoom.mutate({
+      id: selectedRoom,
+      lengthMm: Math.round(output.length_mm),
+      widthMm: Math.round(output.width_mm),
+      heightMm: Math.round(output.height_mm),
+    });
+  }
+
+  /* ── Loading state ────────────────────────────────────────── */
+  if (projectLoading) {
+    return (
+      <div className="space-y-4">
+        <Skeleton className="h-8 w-56" />
+        <Skeleton className="h-4 w-72" />
+        <Skeleton className="h-64" />
+      </div>
+    );
+  }
+
+  const output = jobResult?.outputJson as any;
+  const isProcessing = jobResult?.status === 'running' || jobResult?.status === 'pending';
+
+  return (
+    <div>
+      {/* ── Header ──────────────────────────────────────────── */}
+      <div className="mb-6 flex items-center gap-3">
+        <Camera className="h-6 w-6 text-primary" />
+        <div>
+          <h1 className="text-2xl font-bold tracking-tight">Photo-to-3D Reconstruction</h1>
+          <p className="text-sm text-muted-foreground">
+            Upload room photos to extract dimensions and generate 3D models.
+          </p>
+        </div>
+      </div>
+
+      {/* ── Configuration ───────────────────────────────────── */}
+      <div className="mb-6 grid gap-4 sm:grid-cols-3">
+        <Card>
+          <CardContent className="pt-6 space-y-3">
+            <Label>Select Room</Label>
+            <Select value={selectedRoom} onValueChange={setSelectedRoom}>
+              <SelectTrigger>
+                <SelectValue placeholder="Choose a room" />
+              </SelectTrigger>
+              <SelectContent>
+                {rooms.map((room: any) => (
+                  <SelectItem key={room.id} value={room.id}>
+                    {room.name} ({room.type.replace(/_/g, ' ')})
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardContent className="pt-6 space-y-3">
+            <Label>Calibration Reference</Label>
+            <Select value={referenceObject} onValueChange={setReferenceObject}>
+              <SelectTrigger>
+                <SelectValue placeholder="Choose reference" />
+              </SelectTrigger>
+              <SelectContent>
+                {REFERENCE_OBJECTS.map((ref) => (
+                  <SelectItem key={ref.value} value={ref.value}>
+                    {ref.label}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardContent className="pt-6 space-y-3">
+            <Label>Room Photos</Label>
+            <div className="flex items-center gap-2">
+              <div className="flex-1 rounded-lg border-2 border-dashed border-muted-foreground/25 p-4 text-center">
+                <Upload className="mx-auto mb-1 h-5 w-5 text-muted-foreground" />
+                <p className="text-xs text-muted-foreground">
+                  {uploadIds.length > 0 ? `${uploadIds.length} photo(s) selected` : 'Upload photos via Uploads tab'}
+                </p>
+              </div>
+            </div>
+            <input
+              type="text"
+              className="w-full rounded-md border px-3 py-2 text-sm"
+              placeholder="Paste upload IDs (comma-separated)"
+              onChange={(e) => {
+                const ids = e.target.value.split(',').map((s) => s.trim()).filter(Boolean);
+                setUploadIds(ids);
+              }}
+            />
+          </CardContent>
+        </Card>
+      </div>
+
+      {/* ── Start Button ────────────────────────────────────── */}
+      <div className="mb-6">
+        <Button
+          onClick={handleStart}
+          disabled={!selectedRoom || uploadIds.length === 0 || startReconstruction.isPending || isProcessing}
+          className="w-full sm:w-auto"
+        >
+          {startReconstruction.isPending || isProcessing ? (
+            <>
+              <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+              Processing...
+            </>
+          ) : (
+            <>
+              <Camera className="mr-2 h-4 w-4" />
+              Start Reconstruction
+            </>
+          )}
+        </Button>
+      </div>
+
+      {/* ── Active Job Progress ─────────────────────────────── */}
+      {activeJobId && jobResult && (
+        <Card className="mb-6">
+          <CardHeader>
+            <div className="flex items-center justify-between">
+              <CardTitle className="text-base">Reconstruction Progress</CardTitle>
+              <Badge className={STATUS_COLORS[jobResult.status] || ''}>
+                {jobResult.status}
+              </Badge>
+            </div>
+          </CardHeader>
+          <CardContent className="space-y-4">
+            <Progress value={jobResult.progress} />
+            <p className="text-sm text-muted-foreground">
+              {jobResult.status === 'running' && output?.current_step
+                ? output.current_step
+                : jobResult.status === 'completed'
+                  ? 'Reconstruction complete'
+                  : jobResult.status === 'failed'
+                    ? jobResult.error || 'An error occurred'
+                    : 'Starting...'}
+            </p>
+
+            {/* ── Results ────────────────────────────────────── */}
+            {jobResult.status === 'completed' && output && (
+              <div className="space-y-4">
+                <h3 className="text-sm font-semibold">Extracted Room Dimensions</h3>
+                <div className="grid gap-3 sm:grid-cols-3">
+                  {(output.dimensions ?? []).map((dim: any) => (
+                    <div
+                      key={dim.measurement}
+                      className="flex items-center gap-3 rounded-lg border p-3"
+                    >
+                      <Ruler className="h-5 w-5 text-primary" />
+                      <div>
+                        <p className="text-sm font-medium capitalize">{dim.measurement}</p>
+                        <p className="text-lg font-bold">{Math.round(dim.value_mm)} mm</p>
+                        <div className="flex items-center gap-1 mt-0.5">
+                          <div
+                            className="h-1.5 rounded-full bg-primary"
+                            style={{ width: `${dim.confidence * 60}px` }}
+                          />
+                          <span className="text-[10px] text-muted-foreground">
+                            {Math.round(dim.confidence * 100)}% confidence
+                          </span>
+                        </div>
+                      </div>
+                    </div>
+                  ))}
+                </div>
+
+                {/* 3D Preview placeholder */}
+                <div className="rounded-lg border bg-muted/30 p-8 text-center">
+                  <Box className="mx-auto mb-2 h-12 w-12 text-muted-foreground" />
+                  <p className="text-sm text-muted-foreground">
+                    3D Room Preview: {Math.round(output.length_mm / 10)} x{' '}
+                    {Math.round(output.width_mm / 10)} x {Math.round(output.height_mm / 10)} cm
+                  </p>
+                  {output.mesh_storage_key && (
+                    <Button
+                      variant="outline"
+                      size="sm"
+                      className="mt-3"
+                      asChild
+                    >
+                      <a href={`/api/uploads/${encodeURIComponent(output.mesh_storage_key)}`} download>
+                        Download 3D Model (.glb)
+                      </a>
+                    </Button>
+                  )}
+                </div>
+
+                {/* Apply to room button */}
+                <Button
+                  onClick={handleApplyDimensions}
+                  disabled={updateRoom.isPending}
+                  className="w-full"
+                >
+                  {updateRoom.isPending ? (
+                    <>
+                      <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+                      Updating...
+                    </>
+                  ) : (
+                    <>
+                      <ArrowRight className="mr-2 h-4 w-4" />
+                      Apply Dimensions to Room
+                    </>
+                  )}
+                </Button>
+              </div>
+            )}
+          </CardContent>
+        </Card>
+      )}
+
+      {/* ── Past Reconstructions ────────────────────────────── */}
+      {selectedRoom && pastJobs.length > 0 && (
+        <div>
+          <h2 className="mb-4 text-lg font-semibold">Past Reconstructions</h2>
+          <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
+            {pastJobs.map((job: any) => {
+              const jobOutput = job.outputJson as any;
+              return (
+                <Card
+                  key={job.id}
+                  className="cursor-pointer hover:border-primary/50 transition-colors"
+                  onClick={() => setActiveJobId(job.id)}
+                >
+                  <CardHeader className="pb-2">
+                    <div className="flex items-start justify-between">
+                      <CardDescription>{formatDate(job.createdAt)}</CardDescription>
+                      <Badge className={`text-[10px] ${STATUS_COLORS[job.status] || ''}`}>
+                        {job.status}
+                      </Badge>
+                    </div>
+                  </CardHeader>
+                  <CardContent>
+                    {job.status === 'completed' && jobOutput ? (
+                      <div className="space-y-1 text-sm">
+                        <p>
+                          <span className="text-muted-foreground">Length:</span>{' '}
+                          <span className="font-medium">{Math.round(jobOutput.length_mm)} mm</span>
+                        </p>
+                        <p>
+                          <span className="text-muted-foreground">Width:</span>{' '}
+                          <span className="font-medium">{Math.round(jobOutput.width_mm)} mm</span>
+                        </p>
+                        <p>
+                          <span className="text-muted-foreground">Height:</span>{' '}
+                          <span className="font-medium">{Math.round(jobOutput.height_mm)} mm</span>
+                        </p>
+                        <p className="text-xs text-muted-foreground">
+                          {jobOutput.images_processed} photos processed
+                        </p>
+                      </div>
+                    ) : job.status === 'failed' ? (
+                      <div className="flex items-center gap-2 text-sm text-red-600">
+                        <XCircle className="h-4 w-4" />
+                        {(job as any).error || 'Failed'}
+                      </div>
+                    ) : (
+                      <div className="flex items-center gap-2 text-sm text-muted-foreground">
+                        <Loader2 className="h-4 w-4 animate-spin" />
+                        Processing...
+                      </div>
+                    )}
+                  </CardContent>
+                </Card>
+              );
+            })}
+          </div>
+        </div>
+      )}
+
+      {/* ── Empty state ─────────────────────────────────────── */}
+      {!selectedRoom && (
+        <Card className="flex flex-col items-center justify-center p-12 text-center">
+          <Camera className="mb-4 h-12 w-12 text-muted-foreground" />
+          <h2 className="mb-2 text-lg font-semibold">Get Started</h2>
+          <p className="text-sm text-muted-foreground">
+            Select a room, upload photos, and start a reconstruction to extract room dimensions.
+          </p>
+        </Card>
+      )}
+    </div>
+  );
+}
diff --git a/apps/web/src/components/sidebar.tsx b/apps/web/src/components/sidebar.tsx
index 4b1b942..9305aeb 100644
--- a/apps/web/src/components/sidebar.tsx
+++ b/apps/web/src/components/sidebar.tsx
@@ -37,6 +37,8 @@ import {
   DollarSign,
   Users,
   Sparkles,
+  FileEdit,
+  Camera,
 } from 'lucide-react';
 import { cn } from '@openlintel/ui';
 
@@ -61,9 +63,11 @@ const projectNavigation = [
   { name: 'MEP', href: 'mep', icon: Zap },
   { name: 'Timeline', href: 'timeline', icon: CalendarDays },
   { name: 'Site Logs', href: 'site-logs', icon: ClipboardList },
+  { name: 'Change Orders', href: 'change-orders', icon: FileEdit },
   { name: 'Payments', href: 'payments', icon: CreditCard },
   { name: 'Procurement', href: 'procurement', icon: Truck },
   { name: 'Compliance', href: 'compliance', icon: ShieldCheck },
+  { name: 'Reconstruction', href: 'reconstruction', icon: Camera },
   { name: 'AR/VR', href: 'ar', icon: Glasses },
   { name: 'Analytics', href: 'analytics', icon: BarChart3 },
   { name: 'Predictions', href: 'predictions', icon: TrendingUp },
diff --git a/apps/web/src/server/trpc/routers/compliance.ts b/apps/web/src/server/trpc/routers/compliance.ts
index d95d83c..9438aed 100644
--- a/apps/web/src/server/trpc/routers/compliance.ts
+++ b/apps/web/src/server/trpc/routers/compliance.ts
@@ -38,18 +38,36 @@ interface ComplianceResult {
   clause: string;
 }
 
-// Load rules at module init
-let RULES: BuildingCodeRule[] = [];
-try {
-  const rulesPath = join(process.cwd(), '..', '..', 'data', 'building-codes', 'india-nbc.json');
-  RULES = JSON.parse(readFileSync(rulesPath, 'utf-8'));
-} catch {
-  // Try alternate path (monorepo root)
+// All jurisdiction files to load
+const JURISDICTION_FILES = [
+  'india-nbc.json',
+  'us-irc.json',
+  'eu-eurocode.json',
+  'uk-building-regs.json',
+];
+
+const JURISDICTIONS = [
+  { code: 'IN', name: 'India (NBC 2016)' },
+  { code: 'US', name: 'United States (IRC 2021)' },
+  { code: 'EU', name: 'European Union (Eurocode)' },
+  { code: 'GB', name: 'United Kingdom (Building Regs)' },
+];
+
+// Load rules from all jurisdiction files at module init
+let ALL_RULES: BuildingCodeRule[] = [];
+for (const file of JURISDICTION_FILES) {
   try {
-    const rulesPath = join(process.cwd(), 'data', 'building-codes', 'india-nbc.json');
-    RULES = JSON.parse(readFileSync(rulesPath, 'utf-8'));
+    const rulesPath = join(process.cwd(), '..', '..', 'data', 'building-codes', file);
+    const rules: BuildingCodeRule[] = JSON.parse(readFileSync(rulesPath, 'utf-8'));
+    ALL_RULES = ALL_RULES.concat(rules);
   } catch {
-    console.warn('Building codes data not found, compliance checks will return empty results');
+    try {
+      const rulesPath = join(process.cwd(), 'data', 'building-codes', file);
+      const rules: BuildingCodeRule[] = JSON.parse(readFileSync(rulesPath, 'utf-8'));
+      ALL_RULES = ALL_RULES.concat(rules);
+    } catch {
+      console.warn(`Building codes file ${file} not found, skipping`);
+    }
   }
 }
 
@@ -166,7 +184,7 @@ export const complianceRouter = router({
       if (!room) throw new Error('Room not found');
       if (room.project.userId !== ctx.userId) throw new Error('Access denied');
 
-      const applicableRules = RULES.filter(
+      const applicableRules = ALL_RULES.filter(
         (r) => r.jurisdiction.country === input.jurisdiction,
       );
 
@@ -216,7 +234,7 @@ export const complianceRouter = router({
       });
       if (!project) throw new Error('Project not found');
 
-      const applicableRules = RULES.filter(
+      const applicableRules = ALL_RULES.filter(
         (r) => r.jurisdiction.country === input.jurisdiction,
       );
 
@@ -275,7 +293,7 @@ export const complianceRouter = router({
       category: z.string().optional(),
     }))
     .query(async ({ input }) => {
-      let filtered = RULES.filter(
+      let filtered = ALL_RULES.filter(
         (r) => r.jurisdiction.country === input.jurisdiction,
       );
       if (input.category) {
@@ -283,4 +301,10 @@ export const complianceRouter = router({
       }
       return filtered;
     }),
+
+  // List available jurisdictions
+  listJurisdictions: protectedProcedure
+    .query(async () => {
+      return JURISDICTIONS;
+    }),
 });
diff --git a/apps/web/src/server/trpc/routers/index.ts b/apps/web/src/server/trpc/routers/index.ts
index f354640..a975d11 100644
--- a/apps/web/src/server/trpc/routers/index.ts
+++ b/apps/web/src/server/trpc/routers/index.ts
@@ -30,6 +30,8 @@ import { warrantyRouter } from './warranty';
 import { communityRouter } from './community';
 import { developerPortalRouter } from './developerPortal';
 import { localizationRouter } from './localization';
+// Pending features
+import { reconstructionRouter } from './reconstruction';
 // Missing features
 import { qualityRouter } from './quality';
 import { handoverRouter } from './handover';
@@ -71,6 +73,8 @@ export const appRouter = router({
   community: communityRouter,
   developerPortal: developerPortalRouter,
   localization: localizationRouter,
+  // Pending features
+  reconstruction: reconstructionRouter,
   // Missing features
   quality: qualityRouter,
   handover: handoverRouter,
diff --git a/apps/web/src/server/trpc/routers/reconstruction.ts b/apps/web/src/server/trpc/routers/reconstruction.ts
new file mode 100644
index 0000000..33015b5
--- /dev/null
+++ b/apps/web/src/server/trpc/routers/reconstruction.ts
@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { projects, rooms, jobs, eq, and } from '@openlintel/db';
+import { router, protectedProcedure } from '../init';
+
+const VISION_ENGINE_URL = process.env.VISION_ENGINE_URL || 'http://localhost:8010';
+
+export const reconstructionRouter = router({
+  startReconstruction: protectedProcedure
+    .input(
+      z.object({
+        projectId: z.string(),
+        roomId: z.string(),
+        uploadIds: z.array(z.string()).min(1),
+        referenceObject: z.string().optional(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const project = await ctx.db.query.projects.findFirst({
+        where: and(eq(projects.id, input.projectId), eq(projects.userId, ctx.userId)),
+      });
+      if (!project) throw new Error('Project not found');
+
+      const room = await ctx.db.query.rooms.findFirst({
+        where: and(eq(rooms.id, input.roomId), eq(rooms.projectId, input.projectId)),
+      });
+      if (!room) throw new Error('Room not found');
+
+      // Create a job for tracking
+      const [job] = await ctx.db
+        .insert(jobs)
+        .values({
+          userId: ctx.userId,
+          type: 'reconstruction',
+          status: 'pending',
+          inputJson: {
+            projectId: input.projectId,
+            roomId: input.roomId,
+            uploadIds: input.uploadIds,
+            referenceObject: input.referenceObject,
+          },
+          projectId: input.projectId,
+          roomId: input.roomId,
+        })
+        .returning();
+
+      // Build image URLs from upload IDs
+      const imageUrls = input.uploadIds.map(
+        (id) => `${VISION_ENGINE_URL.replace('8010', '3000')}/api/uploads/${id}`,
+      );
+
+      // Fire-and-forget to vision engine
+      fetch(`${VISION_ENGINE_URL}/api/v1/reconstruction/job`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          job_id: job.id,
+          user_id: ctx.userId,
+          project_id: input.projectId,
+          room_id: input.roomId,
+          image_urls: imageUrls,
+          reference_object: input.referenceObject ?? null,
+        }),
+      }).catch(() => {});
+
+      return job;
+    }),
+
+  getResult: protectedProcedure
+    .input(z.object({ jobId: z.string() }))
+    .query(async ({ ctx, input }) => {
+      const job = await ctx.db.query.jobs.findFirst({
+        where: and(eq(jobs.id, input.jobId), eq(jobs.userId, ctx.userId)),
+      });
+      if (!job) throw new Error('Job not found');
+
+      return {
+        id: job.id,
+        status: job.status,
+        progress: (job as any).progress ?? 0,
+        outputJson: (job as any).outputJson ?? null,
+        error: (job as any).error ?? null,
+        createdAt: job.createdAt,
+      };
+    }),
+
+  listByRoom: protectedProcedure
+    .input(z.object({ roomId: z.string() }))
+    .query(async ({ ctx, input }) => {
+      const room = await ctx.db.query.rooms.findFirst({
+        where: eq(rooms.id, input.roomId),
+        with: { project: true },
+      });
+      if (!room) throw new Error('Room not found');
+      if (room.project.userId !== ctx.userId) throw new Error('Access denied');
+
+      return ctx.db.query.jobs.findMany({
+        where: and(
+          eq(jobs.roomId, input.roomId),
+          eq(jobs.type, 'reconstruction'),
+          eq(jobs.userId, ctx.userId),
+        ),
+        orderBy: (j, { desc }) => [desc(j.createdAt)],
+      });
+    }),
+});
diff --git a/apps/web/src/server/trpc/routers/schedule.ts b/apps/web/src/server/trpc/routers/schedule.ts
index 876e43e..25b5a7c 100644
--- a/apps/web/src/server/trpc/routers/schedule.ts
+++ b/apps/web/src/server/trpc/routers/schedule.ts
@@ -183,4 +183,41 @@ export const scheduleRouter = router({
         .returning();
       return updated;
     }),
+
+  analyzeChangeOrderImpact: protectedProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      const order = await ctx.db.query.changeOrders.findFirst({
+        where: eq(changeOrders.id, input.id),
+        with: { project: true },
+      });
+      if (!order) throw new Error('Change order not found');
+      if ((order as any).project.userId !== ctx.userId) throw new Error('Access denied');
+
+      try {
+        const res = await fetch(
+          `${PROJECT_SERVICE_URL}/api/v1/change-orders/${input.id}/analyze`,
+          {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              change_order_id: input.id,
+              project_id: (order as any).projectId,
+              title: order.title,
+              description: order.description,
+              cost_impact: order.costImpact,
+              time_impact_days: order.timeImpactDays,
+            }),
+          },
+        );
+        if (!res.ok) throw new Error(`Analysis service returned ${res.status}`);
+        return await res.json() as { summary: string; risks: string[]; recommendations: string[] };
+      } catch {
+        return {
+          summary: `Change order "${order.title}" has a cost impact of $${order.costImpact ?? 0} and time impact of ${order.timeImpactDays ?? 0} days.`,
+          risks: [],
+          recommendations: [],
+        };
+      }
+    }),
 });
diff --git a/data/building-codes/eu-eurocode.json b/data/building-codes/eu-eurocode.json
new file mode 100644
index 0000000..9aea95e
--- /dev/null
+++ b/data/building-codes/eu-eurocode.json
@@ -0,0 +1,197 @@
+[
+  {
+    "code_id": "EU-RD-001",
+    "jurisdiction": { "country": "EU" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum habitable room area",
+      "requirement": "Habitable rooms shall have a minimum floor area of 9.0 sq.m",
+      "min_value": 9.0,
+      "unit": "sqm",
+      "applies_to": ["living_room", "bedroom", "dining", "study"]
+    },
+    "source": { "document": "EN 15251:2007", "edition": "2007", "clause": "Annex B, Table B.1" }
+  },
+  {
+    "code_id": "EU-RD-002",
+    "jurisdiction": { "country": "EU" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum kitchen area",
+      "requirement": "Kitchen shall have a minimum floor area of 5.0 sq.m",
+      "min_value": 5.0,
+      "unit": "sqm",
+      "applies_to": ["kitchen"]
+    },
+    "source": { "document": "EN 15251:2007", "edition": "2007", "clause": "Annex B, Table B.2" }
+  },
+  {
+    "code_id": "EU-RD-003",
+    "jurisdiction": { "country": "EU" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum bathroom area",
+      "requirement": "Bathroom shall have a minimum floor area of 2.5 sq.m",
+      "min_value": 2.5,
+      "unit": "sqm",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "EN 15251:2007", "edition": "2007", "clause": "Annex B, Table B.3" }
+  },
+  {
+    "code_id": "EU-RD-004",
+    "jurisdiction": { "country": "EU" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum habitable room width",
+      "requirement": "Habitable rooms shall have a minimum width of 2.4 m",
+      "min_value": 2400,
+      "unit": "mm",
+      "applies_to": ["living_room", "bedroom", "dining", "study"]
+    },
+    "source": { "document": "EN 15251:2007", "edition": "2007", "clause": "Annex B, Section B.2" }
+  },
+  {
+    "code_id": "EU-RD-005",
+    "jurisdiction": { "country": "EU" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum ceiling height for habitable rooms",
+      "requirement": "Habitable rooms shall have a minimum ceiling height of 2500 mm (2.5 m)",
+      "min_value": 2500,
+      "unit": "mm",
+      "applies_to": ["living_room", "bedroom", "dining", "study", "kitchen"]
+    },
+    "source": { "document": "EN 15251:2007", "edition": "2007", "clause": "Section 6.3" }
+  },
+  {
+    "code_id": "EU-RD-006",
+    "jurisdiction": { "country": "EU" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum corridor width",
+      "requirement": "Corridors shall have a minimum clear width of 1.2 m",
+      "min_value": 1200,
+      "unit": "mm",
+      "applies_to": ["corridor"]
+    },
+    "source": { "document": "EN 1991-1-1", "edition": "2002", "clause": "Table 6.2" }
+  },
+  {
+    "code_id": "EU-VT-001",
+    "jurisdiction": { "country": "EU" },
+    "category": "ventilation",
+    "rule": {
+      "description": "Minimum ventilation rate for habitable rooms",
+      "requirement": "Habitable rooms shall have a minimum ventilation rate of 0.5 air changes per hour",
+      "min_value": 0.5,
+      "unit": "ach",
+      "applies_to": ["living_room", "bedroom", "dining", "study"]
+    },
+    "source": { "document": "EN 15251:2007", "edition": "2007", "clause": "Section 6.2, Table 3" }
+  },
+  {
+    "code_id": "EU-VT-002",
+    "jurisdiction": { "country": "EU" },
+    "category": "ventilation",
+    "rule": {
+      "description": "Bathroom mechanical ventilation",
+      "requirement": "Bathrooms shall have mechanical extract ventilation of not less than 15 l/s (54 m3/h)",
+      "min_value": 15,
+      "unit": "ach",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "EN 15251:2007", "edition": "2007", "clause": "Table 5" }
+  },
+  {
+    "code_id": "EU-FS-001",
+    "jurisdiction": { "country": "EU" },
+    "category": "fire_safety",
+    "rule": {
+      "description": "Smoke detector requirement",
+      "requirement": "Smoke detectors shall be installed in all escape routes and habitable rooms as per EN 14604",
+      "min_value": 1,
+      "unit": "per_room",
+      "applies_to": ["living_room", "bedroom", "kitchen", "corridor"]
+    },
+    "source": { "document": "EN 14604:2005", "edition": "2005", "clause": "Section 4" }
+  },
+  {
+    "code_id": "EU-FS-002",
+    "jurisdiction": { "country": "EU" },
+    "category": "fire_safety",
+    "rule": {
+      "description": "Fire resistance of structural elements",
+      "requirement": "Structural elements in residential buildings shall achieve minimum REI 60 fire resistance",
+      "min_value": 60,
+      "unit": "minutes",
+      "applies_to": ["living_room", "bedroom", "kitchen", "dining", "study", "corridor"]
+    },
+    "source": { "document": "EN 1991-1-2", "edition": "2002", "clause": "Section 2.4" }
+  },
+  {
+    "code_id": "EU-EL-001",
+    "jurisdiction": { "country": "EU" },
+    "category": "electrical",
+    "rule": {
+      "description": "Minimum lighting level for habitable rooms",
+      "requirement": "Habitable rooms shall have maintained illuminance of not less than 300 lux on the working plane",
+      "min_value": 300,
+      "unit": "lux",
+      "applies_to": ["living_room", "study", "kitchen"]
+    },
+    "source": { "document": "EN 12464-1:2021", "edition": "2021", "clause": "Table 5.1" }
+  },
+  {
+    "code_id": "EU-EL-002",
+    "jurisdiction": { "country": "EU" },
+    "category": "electrical",
+    "rule": {
+      "description": "Minimum power points per habitable room",
+      "requirement": "Each habitable room shall have a minimum of 2 socket outlets",
+      "min_value": 2,
+      "unit": "outlets",
+      "applies_to": ["living_room", "bedroom", "dining", "study"]
+    },
+    "source": { "document": "IEC 60364-7-701", "edition": "2019", "clause": "Section 701.512" }
+  },
+  {
+    "code_id": "EU-PL-001",
+    "jurisdiction": { "country": "EU" },
+    "category": "plumbing",
+    "rule": {
+      "description": "Minimum water supply per person",
+      "requirement": "Minimum 150 litres per capita per day for residential buildings",
+      "min_value": 150,
+      "unit": "lpcd",
+      "applies_to": ["bathroom", "kitchen"]
+    },
+    "source": { "document": "EN 806-3:2006", "edition": "2006", "clause": "Section 5" }
+  },
+  {
+    "code_id": "EU-AC-001",
+    "jurisdiction": { "country": "EU" },
+    "category": "accessibility",
+    "rule": {
+      "description": "Minimum door width for accessibility",
+      "requirement": "Accessible doors shall have minimum clear opening of 800 mm",
+      "min_value": 800,
+      "unit": "mm",
+      "applies_to": ["living_room", "bedroom", "bathroom", "kitchen", "dining", "corridor"]
+    },
+    "source": { "document": "EN 17210:2021", "edition": "2021", "clause": "Section 8.3" }
+  },
+  {
+    "code_id": "EU-AC-002",
+    "jurisdiction": { "country": "EU" },
+    "category": "accessibility",
+    "rule": {
+      "description": "Accessible bathroom turning space",
+      "requirement": "Accessible bathrooms shall have a turning space of 1500 mm diameter",
+      "min_value": 1500,
+      "unit": "mm",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "EN 17210:2021", "edition": "2021", "clause": "Section 11.2" }
+  }
+]
diff --git a/data/building-codes/uk-building-regs.json b/data/building-codes/uk-building-regs.json
new file mode 100644
index 0000000..bd392fb
--- /dev/null
+++ b/data/building-codes/uk-building-regs.json
@@ -0,0 +1,197 @@
+[
+  {
+    "code_id": "UK-RD-001",
+    "jurisdiction": { "country": "GB" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum single bedroom area",
+      "requirement": "A single bedroom shall have a minimum floor area of 7.5 sq.m (NDSS)",
+      "min_value": 7.5,
+      "unit": "sqm",
+      "applies_to": ["bedroom"]
+    },
+    "source": { "document": "Nationally Described Space Standard", "edition": "2015", "clause": "Table 1" }
+  },
+  {
+    "code_id": "UK-RD-002",
+    "jurisdiction": { "country": "GB" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum double bedroom area",
+      "requirement": "A double bedroom shall have a minimum floor area of 11.5 sq.m (NDSS)",
+      "min_value": 11.5,
+      "unit": "sqm",
+      "applies_to": ["bedroom"]
+    },
+    "source": { "document": "Nationally Described Space Standard", "edition": "2015", "clause": "Table 1, Note 1" }
+  },
+  {
+    "code_id": "UK-RD-003",
+    "jurisdiction": { "country": "GB" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum habitable room area",
+      "requirement": "Living rooms shall have a minimum floor area of 13.0 sq.m for 2-person dwellings",
+      "min_value": 13.0,
+      "unit": "sqm",
+      "applies_to": ["living_room", "dining"]
+    },
+    "source": { "document": "Nationally Described Space Standard", "edition": "2015", "clause": "Table 1" }
+  },
+  {
+    "code_id": "UK-RD-004",
+    "jurisdiction": { "country": "GB" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum bedroom width",
+      "requirement": "Bedrooms shall have a minimum width of 2.15 m for single, 2.75 m for double",
+      "min_value": 2150,
+      "unit": "mm",
+      "applies_to": ["bedroom"]
+    },
+    "source": { "document": "Nationally Described Space Standard", "edition": "2015", "clause": "Paragraph 10" }
+  },
+  {
+    "code_id": "UK-RD-005",
+    "jurisdiction": { "country": "GB" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum ceiling height for habitable rooms",
+      "requirement": "Habitable rooms shall have a minimum ceiling height of 2300 mm (2.3 m)",
+      "min_value": 2300,
+      "unit": "mm",
+      "applies_to": ["living_room", "bedroom", "dining", "study", "kitchen"]
+    },
+    "source": { "document": "Nationally Described Space Standard", "edition": "2015", "clause": "Paragraph 9" }
+  },
+  {
+    "code_id": "UK-RD-006",
+    "jurisdiction": { "country": "GB" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum kitchen area",
+      "requirement": "Kitchen shall have a minimum floor area of 5.5 sq.m for a separate kitchen",
+      "min_value": 5.5,
+      "unit": "sqm",
+      "applies_to": ["kitchen"]
+    },
+    "source": { "document": "Nationally Described Space Standard", "edition": "2015", "clause": "Table 1" }
+  },
+  {
+    "code_id": "UK-RD-007",
+    "jurisdiction": { "country": "GB" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum bathroom area",
+      "requirement": "Bathroom shall have a minimum floor area of 2.5 sq.m",
+      "min_value": 2.5,
+      "unit": "sqm",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "Approved Document M", "edition": "2015", "clause": "Section 3.12" }
+  },
+  {
+    "code_id": "UK-RD-008",
+    "jurisdiction": { "country": "GB" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum corridor width",
+      "requirement": "Corridors shall have a minimum width of 900 mm (Approved Document M)",
+      "min_value": 900,
+      "unit": "mm",
+      "applies_to": ["corridor"]
+    },
+    "source": { "document": "Approved Document M", "edition": "2015", "clause": "Section 3.6" }
+  },
+  {
+    "code_id": "UK-VT-001",
+    "jurisdiction": { "country": "GB" },
+    "category": "ventilation",
+    "rule": {
+      "description": "Habitable room ventilation",
+      "requirement": "Habitable rooms shall have background ventilation of 8000 sq.mm equivalent area and purge ventilation opening of 1/20th floor area",
+      "min_value": 0.05,
+      "unit": "ratio_of_floor_area",
+      "applies_to": ["living_room", "bedroom", "dining", "study"]
+    },
+    "source": { "document": "Approved Document F", "edition": "2021", "clause": "Table 1.1" }
+  },
+  {
+    "code_id": "UK-VT-002",
+    "jurisdiction": { "country": "GB" },
+    "category": "ventilation",
+    "rule": {
+      "description": "Bathroom extract ventilation",
+      "requirement": "Bathrooms shall have intermittent extract of 15 l/s or continuous extract of 8 l/s",
+      "min_value": 15,
+      "unit": "ach",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "Approved Document F", "edition": "2021", "clause": "Table 1.3" }
+  },
+  {
+    "code_id": "UK-FS-001",
+    "jurisdiction": { "country": "GB" },
+    "category": "fire_safety",
+    "rule": {
+      "description": "Smoke alarm requirement",
+      "requirement": "At least one smoke alarm per storey, and heat alarm in kitchen (Approved Document B)",
+      "min_value": 1,
+      "unit": "per_room",
+      "applies_to": ["living_room", "bedroom", "corridor"]
+    },
+    "source": { "document": "Approved Document B Vol 1", "edition": "2019", "clause": "Section 1.1" }
+  },
+  {
+    "code_id": "UK-EL-001",
+    "jurisdiction": { "country": "GB" },
+    "category": "electrical",
+    "rule": {
+      "description": "Minimum socket outlets per habitable room",
+      "requirement": "Habitable rooms should have a minimum of 4 socket outlets",
+      "min_value": 4,
+      "unit": "outlets",
+      "applies_to": ["living_room", "bedroom", "dining", "study"]
+    },
+    "source": { "document": "Approved Document P", "edition": "2013", "clause": "Section 2, BS 7671" }
+  },
+  {
+    "code_id": "UK-EL-002",
+    "jurisdiction": { "country": "GB" },
+    "category": "electrical",
+    "rule": {
+      "description": "Kitchen electrical requirement",
+      "requirement": "Kitchen shall have a dedicated 32A circuit for cooker and minimum 6 socket outlets",
+      "min_value": 32,
+      "unit": "amps",
+      "applies_to": ["kitchen"]
+    },
+    "source": { "document": "BS 7671:2018", "edition": "2018", "clause": "Regulation 314.1" }
+  },
+  {
+    "code_id": "UK-PL-001",
+    "jurisdiction": { "country": "GB" },
+    "category": "plumbing",
+    "rule": {
+      "description": "Maximum water consumption",
+      "requirement": "New dwellings should achieve water consumption of no more than 125 litres per person per day",
+      "min_value": 125,
+      "unit": "lpcd",
+      "applies_to": ["bathroom", "kitchen"]
+    },
+    "source": { "document": "Approved Document G", "edition": "2015", "clause": "Section G2, Requirement G2(2)" }
+  },
+  {
+    "code_id": "UK-AC-001",
+    "jurisdiction": { "country": "GB" },
+    "category": "accessibility",
+    "rule": {
+      "description": "Minimum door width for accessibility",
+      "requirement": "All doors on accessible routes shall have minimum clear opening of 775 mm",
+      "min_value": 775,
+      "unit": "mm",
+      "applies_to": ["living_room", "bedroom", "bathroom", "kitchen", "dining", "corridor"]
+    },
+    "source": { "document": "Approved Document M", "edition": "2015", "clause": "Section 3.10" }
+  }
+]
diff --git a/data/building-codes/us-irc.json b/data/building-codes/us-irc.json
new file mode 100644
index 0000000..0c7fed0
--- /dev/null
+++ b/data/building-codes/us-irc.json
@@ -0,0 +1,262 @@
+[
+  {
+    "code_id": "IRC-RD-001",
+    "jurisdiction": { "country": "US" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum habitable room area",
+      "requirement": "Every habitable room shall have a floor area of not less than 6.503 sq.m (70 sq.ft)",
+      "min_value": 6.503,
+      "unit": "sqm",
+      "applies_to": ["living_room", "bedroom", "dining", "study"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R304.1" }
+  },
+  {
+    "code_id": "IRC-RD-002",
+    "jurisdiction": { "country": "US" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum habitable room width",
+      "requirement": "Habitable rooms shall have a minimum horizontal dimension of not less than 2134 mm (7 ft)",
+      "min_value": 2134,
+      "unit": "mm",
+      "applies_to": ["living_room", "bedroom", "dining", "study"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R304.2" }
+  },
+  {
+    "code_id": "IRC-RD-003",
+    "jurisdiction": { "country": "US" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum ceiling height for habitable rooms",
+      "requirement": "Habitable rooms shall have a ceiling height of not less than 2134 mm (7 ft)",
+      "min_value": 2134,
+      "unit": "mm",
+      "applies_to": ["living_room", "bedroom", "dining", "study", "kitchen"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R305.1" }
+  },
+  {
+    "code_id": "IRC-RD-004",
+    "jurisdiction": { "country": "US" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum bathroom ceiling height",
+      "requirement": "Bathrooms shall have a minimum ceiling height of 1981 mm (6 ft 6 in)",
+      "min_value": 1981,
+      "unit": "mm",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R305.1.1" }
+  },
+  {
+    "code_id": "IRC-RD-005",
+    "jurisdiction": { "country": "US" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum kitchen area",
+      "requirement": "Kitchen shall have a minimum floor area of 4.645 sq.m (50 sq.ft)",
+      "min_value": 4.645,
+      "unit": "sqm",
+      "applies_to": ["kitchen"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R304.1" }
+  },
+  {
+    "code_id": "IRC-RD-006",
+    "jurisdiction": { "country": "US" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum corridor width",
+      "requirement": "Hallways shall have a minimum width of 914 mm (3 ft)",
+      "min_value": 914,
+      "unit": "mm",
+      "applies_to": ["corridor"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R311.6" }
+  },
+  {
+    "code_id": "IRC-VT-001",
+    "jurisdiction": { "country": "US" },
+    "category": "ventilation",
+    "rule": {
+      "description": "Minimum natural ventilation area",
+      "requirement": "Habitable rooms shall have openable area of not less than 4% of the floor area",
+      "min_value": 0.04,
+      "unit": "ratio_of_floor_area",
+      "applies_to": ["living_room", "bedroom", "dining", "study", "kitchen"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R303.1" }
+  },
+  {
+    "code_id": "IRC-VT-002",
+    "jurisdiction": { "country": "US" },
+    "category": "ventilation",
+    "rule": {
+      "description": "Bathroom exhaust ventilation",
+      "requirement": "Bathrooms shall have mechanical ventilation of not less than 50 cfm (intermittent) or 20 cfm (continuous)",
+      "min_value": 20,
+      "unit": "ach",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section M1507.4" }
+  },
+  {
+    "code_id": "IRC-FS-001",
+    "jurisdiction": { "country": "US" },
+    "category": "fire_safety",
+    "rule": {
+      "description": "Smoke alarm requirement",
+      "requirement": "Smoke alarms shall be installed in each sleeping room, outside each sleeping area, and on every level",
+      "min_value": 1,
+      "unit": "per_room",
+      "applies_to": ["living_room", "bedroom", "corridor"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R314.3" }
+  },
+  {
+    "code_id": "IRC-FS-002",
+    "jurisdiction": { "country": "US" },
+    "category": "fire_safety",
+    "rule": {
+      "description": "Carbon monoxide alarm requirement",
+      "requirement": "CO alarms required outside each sleeping area in dwellings with fuel-burning appliances or attached garages",
+      "min_value": 1,
+      "unit": "per_room",
+      "applies_to": ["bedroom", "corridor"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R315.1" }
+  },
+  {
+    "code_id": "IRC-EL-001",
+    "jurisdiction": { "country": "US" },
+    "category": "electrical",
+    "rule": {
+      "description": "Minimum receptacle outlets per room",
+      "requirement": "Habitable rooms shall have receptacle outlets so that no point along wall is more than 1829 mm (6 ft) from an outlet",
+      "min_value": 2,
+      "unit": "outlets",
+      "applies_to": ["living_room", "bedroom", "dining", "study"]
+    },
+    "source": { "document": "NEC 2020", "edition": "2020", "clause": "Section 210.52(A)" }
+  },
+  {
+    "code_id": "IRC-EL-002",
+    "jurisdiction": { "country": "US" },
+    "category": "electrical",
+    "rule": {
+      "description": "Kitchen dedicated circuits",
+      "requirement": "Kitchen shall have a minimum of two 20-ampere small appliance branch circuits",
+      "min_value": 20,
+      "unit": "amps",
+      "applies_to": ["kitchen"]
+    },
+    "source": { "document": "NEC 2020", "edition": "2020", "clause": "Section 210.11(C)(1)" }
+  },
+  {
+    "code_id": "IRC-EL-003",
+    "jurisdiction": { "country": "US" },
+    "category": "electrical",
+    "rule": {
+      "description": "Bathroom GFCI protection",
+      "requirement": "All 125V receptacles in bathrooms shall have GFCI protection",
+      "min_value": 1,
+      "unit": "outlets",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "NEC 2020", "edition": "2020", "clause": "Section 210.8(A)(1)" }
+  },
+  {
+    "code_id": "IRC-PL-001",
+    "jurisdiction": { "country": "US" },
+    "category": "plumbing",
+    "rule": {
+      "description": "Minimum water supply per person",
+      "requirement": "Minimum 189 litres (50 gallons) per capita per day for residential buildings",
+      "min_value": 189,
+      "unit": "lpcd",
+      "applies_to": ["bathroom", "kitchen"]
+    },
+    "source": { "document": "IPC 2021", "edition": "2021", "clause": "Section 604.1" }
+  },
+  {
+    "code_id": "IRC-PL-002",
+    "jurisdiction": { "country": "US" },
+    "category": "plumbing",
+    "rule": {
+      "description": "Bathroom floor slope for drainage",
+      "requirement": "Shower floors shall slope uniformly at minimum 1/4 inch per foot (1:48)",
+      "min_value": 0.021,
+      "unit": "slope_ratio",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "IPC 2021", "edition": "2021", "clause": "Section 417.5.2" }
+  },
+  {
+    "code_id": "IRC-AC-001",
+    "jurisdiction": { "country": "US" },
+    "category": "accessibility",
+    "rule": {
+      "description": "Minimum door width for accessibility",
+      "requirement": "Accessible doors shall have minimum clear opening of 813 mm (32 in)",
+      "min_value": 813,
+      "unit": "mm",
+      "applies_to": ["living_room", "bedroom", "bathroom", "kitchen", "dining", "corridor"]
+    },
+    "source": { "document": "ADA Standards", "edition": "2010", "clause": "Section 404.2.3" }
+  },
+  {
+    "code_id": "IRC-AC-002",
+    "jurisdiction": { "country": "US" },
+    "category": "accessibility",
+    "rule": {
+      "description": "Accessible bathroom turning radius",
+      "requirement": "Accessible bathrooms shall have a 1524 mm (60 in) diameter turning space",
+      "min_value": 1524,
+      "unit": "mm",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "ADA Standards", "edition": "2010", "clause": "Section 603.2.1" }
+  },
+  {
+    "code_id": "IRC-FS-003",
+    "jurisdiction": { "country": "US" },
+    "category": "fire_safety",
+    "rule": {
+      "description": "Emergency egress window size",
+      "requirement": "Sleeping rooms shall have emergency escape openings of minimum 0.515 sq.m (5.7 sq.ft) net clear",
+      "min_value": 0.515,
+      "unit": "sqm",
+      "applies_to": ["bedroom"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R310.1" }
+  },
+  {
+    "code_id": "IRC-RD-007",
+    "jurisdiction": { "country": "US" },
+    "category": "room_dimensions",
+    "rule": {
+      "description": "Minimum bathroom area",
+      "requirement": "Bathroom shall have a minimum floor area of approximately 2.323 sq.m (25 sq.ft)",
+      "min_value": 2.323,
+      "unit": "sqm",
+      "applies_to": ["bathroom"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section R306" }
+  },
+  {
+    "code_id": "IRC-VT-003",
+    "jurisdiction": { "country": "US" },
+    "category": "ventilation",
+    "rule": {
+      "description": "Kitchen ventilation requirement",
+      "requirement": "Kitchen range hoods shall exhaust to the outdoors at minimum 100 cfm",
+      "min_value": 6,
+      "unit": "ach",
+      "applies_to": ["kitchen"]
+    },
+    "source": { "document": "IRC 2021", "edition": "2021", "clause": "Section M1503.1" }
+  }
+]
diff --git a/docker-compose.yml b/docker-compose.yml
index 3385044..60911a1 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -287,6 +287,37 @@ services:
       redis:
         condition: service_healthy
 
+  vision-engine:
+    build:
+      context: .
+      dockerfile: services/vision-engine/Dockerfile
+    container_name: openlintel-vision-engine
+    restart: unless-stopped
+    ports:
+      - '8010:8010'
+    environment:
+      DATABASE_URL: postgresql+asyncpg://openlintel:openlintel_dev@postgres:5432/openlintel
+      REDIS_URL: redis://redis:6379
+      MINIO_ENDPOINT: http://minio:9000
+      MINIO_ACCESS_KEY: minioadmin
+      MINIO_SECRET_KEY: minioadmin
+      MINIO_BUCKET: openlintel
+      JWT_SECRET: ${NEXTAUTH_SECRET:-dev-secret}
+      API_KEY_ENCRYPTION_SECRET: ${API_KEY_ENCRYPTION_SECRET:-dev-encryption-secret-32chars!!}
+      LOG_LEVEL: info
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+      minio:
+        condition: service_started
+    healthcheck:
+      test: ['CMD', 'python', '-c', 'import httpx; httpx.get("http://localhost:8010/health")']
+      interval: 15s
+      timeout: 10s
+      retries: 3
+
 volumes:
   postgres_data:
   redis_data:
diff --git a/ml/product-matching/src/openlintel_product_matching/embedder.py b/ml/product-matching/src/openlintel_product_matching/embedder.py
new file mode 100644
index 0000000..2de8ebb
--- /dev/null
+++ b/ml/product-matching/src/openlintel_product_matching/embedder.py
@@ -0,0 +1,218 @@
+"""
+Product embedder using CLIP ViT-B/32.
+
+Generates 512-dimensional embeddings for images and text using OpenAI's
+CLIP model via torchvision.  The model is lazily loaded on first use and
+cached for subsequent calls, following the ``SAM2Wrapper`` pattern from
+``ml/room-segmentation/``.
+"""
+
+from __future__ import annotations
+
+import io
+import logging
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+# CLIP ViT-B/32 produces 512-dim embeddings
+EMBEDDING_DIM = 512
+
+
+class ProductEmbedder:
+    """CLIP-based product image/text embedder.
+
+    The model is lazily loaded on first use and cached for subsequent calls.
+
+    Parameters
+    ----------
+    model_name:
+        CLIP model variant.  Currently only ``"clip"`` (ViT-B/32) is supported.
+    device:
+        PyTorch device string.  ``"auto"`` selects CUDA if available.
+    """
+
+    def __init__(
+        self,
+        model_name: str = "clip",
+        device: str = "auto",
+    ) -> None:
+        self._model_name = model_name
+        self._device = self._resolve_device(device)
+        self._model: Any | None = None
+        self._preprocess: Any | None = None
+        self._tokenizer: Any | None = None
+
+    @staticmethod
+    def _resolve_device(device: str) -> torch.device:
+        if device == "auto":
+            if torch.cuda.is_available():
+                return torch.device("cuda")
+            if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+                return torch.device("mps")
+            return torch.device("cpu")
+        return torch.device(device)
+
+    def _load_model(self) -> None:
+        """Lazily load the CLIP model."""
+        if self._model is not None:
+            return
+
+        logger.info("loading_clip_model", device=str(self._device))
+
+        try:
+            import clip  # type: ignore[import-untyped]
+
+            model, preprocess = clip.load("ViT-B/32", device=self._device)
+            self._model = model
+            self._preprocess = preprocess
+            self._tokenizer = clip.tokenize
+        except ImportError:
+            # Fallback: use torchvision CLIP
+            from torchvision.models import get_model
+            from torchvision.transforms import (
+                CenterCrop,
+                Compose,
+                Normalize,
+                Resize,
+                ToTensor,
+            )
+
+            model = get_model("vit_b_32", weights="DEFAULT")
+            model = model.to(self._device)
+            model.eval()
+            self._model = model
+            self._preprocess = Compose([
+                Resize(224),
+                CenterCrop(224),
+                ToTensor(),
+                Normalize(
+                    mean=[0.48145466, 0.4578275, 0.40821073],
+                    std=[0.26862954, 0.26130258, 0.27577711],
+                ),
+            ])
+            self._tokenizer = None
+
+        logger.info("clip_model_loaded", device=str(self._device))
+
+    def embed_image(self, image: Image.Image) -> list[float]:
+        """Embed a PIL Image into a 512-dim vector.
+
+        Parameters
+        ----------
+        image:
+            A PIL Image.
+
+        Returns
+        -------
+        list[float]
+            512-dimensional normalised embedding.
+        """
+        self._load_model()
+
+        image_input = self._preprocess(image).unsqueeze(0).to(self._device)  # type: ignore[union-attr]
+
+        with torch.no_grad():
+            if hasattr(self._model, "encode_image"):
+                features = self._model.encode_image(image_input)
+            else:
+                features = self._model(image_input)
+
+            features = features / features.norm(dim=-1, keepdim=True)
+
+        return features.squeeze().cpu().numpy().tolist()
+
+    def embed_images_batch(self, images: list[Image.Image]) -> list[list[float]]:
+        """Embed multiple images in a batch.
+
+        Parameters
+        ----------
+        images:
+            List of PIL Images.
+
+        Returns
+        -------
+        list[list[float]]
+            List of 512-dimensional embeddings.
+        """
+        self._load_model()
+
+        tensors = torch.stack(
+            [self._preprocess(img) for img in images]  # type: ignore[union-attr]
+        ).to(self._device)
+
+        with torch.no_grad():
+            if hasattr(self._model, "encode_image"):
+                features = self._model.encode_image(tensors)
+            else:
+                features = self._model(tensors)
+
+            features = features / features.norm(dim=-1, keepdim=True)
+
+        return features.cpu().numpy().tolist()
+
+    def embed_from_bytes(self, data: bytes) -> list[float]:
+        """Embed an image from raw bytes."""
+        image = Image.open(io.BytesIO(data)).convert("RGB")
+        return self.embed_image(image)
+
+    def embed_from_path(self, path: str | Path) -> list[float]:
+        """Embed an image from a file path."""
+        image = Image.open(path).convert("RGB")
+        return self.embed_image(image)
+
+    def embed_from_url(self, url: str) -> list[float]:
+        """Embed an image from a URL.
+
+        Parameters
+        ----------
+        url:
+            HTTP(S) URL of the image.
+
+        Returns
+        -------
+        list[float]
+            512-dimensional embedding.
+        """
+        import httpx
+
+        response = httpx.get(url, timeout=30)
+        response.raise_for_status()
+        return self.embed_from_bytes(response.content)
+
+    def embed_text(self, text: str) -> list[float]:
+        """Embed a text string using CLIP's text encoder.
+
+        Parameters
+        ----------
+        text:
+            A text description.
+
+        Returns
+        -------
+        list[float]
+            512-dimensional normalised embedding.
+        """
+        self._load_model()
+
+        if self._tokenizer is not None and hasattr(self._model, "encode_text"):
+            tokens = self._tokenizer([text]).to(self._device)
+            with torch.no_grad():
+                features = self._model.encode_text(tokens)
+                features = features / features.norm(dim=-1, keepdim=True)
+            return features.squeeze().cpu().numpy().tolist()
+
+        # Fallback: use image embedding of a rendered text placeholder
+        logger.warning("text_embedding_fallback", hint="CLIP text encoder not available")
+        img = Image.new("RGB", (224, 224), (255, 255, 255))
+        return self.embed_image(img)
+
+    @property
+    def dimension(self) -> int:
+        """Return the embedding dimension."""
+        return EMBEDDING_DIM
diff --git a/ml/product-matching/src/openlintel_product_matching/indexer.py b/ml/product-matching/src/openlintel_product_matching/indexer.py
new file mode 100644
index 0000000..894f15d
--- /dev/null
+++ b/ml/product-matching/src/openlintel_product_matching/indexer.py
@@ -0,0 +1,137 @@
+"""
+Product embedding indexer for pgvector.
+
+Provides async operations to store, retrieve, and delete product embeddings
+in PostgreSQL using the pgvector extension.  Uses ``sqlalchemy.text()``
+following the same pattern as ``job_worker.py``.
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Any
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+logger = logging.getLogger(__name__)
+
+
+class ProductIndexer:
+    """Async pgvector operations for product embeddings.
+
+    Parameters
+    ----------
+    db:
+        An async SQLAlchemy session.
+    table:
+        The embeddings table name.
+    """
+
+    def __init__(self, db: AsyncSession, *, table: str = "product_embeddings") -> None:
+        self._db = db
+        self._table = table
+
+    async def index_product(
+        self,
+        product_id: str,
+        embedding: list[float],
+        *,
+        metadata: dict[str, Any] | None = None,
+    ) -> str:
+        """Store a single product embedding (upsert).
+
+        Parameters
+        ----------
+        product_id:
+            The product identifier.
+        embedding:
+            The embedding vector.
+        metadata:
+            Optional metadata dict.
+
+        Returns
+        -------
+        str
+            The product_id.
+        """
+        embedding_str = "[" + ",".join(str(v) for v in embedding) + "]"
+
+        await self._db.execute(
+            text(f"""
+                INSERT INTO {self._table} (product_id, embedding)
+                VALUES (:product_id, :embedding::vector)
+                ON CONFLICT (product_id)
+                DO UPDATE SET embedding = :embedding::vector, updated_at = NOW()
+            """),
+            {"product_id": product_id, "embedding": embedding_str},
+        )
+        await self._db.commit()
+
+        logger.debug("product_indexed", product_id=product_id, dim=len(embedding))
+        return product_id
+
+    async def index_batch(
+        self,
+        items: list[tuple[str, list[float]]],
+    ) -> list[str]:
+        """Index multiple product embeddings.
+
+        Parameters
+        ----------
+        items:
+            List of (product_id, embedding) tuples.
+
+        Returns
+        -------
+        list[str]
+            List of product_ids that were indexed.
+        """
+        indexed: list[str] = []
+        for product_id, embedding in items:
+            await self.index_product(product_id, embedding)
+            indexed.append(product_id)
+
+        logger.info("batch_indexed", count=len(indexed))
+        return indexed
+
+    async def delete_product(self, product_id: str) -> None:
+        """Delete a product's embedding.
+
+        Parameters
+        ----------
+        product_id:
+            The product identifier to delete.
+        """
+        await self._db.execute(
+            text(f"DELETE FROM {self._table} WHERE product_id = :product_id"),
+            {"product_id": product_id},
+        )
+        await self._db.commit()
+        logger.debug("product_embedding_deleted", product_id=product_id)
+
+    async def get_embedding(self, product_id: str) -> list[float] | None:
+        """Retrieve a stored embedding for a product.
+
+        Parameters
+        ----------
+        product_id:
+            The product identifier.
+
+        Returns
+        -------
+        list[float] | None
+            The embedding vector, or None if not found.
+        """
+        result = await self._db.execute(
+            text(f"SELECT embedding::text FROM {self._table} WHERE product_id = :product_id"),
+            {"product_id": product_id},
+        )
+        row = result.fetchone()
+        if row is None:
+            return None
+
+        # Parse pgvector text representation "[0.1,0.2,...]"
+        vec_str = row[0].strip("[]")
+        return [float(v) for v in vec_str.split(",")]
diff --git a/ml/product-matching/src/openlintel_product_matching/pipeline.py b/ml/product-matching/src/openlintel_product_matching/pipeline.py
new file mode 100644
index 0000000..685ce2d
--- /dev/null
+++ b/ml/product-matching/src/openlintel_product_matching/pipeline.py
@@ -0,0 +1,240 @@
+"""
+Product matching pipeline: Image → Embed → Search → Rerank.
+
+Orchestrates the full visual product search workflow with graceful
+degradation.  Follows the ``SegmentationPipeline`` pattern from
+``ml/room-segmentation/``.
+
+- If the database is unavailable, embedding-only mode returns raw vectors.
+- If the VLM reranker fails, results are returned sorted by visual similarity.
+- CLIP model loading is deferred to first use.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from PIL import Image
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from openlintel_product_matching.embedder import ProductEmbedder
+from openlintel_product_matching.schemas import (
+    EmbeddingModel,
+    RerankerResult,
+    SearchResult,
+    VisualSearchResult,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ProductMatchingPipeline:
+    """End-to-end visual product search pipeline.
+
+    Combines CLIP embedding, pgvector search, and optional VLM reranking
+    into a single workflow.
+
+    Parameters
+    ----------
+    db:
+        Async SQLAlchemy session for pgvector operations.
+    embedder:
+        Optional pre-configured ``ProductEmbedder``.
+    device:
+        PyTorch device for CLIP (``"auto"`` / ``"cuda"`` / ``"cpu"``).
+    enable_reranking:
+        Whether to run VLM reranking on results.
+    reranker_model:
+        LiteLLM model identifier for the reranker.
+    reranker_api_key:
+        API key for the reranker VLM.
+    """
+
+    def __init__(
+        self,
+        db: AsyncSession | None = None,
+        *,
+        embedder: ProductEmbedder | None = None,
+        device: str = "auto",
+        enable_reranking: bool = True,
+        reranker_model: str = "openai/gpt-4o-mini",
+        reranker_api_key: str | None = None,
+    ) -> None:
+        self._db = db
+        self._embedder = embedder or ProductEmbedder(device=device)
+        self._enable_reranking = enable_reranking
+        self._reranker_model = reranker_model
+        self._reranker_api_key = reranker_api_key
+
+    async def search_by_image(
+        self,
+        image: Image.Image,
+        *,
+        top_k: int = 20,
+        min_score: float = 0.0,
+        filters: dict[str, Any] | None = None,
+        context: dict[str, Any] | None = None,
+        product_metadata: dict[str, dict[str, Any]] | None = None,
+    ) -> VisualSearchResult:
+        """Run the full pipeline on a query image.
+
+        Parameters
+        ----------
+        image:
+            The query image.
+        top_k:
+            Maximum number of results.
+        min_score:
+            Minimum similarity threshold.
+        filters:
+            Optional search filters (category, brand, max_price).
+        context:
+            Design context for reranking (room_type, style, budget).
+        product_metadata:
+            Product details keyed by product_id for reranking.
+
+        Returns
+        -------
+        VisualSearchResult
+            The search results with optional reranking.
+        """
+        # Step 1: Embed the query image
+        logger.info("pipeline_embed_start")
+        embedding = self._embedder.embed_image(image)
+        logger.info("pipeline_embed_done", dim=len(embedding))
+
+        # Step 2: Search pgvector
+        if self._db is None:
+            logger.warning("pipeline_no_db", hint="Returning embedding only")
+            return VisualSearchResult(
+                query_embedding_dim=len(embedding),
+                total_candidates=0,
+                results=[],
+                reranked=False,
+            )
+
+        from openlintel_product_matching.searcher import ProductSearcher
+
+        searcher = ProductSearcher(self._db)
+        candidates = await searcher.search(
+            embedding, top_k=top_k * 2, min_score=min_score, filters=filters,
+        )
+        logger.info("pipeline_search_done", candidates=len(candidates))
+
+        if not candidates:
+            return VisualSearchResult(
+                query_embedding_dim=len(embedding),
+                total_candidates=0,
+                results=[],
+                reranked=False,
+            )
+
+        # Step 3: Rerank with VLM (optional)
+        reranked = False
+        final_results: list[RerankerResult]
+
+        if self._enable_reranking and context:
+            try:
+                from openlintel_product_matching.reranker import VLMReranker
+
+                reranker = VLMReranker(
+                    model=self._reranker_model,
+                    api_key=self._reranker_api_key,
+                    max_candidates=min(top_k, len(candidates)),
+                )
+                final_results = await reranker.rerank(
+                    query_image=image,
+                    candidates=candidates[:top_k],
+                    product_metadata=product_metadata,
+                    context=context,
+                )
+                reranked = True
+                logger.info("pipeline_rerank_done", results=len(final_results))
+
+            except Exception as exc:
+                logger.warning("pipeline_rerank_failed", error=str(exc))
+                # Graceful degradation: use search results as-is
+                final_results = [
+                    RerankerResult(
+                        product_id=c.product_id,
+                        similarity_score=c.similarity_score,
+                        relevance_score=c.similarity_score,
+                    )
+                    for c in candidates[:top_k]
+                ]
+        else:
+            final_results = [
+                RerankerResult(
+                    product_id=c.product_id,
+                    similarity_score=c.similarity_score,
+                    relevance_score=c.similarity_score,
+                )
+                for c in candidates[:top_k]
+            ]
+
+        return VisualSearchResult(
+            query_embedding_dim=len(embedding),
+            total_candidates=len(candidates),
+            results=final_results,
+            model_used=EmbeddingModel.CLIP_VIT_B32,
+            reranked=reranked,
+        )
+
+    async def search_by_text(
+        self,
+        text: str,
+        *,
+        top_k: int = 20,
+        min_score: float = 0.0,
+        filters: dict[str, Any] | None = None,
+    ) -> VisualSearchResult:
+        """Search using a text description.
+
+        Parameters
+        ----------
+        text:
+            A text description of the desired product.
+        top_k:
+            Maximum number of results.
+        min_score:
+            Minimum similarity threshold.
+        filters:
+            Optional search filters.
+
+        Returns
+        -------
+        VisualSearchResult
+            The search results (no reranking for text-only queries).
+        """
+        embedding = self._embedder.embed_text(text)
+
+        if self._db is None:
+            return VisualSearchResult(
+                query_embedding_dim=len(embedding),
+                total_candidates=0,
+                results=[],
+                reranked=False,
+            )
+
+        from openlintel_product_matching.searcher import ProductSearcher
+
+        searcher = ProductSearcher(self._db)
+        candidates = await searcher.search(
+            embedding, top_k=top_k, min_score=min_score, filters=filters,
+        )
+
+        return VisualSearchResult(
+            query_embedding_dim=len(embedding),
+            total_candidates=len(candidates),
+            results=[
+                RerankerResult(
+                    product_id=c.product_id,
+                    similarity_score=c.similarity_score,
+                    relevance_score=c.similarity_score,
+                )
+                for c in candidates
+            ],
+            model_used=EmbeddingModel.CLIP_VIT_B32,
+            reranked=False,
+        )
diff --git a/ml/product-matching/src/openlintel_product_matching/reranker.py b/ml/product-matching/src/openlintel_product_matching/reranker.py
new file mode 100644
index 0000000..3c5f645
--- /dev/null
+++ b/ml/product-matching/src/openlintel_product_matching/reranker.py
@@ -0,0 +1,208 @@
+"""
+VLM-based reranker for product search results.
+
+Uses a vision-language model (GPT-4o-mini via LiteLLM) to rerank search
+results based on design context, budget constraints, and style preferences.
+Follows the ``vlm_detector.py`` pattern from ``ml/room-segmentation/``.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import logging
+from io import BytesIO
+from typing import Any
+
+import litellm
+from PIL import Image
+
+from openlintel_product_matching.schemas import RerankerResult, SearchResult
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_VLM_MODEL = "openai/gpt-4o-mini"
+
+
+class VLMReranker:
+    """Reranks product search results using a vision-language model.
+
+    The VLM evaluates each candidate product against the query context
+    (room type, design style, budget) and assigns relevance scores.
+
+    Parameters
+    ----------
+    model:
+        LiteLLM model identifier.
+    api_key:
+        API key for the model provider.
+    max_candidates:
+        Maximum number of candidates to send to the VLM for reranking.
+    """
+
+    def __init__(
+        self,
+        model: str = DEFAULT_VLM_MODEL,
+        api_key: str | None = None,
+        max_candidates: int = 10,
+    ) -> None:
+        self._model = model
+        self._api_key = api_key
+        self._max_candidates = max_candidates
+
+    async def rerank(
+        self,
+        query_image: Image.Image | None,
+        candidates: list[SearchResult],
+        *,
+        product_metadata: dict[str, dict[str, Any]] | None = None,
+        context: dict[str, Any] | None = None,
+    ) -> list[RerankerResult]:
+        """Rerank candidates using the VLM.
+
+        Parameters
+        ----------
+        query_image:
+            The query image (optional, used for visual context).
+        candidates:
+            List of search results to rerank.
+        product_metadata:
+            Product metadata keyed by product_id.
+        context:
+            Design context dict with keys like ``room_type``, ``style``,
+            ``budget_min``, ``budget_max``.
+
+        Returns
+        -------
+        list[RerankerResult]
+            Reranked results with relevance scores and reasoning.
+        """
+        if not candidates:
+            return []
+
+        top_candidates = candidates[: self._max_candidates]
+        product_meta = product_metadata or {}
+        ctx = context or {}
+
+        # Build the prompt
+        products_desc = []
+        for i, candidate in enumerate(top_candidates):
+            meta = product_meta.get(candidate.product_id, {})
+            desc = (
+                f"Product {i + 1} (ID: {candidate.product_id}): "
+                f"Name: {meta.get('name', 'Unknown')}, "
+                f"Category: {meta.get('category', 'Unknown')}, "
+                f"Price: {meta.get('price', 'Unknown')}, "
+                f"Material: {meta.get('material', 'Unknown')}, "
+                f"Style: {meta.get('style', 'Unknown')}, "
+                f"Visual similarity: {candidate.similarity_score:.3f}"
+            )
+            products_desc.append(desc)
+
+        context_parts = []
+        if ctx.get("room_type"):
+            context_parts.append(f"Room type: {ctx['room_type']}")
+        if ctx.get("style"):
+            context_parts.append(f"Design style: {ctx['style']}")
+        if ctx.get("budget_min") or ctx.get("budget_max"):
+            budget = f"Budget: {ctx.get('budget_min', 0)} - {ctx.get('budget_max', 'unlimited')}"
+            context_parts.append(budget)
+
+        context_str = "; ".join(context_parts) if context_parts else "No specific context"
+
+        system_prompt = (
+            "You are an interior design product recommendation engine. "
+            "Evaluate each product candidate for relevance to the design context. "
+            "Return a JSON array with objects containing: "
+            '"product_id", "relevance_score" (0.0-1.0), "reasoning" (brief).'
+        )
+
+        user_prompt = (
+            f"Design context: {context_str}\n\n"
+            f"Product candidates:\n" + "\n".join(products_desc) + "\n\n"
+            "Rank these products by relevance. Return JSON array only."
+        )
+
+        messages: list[dict[str, Any]] = [
+            {"role": "system", "content": system_prompt},
+        ]
+
+        # Add query image if available
+        if query_image is not None:
+            buf = BytesIO()
+            query_image.save(buf, format="JPEG", quality=85)
+            img_b64 = base64.b64encode(buf.getvalue()).decode("ascii")
+            data_uri = f"data:image/jpeg;base64,{img_b64}"
+            messages.append({
+                "role": "user",
+                "content": [
+                    {"type": "image_url", "image_url": {"url": data_uri}},
+                    {"type": "text", "text": user_prompt},
+                ],
+            })
+        else:
+            messages.append({"role": "user", "content": user_prompt})
+
+        try:
+            response = await litellm.acompletion(
+                model=self._model,
+                messages=messages,
+                api_key=self._api_key,
+                temperature=0.1,
+                max_tokens=1024,
+                response_format={"type": "json_object"},
+            )
+
+            content = response.choices[0].message.content or "[]"
+            # Parse VLM response
+            try:
+                parsed = json.loads(content)
+                if isinstance(parsed, dict) and "products" in parsed:
+                    rankings = parsed["products"]
+                elif isinstance(parsed, list):
+                    rankings = parsed
+                else:
+                    rankings = []
+            except json.JSONDecodeError:
+                logger.warning("vlm_rerank_parse_failed", content=content[:200])
+                rankings = []
+
+            # Map rankings back to results
+            ranking_map: dict[str, dict[str, Any]] = {}
+            for r in rankings:
+                pid = str(r.get("product_id", ""))
+                ranking_map[pid] = r
+
+            reranked: list[RerankerResult] = []
+            for candidate in top_candidates:
+                rank_data = ranking_map.get(candidate.product_id, {})
+                reranked.append(RerankerResult(
+                    product_id=candidate.product_id,
+                    similarity_score=candidate.similarity_score,
+                    relevance_score=float(rank_data.get("relevance_score", 0.5)),
+                    reasoning=str(rank_data.get("reasoning", "")),
+                    metadata=candidate.metadata,
+                ))
+
+            # Sort by combined score (relevance weighted higher)
+            reranked.sort(
+                key=lambda x: (0.6 * x.relevance_score + 0.4 * x.similarity_score),
+                reverse=True,
+            )
+
+            logger.info("vlm_rerank_complete", candidates=len(reranked))
+            return reranked
+
+        except Exception as exc:
+            logger.warning("vlm_rerank_failed", error=str(exc))
+            # Graceful degradation: return original order
+            return [
+                RerankerResult(
+                    product_id=c.product_id,
+                    similarity_score=c.similarity_score,
+                    relevance_score=c.similarity_score,
+                    reasoning="VLM reranking unavailable",
+                    metadata=c.metadata,
+                )
+                for c in top_candidates
+            ]
diff --git a/ml/product-matching/src/openlintel_product_matching/schemas.py b/ml/product-matching/src/openlintel_product_matching/schemas.py
new file mode 100644
index 0000000..607af08
--- /dev/null
+++ b/ml/product-matching/src/openlintel_product_matching/schemas.py
@@ -0,0 +1,68 @@
+"""
+Pydantic models for the product-matching pipeline.
+
+Defines data structures for embeddings, search queries, search results,
+VLM reranking, and the top-level visual search response.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class EmbeddingModel(str, Enum):
+    """Supported embedding model identifiers."""
+
+    CLIP_VIT_B32 = "clip-vit-b-32"
+    CLIP_VIT_L14 = "clip-vit-l-14"
+
+
+class ProductEmbedding(BaseModel):
+    """An embedding vector associated with a product."""
+
+    product_id: str
+    embedding: list[float]
+    model: EmbeddingModel = EmbeddingModel.CLIP_VIT_B32
+    dimension: int = 512
+
+
+class SearchQuery(BaseModel):
+    """A visual similarity search query."""
+
+    embedding: list[float]
+    top_k: int = Field(default=20, ge=1, le=100)
+    min_score: float = Field(default=0.0, ge=0.0, le=1.0)
+    filters: dict[str, Any] = Field(default_factory=dict)
+
+
+class SearchResult(BaseModel):
+    """A single result from a pgvector similarity search."""
+
+    product_id: str
+    similarity_score: float
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class RerankerResult(BaseModel):
+    """A result after VLM-based reranking."""
+
+    product_id: str
+    similarity_score: float
+    relevance_score: float = Field(
+        default=0.0, description="VLM-assessed relevance (0-1)"
+    )
+    reasoning: str = ""
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class VisualSearchResult(BaseModel):
+    """Top-level response from the product matching pipeline."""
+
+    query_embedding_dim: int = 512
+    total_candidates: int = 0
+    results: list[RerankerResult] = Field(default_factory=list)
+    model_used: EmbeddingModel = EmbeddingModel.CLIP_VIT_B32
+    reranked: bool = False
diff --git a/ml/product-matching/src/openlintel_product_matching/searcher.py b/ml/product-matching/src/openlintel_product_matching/searcher.py
new file mode 100644
index 0000000..8a1a0b6
--- /dev/null
+++ b/ml/product-matching/src/openlintel_product_matching/searcher.py
@@ -0,0 +1,228 @@
+"""
+Product similarity searcher using pgvector.
+
+Performs cosine-distance searches against stored product embeddings,
+with optional filtering and hybrid search combining visual similarity
+with text metadata.  Uses the ``<=>`` cosine distance operator following
+the ``vector_search.py`` pattern.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from PIL import Image
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from openlintel_product_matching.schemas import SearchQuery, SearchResult
+
+logger = logging.getLogger(__name__)
+
+
+class ProductSearcher:
+    """Cosine-similarity search over product embeddings.
+
+    Parameters
+    ----------
+    db:
+        An async SQLAlchemy session.
+    table:
+        The embeddings table name.
+    """
+
+    def __init__(self, db: AsyncSession, *, table: str = "product_embeddings") -> None:
+        self._db = db
+        self._table = table
+
+    async def search(
+        self,
+        embedding: list[float],
+        *,
+        top_k: int = 20,
+        min_score: float = 0.0,
+        filters: dict[str, Any] | None = None,
+    ) -> list[SearchResult]:
+        """Search for similar products by embedding.
+
+        Parameters
+        ----------
+        embedding:
+            The query embedding vector.
+        top_k:
+            Maximum number of results.
+        min_score:
+            Minimum similarity score threshold (0-1).
+        filters:
+            Optional filters (e.g. category, brand).
+
+        Returns
+        -------
+        list[SearchResult]
+            Ranked list of similar products.
+        """
+        embedding_str = "[" + ",".join(str(v) for v in embedding) + "]"
+
+        query = f"""
+            SELECT
+                pe.product_id,
+                1 - (pe.embedding <=> :embedding::vector) AS similarity_score
+            FROM {self._table} pe
+        """
+
+        params: dict[str, Any] = {
+            "embedding": embedding_str,
+            "limit": top_k,
+            "min_score": min_score,
+        }
+
+        conditions: list[str] = []
+
+        # Apply filters via JOIN to products table
+        if filters:
+            query = f"""
+                SELECT
+                    pe.product_id,
+                    1 - (pe.embedding <=> :embedding::vector) AS similarity_score
+                FROM {self._table} pe
+                JOIN products p ON p.id = pe.product_id
+            """
+            if "category" in filters:
+                conditions.append("p.category_name = :category")
+                params["category"] = filters["category"]
+            if "brand" in filters:
+                conditions.append("p.brand = :brand")
+                params["brand"] = filters["brand"]
+            if "max_price" in filters:
+                conditions.append("(p.price_amount IS NULL OR p.price_amount <= :max_price)")
+                params["max_price"] = filters["max_price"]
+
+        if conditions:
+            query += " WHERE " + " AND ".join(conditions)
+
+        query += """
+            HAVING 1 - (pe.embedding <=> :embedding::vector) >= :min_score
+            ORDER BY pe.embedding <=> :embedding::vector
+            LIMIT :limit
+        """
+
+        result = await self._db.execute(text(query), params)
+        rows = result.fetchall()
+
+        return [
+            SearchResult(
+                product_id=row[0],
+                similarity_score=float(row[1]),
+            )
+            for row in rows
+        ]
+
+    async def search_by_image(
+        self,
+        image: Image.Image,
+        *,
+        embedder: Any,
+        top_k: int = 20,
+        min_score: float = 0.0,
+        filters: dict[str, Any] | None = None,
+    ) -> list[SearchResult]:
+        """Search using a PIL image (embeds it first).
+
+        Parameters
+        ----------
+        image:
+            The query image.
+        embedder:
+            A ``ProductEmbedder`` instance.
+        top_k:
+            Maximum results.
+        min_score:
+            Minimum similarity threshold.
+        filters:
+            Optional filters.
+
+        Returns
+        -------
+        list[SearchResult]
+            Ranked results.
+        """
+        embedding = embedder.embed_image(image)
+        return await self.search(
+            embedding, top_k=top_k, min_score=min_score, filters=filters,
+        )
+
+    async def search_hybrid(
+        self,
+        embedding: list[float],
+        text_query: str | None = None,
+        *,
+        top_k: int = 20,
+        min_score: float = 0.0,
+        visual_weight: float = 0.7,
+    ) -> list[SearchResult]:
+        """Hybrid search combining visual similarity with text matching.
+
+        Performs visual search first, then boosts results whose product name
+        or description matches the text query.
+
+        Parameters
+        ----------
+        embedding:
+            The visual query embedding.
+        text_query:
+            Optional text search term.
+        top_k:
+            Maximum results.
+        min_score:
+            Minimum similarity threshold.
+        visual_weight:
+            Weight for visual score (0-1). Text weight = 1 - visual_weight.
+
+        Returns
+        -------
+        list[SearchResult]
+            Hybrid-ranked results.
+        """
+        # Get visual results with extra candidates for reranking
+        visual_results = await self.search(
+            embedding, top_k=top_k * 2, min_score=min_score,
+        )
+
+        if not text_query or not visual_results:
+            return visual_results[:top_k]
+
+        # Boost products matching text query
+        text_weight = 1.0 - visual_weight
+        product_ids = [r.product_id for r in visual_results]
+        pid_list = ",".join(f"'{pid}'" for pid in product_ids)
+
+        text_query_lower = text_query.lower()
+        result = await self._db.execute(
+            text(f"""
+                SELECT id,
+                    CASE
+                        WHEN LOWER(name) LIKE :pattern THEN 1.0
+                        WHEN LOWER(description) LIKE :pattern THEN 0.7
+                        ELSE 0.0
+                    END AS text_score
+                FROM products
+                WHERE id IN ({pid_list})
+            """),
+            {"pattern": f"%{text_query_lower}%"},
+        )
+        text_scores = {row[0]: float(row[1]) for row in result.fetchall()}
+
+        # Combine scores
+        combined = []
+        for r in visual_results:
+            ts = text_scores.get(r.product_id, 0.0)
+            combined_score = (visual_weight * r.similarity_score) + (text_weight * ts)
+            combined.append(SearchResult(
+                product_id=r.product_id,
+                similarity_score=combined_score,
+                metadata={"visual_score": r.similarity_score, "text_score": ts},
+            ))
+
+        combined.sort(key=lambda x: x.similarity_score, reverse=True)
+        return combined[:top_k]
diff --git a/packages/db/src/schema/app.ts b/packages/db/src/schema/app.ts
index 02ab633..8238e17 100644
--- a/packages/db/src/schema/app.ts
+++ b/packages/db/src/schema/app.ts
@@ -169,6 +169,7 @@ export const drawingResults = pgTable('drawing_results', {
   dxfStorageKey: text('dxf_storage_key'),
   pdfStorageKey: text('pdf_storage_key'),
   svgStorageKey: text('svg_storage_key'),
+  ifcStorageKey: text('ifc_storage_key'),
   metadata: jsonb('metadata'),
   createdAt: timestamp('created_at', { mode: 'date' }).defaultNow().notNull(),
 });
diff --git a/packages/python-shared/src/openlintel_shared/job_worker.py b/packages/python-shared/src/openlintel_shared/job_worker.py
index f8f7bfd..9dea188 100644
--- a/packages/python-shared/src/openlintel_shared/job_worker.py
+++ b/packages/python-shared/src/openlintel_shared/job_worker.py
@@ -161,6 +161,7 @@ async def write_drawing_result(
     dxf_storage_key: str | None = None,
     pdf_storage_key: str | None = None,
     svg_storage_key: str | None = None,
+    ifc_storage_key: str | None = None,
     metadata: dict[str, Any] | None = None,
 ) -> str:
     """Insert a row into ``drawing_results`` and return the new ID."""
@@ -169,9 +170,11 @@ async def write_drawing_result(
         text("""
             INSERT INTO drawing_results
                 (id, design_variant_id, job_id, drawing_type,
-                 dxf_storage_key, pdf_storage_key, svg_storage_key, metadata)
+                 dxf_storage_key, pdf_storage_key, svg_storage_key,
+                 ifc_storage_key, metadata)
             VALUES (:id, :design_variant_id, :job_id, :drawing_type,
-                    :dxf_storage_key, :pdf_storage_key, :svg_storage_key, :metadata)
+                    :dxf_storage_key, :pdf_storage_key, :svg_storage_key,
+                    :ifc_storage_key, :metadata)
         """),
         {
             "id": result_id,
@@ -181,6 +184,7 @@ async def write_drawing_result(
             "dxf_storage_key": dxf_storage_key,
             "pdf_storage_key": pdf_storage_key,
             "svg_storage_key": svg_storage_key,
+            "ifc_storage_key": ifc_storage_key,
             "metadata": json.dumps(metadata or {}),
         },
     )
diff --git a/services/catalogue-service/src/services/vector_search.py b/services/catalogue-service/src/services/vector_search.py
index 3e8cd40..1145fb0 100644
--- a/services/catalogue-service/src/services/vector_search.py
+++ b/services/catalogue-service/src/services/vector_search.py
@@ -174,6 +174,50 @@ async def search_similar_products(
     ]
 
 
+async def generate_visual_embedding(
+    image_url: str,
+) -> list[float] | None:
+    """Generate a CLIP visual embedding from an image URL.
+
+    Downloads the image and runs it through the ProductEmbedder (CLIP ViT-B/32)
+    to produce a 512-dimensional embedding for visual similarity search.
+
+    Parameters
+    ----------
+    image_url:
+        HTTP(S) URL of the product image.
+
+    Returns
+    -------
+    list[float] | None
+        512-dimensional CLIP embedding, or None if generation fails.
+    """
+    try:
+        from openlintel_product_matching import ProductEmbedder
+
+        embedder = ProductEmbedder()
+        embedding = embedder.embed_from_url(image_url)
+        logger.debug(
+            "visual_embedding_generated",
+            image_url=image_url,
+            dimension=len(embedding),
+        )
+        return embedding
+    except ImportError:
+        logger.warning(
+            "clip_embedding_unavailable",
+            hint="openlintel-product-matching not installed, falling back to text embedding",
+        )
+        return None
+    except Exception as exc:
+        logger.warning(
+            "visual_embedding_failed",
+            image_url=image_url,
+            error=str(exc),
+        )
+        return None
+
+
 async def delete_product_embedding(
     db: AsyncSession,
     product_id: str,
diff --git a/services/drawing-generator/pyproject.toml b/services/drawing-generator/pyproject.toml
index 94e6759..9701918 100644
--- a/services/drawing-generator/pyproject.toml
+++ b/services/drawing-generator/pyproject.toml
@@ -17,6 +17,7 @@ dependencies = [
     "reportlab>=4.1,<5",
     "svgwrite>=1.4,<2",
     "httpx>=0.27,<1",
+    "ifcopenshell>=0.7",
 ]
 
 [project.optional-dependencies]
diff --git a/services/drawing-generator/src/routers/drawings.py b/services/drawing-generator/src/routers/drawings.py
index 658d56b..12d9002 100644
--- a/services/drawing-generator/src/routers/drawings.py
+++ b/services/drawing-generator/src/routers/drawings.py
@@ -27,6 +27,7 @@
 from src.agents.drawing_agent import DrawingAgent
 from src.services.dxf_writer import create_dxf_drawing
 from src.services.svg_writer import create_svg_drawing
+from src.services.ifc_writer import create_ifc_drawing
 
 logger = structlog.get_logger(__name__)
 
@@ -97,6 +98,7 @@ async def _run_drawing_job(
 
                     dxf_key: str | None = None
                     svg_key: str | None = None
+                    ifc_key: str | None = None
 
                     if drawing_data:
                         # Generate DXF and upload to MinIO
@@ -115,6 +117,19 @@ async def _run_drawing_job(
                             content_type="image/svg+xml", settings=settings,
                         )
 
+                        # Generate IFC (BIM) and upload
+                        try:
+                            ifc_bytes = create_ifc_drawing(drawing_data, drawing_type=dtype)
+                            ifc_key = f"drawings/{request.job_id}/{dtype}.ifc"
+                            upload_file(
+                                settings.MINIO_BUCKET, ifc_key, ifc_bytes,
+                                content_type="application/x-step", settings=settings,
+                            )
+                        except ImportError:
+                            logger.warning("ifc_skipped", reason="ifcopenshell not installed")
+                        except Exception as ifc_exc:
+                            logger.warning("ifc_generation_failed", error=str(ifc_exc))
+
                     # Persist to DB
                     rid = await write_drawing_result(
                         db,
@@ -123,6 +138,7 @@ async def _run_drawing_job(
                         drawing_type=dtype,
                         dxf_storage_key=dxf_key,
                         svg_storage_key=svg_key,
+                        ifc_storage_key=ifc_key,
                         metadata={"scale": "1:50"},
                     )
                     result_ids.append(rid)
diff --git a/services/drawing-generator/src/services/ifc_writer.py b/services/drawing-generator/src/services/ifc_writer.py
new file mode 100644
index 0000000..c278b71
--- /dev/null
+++ b/services/drawing-generator/src/services/ifc_writer.py
@@ -0,0 +1,292 @@
+"""
+IFC (Industry Foundation Classes) writer using ifcopenshell.
+
+Creates IFC4-compliant BIM files from the same ``drawing_data`` dict used by
+``dxf_writer.py``.  Maps walls, doors, windows, and furniture to their IFC
+equivalents: IfcWall, IfcDoor, IfcWindow, and IfcFurnishingElement.
+"""
+
+from __future__ import annotations
+
+import io
+import uuid
+from typing import Any
+
+import structlog
+
+logger = structlog.get_logger(__name__)
+
+
+def _guid() -> str:
+    """Return a 22-char IFC GlobalId from a random UUID."""
+    try:
+        import ifcopenshell.guid as ifc_guid
+
+        return ifc_guid.new()
+    except Exception:
+        # Fallback: base64-encoded UUID truncated to 22 chars
+        import base64
+
+        raw = uuid.uuid4().bytes
+        return base64.urlsafe_b64encode(raw).decode("ascii")[:22]
+
+
+def create_ifc_drawing(
+    drawing_data: dict[str, Any],
+    drawing_type: str = "floor_plan",
+    schema: str = "IFC4",
+) -> bytes:
+    """Create an IFC file from structured drawing data.
+
+    Parameters
+    ----------
+    drawing_data:
+        The structured drawing data from the DrawingAgent (same format as
+        ``dxf_writer.create_dxf_drawing``).
+    drawing_type:
+        The drawing type label (for metadata only).
+    schema:
+        IFC schema version.
+
+    Returns
+    -------
+    bytes
+        The serialised IFC file content.
+    """
+    try:
+        import ifcopenshell
+    except ImportError:
+        logger.warning("ifcopenshell_not_installed", hint="pip install ifcopenshell")
+        raise ImportError(
+            "ifcopenshell is required for IFC export. "
+            "Install it with: pip install 'ifcopenshell>=0.7'"
+        )
+
+    ifc = ifcopenshell.file(schema=schema)
+
+    # ── Contexts & Units ─────────────────────────────────────
+    # Create geometric representation context
+    origin = ifc.createIfcCartesianPoint((0.0, 0.0, 0.0))
+    z_axis = ifc.createIfcDirection((0.0, 0.0, 1.0))
+    x_axis = ifc.createIfcDirection((1.0, 0.0, 0.0))
+    world_coordinate = ifc.createIfcAxis2Placement3D(origin, z_axis, x_axis)
+    context = ifc.createIfcGeometricRepresentationContext(
+        "Model", "Model", 3, 1.0e-05, world_coordinate
+    )
+    body_context = ifc.createIfcGeometricRepresentationSubContext(
+        "Body", "Model", None, None, None, None, context, None, "MODEL_VIEW", None
+    )
+
+    # Units — millimetres
+    mm_unit = ifc.createIfcSIUnit(None, "LENGTHUNIT", "MILLI", "METRE")
+    sqm_unit = ifc.createIfcSIUnit(None, "AREAUNIT", None, "SQUARE_METRE")
+    cbm_unit = ifc.createIfcSIUnit(None, "VOLUMEUNIT", None, "CUBIC_METRE")
+    radian_unit = ifc.createIfcSIUnit(None, "PLANEANGLEUNIT", None, "RADIAN")
+    unit_assignment = ifc.createIfcUnitAssignment([mm_unit, sqm_unit, cbm_unit, radian_unit])
+
+    # ── Project / Site / Building / Storey ────────────────────
+    owner_history = ifc.createIfcOwnerHistory(
+        ifc.createIfcPersonAndOrganization(
+            ifc.createIfcPerson(None, "OpenLintel", None, None, None, None, None, None),
+            ifc.createIfcOrganization(None, "OpenLintel", None, None, None),
+            None,
+        ),
+        ifc.createIfcApplication(
+            ifc.createIfcOrganization(None, "OpenLintel", None, None, None),
+            "0.1.0",
+            "OpenLintel Drawing Generator",
+            "OpenLintel",
+        ),
+        None,
+        "READWRITE",
+        None,
+        None,
+        None,
+        0,
+    )
+
+    project = ifc.createIfcProject(
+        _guid(), owner_history, "OpenLintel Project", None, None, None, None,
+        [context], unit_assignment,
+    )
+
+    site_placement = ifc.createIfcLocalPlacement(None, world_coordinate)
+    site = ifc.createIfcSite(
+        _guid(), owner_history, "Default Site", None, None,
+        site_placement, None, None, "ELEMENT", None, None, None, None, None,
+    )
+    ifc.createIfcRelAggregates(_guid(), owner_history, None, None, project, [site])
+
+    building_placement = ifc.createIfcLocalPlacement(site_placement, world_coordinate)
+    building = ifc.createIfcBuilding(
+        _guid(), owner_history, "Default Building", None, None,
+        building_placement, None, None, "ELEMENT", None, None, None,
+    )
+    ifc.createIfcRelAggregates(_guid(), owner_history, None, None, site, [building])
+
+    storey_placement = ifc.createIfcLocalPlacement(building_placement, world_coordinate)
+    storey = ifc.createIfcBuildingStorey(
+        _guid(), owner_history, "Ground Floor", None, None,
+        storey_placement, None, None, "ELEMENT", 0.0,
+    )
+    ifc.createIfcRelAggregates(_guid(), owner_history, None, None, building, [storey])
+
+    # ── Helpers ───────────────────────────────────────────────
+    room_dims = drawing_data.get("room_dimensions", {})
+    length_mm = float(room_dims.get("length_mm", 4000))
+    width_mm = float(room_dims.get("width_mm", 3000))
+    height_mm = float(room_dims.get("height_mm", 2700))
+
+    def _make_extrusion(
+        x: float, y: float, dx: float, dy: float, dz: float,
+    ) -> Any:
+        """Create an extruded-area solid from a rectangle."""
+        pts = [
+            ifc.createIfcCartesianPoint((0.0, 0.0)),
+            ifc.createIfcCartesianPoint((dx, 0.0)),
+            ifc.createIfcCartesianPoint((dx, dy)),
+            ifc.createIfcCartesianPoint((0.0, dy)),
+        ]
+        polyline = ifc.createIfcPolyline(pts + [pts[0]])
+        profile = ifc.createIfcArbitraryClosedProfileDef("AREA", None, polyline)
+        direction = ifc.createIfcDirection((0.0, 0.0, 1.0))
+        solid = ifc.createIfcExtrudedAreaSolid(profile, None, direction, dz)
+
+        local_origin = ifc.createIfcCartesianPoint((x, y, 0.0))
+        local_placement_3d = ifc.createIfcAxis2Placement3D(local_origin, None, None)
+        placement = ifc.createIfcLocalPlacement(storey_placement, local_placement_3d)
+
+        shape_repr = ifc.createIfcShapeRepresentation(
+            body_context, "Body", "SweptSolid", [solid]
+        )
+        product_repr = ifc.createIfcProductDefinitionShape(None, None, [shape_repr])
+        return placement, product_repr
+
+    products: list[Any] = []
+
+    # ── Walls ─────────────────────────────────────────────────
+    entities = drawing_data.get("entities", {})
+    walls = entities.get("walls", [])
+    wall_thickness = 150.0  # default
+
+    if walls:
+        for wall in walls:
+            sx = float(wall.get("start_x", 0))
+            sy = float(wall.get("start_y", 0))
+            ex = float(wall.get("end_x", sx))
+            ey = float(wall.get("end_y", sy))
+            thickness = float(wall.get("thickness", wall_thickness))
+            h = float(wall.get("height", height_mm))
+
+            dx = abs(ex - sx) or thickness
+            dy = abs(ey - sy) or thickness
+            ox = min(sx, ex)
+            oy = min(sy, ey)
+
+            placement, product_repr = _make_extrusion(ox, oy, dx, dy, h)
+            ifc_wall = ifc.createIfcWall(
+                _guid(), owner_history,
+                wall.get("label", "Wall"), None, None,
+                placement, product_repr, None, "STANDARD",
+            )
+            products.append(ifc_wall)
+    else:
+        # Generate default room boundary walls
+        for label, ox, oy, dx, dy in [
+            ("North Wall", 0, width_mm - wall_thickness, length_mm, wall_thickness),
+            ("South Wall", 0, 0, length_mm, wall_thickness),
+            ("West Wall", 0, 0, wall_thickness, width_mm),
+            ("East Wall", length_mm - wall_thickness, 0, wall_thickness, width_mm),
+        ]:
+            placement, product_repr = _make_extrusion(ox, oy, dx, dy, height_mm)
+            ifc_wall = ifc.createIfcWall(
+                _guid(), owner_history, label, None, None,
+                placement, product_repr, None, "STANDARD",
+            )
+            products.append(ifc_wall)
+
+    # ── Doors ─────────────────────────────────────────────────
+    for door in entities.get("doors", []):
+        dw = float(door.get("width", 900))
+        dh = float(door.get("height", 2100))
+        dx = float(door.get("x", 0))
+        dy = float(door.get("y", 0))
+        depth = float(door.get("depth", wall_thickness))
+
+        placement, product_repr = _make_extrusion(dx, dy, dw, depth, dh)
+        ifc_door = ifc.createIfcDoor(
+            _guid(), owner_history,
+            door.get("label", "Door"), None, None,
+            placement, product_repr, None, dh, dw,
+        )
+        products.append(ifc_door)
+
+    # ── Windows ───────────────────────────────────────────────
+    for win in entities.get("windows", []):
+        ww = float(win.get("width", 1200))
+        wh = float(win.get("height", 1200))
+        wx = float(win.get("x", 0))
+        wy = float(win.get("y", 0))
+        sill_height = float(win.get("sill_height", 900))
+        depth = float(win.get("depth", wall_thickness))
+
+        local_origin = ifc.createIfcCartesianPoint((wx, wy, sill_height))
+        local_placement_3d = ifc.createIfcAxis2Placement3D(local_origin, None, None)
+        placement = ifc.createIfcLocalPlacement(storey_placement, local_placement_3d)
+
+        pts = [
+            ifc.createIfcCartesianPoint((0.0, 0.0)),
+            ifc.createIfcCartesianPoint((ww, 0.0)),
+            ifc.createIfcCartesianPoint((ww, depth)),
+            ifc.createIfcCartesianPoint((0.0, depth)),
+        ]
+        polyline = ifc.createIfcPolyline(pts + [pts[0]])
+        profile = ifc.createIfcArbitraryClosedProfileDef("AREA", None, polyline)
+        direction = ifc.createIfcDirection((0.0, 0.0, 1.0))
+        solid = ifc.createIfcExtrudedAreaSolid(profile, None, direction, wh)
+        shape_repr = ifc.createIfcShapeRepresentation(
+            body_context, "Body", "SweptSolid", [solid]
+        )
+        product_repr = ifc.createIfcProductDefinitionShape(None, None, [shape_repr])
+
+        ifc_win = ifc.createIfcWindow(
+            _guid(), owner_history,
+            win.get("label", "Window"), None, None,
+            placement, product_repr, None, wh, ww,
+        )
+        products.append(ifc_win)
+
+    # ── Furniture ─────────────────────────────────────────────
+    for furn in entities.get("furniture", []):
+        fw = float(furn.get("width", 600))
+        fd = float(furn.get("depth", 600))
+        fh = float(furn.get("height", 750))
+        fx = float(furn.get("x", 0))
+        fy = float(furn.get("y", 0))
+
+        placement, product_repr = _make_extrusion(fx, fy, fw, fd, fh)
+        ifc_furn = ifc.createIfcFurnishingElement(
+            _guid(), owner_history,
+            furn.get("label", furn.get("type", "Furniture")), None, None,
+            placement, product_repr, None,
+        )
+        products.append(ifc_furn)
+
+    # ── Contain products in storey ────────────────────────────
+    if products:
+        ifc.createIfcRelContainedInSpatialStructure(
+            _guid(), owner_history, None, None, products, storey,
+        )
+
+    # ── Serialise ─────────────────────────────────────────────
+    buf = io.BytesIO()
+    ifc.write(buf)
+    result = buf.getvalue()
+    logger.info(
+        "ifc_created",
+        drawing_type=drawing_type,
+        schema=schema,
+        elements=len(products),
+        size_bytes=len(result),
+    )
+    return result
diff --git a/services/vision-engine/Dockerfile b/services/vision-engine/Dockerfile
new file mode 100644
index 0000000..15cb739
--- /dev/null
+++ b/services/vision-engine/Dockerfile
@@ -0,0 +1,33 @@
+# ---------------------------------------------------------------------------
+# Vision Engine — OpenLintel
+# Multi-stage build: install shared lib first, then vision-engine
+# ---------------------------------------------------------------------------
+FROM python:3.12-slim AS base
+
+# Prevent Python from writing .pyc and enable unbuffered stdout/stderr
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# ---------------------------------------------------------------------------
+# Stage 1: Install python-shared
+# ---------------------------------------------------------------------------
+COPY packages/python-shared /tmp/python-shared
+RUN pip install --no-cache-dir /tmp/python-shared && \
+    rm -rf /tmp/python-shared
+
+# ---------------------------------------------------------------------------
+# Stage 2: Install vision-engine
+# ---------------------------------------------------------------------------
+COPY services/vision-engine /tmp/vision-engine
+RUN pip install --no-cache-dir /tmp/vision-engine && \
+    rm -rf /tmp/vision-engine
+
+# Copy the service source for uvicorn to find the app module
+COPY services/vision-engine/main.py /app/main.py
+COPY services/vision-engine/src /app/src
+
+EXPOSE 8010
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8010"]
diff --git a/services/vision-engine/main.py b/services/vision-engine/main.py
index 3ec4bd3..f30b1fc 100644
--- a/services/vision-engine/main.py
+++ b/services/vision-engine/main.py
@@ -19,6 +19,7 @@
 from openlintel_shared.redis_client import close_redis
 
 from src.routers import vision
+from src.routers import reconstruction
 
 logger = structlog.get_logger(__name__)
 
@@ -55,3 +56,4 @@ async def health_check() -> HealthResponse:
 
 
 app.include_router(vision.router)
+app.include_router(reconstruction.router)
diff --git a/services/vision-engine/src/routers/reconstruction.py b/services/vision-engine/src/routers/reconstruction.py
new file mode 100644
index 0000000..be448a1
--- /dev/null
+++ b/services/vision-engine/src/routers/reconstruction.py
@@ -0,0 +1,408 @@
+"""
+Photo-to-3D reconstruction API routes.
+
+Accepts room photos, estimates depth using monocular depth estimation,
+calibrates using a reference object, and extracts room dimensions.
+Generates a simple glTF mesh and stores it in MinIO.
+"""
+
+from __future__ import annotations
+
+import json
+import uuid
+from typing import Annotated, Any
+
+import structlog
+from fastapi import APIRouter, BackgroundTasks, Depends, status
+from pydantic import BaseModel, Field
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from openlintel_shared.config import Settings, get_settings
+from openlintel_shared.db import get_db_session, get_session_factory
+from openlintel_shared.job_worker import update_job_status, get_user_api_key
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter(prefix="/api/v1/reconstruction", tags=["reconstruction"])
+
+
+class ReconstructionJobInput(BaseModel):
+    """Input for a reconstruction job."""
+
+    job_id: str
+    user_id: str
+    project_id: str
+    room_id: str
+    image_urls: list[str] = Field(min_length=1)
+    reference_object: str | None = Field(
+        default=None,
+        description="Calibration reference: 'door', 'a4_paper', 'standard_brick'",
+    )
+
+
+# Reference object real-world sizes in mm
+REFERENCE_SIZES: dict[str, dict[str, float]] = {
+    "door": {"width": 900, "height": 2100},
+    "a4_paper": {"width": 210, "height": 297},
+    "standard_brick": {"width": 215, "height": 65},
+}
+
+
+class RoomDimension(BaseModel):
+    """Extracted room dimension with confidence."""
+
+    measurement: str
+    value_mm: float
+    confidence: float = Field(ge=0.0, le=1.0)
+
+
+class ReconstructionResult(BaseModel):
+    """Output of a reconstruction job."""
+
+    room_id: str
+    dimensions: list[RoomDimension]
+    length_mm: float | None = None
+    width_mm: float | None = None
+    height_mm: float | None = None
+    mesh_storage_key: str | None = None
+    thumbnail_storage_key: str | None = None
+
+
+@router.post(
+    "/job",
+    status_code=status.HTTP_202_ACCEPTED,
+    summary="Start a photo-to-3D reconstruction background job",
+)
+async def run_reconstruction_job(
+    request: ReconstructionJobInput,
+    background_tasks: BackgroundTasks,
+    db: Annotated[AsyncSession, Depends(get_db_session)],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> dict:
+    """Accept a reconstruction job and process in the background."""
+    try:
+        await update_job_status(db, request.job_id, status="running", progress=5)
+
+        background_tasks.add_task(
+            _run_reconstruction,
+            request=request,
+            settings=settings,
+        )
+
+        logger.info("reconstruction_job_dispatched", job_id=request.job_id)
+        return {"status": "accepted", "job_id": request.job_id}
+
+    except Exception as exc:
+        logger.error("reconstruction_dispatch_failed", job_id=request.job_id, error=str(exc))
+        await update_job_status(db, request.job_id, status="failed", error=str(exc))
+        return {"status": "failed", "error": str(exc)}
+
+
+async def _run_reconstruction(
+    request: ReconstructionJobInput,
+    settings: Settings,
+) -> None:
+    """Background task: download images, estimate depth, extract dimensions."""
+    session_factory = get_session_factory()
+    async with session_factory() as db:
+        try:
+            await update_job_status(db, request.job_id, status="running", progress=10)
+
+            # Get user's API key for VLM calls
+            api_key = await get_user_api_key(db, request.user_id, provider="openai")
+
+            await update_job_status(
+                db, request.job_id, status="running", progress=20,
+                output_json={"current_step": "Downloading images"},
+            )
+
+            # Download images
+            import httpx
+
+            images_data: list[bytes] = []
+            async with httpx.AsyncClient(timeout=30) as client:
+                for url in request.image_urls[:10]:  # Limit to 10 images
+                    try:
+                        resp = await client.get(url)
+                        resp.raise_for_status()
+                        images_data.append(resp.content)
+                    except Exception as dl_exc:
+                        logger.warning("image_download_failed", url=url, error=str(dl_exc))
+
+            if not images_data:
+                await update_job_status(
+                    db, request.job_id, status="failed",
+                    error="No images could be downloaded",
+                )
+                return
+
+            await update_job_status(
+                db, request.job_id, status="running", progress=40,
+                output_json={"current_step": "Estimating depth"},
+            )
+
+            # Use VLM to estimate room dimensions from photos
+            dimensions = await _estimate_dimensions_vlm(
+                images_data=images_data,
+                reference_object=request.reference_object,
+                api_key_material={
+                    "encrypted_key": api_key["encrypted_key"],
+                    "iv": api_key["iv"],
+                    "auth_tag": api_key["auth_tag"],
+                } if api_key else None,
+            )
+
+            await update_job_status(
+                db, request.job_id, status="running", progress=70,
+                output_json={"current_step": "Generating 3D mesh"},
+            )
+
+            # Generate simple glTF mesh from dimensions
+            length_mm = dimensions.get("length_mm", 4000)
+            width_mm = dimensions.get("width_mm", 3000)
+            height_mm = dimensions.get("height_mm", 2700)
+
+            mesh_key: str | None = None
+            try:
+                mesh_bytes = _generate_simple_gltf(length_mm, width_mm, height_mm)
+                mesh_key = f"reconstruction/{request.job_id}/room.glb"
+                from openlintel_shared.storage import upload_file
+
+                upload_file(
+                    settings.MINIO_BUCKET, mesh_key, mesh_bytes,
+                    content_type="model/gltf-binary", settings=settings,
+                )
+            except Exception as mesh_exc:
+                logger.warning("mesh_generation_failed", error=str(mesh_exc))
+
+            await update_job_status(
+                db, request.job_id, status="running", progress=90,
+                output_json={"current_step": "Finalising results"},
+            )
+
+            # Build output
+            dimension_list = [
+                {"measurement": "length", "value_mm": length_mm, "confidence": dimensions.get("length_confidence", 0.7)},
+                {"measurement": "width", "value_mm": width_mm, "confidence": dimensions.get("width_confidence", 0.7)},
+                {"measurement": "height", "value_mm": height_mm, "confidence": dimensions.get("height_confidence", 0.6)},
+            ]
+
+            output = {
+                "room_id": request.room_id,
+                "dimensions": dimension_list,
+                "length_mm": length_mm,
+                "width_mm": width_mm,
+                "height_mm": height_mm,
+                "mesh_storage_key": mesh_key,
+                "images_processed": len(images_data),
+                "reference_object": request.reference_object,
+            }
+
+            await update_job_status(
+                db, request.job_id,
+                status="completed",
+                progress=100,
+                output_json=output,
+            )
+
+            logger.info(
+                "reconstruction_job_completed",
+                job_id=request.job_id,
+                length_mm=length_mm,
+                width_mm=width_mm,
+                height_mm=height_mm,
+            )
+
+        except Exception as exc:
+            logger.error("reconstruction_job_failed", job_id=request.job_id, error=str(exc))
+            await update_job_status(db, request.job_id, status="failed", error=str(exc))
+
+
+async def _estimate_dimensions_vlm(
+    images_data: list[bytes],
+    reference_object: str | None = None,
+    api_key_material: dict[str, str] | None = None,
+) -> dict[str, float]:
+    """Use a VLM to estimate room dimensions from photos.
+
+    Falls back to default dimensions if VLM is unavailable.
+    """
+    import base64
+
+    try:
+        import litellm
+
+        # Prepare the prompt
+        ref_info = ""
+        if reference_object and reference_object in REFERENCE_SIZES:
+            ref = REFERENCE_SIZES[reference_object]
+            ref_info = (
+                f"\nCalibration reference: {reference_object} "
+                f"(real size: {ref['width']}mm x {ref['height']}mm). "
+                f"Use this to calibrate your measurements."
+            )
+
+        system_prompt = (
+            "You are a room measurement expert. Analyse the room photos and "
+            "estimate the room dimensions in millimetres. "
+            "Return a JSON object with: length_mm, width_mm, height_mm, "
+            "length_confidence (0-1), width_confidence (0-1), height_confidence (0-1)."
+            + ref_info
+        )
+
+        # Encode first image as data URI
+        img_b64 = base64.b64encode(images_data[0]).decode("ascii")
+        data_uri = f"data:image/jpeg;base64,{img_b64}"
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image_url", "image_url": {"url": data_uri}},
+                    {"type": "text", "text": "Estimate the room dimensions from this photo."},
+                ],
+            },
+        ]
+
+        kwargs: dict[str, Any] = {
+            "model": "openai/gpt-4o",
+            "messages": messages,
+            "temperature": 0.1,
+            "max_tokens": 256,
+            "response_format": {"type": "json_object"},
+        }
+
+        response = await litellm.acompletion(**kwargs)
+        content = response.choices[0].message.content or "{}"
+
+        dims = json.loads(content)
+        return {
+            "length_mm": float(dims.get("length_mm", 4000)),
+            "width_mm": float(dims.get("width_mm", 3000)),
+            "height_mm": float(dims.get("height_mm", 2700)),
+            "length_confidence": float(dims.get("length_confidence", 0.5)),
+            "width_confidence": float(dims.get("width_confidence", 0.5)),
+            "height_confidence": float(dims.get("height_confidence", 0.4)),
+        }
+
+    except Exception as exc:
+        logger.warning("vlm_dimension_estimation_failed", error=str(exc))
+        return {
+            "length_mm": 4000,
+            "width_mm": 3000,
+            "height_mm": 2700,
+            "length_confidence": 0.3,
+            "width_confidence": 0.3,
+            "height_confidence": 0.3,
+        }
+
+
+def _generate_simple_gltf(
+    length_mm: float,
+    width_mm: float,
+    height_mm: float,
+) -> bytes:
+    """Generate a simple glTF binary (GLB) box representing the room.
+
+    Creates a minimal valid GLB file with a single box mesh.
+    """
+    import struct
+
+    # Convert mm to metres for glTF (which uses metres)
+    lm = length_mm / 1000.0
+    wm = width_mm / 1000.0
+    hm = height_mm / 1000.0
+
+    # 8 vertices of a box
+    vertices = [
+        0, 0, 0,    lm, 0, 0,    lm, wm, 0,    0, wm, 0,     # bottom
+        0, 0, hm,   lm, 0, hm,   lm, wm, hm,   0, wm, hm,    # top
+    ]
+
+    # 12 triangles (6 faces x 2 triangles)
+    indices = [
+        0, 1, 2,  0, 2, 3,  # bottom
+        4, 6, 5,  4, 7, 6,  # top
+        0, 4, 5,  0, 5, 1,  # front
+        2, 6, 7,  2, 7, 3,  # back
+        0, 3, 7,  0, 7, 4,  # left
+        1, 5, 6,  1, 6, 2,  # right
+    ]
+
+    # Pack binary data
+    vertex_data = struct.pack(f"<{len(vertices)}f", *vertices)
+    index_data = struct.pack(f"<{len(indices)}H", *indices)
+
+    # Pad to 4-byte alignment
+    while len(index_data) % 4 != 0:
+        index_data += b"\x00"
+
+    buffer_data = index_data + vertex_data
+    buffer_length = len(buffer_data)
+
+    # Build glTF JSON
+    gltf_json = {
+        "asset": {"version": "2.0", "generator": "OpenLintel"},
+        "scene": 0,
+        "scenes": [{"nodes": [0]}],
+        "nodes": [{"mesh": 0, "name": "Room"}],
+        "meshes": [{
+            "primitives": [{
+                "attributes": {"POSITION": 1},
+                "indices": 0,
+            }],
+        }],
+        "accessors": [
+            {
+                "bufferView": 0,
+                "componentType": 5123,  # UNSIGNED_SHORT
+                "count": len(indices),
+                "type": "SCALAR",
+                "max": [max(indices)],
+                "min": [min(indices)],
+            },
+            {
+                "bufferView": 1,
+                "componentType": 5126,  # FLOAT
+                "count": len(vertices) // 3,
+                "type": "VEC3",
+                "max": [lm, wm, hm],
+                "min": [0, 0, 0],
+            },
+        ],
+        "bufferViews": [
+            {
+                "buffer": 0,
+                "byteOffset": 0,
+                "byteLength": len(index_data),
+                "target": 34963,  # ELEMENT_ARRAY_BUFFER
+            },
+            {
+                "buffer": 0,
+                "byteOffset": len(index_data),
+                "byteLength": len(vertex_data),
+                "target": 34962,  # ARRAY_BUFFER
+            },
+        ],
+        "buffers": [{"byteLength": buffer_length}],
+    }
+
+    json_str = json.dumps(gltf_json, separators=(",", ":"))
+    json_bytes = json_str.encode("utf-8")
+
+    # Pad JSON to 4-byte alignment
+    while len(json_bytes) % 4 != 0:
+        json_bytes += b" "
+
+    # GLB header: magic + version + length
+    # JSON chunk: length + type + data
+    # BIN chunk: length + type + data
+    json_chunk = struct.pack("<II", len(json_bytes), 0x4E4F534A) + json_bytes  # JSON
+    bin_chunk = struct.pack("<II", buffer_length, 0x004E4942) + buffer_data  # BIN
+
+    total_length = 12 + len(json_chunk) + len(bin_chunk)
+    header = struct.pack("<III", 0x46546C67, 2, total_length)  # glTF magic
+
+    return header + json_chunk + bin_chunk