@pascal-app/core 1.0.5 → 1.0.7

package/dist/agent-operations/__fixtures__/search-assets-cases.js

@@ -23,6 +23,20 @@ export const LIBRARY = [
 ];
 const noScene = () => ({ nodes: {}, rootNodeIds: [] });
 const library = { activeLevelId: null, catalog: LIBRARY };
+// One "chair" at each rank, listed out of order.
+const CHAIRS = [
+    item('cushion', 'Seat Cushion', 'decor', ['deckchair']),
+    item('armchair', 'Armchair', 'furniture', ['seating']),
+    item('throne', 'Throne', 'furniture', ['chair', 'royal']),
+    item('bar-stool', 'Bar Stool', 'chairs', ['bar']),
+    item('garden-chair', 'Garden Chair', 'outdoor', ['seating']),
+    item('dining-chair', 'Dining Chair', 'furniture', ['seating']),
+    item('chair', 'Chair', 'furniture', []),
+    item('chairside', 'Chairside Table', 'furniture', []),
+    { ...item('nightstand', 'Nightstand', 'furniture', []), functionTags: ['side-table'] },
+];
+// 30 chairs over two categories: more than a search lists unless it is narrowed.
+const MANY_CHAIRS = Array.from({ length: 30 }, (_, index) => item(`chair-${index}`, `Chair ${String(index).padStart(2, '0')}`, index % 3 ? 'furniture' : 'outdoor', []));
 export const SEARCH_ASSETS_CASES = [
     {
         name: 'one group per query, in order, on the name, category or tags',
@@ -37,6 +51,7 @@ export const SEARCH_ASSETS_CASES = [
                     {
                         query: 'sofa',
                         total: 1,
+                        truncated: false,
                         results: [
                             {
                                 id: 'sofa',
@@ -137,6 +152,82 @@ export const SEARCH_ASSETS_CASES = [
             },
         },
     },
+    {
+        name: 'the name exactly first, then a word of the name, a word starting it, the category, a tag, inside the name, anywhere',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'chair' }, { query: 'side table' }] },
+        context: { activeLevelId: null, catalog: CHAIRS },
+        expect: {
+            result: {
+                groups: [
+                    {
+                        total: 8,
+                        truncated: false,
+                        results: [
+                            { id: 'chair' },
+                            { id: 'dining-chair' },
+                            { id: 'garden-chair' },
+                            { id: 'chairside' },
+                            { id: 'bar-stool' },
+                            { id: 'throne' },
+                            { id: 'armchair' },
+                            { id: 'cushion' },
+                        ],
+                    },
+                    { total: 2, results: [{ id: 'nightstand' }, { id: 'chairside' }] },
+                ],
+            },
+        },
+    },
+    {
+        name: 'a broad query lists the best 24, counts every match and says how to narrow it',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'chair' }, { query: 'chair', category: 'outdoor' }] },
+        context: { activeLevelId: null, catalog: MANY_CHAIRS },
+        expect: {
+            result: {
+                total: 40,
+                groups: [
+                    { total: 30, truncated: true },
+                    { total: 10, truncated: false },
+                ],
+                hint: '"chair" matches 30 items and lists the best 24: add words or a category to narrow it (furniture 20, outdoor 10).',
+            },
+            check: (result) => {
+                const [broad] = result.groups;
+                return broad.results.length === 24 && broad.results[0].id === 'chair-0'
+                    ? []
+                    : [`lists ${broad.results.length}, first ${broad.results[0]?.id}`];
+            },
+        },
+    },
+    {
+        name: 'a limit lists fewer, and a cut query with a category is narrowed by words',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'chair', category: 'furniture' }], limit: 5 },
+        context: { activeLevelId: null, catalog: MANY_CHAIRS },
+        expect: {
+            result: {
+                groups: [
+                    {
+                        total: 20,
+                        truncated: true,
+                        results: [
+                            { id: 'chair-1' },
+                            { id: 'chair-2' },
+                            { id: 'chair-4' },
+                            { id: 'chair-5' },
+                            { id: 'chair-7' },
+                        ],
+                    },
+                ],
+                hint: '"chair" matches 20 items and lists the best 5: add words to narrow it.',
+            },
+        },
+    },
     {
         // The MCP always has one (its built-in list when the host passes none).
         name: 'a host without a catalog is refused rather than answered with nothing',

package/dist/agent-operations/__fixtures__/site-cases.d.ts

@@ -184,6 +184,45 @@ export declare const site: (extra?: Record<string, unknown>) => {
             points: [number, number][];
         }[];
     } | undefined;
+    wallTypes?: {
+        id: string;
+        label: string;
+        assembly: {
+            layers: {
+                id: string;
+                role: "air" | "covering" | "deck" | "fill" | "finish" | "furring" | "glazing" | "insulation" | "lining" | "membrane" | "sheathing" | "shell" | "structure" | "substrate" | "underlay";
+                thickness: number;
+                core?: true | undefined;
+                spacing?: number | undefined;
+                material?: string | undefined;
+                slot?: string | undefined;
+                returns?: boolean | undefined;
+                display?: "construction" | "finished" | undefined;
+                inset?: number | undefined;
+                bottom?: number | undefined;
+                lift?: number | undefined;
+                src?: string | undefined;
+            }[];
+            backing?: {
+                id: string;
+                role: "air" | "covering" | "deck" | "fill" | "finish" | "furring" | "glazing" | "insulation" | "lining" | "membrane" | "sheathing" | "shell" | "structure" | "substrate" | "underlay";
+                thickness: number;
+                core?: true | undefined;
+                spacing?: number | undefined;
+                material?: string | undefined;
+                slot?: string | undefined;
+                returns?: boolean | undefined;
+                display?: "construction" | "finished" | undefined;
+                inset?: number | undefined;
+                bottom?: number | undefined;
+                lift?: number | undefined;
+                src?: string | undefined;
+            }[] | undefined;
+            face?: "exterior" | "front" | undefined;
+            presetId?: string | undefined;
+            cavityInsulation?: string | undefined;
+        };
+    }[] | undefined;
     children: string[];
 };
 export declare const building: (extra?: Record<string, unknown>, id?: string) => {
@@ -243,7 +282,7 @@ export declare const level: (buildingId?: string, id?: string) => {
     } | undefined;
     id: `level_${string}`;
     type: "level";
-    children: (`block_${string}` | `ceiling_${string}` | `column_${string}` | `construction-dimension_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `slab_${string}` | `spawn_${string}` | `stair_${string}` | `structural-grid_${string}` | `wall_${string}` | `zone_${string}`)[];
+    children: (`beam_${string}` | `block_${string}` | `ceiling_${string}` | `column_${string}` | `construction-dimension_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `slab_${string}` | `spawn_${string}` | `stair_${string}` | `structural-grid_${string}` | `wall_${string}` | `zone_${string}`)[];
     level: number;
     baseElevation: number;
     height?: number | undefined;

package/dist/agent-operations/__fixtures__/site-cases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"site-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/site-cases.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,OAAO,EAOb,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAExD;;;;GAIG;AAEH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE1B,qEAAqE;AACrE,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,OAAO,EAAE,GAAG,UAAU,CAcrD;AAED,eAAO,MAAM,IAAI,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACS,CAAA;AAC5D,eAAO,MAAM,QAAQ,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACK,CAAA;AAC5D,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACoE,CAAA;AAyCtF,eAAO,MAAM,MAAM;IACjB,OAAO;QAAI,IAAI;QAAa,MAAM;;IAClC,QAAQ;QAAI,KAAK;QAAK,IAAI;QAAO,IAAI;;IACrC,cAAc;IACd,SAAS;IACT,OAAO;QAAI,MAAM;QAAiB,IAAI;QAAe,KAAK;;IAC1D,MAAM;QAAI,GAAG;;CACd,CAAA;AAGD,eAAO,MAAM,QAAQ;IACnB,OAAO;QACL,IAAI;QACJ,MAAM;;IAOR,SAAS;CACV,CAAA;AAGD,eAAO,MAAM,KAAK;IAChB,OAAO;QACL,IAAI;QACJ,MAAM;;CAWT,CAAA;AAqBD,eAAO,MAAM,cAAc,EAAE,aAAa,EAiTzC,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,aAAa,EAkW/C,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,aAAa,EAqE1C,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,aAAa,EA4D5C,CAAA"}
+{"version":3,"file":"site-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/site-cases.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,OAAO,EAOb,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAExD;;;;GAIG;AAEH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE1B,qEAAqE;AACrE,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,OAAO,EAAE,GAAG,UAAU,CAcrD;AAED,eAAO,MAAM,IAAI,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACS,CAAA;AAC5D,eAAO,MAAM,QAAQ,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACK,CAAA;AAC5D,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACoE,CAAA;AAyCtF,eAAO,MAAM,MAAM;IACjB,OAAO;QAAI,IAAI;QAAa,MAAM;;IAClC,QAAQ;QAAI,KAAK;QAAK,IAAI;QAAO,IAAI;;IACrC,cAAc;IACd,SAAS;IACT,OAAO;QAAI,MAAM;QAAiB,IAAI;QAAe,KAAK;;IAC1D,MAAM;QAAI,GAAG;;CACd,CAAA;AAGD,eAAO,MAAM,QAAQ;IACnB,OAAO;QACL,IAAI;QACJ,MAAM;;IAOR,SAAS;CACV,CAAA;AAGD,eAAO,MAAM,KAAK;IAChB,OAAO;QACL,IAAI;QACJ,MAAM;;CAWT,CAAA;AAqBD,eAAO,MAAM,cAAc,EAAE,aAAa,EAiTzC,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,aAAa,EAkW/C,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,aAAa,EAqE1C,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,aAAa,EA4D5C,CAAA"}

package/dist/agent-operations/__fixtures__/structure-cases.d.ts

@@ -4,4 +4,7 @@ export declare const ADD_WALL_CASES: AgentToolCase[];
 export declare const ADD_FENCE_CASES: AgentToolCase[];
 export declare const ADD_LEVEL_CASES: AgentToolCase[];
 export declare const CREATE_STAIR_CASES: AgentToolCase[];
+export declare const WALL_TYPE_CASES: AgentToolCase[];
+export declare const FRAMING_POST_CASES: AgentToolCase[];
+export declare const RAILING_WALL_CASES: AgentToolCase[];
 //# sourceMappingURL=structure-cases.d.ts.map

package/dist/agent-operations/__fixtures__/structure-cases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"structure-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/structure-cases.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAyCxD,wBAAgB,YAAY,IAAI,UAAU,CAkDzC;AA8JD,eAAO,MAAM,cAAc,EAAE,aAAa,EAkOzC,CAAA;AAOD,eAAO,MAAM,eAAe,EAAE,aAAa,EAiF1C,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,aAAa,EAkP1C,CAAA;AAoHD,eAAO,MAAM,kBAAkB,EAAE,aAAa,EA+W7C,CAAA"}
+{"version":3,"file":"structure-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/structure-cases.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAyCxD,wBAAgB,YAAY,IAAI,UAAU,CAkDzC;AA8JD,eAAO,MAAM,cAAc,EAAE,aAAa,EAkOzC,CAAA;AAOD,eAAO,MAAM,eAAe,EAAE,aAAa,EAiF1C,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,aAAa,EAiO1C,CAAA;AAoHD,eAAO,MAAM,kBAAkB,EAAE,aAAa,EA+W7C,CAAA;AAmBD,eAAO,MAAM,eAAe,EAAE,aAAa,EAmE1C,CAAA;AAED,eAAO,MAAM,kBAAkB,EAAE,aAAa,EAwD7C,CAAA;AAED,eAAO,MAAM,kBAAkB,EAAE,aAAa,EAoD7C,CAAA"}

package/dist/agent-operations/__fixtures__/structure-cases.js

@@ -1,6 +1,7 @@
-import { BuildingNode, CeilingNode, LevelNode, SiteNode, SlabNode, WallNode, ZoneNode, } from '../../schema/index.js';
+import { BeamNode, ColumnNode, BuildingNode, CeilingNode, LevelNode, railingWallDefaults, SiteNode, SlabNode, WallNode, ZoneNode, } from '../../schema/index.js';
 import { FOUNDATION_CONSTRUCTIONS } from '../../lib/foundation-construction.js';
 import { foundationWallConstruction } from '../../lib/foundation-wall.js';
+import { WALL_ASSEMBLY_PRESETS, wallAssemblyPatch } from '../../systems/wall/wall-assembly.js';
 import { getLevelElevations } from '../../services/storey.js';
 const HALL = [
     [0, 0],
@@ -543,22 +544,6 @@ export const ADD_LEVEL_CASES = [
             mentions: ['below grade', 'cast concrete', 'Europe'],
         },
     },
-    {
-        name: 'set_ground_level on a site in Paris seats the building 0.15 m over grade, as cast concrete foundations do',
-        tool: 'set_ground_level',
-        scene: () => onSite(storeysScene(), SiteNode.parse({ id: 'site_paris', dossier: dossierAt('Paris, France') })),
-        input: { levelId: 'level_ground' },
-        expect: {
-            result: {
-                ok: true,
-                floorElevation: 0.15,
-                aboveGrade: 0.15,
-                foundation: { region: 'europe', construction: 'cast-concrete' },
-            },
-            mentions: ['cast concrete', 'Europe'],
-            after: { building_house: { position: [0, 0.15, 0], groundLevelId: 'level_ground' } },
-        },
-    },
     {
         name: 'above the highest level of the viewed building, at the default storey height',
         tool: 'add_level',
@@ -630,7 +615,7 @@ export const ADD_LEVEL_CASES = [
         scene: storeysScene,
         input: { levelId: 'level_upper' },
         expect: {
-            result: { ok: true, renumbered: true, floorElevation: 0.203 },
+            result: { ok: true, renumbered: true, floorElevation: 0 },
             after: {
                 level_upper: { level: 0 },
                 level_ground: { level: -1 },
@@ -1213,3 +1198,199 @@ export const CREATE_STAIR_CASES = [
         expect: { refusal: 'unknown_material', mentions: ['railingMaterial', 'library:brass-rail'] },
     },
 ];
+const ASSEMBLY_PRESET = WALL_ASSEMBLY_PRESETS.find((entry) => entry.id === 'exterior-2x6-siding');
+const PROJECT_TYPE = {
+    id: 'custom-porch', label: 'Porch wall',
+    assembly: { face: 'exterior', presetId: 'custom-porch', layers: [
+            { id: 'framing', role: 'structure', core: true, material: 'wood', thickness: 0.14 },
+            { id: 'interior', role: 'lining', material: 'drywall', thickness: 0.01 },
+        ] },
+};
+function wallTypesScene() {
+    const scene = storeysScene();
+    const site = SiteNode.parse({ id: 'site_types', children: scene.rootNodeIds, wallTypes: [PROJECT_TYPE] });
+    for (const id of scene.rootNodeIds)
+        scene.nodes[id].parentId = site.id;
+    scene.nodes[site.id] = site;
+    scene.rootNodeIds = [site.id];
+    return scene;
+}
+export const WALL_TYPE_CASES = [
+    ...[ASSEMBLY_PRESET, PROJECT_TYPE].map((type) => ({
+        name: `add wall copies ${type.id} layers and thickness, overriding explicit thickness`,
+        tool: 'add_wall', scene: wallTypesScene,
+        input: { levelId: 'level_ground', start: [8, 0], end: [8, 4], type: type.id, thickness: 0.3 },
+        expect: { result: { ok: true }, check: (result, nodes) => {
+                const wall = nodes[result.wallId];
+                const patch = wallAssemblyPatch(type.assembly);
+                return wall?.type === 'wall' && JSON.stringify(wall) === JSON.stringify(WallNode.parse({ ...wall, ...patch })) && wall.thickness === patch.thickness
+                    ? [] : ['Assembly or thickness differs from the panel patch'];
+            } },
+    })),
+    {
+        name: 'an explicit assembly below grade keeps its type without claiming default foundation construction',
+        tool: 'add_wall', scene: basementHouseScene,
+        input: { levelId: 'level_base', start: [0, 0], end: [6, 0], type: ASSEMBLY_PRESET.id },
+        expect: { result: { ok: true }, check: (result, nodes) => {
+                const wall = nodes[result.wallId];
+                return wall?.type === 'wall' && wall.assembly?.presetId === ASSEMBLY_PRESET.id && !result.construction
+                    ? [] : ['Explicit wall type was replaced or reported as default foundation construction'];
+            } },
+    },
+    ...[ASSEMBLY_PRESET, PROJECT_TYPE].map((type) => ({
+        name: `set wall type copies ${type.id} on existing walls`,
+        tool: 'set_wall_type', scene: wallTypesScene,
+        input: { wallIds: ['wall_ground'], type: type.id },
+        expect: { result: { ok: true, wallIds: ['wall_ground'], type: type.id },
+            after: { wall_ground: wallAssemblyPatch(type.assembly) } },
+    })),
+    ...['add_wall', 'set_wall_type'].map((tool) => ({
+        name: 'unknown assembly ids are refused', tool, scene: wallTypesScene,
+        input: { levelId: 'level_ground', start: [8, 0], end: [8, 4], wallIds: ['wall_ground'], type: 'missing-type' },
+        expect: { refusal: 'unknown_wall_type' },
+    })),
+    {
+        name: 'every wall must exist before any wall type changes',
+        tool: 'set_wall_type', scene: wallTypesScene,
+        input: { wallIds: ['wall_ground', 'wall_missing'], type: PROJECT_TYPE.id },
+        expect: { refusal: 'target_not_found' },
+    },
+    {
+        name: 'clearing an assembly keeps its thickness',
+        tool: 'set_wall_type', scene: () => {
+            const scene = wallTypesScene();
+            Object.assign(scene.nodes.wall_ground, wallAssemblyPatch(PROJECT_TYPE.assembly));
+            return scene;
+        },
+        input: { wallIds: ['wall_ground'], type: null },
+        expect: { result: { ok: true }, check: (_result, nodes) => {
+                const wall = nodes.wall_ground;
+                return wall?.type === 'wall' && !wall.assembly && wall.thickness === wallAssemblyPatch(PROJECT_TYPE.assembly).thickness
+                    ? [] : ['Clearing the assembly changed thickness or retained layers'];
+            } },
+    },
+    ...[ASSEMBLY_PRESET, PROJECT_TYPE, null].map((type) => ({
+        name: `get walls reports ${type?.id ?? 'no assembly'} and available types`,
+        tool: 'get_walls', scene: () => {
+            const scene = wallTypesScene();
+            if (type)
+                Object.assign(scene.nodes.wall_ground, wallAssemblyPatch(type.assembly));
+            return scene;
+        },
+        input: { levelId: 'level_ground' },
+        expect: { result: {}, contains: {
+                walls: [{ id: 'wall_ground', type: type ? { id: type.id, label: type.label } : null }],
+                wallTypes: [{ id: PROJECT_TYPE.id, label: PROJECT_TYPE.label }, { id: ASSEMBLY_PRESET.id, label: ASSEMBLY_PRESET.label }],
+            } },
+    })),
+];
+export const FRAMING_POST_CASES = [
+    {
+        name: 'role post uses the Post tile defaults and reaches the beam above it',
+        tool: 'add_column', scene: () => {
+            const scene = storeysScene();
+            const beam = BeamNode.parse({ id: 'beam_post', parentId: 'level_ground', start: [7, 0], end: [10, 0], topElevation: 2.6, depth: 0.2 });
+            scene.nodes[beam.id] = beam;
+            scene.nodes.level_ground.children.push(beam.id);
+            return scene;
+        },
+        input: { level: 'level_ground', x: 8, z: 0, role: 'post' },
+        expect: { result: { ok: true, width: 5.5 * 0.0254, depth: 5.5 * 0.0254 }, check: (result, nodes) => {
+                const post = nodes[result.columnId];
+                return post?.type === 'column' && post.role === 'post' && post.crossSection === 'square' && post.postBase === 'none' && post.baseStyle === 'none' && post.capitalStyle === 'none' && post.slots?.shaft === 'library:wood-woodplank19' && Math.abs(post.height - 2.4) < 1e-9
+                    ? [] : [`Wrong Post tile defaults: ${JSON.stringify(post)}`];
+            } },
+    },
+    ...['4x4', '6x6', '8x8'].map((size, index) => ({
+        name: `post ${size} with ${['none', 'post-base', 'pier'][index]} uses native size and base fields`,
+        tool: 'add_column', scene: storeysScene,
+        input: { level: 'level_ground', x: 8, z: 0, role: 'post', postSize: size, postBase: ['none', 'post-base', 'pier'][index], height: '8 ft' },
+        expect: { result: { ok: true, height: 2.4384 }, check: (result, nodes) => {
+                const post = nodes[result.columnId];
+                const side = [3.5, 5.5, 7.25][index] * 0.0254;
+                const base = ['none', 'post-base', 'pier'][index];
+                return post?.type === 'column' && post.width === side && post.depth === side && post.postBase === base && post.baseStyle === (index === 0 ? 'none' : 'simple-square') && post.baseHeight === [0, 1.5 * 0.0254, 8 * 0.0254][index] && (index === 0 || post.slots?.base === ['unused', 'library:metal-steel', 'library:concrete-raw'][index])
+                    ? [] : ['Post section or base differs from the tile choices'];
+            } },
+    })),
+    {
+        name: 'editing a post size and base keeps its authored height, position and shaft finish',
+        tool: 'add_column', scene: () => {
+            const scene = storeysScene();
+            const post = ColumnNode.parse({ id: 'column_post', parentId: 'level_ground', role: 'post', crossSection: 'square', width: 0.1397, depth: 0.1397, height: 1.8, position: [8, 0, 0], slots: { shaft: 'library:preset-white', base: 'library:metal-steel' }, postBase: 'post-base' });
+            scene.nodes[post.id] = post;
+            scene.nodes.level_ground.children.push(post.id);
+            return scene;
+        },
+        input: { nodeId: 'column_post', postSize: '8x8', postBase: 'pier' },
+        expect: { result: { ok: true }, after: { column_post: { role: 'post', width: 7.25 * 0.0254, depth: 7.25 * 0.0254, height: 1.8, position: [8, 0, 0], postBase: 'pier', baseStyle: 'simple-square', baseHeight: 8 * 0.0254, slots: { shaft: 'library:preset-white', base: 'library:concrete-raw' } } } },
+    },
+    {
+        name: 'ordinary columns keep their defaults when no post is requested',
+        tool: 'add_column', scene: storeysScene,
+        input: { level: 'level_ground', x: 8, z: 0 },
+        expect: { result: { height: 2.5, width: 0.44, depth: 0.44 }, check: (result, nodes) => {
+                const column = nodes[result.columnId];
+                return column?.type === 'column' && !column.role && !column.postBase && column.crossSection === 'round' ? [] : ['Ordinary column defaults changed'];
+            } },
+    },
+    {
+        name: 'post choices on an ordinary column require role post',
+        tool: 'add_column', scene: storeysScene,
+        input: { level: 'level_ground', x: 8, z: 0, postSize: '4x4' },
+        expect: { refusal: 'not_a_post' },
+    },
+];
+export const RAILING_WALL_CASES = [
+    ...[undefined, 'post-and-rail', 'balusters', 'cable', 'boards', 'glass', 'metal'].map((style) => ({
+        name: `railing ${style ?? 'default'} uses Build panel members and post thickness even below grade`,
+        tool: 'add_wall', scene: basementHouseScene,
+        input: { levelId: 'level_base', start: [0, 0], end: [6, 0], wallType: 'railing', thickness: 0.3, ...(style ? { railing: { style } } : {}) },
+        expect: { result: { ok: true }, check: (result, nodes) => {
+                const wall = nodes[result.wallId];
+                const defaults = railingWallDefaults(style);
+                return wall?.type === 'wall' && wall.wallType === 'railing' && wall.height === defaults.height && wall.thickness === defaults.thickness && !wall.assembly && JSON.stringify(wall.railing) === JSON.stringify(defaults.railing) && !result.construction
+                    ? [] : [`Railing differs from Build defaults: ${JSON.stringify(wall)}`];
+            } },
+    })),
+    {
+        name: 'railing accepts every schema setting and a custom guard height in length notation',
+        tool: 'add_wall', scene: storeysScene,
+        input: { levelId: 'level_ground', start: [8, 0], end: [8, 4], wallType: 'railing', height: '42 in', thickness: 0.3,
+            railing: { style: 'cable', postSpacing: '4 ft', postSize: '3 in', infillSize: '0.25 in', infillGap: '2 in', bottomClearance: 0, cap: false } },
+        expect: { result: { ok: true }, check: (result, nodes) => {
+                const wall = nodes[result.wallId];
+                const expected = WallNode.parse({ ...wall, wallType: 'railing', height: 1.0668, thickness: 0.0762,
+                    railing: { style: 'cable', postSpacing: 1.2192, postSize: 0.0762, infillSize: 0.00635, infillGap: 0.0508, bottomClearance: 0, cap: false } });
+                return JSON.stringify(wall) === JSON.stringify(expected) ? [] : ['Custom guard settings or height were lost'];
+            } },
+    },
+    {
+        name: 'railing settings require the railing kind', tool: 'add_wall', scene: storeysScene,
+        input: { levelId: 'level_ground', start: [8, 0], end: [8, 4], railing: { style: 'glass' } },
+        expect: { refusal: 'not_a_railing' },
+    },
+    {
+        name: 'railings take no assembly type', tool: 'add_wall', scene: storeysScene,
+        input: { levelId: 'level_ground', start: [8, 0], end: [8, 4], wallType: 'railing', type: ASSEMBLY_PRESET.id },
+        expect: { refusal: 'railing_wall' },
+    },
+    ...['railing', 'curtain'].map((wallType) => ({
+        name: `existing ${wallType} walls refuse assembly changes`, tool: 'set_wall_type', scene: () => {
+            const scene = storeysScene();
+            Object.assign(scene.nodes.wall_ground, { wallType });
+            return scene;
+        },
+        input: { wallIds: ['wall_ground'], type: ASSEMBLY_PRESET.id },
+        expect: { refusal: `${wallType}_wall` },
+    })),
+    ...[undefined, 'standard', 'railing', 'curtain'].map((wallType) => ({
+        name: `get walls reports wallType ${wallType ?? 'standard for legacy walls'}`, tool: 'get_walls', scene: () => {
+            const scene = storeysScene();
+            Object.assign(scene.nodes.wall_ground, { wallType });
+            return scene;
+        },
+        input: { levelId: 'level_ground' },
+        expect: { result: {}, contains: { walls: [{ id: 'wall_ground', wallType: wallType ?? 'standard' }] } },
+    })),
+];

package/dist/agent-operations/__fixtures__/unit-cases.d.ts

@@ -0,0 +1,6 @@
+import type { AgentToolCase } from './cases.js';
+export declare const CREATE_UNIT_CASES: AgentToolCase[];
+export declare const SET_UNIT_MEMBERS_CASES: AgentToolCase[];
+export declare const LIST_UNITS_CASES: AgentToolCase[];
+export declare const UNIT_CASES: AgentToolCase[];
+//# sourceMappingURL=unit-cases.d.ts.map

package/dist/agent-operations/__fixtures__/unit-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/unit-cases.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,SAAS,CAAA;AAqFxD,eAAO,MAAM,iBAAiB,EAAE,aAAa,EA4E5C,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,aAAa,EAwDjD,CAAA;AAED,eAAO,MAAM,gBAAgB,EAAE,aAAa,EAmD3C,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,aAAa,EAIrC,CAAA"}