@floless/app 0.51.0 → 0.52.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.52.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.52.0" : void 0 });
 }
 
 // workflow-update.ts
@@ -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)
   "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-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-takeoff` 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/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/package.json

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