@floless/app 0.51.0 → 0.53.0

package/dist/floless-server.cjs

@@ -52856,7 +52856,7 @@ function appVersion() {
   return resolveVersion({
     isSea: isSea2(),
     sqVersionXml: readSqVersionXml(),
-    define: true ? "0.51.0" : void 0,
+    define: true ? "0.53.0" : void 0,
     pkgVersion: readPkgVersion()
   });
 }
@@ -52866,7 +52866,7 @@ function resolveChannel(s) {
   return "dev";
 }
 function appChannel() {
-  return resolveChannel({ isSea: isSea2(), define: true ? "0.51.0" : void 0 });
+  return resolveChannel({ isSea: isSea2(), define: true ? "0.53.0" : void 0 });
 }
 
 // workflow-update.ts
@@ -53893,7 +53893,7 @@ function contractToScene(contractInput) {
     color: pickColor(profile, i, contract)
   }));
   return {
-    scene: { meta: { name: contract.title || "Steel takeoff", units: "mm", up: "z" }, groups, elements },
+    scene: { meta: { name: contract.title || "Steel Model", units: "mm", up: "z" }, groups, elements },
     skipped
   };
 }
@@ -60631,14 +60631,18 @@ var PRODUCT_SKILLS = [
   //  file a diagnosed bug/idea/question to the private log via the floless.io relay
   "floless-app-routines",
   //      author event-driven ("on trigger") routines
+  "floless-app-steel-model",
+  //   front-door guide: orchestrate a steel drawing SET into a model (project → knowledge → agents → confirm-gated reads via the reader)
   "floless-app-steel-takeoff",
   // read a steel drawing into an editable steel.takeoff/v1 contract (the Steel Takeoff reader)
   "floless-app-tweak-contract",
-  // handle a tweak-contract request from the steel-takeoff contract editor (Slice 2 AI round-trip)
+  // handle a tweak-contract request from the Steel Model contract editor (Slice 2 AI round-trip)
   "floless-app-ui",
   //            compose Custom Panels (~/.floless/ui/extensions.json) for the Dashboard
-  "floless-app-workflows"
+  "floless-app-workflows",
   //     author/run .flo workflows
+  "reading-structural-drawings"
+  // the drawing-set reading discipline (non-namespace) the steel guide + reader lean on; shipped so users get it too
 ];
 function selectShippedSkillNames(names) {
   const present = new Set(names);

package/dist/skills/floless-app-queue/SKILL.md

@@ -40,7 +40,7 @@ documented in `floless-app-bridge`; the five types map to:
 |---|---|---|
 | `tweak` | "Tweak node **`<nodeId>`** in **`<appId>`** — *<instruction>*" | `floless-app-workflows` |
 | `use-template` | "Add template **<template.name>** to **`<appId>`**" | `floless-app-workflows` |
-| `tweak-contract` | "Edit the steel-takeoff contract for **`<appId>`** — *<instruction>* (+N screenshot(s))" | `floless-app-tweak-contract` |
+| `tweak-contract` | "Edit the Steel Model contract for **`<appId>`** — *<instruction>* (+N screenshot(s))" | `floless-app-tweak-contract` |
 | `ui-customize` | "Customize the Dashboard (optionally `panel <panelId>`) — *<instruction>*" | `floless-app-ui` |
 | `rebake` | "Re-read the **<inputName>** drawing (<sourceName>) in **`<appId>`** — *<instruction>*" | `floless-app-rebake` |
 

package/dist/skills/floless-app-report-issue/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: floless-app-report-issue
-description: File a diagnosed bug / idea / question from floless.app into the PRIVATE product log via the floless.io relay. Use when the user invokes /floless-app-report-issue, clicks "Report an issue" in the floless.app UI (a queued report or a copied prompt), or says "report this", "file a bug", "something broke in floless", "send feedback / a feature idea". It READS the live run evidence first (latest run trace, failing node + error, the .flo, exec code), offers a workaround when one exists, then composes a maintainer-ready report and sends it — always showing the exact text and confirming first. Read-only: it never re-runs a workflow node.
+description: File a diagnosed bug / idea / question from floless.app into the PRIVATE product log via the floless.io relay. Use when the user invokes /floless-app-report-issue, clicks "Report an issue" in the floless.app UI (a queued report or a copied prompt), or says "report this", "file a bug", "something broke in floless", "send feedback / a feature idea". It READS the live run evidence first (latest run trace, failing node + error, the .flo, exec code), offers a workaround when one exists, then composes a maintainer-ready report and sends it — always showing the exact text and confirming first. Read-only — it never re-runs a workflow node.
 metadata:
   version: 0.1.0
 ---

package/dist/skills/floless-app-steel-model/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: floless-app-steel-model
+description: The front-door guide for turning a structural steel drawing SET into an editable model in floless.app — the "Steel Model" flow. This skill orchestrates the whole pipeline — set up a project folder, learn the set into plain-English knowledge files, provision the right AWARE agents (region-specific steel detailer plus any bake targets), confirm which sheets are plans / elevations / details, then hand off to the Steel Takeoff reader to read each plan into a steel.takeoff/v1 contract — with explicit confirm gates between stages. Use it when a user wants to model steel from a drawing SET or asks things like "model this steel job from the drawings", "take off this whole set", "start a steel takeoff project", "turn these structural drawings into a model", "I have a PDF set of framing plans", or "/floless-app-steel-model". It is re-runnable — resume at any stage. For a single already-isolated framing plan the Steel Takeoff reader (floless-app-steel-takeoff) can be used directly; this guide is for driving a real job end to end.
+metadata:
+  version: 0.1.0
+---
+
+# Steel Model — guide a steel drawing set into an editable model
+
+## What this is
+
+The **front door** to floless.app's steel pipeline. A real steel job arrives as a *set* of PDFs
+(framing plans, elevations, sections, details, schedules) plus firm conventions — not a single
+clean plan. This guide drives that whole job: project setup → learn the set → provision agents →
+classify the sheets → read each framing plan into an editable **steel.takeoff/v1 contract**, then
+point the user at the on-canvas tools (filter, 3D, IFC/Tekla export, BOM, the connection library,
+clickable callouts).
+
+It is the **orchestration layer ABOVE** the readers and the editor. The actual drawing reading is
+done by **`floless-app-steel-takeoff`** (the Steel Takeoff reader) — this guide gets the project to
+the point where that read is reliable, and hands off. The host AI is the brain (the FloLess thin-UI
+contract): reading happens at COMPOSE time with the terminal AI's own vision; there is no model in
+the run path and no API key.
+
+**Re-runnable + interactive.** Each stage ends with an explicit **confirm gate** — show the user
+what was found and get an OK before spending effort on the next stage. Resume at any stage on
+re-invoke ("we already set up the folder, provision the agents").
+
+> Companion skills (both ship with floless.app — invoke them, don't duplicate them):
+> - **`reading-structural-drawings`** — the reading *discipline* (massing + coordinate frame FIRST,
+>   members LAST, cross-validate every view). Follow it whenever skimming or classifying the set
+>   (stages 2 and 5) — it stops the classic failures (two buildings read as one, a sloped roof read
+>   as flat, grids conflated across sheets).
+> - **`floless-app-steel-takeoff`** — reads one framing plan into the contract (the heavy vision
+>   pipeline, the filter pre-stage, the AISC/EN/BS lookup, the contract write + editor hand-off).
+
+---
+
+## The flow
+
+Work the stages in order. Announce the stage, do the work, then **stop at the confirm gate** and
+wait for the user's OK before the next stage.
+
+### 1. Project folder
+
+A steel job has many files and derived artifacts — keep them together. Ask the user to pick or
+create a **dedicated project folder** (e.g. `~/projects/<job-name>/`). Everything lives there: the
+drawing PDF(s), the knowledge files (stage 2), and any exported contracts / IFC / BOM. If they
+already have one, use it. Record the absolute path for the rest of the run.
+
+**Gate:** confirm the folder path and that the drawing set (PDF) is in it (or get its path).
+
+### 2. Learn the set → plain-English knowledge files
+
+Before reading geometry, skim the set and capture what matters into a few short Markdown files in
+the project folder (a few files, **not** a framework):
+
+- **`set-index.md`** — one line per sheet: number, title, and what it is (framing plan / elevation /
+  section / detail / schedule). This is the map the later stages classify against.
+- **`general-notes.md`** — the General Notes that bind the whole job: design spec, default
+  connection type, bolt/weld standard, material grades, anything that overrides a single sheet.
+- **`company-rules.md`** *(ask first)* — **ask whether the firm has company-specific standards**
+  (e.g. "moment → detail 50S504 → Tekla component 146"). If yes, capture them here. This file feeds
+  the connection-library pre-fill in stage 6 (the editor's Connections panel reads these as
+  `source:"company-rules"`). If the firm has none, skip the file — don't invent rules.
+
+Read the set with the terminal AI's own vision, following the **`reading-structural-drawings`**
+discipline while skimming (massing + coordinate frame first — it's what makes the sheet
+classification reliable).
+
+**Gate:** show `set-index.md` (the sheet map) and confirm the classification looks right — the user
+knows their set better than any read.
+
+### 3. Provision the AWARE agents
+
+The reader leans on a **region-specific steel detailer** agent (AISC vs EN vs BS section tables) and,
+if the user will bake later, the host bridges.
+
+1. **Check what's installed:** `aware agent list --json`.
+2. **Steel detailer — ask the region**, then install the match: `steel-detailer-us` (AISC /
+   imperial), `steel-detailer-eu` (EN), or `steel-detailer-uk` (BS). Install with
+   `aware agent install <id>`. **Verify it's live** with a known-section lookup before relying on it
+   (a section that should resolve — e.g. a W-shape for US — returns a weight).
+3. **Bake targets (optional, only if they'll export later):** offer `tekla`, `rhino`, `revit`,
+   `sketchup` — install the ones they want. (3D and IFC export need no host; Tekla bake needs Tekla
+   open with a model.)
+4. **Discover more:** `aware agent catalog` / `aware agent search <capability>` lists agents that
+   are *available but not installed*. Scan it and suggest any genuinely useful one for steel work;
+   don't install without asking.
+
+If `aware agent catalog` is unsupported (older AWARE), say so and offer to update AWARE (the footer
+↑ Upgrade pill / `floless-app-onboarding` covers this); fall back to `aware agent list`.
+
+**Gate:** confirm the detailer (right region, verified live) and any bake agents are installed.
+
+### 4. Read method — PyMuPDF + hide the title block
+
+The read method is settled: a deterministic **PyMuPDF** pass enumerates the drawing elements (no
+LLM, no API key) and the framing area is rastered for the vision read. The **title block is
+excluded** from what's read and rastered (it carries client/project/firm identity — see
+Confidentiality). This is handled inside the Steel Takeoff reader and the filter pre-stage; surface
+it to the user as "your title block stays out of the read," and confirm the crop excludes it on the
+first sheet.
+
+**Gate:** on the first framing plan, confirm the framing area is captured and the title block is
+out of frame.
+
+### 5. Classify the sheets + confirm, view by view
+
+The set has many sheets; only the **framing plans** become takeoff contracts. Walk the user through,
+with an explicit OK at each kind (this is the interactive heart — never one-shot a whole set):
+
+- **Framing plans** — the sheets that get read into members. Confirm the list before reading.
+- **Elevations / sections** — used for member heights (TOS/BOS), moment-frame schedules, and as
+  jump targets for clickable callouts (stage 6). Confirm which sheets these are.
+- **Details** — the connection details the callouts point to. Confirm the detail sheets.
+- **A sample line + profile** — on the first plan, read ONE member (its segment + profile label)
+  and show it back; get an OK that the geometry + size mapping is right before reading the rest.
+
+**Gate:** explicit OK on the framing-plan list and the sample read before the full read.
+
+### 6. Hand off to the reader + the on-canvas tools
+
+With the project, knowledge, agents, and classification confirmed, drive the actual reads and point
+the user at the editor:
+
+- **Read each framing plan** via **`floless-app-steel-takeoff`** — it runs the filter pre-stage
+  (isolate the steel linework by layer/thickness/colour), the vision read, the AISC/EN/BS lookup
+  via the detailer, honors `target_confidence`, writes the `steel.takeoff/v1` contract, and opens
+  the overlay editor. One contract per `steel-model` app; multi-sheet sets ride the filter's
+  `sheets[]` + the editor's plan switcher.
+- **Pre-fill the connection library** from `company-rules.md` (stage 2): emit the firm's rows into
+  the contract's `connections[]` with `source:"company-rules"`; the user reviews/assigns them per
+  member end in the editor's **Connections** panel (the per-end picker + confidence card).
+- **Point at the rest of the canvas:** the **filter** view (refine the kept linework), **Approve**
+  (bake the lock — the determinism gate), **3D** model, **IFC** / **Tekla** export, the **BOM**, the
+  **confidence report**, and the **callout bubbles** (click a section/elevation/detail mark on a
+  plan to jump to the referenced sheet).
+
+**Done** when each framing plan has an approved, editor-reviewed contract and the user knows which
+on-canvas tool does what. The exports (3D/IFC/Tekla/BOM) are on-demand from the editor.
+
+---
+
+## Guardrails
+
+- **The host AI is the brain; the run is deterministic.** Reading is a compose-time act; never put
+  an LLM or heavy compute in the run path or the server.
+- **Confidentiality (hard rule).** Never commit or echo `raster_b64` / `bg_b64` page rasters or any
+  client / project / firm names. The title block is excluded from the read for this reason. Keep job
+  files in the user's project folder, not the repo.
+- **Confirm gates are not optional.** A steel set is easy to misread (two buildings on one sheet, a
+  sloped roof, grids that differ across sheets). Show findings and get an OK at each stage — the
+  user catches what a read misses.
+- **Don't duplicate the companions.** Hand the actual drawing read to `floless-app-steel-takeoff`;
+  follow `reading-structural-drawings` for the reading discipline. This guide owns the orchestration
+  and the gates, not the pixel-level read.
+- **Tekla (or any platform) component INSERTION at bake is deferred** — the connection library +
+  per-end references + scoring are editor-verifiable today; native component placement is a later,
+  Tekla-gated step. Don't promise it.

package/dist/skills/floless-app-steel-takeoff/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: floless-app-steel-takeoff
-description: Read a structural steel drawing into an editable steel.takeoff/v1 contract in floless.app — the "Steel Takeoff" reader. Triggers on a pending floless `rebake` request for the `steel-takeoff` app (queued from its "Re-read & re-bake ▸" button), or asks like "read this framing plan into a takeoff", "turn this structural drawing into a takeoff", "bake my drawing into steel-takeoff", "extract members from this PDF". Teaches the host AI to READ a steel drawing (PDF/image) with its own vision at COMPOSE time, build a steel.takeoff/v1 contract (members + profiles + elevations + weights from AISC lookup), write it to the contract store, and hand control to the editor — no model in the run path, no API key.
+description: Read a structural steel drawing into an editable steel.takeoff/v1 contract in floless.app — the "Steel Takeoff" reader. Triggers on a pending floless `rebake` request for the `steel-model` app (queued from its "Re-read & re-bake ▸" button), or asks like "read this framing plan into a takeoff", "turn this structural drawing into a takeoff", "bake my drawing into steel-model", "extract members from this PDF". Teaches the host AI to READ a steel drawing (PDF/image) with its own vision at COMPOSE time, build a steel.takeoff/v1 contract (members + profiles + elevations + weights from AISC lookup), write it to the contract store, and hand control to the editor — no model in the run path, no API key.
 metadata:
   version: 0.1.0
 ---
@@ -9,7 +9,7 @@ metadata:
 
 ## What this is
 
-`steel-takeoff` is a FloLess app that turns a structural steel drawing into an editable
+`steel-model` is a FloLess app that turns a structural steel drawing into an editable
 **takeoff contract** — members, profiles, AISC weights, T.O. elevations, connection detail refs
 — rendered in the overlay editor, then baked at Approve into the app's `read` node.
 
@@ -34,7 +34,7 @@ but do not attempt them here.
 ### 1. Find the drawing
 
 From a `rebake` request: `GET http://localhost:<port>/api/requests` → the entry with
-`type:"rebake"` and `appId:"steel-takeoff"` carries `snapshots: ["<abs path>"]` (the drawing
+`type:"rebake"` and `appId:"steel-model"` carries `snapshots: ["<abs path>"]` (the drawing
 file) and optionally `sourceName` (the original filename — use it for the `source.name`
 provenance field). If the user just attaches or points at a drawing in prose, skip the lookup
 and proceed from that path.
@@ -72,7 +72,7 @@ native/display coords):
    `*BEAM*STEL*`, `*COL*`, `*BRACE*`, `*JOIST*`) → default **on**; others off. Mark
    `drawable: false` on pure text/dimension/title-block layers.
 5. Set `filter.mode: "layer"`, `filter.active: 0`. **PUT** the contract
-   (`PUT /api/contract/steel-takeoff`). On a re-read, preserve any existing per-facet `on` flags.
+   (`PUT /api/contract/steel-model`). On a re-read, preserve any existing per-facet `on` flags.
 
 Then tell the user to open the **Filter** node, flip through the sheets, narrow to the steel, and
 **Save**. The saved `on` flags + `mode` are what step 2 reads — **per sheet** (each sheet's elements
@@ -180,7 +180,7 @@ excluded from the average and counted separately as the headline drag).
 **The score endpoint is your gauge — call it, don't guess:**
 
 ```
-POST http://localhost:<port>/api/contract/steel-takeoff/score
+POST http://localhost:<port>/api/contract/steel-model/score
 Content-Type: application/json
 { "contract": <your draft contract>, "target": <target_confidence, e.g. 70> }
 ```
@@ -309,7 +309,7 @@ Key field rules:
 ### 5. Write to the contract store
 
 ```
-PUT http://localhost:<port>/api/contract/steel-takeoff
+PUT http://localhost:<port>/api/contract/steel-model
 Content-Type: application/json
 
 <contract JSON body>
@@ -317,7 +317,7 @@ Content-Type: application/json
 
 The server schema-validates the body. If it responds with `400`, read the error, fix the
 offending fields, and re-PUT. You can read back the current contract with
-`GET /api/contract/steel-takeoff`.
+`GET /api/contract/steel-model`.
 
 ### 6. Hand off to the user
 
@@ -347,7 +347,7 @@ DELETE http://localhost:<port>/api/requests/<id>
 
 Never write client, firm, or project identifiers into files, commits, or responses. The
 contract carries the source path in `source.path` and an embedded raster in `raster_b64` — both
-are machine-local (stored under `~/.floless/contracts/steel-takeoff.json` by the server and
+are machine-local (stored under `~/.floless/contracts/steel-model.json` by the server and
 never committed). Clip title blocks from any embedded preview.
 
 ---

package/dist/skills/floless-app-tweak-contract/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: floless-app-tweak-contract
-description: This skill should be used when there is a pending floless `tweak-contract` request — the user typed an instruction in the steel-takeoff contract editor and clicked Send (Ask AI). Also triggers on asks like "edit the steel takeoff contract via AI", "adjust the steel takeoff in the contract editor", "the user asked me to change the steel contract", "pick up my tweak-contract request", "update the member profile in the contract". It teaches the host AI to read the request, fetch the current steel.takeoff/v1 contract, apply the instruction (and any pasted screenshots), PUT the updated contract back, and resolve the request.
+description: This skill should be used when there is a pending floless `tweak-contract` request — the user typed an instruction in the Steel Model contract editor and clicked Send (Ask AI). Also triggers on asks like "edit the steel takeoff contract via AI", "adjust the steel takeoff in the contract editor", "the user asked me to change the steel contract", "pick up my tweak-contract request", "update the member profile in the contract". It teaches the host AI to read the request, fetch the current steel.takeoff/v1 contract, apply the instruction (and any pasted screenshots), PUT the updated contract back, and resolve the request.
 metadata:
   version: 0.1.0
 ---
@@ -9,7 +9,7 @@ metadata:
 
 ## What this is
 
-The floless.app steel-takeoff contract editor surfaces an **Ask AI** panel: the user types
+The floless.app Steel Model contract editor surfaces an **Ask AI** panel: the user types
 an instruction ("change all W12X26 to W14X30", "add a new beam on sheet S-202", "mark this
 member as moment-frame") and optionally pastes screenshots, then clicks **Send**. That records
 a `tweak-contract` request in the reverse channel. You pick it up here, edit the contract

package/dist/skills/reading-structural-drawings/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: reading-structural-drawings
+description: This skill should be used BEFORE modelling anything from a structural/architectural drawing SET (PDF). Use it whenever turning drawings into a 3D frame, takeoff, IFC, or Tekla model — it is the prerequisite reading discipline for the `floless-app-steel-takeoff` reader (and the `floless-app-steel-model` guide that orchestrates the full flow). Triggers on "read this drawing set", "model this structure from the PDF", "take off this steel", "build a model from these drawings", or any pure-PDF → structure task. It encodes the method that stops the classic failures (missing that a set is TWO buildings, missing a curved/sloped roof, conflating grids across sheets, tracing dimension lines as members) — establish MASSING + COORDINATE FRAME first (from the index + elevations + sections), members LAST; deterministic geometry feeds the reasoning; cross-validate every view; verify before presenting.
+metadata:
+  version: 0.1.2
+---
+
+# Reading a structural drawing set — the discipline (do this BEFORE you model anything)
+
+## Why this exists (the lesson, in one line)
+
+A frontier vision model is **document-literate, not drawing-literate** — free-reading a multi-sheet
+set and counting members "by eye" fails *by default* (symbol-grounded geometry ≈ 0.4–0.55 accuracy,
+AECV-Bench 2026). Getting a building wrong (two buildings read as one, a curved roof read as flat,
+a skewed grid read straight) is **not an OCR problem — it is a topology / cross-sheet-fusion
+problem.** The fix is order and validation, not "look harder". This skill is that order.
+
+> **Hard rule:** establish the **massing** (how many buildings, roof shape) and the **coordinate
+> frame** (grids + levels) FIRST. Members come LAST. If you are reading member sizes before you can
+> state the building count and roof geometry, STOP — you are about to be confidently wrong.
+
+## The one mistake to never repeat
+
+Plans cannot show the third dimension. **Building count, roof shape, and storey heights live in the
+ELEVATIONS and SECTIONS — read those before the framing plans.** (A real failure this skill came
+from: a set was modelled as one straight box from the plans; it was actually two separate buildings,
+one with a curved roof — both obvious in the elevations, invisible in the plan.)
+
+## Tools — use the deterministic layer; the AI interprets, never measures
+
+- **Render/extract with PyMuPDF (`fitz`)** — prefer it over `pdftoppm` (which may not be installed).
+  `page.get_text("words")` gives positioned text (grid bubbles, sizes) **losslessly** on vector PDFs;
+  `page.get_drawings()` gives every line with real coordinates. Read vectors before you OCR pixels.
+- **AWARE `vision` agent** (`aware agent describe vision`) — image/PDF → **fixed-schema** structured
+  JSON via a model. Use it for the structured extraction passes below; the FIXED schema is the point
+  (it constrains hallucination). The terminal AI / `vision` *interprets and assembles*; AWARE's
+  deterministic nodes own measurement and the `.lock` (the floless contract).
+- **Ask for DXF/DWG first.** If the source CAD exists, `ezdxf` (layers → grids/members/dims directly,
+  ARCs → curved roof for free) collapses ~80% of this. AWARE also ships CAD agents
+  (`autocad-2025/26`, `tekla`, `tsd-25/26`, `allplan`, `archicad`) if a real model file is available —
+  reading the model beats reverse-engineering the drawing.
+
+## The method — ordered passes (do not start a pass until the prior one is done)
+
+### Pass 0 — Inventory & sheet classification
+Read the **cover / drawing index** and **general notes** first. Build a sheet list classified by
+type (index, notes, foundation plan, framing plans per level, frame elevations, sections, details,
+**schedules**). Confirm the set is complete + current revision. Grab the legend, datum, material
+defaults, and the **abbreviations** (FC/MF/BF/(E)/(N)/matchline symbols). Trust PyMuPDF page_count over
+any external count.
+
+### Pass 1 — MASSING (how many buildings, what shape) — from elevations/sections, not plans
+- **Count the buildings.** Look for separate grid-label namespaces, **expansion/seismic joints**
+  (a double grid line / gap = two *structurally independent* buildings — members never frame across),
+  matchlines, building-name labels, and **disjoint grid clusters** (cluster the long grid lines from
+  `get_drawings()` — separate clusters = separate buildings).
+- **Roof + heights** from the **frame elevations and sections**: flat / sloped / hipped / **curved**;
+  ridge/eave elevations; storey heights; mezzanines. State each building's roof type explicitly.
+- Output a massing statement BEFORE going further, e.g. *"2 buildings: West (grids F–K.1 × 0.5–5.2),
+  2-storey, curved roof; East (grids A–F × 0.5–6), 2-storey, ~flat roof; separated by a seismic joint."*
+
+### Pass 2 — COORDINATE FRAME (grid + levels) per building
+- **Grid:** grid-bubble label positions are usually real text (`get_text("words")`). Per building,
+  per axis, build `(label, position, real_offset)`. **Calibrate scale from a real dimension string**
+  (e.g. a "16'-7¾"" between two bubbles) — NOT the title-block "1:100" (PDFs get re-scaled on plot).
+  A 2-point fit gives `real = A·pixel + b`. Check the grid is orthogonal / skewed / radial — don't
+  assume 90°. **Each sheet may have its own origin/orientation — re-anchor per sheet; never carry one
+  sheet's grid onto another** (this conflation is a top failure).
+- **Levels:** OCR the level/T.O.STEEL tags from an elevation/section into a datum table
+  (L1 +0'-0", L2 +16'-6", Roof …). Members snap to these.
+
+### Pass 3 — MEMBERS (now, and only now), per building, per level
+- Tile big sheets: **always include a low-DPI full-sheet overview alongside overlapping high-DPI
+  tiles** (≥200 DPI; overlap ≥ the largest label). A 3×3 of tiles with **no** overview destroys
+  coherence — that is the "wrong shape" failure. Tile only as fine as needed to make the smallest
+  label ~20 px.
+- Place each member by the **grid lines it spans** + its level. Read its size label; **confirm size
+  against the schedule** (column schedule = authoritative per tier/splice; beam schedule maps marks).
+  Map W18×35 = wide-flange, 18" nominal depth, 35 lb/ft, etc.
+- **Use a structured schema that enforces the order** (vision agent or your own): fill
+  `coordinate_system → buildings(+roof) → grids_per_building → members`, every value carrying
+  `source_view`, `evidence_bbox`, `confidence`, plus mandatory `unreadable[]` and `contradictions[]`.
+  A nullable/`unreadable` escape on every field is required — forcing a value the sheet doesn't show
+  *causes* fabrication.
+
+### Pass 4 — CROSS-VALIDATE (no single view is trusted)
+Plan ↔ elevation ↔ section ↔ schedule must agree. Confirm every member in ≥2 views; confirm
+sloped/spliced members in section/elevation. Disagreement → record in `contradictions[]` as an RFI
+candidate; **do not silently pick one.**
+
+### Pass 5 — VERIFY before presenting (definition of done)
+Before building/baking ANY model, self-check against the elevations/sections/3D:
+- building count, roof shape, storey heights, footprint — do they match what the elevations show?
+- did any member cross a seismic joint or matchline? (bug)
+- is the grid the right one for *this* building (not another sheet's)?
+Only then build the scene / overlay / IFC. If unsure, present the **massing + grid** for confirmation
+*before* spending effort on members.
+
+## Pitfalls checklist (the traps that cause wrong models)
+- [ ] Multiple independent buildings on one set (count first).
+- [ ] Seismic / expansion joint read as one structure.
+- [ ] Skewed / rotated / radial grid assumed orthogonal.
+- [ ] Curved / sloped roof read as flat (read the elevation!).
+- [ ] Grid from sheet A used on sheet B (per-sheet origins).
+- [ ] Dimension lines / grid lines / leaders traced as members (auto-extraction noise).
+- [ ] `(E)` existing vs `(N)` new vs demo merged (read the legend / line-weight / colour).
+- [ ] Member crossing a matchline read as terminating or double-counted.
+- [ ] Mezzanine / intermediate level missed (only sections show it).
+- [ ] Sizes scaled off the PDF instead of read from dimensions/schedule.
+
+## Companion skills
+- After this reading produces a verified structure, hand to the **`floless-app-steel-takeoff`** reader
+  to produce the editable `steel.takeoff/v1` contract (which then exports 3D + IFC + Tekla + BOM). This
+  skill is the *reading discipline*; that one is the *reader*. The **`floless-app-steel-model`** guide
+  (the front-door orchestrator) wraps the whole flow and references this discipline at the
+  classify-and-verify gates rather than re-deriving it.
+- There is no off-the-shelf OSS tool that does the whole drawing→model job — floorplan vectorisers
+  (e.g. CubiCasa5k) are residential-trained and won't read steel framing — which is why the order +
+  validation discipline above, not a single tool, is the method.
+
+## References (researched 2026-06-16)
+- AECV-Bench — VLMs are document- not drawing-literate; human-in-the-loop for geometry. arXiv 2601.04819.
+- Multi-stage hybrid VLM for multi-view drawings (arXiv 2510.21862); CAD2Program 2D→3D (arXiv 2412.11892).
+- "From Drawings to Decisions" detect-then-read (YOLO-OBB + small VLM), arXiv 2506.17374.
+- Image-tiling needs a global overview (arXiv 2512.11167); Claude vision limits (≤1568 px, images-before-text).
+- AISC 303 Code of Standard Practice (drawings show size/grade/location + work points); steel-detailing read-order guides.
+- Tooling: PyMuPDF, PaddleOCR/Surya, OpenCV/ELSED, ezdxf, IfcOpenShell.

package/dist/templates/{steel-takeoff.flo → steel-model.flo}

@@ -1,6 +1,6 @@
-app:           steel-takeoff
+app:           steel-model
 version:       0.2.0
-display-name:  Steel Takeoff
+display-name:  Steel Model
 publisher:     floless
 module:        steel-detailer
 description: |

package/dist/web/aware.js

@@ -2880,7 +2880,7 @@
   }
 
   // ── Workflow update (module-shaped) ─────────────────────────────────────────────
-  // A FloLess-published workflow (e.g. steel-takeoff) has a newer bundled template. Poll GET
+  // A FloLess-published workflow (e.g. steel-model) has a newer bundled template. Poll GET
   // /api/workflows/updates; when the OPEN app has one, show a pill → modal with the changelog →
   // "Back up & update" POSTs /api/workflows/:id/update (backup → swap structure → re-bake the user's
   // data from the contract store → recompile) → reload the app. No auto-update. `_wfUpdates` + the

package/dist/web/steel-3d-view.js

@@ -1,5 +1,5 @@
 /*
- * steel-3d-view.js — the 3D render/interaction layer for the steel-takeoff editor's 3D mode.
+ * steel-3d-view.js — the 3D render/interaction layer for the steel-model editor's 3D mode.
  *
  * Three.js lives ONLY here (the rest of the editor is import-free). It renders the SAME scene the
  * IFC/Tekla bake uses (fetched from /api/contract/:id/scene → contractToScene), so the editable 3D

package/dist/web/steel-editor.html

@@ -1,5 +1,5 @@
 <!doctype html><html><head><meta charset=utf-8>
-<title>Steel takeoff — editor</title>
+<title>Steel Model — editor</title>
 <style>
  :root{--bg:#0f172a;--panel:#1e293b;--line:#334155;--text:#e2e8f0;--mut:#94a3b8;--brand:#3b82f6}
  /* Theme EVERY scrollbar — no native white default may leak (applies to the canvas, panels, and every modal list). */
@@ -204,7 +204,7 @@
 <script type="module" src="./steel-3d-view.js"></script>
 </head><body>
 <header>
- <b>Steel takeoff</b>
+ <b>Steel Model</b>
  <div id=viewToggle role=group aria-label="Canvas view"><button id=vt2d class="seg on" aria-pressed=true title="Plan view (2D overlay)">2D</button><button id=vt3d class=seg aria-pressed=false title="3D model view">3D</button></div>
  <select id=planSel title="Switch plan view"></select>
  <span class=stat>Members <b id=mc>0</b></span><span class=stat>Weight <b id=wt>0</b> tons · <b id=wtlb>0</b> lb</span>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floless/app",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "type": "module",
   "description": "Thin localhost host for floless.app — serves web/ and shells the aware CLI. No engine, no LLM.",
   "bin": {