@pascal-app/core 1.0.4 → 1.0.5

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

@@ -1,6 +1,6 @@
 import { createZone, cutFloorOpening, divideZone, structureChangeBatch } from '../../commands/structure/index.js';
 import { reconcileSceneStructure } from '../../lib/structure-reconcile.js';
-import { BuildingNode, ItemNode, LevelNode } from '../../schema/index.js';
+import { BuildingNode, ItemNode, LevelNode, } from '../../schema/index.js';
 import { applySceneChanges } from '../apply-changes.js';
 function kitchenScene({ divided, hatch, lamp } = {}) {
     const names = {
@@ -65,6 +65,31 @@ function kitchenScene({ divided, hatch, lamp } = {}) {
     }
     return { nodes, rootNodeIds: [building.id] };
 }
+const LIT = { artificialLight: true, mechanicalVentilation: true };
+/** The kitchen with metadata already on its zone: what a plan import or an earlier edit left. */
+function withKitchenMetadata(metadata) {
+    const scene = kitchenScene();
+    scene.nodes.zone_kitchen = { ...scene.nodes.zone_kitchen, metadata };
+    return scene;
+}
+export function paintedKitchenScene() {
+    const scene = kitchenScene({ divided: true });
+    scene.nodes.zone_kitchen = {
+        ...scene.nodes.zone_kitchen,
+        wallMaterial: 'library:preset-white',
+        wallOverrides: [{ wallId: 'wall_north', face: 'a', finish: 'library:local-tile' }],
+    };
+    scene.nodes.zone_pantry = {
+        ...scene.nodes.zone_pantry,
+        wallMaterial: 'library:pantry-blue',
+        wallOverrides: [{ wallId: 'wall_south', face: 'a', finish: 'library:pantry-tile' }],
+    };
+    scene.nodes.wall_north = {
+        ...scene.nodes.wall_north,
+        faceRegions: [{ id: 'wainscot', face: 'a', v1: 0.9, finish: 'library:wood' }],
+    };
+    return scene;
+}
 /** The kitchen's floor plate: the reconciler names it from its footprint. */
 const plateId = Object.values(kitchenScene().nodes).find((node) => node.type === 'slab' && node.plateRole === 'base').id;
 /** The scene holds this many nodes of each type: rooms and separators the call minted. */
@@ -190,6 +215,88 @@ export const ROOM_CASES = [
             after: { zone_kitchen: { name: 'Studio', floor: { finish: 'wood' } } },
         },
     },
+    {
+        name: 'declares a room lit and ventilated by artificial means, beside the rest of its metadata',
+        tool: 'set_zone_intent',
+        scene: () => withKitchenMetadata({ note: 'from the plan' }),
+        input: {
+            zoneId: 'zone_kitchen',
+            patch: { daylight: { artificialLight: true, mechanicalVentilation: true } },
+        },
+        expect: {
+            result: { changes: 1 },
+            check: (_result, nodes) => JSON.stringify(nodes.zone_kitchen.metadata) ===
+                JSON.stringify({ note: 'from the plan', daylight: LIT })
+                ? []
+                : [`metadata must hold the note and the declaration: ${JSON.stringify(nodes.zone_kitchen.metadata)}`],
+        },
+    },
+    {
+        name: 'a null daylight clears the declaration and keeps the rest of the metadata',
+        tool: 'set_zone_intent',
+        scene: () => withKitchenMetadata({ note: 'from the plan', daylight: LIT }),
+        input: { zoneId: 'zone_kitchen', patch: { daylight: null } },
+        expect: {
+            result: { changes: 1 },
+            check: (_result, nodes) => JSON.stringify(nodes.zone_kitchen.metadata) ===
+                JSON.stringify({ note: 'from the plan' })
+                ? []
+                : [`metadata must hold the note alone: ${JSON.stringify(nodes.zone_kitchen.metadata)}`],
+        },
+    },
+    // Single public writes: room commands deliberately are not batchable.
+    ...[
+        ['omitting wall intent retains chosen white', { name: 'Studio' }, 'library:preset-white'],
+        ['a wall intent string replaces chosen white', { wallMaterial: 'library:blue' }, 'library:blue'],
+        ['an empty wall intent string remains a string', { wallMaterial: '' }, ''],
+        ['null clears room wall intent without clearing local paint', { wallMaterial: null }, undefined],
+    ].map(([name, patch, wallMaterial]) => ({
+        name,
+        tool: 'set_zone_intent',
+        scene: paintedKitchenScene,
+        input: { zoneId: 'zone_kitchen', patch },
+        expect: {
+            result: { changes: 1 },
+            after: {
+                zone_kitchen: {
+                    wallOverrides: [{ wallId: 'wall_north', face: 'a', finish: 'library:local-tile' }],
+                },
+                zone_pantry: {
+                    wallMaterial: 'library:pantry-blue',
+                    wallOverrides: [{ wallId: 'wall_south', face: 'a', finish: 'library:pantry-tile' }],
+                },
+                wall_north: {
+                    faceRegions: [{ id: 'wainscot', face: 'a', v1: 0.9, finish: 'library:wood' }],
+                },
+            },
+            check: (_result, nodes) => nodes.zone_kitchen.wallMaterial === wallMaterial
+                ? []
+                : [`persisted wallMaterial must be ${String(wallMaterial)}`],
+        },
+    })),
+    {
+        name: 'adjacent rooms read independent wall defaults and local paint',
+        tool: 'get_zones',
+        scene: paintedKitchenScene,
+        input: { levelId: 'level_rooms' },
+        expect: {
+            result: {},
+            contains: {
+                zones: [
+                    {
+                        id: 'zone_kitchen',
+                        wallMaterial: 'library:preset-white',
+                        wallOverrides: [{ wallId: 'wall_north', face: 'a', finish: 'library:local-tile' }],
+                    },
+                    {
+                        id: 'zone_pantry',
+                        wallMaterial: 'library:pantry-blue',
+                        wallOverrides: [{ wallId: 'wall_south', face: 'a', finish: 'library:pantry-tile' }],
+                    },
+                ],
+            },
+        },
+    },
     {
         name: 'a floor key no room has is a conflict that says what to choose',
         tool: 'set_zone_intent',
@@ -213,6 +320,20 @@ export const ROOM_CASES = [
             check: holds({ zone: 1, wall: 4 }),
         },
     },
+    {
+        name: 'a turn in degrees: half a turn about its centre, then moved',
+        tool: 'move_zone',
+        scene: kitchenScene,
+        input: { zoneId: 'zone_kitchen', rotate: { angle: '180°' }, translate: [10, 0] },
+        expect: {
+            result: { zoneId: 'zone_kitchen' },
+            check: (_result, nodes) => {
+                const wall = nodes.wall_south;
+                const off = [...wall.start, ...wall.end].some((value, i) => Math.abs(value - [18, 4, 10, 4][i]) > 1e-9);
+                return off ? [`wall_south runs ${wall.start} → ${wall.end}, not 18,4 → 10,4`] : [];
+            },
+        },
+    },
     {
         name: 'duplicates a room, its ceiling lamp hung on the copy’s ceiling',
         tool: 'duplicate_zone',
@@ -313,6 +434,13 @@ export const ROOM_CASES = [
         input: { zoneId: 'zone_kitchen', patch: { thickness: 0.3 } },
         expect: { result: {}, after: { [plateId]: { thickness: 0.3 } } },
     },
+    {
+        name: 'a slab thickness in feet, as the person said it',
+        tool: 'set_room_floor_construction',
+        scene: kitchenScene,
+        input: { zoneId: 'zone_kitchen', patch: { thickness: '1 ft' } },
+        expect: { result: {}, after: { [plateId]: { thickness: 0.3048 } } },
+    },
     {
         name: 'sets a footprint reference datum',
         tool: 'rebase_floor_reference',
@@ -320,6 +448,13 @@ export const ROOM_CASES = [
         input: { slabId: plateId, referenceFloorElevation: 0.2 },
         expect: { result: {}, after: { [plateId]: { referenceFloorElevation: 0.2 } } },
     },
+    {
+        name: 'a reference datum in inches',
+        tool: 'rebase_floor_reference',
+        scene: kitchenScene,
+        input: { slabId: plateId, referenceFloorElevation: '8 in' },
+        expect: { result: {}, after: { [plateId]: { referenceFloorElevation: 0.2032 } } },
+    },
     {
         name: 'adds a mezzanine over part of a room',
         tool: 'create_mezzanine',

package/dist/agent-operations/__fixtures__/scene-check-cases.d.ts

@@ -0,0 +1,4 @@
+import type { AgentToolCase } from './cases.js';
+export declare const VALIDATE_SCENE_CASES: AgentToolCase[];
+export declare const CHECK_ROOMS_CASES: AgentToolCase[];
+//# sourceMappingURL=scene-check-cases.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scene-check-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/scene-check-cases.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,SAAS,CAAA;AA+GxD,eAAO,MAAM,oBAAoB,EAAE,aAAa,EAgQ/C,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,aAAa,EA6T5C,CAAA"}

package/dist/agent-operations/__fixtures__/scene-check-cases.js

@@ -0,0 +1,417 @@
+import { CeilingNode, DoorNode, ItemNode, SeparatorNode, SiteNode, SlabNode, StairNode, StairSegmentNode, WallNode, ZoneNode, } from '../../schema/index.js';
+import { building, level, ROOM, room, scene, stairOn } from './verify-scene-cases.js';
+/** A closed ring of walls on a level, with a door so the level has one. */
+function wallRing(levelId, tag, ring, open = false) {
+    const walls = (open ? ring.slice(0, -1) : ring).map((start, i) => WallNode.parse({
+        id: `wall_${tag}_${i}`,
+        parentId: levelId,
+        start,
+        end: ring[(i + 1) % ring.length],
+        height: 2.5,
+    }));
+    const host = walls[0];
+    const door = DoorNode.parse({
+        id: `door_${tag}`,
+        parentId: host.id,
+        wallId: host.id,
+        position: [1, 1.05, 0],
+    });
+    return [...walls, door];
+}
+const rect = (x0, z0, x1, z1) => [
+    [x0, z0],
+    [x1, z0],
+    [x1, z1],
+    [x0, z1],
+];
+const roomZone = (id, levelId, name, polygon, extra = {}) => ZoneNode.parse({ id, parentId: levelId, name, polygon, spaceRole: 'room', ...extra });
+const ground = (...nodes) => scene(building(), level('level_0', 0), ...nodes);
+/** A finished room on the ground floor: its walls, a door, its room zone, floor and ceiling. */
+const finished = (tag, name, ring = ROOM) => [
+    ...wallRing('level_0', tag, ring),
+    roomZone(`zone_${tag}`, 'level_0', name, ring),
+    SlabNode.parse({ id: `slab_${tag}`, parentId: 'level_0', polygon: ring }),
+    CeilingNode.parse({ id: `ceiling_${tag}`, parentId: 'level_0', polygon: ring }),
+];
+const living = () => finished('living', 'Living');
+/** A finished storey, but nodes as a stored scene may hold them: rejected by their schema. */
+const withNodes = (...extra) => ({
+    nodes: {
+        ...ground(...room('level_0', 'ground')).nodes,
+        ...Object.fromEntries(extra.map((node) => [node.id, node])),
+    },
+    rootNodeIds: ['building_main'],
+});
+/** A node of a plugin's kind no schema here knows. */
+const pluginNode = (id, type) => ({
+    object: 'node',
+    id,
+    type,
+    parentId: 'level_0',
+    visible: true,
+    metadata: {},
+});
+const badZone = (id, fields) => ({
+    ...ZoneNode.parse({ id, parentId: 'level_0', name: 'Patio', polygon: rect(10, 0, 12, 2) }),
+    ...fields,
+});
+const verify = (name, build, expect) => ({
+    name,
+    tool: 'verify_scene',
+    scene: build,
+    input: {},
+    ...(expect.surfaces && { surfaces: expect.surfaces }),
+    expect: {
+        result: expect.result ?? {},
+        ...(expect.contains && { contains: { issues: expect.contains } }),
+        ...(expect.lacks && { lacks: { issues: expect.lacks } }),
+        ...(expect.mentions && { mentions: expect.mentions }),
+        ...(expect.check && { check: (result) => expect.check(result) }),
+    },
+});
+const issuesOf = (result, type) => result.issues.filter((issue) => issue.type === type);
+export const VALIDATE_SCENE_CASES = [
+    verify('validate_scene {} on a valid scene ({ valid: true, errors: [], warnings: [] }): valid, no schema_invalid, no site_hidden', () => ground(...room('level_0', 'ground')), {
+        result: { valid: true, hasIssues: false },
+        lacks: [{ type: 'schema_invalid' }, { type: 'site_hidden' }],
+    }),
+    verify("validate_scene {} with a hidden site (valid, a warning on the site's visible): valid, site_hidden (info) on the site, the scene still clean", () => {
+        const site = SiteNode.parse({ id: 'site_lot', visible: false });
+        return { nodes: { [site.id]: site }, rootNodeIds: [site.id] };
+    }, {
+        result: { valid: true, hasIssues: false },
+        contains: [{ type: 'site_hidden', nodeId: 'site_lot', severity: 'info' }],
+        mentions: ['stay visible'],
+    }),
+    verify('validate_scene {} with a field its schema rejects (valid: false, the error by node and path): valid false, schema_invalid with nodeId and path', () => withNodes(badZone('zone_bad', { color: 5 })), {
+        result: { valid: false, hasIssues: true },
+        contains: [{ type: 'schema_invalid', nodeId: 'zone_bad', path: 'color' }],
+        mentions: ['Schema: zone_bad.color'],
+    }),
+    verify('validate_scene {} on a node with two rejected fields (one error per path): one schema_invalid per path', () => withNodes(badZone('zone_bad', { color: 5, roomNumber: 7 })), {
+        contains: [
+            { type: 'schema_invalid', nodeId: 'zone_bad', path: 'color' },
+            { type: 'schema_invalid', nodeId: 'zone_bad', path: 'roomNumber' },
+        ],
+    }),
+    verify('validate_scene {} with seven rejected nodes (all seven listed): all seven schema_invalid, where verify_scene listed five', () => withNodes(...Array.from({ length: 7 }, (_, i) => badZone(`zone_bad${i}`, { color: i }))), {
+        result: { valid: false },
+        check: (result) => {
+            const ids = issuesOf(result, 'schema_invalid').map((issue) => issue.nodeId);
+            const expected = Array.from({ length: 7 }, (_, i) => `zone_bad${i}`);
+            return expected.every((id) => ids.includes(id)) && ids.length === 7
+                ? []
+                : [`schema_invalid on ${ids.join(', ')}, not one on each of the seven zones`];
+        },
+    }),
+    // A plugin's node on a surface without the plugin: method.ts calls these expected, so they are
+    // named once per kind, as info, where validate_scene listed zod's whole list of kinds per node.
+    verify('validate_scene {} with a node of no known kind (its type rejected): schema_unknown_kind (info) names the kind and the node, and the scene stays valid', () => withNodes(pluginNode('gadget_odd', 'gadget')), {
+        result: { valid: true, hasIssues: false },
+        contains: [
+            {
+                type: 'schema_unknown_kind',
+                severity: 'info',
+                kind: 'gadget',
+                count: 1,
+                nodeIds: ['gadget_odd'],
+            },
+        ],
+        lacks: [{ type: 'schema_invalid' }],
+    }),
+    verify("validate_scene {} with 300 nodes of a plugin's kind (300 errors of the whole list of kinds): one schema_unknown_kind with the count and five ids, the answer small", () => withNodes(...Array.from({ length: 300 }, (_, i) => pluginNode(`beam_${i}`, 'acme:beam'))), {
+        result: { valid: true, hasIssues: false },
+        contains: [{ type: 'schema_unknown_kind', kind: 'acme:beam', count: 300 }],
+        check: (result) => {
+            const found = issuesOf(result, 'schema_unknown_kind');
+            const size = JSON.stringify(result).length;
+            return [
+                ...(found.length === 1 && found[0].nodeIds.length === 5
+                    ? []
+                    : [`${found.length} schema_unknown_kind, not one naming five of the nodes`]),
+                ...(size < 8_000 ? [] : [`the answer is ${size} bytes`]),
+            ];
+        },
+    }),
+    verify('validate_scene {} with a node whose type is empty (its type rejected): schema_invalid on it, no kind of that name', () => withNodes(pluginNode('wall_garbage', '')), {
+        result: { valid: false },
+        contains: [{ type: 'schema_invalid', nodeId: 'wall_garbage' }],
+        lacks: [{ type: 'schema_unknown_kind' }],
+    }),
+    verify("validate_scene {} with malformed geometry (a zone's polygon, a wall's start null): every error, the other checks reading around those nodes", () => {
+        const graph = withNodes(badZone('zone_bad', { polygon: null }));
+        const wall = graph.nodes.wall_ground;
+        graph.nodes.wall_ground = { ...wall, start: null };
+        return graph;
+    }, {
+        result: { valid: false, hasIssues: true },
+        contains: [
+            { type: 'schema_invalid', nodeId: 'zone_bad', path: 'polygon' },
+            { type: 'schema_invalid', nodeId: 'wall_ground', path: 'start' },
+        ],
+    }),
+    verify("validate_scene {} with a hidden site its schema rejects (the error and the hidden site's warning): schema_invalid and site_hidden on the site", () => {
+        const site = { ...SiteNode.parse({ id: 'site_lot', visible: false }), children: null };
+        return { nodes: { [site.id]: site }, rootNodeIds: [site.id] };
+    }, {
+        result: { valid: false },
+        contains: [
+            { type: 'schema_invalid', nodeId: 'site_lot', path: 'children' },
+            { type: 'site_hidden', nodeId: 'site_lot' },
+        ],
+    }),
+    verify('validate_scene {} on a level stored with no children, which its schema fills (valid): valid, the level read with none', () => {
+        const graph = ground();
+        const { children: _, ...stored } = graph.nodes.level_0;
+        graph.nodes.level_0 = stored;
+        return graph;
+    }, { result: { valid: true, levels: [{ levelId: 'level_0' }] } }),
+    // Measured around a wall it could not read, the room would read open, its door off its wall and
+    // the level with no door: the level waits for the fix.
+    verify("validate_scene {} with a finished room's wall its schema rejects (the error alone): schema_invalid on the wall, the level unread, no finding read around it", () => {
+        const graph = ground(...living());
+        graph.nodes.wall_living_0 = { ...graph.nodes.wall_living_0, thickness: 'thick' };
+        return graph;
+    }, {
+        result: { valid: false, levels: [{ levelId: 'level_0', unread: ['wall_living_0'] }] },
+        contains: [{ type: 'schema_invalid', nodeId: 'wall_living_0', path: 'thickness' }],
+        lacks: [
+            { type: 'room_not_enclosed' },
+            { type: 'space_no_room' },
+            { type: 'opening_not_on_wall' },
+            { type: 'walls_no_doors' },
+            { type: 'wall_open_end' },
+        ],
+    }),
+    verify("validate_scene {} with the wall a fridge stands against rejected by its schema (the error alone): no item_mid_room read around it", () => {
+        const graph = withNodes(ItemNode.parse({
+            id: 'item_fridge',
+            parentId: 'level_0',
+            position: [3.6, 0, 1.5],
+            asset: {
+                id: 'fridge',
+                name: 'fridge',
+                category: 'furniture',
+                thumbnail: '/items/fridge/thumbnail.webp',
+                src: '/items/fridge/model.glb',
+                dimensions: [0.7, 1.8, 0.72],
+            },
+        }));
+        graph.nodes.wall_ground_1 = { ...graph.nodes.wall_ground_1, thickness: 'thick' };
+        return graph;
+    }, {
+        result: { valid: false, levels: [{ levelId: 'level_0', unread: ['wall_ground_1'] }] },
+        lacks: [{ type: 'item_mid_room' }],
+    }),
+    verify("validate_scene {} with the slab a stair arrives on rejected by its schema (the error alone): no stair finding read around it", () => {
+        const graph = scene(building(), level('level_0', 0), level('level_1', 1), StairNode.parse({
+            id: 'stair_main',
+            parentId: 'level_0',
+            fromLevelId: 'level_0',
+            toLevelId: 'level_1',
+            position: [2, 0, 0],
+            slabOpeningMode: 'destination',
+        }), StairSegmentNode.parse({
+            id: 'sseg_main',
+            parentId: 'stair_main',
+            height: 3.8,
+            length: 5,
+            stepCount: 20,
+        }), SlabNode.parse({
+            id: 'slab_upper',
+            parentId: 'level_1',
+            polygon: rect(-2, -2, 8, 8),
+            plateRole: 'base',
+            elevation: 1,
+        }));
+        graph.nodes.slab_upper = { ...graph.nodes.slab_upper, thickness: 'thick' };
+        return graph;
+    }, {
+        result: { valid: false },
+        check: (result) => {
+            const stairs = result.issues.filter((issue) => issue.type.startsWith('stair_'));
+            return stairs.length === 0 ? [] : [`stair findings ${stairs.map((issue) => issue.type)}`];
+        },
+    }),
+    verify('validate_scene {} with a storey its schema rejects, the one stair on it (the error alone): schema_invalid on the level, no missing_stair read around it', () => {
+        const graph = scene(building(), level('level_0', 0), level('level_1', 1), level('level_2', 2), ...room('level_0', 'ground'), ...room('level_1', 'first'), ...room('level_2', 'second'), ...stairOn('level_0'));
+        graph.nodes.level_0 = { ...graph.nodes.level_0, height: 'tall' };
+        return graph;
+    }, {
+        result: { valid: false },
+        contains: [{ type: 'schema_invalid', nodeId: 'level_0', path: 'height' }],
+        lacks: [{ type: 'missing_stair' }],
+    }),
+];
+export const CHECK_ROOMS_CASES = [
+    verify('check_rooms { levelId } counts ("4 walls, 1 detected spaces, 1 zones"): the level\'s content.walls, spaces and content.zones', () => ground(...living()), {
+        result: {
+            hasIssues: false,
+            levels: [{ levelId: 'level_0', content: { walls: 4, zones: 1 }, spaces: 1 }],
+        },
+        lacks: [
+            { type: 'space_no_room' },
+            { type: 'space_many_rooms' },
+            { type: 'room_not_enclosed' },
+            { type: 'room_unnamed' },
+        ],
+    }),
+    verify('check_rooms { levelId } on a space two drawn zones split beside the room the walls gave it ("space … : Room 1 + Kitchen + Dining"): space_many_rooms with the three zones', () => ground(...wallRing('level_0', 'plan', ROOM), roomZone('zone_room1', 'level_0', 'Room 1', ROOM, { autoFromWalls: true }), ZoneNode.parse({
+        id: 'zone_kitchen',
+        parentId: 'level_0',
+        name: 'Kitchen',
+        polygon: rect(0, 0, 2, 3),
+    }), ZoneNode.parse({
+        id: 'zone_dining',
+        parentId: 'level_0',
+        name: 'Dining',
+        polygon: rect(2, 0, 4, 3),
+    })), {
+        result: { hasIssues: true, levels: [{ levelId: 'level_0', spaces: 1 }] },
+        contains: [{ type: 'space_many_rooms', levelId: 'level_0' }],
+        check: (result) => {
+            const found = issuesOf(result, 'space_many_rooms');
+            const ids = (found[0]?.zoneIds ?? []);
+            return found.length === 1 &&
+                ids.length === 3 &&
+                ids.includes('zone_kitchen') &&
+                ids.includes('zone_dining')
+                ? []
+                : [`${found.length} space_many_rooms over ${ids.join(', ')}: one, over the three zones`];
+        },
+    }),
+    verify('check_rooms { levelId } on a room drawn inside the room the walls gave a space, its twin ("space … : Room 1 + Kitchen"): space_many_rooms with both', () => ground(...wallRing('level_0', 'twin', ROOM), roomZone('zone_room1', 'level_0', 'Room 1', ROOM, { autoFromWalls: true }), roomZone('zone_kitchen', 'level_0', 'Kitchen', rect(0.5, 0.5, 3.5, 2.5))), {
+        contains: [{ type: 'space_many_rooms', levelId: 'level_0' }],
+        check: (result) => {
+            const ids = (issuesOf(result, 'space_many_rooms')[0]?.zoneIds ?? []);
+            return ids.length === 2 && ids.includes('zone_kitchen')
+                ? []
+                : [`space_many_rooms over ${ids.join(', ')}: the room and its twin`];
+        },
+    }),
+    verify('zones no room inside a room (areas no walls bound, an open-air study) do not split the space', () => ground(...living(), ZoneNode.parse({
+        id: 'zone_daylight',
+        parentId: 'level_0',
+        name: 'Daylight study',
+        polygon: rect(1, 1, 3, 2),
+        hasFloor: false,
+        hasCeiling: false,
+    }), ZoneNode.parse({
+        id: 'zone_reading',
+        parentId: 'level_0',
+        name: 'Reading area',
+        polygon: rect(1, 1.2, 2, 2.2),
+    })), { lacks: [{ type: 'space_many_rooms' }] }),
+    verify('a mezzanine over its room does not split the space', () => ground(...living(), roomZone('zone_mezzanine', 'level_0', 'Mezzanine', rect(0, 0, 2, 3), {
+        floor: { support: 'open', elevation: 1.4 },
+    })), { lacks: [{ type: 'space_many_rooms' }] }),
+    // A store (the MCP's, the editor's) numbers a room for every space its walls enclose when it
+    // loads a scene, and the reconciler after every edit, so a space with no zone is a graph read as
+    // stored or a level mid-edit: these run on the core runner, which reads the graph as declared.
+    verify('check_rooms { levelId } on a space the walls enclose with no zone ("space … NO ZONE"): space_no_room with the level, its walls, area and a point in it', () => ground(...wallRing('level_0', 'bare', ROOM)), {
+        surfaces: ['core'],
+        result: { hasIssues: true, levels: [{ levelId: 'level_0', spaces: 1 }] },
+        contains: [{ type: 'space_no_room', levelId: 'level_0' }],
+        check: (result) => {
+            const [found] = issuesOf(result, 'space_no_room');
+            const walls = ['wall_bare_0', 'wall_bare_1', 'wall_bare_2', 'wall_bare_3'];
+            const [x, z] = found.at;
+            return [
+                ...([...found.wallIds].sort().join() === walls.join()
+                    ? []
+                    : [`walls ${found.wallIds}, not ${walls}`]),
+                ...(found.area > 10 && found.area <= 12
+                    ? []
+                    : [`area ${found.area} m², not the 4 × 3 m room inside its walls`]),
+                ...(x > 0 && x < 4 && z > 0 && z < 3 ? [] : [`(${x}, ${z}) is outside the space`]),
+            ];
+        },
+    }),
+    verify('check_rooms { levelId } on a room a new wall split in two, its zone over one half ("space … NO ZONE" for the other): space_no_room on the uncovered half only', () => ground(...wallRing('level_0', 'hall', rect(0, 0, 6, 3)), WallNode.parse({ id: 'wall_split', parentId: 'level_0', start: [3, 0], end: [3, 3] }), roomZone('zone_west', 'level_0', 'Study', rect(0, 0, 3, 3))), {
+        surfaces: ['core'],
+        result: { levels: [{ levelId: 'level_0', spaces: 2 }] },
+        check: (result) => {
+            const found = issuesOf(result, 'space_no_room');
+            const [x] = (found[0]?.at ?? [0, 0]);
+            return found.length === 1 && x > 3
+                ? []
+                : [`${found.length} space_no_room, the first at x ${x}: one, east of the new wall`];
+        },
+    }),
+    verify('check_rooms { levelId } on a zone its walls do not close ("zone … walls do not close around it"): room_not_enclosed on the room', () => ground(...wallRing('level_0', 'open', ROOM, true), roomZone('zone_open', 'level_0', 'Kitchen', ROOM)), {
+        result: { hasIssues: true, levels: [{ levelId: 'level_0', spaces: 0 }] },
+        contains: [{ type: 'room_not_enclosed', levelId: 'level_0', zoneId: 'zone_open' }],
+        mentions: ['Kitchen'],
+    }),
+    verify('check_rooms { levelId } on a zone named Room ("zone "Room" … unnamed"): room_unnamed (info) on the room', () => ground(...finished('placeholder', 'Room')), {
+        result: { hasIssues: false },
+        contains: [
+            { type: 'room_unnamed', levelId: 'level_0', zoneId: 'zone_placeholder', severity: 'info' },
+        ],
+    }),
+    verify('check_rooms { levelId } on a zone with a blank name ("zone "" … unnamed"): room_unnamed on the room', () => ground(...finished('blank', ' ')), { contains: [{ type: 'room_unnamed', zoneId: 'zone_blank' }] }),
+    verify('check_rooms { levelId } on an upper storey: verify_scene reads every level, the finding names its level', () => scene(building(), level('level_0', 0), level('level_1', 1), ...living(), ...wallRing('level_1', 'loft', ROOM, true), roomZone('zone_loft', 'level_1', 'Loft', ROOM)), {
+        contains: [{ type: 'room_not_enclosed', levelId: 'level_1', zoneId: 'zone_loft' }],
+        lacks: [{ type: 'room_not_enclosed', levelId: 'level_0' }],
+    }),
+    verify('check_rooms { levelId } on a room the reconciler opened when a wall went ("… walls do not close around it"): room_not_enclosed', () => ground(...wallRing('level_0', 'gone', ROOM, true), roomZone('zone_gone', 'level_0', 'Kitchen', ROOM, {
+        autoFromWalls: true,
+        enclosureStatus: 'open',
+    })), { contains: [{ type: 'room_not_enclosed', zoneId: 'zone_gone' }] }),
+    verify('check_rooms { levelId } on a zone three walls bound, left generic as set_zone draws one no room adopts ("… walls do not close around it"): room_not_enclosed, info, as it may be a courtyard', () => ground(...wallRing('level_0', 'drawn', ROOM, true), ZoneNode.parse({ id: 'zone_drawn', parentId: 'level_0', name: 'Kitchen', polygon: ROOM })), {
+        contains: [{ type: 'room_not_enclosed', zoneId: 'zone_drawn', severity: 'info' }],
+        mentions: ['a room missing a wall or a courtyard'],
+    }),
+    verify('check_rooms { levelId } on such a zone named Zone ("… walls do not close around it unnamed"): room_not_enclosed and room_unnamed', () => ground(...wallRing('level_0', 'drawn', ROOM, true), ZoneNode.parse({ id: 'zone_drawn', parentId: 'level_0', name: 'Zone', polygon: ROOM })), {
+        contains: [
+            { type: 'room_not_enclosed', zoneId: 'zone_drawn' },
+            { type: 'room_unnamed', zoneId: 'zone_drawn' },
+        ],
+    }),
+    // What check_rooms called open or unnamed and Pascal does not: a terrace closes with
+    // separators; a person can declare a room open; a zone no walls bound (a garden, a site or
+    // analysis area, one along a single house wall) is no room.
+    verify('a terrace closed by separators, no walls of its own, is enclosed', () => ground(...living(), ...rect(6, 0, 9, 3).map((start, i, ring) => SeparatorNode.parse({
+        id: `separator_terrace_${i}`,
+        parentId: 'level_0',
+        start,
+        end: ring[(i + 1) % ring.length],
+    })), roomZone('zone_terrace', 'level_0', 'Terrace', rect(6, 0, 9, 3), { hasCeiling: false })), { lacks: [{ type: 'room_not_enclosed' }, { type: 'space_no_room' }] }),
+    verify('a room declared open, and zones no walls bound, need no walls', () => ground(...living(), roomZone('zone_porch', 'level_0', 'Porch', rect(0, -2, 4, 0), {
+        enclosureStatus: 'open',
+    }), ZoneNode.parse({
+        id: 'zone_garden',
+        parentId: 'level_0',
+        name: 'Zone',
+        polygon: rect(6, 0, 10, 4),
+    }), ZoneNode.parse({
+        id: 'zone_yard',
+        parentId: 'level_0',
+        name: 'Yard',
+        polygon: rect(0, 3, 4, 7),
+    })), { lacks: [{ type: 'room_not_enclosed' }, { type: 'room_unnamed' }] }),
+    verify("a courtyard the house's rooms bound on three sides is no defect: room_not_enclosed on it is info, and the scene clean", () => ground(...finished('west', 'Living', rect(0, 0, 3, 5)), ...finished('east', 'Kitchen', rect(7, 0, 10, 5)), ...finished('north', 'Hall', rect(3, -3, 7, 0)), ZoneNode.parse({
+        id: 'zone_court',
+        parentId: 'level_0',
+        name: 'Courtyard',
+        polygon: rect(3, 0, 7, 5),
+    })), {
+        result: { hasIssues: false },
+        contains: [{ type: 'room_not_enclosed', zoneId: 'zone_court', severity: 'info' }],
+    }),
+    verify('a courtyard behind 0.6 m garden walls is no room', () => {
+        const court = rect(6, 0, 10, 3);
+        return ground(...living(), ...court.slice(0, -1).map((start, i) => WallNode.parse({
+            id: `wall_garden_${i}`,
+            parentId: 'level_0',
+            start,
+            end: court[i + 1],
+            height: 0.6,
+        })), ZoneNode.parse({
+            id: 'zone_court',
+            parentId: 'level_0',
+            name: 'Courtyard',
+            polygon: court,
+        }));
+    }, { lacks: [{ type: 'room_not_enclosed' }] }),
+];

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

@@ -1 +1 @@
-{"version":3,"file":"search-assets-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/search-assets-cases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,SAAS,CAAA;AA2BxD,eAAO,MAAM,OAAO,EAAE,UAAU,EAM/B,CAAA;AAKD,eAAO,MAAM,mBAAmB,EAAE,aAAa,EA+G9C,CAAA"}
+{"version":3,"file":"search-assets-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/search-assets-cases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,SAAS,CAAA;AA2BxD,eAAO,MAAM,OAAO,EAAE,UAAU,EAM/B,CAAA;AAKD,eAAO,MAAM,mBAAmB,EAAE,aAAa,EA2H9C,CAAA"}

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

@@ -52,6 +52,18 @@ export const SEARCH_ASSETS_CASES = [
             },
         },
     },
+    {
+        name: 'a search that finds something says nothing of other sources',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'sofa' }] },
+        context: library,
+        expect: {
+            result: { total: 1 },
+            absent: ['hint'],
+            check: (result) => (JSON.stringify(result).includes('add_object') ? ['names add_object'] : []),
+        },
+    },
     {
         name: 'every word of a query must match',
         tool: 'search_assets',
@@ -98,7 +110,7 @@ export const SEARCH_ASSETS_CASES = [
         },
     },
     {
-        name: 'a fixture the library lacks points to add_object, not to a design of its own',
+        name: 'a fixture the library lacks names the other sources there are, as a fact',
         tool: 'search_assets',
         scene: noScene,
         input: { queries: [{ query: 'wall light' }] },
@@ -107,7 +119,7 @@ export const SEARCH_ASSETS_CASES = [
             result: {
                 total: 0,
                 groups: [{ query: 'wall light', total: 0, results: [] }],
-                hint: 'Nothing in the library matches "wall light". Build what it lacks with add_object.',
+                hint: 'Nothing in the library matches "wall light". add_object builds an object of any shape and size, place_design places a procedural design.',
             },
         },
     },
@@ -121,7 +133,7 @@ export const SEARCH_ASSETS_CASES = [
             result: {
                 total: 1,
                 groups: [{ total: 1 }, { query: 'gazebo', total: 0 }, { query: 'sconce', total: 0 }],
-                hint: 'Nothing in the library matches "gazebo", "sconce". Build what it lacks with add_object.',
+                hint: 'Nothing in the library matches "gazebo", "sconce". add_object builds an object of any shape and size, place_design places a procedural design.',
             },
         },
     },