← Skills

SIP Foundation Construction

Native Read-only

Concrete slab and strip foundation geometry, DPC placement, slab overhang rule, and the NON-NEGOTIABLE foundation agent naming rule.

/skills/sip_foundations.md

Estimated tokens
3099
Characters
12394
Source
Native

Markdown 

# SIP Foundation Construction Skill

## Foundations

### 1. Concrete Slab (most common for SIP)

**The slab MUST extend beyond the wall footprint on all sides.** Use `SLAB_OVERHANG = 200mm` minimum. The wall bottom plates sit on the slab surface; the slab overhang provides bearing for the edge beam and prevents the wall foam from being at the slab edge.

```
Section view:
 ┌──────────────────────────────────────────────┐
 │  SIP wall panel (foam min 150mm above ground)│
 ├──────────────────────────────────────────────┤ ← PT bottom plate (45×90mm)
 ├──────────────────────────────────────────────┤ ← DPC membrane (3mm)
 ├──────────────────────────────────────────────┤ ← slab top (Z=0)
 │           concrete slab 125mm                │
 ├─────┬────────────────────────────────┬───────┤
 │edge │    insulation (optional)       │ edge  │
 │beam │                                │ beam  │
 │300× │                                │ 300×  │
 │600  │                                │ 600   │
 └─────┴────────────────────────────────┴───────┘
    ← SLAB_OVERHANG (200mm min) →
    ← slab extends past wall face on all sides
```

```python
# === SLAB PARAMETERS ===
BUILDING_WIDTH = 3000    # outer wall face to outer wall face
BUILDING_DEPTH = 2000
SLAB_OVERHANG = 200      # slab extends beyond wall footprint — minimum 200mm
SLAB_W = BUILDING_WIDTH + 2 * SLAB_OVERHANG
SLAB_D = BUILDING_DEPTH + 2 * SLAB_OVERHANG
SLAB_T = 125             # slab field thickness
EDGE_BEAM_W = 300        # thickened perimeter beam width
EDGE_BEAM_D = 600        # total depth including slab thickness
DPC_T = 3                # damp proof course
CORE_THICKNESS = 150     # foam core of the SIP panel (SIP-150)
FACE_THICKNESS = 11      # OSB skin each side
SILL_PLATE_W = CORE_THICKNESS   # plate slots into foam groove — NOT full SIP thickness
SILL_PLATE_H = 90

# Slab origin is SW corner of slab at slab bottom surface
# Z=0 = slab top (all wall and floor references start here)
slab_x0 = -SLAB_OVERHANG
slab_y0 = -SLAB_OVERHANG

# Slab field
slab = Part.makeBox(SLAB_W, SLAB_D, SLAB_T,
                    Vector(slab_x0, slab_y0, -SLAB_T))

# Edge beams (perimeter thickening)
eb_n = Part.makeBox(SLAB_W, EDGE_BEAM_W, EDGE_BEAM_D,
                    Vector(slab_x0, slab_y0 + SLAB_D - EDGE_BEAM_W, -EDGE_BEAM_D))
eb_s = Part.makeBox(SLAB_W, EDGE_BEAM_W, EDGE_BEAM_D,
                    Vector(slab_x0, slab_y0, -EDGE_BEAM_D))
eb_e = Part.makeBox(EDGE_BEAM_W, SLAB_D, EDGE_BEAM_D,
                    Vector(slab_x0 + SLAB_W - EDGE_BEAM_W, slab_y0, -EDGE_BEAM_D))
eb_w = Part.makeBox(EDGE_BEAM_W, SLAB_D, EDGE_BEAM_D,
                    Vector(slab_x0, slab_y0, -EDGE_BEAM_D))

foundation = slab.fuse(eb_n).fuse(eb_s).fuse(eb_e).fuse(eb_w)

# Anchor bolts M12 at 600mm centres (perimeter, modelled as cylinders)
BOLT_D = 12
BOLT_L = 150
for x_pos in range(300, BUILDING_WIDTH - 300, 600):
    # South edge — bolt centred in foam channel (Y = FACE_THICKNESS + SILL_PLATE_W / 2)
    bolt = Part.makeCylinder(BOLT_D / 2, BOLT_L,
                              Vector(x_pos, FACE_THICKNESS + SILL_PLATE_W / 2, -BOLT_L))
    foundation = foundation.fuse(bolt)

# DPC membrane strip and sill plate sit at Z=0 on slab surface.
# Offset by FACE_THICKNESS so they align with the foam channel (OSB skins overhang on both sides).
dpc_s = Part.makeBox(BUILDING_WIDTH, SILL_PLATE_W, DPC_T,
                     Vector(0, FACE_THICKNESS, 0))
sp_s  = Part.makeBox(BUILDING_WIDTH, SILL_PLATE_W, SILL_PLATE_H,
                     Vector(0, FACE_THICKNESS, DPC_T))
# Repeat for N, E, W walls
```

**Key rules for slab foundations:**
- Slab top surface = Z=0 (all wall/floor heights reference from this)
- `SLAB_OVERHANG` ≥ 200mm — if SLAB_W or SLAB_D equals BUILDING_WIDTH/DEPTH, the slab is too small
- Foam core bottom = DPC_T + SILL_PLATE_H = must be ≥ 150mm above finished ground (≈ top of edge beam)
- Anchor bolts: M12, 150mm embedment, 600mm centres, 150mm from corners

---

### 2. Strip Foundation

A single perimeter concrete strip foundation — a flat rectangular ring/frame sitting directly under all sole plates. Modelled as **one FreeCAD component** with agent id `foundation`. No T-shaped cross-section, no separate foundation wall segment, no individual side agents.

**NON-NEGOTIABLE: Strip foundations are ONE component, ONE agent (`foundation`), ONE FreeCAD model. Do NOT create four separate agents (`foundation_strip_south` etc.). Do NOT add a foundation wall box on top of the strip. The strip top face IS the sole plate bearing face at Z=0.**

**Z reference:** Z=0 is the top face of the strip (sole plate bearing face). Strip extends downward to Z=−STRIP_D.

**Plan geometry:** The strip is a hollow rectangular frame. Build it by fusing four flat boxes:
- South segment: full outer width × STRIP_W, placed at south edge
- North segment: full outer width × STRIP_W, placed at north edge
- West segment: STRIP_W wide × inner depth (between south and north segments)
- East segment: STRIP_W wide × inner depth (between south and north segments)

**Formula:**
- Outer width = `BUILDING_WIDTH + 2 × STRIP_W`
- Outer depth = `BUILDING_DEPTH + 2 × STRIP_W`
- Inner void starts at Y=STRIP_W (south), ends at Y=STRIP_W+BUILDING_DEPTH (north)
- All four segments are STRIP_D tall; top at Z=0, bottom at Z=−STRIP_D

```python
# === STRIP FOUNDATION PARAMETERS ===
BUILDING_WIDTH = 4000   # outer wall face to outer wall face (from spec)
BUILDING_DEPTH = 3000
STRIP_W = 450           # strip width (plan dimension, perpendicular to wall)
STRIP_D = 300           # strip depth (total buried concrete thickness)

# Z=0 = top of strip = sole plate bearing face
# Strip runs from Z=0 down to Z=-STRIP_D (flat, no foundation wall above it)

# South segment — full outer width, south edge
seg_s = Part.makeBox(BUILDING_WIDTH + 2 * STRIP_W, STRIP_W, STRIP_D,
                     Vector(-STRIP_W, -STRIP_W, -STRIP_D))

# North segment — full outer width, north edge
seg_n = Part.makeBox(BUILDING_WIDTH + 2 * STRIP_W, STRIP_W, STRIP_D,
                     Vector(-STRIP_W, BUILDING_DEPTH, -STRIP_D))

# West segment — between south and north, west edge
seg_w = Part.makeBox(STRIP_W, BUILDING_DEPTH, STRIP_D,
                     Vector(-STRIP_W, 0, -STRIP_D))

# East segment — between south and north, east edge
seg_e = Part.makeBox(STRIP_W, BUILDING_DEPTH, STRIP_D,
                     Vector(BUILDING_WIDTH, 0, -STRIP_D))

# Fuse into single perimeter ring
foundation = seg_s.fuse(seg_n).fuse(seg_w).fuse(seg_e)

feature = doc.addObject("Part::Feature", "StripFoundation")
feature.Shape = foundation
```

**Key rules for strip foundations:**
- ONE agent (`foundation`), ONE model — never split into four side agents
- No foundation wall segment — the strip top face at Z=0 is the bearing face for sole plates
- South and north segments span `BUILDING_WIDTH + 2 × STRIP_W`; east and west span `BUILDING_DEPTH`
- All four segments are the same depth (STRIP_D); top face exactly at Z=0
- Cladding overhangs the foundation face by 40–50mm — the strip exterior face is flush with the SIP wall exterior face

---

### 3. Screw Pile Foundation

Steel screw piles driven to bearing depth, carrying LVL bearer beams. Best for sloped sites and remote/off-grid builds.

```python
# === SCREW PILE PARAMETERS ===
PILE_DIAMETER = 114
PILE_SPACING_X = 2400
PILE_SPACING_Y = 2400
PILE_EXPOSED_H = 600
BEARER_W = 90
BEARER_H = 190

piles_x = (BUILDING_WIDTH // PILE_SPACING_X) + 1
piles_y = (BUILDING_DEPTH // PILE_SPACING_Y) + 1

parts = []
for ix in range(piles_x):
    for iy in range(piles_y):
        x = ix * PILE_SPACING_X
        y = iy * PILE_SPACING_Y
        pile = Part.makeCylinder(PILE_DIAMETER / 2, PILE_EXPOSED_H,
                                 Vector(x, y, -PILE_EXPOSED_H))
        parts.append(pile)

# Bearer beams spanning across building width
for iy in range(piles_y):
    y = iy * PILE_SPACING_Y
    b1 = Part.makeBox(BUILDING_WIDTH, BEARER_W, BEARER_H, Vector(0, y, 0))
    b2 = Part.makeBox(BUILDING_WIDTH, BEARER_W, BEARER_H,
                      Vector(0, y + BEARER_W + 10, 0))
    parts.extend([b1, b2])
```

---

## Building Assembly — Coordinate System (Slab and Footprint)

```
Origin (0, 0, 0) = the SW corner of the building footprint at Z = 0 (top of slab / floor level).
X-axis = East (along building width)
Y-axis = North (along building depth)
Z-axis = Up
```

### Slab and Footprint

The slab extends `SLAB_OVERHANG` beyond the building footprint on all four sides. The building footprint is the outer face of the wall panels.

```python
BUILDING_WIDTH = 3000     # outer face to outer face (X)
BUILDING_DEPTH = 2000     # outer face to outer face (Y)
PANEL_THICKNESS = 172     # TOTAL_THICKNESS
SLAB_OVERHANG = 200       # slab extends this far past wall face on all sides
SLAB_T = 125
SLAB_W = BUILDING_WIDTH + 2 * SLAB_OVERHANG
SLAB_D = BUILDING_DEPTH + 2 * SLAB_OVERHANG

# Slab origin: SW corner of slab at slab bottom
slab_origin = Vector(-SLAB_OVERHANG, -SLAB_OVERHANG, -SLAB_T)
slab = Part.makeBox(SLAB_W, SLAB_D, SLAB_T, slab_origin)
# Slab top surface is at Z = 0
```

## MANDATORY: Foundation Component

**Every SIP building manifest MUST include a `foundation` component.** No exceptions. The foundation is always generated — even when the user hasn't mentioned the foundation in the prompt. It is the root of the dependency tree and provides the floor level, building footprint dimensions, and panel_thickness to every wall agent.

**NON-NEGOTIABLE — agent id MUST be exactly `foundation`:**

The foundation agent id is always the literal string `foundation`. No other name is acceptable. The validator, dependency resolver, and all downstream agents depend on this exact string.

❌ FORBIDDEN agent ids — do not use any of these:
- `concrete_slab` — wrong: this is a material description, not the role id
- `slab` — wrong: too generic
- `strip_foundation` — wrong: describes the type, not the role
- `foundation_slab` — wrong: reversed
- `base_plate` / `base_plate_south` / `base_plate_north` — wrong: base plates are sole plates, not the foundation
- `foundation_front` / `foundation_south` / `foundation_strip_north` — wrong: never split the foundation into sides

✅ CORRECT: one agent, id = `foundation`, priority = 1, no dependencies.

**Rules:**
- Agent id: `foundation` (exactly this string — see forbidden list above)
- Priority: 1 (highest — no dependencies)
- Dependencies: none
- Foundation type defaults to `slab_on_grade` unless the design spec explicitly states otherwise
- Use `BUILDING_WIDTH` and `BUILDING_DEPTH` from the design spec `overall_dimensions` for the footprint (the slab extends SLAB_OVERHANG = 200mm beyond this on all sides)
- The foundation is modelled as a single flat piece: slab field + perimeter edge beams as one fused solid
- `assembly_placement.position` = `{x: -200, y: -200, z: -125}` for a 125mm slab with 200mm overhang (slab bottom is -125mm, SW corner of slab is at -200, -200)
- `bounding_box` = `{x: BUILDING_WIDTH + 400, y: BUILDING_DEPTH + 400, z: 125}` (slab field only; edge beam extends deeper)

**Goal string template:**
```
Create slab-on-grade foundation, BUILDINGWIDTHxBUILDINGDEPTHmm slab overhang 200mm all sides, 125mm slab thickness, 600mm edge beam depth, 300mm edge beam width. Single fused solid. Z=0 is slab top.
```
(Replace BUILDINGWIDTH and BUILDINGDEPTH with actual mm values from the spec.)

**If the spec mentions a strip foundation:** use a SINGLE agent with id `foundation`, priority 1. The strip is a flat perimeter ring — one model, one component. Do NOT create four separate side agents. See the Strip Foundation section above for exact geometry and Python code.

**Wrong vs correct — strip foundation:**
```
❌ WRONG (split into sides):
  { "id": "foundation_front", "priority": 1, ... }
  { "id": "foundation_back",  "priority": 1, ... }
  { "id": "foundation_left",  "priority": 1, ... }
  { "id": "foundation_right", "priority": 1, ... }

✅ CORRECT (single perimeter ring):
  { "id": "foundation", "priority": 1, "dependencies": [], ... }
```

**If the spec mentions a screw pile foundation**, use the screw pile catalog entry; use agent id `foundation`.

## ⚠ Non-Negotiable Foundation Rule

5. **Foundation slab extends beyond the wall footprint on all sides.**
   `SLAB_W = BUILDING_WIDTH + 2 × SLAB_OVERHANG` (minimum 200mm). A slab the same size as the wall footprint leaves no bearing margin.
v0.0.170