@pascal-app/core 1.0.6 → 1.0.7

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-tools/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-tools/index.ts"],"names":[],"mappings":"AA0CA,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,mBAAmB,CAAA;AACjC,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAClC,cAAc,SAAS,CAAA;AACvB,cAAc,sBAAsB,CAAA;AACpC,cAAc,SAAS,CAAA;AACvB,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA;AACvB,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,QAAQ,CAAA;AACtB,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAC1E,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,SAAS,CAAA;AACvB,cAAc,gBAAgB,CAAA;AAE9B;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDgB,CAAA;AAEjD,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAChF,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACjD,cAAc,gBAAgB,CAAA;AAC9B,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAC/D,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA"}

package/dist/agent-tools/index.js

@@ -15,6 +15,7 @@ import { findByTypeTool } from './find-by-type.js';
 import { furnishRoomTool } from './furnish-room.js';
 import { addLevelTool, duplicateLevelTool, getLevelSummaryTool, getWallsTool, getZonesTool, listLevelsTool, setGroundLevelTool, } from './levels.js';
 import { mergeWindowsTool } from './merge-windows.js';
+import { duplicateNodeTool, moveNodeTool } from './move-duplicate.js';
 import { deleteNodeTool, getNodeTool } from './nodes.js';
 import { paintTool } from './paint.js';
 import { placeInRoomTool } from './place-in-room.js';
@@ -24,10 +25,11 @@ import { ROOM_TOOL_CONTRACTS } from './room-structure.js';
 import { searchMaterialsTool } from './search-materials.js';
 import { getSiteTool, placeBuildingTool } from './site.js';
 import { createStairTool, fitStairTool, measureStairTool } from './stairs.js';
+import { UNIT_TOOL_CONTRACTS } from './units.js';
 import { verifySceneTool } from './verify-scene.js';
 import { viewSceneTool } from './view-scene.js';
 import { addDoorTool, addWindowTool } from './wall-openings.js';
-import { addWallTool } from './walls.js';
+import { addWallTool, setWallTypeTool } from './walls.js';
 export * from './achieved.js';
 export * from './add-object.js';
 export * from './assets.js';
@@ -45,6 +47,7 @@ export * from './hosted-services.js';
 export * from './levels.js';
 export * from './measurement.js';
 export * from './merge-windows.js';
+export * from './move-duplicate.js';
 export { NodeId } from './node-id.js';
 export * from './nodes.js';
 export * from './notation-inventory.js';
@@ -59,6 +62,7 @@ export * from './search-materials.js';
 export * from './site.js';
 export { CATALOG_SOURCE, OTHER_SOURCES, OUTSIDE_SOURCES } from './sources.js';
 export * from './stairs.js';
+export * from './units.js';
 export * from './verify-scene.js';
 export * from './view-scene.js';
 export * from './wall-openings.js';
@@ -88,6 +92,7 @@ export const AGENT_TOOL_CONTRACTS = [
     placeDesignTool,
     validateDesignTool,
     addWallTool,
+    setWallTypeTool,
     addFenceTool,
     addCornerWindowTool,
     mergeWindowsTool,
@@ -98,6 +103,8 @@ export const AGENT_TOOL_CONTRACTS = [
     createRoofTool,
     moveRoofsToRoofLevelTool,
     deleteNodeTool,
+    moveNodeTool,
+    duplicateNodeTool,
     addObjectTool,
     authorSceneTool,
     getSourceTool,
@@ -115,6 +122,7 @@ export const AGENT_TOOL_CONTRACTS = [
     getSiteTool,
     placeBuildingTool,
     ...ROOM_TOOL_CONTRACTS,
+    ...UNIT_TOOL_CONTRACTS,
     runBatchTool,
 ];
 export { BATCHABLE_TOOLS, INDEPENDENT_BATCH_TOOLS, runBatchTool } from './batch.js';

package/dist/agent-tools/levels.js

@@ -22,19 +22,19 @@ export const getLevelSummaryTool = {
 export const getWallsTool = {
     name: 'get_walls',
     title: 'Get walls',
-    description: 'Get the walls of a level: start and end in metres, length, stored and resolved height, thickness, and their doors and windows. wallFaceChains gives base-chain provenance for geometric faces a (left of start → end) and b (right): ref (authored face slot), legacy (inline spec), or default (declared fallback ref). These are not final rendered finishes: room intent, face paint regions, exterior assembly cladding and reference availability can change appearance. A chosen white or default-matching ref is legitimate; fallback alone is not a defect or a requirement to paint.',
+    description: 'Get the walls of a level: start and end in metres, length, stored and resolved height, thickness, wallType (standard, railing or curtain; standard when absent), type ({ id, label } for a known assembly preset or project wall type, null otherwise), and their doors and windows. wallTypes lists available assembly type ids and labels for add_wall.type and set_wall_type. wallFaceChains gives base-chain provenance for geometric faces a (left of start → end) and b (right): ref (authored face slot), legacy (inline spec), or default (declared fallback ref). These are not final rendered finishes: room intent, face paint regions, exterior assembly cladding and reference availability can change appearance. A chosen white or default-matching ref is legitimate; fallback alone is not a defect or a requirement to paint.',
     input: levelTarget,
 };
 export const getZonesTool = {
     name: 'get_zones',
     title: 'Get zones',
-    description: 'Get the zones (rooms) of a level: name, colour, polygon and holes in metres, area in m² (holes taken out), bounding size, and floor_choices: the floor plates the room can take (key, plateId, name, current; drawn and mezzanine flags). A room shares its floor plate with the rooms next to it unless detached. Persisted authored wall intent is wallMaterial (string, or null when absent) and wallOverrides (records of wallId, geometric face a or b, and finish; [] when absent). This is not a final rendered finish or visual verification: local overrides and face paint can take precedence, and absent room intent is not a defect or a requirement to paint.',
+    description: 'Get the zones (rooms) of a level: name, colour, polygon and holes in metres, area in m² (holes taken out), bounding size, roomType (room when absent, porch, deck or patio), floor.drop (step-down in metres, 0 when absent; an explicit floor.elevation takes precedence), porchFraming (auto, postSize, postSpacing in metres, beamSize, postCount and beamCount of existing generated parts; null when no outdoor/framing intent), and decking (boardSize, gap in metres, direction; resolved defaults for decks or when settings exist). auto follows porchFraming.auto; absent, on for a covered porch, off for decks/patios. false leaves framing to hand edits. These names and units match set_zone_intent. Includes the unit it belongs to (unitId and unit, its name; null: common area), and floor_choices: available floor plates (key, plateId, name, current; drawn and mezzanine flags). A room shares its floor plate with adjacent rooms unless detached. Persisted wall intent is wallMaterial (string, null when absent) and wallOverrides (wallId, geometric face a or b, finish; [] when absent), not a final rendered finish: local overrides and face paint can take precedence; absent intent is not a defect or a requirement to paint.',
     input: levelTarget,
 };
 export const addLevelTool = {
     name: 'add_level',
     title: 'Add level',
-    description: "Add an empty level to a building, as the editor does: above its top storey, under the building's roof level, which moves up one so the roof stays on top; or below its lowest level for a basement, which goes one storey under the lowest level and every existing level keeps its place, the ground floor included. On a scene with no building (a new or cleared scene), it starts the scene as the editor does: a site, a building and its ground level. A level that ends up below grade says in its result how a new wall on it is built (wallConstruction): a wall against the ground is a foundation wall, " +
+    description: "Add an empty level to a building as the editor does, above its top storey or below its lowest for a basement, and return its id, floor index and height. Above, it goes under the building's roof level, which moves up one so the roof stays on top; a basement goes one storey under the lowest level, every existing level keeping its place, the ground floor included. On a scene with no building (a new or cleared scene), it starts the scene as the editor does: a site, a building and its ground level. A level that ends up below grade says in its result how a new wall on it is built (wallConstruction): a wall against the ground is a foundation wall, " +
         FOUNDATION_BY_REGION_NOTE +
         ', a partition is an ordinary wall. To copy a floor with its content, use duplicate_level.',
     input: {
@@ -80,7 +80,7 @@ export const duplicateLevelTool = {
 export const setGroundLevelTool = {
     name: 'set_ground_level',
     title: 'Set ground level',
-    description: "Make a level the building's ground floor: the one standing at grade, its floor 8 in over the ground (about 6 in on cast concrete foundations, 12 in on stone: the building's foundation construction seats it; the result names it). A building's levels stack on a ground line; the levels with a lower floor index are below grade (basements), the ones at or over it are not, and list_levels reads it as groundLevels (levelId, floorElevation, floorOverGrade, seated) and each level's gradeStanding (at-grade, partly-below-grade, below-grade) and isGroundLevel. This names the level on the building, seats the building so that level's floor datum, the top of the foundation where the wood framing starts, stands 0.203 m (8 in) over grade on a block foundation, 0.15 m on cast concrete (Europe), 0.3 m on stone (a historic style) (flat site: world Y 0.203; sculpted terrain: 0.203 m over the mean ground height under its floor), moving the building in height only — the plan stays where it is and every level keeps its place relative to the others — and renumbers the floor indices so it is 0 and the ones under it are -1, -2…. A level added below (add_level position below) stacks under the lowest level without moving the ground floor. A roof level or a support level cannot be the ground floor (not_a_storey). One undo step. Refusals: level_not_found, not_a_level, no_building, not_a_storey. Answering unchanged: true when the level is already the named ground floor, at that seat, at index 0.",
+    description: "Make a level the building's ground floor: the one standing at grade, its floor on the ground. A building's levels stack on a ground line; the levels with a lower floor index are below grade (basements), the ones at or over it are not, and list_levels reads it as groundLevels (levelId, floorElevation, floorOverGrade, seated) and each level's gradeStanding (at-grade, partly-below-grade, below-grade) and isGroundLevel. This names the level on the building, seats the building so that level's floor datum stands on grade (flat site: world Y 0; sculpted terrain: the mean ground height under its floor), moving the building in height only — the plan stays where it is and every level keeps its place relative to the others — and renumbers the floor indices so it is 0 and the ones under it are -1, -2…. A level added below (add_level position below) stacks under the lowest level without moving the ground floor. A roof level or a support level cannot be the ground floor (not_a_storey). One undo step. Refusals: level_not_found, not_a_level, no_building, not_a_storey. Answering unchanged: true when the level is already the named ground floor, on grade, at index 0.",
     input: {
         levelId: NodeId.describe('The level to stand at grade, by an id list_levels returned.'),
     },

package/dist/agent-tools/move-duplicate.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+export declare const moveNodeTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        id: z.ZodString;
+        to: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        by: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        y: z.ZodOptional<z.ZodNumber>;
+        rotation: z.ZodOptional<z.ZodNumber>;
+        force: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+export declare const moveNodeOutput: {
+    ok: z.ZodLiteral<true>;
+    id: z.ZodString;
+    type: z.ZodString;
+    host: z.ZodEnum<{
+        ceiling: "ceiling";
+        free: "free";
+        level: "level";
+        roof: "roof";
+        wall: "wall";
+    }>;
+    hostId: z.ZodNullable<z.ZodString>;
+    position: z.ZodArray<z.ZodNumber>;
+    clamped: z.ZodBoolean;
+    message: z.ZodString;
+    achieved: z.ZodObject<{
+        created: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        updated: z.ZodNumber;
+        deleted: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        unchanged: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>;
+};
+export declare const duplicateNodeTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        ids: z.ZodArray<z.ZodString>;
+        offset: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        targetLevelId: z.ZodOptional<z.ZodString>;
+    };
+};
+export declare const duplicateNodeOutput: {
+    ok: z.ZodLiteral<true>;
+    copies: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        copyId: z.ZodString;
+        type: z.ZodString;
+        descendantCount: z.ZodNumber;
+    }, z.core.$strip>>;
+    totalCreated: z.ZodNumber;
+    skippedIds: z.ZodArray<z.ZodString>;
+    message: z.ZodString;
+    achieved: z.ZodObject<{
+        created: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        updated: z.ZodNumber;
+        deleted: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        unchanged: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>;
+};
+//# sourceMappingURL=move-duplicate.d.ts.map

package/dist/agent-tools/move-duplicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-duplicate.d.ts","sourceRoot":"","sources":["../../src/agent-tools/move-duplicate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,eAAO,MAAM,YAAY;IACvB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,EAAE;QACF,EAAE;QAKF,EAAE;QAGF,CAAC;QAMD,QAAQ;QACR,KAAK;;CAKR,CAAA;AAED,eAAO,MAAM,cAAc;IACzB,EAAE;IACF,EAAE;IACF,IAAI;IACJ,IAAI;;;;;;;IACJ,MAAM;IACN,QAAQ;IACR,OAAO;IACP,OAAO;IACP,QAAQ;;;;;;CACT,CAAA;AAED,eAAO,MAAM,iBAAiB;IAC5B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,GAAG;QAKH,MAAM;QAGN,aAAa;;CAIhB,CAAA;AAED,eAAO,MAAM,mBAAmB;IAC9B,EAAE;IACF,MAAM;;;;;;IAQN,YAAY;IACZ,UAAU;IACV,OAAO;IACP,QAAQ;;;;;;CACT,CAAA"}

package/dist/agent-tools/move-duplicate.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { achievedOutput } from './achieved.js';
+import { NodeId } from './node-id.js';
+// Arrays avoid tuple-form JSON schemas that some MCP clients cannot call.
+const planPoint = z.array(z.number()).length(2);
+export const moveNodeTool = {
+    name: 'move_node',
+    title: 'Move node',
+    description: "Move one node as the editor's move tool does, re-seated on its wall, ceiling, roof segment or level, and return where it now sits and whether it clamped. A door, window or wall item slides along its wall (the plan point is projected onto the wall, clamped to stay on it, and refused with opening_overlap where it would hit a sibling, unless force, like holding Alt); a ceiling item moves in plan under its ceiling, keeping its drop; a floor or free node moves in plan on its level, keeping its height; a roof piece (skylight, chimney, vents, solar, dormer) moves in its segment-local plan, the frame its stored position uses, its height staying anchored to the segment surface; a wall takes by only (its ends translate, its openings ride in their wall-local seats). to and by are plan metres [x, z]: level plan for level, wall and ceiling hosts, segment-local for a roof host. Exactly one of to (absolute) or by (delta), or rotation alone. y is a window's sill height or a wall item's bottom height in metres, and nothing else takes it. rotation is yaw in degrees for free, ceiling and roof nodes. Returns the host class and id, the node's stored position after the move (a wall: its start point as [x, 0, z]), and whether the seat clamped. Refusals: node_not_found, node_not_movable (site, building, level, zone — use move_zone — roof, roof segment, stair, derived plates and other geometry-defined kinds), move_target_required, move_target_ambiguous (both to and by, or to on a wall), move_host_missing (its wall, ceiling or segment is gone), curved_wall, wall_too_short, wall_too_low, opening_overlap, rotation_not_supported (wall-hosted nodes face their wall side), height_not_applicable, move_not_supported (an item resting on another item).",
+    input: {
+        id: NodeId.describe('The node id.'),
+        to: planPoint
+            .optional()
+            .describe('Absolute plan target [x, z] in metres, in the frame the description names for its host.'),
+        by: planPoint
+            .optional()
+            .describe('Plan delta [dx, dz] in metres from where the node sits, same frame as to.'),
+        y: z
+            .number()
+            .optional()
+            .describe("A window's sill height or a wall item's bottom height above the floor, in metres."),
+        rotation: z.number().optional().describe('Yaw in degrees (free, ceiling and roof nodes).'),
+        force: z
+            .boolean()
+            .optional()
+            .describe('Allow a wall seat that overlaps a sibling, like holding Alt in the editor.'),
+    },
+};
+export const moveNodeOutput = {
+    ok: z.literal(true),
+    id: z.string(),
+    type: z.string(),
+    host: z.enum(['wall', 'ceiling', 'free', 'roof', 'level']),
+    hostId: z.string().nullable(),
+    position: z.array(z.number()).length(3),
+    clamped: z.boolean(),
+    message: z.string(),
+    achieved: achievedOutput,
+};
+export const duplicateNodeTool = {
+    name: 'duplicate_node',
+    title: 'Duplicate node',
+    description: "Duplicate nodes with everything under them, as the editor's Duplicate does, and return each copy's id beside its source's. The copies get fresh ids, hosted children are re-hosted on them (a wall brings its doors, windows and wall items, their wallId pointing at the copy), and an id inside another listed subtree is skipped rather than copied twice. A door, window, wall item, ceiling item or roof piece copied on its own stays on its same host. offset [dx, dz] in plan metres moves every copy from its source's seat (default [0, 0], an exact copy in place, as the editor's duplicate starts); a wall offset translates its ends, a hosted copy's offset slides it on its host, clamped to stay seated. targetLevelId puts level-parented copies on that level instead; a hosted copy refuses it (hosted_root_level) because its host stays behind. Returns copies (sourceId, copyId, type, descendantCount), totalCreated and skippedIds. Refusals: node_not_found, duplicate_not_supported (a site, building, level — use duplicate_level — zone — use duplicate_zone — roof or roof segment, or a derived plate), duplicate_root_invalid (a node the editor only copies as part of its parent), hosted_root_level, level_not_found.",
+    input: {
+        ids: z
+            .array(NodeId)
+            .min(1)
+            .max(64)
+            .describe('The node ids to copy, each with everything under it.'),
+        offset: planPoint
+            .optional()
+            .describe('Plan delta [dx, dz] in metres applied to every copy. Default [0, 0].'),
+        targetLevelId: NodeId.optional().describe('Copy level-parented roots onto this level instead of their own.'),
+    },
+};
+export const duplicateNodeOutput = {
+    ok: z.literal(true),
+    copies: z.array(z.object({
+        sourceId: z.string(),
+        copyId: z.string(),
+        type: z.string(),
+        descendantCount: z.number().int(),
+    })),
+    totalCreated: z.number().int(),
+    skippedIds: z.array(z.string()),
+    message: z.string(),
+    achieved: achievedOutput,
+};

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

@@ -7,6 +7,7 @@ export declare const paintTool: {
         targets: z.ZodArray<z.ZodString>;
         role: z.ZodOptional<z.ZodString>;
         color: z.ZodOptional<z.ZodString>;
+        exact: z.ZodOptional<z.ZodBoolean>;
         material: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
@@ -37,6 +38,11 @@ export declare const paintTool: {
                 url: z.ZodString;
                 repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
                 scale: z.ZodOptional<z.ZodNumber>;
+                offset: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                normalMap: z.ZodOptional<z.ZodString>;
+                normalScale: z.ZodOptional<z.ZodNumber>;
+                bumpMap: z.ZodOptional<z.ZodString>;
+                bumpScale: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>]>>;
         materialName: z.ZodOptional<z.ZodString>;

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

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/agent-tools/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,SAAS;IACpB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;QACP,IAAI;QACJ,KAAK;QAKL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAMR,YAAY;QASZ,KAAK;;CAER,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/agent-tools/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,SAAS;IACpB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;QACP,IAAI;QACJ,KAAK;QAOL,KAAK;QAML,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAMR,YAAY;QASZ,KAAK;;CAER,CAAA"}

package/dist/agent-tools/paint.js

@@ -4,7 +4,7 @@ import { NodeId } from './node-id.js';
 export const paintTool = {
     name: 'paint',
     title: 'Paint',
-    description: "Give walls, slabs, ceilings, roofs, columns, fences, doors, windows, stairs, blocks, cabinets, shelves, items and the other built parts a finish in one call, as the editor's Paint does. Give one finish: color (#rrggbb, painted with the nearest of the library's flat colours, said with how near); material, a library:<id> (find it with search_materials) or scene:<id> ref, or a native material {properties: {color, roughness, metalness}} for an exact finish, kept as a scene material (materialName names a new one) and reused when the scene holds an equal one; or erase: true, back to the surface's default. role picks the surface: a wall's face a or b, or exterior and interior (the faces turned out of its rooms or into them, else by its stored sides; a partition is interior on both; a wall whose sides are unknown, or with rooms along only part of a face, is refused: name its face, a or b), its trims aSkirting, bSkirting, aCrown, bCrown, aChairRail, bChairRail (skirting, crown or chairRail: that trim on both faces), a curtain wall's curtain-frame, curtain-glass, curtain-solid; a slab's surface, side, edge, riser, underside or foundation; a ceiling's surface; a roof's top (the covering), edge (the gable ends and the trim band), wall (the soffit and the deck edge, and the fascia and rake boards unless they have their own) or fascia (the fascia and rake boards, a fascia band); a glazed roof's glazing-frame, glazing-glass or glazing-solid; a column's shaft, base, capital or frame; a fence's posts, infill, base or rail; a door's panel, frame, glass or hardware; a window's frame or glass; a stair's treads, body or railing; a block's body; a cabinet's front, carcass, countertop, plinth, hardware or glass; another part's own slots, which a refusal names; an item's surfaces by the names its model gives them (its painted ones are in get_node's slots), which paint cannot check. Without a role: both faces of a wall, a slab's or a ceiling's surface, a roof's top, a glazed roof's frame and solid panels, a column's shaft, a whole fence, a door's panel and frame, a window's frame, a block's body, a part's one surface. A roof shows one finish per surface: a segment's finish goes on its roof, and a roof's on all of its segments. A glazed segment holds its own glazing finishes: a roof's glazing roles go on its glazed segments, its other roles on the roof, and without a role both. A wall face is painted whole, over the wall finish of the room it faces; its painted parts keep their own, named in the note. A ceiling shows its finish's colour, not its texture. The result says the finish written, and the scene material when there is one. A target that is not in the scene, a role it lacks or an unknown material refuses the whole call: nothing is painted.",
+    description: "Give walls, slabs, ceilings, roofs, columns, fences, doors, windows, stairs, blocks, cabinets, shelves, items and the other built parts a finish in one call, as the editor's Paint does. Give one finish: color (#rrggbb, painted with the nearest of the library's flat colours, said with how near; with exact: true, that colour itself, a matte scene material); material, a library:<id> (find it with search_materials) or scene:<id> ref, or a native material {properties: {color, roughness, metalness}} for an exact finish, kept as a scene material (materialName names a new one) and reused when the scene holds an equal one; or erase: true, back to the surface's default. role picks the surface: a wall's face a or b, or exterior and interior (the faces turned out of its rooms or into them, else by its stored sides; a partition is interior on both; a wall whose sides are unknown, or with rooms along only part of a face, is refused: name its face, a or b), its trims aSkirting, bSkirting, aCrown, bCrown, aChairRail, bChairRail (skirting, crown or chairRail: that trim on both faces), a curtain wall's curtain-frame, curtain-glass, curtain-solid; a slab's surface, side, edge, riser, underside or foundation; a ceiling's surface; a roof's top (the covering), edge (the gable ends and the trim band), wall (the soffit and the deck edge, and the fascia and rake boards unless they have their own) or fascia (the fascia and rake boards, a fascia band); a glazed roof's glazing-frame, glazing-glass or glazing-solid; a column's shaft, base, capital or frame; a fence's posts, infill, base or rail; a door's panel, frame, glass or hardware; a window's frame, glass, hardware or shutters; a stair's treads, body or railing; a block's body; a cabinet's front, carcass, countertop, plinth, hardware or glass; another part's own slots, which a refusal names; an item's surfaces by the names its model gives them (its painted ones are in get_node's slots), which paint cannot check. Without a role: both faces of a wall, a slab's or a ceiling's surface, a roof's top, a glazed roof's frame and solid panels, a column's shaft, a whole fence, a door's panel and frame, a window's frame, a block's body, a part's one surface. A roof shows one finish per surface: a segment's finish goes on its roof, and a roof's on all of its segments. A glazed segment holds its own glazing finishes: a roof's glazing roles go on its glazed segments, its other roles on the roof, and without a role both. A wall face is painted whole, over the wall finish of the room it faces; its painted parts keep their own, named in the note. A ceiling shows its finish's colour, not its texture. The result says the finish written, and the scene material when there is one. A target that is not in the scene, a role it lacks or an unknown material refuses the whole call: nothing is painted.",
     input: {
         targets: z.array(NodeId).min(1).max(200).describe('The nodes to paint.'),
         role: z.string().min(1).optional().describe('The surface: see the description.'),
@@ -12,11 +12,15 @@ export const paintTool = {
             .string()
             .regex(/^#[0-9a-fA-F]{6}$/)
             .optional()
-            .describe('A colour, #rrggbb: painted with the nearest library colour.'),
+            .describe('A colour, #rrggbb: painted with the nearest library colour, or as given with exact.'),
+        exact: z
+            .boolean()
+            .optional()
+            .describe('With color: paint that colour itself, a matte scene material, not the nearest library colour (a brand colour, a colour matched to a photo).'),
         material: z
             .union([z.string().min(1), MaterialSchema])
             .optional()
-            .describe('A library:<id> or scene:<id> ref, or a native material (properties color, roughness, metalness, and an existing texture) kept as a scene material.'),
+            .describe("A library:<id> or scene:<id> ref, or a native material kept as a scene material: properties color, roughness, metalness; texture { url (https, or artifact://<sha256> of an image stored with the project), repeat [u, v] (tiles per metre), offset [u, v] (in tiles), normalMap, normalScale, bumpMap, bumpScale }, its maps sharing the image's repeat and offset. Surfaces are laid in level metres: a floor, a slab's top or a ceiling at u = plan x, v = −z; a wall face at u = x for a wall running along x (−x on its face turned to −z), z for one running along z (−z on its face turned to −x), v = 1 − the height above the level's floor. A joint at c along u or v: offset = frac(−c × repeat)."),
         materialName: z
             .string()
             .trim()

package/dist/agent-tools/photo-elevation.js

@@ -10,7 +10,7 @@ const segment = z.array(point).length(2);
 export const straightenFacadePhotoTool = {
     name: 'straighten_facade_photo',
     title: 'Straighten a facade photo',
-    description: "Straighten faces of a building photo into elevations at a known scale, to measure the facade instead of guessing it: bay pitch, pier and window widths, pane grids, side panels, spandrels, sill and head heights. Pass every face the photo shows in one call: they share the photo's camera, found from the lines picked on them, so each elevation is metric from its walls' width and the storey height is measured from the photo rather than taken from the scene. Per face: its vertical edges (two points on each, top and bottom as seen), the same feature on at least two storeys (the window heads of a low and a high floor, say: two points far apart along each, with that storey's level), and the face's walls on one storey (their extent is the width). A face whose far edge leaves the photo gives only the corner it shares with another face. Points are fractions of the photo, [0,0] its top left and [1,1] its bottom right. Returns per face the straightened elevation with a metre grid and the scene's storeys drawn at the picked feature, a close-up of each picked corner to check (call again with corrected points if one is off), the photo pixels per metre at each side, the fit error and the photo's storey height beside the scene's; and the camera: its focal length (a phone's main camera is about 26 mm), its tilt, what it assumes, and its pose in the scene (position, target, up, vertical fov, the photo's aspect): view_scene from that pose shows the scene as the photo does. One face seen square on (a frontal photo) gives a pose too, its focal length taken from focal35mm when it cannot be read from the photo. A single face with both edges is fitted from its own picks, its heights from the storeys. Only what lies on the wall plane measures true: balconies, overhangs and anything standing proud are smeared, and a face seen at a grazing angle has too few pixels per metre for panes.",
+    description: "Straighten the faces of a building photo into metric elevations to measure its facade, and return each on a metre grid and a camera pose when recoverable. They measure the facade instead of guessing it: bay pitch, pier and window widths, pane grids, side panels, spandrels, sill and head heights. Pass every face the photo shows in one call: they share the photo's camera, found from the lines picked on them, so each elevation is metric from its walls' width and the storey height is measured from the photo rather than taken from the scene. Per face: its vertical edges (two points on each, top and bottom as seen), the same feature on at least two storeys (the window heads of a low and a high floor, say: two points far apart along each, with that storey's level), and the face's walls on one storey (their extent is the width). A face whose far edge leaves the photo gives only the corner it shares with another face. Points are fractions of the photo, [0,0] its top left and [1,1] its bottom right. Returns per face the straightened elevation with a metre grid and the scene's storeys drawn at the picked feature, a close-up of each picked corner to check (call again with corrected points if one is off), the photo pixels per metre at each side, the fit error and the photo's storey height beside the scene's; and the camera: its focal length (a phone's main camera is about 26 mm), its tilt, what it assumes, and its pose in the scene (position, target, up, vertical fov, the photo's aspect): view_scene from that pose shows the scene as the photo does. One face seen square on (a frontal photo) gives a pose too, its focal length taken from focal35mm when it cannot be read from the photo. A single face with both edges is fitted from its own picks, its heights from the storeys. Only what lies on the wall plane measures true: balconies, overhangs and anything standing proud are smeared, and a face seen at a grazing angle has too few pixels per metre for panes.",
     input: {
         source: z.string().describe("The photo: its attachment URL, as the user's message gives it."),
         faces: z

package/dist/agent-tools/project-files.d.ts

@@ -82,7 +82,7 @@ export declare const renameProjectFileTool: {
 export declare const deleteProjectFileTool: {
     readonly name: 'delete_project_file';
     readonly title: 'Delete project file';
-    readonly description: 'Remove a file from the project catalog. A Studio file is removed from Studio too. Only do this when the user requests deletion. Existing scene or chat references may still retain the bytes; this is not guaranteed storage erasure.';
+    readonly description: 'Remove a file from the project catalog. A Studio file is removed from Studio too. Only do this when the user requests deletion. A scene or a conversation that references it may still retain the bytes; this is not guaranteed storage erasure.';
     readonly input: {
         projectId: z.ZodOptional<z.ZodString>;
         fileId: z.ZodString;
@@ -173,7 +173,7 @@ export declare const PROJECT_FILE_TOOL_CONTRACTS: readonly [{
 }, {
     readonly name: 'delete_project_file';
     readonly title: 'Delete project file';
-    readonly description: 'Remove a file from the project catalog. A Studio file is removed from Studio too. Only do this when the user requests deletion. Existing scene or chat references may still retain the bytes; this is not guaranteed storage erasure.';
+    readonly description: 'Remove a file from the project catalog. A Studio file is removed from Studio too. Only do this when the user requests deletion. A scene or a conversation that references it may still retain the bytes; this is not guaranteed storage erasure.';
     readonly input: {
         projectId: z.ZodOptional<z.ZodString>;
         fileId: z.ZodString;

package/dist/agent-tools/project-files.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project-files.d.ts","sourceRoot":"","sources":["../../src/agent-tools/project-files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,eAAO,MAAM,oBAAoB;mBACzB,oBAAoB;oBACnB,oBAAoB;0BAEzB,8QAA8Q;;;;;;;;;;;;;;;;;;;;CASxQ,CAAA;AAEV,eAAO,MAAM,kBAAkB;aAC7B,IAAI,EAAE,kBAAkB;aACxB,KAAK,EAAE,mBAAmB;aAC1B,WAAW,EACT,2JAA2J;aAC7J,KAAK;;;;aACL,WAAW;;;;;;CACH,CAAA;AAEV,eAAO,MAAM,qBAAqB;mBAC1B,qBAAqB;oBACpB,qBAAqB;0BAE1B,ieAAie;;;;;;;;;;;;;;;;iBAuBje,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;CAEP,CAAA;AAEV,eAAO,MAAM,qBAAqB;mBAC1B,qBAAqB;oBACpB,qBAAqB;0BAE1B,yHAAyH;;;;;;;iBAGzH,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;CAEP,CAAA;AAEV,eAAO,MAAM,qBAAqB;aAChC,IAAI,EAAE,qBAAqB;aAC3B,KAAK,EAAE,qBAAqB;aAC5B,WAAW,EACT,uOAAuO;aACzO,KAAK;;;;aACL,WAAW;iBACT,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;CAEP,CAAA;AAEV,eAAO,MAAM,2BAA2B;mBArFhC,oBAAoB;oBACnB,oBAAoB;0BAEzB,8QAA8Q;;;;;;;;;;;;;;;;;;;;;mBAY1Q,kBAAkB;oBACjB,mBAAmB;0BAExB,2JAA2J;;;;;;;;;;;;mBAMvJ,qBAAqB;oBACpB,qBAAqB;0BAE1B,ieAAie;;;;;;;;;;;;;;;;iBAuBje,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;;mBAKT,qBAAqB;oBACpB,qBAAqB;0BAE1B,yHAAyH;;;;;;;iBAGzH,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;;mBAKT,qBAAqB;oBACpB,qBAAqB;0BAE1B,uOAAuO;;;;;;iBAGvO,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;EAUP,CAAA;AACV,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAA"}
+{"version":3,"file":"project-files.d.ts","sourceRoot":"","sources":["../../src/agent-tools/project-files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,eAAO,MAAM,oBAAoB;mBACzB,oBAAoB;oBACnB,oBAAoB;0BAEzB,8QAA8Q;;;;;;;;;;;;;;;;;;;;CASxQ,CAAA;AAEV,eAAO,MAAM,kBAAkB;aAC7B,IAAI,EAAE,kBAAkB;aACxB,KAAK,EAAE,mBAAmB;aAC1B,WAAW,EACT,2JAA2J;aAC7J,KAAK;;;;aACL,WAAW;;;;;;CACH,CAAA;AAEV,eAAO,MAAM,qBAAqB;mBAC1B,qBAAqB;oBACpB,qBAAqB;0BAE1B,ieAAie;;;;;;;;;;;;;;;;iBAuBje,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;CAEP,CAAA;AAEV,eAAO,MAAM,qBAAqB;mBAC1B,qBAAqB;oBACpB,qBAAqB;0BAE1B,yHAAyH;;;;;;;iBAGzH,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;CAEP,CAAA;AAEV,eAAO,MAAM,qBAAqB;aAChC,IAAI,EAAE,qBAAqB;aAC3B,KAAK,EAAE,qBAAqB;aAC5B,WAAW,EACT,kPAAkP;aACpP,KAAK;;;;aACL,WAAW;iBACT,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;CAEP,CAAA;AAEV,eAAO,MAAM,2BAA2B;mBArFhC,oBAAoB;oBACnB,oBAAoB;0BAEzB,8QAA8Q;;;;;;;;;;;;;;;;;;;;;mBAY1Q,kBAAkB;oBACjB,mBAAmB;0BAExB,2JAA2J;;;;;;;;;;;;mBAMvJ,qBAAqB;oBACpB,qBAAqB;0BAE1B,ieAAie;;;;;;;;;;;;;;;;iBAuBje,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;;mBAKT,qBAAqB;oBACpB,qBAAqB;0BAE1B,yHAAyH;;;;;;;iBAGzH,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;;mBAKT,qBAAqB;oBACpB,qBAAqB;0BAE1B,kPAAkP;;;;;;iBAGlP,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;EAUP,CAAA;AACV,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/agent-tools/project-files.js

@@ -81,7 +81,7 @@ export const renameProjectFileTool = {
 export const deleteProjectFileTool = {
     name: 'delete_project_file',
     title: 'Delete project file',
-    description: 'Remove a file from the project catalog. A Studio file is removed from Studio too. Only do this when the user requests deletion. Existing scene or chat references may still retain the bytes; this is not guaranteed storage erasure.',
+    description: 'Remove a file from the project catalog. A Studio file is removed from Studio too. Only do this when the user requests deletion. A scene or a conversation that references it may still retain the bytes; this is not guaranteed storage erasure.',
     input: file,
     annotations: {
         readOnlyHint: false,

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

@@ -7,9 +7,17 @@
 export declare class AgentRefusal extends Error {
     readonly code: string;
     readonly details: Record<string, unknown>;
+    /** What the refusal asks its host to remember with the agent's session, as an outcome's `keep` does. */
+    readonly keep?: RefusalKeep | undefined;
     readonly name = "AgentRefusal";
-    constructor(code: string, message: string, details?: Record<string, unknown>);
+    constructor(code: string, message: string, details?: Record<string, unknown>, 
+    /** What the refusal asks its host to remember with the agent's session, as an outcome's `keep` does. */
+    keep?: RefusalKeep | undefined);
 }
+/** The readings a refusal asks a host to keep (`SessionKeep.readings`): a refused call changes nothing else. */
+export type RefusalKeep = {
+    readonly readings: Readonly<Record<string, unknown>>;
+};
 export declare function isAgentRefusal(error: unknown): error is AgentRefusal;
 export declare function refuse(code: string, message: string, details?: Record<string, unknown>): never;
 /** The answer both surfaces return for a refusal. */

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

@@ -1 +1 @@
-{"version":3,"file":"refusal.d.ts","sourceRoot":"","sources":["../../src/agent-tools/refusal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,KAAK;IAGnC,QAAQ,CAAC,IAAI,EAAE,MAAM;IAErB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAJ3C,SAAkB,IAAI,kBAAiB;IACvC,YACW,IAAI,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACN,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EAG/C;CACF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAOpE;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,CAE9F;AAED,qDAAqD;AACrD,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY;;;EAEjD"}
+{"version":3,"file":"refusal.d.ts","sourceRoot":"","sources":["../../src/agent-tools/refusal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,KAAK;IAGnC,QAAQ,CAAC,IAAI,EAAE,MAAM;IAErB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACzC,wGAAwG;IACxG,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW;IAN7B,SAAkB,IAAI,kBAAiB;IACvC,YACW,IAAI,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACN,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAC9C,wGAAwG;IAC/F,IAAI,CAAC,EAAE,WAAW,YAAA,EAG5B;CACF;AAED,gHAAgH;AAChH,MAAM,MAAM,WAAW,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAAE,CAAA;AAElF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAOpE;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,CAE9F;AAED,qDAAqD;AACrD,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY;;;EAEjD"}

package/dist/agent-tools/refusal.js

@@ -7,11 +7,15 @@
 export class AgentRefusal extends Error {
     code;
     details;
+    keep;
     name = 'AgentRefusal';
-    constructor(code, message, details = {}) {
+    constructor(code, message, details = {}, 
+    /** What the refusal asks its host to remember with the agent's session, as an outcome's `keep` does. */
+    keep) {
         super(message);
         this.code = code;
         this.details = details;
+        this.keep = keep;
     }
 }
 export function isAgentRefusal(error) {

package/dist/agent-tools/roofs.js

@@ -89,7 +89,7 @@ export const createRoofTool = {
 export const moveRoofsToRoofLevelTool = {
     name: 'move_roofs_to_roof_level',
     title: 'Move roofs to the roof level',
-    description: "Move the roofs a storey holds on its own walls to the level the roof rule gives them, as a roof's panel does by hand (Move to the roof level): over the top storey, the building's roof level (made, named Roof, when there is none); under an upper storey, that storey. Each roof stands exactly where it stood, its segments, finishes and id kept: only the level holding it changes, so exploded and solo level views show the storey's plan with no roof over it. For a project built before roofs had their own level, when verify_scene reports roof_mixed_in_storey. Refused with a code: level_not_found, no_roof_on_walls (the storey holds no roof standing on its walls; a porch roof on its beam and a lower wing's roof on the storey above already sit where they belong). Returns the roofs moved (roofIds), the level they went to (roofLevelId) and the roof level made for them (createdRoofLevelId).",
+    description: "Move the roofs a storey holds on its own walls to the level the roof rule gives them, and return the roofs moved and the level they went to. It does what a roof's panel does by hand (Move to the roof level): over the top storey, the building's roof level (made, named Roof, when there is none); under an upper storey, that storey. Each roof stands exactly where it stood, its segments, finishes and id kept: only the level holding it changes, so exploded and solo level views show the storey's plan with no roof over it. For a project built before roofs had their own level, when verify_scene reports roof_mixed_in_storey. Refused with a code: level_not_found, no_roof_on_walls (the storey holds no roof standing on its walls; a porch roof on its beam and a lower wing's roof on the storey above already sit where they belong). Returns the roofs moved (roofIds), the level they went to (roofLevelId) and the roof level made for them (createdRoofLevelId).",
     input: {
         levelId: NodeId.describe('The storey whose roofs move, by an id list_levels returned.'),
     },

package/dist/agent-tools/room-structure.d.ts

@@ -169,6 +169,36 @@ export declare const setZoneIntentTool: {
                     polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
                     finish: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
                 }, z.core.$strip>>>>;
+                drop: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>;
+            }, z.core.$strict>>>;
+            roomType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                deck: "deck";
+                patio: "patio";
+                porch: "porch";
+            }>>>;
+            porchFraming: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                auto: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                postSize: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    "4x4": "4x4";
+                    "6x6": "6x6";
+                    "8x8": "8x8";
+                }>>>;
+                postSpacing: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>;
+                beamSize: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+            decking: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                boardSize: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    "2x4": "2x4";
+                    "2x6": "2x6";
+                    "5/4x6": "5/4x6";
+                    composite: "composite";
+                }>>>;
+                gap: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>;
+                direction: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    diagonal: "diagonal";
+                    parallel: "parallel";
+                    perpendicular: "perpendicular";
+                }>>>;
             }, z.core.$strict>>>;
             ceiling: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 regions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
@@ -388,6 +418,36 @@ export declare const ROOM_TOOL_CONTRACTS: readonly [{
                     polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
                     finish: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
                 }, z.core.$strip>>>>;
+                drop: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>;
+            }, z.core.$strict>>>;
+            roomType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                deck: "deck";
+                patio: "patio";
+                porch: "porch";
+            }>>>;
+            porchFraming: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                auto: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                postSize: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    "4x4": "4x4";
+                    "6x6": "6x6";
+                    "8x8": "8x8";
+                }>>>;
+                postSpacing: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>;
+                beamSize: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+            decking: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                boardSize: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    "2x4": "2x4";
+                    "2x6": "2x6";
+                    "5/4x6": "5/4x6";
+                    composite: "composite";
+                }>>>;
+                gap: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>;
+                direction: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    diagonal: "diagonal";
+                    parallel: "parallel";
+                    perpendicular: "perpendicular";
+                }>>>;
             }, z.core.$strict>>>;
             ceiling: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 regions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{

package/dist/agent-tools/room-structure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"room-structure.d.ts","sourceRoot":"","sources":["../../src/agent-tools/room-structure.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"room-structure.d.ts","sourceRoot":"","sources":["../../src/agent-tools/room-structure.ts"],"names":[],"mappings":"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"}

package/dist/agent-tools/room-structure.js

@@ -16,6 +16,25 @@ const zoneIntentPatch = z.strictObject({
         elevation: measurement('length', 'm').nullable().optional(),
         finish: finish.nullable().optional(),
         regions: paintRegions.nullable().optional(),
+        drop: measurement('length', 'm', { min: 0 }).nullable().optional(),
+    })
+        .nullable()
+        .optional(),
+    roomType: z.enum(['porch', 'deck', 'patio']).nullable().optional(),
+    porchFraming: z
+        .strictObject({
+        auto: z.boolean().nullable().optional(),
+        postSize: z.enum(['4x4', '6x6', '8x8']).nullable().optional(),
+        postSpacing: measurement('length', 'm', { min: 0.6 }).nullable().optional(),
+        beamSize: z.string().nullable().optional(),
+    })
+        .nullable()
+        .optional(),
+    decking: z
+        .strictObject({
+        boardSize: z.enum(['5/4x6', '2x6', '2x4', 'composite']).nullable().optional(),
+        gap: measurement('length', 'm', { positive: true }).nullable().optional(),
+        direction: z.enum(['parallel', 'diagonal', 'perpendicular']).nullable().optional(),
     })
         .nullable()
         .optional(),
@@ -163,7 +182,7 @@ export const lockOutsideFacesTool = {
 export const setZoneIntentTool = {
     name: 'set_zone_intent',
     title: 'Set room intent',
-    description: 'Update room name, floor finish/elevation/regions, floor.footprint ("new" mints a unique floor key tied to this creator room, an existing key joins that floor on this level, null returns to the shared floor). Touching rooms with the same key share a base plate; disconnected pieces share construction settings. Conversion preserves world geometry in one edit and refuses when infeasible. get_zones exposes floor_choices. A keyed floor uses "<creator room name> floor" while the creator remains on that key; otherwise it uses the largest named room. Existing keys such as "own" without a creator use that fallback. A user-given plate name wins; the shared floor stays "Shared floor". Keyed rooms can have raised or sunken floor.elevation, stored as a level-local walking top. Slab thickness, foundation height and edge finish use set_room_floor_construction, updating every piece of the key. Update ceiling paint regions (ceiling.regions: [x, z] polygons with a finish, later wins), step finishes (floorStepFinish for every step of the room; floorStepOverrides: [{ key, step?, finish }] per doorway, key = the door id the step sits under or the lower room id), wall material and construction opt-outs. daylight { artificialLight, mechanicalVentilation } declares a habitable room lit and aired by artificial means (the IRC R303.1 exceptions to daylight; both true), stored in the room\'s metadata; a bedroom, living room or kitchen needs a window to outside or this declaration, above and below grade alike. Absent fields are unchanged; null clears.',
+    description: 'Update a room\'s intent in one patch (name, floor, ceiling, steps, walls, daylight, outdoor type, porch framing, decking) and return how many changes it made. It sets the room name, floor finish/elevation/regions and floor.footprint ("new" mints a unique floor key tied to this creator room, an existing key joins that floor on this level, null returns to the shared floor). Touching rooms with the same key share a base plate; disconnected pieces share construction settings. Conversion preserves world geometry in one edit and refuses when infeasible. get_zones exposes floor_choices. A keyed floor uses "<creator room name> floor" while the creator remains on that key; otherwise it uses the largest named room. Existing keys such as "own" without a creator use that fallback. A user-given plate name wins; the shared floor stays "Shared floor". Keyed rooms can have raised or sunken floor.elevation, stored as a level-local walking top. Slab thickness, foundation height and edge finish use set_room_floor_construction, updating every piece of the key. Update ceiling paint regions (ceiling.regions: [x, z] polygons with a finish, later wins), step finishes (floorStepFinish for every step of the room; floorStepOverrides: [{ key, step?, finish }] per doorway, key = the door id the step sits under or the lower room id), wall material and construction opt-outs. daylight { artificialLight, mechanicalVentilation } declares a habitable room lit and aired by artificial means (the IRC R303.1 exceptions to daylight; both true), stored in the room\'s metadata; a bedroom, living room or kitchen needs a window to outside or this declaration, above and below grade alike. roomType ("porch" | "deck" | "patio", null for a room) makes the room outdoors: a porch is a concrete slab stepped floor.drop (1.5 in) under the house with a ceiling, a deck wood decking 1 in down and framed, a patio concrete and open. porchFraming { auto, postSize "4x4"|"6x6"|"8x8", postSpacing m, beamSize e.g. "6x8" } sets the posts of a covered porch (one at each outside corner, more at most postSpacing apart) and the beam on them under its ceiling; a deck or patio gets them only with auto true (to carry a roof over it). A size or the spacing rebuilds them, auto false leaves them as edited. decking { boardSize "5/4x6"|"2x6"|"2x4"|"composite", gap m (1/8, 3/16 or 1/4 in), direction "parallel"|"diagonal"|"perpendicular" to the house } sets a deck\'s boards (default 5/4x6, 1/4 in apart, along the house); its frame follows: joists 12 in on centre under diagonal 5/4 or composite boards (IRC R507.7), and along the house on beams square to it under boards running out from it. Absent fields are unchanged; null clears.',
     input: { zoneId: NodeId, patch: zoneIntentPatch },
 };
 export const divideZoneTool = {

package/dist/agent-tools/search-materials.d.ts

@@ -19,6 +19,7 @@ export declare const searchMaterialsTool: {
                 other: "other";
                 plastic: "plastic";
                 roofing: "roofing";
+                siding: "siding";
                 stone: "stone";
                 tile: "tile";
                 wallpaper: "wallpaper";

package/dist/agent-tools/search-materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-materials.d.ts","sourceRoot":"","sources":["../../src/agent-tools/search-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,mBAAmB;IAC9B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BV,CAAA"}
+{"version":3,"file":"search-materials.d.ts","sourceRoot":"","sources":["../../src/agent-tools/search-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,mBAAmB;IAC9B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BV,CAAA"}

package/dist/agent-tools/site.js

@@ -10,7 +10,7 @@ const site = NodeId.optional().describe("The site, by its id (get_site's siteId)
 export const getSiteTool = {
     name: 'get_site',
     title: 'Get site',
-    description: "Read the site a building stands on, in its level coordinates: the lot and its area, with the footprint a house usually covers on it (30 to 45%); the buildable area inside the setbacks with its centre, its area, each edge's frontage and depth, and its front edge (behind the street; while no street is recorded, behind the edge facing north, which the setbacks take as the front); the street side with the lot's frontage and depth on it; north; the ground (sloped with its fall, read flat, or not read); the address, parcel and zoning when known; whether the lot is only the new-project placeholder; and where the footprint sits now with its yards.",
+    description: "Read the site a building stands on and return, in its level coordinates, its lot, buildable area, street side, north, ground and the footprint's yards. It gives the lot and its area, with the footprint a house usually covers on it (30 to 45%); the buildable area inside the setbacks with its centre, its area, each edge's frontage and depth, and its front edge (behind the street; while no street is recorded, behind the edge facing north, which the setbacks take as the front); the street side with the lot's frontage and depth on it; north; the ground (sloped with its fall, read flat, or not read); the address, parcel and zoning when known; whether the lot is only the new-project placeholder; and where the footprint sits now with its yards.",
     input: { building, site },
 };
 export const placeBuildingTool = {