@floless/app 0.42.0 → 0.44.0

package/dist/templates/college-phase-exporter.flo

@@ -0,0 +1,86 @@
+app:           college-phase-exporter
+version:       0.1.0
+display-name:  College — Phase Exporter
+description: |
+  Reproduces the desktop "College - Phase Exporter" outcome on AWARE.
+  Given a phase number: Tekla BOM report -> SharePoint Excel -> Trimble Connect
+  upload -> Teams + email -> HTML summary. Composed against installed curated
+  commands only. Write-mode nodes carry the v0.11 safety contract.
+exposes-as-agent: false
+requires:
+  - tekla@0.1.x
+  - microsoft-365@0.1.x
+  - trimble-connect@0.1.x
+  - html-report@0.1.x
+requires-permissions:
+  filesystem:
+    - write: '{{ inputs.report-dir }}'
+  network:
+    - https://graph.microsoft.com
+    - https://app.connect.trimble.com
+layout: dag
+nodes:
+  - id: report
+    agent: tekla
+    command: report-create
+    inputs:
+      template: '350 Advanced Bill'
+      scope: phase
+      phase: '{{ inputs.phase }}'
+      output-path: '{{ inputs.report-dir }}/BOM-Phase-{{ inputs.phase }}.xlsx'
+  - id: excel
+    agent: microsoft-365
+    command: excel.range.write
+    inputs:
+      workbook: '{{ inputs.sharepoint-workbook-url }}'
+      worksheet: 'Phase {{ inputs.phase }}'
+      range: 'A1:B2'
+      values:
+        - ['Phase', 'Rows']
+        - ['{{ inputs.phase }}', '{{ report.row-count }}']
+    safety: { transaction-group: phase-export, snapshot: false }
+  - id: upload
+    agent: trimble-connect
+    command: upload
+    inputs:
+      project-id: '{{ inputs.tc-project-id }}'
+      folder-id: '{{ inputs.tc-reports-folder-id }}'
+      file-path: '{{ report.path }}'
+  - id: summary
+    agent: html-report
+    command: render
+    inputs:
+      template: 'phase-export-summary'
+      data:
+        phase: '{{ inputs.phase }}'
+        report: '{{ report.path }}'
+        uploaded: '{{ upload.url }}'
+      output-path: '{{ inputs.report-dir }}/Phase-{{ inputs.phase }}-summary.html'
+  - id: teams
+    agent: microsoft-365
+    command: teams.channel.post-message
+    inputs:
+      team-id: '{{ inputs.teams-team-id }}'
+      channel-id: '{{ inputs.teams-channel-id }}'
+      message: 'BOM Phase {{ inputs.phase }} exported {{ run.date }}. Report uploaded to Trimble Connect.'
+    safety: { transaction-group: notify, snapshot: false }
+  - id: email
+    agent: microsoft-365
+    command: outlook.mail.send-with-attachment
+    inputs:
+      to: ['{{ inputs.notify-email }}']
+      subject: 'Done — Phase {{ inputs.phase }} BOM'
+      content-type: html
+      body: |
+        Phase {{ inputs.phase }} bill of materials is attached and uploaded to Trimble Connect.
+      attachments:
+        - path: '{{ report.path }}'
+          filename: 'BOM-Phase-{{ inputs.phase }}.xlsx'
+    safety: { transaction-group: notify, snapshot: false }
+connections:
+  - { from: report,  to: excel }
+  - { from: report,  to: upload }
+  - { from: report,  to: summary }
+  - { from: upload,  to: summary }
+  - { from: summary, to: teams }
+  - { from: summary, to: email }

package/dist/templates/dummy-report.flo

@@ -0,0 +1,104 @@
+app:           dummy-report
+version:       0.1.0
+display-name:  Dummy Report
+description: |
+  A self-contained test workflow that produces a styled HTML report — no Tekla
+  model required. Neither node touches `model`, so it runs on the host bridge with
+  nothing open. Use it to preview the in-app HTML Viewer and the "Made with
+  FloLess" report badge end to end without a real model. Two real tekla/exec nodes:
+  a title input → a report node that builds the HTML inline and is the terminal the
+  viewer renders.
+exposes-as-agent: false
+inputs:
+  title:
+    type: string
+    default: "FloLess Test Report"
+    description: Heading shown at the top of the generated report (editable per run).
+requires:
+  - tekla@0.1.x
+layout: linear
+nodes:
+  # ── node 1: Title input — carries the report title downstream (no model deref) ──
+  - id: title-input
+    agent: tekla
+    command: exec
+    mode: read
+    config:
+      version: "2026.0"
+      args:
+        title: "{{ inputs.title }}"
+      code: |
+        // Title input — pure pass-through. Never touches `model`, so it runs even
+        // with no Tekla model open. Emits the title for the downstream report node.
+        string title = "FloLess Test Report";
+        if (args != null && args.TryGetValue("title", out var tv) && tv != null)
+        {
+            var s = tv.ToString();
+            if (!string.IsNullOrWhiteSpace(s)) title = s;
+        }
+        return new { ok = true, title };
+  # ── node 2: Report — build the styled HTML inline; be the terminal the viewer renders ──
+  - id: report
+    agent: tekla
+    command: exec
+    mode: read
+    config:
+      version: "2026.0"
+      args:
+        title: "{{ title-input.result.title }}"
+      code: |
+        // Dummy report — builds a styled HTML report inline and returns it as this
+        // terminal node's `html`, so the floless.app HTML Viewer renders it on
+        // double-click. Touches NO `model` (runs with no Tekla open) and writes no
+        // file. Pure string build, manual HTML-escape (no System.Net available).
+        using System;
+        using System.Text;
+
+        string title = "FloLess Test Report";
+        if (args != null && args.TryGetValue("title", out var tv) && tv != null)
+        {
+            var s = tv.ToString();
+            if (!string.IsNullOrWhiteSpace(s)) title = s;
+        }
+
+        Func<string, string> E = s => (s ?? "").Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;").Replace("\"", "&quot;");
+        string now = DateTime.Now.ToString("yyyy-MM-dd HH:mm");
+
+        var sb = new StringBuilder();
+        sb.Append("<!DOCTYPE html><html lang=\"en\"><head><meta charset=\"UTF-8\">");
+        sb.Append("<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">");
+        sb.Append("<title>" + E(title) + "</title><style>");
+        sb.Append("*{margin:0;padding:0;box-sizing:border-box}");
+        sb.Append("body{font-family:-apple-system,'Segoe UI',Roboto,sans-serif;background:#f1f5f9;color:#0f172a;padding:2.5rem;line-height:1.6}");
+        sb.Append(".wrap{max-width:760px;margin:0 auto;background:#fff;border:1px solid #e2e8f0;border-radius:12px;padding:2rem 2.25rem;box-shadow:0 10px 30px rgba(2,6,23,.06)}");
+        sb.Append(".hd{border-bottom:2px solid #4a9eff;padding-bottom:1rem;margin-bottom:1.5rem}");
+        sb.Append(".hd h1{font-size:1.6rem;font-weight:800;color:#0f172a}");
+        sb.Append(".hd p{color:#64748b;font-size:.85rem;margin-top:.3rem}");
+        sb.Append(".cards{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:.85rem;margin-bottom:1.75rem}");
+        sb.Append(".card{background:#f8fafc;border:1px solid #e2e8f0;border-radius:8px;padding:.9rem 1rem}");
+        sb.Append(".card .l{font-size:.68rem;text-transform:uppercase;letter-spacing:.05em;color:#94a3b8}");
+        sb.Append(".card .v{font-size:1.15rem;font-weight:700;color:#0f172a;margin-top:.15rem}");
+        sb.Append("table{width:100%;border-collapse:collapse;font-size:.9rem;margin-top:.25rem}");
+        sb.Append("th,td{text-align:left;padding:.6rem .75rem;border-bottom:1px solid #eef2f7}");
+        sb.Append("th{font-size:.7rem;text-transform:uppercase;letter-spacing:.05em;color:#94a3b8}");
+        sb.Append("td:first-child{font-weight:600;color:#334155;width:38%}");
+        sb.Append(".ft{margin-top:1.75rem;padding-top:1rem;border-top:1px solid #eef2f7;color:#94a3b8;font-size:.78rem;text-align:center}");
+        sb.Append("</style></head><body><div class=\"wrap\">");
+        sb.Append("<div class=\"hd\"><h1>" + E(title) + "</h1><p>A sample report generated by FloLess to preview the report viewer.</p></div>");
+        sb.Append("<div class=\"cards\">");
+        sb.Append("<div class=\"card\"><div class=\"l\">Status</div><div class=\"v\">OK</div></div>");
+        sb.Append("<div class=\"card\"><div class=\"l\">Generated</div><div class=\"v\">" + E(now) + "</div></div>");
+        sb.Append("<div class=\"card\"><div class=\"l\">Model needed</div><div class=\"v\">No</div></div>");
+        sb.Append("</div>");
+        sb.Append("<table><thead><tr><th>Field</th><th>Value</th></tr></thead><tbody>");
+        sb.Append("<tr><td>Workflow</td><td>dummy-report</td></tr>");
+        sb.Append("<tr><td>Status</td><td>OK</td></tr>");
+        sb.Append("<tr><td>Source</td><td>Generated by FloLess (no model required)</td></tr>");
+        sb.Append("<tr><td>Generated</td><td>" + E(now) + "</td></tr>");
+        sb.Append("</tbody></table>");
+        sb.Append("<div class=\"ft\">This is a dummy report for testing the FloLess HTML viewer.</div>");
+        sb.Append("</div></body></html>");
+
+        return new { ok = true, title, html = sb.ToString() };
+connections:
+  - { from: title-input, to: report }

package/dist/templates/hello-world.flo

@@ -0,0 +1,91 @@
+app:           hello-world
+version:       0.2.0
+display-name:  AWARE Hello World
+description: |
+  Smoke test: writes a one-line greeting to Tekla's prompt (status) bar — once in
+  Tekla 2025 and once in Tekla 2026 — to prove the AWARE runtime can drive a real
+  desktop host end to end. Two real tekla/exec nodes running read-only Roslyn C#
+  (Operation.DisplayPrompt; no model mutation, no filesystem write), so it runs on
+  any open model with no write permission.
+exposes-as-agent: false
+inputs:
+  message:
+    type: string
+    default: "Hello from floless.app — running end to end on AWARE."
+    description: The greeting shown on Tekla's prompt/status bar (editable per run).
+requires:
+  - tekla@0.1.x
+layout: dag
+nodes:
+  - id: message-input
+    agent: tekla
+    command: exec
+    mode: read
+    config:
+      version: "2025.0"
+      args:
+        message: "{{ inputs.message }}"
+      code: |
+        // Message input — carries the greeting downstream to both status nodes.
+        // Pure pass-through: returns the input message; never touches the model,
+        // so it runs even with no Tekla open (no model deref). Downstream nodes
+        // read it via the message-input.result.message template.
+        string message = "Hello from floless.app — running end to end on AWARE.";
+        if (args != null && args.TryGetValue("message", out var mv) && mv != null)
+        {
+            var s = mv.ToString();
+            if (!string.IsNullOrWhiteSpace(s)) message = s;
+        }
+
+        return new { ok = true, message };
+  - id: tekla-2025-status
+    agent: tekla
+    command: exec
+    mode: read
+    config:
+      version: "2025.0"
+      args:
+        message: "{{ message-input.result.message }}"
+      code: |
+        // Hello World — write a one-line greeting to Tekla's prompt (status) bar.
+        // Read-only: a transient prompt; never touches the model or filesystem.
+        if (model == null)
+            return new { ok = false, error = "No live Tekla 2025 model — open one in Tekla Structures 2025." };
+
+        string message = "Hello from floless.app — running on AWARE (Tekla 2025).";
+        if (args != null && args.TryGetValue("message", out var mv) && mv != null)
+        {
+            var s = mv.ToString();
+            if (!string.IsNullOrWhiteSpace(s)) message = s;
+        }
+
+        Tekla.Structures.Model.Operations.Operation.DisplayPrompt(message);
+
+        return new { ok = true, host = "tekla", version = "2025.0", message };
+  - id: tekla-2026-status
+    agent: tekla
+    command: exec
+    mode: read
+    config:
+      version: "2026.0"
+      args:
+        message: "{{ message-input.result.message }}"
+      code: |
+        // Hello World — write a one-line greeting to Tekla's prompt (status) bar.
+        // Read-only: a transient prompt; never touches the model or filesystem.
+        if (model == null)
+            return new { ok = false, error = "No live Tekla 2026 model — open one in Tekla Structures 2026." };
+
+        string message = "Hello from floless.app — running on AWARE (Tekla 2026).";
+        if (args != null && args.TryGetValue("message", out var mv) && mv != null)
+        {
+            var s = mv.ToString();
+            if (!string.IsNullOrWhiteSpace(s)) message = s;
+        }
+
+        Tekla.Structures.Model.Operations.Operation.DisplayPrompt(message);
+
+        return new { ok = true, host = "tekla", version = "2026.0", message };
+connections:
+  - { from: message-input, to: tekla-2025-status }
+  - { from: message-input, to: tekla-2026-status }

package/dist/templates/screenshot-to-saved-settings.flo

@@ -0,0 +1,56 @@
+app:           screenshot-to-saved-settings
+version:       0.1.0
+display-name:  Screenshot to Saved Settings
+description: |
+  Reproduces the desktop "screenshot-to-saved-settings" outcome on AWARE,
+  the decalog-#9 way (app-spec "Reading a drawing / PDF / image"):
+
+  The terminal AI reads a steel connection-schedule screenshot at COMPOSE time
+  and bakes the parsed rows into config.yaml as literals. The run is then fully
+  deterministic — for-each row writes a Tekla saved-attribute (.j) file via the
+  curated save-attributes verb. No runtime think-node reads the drawing.
+
+  (Optionally gate the writes behind an approve: block so a human eyeballs the
+  extraction first — app-spec L325. Omitted here: approve runtime lands in
+  aware v0.19.x; the compose-time-extraction + deterministic-write core is the
+  point.)
+exposes-as-agent: false
+inputs:
+  # The source drawing is BAKED at compose time (its rows live in config.schedule-rows),
+  # so this is not a runtime input — declaring it with read-strategy: bake surfaces the
+  # "Re-read & re-bake ▸" affordance (B3) so the user can swap the drawing and have the
+  # host AI re-extract + re-bake. The deterministic run never reads it.
+  drawing:
+    type: image
+    widget: file
+    read-strategy: bake
+    description: The connection-schedule screenshot baked into config — swap it to re-read & re-bake.
+requires:
+  - tekla@0.1.x
+  - html-report@0.1.x
+layout: linear
+nodes:
+  # Deterministic write: one .j attribute file per compose-time-extracted row.
+  - id: write-attributes
+    for-each: '{{ config.schedule-rows }}'
+    do:
+      - id: save
+        agent: tekla
+        command: save-attributes
+        config:
+          joint-id: '{{ item.joint-id }}'
+          filename: '{{ item.preset }}'
+        safety:
+          transaction-group: schedule-import
+          snapshot: true
+
+  - id: summary
+    agent: html-report
+    command: render
+    config:
+      template: 'schedule-import-summary'
+      data:
+        presets: '{{ config.schedule-rows }}'
+      output-path: '{{ inputs.report-dir }}/schedule-import.html'
+connections:
+  - { from: write-attributes, to: summary }

package/dist/templates/steel-from-drawings.flo

@@ -0,0 +1,73 @@
+app:           steel-from-drawings
+version:       0.1.0
+display-name:  Steel from Drawings
+description: |
+  Turn a structural steel drawing into an interactive, licence-free 3D model — no Tekla, no
+  modelling, no AI API key. Your terminal AI (Claude Code / Codex) reads the drawing once and
+  bakes a schematic 3D scene into this app; the viewer-3d agent renders it as an interactive
+  document anyone can orbit, click to inspect, and take off (counts + length by section) — so an
+  estimator, PM, fabricator or client can understand and price the steel before opening a seat.
+
+  The reading is a COMPOSE-TIME act — the FloLess way: the app is the prompt in your terminal, so
+  the brain is your AI terminal, never this server, and there is never a model in the run path.
+  Attach a drawing and use "Re-read & re-bake ▸" (or just ask your terminal AI to read it). The AI
+  reads the grids, members and sizes and bakes them straight into the `view` node's `scene` below
+  (the viewer-3d scene schema), recompiles, and asks you to approve; the deterministic run then
+  only renders the approved scene. Ships with a small example scene so it renders out of the box —
+  the `floless-app-steel-from-drawings` skill teaches your terminal AI how to read your own drawing in.
+exposes-as-agent: false
+inputs:
+  # BAKED at compose time: the terminal AI reads this drawing and writes the `view.scene` block
+  # below (the run never reads the drawing). read-strategy: bake surfaces "Re-read & re-bake ▸" so
+  # you can swap the drawing and have your AI re-read it. No runtime input node.
+  drawing:
+    type: image
+    widget: file
+    accept: [pdf, png, jpg]
+    read-strategy: bake
+    description: A structural steel drawing (framing plan / GA / elevation) — baked into the scene below; swap it to re-read & re-bake.
+requires:
+  - viewer-3d@0.1.x
+layout: linear
+nodes:
+  # The viewer-3d render node IS the terminal. Ships with a small EXAMPLE scene (a sample 3x2 bay
+  # frame, schematic) so the app renders out of the box. Re-bake — or the
+  # floless-app-steel-from-drawings skill — replaces this whole `scene` with a reading of YOUR drawing.
+  - id: view
+    agent: viewer-3d
+    command: render
+    config:
+      scene:
+        meta: { name: "Example — steel framing (sample, not your drawing)", units: mm, up: z }
+        groups:
+          - { key: column, label: "Columns (HSS6x6x3/8)", color: "#60a5fa" }
+          - { key: beam,   label: "Beams (W10x33)",       color: "#94a3b8" }
+        elements:
+          # 6 columns (z 0 -> 4500) on a 3 x 2 grid
+          - { id: COL-1A, group: column, kind: box, from: [0,0,0],       to: [0,0,4500],       section: { w: 150, d: 150 }, meta: { profile: "HSS6x6x3/8", grid: "1-A" } }
+          - { id: COL-2A, group: column, kind: box, from: [6000,0,0],    to: [6000,0,4500],    section: { w: 150, d: 150 }, meta: { profile: "HSS6x6x3/8", grid: "2-A" } }
+          - { id: COL-3A, group: column, kind: box, from: [12000,0,0],   to: [12000,0,4500],   section: { w: 150, d: 150 }, meta: { profile: "HSS6x6x3/8", grid: "3-A" } }
+          - { id: COL-1B, group: column, kind: box, from: [0,6000,0],    to: [0,6000,4500],    section: { w: 150, d: 150 }, meta: { profile: "HSS6x6x3/8", grid: "1-B" } }
+          - { id: COL-2B, group: column, kind: box, from: [6000,6000,0], to: [6000,6000,4500], section: { w: 150, d: 150 }, meta: { profile: "HSS6x6x3/8", grid: "2-B" } }
+          - { id: COL-3B, group: column, kind: box, from: [12000,6000,0],to: [12000,6000,4500],section: { w: 150, d: 150 }, meta: { profile: "HSS6x6x3/8", grid: "3-B" } }
+          # roof beams at z 4500 (W10x33): along each row, then tie beams along each grid line
+          - { id: BM-12A, group: beam, kind: box, from: [0,0,4500],      to: [6000,0,4500],      section: { w: 150, d: 250 }, meta: { profile: "W10x33", grid: "A" } }
+          - { id: BM-23A, group: beam, kind: box, from: [6000,0,4500],   to: [12000,0,4500],     section: { w: 150, d: 250 }, meta: { profile: "W10x33", grid: "A" } }
+          - { id: BM-12B, group: beam, kind: box, from: [0,6000,4500],   to: [6000,6000,4500],   section: { w: 150, d: 250 }, meta: { profile: "W10x33", grid: "B" } }
+          - { id: BM-23B, group: beam, kind: box, from: [6000,6000,4500],to: [12000,6000,4500],  section: { w: 150, d: 250 }, meta: { profile: "W10x33", grid: "B" } }
+          - { id: BM-1AB, group: beam, kind: box, from: [0,0,4500],      to: [0,6000,4500],      section: { w: 150, d: 250 }, meta: { profile: "W10x33", grid: "1" } }
+          - { id: BM-2AB, group: beam, kind: box, from: [6000,0,4500],   to: [6000,6000,4500],   section: { w: 150, d: 250 }, meta: { profile: "W10x33", grid: "2" } }
+          - { id: BM-3AB, group: beam, kind: box, from: [12000,0,4500],  to: [12000,6000,4500],  section: { w: 150, d: 250 }, meta: { profile: "W10x33", grid: "3" } }
+        grids:
+          - { label: "1", at: [0,-3000,0] }
+          - { label: "2", at: [6000,-3000,0] }
+          - { label: "3", at: [12000,-3000,0] }
+          - { label: "A", at: [-3000,0,0] }
+          - { label: "B", at: [-3000,6000,0] }
+        panels:
+          - title: Takeoff
+            note: "EXAMPLE — not your drawing. A sample steel frame on a 1-3 x A-B grid; sizes & heights are illustrative. Use 'Re-read & re-bake ▸' (or ask your terminal AI) to read your own drawing."
+            columns: [Section, "No.", Length]
+            rows:
+              - ["HSS6x6x3/8", 6, "27.0 m"]
+              - ["W10x33", 7, "42.0 m"]

package/dist/templates/steel-takeoff.flo

@@ -0,0 +1,151 @@
+app:           steel-takeoff
+version:       0.2.0
+display-name:  Steel Takeoff
+publisher:     floless
+module:        steel-detailer
+description: |
+  Turn a structural steel drawing into a verifiable takeoff — overlay + properties + a confidence
+  report you can judge — then an interactive 3D model (bake to IFC/Tekla) and a formatted BOM, all
+  in one workflow. The reading is a COMPOSE-TIME act (the FloLess way): your terminal AI reads the
+  drawing and bakes the takeoff; the deterministic run only renders the approved result. Attach a
+  drawing and use "Re-read & re-bake ▸" (or ask your terminal AI). Double-click the takeoff node to
+  open the editor; Approve bakes the lock; freeze a stage once it's right so Run never recomputes it.
+exposes-as-agent: false
+# Workflow changelog (FloLess-published). Newest first; the app shows entries newer than the
+# installed version when offering an update. Plain-English — it surfaces to the user.
+changelog:
+  - version: 0.2.0
+    summary: Filter your drawing down to the steel first
+    changes:
+      - "Added: a Filter step at the start that keeps only the real steel lines of your drawing — by layer, line weight, or colour, or by clicking an example — so the takeoff reads a clean drawing."
+  - version: 0.1.0
+    summary: Initial steel takeoff
+inputs:
+  drawing:
+    type: image
+    widget: file
+    accept: [pdf, png, jpg]
+    read-strategy: bake
+    description: A structural steel drawing — read by your terminal AI into the takeoff; swap to re-read & re-bake.
+  target_confidence:
+    type: number
+    default: 70
+    description: Minimum aggregate confidence the AI read aims for before handing you the editor (%).
+requires:
+  - html-report@0.2.x
+  - viewer-3d@0.1.x
+layout: linear
+nodes:
+  # ── node 1: filter — isolate the steel linework (FIRST stage) ─────────────────
+  # The pre-stage. Your terminal AI reads the drawing once (PyMuPDF, deterministic —
+  # no LLM) and bakes every element's layer / thickness / colour into the contract's
+  # `filter` block. Double-click this node to open the filter view: keep only the real
+  # steel lines — by facet (layer / thickness / colour) or the eyedropper (click a line
+  # or label → Add its layer/thickness/colour) — then Save. That saved selection is what
+  # the takeoff reader binds profile labels to (it replaces the length heuristic; falls
+  # back to it when no filter is saved). Ships with a tiny example summary so it renders
+  # out of the box; "Re-read & re-bake ▸" replaces it. The run renders a kept-layers
+  # summary (a baked read-only overlay is a later refinement).
+  - id: filter
+    agent: html-report
+    command: render
+    config:
+      surface: steel-filter
+      data:
+        - { Layer: "S-ANNO-BEAM-STEL", Elements: 374, Kept: "yes (steel)" }
+        - { Layer: "S-ANNO-GRID",      Elements: 319, Kept: "no" }
+        - { Layer: "S-ANNO-DIMS",      Elements: 575, Kept: "no" }
+
+  # ── node 2: read — takeoff summary ───────────────────────────────────────────
+  # config.contract is the FloLess editor discriminator (renderers.js contractTypeOf).
+  # config.takeoff is the SINGLE SOURCE the editor + Approve-bake + render all key on:
+  # server/contract-bake.ts writes the approved contract under config.takeoff (finding
+  # this node by config.contract === type), and GET /api/contract falls back to it so
+  # the editor opens with the baked contract. It is BAKED at compose time by the terminal
+  # AI from the drawing above; the run re-renders it as an HTML summary. Ships with a tiny
+  # EXAMPLE so it renders out of the box — "Re-read & re-bake ▸" replaces config.takeoff.
+  - id: read
+    agent: html-report
+    command: render
+    config:
+      contract: steel.takeoff/v1
+      takeoff:
+        type: steel.takeoff/v1
+        source: { name: "Example — sample framing (not a real drawing)" }
+        weights:
+          W10X33:       49.1
+          HSS6X6X3/8:  27.48
+        plans:
+          - sheet: EX-1
+            title: Example Framing Plan
+            members:
+              - { id: m1, profile: W10X33,      role: beam,   wp: [[0,0],[6000,0]] }
+              - { id: m2, profile: HSS6X6X3/8,  role: column, wp: [[0,0],[0,4500]] }
+      template: steel-takeoff-summary
+      # NOTE: html-report does NOT template a sibling config key — `data: '{{ config.takeoff }}'`
+      # collapses to one opaque item (verified: subtitle "1 item", no member data). So we mirror
+      # config.takeoff inline here for the render. config.takeoff above remains the canonical
+      # source (editor + Approve-bake + GET /api/contract); a later task can wire the render
+      # to it once html-report (or the BOM formatter) consumes the structured contract.
+      data:
+        type: steel.takeoff/v1
+        source: { name: "Example — sample framing (not a real drawing)" }
+        weights:
+          W10X33:       49.1
+          HSS6X6X3/8:  27.48
+        plans:
+          - sheet: EX-1
+            title: Example Framing Plan
+            members:
+              - { id: m1, profile: W10X33,      role: beam,   wp: [[0,0],[6000,0]] }
+              - { id: m2, profile: HSS6X6X3/8,  role: column, wp: [[0,0],[0,4500]] }
+
+  # ── node 3: view — interactive 3D model ──────────────────────────────────────
+  # scene is BAKED at compose time (matches config.takeoff above).
+  # Ships with a minimal EXAMPLE scene matching the takeoff above so it renders
+  # out of the box. The terminal AI replaces the whole scene when re-baking.
+  - id: view
+    agent: viewer-3d
+    command: render
+    config:
+      scene:
+        meta: { name: "Example — sample framing (not a real drawing)", units: mm, up: z }
+        groups:
+          - { key: column, label: "Columns (HSS6x6x3/8)", color: "#60a5fa" }
+          - { key: beam,   label: "Beams (W10x33)",       color: "#94a3b8" }
+        elements:
+          - { id: m1, group: beam,   kind: box, from: [0,0,0],    to: [6000,0,0],    section: { w: 150, d: 250 }, meta: { profile: "W10X33",      sheet: "EX-1" } }
+          - { id: m2, group: column, kind: box, from: [0,0,0],    to: [0,0,4500],    section: { w: 150, d: 150 }, meta: { profile: "HSS6X6X3/8",  sheet: "EX-1" } }
+        panels:
+          - title: Takeoff
+            note: "EXAMPLE — not your drawing. Swap the drawing input and ask your terminal AI to re-read & re-bake."
+            columns: [Section, "No.", "Length / Height"]
+            rows:
+              - ["W10X33",      1, "6.0 m"]
+              - ["HSS6X6X3/8",  1, "4.5 m"]
+
+  # ── node 4: bom — bill of materials ──────────────────────────────────────────
+  # Stub: renders the same takeoff data as a formatted BOM table.
+  # Replace with a real BOM formatter skill (later task).
+  - id: bom
+    agent: html-report
+    command: render
+    config:
+      template: steel-takeoff-bom
+      data:
+        type: steel.takeoff/v1
+        source: { name: "Example — sample framing (not a real drawing)" }
+        weights:
+          W10X33:       49.1
+          HSS6X6X3/8:  27.48
+        plans:
+          - sheet: EX-1
+            title: Example Framing Plan
+            members:
+              - { id: m1, profile: W10X33,      role: beam,   wp: [[0,0],[6000,0]] }
+              - { id: m2, profile: HSS6X6X3/8,  role: column, wp: [[0,0],[0,4500]] }
+
+connections:
+  - { from: filter, to: read }
+  - { from: read, to: view }
+  - { from: view, to: bom }