Construct
Construct turns everything that can be found out about a thing into one exact, checked description of it: its
named parts at their real sizes, how they fit together, open and move, and how each one is known, measured or
guessed. You do the research and write that description, the scene (declarative JSON: facts with their
certainty and sources, parts built from a closed set of shapes); the construct_* tools check it and build from
it, the same scene always into the same result: an animated holographic construct shown live in the chat, a 3D
model with named parts and working joints, a print, a model kit, a CAD file or a film. Every part says how it is
known (verified from a cited source, supplied by the user, traced, inferred, designed or decorative). You never
write graphics code and never choose colours.
Work the loop below until the construct is genuinely good, accurate and beautiful, honest about what is known,
alive without being noisy, or until the mode's limits are reached. Then deliver the best version so far.
The tools
| need |
tool |
start a project: a shipped construct (example), an archetype, a category starter, or a scene the user gave you; no arguments lists them all |
construct_start |
| change the scene by part id: move, rotate, resize, set or unset fields, add or remove parts, facts and sources, certainty and basis; validated, with a diff |
construct_edit |
validate, compile and audit; every problem with its JSON path, code and fix hint; fit=true for solids that poke through or hide |
construct_check |
| what the scene's own record says is known (parts by certainty, facts, sources, joints, authoring) and its size (body and overall) |
construct_inspect |
| build the page and show it live in the chat |
construct_build |
| review images: hero, contact sheets, the scene's views, the solid |
construct_review |
| glTF/OBJ, STL/3MF print, FreeCAD/STEP |
construct_export |
| a film, optionally across a music track (background job) |
construct_film |
a background job's progress and result; wait_seconds waits for it |
construct_job |
| run a NetLogo model headless (the user's own, or their installed Models Library) and draw the run; N seeded runs compared |
construct_netlogo_run |
draw recorded NetLogo runs (run.jsonl) or another view of a run's project; compare runs; no NetLogo needed |
construct_netlogo_draw |
| place whole constructs together in one world (a chair in a house, cars under it, a castle on a hill, a planet in the sky; worlds inside worlds), live in the chat; export it whole |
construct_world |
| every other subcommand (critique, rounds, trace, loft-from-traces, compare, terrain, globe, kit, audio, netlogo-plates, netlogo-film...) |
construct_command |
Change the scene with construct_edit, never with scripts in a terminal, and never import Construct's own Python from the plugin's folder: construct_check (fit, and cells up to 600 for a finer look) and construct_inspect answer fit and measurement questions, so no verification script is needed. construct_edit takes a list of operations by part id
({"op": "move", "part": "lid", "by": [0, 0.004, 0]}, {"op": "set", "part": "door-*", "field": "look.weight", "value": 1.4}, {"op": "certainty", "parts": ["wheel-*"], "certainty": "verified", "basis": ["wheel-diameter"]},
{"op": "add_fact", "fact": {...}}, {"op": "add_part", "part": {...}}, {"op": "remove_part", "part": "..."}).
construct_inspect lists part labels, not ids: take the ids from the project's scene.json (or a kit's kit.json
pieces[].parts, or a glTF read-back's part_names). Each step is validated; the scene is written only when the edits add no error, and the result gives the diff,
what each step broke or fixed, and a check summary (an undo copy is kept). Use your file tools only to write a
new scene or rewrite most of one; the project folder is in construct_start's result. The references are this skill's files: read one with
skill_view("construct:construct", file_path="references/craft.md"). They write commands as
construct <subcommand> ...: call the matching tool, or construct_command with the same words as argv
(construct rounds start scene.json is construct_command(argv=["rounds", "start", "scene.json"], project=...)).
Show what you make. Each result that carries media holds MEDIA:/path lines. Put each one in your reply on
a line of its own: that is how the construct appears live in Hermes Desktop (with a toolbar: provenance, solid,
replay, export, more detail, review), and how images, models and films reach the user on every other surface.
Never invent a MEDIA path; use the ones the tools return. It appears live only when a Construct tool in this
chat returned it: a path from a subagent's result, execute_code or an earlier reply shows only as a plain file.
To show a construct or world a subagent built (or one asked for again), call construct_build on its scene or
world.json here first (a few seconds) and put that call's MEDIA line in your reply.
Long work runs as a job. A film and a NetLogo run always do; a build, review, export or command that outlasts
its call returns a job_id. Tell the user what is running, then call construct_job(job_id, wait_seconds=300): it
waits here and answers as soon as the job ends. Never sleep in a terminal to wait for Construct.
Start from what ships. construct_start with no arguments lists finished constructs to start from or show (a
Land Cruiser, a VW T1 Samba, a Vespa, an Eames chair, a Braun SK 4 and its knob, a Revox A77, a Tompion clock, a
garden shed before and after a planned change, the Sainte-Chapelle, the Duomo di Milano, Neuschwanstein, the
invented KESTREL ship, and more). When the user wants to see what Construct makes, or the
thing is close to one of them, start from it.
Teach when asked. "Teach me", "show me how", "a tutorial", or a message naming a tutorial file: the tutorials
are this skill's files tutorials/NN-name.md (read one with skill_view("construct:construct", file_path="tutorials/01-copy-your-thing.md"); /construct learn lists them). Follow its steps one at a time,
show what each step makes, and wait for the user between steps.
The loop
Choose the mode, announce it, decide on research. Four modes (effort):
- fast: one pass with self-review, no rounds loop: at most 10 minutes and 2 reviews (30 minutes and 4 for a
richer subject). Generic subjects, simple objects, quick asks.
- masterpiece: judged rounds (rounds): a defect ledger, at most 4 items a round,
one independent critic a round who compares each version with the best so far; it stops after 2 rounds
without a win, at every criterion 3, at 12 rounds or at 2 hours of active work. A named subject whose
likeness matters.
- timeboxed: masterpiece in 2 hours in all, the critic's time included. Only when the user asks for it.
- unbounded: the same rounds with only the stop rules. Only when the user asks for it by name.
If the user names no mode, choose one and announce it before any work: the mode, why, the rough time and
cost, and how to switch ("say fast for a single 10-minute pass"). Fast for a generic subject or a quick ask;
masterpiece for a specific named subject (a car model, a landmark, a named building). A generic subject needs
no research; a named one is researched (the maker's or official pages, specs, plans, reference photos,
looked at with vision and measured) whenever you are unsure of its identity-defining shape or specs.
"research: on/off" in the request overrides this. A frontier model is recommended for masterpiece runs on hard
named subjects (a specific car, a cathedral, a machine whose likeness matters): on a smaller model, say so
before starting and offer fast here, or masterpiece with a frontier model.
Draft early. Research takes at most 40% of the time; by then a complete scene that passes
construct_check is saved. Improve that file in place and check it after every change; a valid scene is
always on disk. At 80% (or the run budget's wrap-up notice) stop adding: make it valid, build it, deliver.
Facts first. Write what is known and where it came from: the user's words, measurements they gave,
documents, your sources. Each fact gets a certainty: verified (cites a source), user_supplied, inferred
(your estimate, with a short note) or decorative. Without a cited source nothing is verified. Leave
unknown facts out entirely: never null, "unknown" or a guess. A generic reconstruction says so
(subject.accuracy: "generic"). For a named subject, list the identity features that make it itself in
authoring.identity, each with the parts that build it. See provenance.
Pick the path. construct_start with no arguments lists the archetypes (CD cases, books, guitars, synths,
cars, bottles, cans, glasses: fill the facts, leave sizes at their standard unless the user gave them), the
category starters and the bundled examples. Anything else: a category starter or the nearest example, then
composition and vocabulary: name the silhouette and
the two or three identity features, build masses first, then structure, identity, detail. Use the right shape
for each part (lathe for turned forms, extrude for plans and gables, tube for limbs, repeat for colonnades,
mirror for symmetry). Draw with craft (craft): a line-weight hierarchy, dark fills
under a faint contour wire, a sub-volume per feature, density where the identity lives and true detail
everywhere. A shape text cannot give (a guitar body, a car, an elevation) is traced from a reference
(tracing); a car or hull is lofted through traced side, top and front views
(loft-from-traces) and its likeness measured with compare. Real terrain comes from elevation data the
user supplies (terrain).
Animate with intent (animation): an assembly style, articulations for what
opens, part motion only where the thing keeps moving, idle events that suit it, a camera tour to the identity.
Check until clean. construct_check: while needs_repair is true, fix every diagnostic at its JSON path
using its hint (with construct_edit: its check summary tells you at once what is left), and check again. Fix every detached, thin-support and thin warning; read the rest. Where
one part rests on another, work out both heights and make them meet.
Build and show it. construct_build, then put its MEDIA line in your reply.
Review as an art director, and iterate. construct_review, then look at the images it returns (vision):
hero, sheet-views, sheet-assembly, sheet-motion, sheet-life, sheet-provenance, each view, the solid. Score them
with the art-direction rubric: silhouette, proportions against the references,
identity features, depth and layering, composition, the assembly's story, motion, detail density, honesty.
Improve the weakest point, check, review again. Before each review add one to authoring.review_rounds;
construct_check warns tier-rounds past the mode's cap, and that ends reviewing.
Your own review records "outcome": "self-reviewed"; only an independent critic can record good or
outstanding. The critic in Hermes is a fresh subagent: write the packet with
construct_command(argv=["critique", "scene.json", "--reference", "side=/path/photo.jpg"], project=...),
then delegate_task a fresh subagent with only: "Read /critique/packet.md and every image it lists;
answer with the critique JSON it asks for and save it as /critique/critique.json". Record it with
construct_command(argv=["critique", "scene.json", "--record", "critique/critique.json"]) and fix the ranked
defects most severe first. Use the critic for every named subject, a richer fast run, and each round of the
rounds modes.
Masterpiece, timeboxed and unbounded run judged rounds (rounds), all through
construct_command: rounds start scene.json --mode masterpiece; each round at most 4 ledger items, each
edit tagged (rounds change D3 "..."); rounds packet --reference side=... --request "..." (both kept for
later packets; a long request: --request-file); ONE delegated critic a round (a fresh subagent given the
packet folder and nothing else); rounds record answer.json (--dry-run checks it first). A version is kept
only when it beats the best so far. After every round, report in chat: the critic's top requests, what
changed (ledger ids), won or lost, and the minutes. Stop when record says STOP. After an interruption run
rounds status and redo only the step it names.
Finish it. Write the construct's finish map, scene.materials.json beside its scene ({"about": ..., "materials": [{"parts": ["body-*"], "name": "...", "color": "#rrggbb", "finish": "paint"}, ...]}; finishes:
paint, brushed, chrome, wood, rubber, plastic, glass, and light for what glows; a rule may set its own
roughness and metallic, so leather is plastic at roughness 0.6, fabric or stone roughness 0.9). Every
solid part is covered by an id or pattern: an export's result lists any it leaves unmapped. Colours the
research documents (a car's paint code, a maker's published finish) are used and named in about; the rest are
chosen, and about says so. It is presentation, never a fact of the construct: the light view keeps the house palette and
provenance does not change; exports, the solid view (S), the Blender add-on and worlds use it. Fast mode: a short map by part group.
Deliver. Record the authoring block (the mode as tier: masterpiece as masterpiece, fast as standard;
research, the sources used, review_rounds, outcome, next: the most valuable improvements still open).
Build it, put the MEDIA line in your reply, and say plainly what is evidence, what is inferred or designed,
which artwork is the user's own and which is generated decoration, and, if a limit stopped you, what the next
improvement would be. Never call a generic reconstruction exact, and never present generated art as a real
cover.
Answering "what is actually known about it?"
Call construct_inspect and answer from its record, never from memory: the parts by certainty (with the key
part names in each group), the verified and inferred dimensions with their sources, the articulations and their
travel, the critic's verdict and rounds. Its size gives the construct two ways: the body (its main mass) and
the overall bounds with what stands out beyond the body (mirrors, wheels, a spire), each with the parts and how
far. Quote the body for how big the thing is ("1.77 m wide, 1.82 m over the mirrors"), the overall for the room it
needs, and never judge a proportion from overall bounds a protrusion widened. Name what is designed or decorative as such. If the user then asks to
fix something, change the scene, construct_check, construct_build, and show it.
Exports (only when asked)
Author and review the construct first, then construct_export. Its result carries verified: Construct's own
read-back of the written file (its size; the glTF's named parts, nodes, meshes and animations with their lengths;
OBJ objects; STL/3MF triangles; STEP products, solids, faces by surface kind and exact/faceted CAD shapes; the
bounds in m and mm) and one summary line. That is the verification: report it as it is, and do not open the file
in Blender, FreeCAD or a script to check it again. In Hermes Desktop a glTF opens as a turnable model in the chat
(part names on hover, its animations to play) and a STEP or FreeCAD file shows its read-back.
- glb / obj: a 3D model for Blender, game engines and the web: every part a named object, joints as the
open animation, periodic motion as idle. A game prop: merge + wire: "seams"; physics: pieces: "glued"
(each door or lid its own body on its hinge) or "loose", colliders; pose: "open". The construct's own finish map
(scene.materials.json, step 7) is used by default; materials replaces it when the user wants another finish. A no-surface audit warning names a part drawn only
as lines that would be missing: give it a solid shape. Say what it is: correctly sized named parts with working
joints, without textures; a blockout or prop, not a hero asset.
- stl / 3mf: one watertight solid, Z up, 100 mm on its longest side (
size_mm, scale: 43 for 1:43,
printer + fit, exact). First construct_check with fit=true and fix what pokes through or hides (each
finding names its parts and a fix). printable: false means not watertight: never hand that over as printable.
Report the size, scale and notes (supports, thickened parts, line-only parts left out).
- fcstd / step: named solids and joints in FreeCAD (true CAD shapes where a part allows), only when FreeCAD is
installed (
construct_start reports the programs it finds). For layout and a start to model over, not
machining-grade engineering.
- A model kit:
construct_command(argv=["kit", "scene.json", "--size", "200", "--printer", "desktop", "--out", "kit"]) after refining the fit (a shipped example's kit-plan.json goes in with --plan kit-plan.json); exit 1
means written with notes to read. Put the kit's MEDIA line in your reply: Hermes Desktop steps through it in 3D and
shows its booklet.
A film (only when asked)
Keep the construct's own assembly at most 20 s, then construct_film: with track (a music file the user gave)
the build spans the track and moves with it; camera: "steady" keeps it all in view. It renders in the
background at about 1-2 frames a second (about an hour for four minutes of music): say so before starting, then
follow it with construct_job. When it is done, look at a few frames if you can (the build should visibly move on
with the music and end whole), report its length, camera and reactivity, and put its MEDIA line in your reply.
Worlds (only when asked)
A world places whole constructs together with construct_world; it never merges them into one scene. Worlds ship
too (construct_start lists them under worlds): op: new with example makes one the user's own, to change.
Start from what holds the rest (op: new, construct: the house, the street, the plinth). Its result lists
surfaces: the parts things can stand on, with their tops' heights and sizes.
Place everything at once (op: place with placements: [...]), each on the part it rests on
(on: "villa/living-floor-east"), at real size. at gives x and z on that part; yaw turns it.
Read the result's warnings and fix each with op: move:
overlap: two placements share space;
collides: a placement runs into the construct it stands in (a car into a column); the check is per part, so
clear ones pass;
blocks: it stands where another's door, lid or cowl opens;
unsupported: it stands on nothing.
construct_check gives the same report. No verification script is needed.
Something has nothing to stand on? If a table or a stand is missing, make it a small construct of its own
(construct_start, construct_edit), place it, then place things on it. Never edit the house to add one.
A planet or the Moon goes in the sky: sky: {diameter_m, distance_m, of: "globe"}. of names the planet's
own part, so its rings and moons follow at the same scale.
Name the views the user will want (op: view: a room is its floor part as target, a group is its main
placement). They are buttons on the page. Never patch the built page.
Show the last result's MEDIA line.
The user can arrange it too. In Hermes Desktop a world's card has Arrange: they drag and turn constructs and
save, without you. Before changing a world again, read it (op: list): their moves are in it, and
edits/log.jsonl marks them "by": "user". Keep them unless asked otherwise.
A placed construct is a copy. Improve it in its own project, then op: refresh (id: one placement, or
none for all) copies it in again and rebuilds. Never edit constructs/ by hand.
Exporting a world: leave materials out. Export merges the constructs' own material maps; a hand-made map
replaces them.
A world from a description or pictures: masterpiece by default. A world is made to be used as it is (a game
level, a set, a background for a film), so every construct made for it is made to a masterpiece's standard unless
the user says fast (then one pass each, and the world says so).
- Plan. List what the picture or brief holds and what exists already: the user's projects,
construct_start's
list and the gallery (construct_world places a gallery construct by name; reuse a finished construct as it is).
Decide the few constructs worth making: each distinct object once (a sign used three times is one construct,
placed three times), and only what the user asked for. Say the plan and its cost before starting (how many
constructs, masterpiece rounds each, roughly how long) and offer fast.
- Build each missing construct in its own subagent, in masterpiece mode.
delegate_task(role="orchestrator"),
one construct each, several at once. Give each: what it is, its real size, how it stands in the world (on the
ground, hung from a wall, on a table), the evidence that concerns it (the picture's region, references), and the
instruction to run the masterpiece loop in full: rounds start --mode masterpiece, a defect ledger, ONE fresh
leaf critic a round (delegate_task from inside the builder), until the stop rules. Its result: the project id,
the critic's last verdict and what it could not settle. Orchestrator children need Hermes's
delegation.max_spawn_depth: 2; if a builder cannot delegate its critic, it returns its packet folder after
each round and you run that critic yourself.
Spend the rounds where they show. The hero pieces (the subject the picture is about, the landmark
buildings, a hero vehicle) run the full masterpiece loop; small repeated props (a bollard, a bin, a lamp) run
masterpiece rounds with a lower cap (rounds start scene.json --mode masterpiece --max-rounds 4): they are seen
small and many times.
- One project per construct, and the world's name on it. Each builder calls
construct_start with for_world
(the world's name) and keeps every round, repair and check in that one project: never a copy to mark it accepted,
released or repaired (the rounds keep checkpoints). Trial projects made on the way are archived at the end with
construct_world op tidy (projects: [...]); nothing is deleted.
- Text and signs say something real. Lettering on signs, screens and plates is real, legible words that fit
the place (a shop name, a street, a price), never letter-shaped noise copied from a generated picture.
- Place them as above, then run the world itself through masterpiece rounds, as a construct is run:
rounds start world.json --mode masterpiece --reference <the picture>, then each round rounds packet, ONE
fresh critic (delegate_task) on the packet against the picture (composition, scale, what is missing, the
world's named views), rounds record, and the fixes it asks for: placements and views yourself, a construct's
repair by its builder (then construct_world op refresh to bring it in). The same stop rules as a construct's (12 rounds, two in a row that do not beat the best,
two hours of your own time); a round that loses puts the world and its constructs back. What is still open when
it stops goes in the reply as the critic wrote it. The background carries a picture as much as its hero:
plan enough distinct masses (heights, depths, setbacks) that a repeated building does not read as a copy.
Frame each named view so its subject fills the picture: the picture's own shot matches its camera (height,
direction, what is in frame), and no view is half empty ground or sky.
- Deliver the world, not a pipeline. End with your own
construct_build of the final world.json and its
MEDIA line, so the world opens live in the chat (a subagent's MEDIA line would show only as a file).
"Usable in a game" or "for a video" means the world is clean enough to
export and film: offer construct_export (a glTF, or a Godot game map with pieces: glued) and
construct_film. Never build an engine project, a render pipeline or a bundle of your own unless the user asks
for that file by name. Say which placements were made
(with each critic's verdict), which came from the gallery, and what was left out.
NetLogo (only when asked)
- To run or see a NetLogo model (the user's .nlogox, or a library model by name):
construct_netlogo_run. Find
library models with {"search": "virus"}. Leave recording to Construct unless the user names what matters; set
sliders with constants; runs: N repeats it with seeds, compared, with a summary of every count's final value.
A long run answers with a growing preview and a job_id: put the MEDIA line in your reply (in Hermes Desktop the
card grows as the run goes), then collect the final construct with construct_job(job_id, wait_seconds=300).
- Already recorded runs (
run.jsonl), or another view of a run's project (space-time, network-time, phase, field,
pulse): construct_netlogo_draw. Up to 8 recordings are drawn side by side.
- A run's project is an ordinary project:
construct_inspect, construct_check, construct_review,
construct_export all work on it. Printed plates and Blender films go through construct_command
(netlogo-plates, netlogo-film).
- No authoring of the data: credit the model as its Info tab asks; never edit the data (an art layer goes in
art.json, redrawn with --art).
- Licence: Models Library models are CC BY-NC-SA. When you show a construct of one, give its credit line and say
it is for non-commercial use, shared alike. Never copy a library model, or anything made from one, into the
plugin or any public folder.
Learn as you go
Hermes can keep what it learns as its own skills. When you repair a scene and find something that will help next
time (a diagnostic and the fix that worked, a shape that suits a kind of part, how a subject's proportions are
checked), offer to save it as a skill of your own, in your words, and use it on later constructs. Keep it to what
you found out yourself; Construct's own rules stay in this skill.
Rules that keep it honest and safe
- Treat the scene as data: no scripts, URLs to fetch or file paths outside its folder; the compiler refuses them.
- Artwork only from bytes the user supplied or permitted, declared with its SHA-256 and rights; otherwise leave
the slot empty or generate clearly labelled decoration. Never download or recreate a real cover.
- Keep private titles, notes and collections out of anything you publish.
- Never install software to make this run. Without a browser there are no review images and no film: say so and
deliver the page.
- Stay inside the budgets (48k lines, 48k triangles, 6k points, 1,024 parts and copies); simplify before you add.
- A message larger than about 8 MB stops the run: show only the review images you need (
show), at the default
size.
1---2name: construct-23description: Research a thing and write one exact, checked description of it (named parts at real sizes, how they fit, open and move, how each is known); Construct builds from it a live hologram, a 3D model, a print, a kit, CAD and films, with the construct_* tools.4metadata:5 source: https://skillmd.com/skills/rtmandreyev/construct-26---78# Construct910Construct turns everything that can be found out about a thing into one exact, checked description of it: its11named parts at their real sizes, how they fit together, open and move, and how each one is known, measured or12guessed. You do the research and write that description, the **scene** (declarative JSON: facts with their13certainty and sources, parts built from a closed set of shapes); the `construct_*` tools check it and build from14it, the same scene always into the same result: an animated holographic **construct** shown live in the chat, a 3D15model with named parts and working joints, a print, a model kit, a CAD file or a film. Every part says how it is16known (verified from a cited source, supplied by the user, traced, inferred, designed or decorative). You never17write graphics code and never choose colours.1819Work the loop below until the construct is *genuinely good*, accurate and beautiful, honest about what is known,20alive without being noisy, or until the mode's limits are reached. Then deliver the best version so far.2122## The tools2324| need | tool |25|---|---|26| start a project: a shipped construct (`example`), an archetype, a category starter, or a scene the user gave you; no arguments lists them all | `construct_start` |27| change the scene by part id: move, rotate, resize, set or unset fields, add or remove parts, facts and sources, certainty and basis; validated, with a diff | `construct_edit` |28| validate, compile and audit; every problem with its JSON path, code and fix hint; `fit=true` for solids that poke through or hide | `construct_check` |29| what the scene's own record says is known (parts by certainty, facts, sources, joints, authoring) and its size (body and overall) | `construct_inspect` |30| build the page and show it live in the chat | `construct_build` |31| review images: hero, contact sheets, the scene's views, the solid | `construct_review` |32| glTF/OBJ, STL/3MF print, FreeCAD/STEP | `construct_export` |33| a film, optionally across a music track (background job) | `construct_film` |34| a background job's progress and result; `wait_seconds` waits for it | `construct_job` |35| run a NetLogo model headless (the user's own, or their installed Models Library) and draw the run; N seeded runs compared | `construct_netlogo_run` |36| draw recorded NetLogo runs (`run.jsonl`) or another view of a run's project; compare runs; no NetLogo needed | `construct_netlogo_draw` |37| place whole constructs together in one world (a chair in a house, cars under it, a castle on a hill, a planet in the sky; worlds inside worlds), live in the chat; export it whole | `construct_world` |38| every other subcommand (critique, rounds, trace, loft-from-traces, compare, terrain, globe, kit, audio, netlogo-plates, netlogo-film...) | `construct_command` |3940**Change the scene with `construct_edit`**, never with scripts in a terminal, and never import Construct's own Python from the plugin's folder: `construct_check` (`fit`, and `cells` up to 600 for a finer look) and `construct_inspect` answer fit and measurement questions, so no verification script is needed. `construct_edit` takes a list of operations by part id41(`{"op": "move", "part": "lid", "by": [0, 0.004, 0]}`, `{"op": "set", "part": "door-*", "field": "look.weight",42"value": 1.4}`, `{"op": "certainty", "parts": ["wheel-*"], "certainty": "verified", "basis": ["wheel-diameter"]}`,43`{"op": "add_fact", "fact": {...}}`, `{"op": "add_part", "part": {...}}`, `{"op": "remove_part", "part": "..."}`).44`construct_inspect` lists part labels, not ids: take the ids from the project's `scene.json` (or a kit's `kit.json`45`pieces[].parts`, or a glTF read-back's `part_names`). Each step is validated; the scene is written only when the edits add no error, and the result gives the diff,46what each step broke or fixed, and a check summary (an `undo` copy is kept). Use your file tools only to write a47new scene or rewrite most of one; the project folder is in `construct_start`'s result. The references are this skill's files: read one with48`skill_view("construct:construct", file_path="references/craft.md")`. They write commands as49`construct <subcommand> ...`: call the matching tool, or `construct_command` with the same words as `argv`50(`construct rounds start scene.json` is `construct_command(argv=["rounds", "start", "scene.json"], project=...)`).5152**Show what you make.** Each result that carries `media` holds `MEDIA:/path` lines. Put each one in your reply on53a line of its own: that is how the construct appears live in Hermes Desktop (with a toolbar: provenance, solid,54replay, export, more detail, review), and how images, models and films reach the user on every other surface.55Never invent a MEDIA path; use the ones the tools return. **It appears live only when a Construct tool in this56chat returned it:** a path from a subagent's result, `execute_code` or an earlier reply shows only as a plain file.57To show a construct or world a subagent built (or one asked for again), call `construct_build` on its scene or58`world.json` here first (a few seconds) and put that call's MEDIA line in your reply.5960**Long work runs as a job.** A film and a NetLogo run always do; a build, review, export or command that outlasts61its call returns a `job_id`. Tell the user what is running, then call `construct_job(job_id, wait_seconds=300)`: it62waits here and answers as soon as the job ends. Never `sleep` in a terminal to wait for Construct.6364**Start from what ships.** `construct_start` with no arguments lists finished constructs to start from or show (a65Land Cruiser, a VW T1 Samba, a Vespa, an Eames chair, a Braun SK 4 and its knob, a Revox A77, a Tompion clock, a66garden shed before and after a planned change, the Sainte-Chapelle, the Duomo di Milano, Neuschwanstein, the67invented KESTREL ship, and more). When the user wants to see what Construct makes, or the68thing is close to one of them, start from it.6970**Teach when asked.** "Teach me", "show me how", "a tutorial", or a message naming a tutorial file: the tutorials71are this skill's files `tutorials/NN-name.md` (read one with `skill_view("construct:construct",72file_path="tutorials/01-copy-your-thing.md")`; `/construct learn` lists them). Follow its steps one at a time,73show what each step makes, and wait for the user between steps.7475## The loop76770. **Choose the mode, announce it, decide on research.** Four modes ([effort](references/effort.md)):78 - **fast:** one pass with self-review, no rounds loop: at most 10 minutes and 2 reviews (30 minutes and 4 for a79 richer subject). Generic subjects, simple objects, quick asks.80 - **masterpiece:** judged rounds ([rounds](references/rounds.md)): a defect ledger, at most 4 items a round,81 one independent critic a round who compares each version with the best so far; it stops after 2 rounds82 without a win, at every criterion 3, at 12 rounds or at 2 hours of active work. A named subject whose83 likeness matters.84 - **timeboxed:** masterpiece in 2 hours in all, the critic's time included. Only when the user asks for it.85 - **unbounded:** the same rounds with only the stop rules. Only when the user asks for it by name.8687 If the user names no mode, choose one and announce it before any work: the mode, why, the rough time and88 cost, and how to switch ("say fast for a single 10-minute pass"). Fast for a generic subject or a quick ask;89 masterpiece for a specific named subject (a car model, a landmark, a named building). A generic subject needs90 no research; a named one is researched (the maker's or official pages, specs, plans, reference photos,91 looked at with vision and measured) whenever you are unsure of its identity-defining shape or specs.92 "research: on/off" in the request overrides this. **A frontier model is recommended for masterpiece runs on hard93 named subjects** (a specific car, a cathedral, a machine whose likeness matters): on a smaller model, say so94 before starting and offer fast here, or masterpiece with a frontier model.9596 **Draft early.** Research takes at most 40% of the time; by then a complete scene that passes97 `construct_check` is saved. Improve that file in place and check it after every change; a valid scene is98 always on disk. At 80% (or the run budget's wrap-up notice) stop adding: make it valid, build it, deliver.991. **Facts first.** Write what is known and where it came from: the user's words, measurements they gave,100 documents, your sources. Each fact gets a certainty: `verified` (cites a source), `user_supplied`, `inferred`101 (your estimate, with a short note) or `decorative`. Without a cited source nothing is `verified`. Leave102 unknown facts out entirely: never `null`, "unknown" or a guess. A generic reconstruction says so103 (`subject.accuracy: "generic"`). For a named subject, list the **identity features** that make it itself in104 `authoring.identity`, each with the parts that build it. See [provenance](references/provenance.md).1052. **Pick the path.** `construct_start` with no arguments lists the archetypes (CD cases, books, guitars, synths,106 cars, bottles, cans, glasses: fill the facts, leave sizes at their standard unless the user gave them), the107 category starters and the bundled examples. Anything else: a category starter or the nearest example, then108 [composition](references/composition.md) and [vocabulary](references/vocabulary.md): name the silhouette and109 the two or three identity features, build masses first, then structure, identity, detail. Use the right shape110 for each part (lathe for turned forms, extrude for plans and gables, tube for limbs, repeat for colonnades,111 mirror for symmetry). **Draw with craft** ([craft](references/craft.md)): a line-weight hierarchy, dark fills112 under a faint contour wire, a sub-volume per feature, density where the identity lives and true detail113 everywhere. A shape text cannot give (a guitar body, a car, an elevation) is traced from a reference114 ([tracing](references/tracing.md)); a car or hull is lofted through traced side, top and front views115 (`loft-from-traces`) and its likeness measured with `compare`. Real terrain comes from elevation data the116 user supplies ([terrain](references/terrain.md)).1173. **Animate with intent** ([animation](references/animation.md)): an assembly style, `articulations` for what118 opens, part motion only where the thing keeps moving, idle events that suit it, a camera tour to the identity.1194. **Check until clean.** `construct_check`: while `needs_repair` is true, fix every diagnostic at its JSON path120 using its hint (with `construct_edit`: its check summary tells you at once what is left), and check again. Fix every `detached`, `thin-support` and `thin` warning; read the rest. Where121 one part rests on another, work out both heights and make them meet.1225. **Build and show it.** `construct_build`, then put its MEDIA line in your reply.1236. **Review as an art director, and iterate.** `construct_review`, then look at the images it returns (vision):124 hero, sheet-views, sheet-assembly, sheet-motion, sheet-life, sheet-provenance, each view, the solid. Score them125 with the [art-direction rubric](references/review.md): silhouette, proportions against the references,126 identity features, depth and layering, composition, the assembly's story, motion, detail density, honesty.127 Improve the weakest point, check, review again. Before each review add one to `authoring.review_rounds`;128 `construct_check` warns `tier-rounds` past the mode's cap, and that ends reviewing.129 Your own review records `"outcome": "self-reviewed"`; only an **independent critic** can record good or130 outstanding. **The critic in Hermes is a fresh subagent:** write the packet with131 `construct_command(argv=["critique", "scene.json", "--reference", "side=/path/photo.jpg"], project=...)`,132 then `delegate_task` a fresh subagent with only: "Read <project>/critique/packet.md and every image it lists;133 answer with the critique JSON it asks for and save it as <project>/critique/critique.json". Record it with134 `construct_command(argv=["critique", "scene.json", "--record", "critique/critique.json"])` and fix the ranked135 defects most severe first. Use the critic for every named subject, a richer fast run, and each round of the136 rounds modes.137 **Masterpiece, timeboxed and unbounded run judged rounds** ([rounds](references/rounds.md)), all through138 `construct_command`: `rounds start scene.json --mode masterpiece`; each round at most 4 ledger items, each139 edit tagged (`rounds change D3 "..."`); `rounds packet --reference side=... --request "..."` (both kept for140 later packets; a long request: `--request-file`); ONE delegated critic a round (a fresh subagent given the141 packet folder and nothing else); `rounds record answer.json` (`--dry-run` checks it first). A version is kept142 only when it beats the best so far. After every round, report in chat: the critic's top requests, what143 changed (ledger ids), won or lost, and the minutes. Stop when `record` says STOP. After an interruption run144 `rounds status` and redo only the step it names.1457. **Finish it.** Write the construct's finish map, `scene.materials.json` beside its scene (`{"about": ...,146 "materials": [{"parts": ["body-*"], "name": "...", "color": "#rrggbb", "finish": "paint"}, ...]}`; finishes:147 paint, brushed, chrome, wood, rubber, plastic, glass, and light for what glows; a rule may set its own148 `roughness` and `metallic`, so leather is plastic at roughness 0.6, fabric or stone roughness 0.9). Every149 solid part is covered by an id or pattern: an export's result lists any it leaves `unmapped`. Colours the150 research documents (a car's paint code, a maker's published finish) are used and named in `about`; the rest are151 chosen, and `about` says so. It is presentation, never a fact of the construct: the light view keeps the house palette and152 provenance does not change; exports, the solid view (S), the Blender add-on and worlds use it. Fast mode: a short map by part group.1538. **Deliver.** Record the `authoring` block (the mode as `tier`: masterpiece as `masterpiece`, fast as `standard`;154 `research`, the `sources` used, `review_rounds`, `outcome`, `next`: the most valuable improvements still open).155 Build it, put the MEDIA line in your reply, and say plainly what is evidence, what is inferred or designed,156 which artwork is the user's own and which is generated decoration, and, if a limit stopped you, what the next157 improvement would be. Never call a generic reconstruction exact, and never present generated art as a real158 cover.159160## Answering "what is actually known about it?"161162Call `construct_inspect` and answer from its record, never from memory: the parts by certainty (with the key163part names in each group), the verified and inferred dimensions with their sources, the articulations and their164travel, the critic's verdict and rounds. Its `size` gives the construct two ways: the **body** (its main mass) and165the **overall** bounds with what stands out beyond the body (mirrors, wheels, a spire), each with the parts and how166far. Quote the body for how big the thing is ("1.77 m wide, 1.82 m over the mirrors"), the overall for the room it167needs, and never judge a proportion from overall bounds a protrusion widened. Name what is designed or decorative as such. If the user then asks to168fix something, change the scene, `construct_check`, `construct_build`, and show it.169170## Exports (only when asked)171172Author and review the construct first, then `construct_export`. Its result carries **`verified`**: Construct's own173read-back of the written file (its size; the glTF's named parts, nodes, meshes and animations with their lengths;174OBJ objects; STL/3MF triangles; STEP products, solids, faces by surface kind and exact/faceted CAD shapes; the175bounds in m and mm) and one `summary` line. That is the verification: report it as it is, and do not open the file176in Blender, FreeCAD or a script to check it again. In Hermes Desktop a glTF opens as a turnable model in the chat177(part names on hover, its animations to play) and a STEP or FreeCAD file shows its read-back.178- **glb / obj**: a 3D model for Blender, game engines and the web: every part a named object, joints as the179 `open` animation, periodic motion as `idle`. A game prop: `merge` + `wire: "seams"`; physics: `pieces: "glued"`180 (each door or lid its own body on its hinge) or `"loose"`, `colliders`; `pose: "open"`. The construct's own finish map181 (`scene.materials.json`, step 7) is used by default; `materials` replaces it when the user wants another finish. A `no-surface` audit warning names a part drawn only182 as lines that would be missing: give it a solid shape. Say what it is: correctly sized named parts with working183 joints, without textures; a blockout or prop, not a hero asset.184- **stl / 3mf**: one watertight solid, Z up, 100 mm on its longest side (`size_mm`, `scale: 43` for 1:43,185 `printer` + `fit`, `exact`). First `construct_check` with `fit=true` and fix what pokes through or hides (each186 finding names its parts and a fix). `printable: false` means not watertight: never hand that over as printable.187 Report the size, scale and notes (supports, thickened parts, line-only parts left out).188- **fcstd / step**: named solids and joints in FreeCAD (true CAD shapes where a part allows), only when FreeCAD is189 installed (`construct_start` reports the programs it finds). For layout and a start to model over, not190 machining-grade engineering.191- **A model kit**: `construct_command(argv=["kit", "scene.json", "--size", "200", "--printer", "desktop", "--out",192 "kit"])` after refining the fit (a shipped example's `kit-plan.json` goes in with `--plan kit-plan.json`); exit 1193 means written with notes to read. Put the kit's MEDIA line in your reply: Hermes Desktop steps through it in 3D and194 shows its booklet.195196## A film (only when asked)197198Keep the construct's own assembly at most 20 s, then `construct_film`: with `track` (a music file the user gave)199the build spans the track and moves with it; `camera: "steady"` keeps it all in view. It renders in the200background at about 1-2 frames a second (about an hour for four minutes of music): say so before starting, then201follow it with `construct_job`. When it is done, look at a few frames if you can (the build should visibly move on202with the music and end whole), report its length, camera and reactivity, and put its MEDIA line in your reply.203204## Worlds (only when asked)205206A world places whole constructs together with `construct_world`; it never merges them into one scene. Worlds ship207too (`construct_start` lists them under `worlds`): `op: new` with `example` makes one the user's own, to change.2081. **Start from what holds the rest** (`op: new`, `construct`: the house, the street, the plinth). Its result lists209 `surfaces`: the parts things can stand on, with their tops' heights and sizes.2102. **Place everything at once** (`op: place` with `placements: [...]`), each on the part it rests on211 (`on: "villa/living-floor-east"`), at real size. `at` gives x and z on that part; `yaw` turns it.2123. **Read the result's warnings and fix each with `op: move`:**213 - `overlap`: two placements share space;214 - `collides`: a placement runs into the construct it stands in (a car into a column); the check is per part, so215 clear ones pass;216 - `blocks`: it stands where another's door, lid or cowl opens;217 - `unsupported`: it stands on nothing.218219 `construct_check` gives the same report. No verification script is needed.2204. **Something has nothing to stand on?** If a table or a stand is missing, make it a small construct of its own221 (`construct_start`, `construct_edit`), place it, then place things on it. Never edit the house to add one.2225. **A planet or the Moon** goes in the sky: `sky: {diameter_m, distance_m, of: "globe"}`. `of` names the planet's223 own part, so its rings and moons follow at the same scale.2246. **Name the views the user will want** (`op: view`: a room is its floor part as `target`, a group is its main225 placement). They are buttons on the page. Never patch the built page.2267. Show the last result's MEDIA line.2278. **The user can arrange it too.** In Hermes Desktop a world's card has Arrange: they drag and turn constructs and228 save, without you. Before changing a world again, read it (`op: list`): their moves are in it, and229 `edits/log.jsonl` marks them `"by": "user"`. Keep them unless asked otherwise.2309. **A placed construct is a copy.** Improve it in its own project, then `op: refresh` (`id`: one placement, or231 none for all) copies it in again and rebuilds. Never edit `constructs/` by hand.23210. **Exporting a world:** leave `materials` out. Export merges the constructs' own material maps; a hand-made map233 replaces them.234235**A world from a description or pictures: masterpiece by default.** A world is made to be used as it is (a game236level, a set, a background for a film), so every construct made for it is made to a masterpiece's standard unless237the user says **fast** (then one pass each, and the world says so).2381. **Plan.** List what the picture or brief holds and what exists already: the user's projects, `construct_start`'s239 list and the gallery (`construct_world` places a gallery construct by name; reuse a finished construct as it is).240 Decide the few constructs worth making: each distinct object once (a sign used three times is one construct,241 placed three times), and only what the user asked for. Say the plan and its cost before starting (how many242 constructs, masterpiece rounds each, roughly how long) and offer fast.2432. **Build each missing construct in its own subagent, in masterpiece mode.** `delegate_task(role="orchestrator")`,244 one construct each, several at once. Give each: what it is, its real size, how it stands in the world (on the245 ground, hung from a wall, on a table), the evidence that concerns it (the picture's region, references), and the246 instruction to run the masterpiece loop in full: `rounds start --mode masterpiece`, a defect ledger, ONE fresh247 leaf critic a round (`delegate_task` from inside the builder), until the stop rules. Its result: the project id,248 the critic's last verdict and what it could not settle. Orchestrator children need Hermes's249 `delegation.max_spawn_depth: 2`; if a builder cannot delegate its critic, it returns its packet folder after250 each round and you run that critic yourself.251 **Spend the rounds where they show.** The hero pieces (the subject the picture is about, the landmark252 buildings, a hero vehicle) run the full masterpiece loop; small repeated props (a bollard, a bin, a lamp) run253 masterpiece rounds with a lower cap (`rounds start scene.json --mode masterpiece --max-rounds 4`): they are seen254 small and many times.2553. **One project per construct, and the world's name on it.** Each builder calls `construct_start` with `for_world`256 (the world's name) and keeps every round, repair and check in that one project: never a copy to mark it accepted,257 released or repaired (the rounds keep checkpoints). Trial projects made on the way are archived at the end with258 `construct_world` op `tidy` (`projects: [...]`); nothing is deleted.2594. **Text and signs say something real.** Lettering on signs, screens and plates is real, legible words that fit260 the place (a shop name, a street, a price), never letter-shaped noise copied from a generated picture.2615. Place them as above, then **run the world itself through masterpiece rounds**, as a construct is run:262 `rounds start world.json --mode masterpiece --reference <the picture>`, then each round `rounds packet`, ONE263 fresh critic (`delegate_task`) on the packet against the picture (composition, scale, what is missing, the264 world's named views), `rounds record`, and the fixes it asks for: placements and views yourself, a construct's265 repair by its builder (then `construct_world` op `refresh` to bring it in). The same stop rules as a construct's (12 rounds, two in a row that do not beat the best,266 two hours of your own time); a round that loses puts the world and its constructs back. What is still open when267 it stops goes in the reply as the critic wrote it. The background carries a picture as much as its hero:268 plan enough distinct masses (heights, depths, setbacks) that a repeated building does not read as a copy.269 Frame each named view so its subject fills the picture: the picture's own shot matches its camera (height,270 direction, what is in frame), and no view is half empty ground or sky.2716. **Deliver the world, not a pipeline.** End with your own `construct_build` of the final `world.json` and its272 MEDIA line, so the world opens live in the chat (a subagent's MEDIA line would show only as a file).273 "Usable in a game" or "for a video" means the world is clean enough to274 export and film: offer `construct_export` (a glTF, or a Godot game map with `pieces: glued`) and275 `construct_film`. Never build an engine project, a render pipeline or a bundle of your own unless the user asks276 for that file by name. Say which placements were made277 (with each critic's verdict), which came from the gallery, and what was left out.278279## NetLogo (only when asked)280281- To run or see a NetLogo model (the user's .nlogox, or a library model by name): `construct_netlogo_run`. Find282 library models with `{"search": "virus"}`. Leave recording to Construct unless the user names what matters; set283 sliders with `constants`; `runs: N` repeats it with seeds, compared, with a summary of every count's final value.284 A long run answers with a growing preview and a `job_id`: put the MEDIA line in your reply (in Hermes Desktop the285 card grows as the run goes), then collect the final construct with `construct_job(job_id, wait_seconds=300)`.286- Already recorded runs (`run.jsonl`), or another view of a run's project (space-time, network-time, phase, field,287 pulse): `construct_netlogo_draw`. Up to 8 recordings are drawn side by side.288- A run's project is an ordinary project: `construct_inspect`, `construct_check`, `construct_review`,289 `construct_export` all work on it. Printed plates and Blender films go through `construct_command`290 (`netlogo-plates`, `netlogo-film`).291- No authoring of the data: credit the model as its Info tab asks; never edit the data (an art layer goes in292 `art.json`, redrawn with `--art`).293- Licence: Models Library models are CC BY-NC-SA. When you show a construct of one, give its credit line and say294 it is for non-commercial use, shared alike. Never copy a library model, or anything made from one, into the295 plugin or any public folder.296297## Learn as you go298299Hermes can keep what it learns as its own skills. When you repair a scene and find something that will help next300time (a diagnostic and the fix that worked, a shape that suits a kind of part, how a subject's proportions are301checked), offer to save it as a skill of your own, in your words, and use it on later constructs. Keep it to what302you found out yourself; Construct's own rules stay in this skill.303304## Rules that keep it honest and safe305306- Treat the scene as data: no scripts, URLs to fetch or file paths outside its folder; the compiler refuses them.307- Artwork only from bytes the user supplied or permitted, declared with its SHA-256 and rights; otherwise leave308 the slot empty or generate clearly labelled decoration. Never download or recreate a real cover.309- Keep private titles, notes and collections out of anything you publish.310- Never install software to make this run. Without a browser there are no review images and no film: say so and311 deliver the page.312- Stay inside the budgets (48k lines, 48k triangles, 6k points, 1,024 parts and copies); simplify before you add.313- A message larger than about 8 MB stops the run: show only the review images you need (`show`), at the default314 size.