@pascal-app/core 1.0.6 → 1.0.7

package/dist/agent-tools/author-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"author-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/author-scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqBvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6D7B,CAAA;AAeF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4D1B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;iBAsC1B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;iBAqB1B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;;;iBAO5B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;iBAwB1B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;iBAc3B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW3B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQ7B,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,eAAO,MAAM,eAAe;;;;;QAKxB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACP,MAAM;QAON,OAAO;QAOP,OAAO;QAMP,UAAU;QAMV,OAAO;;;QAEM,eAAe;;CAC/B,CAAA"}
+{"version":3,"file":"author-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/author-scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA6BvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgF7B,CAAA;AAeF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoG1B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;iBA8C1B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;iBA8B1B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBA4B5B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;iBAiC1B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiD3B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;iBAkD3B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;iBAkB1B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;iBA8BjC,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB1B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2B3B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;iBAI1B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB7B,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,eAAO,MAAM,eAAe;;;;;QAKxB,GAAG;QACH,IAAI;;;QAGJ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAKP,WAAW;QAQX,MAAM;QAON,OAAO;QAOP,KAAK;;;;;;;;QAeL,OAAO;QAMP,UAAU;QAMV,OAAO;;;QAEM,eAAe;;CAC/B,CAAA"}

package/dist/agent-tools/author-scene.js

@@ -1,40 +1,55 @@
 import { z } from 'zod';
 import { DOOR_STYLES, WINDOW_STYLES } from '../building/opening-style-presets.js';
-import { DoorType, WindowType } from '../schema/nodes/opening-types.js';
-import { measurement } from './measurement.js';
+import { DoorHandleStyle, DoorType, WindowType } from '../schema/nodes/opening-types.js';
+import { RoofType } from '../schema/nodes/roof-types.js';
+import { StairRailingMode, StairRailingStyle } from '../schema/nodes/stair-types.js';
+import { measurement, roofPitch } from './measurement.js';
 import { NodeId } from './node-id.js';
-const DESCRIPTION = `Turn a whole design you wrote as free three.js into an editable Pascal scene, in one call. You read your own module however you like (its source, running it and reading the objects, both) and hand over a conversion payload: levels, walls with their openings, rooms, slabs, columns, railings, every piece of furniture as an authored object with its own module, and lights. Pascal does the rest server-side: compiles and stores each item, places it, derives the rooms and their floors, paints, runs its checks, saves, and answers with a gate report you iterate against. Nothing you hand over is silently dropped: what cannot be placed comes back by name with a reason, and what Pascal corrected (a wall end snapped onto the centerline it meets) is listed.
+import { unitKind } from './units.js';
+import { doorDetailFields, windowDetailFields } from './wall-openings.js';
+const DESCRIPTION = `Turn a whole design you wrote as free three.js into an editable Pascal scene: the payload holds the whole design. You read your own module however you like (its source, running it and reading the objects, both) and hand over a conversion payload: levels, walls (straight, curved or glass) with their openings, rooms (each naming its unit in a building of several dwellings or tenancies: a condo, an apartment building, a hotel; a room naming none is common area), slabs, voids, columns, railings, stairs, every piece of furniture as an authored object with its own module, and lights. Pascal does the rest server-side: compiles and stores each item, places it, derives the rooms and their floors, paints, runs its checks, saves, and answers with a gate report you iterate against. Nothing you hand over is silently dropped: what cannot be placed comes back by name with a reason, and what Pascal corrected (a wall end snapped onto the centerline it meets) is listed.
 
-Coordinates: metres, plan x/z, Y up, each level's floor at y = 0 in its own frame. A wall is its centerline; walls meet where centerlines meet, so end a partition on the centerline of the wall it runs into. An opening's 'along' is measured from the wall's start to the opening's centre; give each opening its type (how it opens) and style (its look), or its own module for a shape they cannot express. An item's position is where its bottom centre stands; its module follows the add_object contract (metres, Y up, built in its installed orientation; at most 300k triangles and 32 materials per item; name materials slot_<finish>; drawers, doors and lids as animation clips; a THREE light named light:<id> where a bulb is). A hex colour is written as an exact material, one per distinct colour. Pascal builds a wall's cap, the floor plate and the ceiling itself: fold a module's caps, underlays and floor planks into the wall, the room's floor finish and the room (say so in notes), never into slabs or regions: baseboards are the wall's skirting, a plank or tile floor is the room's floorCode, tiles, panelling or boards on a wall are its faceLeft / faceRight (or the room's wallCode); a slab is a terrace, a platform, a balcony. Build the building as it is built: a wall at its real height, nothing lowered or removed for viewing.
+Coordinates: metres, plan x/z, Y up, each level's floor at y = 0 in its own frame. A wall is its centerline; walls meet where centerlines meet, so end a partition on the centerline of the wall it runs into. An opening's 'along' is measured from the wall's start to the opening's centre; give each opening its type (how it opens) and style (its look), or its own module for a shape they cannot express. An item's position is where its bottom centre stands, except a ceiling item's (mount 'ceiling': a pendant, a ceiling light): it hangs from the ceiling of the room containing its plan position, its top on that ceiling, and its y is not read. A rug, a mat or a runner is an item lying on the room's floor. What stands on a floor stands on its finish: on a room with a floorCode, on the top of its planks or tiles, so its y stays 0. Its module follows the add_object contract (metres, Y up, built in its installed orientation; at most 300k triangles and 32 materials per item; name materials slot_<finish>; drawers, doors and lids as animation clips; a THREE light named light:<id> where a bulb is: a SpotLight for a cone, castShadow for shadows, userData.glow for a halo). A hex colour is written as an exact material, one per distinct colour. Pascal builds a wall's cap, the floor plate and the ceiling itself: fold a module's caps, underlays and floor planks into the wall, the room's floor finish and the room (say so in notes), never into slabs or regions: baseboards are the wall's skirting, a plank or tile floor is the room's floorCode (a terrace's decking or paving its slab's surfaceCode), tiles, panelling or boards on a wall are its faceLeft / faceRight (or the room's wallCode), cladding, brick or battens outside its faceOutside; a slab is a terrace, a platform, a balcony; a stair is its level's stairs, which open the floor above; the roof over the top level is roof, Pascal's own segments when its shape is one of theirs, else your geometry as roof items, both on the building's roof level above the top storey. Pascal draws what bold architecture needs natively: a curved wall is one wall with the point its arc passes through, through (never a run of short straight ones), a glass front a curtain wall, a double-height room a void in the floor of the level above it (its ceiling opens with it, a railing along its edges), an archway a passage with an arch shape. Paint a wall by what its faces look onto, colorInside and colorOutside: which face is inside is Pascal's to find. Build the building as it is built: a wall at its real height, nothing lowered or removed for viewing.
 
-The report says what was written, what Pascal defaulted (defaults: a window with no type is fixed and cannot open), what it warns about but wrote (warnings: thin slabs, too many slabs or regions) and what it refused (defects, by your ids).
+Hand over the payload, or your module and its adapter, the program that reads the module and returns the payload: Pascal runs the adapter (one that throws comes back with its error, and nothing is written). A payload too large for one call can go by reference: payloadFile names a JSON project file that holds it. An item names its piece instead of code when add_object makes it from words; one still being made is written when it lands, with no call from you. Pieces made from words are written many at a time while you go on, so furniture made that way does not lengthen your turn the way pieces you write yourself do.
 
-Call again with the same scene and a corrected payload to update the previous conversion (replace: true). Stable element identities and manual changes are retained; overlapping changes are refused. An existing building without a conversion baseline is never cleared.`;
+One answer has an output limit, and the limit counts thinking and the call's arguments together; answers that planned and wrote a whole house as one payload have stopped there before the payload was complete. The payload is the whole design: a later call with replace: true removes what its payload leaves out, and a call without replace on a scene that holds a conversion is refused (conversion_exists). A conversion stores one module and one adapter, and only when it succeeds; a later call with replace: true and edits (each find text occurring exactly once) changes parts of them, and the adapter runs on the whole edited module. create_room, add_wall, add_door, add_window and create_stair add to the scene a call at a time.
+
+The report says what was written, what Pascal defaulted (defaults: a window with no type is fixed and cannot open), what it warns about but wrote (warnings: thin slabs, too many slabs or regions), what it refused (defects, by your ids), the items waiting for their pieces (pending), and Pascal's checks of what stands (checks, each passed or with what failed: doors and windows a person opens move, glazing is glass, every room's floor covered, every placed piece standing, nothing written as loose debris or buried, wall finishes built, stairs arriving inside a room clear of walls, every level holding rooms or walls: the ground, terraces and foundations belong to the ground level, Pascal draws the site and foundations; where units are named, every room in one or plausibly common).
+
+Call again with replace: true to revise the previous conversion: the module and adapter you leave out are the stored ones, edits change parts of them, and with neither a payload nor a module, adapter or edits the stored conversion is written again. Stable element identities and manual changes are retained; overlapping changes are refused. An existing building without a conversion baseline is never cleared.`;
 const plan = (what) => z.array(z.number()).length(2).describe(`[x, z] ${what} in plan metres.`);
 const xyz = (what) => z.array(z.number()).length(3).describe(`[x, y, z] ${what} in metres, y above the level's floor.`);
 const length = (description, opts = {}) => measurement('length', 'm', { description, ...opts });
 export const authorSceneOpening = z.object({
-    kind: z.enum(['door', 'window']),
-    along: length("From the wall's start to the opening's centre, along the centerline."),
+    sidelightLeft: doorDetailFields.sidelightLeft,
+    sidelightRight: doorDetailFields.sidelightRight,
+    transomHeight: doorDetailFields.transomHeight,
+    slidingStyle: doorDetailFields.slidingStyle,
+    slideDirection: doorDetailFields.slideDirection,
+    ...windowDetailFields,
+    kind: z
+        .enum(['door', 'window', 'passage'])
+        .describe('door, window, or passage: a doorway with no leaf (a cased opening, an archway between rooms), which takes no type, style, leaves, hinge, swing or code.'),
+    along: length("From the wall's start to the opening's centre, along the centerline (along the arc on a curved wall)."),
     width: length('Opening width.', { positive: true }),
     height: length('Opening height.', { positive: true }),
-    sill: length('Bottom of the opening above the floor; 0 for a door or floor-to-ceiling glazing (default 0).', { default: 0 }),
+    sill: length("Bottom of the opening above the floor the wall stands on; 0 for a door or floor-to-ceiling glazing (default 0). Negative reaches below that floor, down to the wall's bottom where the wall goes down beside a sunken floor: a garage door filling its doorway to a garage floor below the level's.", { default: 0 }),
     name: z.string().max(80).optional(),
+    shape: z
+        .enum(['rectangle', 'rounded', 'arch'])
+        .optional()
+        .describe('Its outline: rectangle (default), rounded top corners, or arch (a round top), for a door, a window or a passage.'),
+    archHeight: length("An arch's rise above its straight sides, within height (default 0.45 m for a door or passage, 0.35 m for a window).", { positive: true }).optional(),
     type: z
         .enum([...DoorType.options, ...WindowType.options.filter((t) => t !== 'sliding')])
         .optional()
-        .describe('How it opens. A door: hinged (default), double (two leaves), french (two glazed leaves), folding, pocket, barn, sliding, garage-sectional, garage-rollup, garage-tiltup. A window: fixed (default; cannot open), sliding, casement, awning, hopper, single-hung, double-hung, bay, bow, louvered. Give it: a window with no type is written fixed.'),
+        .describe('How it opens. A door: hinged (default), double (two leaves), french (two glazed leaves), folding, pocket, barn, sliding, garage-sectional, garage-rollup, garage-tiltup. A window: fixed (default; cannot open), sliding, casement, awning, hopper, tilt-turn (inward tilt or turn), single-hung, double-hung, bay, bow, louvered. Give it: a window with no type is written fixed.'),
     style: z
         .enum([...DOOR_STYLES, ...WINDOW_STYLES])
         .optional()
         .describe("Its look, by name. A door's leaf: panel (default), glass, modern, paneled-glass, french, shaker, six-panel, craftsman, half-louvered, barn. A fixed window's panes: single (default), double-hung, triple-hung, casement, sliding, grid, tall-grid, wide-grid, horizontal-bands, transom, picture; an operable window draws its own sashes, so a style on one is dropped and reported."),
-    leaves: z
-        .number()
-        .int()
-        .min(1)
-        .max(4)
-        .optional()
-        .describe("A door's leaves, 1 to 4 (default: what its type has; 2 for double, french and sliding)."),
+    leaves: doorDetailFields.leafCount.describe("A door's leaves: sliding 2–4; folding 2, 4, 6 or 8 (default: what its type has; 2 for double, french and sliding)."),
     code: z
         .string()
         .min(1)
@@ -49,6 +64,7 @@ export const authorSceneOpening = z.object({
         .string()
         .optional()
         .describe('Exact #rrggbb for the frame (default: color, or the opening’s own finish when color is absent).'),
+    handleStyle: DoorHandleStyle.optional().describe('Door handle: lever (default), lever-curved, knob, bar, or plate.'),
     hinge: z
         .enum(['start', 'end'])
         .optional()
@@ -58,7 +74,7 @@ export const authorSceneOpening = z.object({
         .optional()
         .describe("The side the door opens towards: the wall's front or back face."),
 });
-const WALL_FACE_MODULE = "a three.js module that builds this face's finish (tiles with joints, panelling, boards) for exactly the face: it receives params.outline, params.holes (its doors and windows), params.base and params.thickness in wall-local metres (x along the wall from its start, y up from the face's base, z out of the face) and lays the finish out: Pascal cuts the build to the outline and its openings, so tiles and boards may run past the edges and over the doors and windows (the holes are there for a layout that wants them, tiles centred on a window); Pascal rebuilds it when the wall or its openings change";
+const WALL_FACE_MODULE = "a three.js module that builds this face's finish (tiles with joints, panelling, boards) for exactly the face: it receives, in wall-local metres (x along the wall from its start, y up from the face's base, z out of the face), params.outline ({ x0, y0, x1, y1 }: the face), params.holes (its doors and windows, each { x0, y0, x1, y1 }), params.base (the floor along the face, [[x, y], …]) and params.thickness, and lays the finish out: Pascal cuts the build to the outline and its openings, so tiles and boards may run past the edges and over the doors and windows (the holes are there for a layout that wants them, tiles centred on a window); Pascal rebuilds it when the wall or its openings change";
 const faceToHeight = (whose) => length(`Where ${whose} stops, metres up from the face's base (default: the full face).`, {
     positive: true,
 }).optional();
@@ -74,20 +90,42 @@ export const authorSceneWall = z.object({
         .describe('Your own id, unique across every wall and item on all levels.'),
     start: plan('start'),
     end: plan('end'),
-    height: length('Wall height.', { positive: true }),
+    height: length("Wall height, from its floor to its top: the room's height, as built. Under another level, the climb from the tallest wall within 0.5 m of that level's floor up to it is that floor's structure, which Pascal draws (2.7 m walls under a floor at 2.9 m: a 0.2 m floor); a wall reaching into that floor stops under it.", { positive: true }),
     thickness: length('Wall thickness.', { positive: true }),
+    through: plan("the point the wall's arc passes through at its middle, bending it from start through it to end (a bay, an apse, a rounded corner, a drum: put it outside the building for one that bulges out): how far it stands from the straight line sets the bend, at most half the start-to-end distance (a half circle). Default: straight. Rooms derive from the arc and openings sit along it; a curved wall takes no faceLeft / faceRight or wallCode, and nothing hangs on it (host).").optional(),
+    curtain: z
+        .object({
+        spacing: length('The mullions at most this far apart (default 1.5 m).', {
+            default: 1.5,
+            positive: true,
+        }),
+        frameColor: z
+            .string()
+            .optional()
+            .describe("The mullions' and frame's colour, #rrggbb or library:<id> (default: Pascal's dark grey)."),
+    })
+        .optional()
+        .describe("A curtain wall: glass from the floor to the wall's top between mullions, straight or curved (a glass front, a winter garden). Doors may sit in it; its faces take no paint, skirting or face finish."),
     color: z
         .string()
         .optional()
         .describe('Paint for both faces: #rrggbb, written as an exact material, or a library ref (library:<id>) from search_materials.'),
+    colorInside: z
+        .string()
+        .optional()
+        .describe('Paint for the face or faces that look into a room of this level, same forms as color: both faces of a partition, the room side of an outside wall. Pascal finds them once the rooms are derived and the report says which face it was; over color.'),
+    colorOutside: z
+        .string()
+        .optional()
+        .describe("Paint for a face no room of this level looks into (an outside wall's cladding or render), same forms as color; over color. Say an outside wall's two finishes this way, not by left and right. The floor between this level and the one above wears the colour most of this level's walls give here, so the facade reads as one."),
     colorLeft: z
         .string()
         .optional()
-        .describe("Paint for the face on the left when looking from start to end, same forms as color; over color. The left is the wall's front."),
+        .describe("Paint for the face on the left when looking from start to end, same forms as color; over colorInside, colorOutside and color. The left is the wall's front."),
     colorRight: z
         .string()
         .optional()
-        .describe('Paint for the face on the right when looking from start to end, same forms as color; over color.'),
+        .describe('Paint for the face on the right when looking from start to end, same forms as color; over colorInside, colorOutside and color.'),
     openings: z.array(authorSceneOpening).optional(),
     skirting: z
         .object({
@@ -112,6 +150,9 @@ export const authorSceneWall = z.object({
     faceRight: authorSceneWallFace
         .optional()
         .describe(`The face on the right looking from start to end (colorRight's face), built by ${WALL_FACE_MODULE}; colorRight stays the paint under it. Over the room's wallCode. The report warns when the build leaves part of the face uncovered.`),
+    faceOutside: authorSceneWallFace
+        .optional()
+        .describe(`The finish of the face no room of this level looks into (an outside wall's cladding, brick, render with bands, battens), built by ${WALL_FACE_MODULE}; colorOutside stays the paint under it. Which face is outside is Pascal's to find, as for colorOutside: both faces of a wall no room stands on. The report warns when the build leaves part of the face uncovered.`),
 });
 export const authorSceneRoom = z.object({
     name: z
@@ -133,7 +174,7 @@ export const authorSceneRoom = z.object({
         .min(1)
         .max(48_000)
         .optional()
-        .describe("A three.js module that builds the floor finish for the room's polygon: it receives params.polygon, params.holes and params.elevation (level coordinates, metres) and lays out the planks, tiles or boards: Pascal cuts the build to the polygon and its holes, so a row may run past the edges (the holes are there for a layout that wants them). Pascal rebuilds it when the room changes; floor stays the fallback finish. The report warns when the build leaves part of the floor uncovered."),
+        .describe("A three.js module that builds the floor finish for the room's polygon: it receives params.polygon ([[x, z], …]) and params.holes ([[[x, z], …], …]), plan x/z in level coordinates, metres, and lays out the planks, tiles or boards. y = 0 is the floor's surface: lay the finish from there up, and Pascal stands the build on the room's floor plate and what stands on the floor (a rug, a sofa) on the build's top. Pascal cuts the build to the polygon and its holes, so a row may run past the edges (the holes are there for a layout that wants them). Pascal rebuilds it when the room changes; floor stays the fallback finish. The report warns when the build leaves part of the floor uncovered."),
     wallCode: z
         .string()
         .min(1)
@@ -141,6 +182,12 @@ export const authorSceneRoom = z.object({
         .optional()
         .describe(`The finish of every wall face that looks into this room (the faces its floor meets, where the skirting runs), each built by ${WALL_FACE_MODULE}. A wall's own faceLeft / faceRight wins over it. The report warns when the build leaves part of a face uncovered.`),
     wallToHeight: faceToHeight("the room's wallCode"),
+    unit: z
+        .string()
+        .min(1)
+        .max(120)
+        .optional()
+        .describe('The unit this room belongs to, by name (Apartment 2B, Suite 301): a dwelling, hotel room or commercial lot of a building with several; rooms with no unit are common area (corridor, lobby, stairs). Leave it out in a single-family house.'),
 });
 export const authorSceneSlab = z.object({
     name: z.string().max(80).optional(),
@@ -150,22 +197,46 @@ export const authorSceneSlab = z.object({
         default: 0,
     }),
     finish: z.string().optional().describe('library:<id> or #rrggbb (an exact colour).'),
+    surfaceCode: z
+        .string()
+        .min(1)
+        .max(48_000)
+        .optional()
+        .describe("A three.js module that builds the slab's surface finish (a terrace's decking or paving, a platform's boards): it receives params.polygon ([[x, z], …]) and params.holes ([[[x, z], …], …]), the slab's outline in level plan x/z, metres, and lays the boards or slabs out from y = 0, the slab's top. Pascal cuts the build to the polygon and its holes, so a row may run past the edges, and stands what is placed on the slab on the build's top. Pascal rebuilds it when the slab changes; finish stays the fallback and the sides keep theirs. The report warns when the build leaves part of the slab uncovered."),
     railing: z
         .array(z.object({
         start: plan('start'),
         end: plan('end'),
         height: length('Railing height (default 1.1 m).', { default: 1.1, positive: true }),
+        color: z.string().optional().describe('#rrggbb or library:<id> (default white).'),
     }))
         .optional()
-        .describe('Railing runs on this slab (a balcony).'),
+        .describe('Railing runs standing on this slab (a balcony).'),
 });
 export const authorSceneColumn = z.object({
     name: z.string().max(80).optional(),
     position: plan('centre'),
+    rotation: measurement('angle', 'deg', {
+        default: 0,
+        description: 'Turn about the vertical axis (default 0): at 0 its width runs along x.',
+    }),
+    shape: z
+        .enum(['square', 'round'])
+        .default('square')
+        .describe('square (default), or round: width is its diameter and depth is not read.'),
     width: length('Column width.', { positive: true }),
-    depth: length('Column depth.', { positive: true }),
+    depth: length('Column depth (default: its width).', { positive: true }).optional(),
     height: length('Column height.', { positive: true }),
-    color: z.string().optional(),
+    color: z
+        .string()
+        .optional()
+        .describe("Its finish, #rrggbb written as an exact material, or library:<id> (default: Pascal's plaster). A column built by code keeps its module's colours."),
+    code: z
+        .string()
+        .min(1)
+        .max(48_000)
+        .optional()
+        .describe("A three.js module for a column shape and width cannot express (a timber post with brackets, a fluted or tapered pier, a steel section): the add_column code contract, mount 'floor', built standing from y = 0 with its bottom centre on position; what it builds sets its width, depth and height, so shape, width, depth and height are not read. Compiled and stored as an item's module is."),
 });
 export const authorSceneItem = z.object({
     id: z.string().min(1).max(64).describe('Your own id, for the report and for hosting.'),
@@ -179,8 +250,15 @@ export const authorSceneItem = z.object({
         .string()
         .min(1)
         .max(48_000)
-        .describe("The piece's own three.js module (see the description)."),
-    position: xyz('bottom centre'),
+        .optional()
+        .describe("The piece's own three.js module (see the description); or piece."),
+    piece: z
+        .string()
+        .min(1)
+        .max(64)
+        .optional()
+        .describe('Instead of code: the id of a piece add_object makes from words (its piece.id). Placed with its module once made; one still being made is placed when it lands.'),
+    position: xyz("bottom centre (a ceiling item's top centre, y not read)"),
     rotation: measurement('angle', 'deg', {
         default: 0,
         description: 'Turn about the vertical axis (default 0).',
@@ -190,6 +268,44 @@ export const authorSceneItem = z.object({
         .optional()
         .describe('The id of the item this one rests on or hangs from (a lamp on a nightstand), or of the wall it is fixed to (a baseboard, a casing, a mirror, art), so moving the host moves it. On a wall, position is still the world bottom centre: the item faces the room on the nearest face, keeping its outward distance from that face; a point inside the wall moves to the face and is reported. Rotation is ignored.'),
 });
+export const authorSceneStair = z.object({
+    name: z.string().max(80).optional(),
+    start: plan("the middle of the bottom step's front edge, where the climb starts"),
+    rotation: measurement('angle', 'deg', {
+        default: 0,
+        description: 'Which way the first flight climbs: 0 toward +z, 90 toward +x, 180 toward −z, 270 toward −x (default 0).',
+    }),
+    width: length('Width across the climb (default 1.0 m).', { default: 1, positive: true }),
+    layout: z
+        .enum(['straight', 'l', 'u'])
+        .default('straight')
+        .describe('straight (default); l: a flight, a landing as deep as the stair is wide, a flight turned 90°; u: a flight, a landing across, a flight back beside the first.'),
+    turn: z
+        .enum(['left', 'right'])
+        .optional()
+        .describe("Which way an L or U turns, to the climber's left or right (default left)."),
+    length: length("The flights' run along the climb, landings aside (default: 0.28 m of going per riser, risers of at most 0.18 m).", { positive: true }).optional(),
+    steps: z
+        .number()
+        .int()
+        .min(2)
+        .optional()
+        .describe('Risers in all (default: from the storey, risers of at most 0.18 m).'),
+    lowerSteps: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("An L or U's risers up to its landing; the rest climb after it (default half)."),
+    railing: StairRailingMode.optional().describe('Which sides have a railing, looking up the flight (default both): none, left, right or both.'),
+    railingStyle: StairRailingStyle.optional().describe('How the railings are built (default balusters): post-and-rail, cable, boards, glass or metal.'),
+    color: z
+        .string()
+        .optional()
+        .describe("The flight's finish, treads and body, #rrggbb written as an exact material, or library:<id> (default: wood treads on a light grey body)."),
+    treads: z.string().optional().describe("The treads' finish, over color; same forms."),
+    railingColor: z.string().optional().describe("The railings' finish; same forms."),
+});
 export const authorSceneLight = z.object({
     position: xyz('the bulb'),
     color: z.string().default('#ffffff').describe('#rrggbb (default white).'),
@@ -202,21 +318,123 @@ export const authorSceneLight = z.object({
         .string()
         .optional()
         .describe('The id of the item holding this light (a pendant, a lamp). Default: without a fixture, a minimal ceiling point is created on the ceiling of the room containing the light’s plan position; outside any room, it attaches to the nearest item on this level and reports the fallback.'),
+    direction: z
+        .array(z.number())
+        .length(3)
+        .refine((v) => Math.hypot(...v) > 1e-6, 'A direction cannot be [0, 0, 0].')
+        .optional()
+        .describe('Makes it a spotlight pointing this way, [x, y, z] (any length): [0, -1, 0] straight down (a recessed downlight), [0, 1, 0] up a wall (a sconce washing upwards).'),
+    target: xyz('a point a spotlight aims at, instead of direction').optional(),
+    angle: measurement('angle', 'deg', {
+        min: 1,
+        max: 179,
+        description: "A spotlight's full cone (default 60): about 30 for a narrow accent, 60 for a downlight, 100 for a wide wash. Giving it makes the light a spot pointing down unless direction or target says otherwise.",
+    }).optional(),
+    softness: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("How feathered a spotlight's edge is: 0 hard, 1 fully soft (default 0.4)."),
+    shadows: z
+        .boolean()
+        .optional()
+        .describe('Casts shadows (default false). Only the couple of shadow-casting lights nearest the view get shadows at once, so keep it for the lights that shape a room.'),
+    glow: z
+        .object({
+        size: length('Across, about 0.15 for a sconce to 0.4 for a lantern.', { positive: true }),
+        strength: z.number().nonnegative().max(10).default(1).describe('Brightness (default 1).'),
+    })
+        .optional()
+        .describe("A soft halo drawn around the lamp itself in the light's colour, strongest at dusk and night."),
 });
-export const authorSceneLevel = z.object({
-    name: z.string().min(1).max(80),
-    elevation: length("The level's floor height above the ground floor's (default 0).", {
+export const authorSceneVoid = z.object({
+    name: z.string().max(80).optional(),
+    polygon: z
+        .array(plan('vertex'))
+        .min(3)
+        .describe("The opening in this level's floor, so the room below rises through it (a double-height living room under a gallery, a stairwell, an atrium). Pascal cuts the floor and the ceiling under it, and stops the cut at the faces of this level's walls."),
+    railing: z
+        .object({
+        height: length('Railing height (default 1.1 m).', { default: 1.1, positive: true }),
+        color: z.string().optional().describe('#rrggbb or library:<id> (default white).'),
+    })
+        .nullable()
+        .optional()
+        .describe("A railing along the void's open edges, broken where a wall of this level stands or a stair arrives (default: a 1.1 m railing; null for none, a void you cannot walk up to)."),
+});
+export const authorSceneRoofSegment = z.object({
+    center: plan('its centre, between the walls it covers'),
+    rotation: measurement('angle', 'deg', {
         default: 0,
+        description: 'Turn about the vertical axis, as an item turns: at 0 its width runs along x.',
+    }),
+    width: length("Along its ridge, between the centerlines of the walls under it (a gable's rakes are its ends).", { positive: true }),
+    depth: length("Across its ridge, between the centerlines of the walls under it (its eaves' sides).", {
+        positive: true,
     }),
+    roofType: RoofType.default('gable').describe('gable (default), hip, shed (one slope, its low eave toward its local +z), flat, or any of the roof shapes create_roof takes.'),
+    pitch: roofPitch('deg', {
+        min: 0,
+        max: 85,
+        description: 'Slope of its planes (default 40°).',
+    }).optional(),
+    overhang: length("How far its eaves reach past the walls' faces, in plan (default 0.3 m).", {
+        default: 0.3,
+    }),
+    gableOverhang: length("How far a gable's or shed's rakes reach past its end walls, in plan.").optional(),
+});
+export const authorSceneRoof = z.object({
+    name: z.string().max(80).optional(),
+    segments: z
+        .array(authorSceneRoofSegment)
+        .default([])
+        .describe("Pascal's own roof over the top level, one segment per rectangle: it stands on the walls' tops and draws its own gable ends, eaves and fascia (default [])."),
+    color: z.string().optional().describe("#rrggbb of the segments' covering."),
+    wallColor: z
+        .string()
+        .optional()
+        .describe('#rrggbb of the walls the segments raise: their gable ends.'),
+    items: z
+        .array(authorSceneItem)
+        .optional()
+        .describe("Roof geometry the segments cannot draw (a roof of another shape, a chimney, a dormer), as items on the roof level. position's y is measured from the top level's floor, as that level's items are."),
+});
+export const authorSceneLevel = z.object({
+    name: z.string().min(1).max(80),
+    elevation: length("The level's floor height above the ground floor's (default 0), its walking surface. It sets the storey below: a storey is as tall as the climb to the next level's floor (its stairs follow), the top one as its tallest wall; the walls under keep their height and this level's floor fills the climb above them.", { default: 0 }),
     walls: z.array(authorSceneWall).optional(),
     rooms: z.array(authorSceneRoom).default([]).describe('Room seeds and finishes (default []).'),
     slabs: z.array(authorSceneSlab).optional(),
+    voids: z
+        .array(authorSceneVoid)
+        .optional()
+        .describe('Openings in this level’s floor onto the level below; never on the first level.'),
     columns: z.array(authorSceneColumn).optional(),
+    stairs: z
+        .array(authorSceneStair)
+        .optional()
+        .describe("Stairs rising from this level to the next one in levels, as Pascal's stair tool builds them: the risers follow the storey height and each stair opens the floor above over its flights. Never a stair as an item."),
     items: z.array(authorSceneItem).optional(),
-    lights: z.array(authorSceneLight).default([]),
+    lights: z
+        .array(authorSceneLight)
+        .default([])
+        .describe("This level's lights (default []): each in its fixture, or on a ceiling point Pascal adds."),
+});
+export const authorSceneUnit = z.object({
+    name: z.string().min(1).max(120).describe('The name the rooms give as their unit.'),
+    kind: unitKind.default('apartment'),
+    color: z.string().optional().describe('#rrggbb tint of the unit in the plan.'),
 });
 export const authorScenePayload = z.object({
     levels: z.array(authorSceneLevel).min(1),
+    units: z
+        .array(authorSceneUnit)
+        .default([])
+        .describe("The units the rooms name, to give them a kind or a colour (default []): a unit named only by rooms is an apartment. A unit's rooms may be on several levels (a duplex). Pascal makes one unit per distinct name, under the building, holding the rooms that name it."),
+    roof: authorSceneRoof
+        .optional()
+        .describe("The roof over the top level, on the building's roof level above it, so exploded and solo level views lift it off the plan."),
     notes: z
         .array(z.string().max(1200))
         .default([])
@@ -226,18 +444,41 @@ export const authorSceneTool = {
     name: 'author_scene',
     title: 'Author scene',
     description: DESCRIPTION,
+    surfaceNotes: {
+        mcp: 'A payload by reference is a project file you upload: upload_project_file with phase prepare and its size answers a signedUrl; PUT the bytes there; then phase complete with the returned fileId and storageKey; that fileId is the payloadFile. A server that keeps no project files refuses payloadFile (files_unavailable); one that cannot run an adapter refuses the module and adapter (adapter_unavailable).',
+        chat: "There is no HTTP client here: the signed upload (phase prepare, PUT, complete) is not a route of yours. A payload too large to write in one answer goes as your module and its adapter, which Pascal runs. A JSON payload that fits in one answer and in 2 MiB can be saved with upload_project_file, phase text, the JSON as its content; the saved file's id in the receipt (file.id) is the payloadFile.",
+    },
     input: {
-        payload: authorScenePayload,
+        payload: authorScenePayload
+            .optional()
+            .describe('The conversion payload. Leave it out to have Pascal run the adapter on the module, or, with neither, to write the stored conversion again.'),
+        payloadFile: z
+            .string()
+            .min(1)
+            .max(128)
+            .optional()
+            .describe('The payload by reference: the fileId of a JSON project file holding it, from upload_project_file. Instead of payload, for one too large to send in a call.'),
         module: z
             .string()
             .max(400_000)
             .optional()
-            .describe('The three.js module the payload was read from. Stored with the scene as its source.'),
+            .describe('The three.js module the payload is read from. Stored with the scene as its source; left out, the stored one is used.'),
         adapter: z
             .string()
             .max(400_000)
             .optional()
-            .describe('The program that produced the payload from the module. Stored with the scene, so a regenerated design starts from it.'),
+            .describe("The program that turns the module into the payload: `export default async function adapt({ THREE, addons, source, run, toModule })` returning the payload. Pascal runs it where three.js modules run (no network, files or DOM); source is the module's text, run(code = source) builds a module (its default or named build({ THREE, scene, addons })) and answers { scene }, its world matrices updated; toModule(object, { origin, rotation, mount, animations }) writes an object of the built scene as an item's or an opening's module, answering { code, position, size, triangles }. Stored with the scene; left out, the stored one is used."),
+        edits: z
+            .array(z
+            .object({
+            in: z.enum(['module', 'adapter']),
+            find: z.string().min(1).describe('Text that occurs exactly once in it.'),
+            replace: z.string().describe('What replaces it.'),
+        })
+            .strict())
+            .max(200)
+            .optional()
+            .describe('Changes to the module or the adapter as given, or as stored when left out, applied in order; the changed texts are run and stored.'),
         replace: z
             .boolean()
             .default(false)

package/dist/agent-tools/batch.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 /** The shared tools a batch runs; a test keeps this in step with the operations registry. */
-export declare const BATCHABLE_TOOLS: readonly ['paint', 'search_materials', 'list_levels', 'get_node', 'get_level_summary', 'get_walls', 'get_zones', 'duplicate_level', 'verify_scene', 'delete_node', 'measure_stair', 'fit_stair', 'find_by_type', 'create_roof', 'add_wall', 'add_fence', 'add_level', 'create_stair', 'add_corner_window', 'merge_windows', 'add_column', 'add_object', 'place_design', 'place_in_room'];
+export declare const BATCHABLE_TOOLS: readonly ['paint', 'search_materials', 'list_levels', 'get_node', 'get_level_summary', 'get_walls', 'get_zones', 'duplicate_level', 'verify_scene', 'delete_node', 'move_node', 'duplicate_node', 'measure_stair', 'fit_stair', 'find_by_type', 'create_roof', 'add_wall', 'set_wall_type', 'add_fence', 'add_level', 'create_unit', 'create_stair', 'add_corner_window', 'merge_windows', 'add_column', 'add_object', 'place_design', 'place_in_room'];
 /**
  * Batched tools whose calls do not depend on each other: one that fails is reported with its own
  * error and the others are applied, whatever onRefusal says. An authored object is made whole or

package/dist/agent-tools/batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/agent-tools/batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,6FAA6F;AAC7F,eAAO,MAAM,eAAe,YAC1B,OAAO,EACP,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,eAAe,EACf,WAAW,EACX,cAAc,EACd,aAAa,EACb,UAAU,EACV,WAAW,EACX,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,YAAY,EAEZ,YAAY,EACZ,cAAc,EACd,eAAe,CAMP,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EAAmB,CAAA;AAExE,eAAO,MAAM,YAAY;IACvB,IAAI;IACJ,KAAK;IACL,WAAW;IACX,KAAK;QACH,KAAK;;;;QAYL,SAAS;;;;;CAKZ,CAAA"}
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/agent-tools/batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,6FAA6F;AAC7F,eAAO,MAAM,eAAe,YAC1B,OAAO,EACP,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,cAAc,EACd,aAAa,EACb,UAAU,EACV,eAAe,EACf,WAAW,EACX,WAAW,EACX,aAAa,EACb,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,YAAY,EAEZ,YAAY,EACZ,cAAc,EACd,eAAe,CAMP,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EAAmB,CAAA;AAExE,eAAO,MAAM,YAAY;IACvB,IAAI;IACJ,KAAK;IACL,WAAW;IACX,KAAK;QACH,KAAK;;;;QAYL,SAAS;;;;;CAKZ,CAAA"}

package/dist/agent-tools/batch.js

@@ -11,13 +11,17 @@ export const BATCHABLE_TOOLS = [
     'duplicate_level',
     'verify_scene',
     'delete_node',
+    'move_node',
+    'duplicate_node',
     'measure_stair',
     'fit_stair',
     'find_by_type',
     'create_roof',
     'add_wall',
+    'set_wall_type',
     'add_fence',
     'add_level',
+    'create_unit',
     'create_stair',
     'add_corner_window',
     'merge_windows',
@@ -41,7 +45,7 @@ export const INDEPENDENT_BATCH_TOOLS = ['add_object'];
 export const runBatchTool = {
     name: 'run_batch',
     title: 'Run a batch of scene tools',
-    description: `Optionally run several scene tools in one call: in order, each on the scene the calls before it left, applied as one undo step, with a report per call. Supports repeated or known-in-advance work; individual calls remain available. A call cannot use an id another call of the same batch creates; created ids are available in the report for subsequent calls. onRefusal stop (default): a refused call stops the batch and nothing is applied; skip: the others are applied and each refusal is reported; add_object calls are independent of each other under both: one that fails is reported with its own error and the others are applied, each with the receipt a single add_object gives. Tools: ${BATCHABLE_TOOLS.join(', ')}.`,
+    description: `Optionally run several scene tools in one call: in order, each on the scene the calls before it left, applied as one undo step, with a report per call. Supports repeated or known-in-advance work; individual calls remain available. A call cannot use an id another call of the same batch creates; created ids are available in the report for subsequent calls. onRefusal stop (default): a refused call stops the batch and nothing is applied; skip: the others are applied and each refusal is reported. This policy includes unsupported tools, invalid inputs and design-brief refusals, as well as runtime refusals. add_object calls are independent of each other under both: one that fails is reported with its own error and the others are applied, each with the receipt a single add_object gives. Tools: ${BATCHABLE_TOOLS.join(', ')}.`,
     input: {
         calls: z
             .array(z.object({

package/dist/agent-tools/checkpoints.js

@@ -5,7 +5,7 @@ import { z } from 'zod';
 export const setCheckpointTool = {
     name: 'set_checkpoint',
     title: 'Set a checkpoint',
-    description: 'A named moment in your work (a roof, a floor, a batch of walls) that verify_scene({ since: name }) can compare against: it lists what was created, changed and deleted since, grouped by level and kind with a view each, and what you made that is gone. "start", the beginning of your work, is always one; a name used again replaces the first; a session keeps at most 8. A checkpoint is kept with your session, not in the project: it changes nothing in the scene, enters no undo, and does not restore anything. Refused: too_many_checkpoints (naming them), scene_too_large, name_required.',
+    description: 'Name this moment of your work (a roof, a floor, a batch of walls) for verify_scene({ since: name }) to compare against, and return the checkpoints kept. verify_scene then lists what was created, changed and deleted since, grouped by level and kind with a view each, and what you made that is gone. "start", the beginning of your work, is always one; a name used again replaces the first; a session keeps at most 8. A checkpoint is kept with your session, not in the project: it changes nothing in the scene, enters no undo, and does not restore anything. Refused: too_many_checkpoints (naming them), scene_too_large, name_required.',
     input: {
         name: z
             .string()

package/dist/agent-tools/columns.d.ts

@@ -10,6 +10,20 @@ export declare const addColumnTool: {
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         x: z.ZodOptional<z.ZodNumber>;
         z: z.ZodOptional<z.ZodNumber>;
+        role: z.ZodOptional<z.ZodEnum<{
+            ornament: "ornament";
+            post: "post";
+        }>>;
+        postSize: z.ZodOptional<z.ZodEnum<{
+            "4x4": "4x4";
+            "6x6": "6x6";
+            "8x8": "8x8";
+        }>>;
+        postBase: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            pier: "pier";
+            "post-base": "post-base";
+        }>>;
         height: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         radius: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;

package/dist/agent-tools/columns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"columns.d.ts","sourceRoot":"","sources":["../../src/agent-tools/columns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DzB,CAAA"}
+{"version":3,"file":"columns.d.ts","sourceRoot":"","sources":["../../src/agent-tools/columns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFzB,CAAA"}

package/dist/agent-tools/columns.js

@@ -6,13 +6,25 @@ import { NodeId } from './node-id.js';
 export const addColumnTool = {
     name: 'add_column',
     title: 'Add column',
-    description: 'Add a structural or decorative column at (x, z), or rebuild one by nodeId. Supports native fields or optional code using the same module and conventions as add_object, with floor mount and its bottom centre at the support point. Params named height, width and depth drive the native size controls. Only add columns when requested.',
+    description: 'Add a structural or decorative column at (x, z), or rebuild one by nodeId. role post makes the Build panel framing post: plain square pressure-treated wood, default 6x6 with no base, reaching the lowest beam above its support or the ceiling plane unless height is given. postSize and postBase use the tile choices. Refused with not_a_post when post choices are given without role post (or an existing post). Supports native fields or optional code using the same module and conventions as add_object, with floor mount and its bottom centre at the support point. Params named height, width and depth drive the native size controls. Only add columns when requested.',
     input: {
         x: z.number().optional().describe('X position of the column center (meters)'),
         z: z.number().optional().describe('Z position of the column center (meters)'),
+        role: z
+            .enum(['ornament', 'post'])
+            .optional()
+            .describe('post: a framing post; ornament: a decorative column. Omitted keeps existing column behavior.'),
+        postSize: z
+            .enum(['4x4', '6x6', '8x8'])
+            .optional()
+            .describe('Nominal post size; actual square sides 0.0889, 0.1397, 0.18415 m. Default for a new post: 6x6. Overrides native width, depth and radius when supplied.'),
+        postBase: z
+            .enum(['none', 'post-base', 'pier'])
+            .optional()
+            .describe('Post base: none (default for a new post), a steel post base, or a concrete pier. Updates base geometry and finish together.'),
         height: measurement('length', 'm', {
             positive: true,
-            description: 'Column height (default: 2.5).',
+            description: 'Column height (default: 2.5 m; a new post reaches the beam above or ceiling plane).',
         }).optional(),
         radius: measurement('length', 'm', {
             positive: true,