@pascal-app/core 1.0.4 → 1.0.6

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

@@ -1,7 +1,9 @@
 import { BuildingNode, DoorNode, ItemNode, LevelNode, WallNode, WindowNode, ZoneNode, } from '../../schema/index.js';
 import { doorFacing } from '../../building/wall-openings.js';
-import { findBlockedDoors } from '../door-clearance.js';
-import { findItemItemCollisions } from '../layout-clearance.js';
+import { area as clippedArea, difference } from '../../lib/polygon-boolean.js';
+import { reconcileSceneStructure } from '../../lib/structure-reconcile.js';
+import { findBlockedDoors, itemNodePlanCorners } from '../door-clearance.js';
+import { findItemItemCollisions, findItemsMidRoom } from '../layout-clearance.js';
 const graph = (...nodes) => ({
     nodes: Object.fromEntries(nodes.map((node) => [node.id, node])),
     rootNodeIds: nodes
@@ -87,6 +89,31 @@ function roomsScene() {
     });
     return graph(building, ground, upper, roof, wallG, door, window, kitchen, wallU);
 }
+/**
+ * Run 6's order: walls drawn first, one add_wall each, round CLEAR (and `extra` inside it), then the
+ * rooms the reconciler made of them, "Room 1" first; `renamed` is a name a person gave it since.
+ */
+function walledScene({ extra = [], renamed } = {}) {
+    return () => {
+        const base = roomsScene().nodes;
+        const walls = [...CLEAR.map((point, i) => [point, CLEAR[(i + 1) % 4]]), ...extra].map(([start, end], i) => WallNode.parse({ id: `wall_c${i}`, parentId: 'level_g', start, end, height: 2.5 }));
+        const level = base.level_g;
+        let nodes = {
+            ...base,
+            level_g: { ...level, children: [...level.children, ...walls.map((wall) => wall.id)] },
+            ...Object.fromEntries(walls.map((wall) => [wall.id, wall])),
+        };
+        const names = { zone: ['zone_walled', 'zone_side'] };
+        let count = 0;
+        nodes = reconcileSceneStructure({
+            nodes,
+            mintId: (kind) => names[kind]?.shift() ?? `${kind}_walled${++count}`,
+        }).nodes;
+        if (renamed)
+            nodes.zone_walled = { ...nodes.zone_walled, name: renamed };
+        return graph(...Object.values(nodes));
+    };
+}
 // ─── Checks the table cannot state: minted ids and derived construction ───────────────────────
 const problems = (...entries) => entries.flatMap(([ok, problem]) => (ok ? [] : [problem]));
 const wallsOn = (nodes, levelId) => Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === levelId);
@@ -141,6 +168,15 @@ function roomBuilt(levelId, name, edges) {
         ]);
     };
 }
+/** The room zones of the ground floor inside CLEAR's box: the one per walled space there. */
+const roomsInClear = (nodes) => Object.values(nodes).filter((node) => node.type === 'zone' &&
+    node.parentId === 'level_g' &&
+    node.spaceRole === 'room' &&
+    node.polygon.every(([x, z]) => x >= -0.01 && x <= 4.01 && z >= 4.99 && z <= 8.01));
+const area = (polygon) => Math.abs(polygon.reduce((sum, [x, z], i) => {
+    const [nx, nz] = polygon[(i + 1) % polygon.length];
+    return sum + x * nz - nx * z;
+}, 0) / 2);
 const roomOn = (levelId) => (result, nodes) => problems([
     nodes[result.zoneId]?.parentId === levelId,
     `the room is on ${String(nodes[result.zoneId]?.parentId)}, not ${levelId}`,
@@ -315,7 +351,7 @@ export const CREATE_ROOM_CASES = [
         },
     },
     {
-        name: "a window sits at add_window's sill height; a door takes its size, hinge, swing and style",
+        name: 'a window is centred on its wall, as add_window places it; a door takes its size, hinge, swing and style',
         tool: 'create_room',
         scene: roomsScene,
         input: room({
@@ -336,11 +372,16 @@ export const CREATE_ROOM_CASES = [
             check: (result, nodes) => {
                 const window = nodes[result.windowIds[0]];
                 const door = nodes[result.doorIds[0]];
+                // Centred on the wall as it stands when the room is made, the storey's 2.8 m: the floor plate
+                // is derived afterwards, and a later add_window sees the slab (a window 2.5 cm lower).
+                const wall = window?.type === 'window' && window.wallId ? nodes[window.wallId] : undefined;
+                const level = wall?.parentId ? nodes[wall.parentId] : undefined;
+                const ceiling = level?.type === 'level' ? (level.height ?? Number.NaN) : Number.NaN;
                 return problems([
                     window?.type === 'window' &&
-                        near(window.position[1] - window.height / 2, 0.9) &&
+                        near(window.position[1], ceiling / 2) &&
                         window.width === 1.5,
-                    `window ${JSON.stringify(window)} is not 1.5 m wide on a 0.9 m sill`,
+                    `window ${JSON.stringify(window)} is not 1.5 m wide and centred on its ${ceiling} m wall`,
                 ], [
                     door?.type === 'door' &&
                         Math.abs(door.width - 0.9144) < 1e-4 &&
@@ -364,7 +405,6 @@ export const CREATE_ROOM_CASES = [
         scene: roomsScene,
         input: room({}),
         context: { activeLevelId: 'level_u' },
-        surfaces: ['core', 'chat'],
         expect: { result: { ok: true }, check: roomOn('level_u') },
     },
     {
@@ -418,6 +458,112 @@ export const CREATE_ROOM_CASES = [
         },
         expect: { refusal: 'outdoor_room_overlap', mentions: ['Kitchen'] },
     },
+    // Run 6: 54 walls drawn first, then 14 create_room calls, each stacking its named zone on the
+    // "Room N" the walls had made: 16 twins.
+    {
+        name: 'a room over walls that already enclose it names the room they made, never a second zone',
+        tool: 'create_room',
+        scene: walledScene(),
+        input: room({ levelId: 'level_g' }),
+        expect: {
+            result: { ok: true, reusedWalls: 4, zoneId: 'zone_walled' },
+            after: { zone_walled: { name: 'Bedroom' } },
+            check: (result, nodes) => [
+                ...roomBuilt('level_g', 'Bedroom', 4)(result, nodes),
+                ...problems([
+                    roomsInClear(nodes).length === 1,
+                    `${roomsInClear(nodes).map((zone) => zone.name).join(', ')} stand over one walled room`,
+                ]),
+            ],
+        },
+    },
+    {
+        name: 'the walled room is named whichever way round and from whichever corner the polygon runs',
+        tool: 'create_room',
+        scene: walledScene(),
+        input: {
+            levelId: 'level_g',
+            name: 'Study',
+            polygon: [
+                [4, 8],
+                [4, 5],
+                [0, 5],
+                [0, 8],
+            ],
+        },
+        expect: {
+            result: { ok: true, zoneId: 'zone_walled' },
+            check: (_, nodes) => problems([
+                roomsInClear(nodes).map((zone) => zone.name).join() === 'Study',
+                `${roomsInClear(nodes).map((zone) => zone.name).join(', ')} stand there, not Study alone`,
+            ]),
+        },
+    },
+    {
+        name: 'a polygon over two walled spaces names the one holding most of it; the other keeps its name',
+        tool: 'create_room',
+        scene: walledScene({
+            extra: [
+                [
+                    [3, 5],
+                    [3, 8],
+                ],
+            ],
+        }),
+        input: room({ levelId: 'level_g', name: 'Master Bedroom' }),
+        expect: {
+            result: { ok: true },
+            check: (result, nodes) => {
+                const rooms = roomsInClear(nodes);
+                const master = nodes[result.zoneId];
+                return problems([rooms.length === 2, `${rooms.length} rooms over two walled spaces`], [
+                    master?.name === 'Master Bedroom' && Math.abs(area(master.polygon) - 9) < 0.05,
+                    `the named room is ${master?.name} over ${master && area(master.polygon)} m², not the 9 m² space`,
+                ], [
+                    rooms.some((zone) => /^Room \d+$/.test(zone.name ?? '')),
+                    'the smaller space lost its own name',
+                ]);
+            },
+        },
+    },
+    // A room a person named is never renamed silently, and never twinned: the refusal names it, and
+    // the agent either passes rename: true or asks the person.
+    {
+        name: 'a room a person named is refused with a choice, never twinned or renamed silently',
+        tool: 'create_room',
+        scene: walledScene({ renamed: 'Library' }),
+        input: room({ levelId: 'level_g' }),
+        expect: { refusal: 'room_named_by_person', mentions: ['Library', 'rename: true only if the person asked', 'ask them'] },
+    },
+    {
+        name: 'rename: true names the room a person named, in place, with no second zone',
+        tool: 'create_room',
+        scene: walledScene({ renamed: 'Library' }),
+        input: room({ levelId: 'level_g', rename: true }),
+        expect: {
+            result: { ok: true, zoneId: 'zone_walled' },
+            after: { zone_walled: { name: 'Bedroom' } },
+            check: (_, nodes) => problems([roomsInClear(nodes).length === 1, 'a second zone stands beside the renamed room']),
+        },
+    },
+    {
+        name: 'the same name over a room a person named has nothing to create',
+        tool: 'create_room',
+        scene: walledScene({ renamed: 'Bedroom' }),
+        input: room({ levelId: 'level_g' }),
+        expect: { refusal: 'room_named_by_person', mentions: ['already', 'Bedroom'] },
+    },
+    {
+        name: 'outdoor over a space walls already enclose names that room and drops its ceiling',
+        tool: 'create_room',
+        scene: walledScene(),
+        input: room({ levelId: 'level_g', name: 'Courtyard', outdoor: true }),
+        expect: {
+            result: { ok: true, zoneId: 'zone_walled', ceilingId: null },
+            after: { zone_walled: { name: 'Courtyard', hasCeiling: false } },
+            check: (_, nodes) => problems([roomsInClear(nodes).length === 1, 'the courtyard stands beside its room']),
+        },
+    },
     {
         name: 'a roof level takes no room',
         tool: 'create_room',
@@ -463,32 +609,86 @@ const CATALOG = [
     item('bedside-table', [0.5, 0.5, 0.4]),
     item('dresser', [1.2, 0.8, 0.5]),
     item('closet', [1.5, 2, 0.6]),
+    // The MCP's built-in sizes (asset-catalog.ts).
+    item('sofa', [2.5, 0.8, 1.5]),
+    item('coffee-table', [2, 0.4, 1.5]),
+    item('livingroom-chair', [1.5, 0.8, 1.5]),
+    item('tv-stand', [2, 0.4, 0.5]),
+    item('toilet', [1, 0.9, 1]),
+    item('bathroom-sink', [2, 1, 1.5]),
+    item('shower-square', [1, 2, 1]),
+    item('bathtub', [1.7, 0.6, 0.8]),
+];
+const ROOM_WALLS = ['wall_s', 'wall_e', 'wall_n', 'wall_w'];
+/** A `width` × `depth` m room: walls south (edge 0), east, north (edge 2), west. */
+const roomOutline = (width, depth) => [
+    [0, 0],
+    [width, 0],
+    [width, depth],
+    [0, depth],
+];
+/** A 5 × 4 m bedroom. */
+const BEDROOM = roomOutline(5, 4);
+/** An L: 10 m along the south, 5 m deep, and a 4 × 5 m wing to the north-west. */
+const L_ROOM = [
+    [0, 0],
+    [10, 0],
+    [10, 5],
+    [4, 5],
+    [4, 10],
+    [0, 10],
 ];
-/** A 5 × 4 m bedroom: walls south (edge 0), east, north (edge 2), west; a door where asked. */
-const BEDROOM = [
+/** A U: two 4 m arms, 6 m deep, round a 2 × 4 m notch to the north. */
+const U_ROOM = [
     [0, 0],
-    [5, 0],
-    [5, 4],
-    [0, 4],
+    [10, 0],
+    [10, 10],
+    [6, 10],
+    [6, 6],
+    [4, 6],
+    [4, 10],
+    [0, 10],
 ];
-const BEDROOM_WALLS = ['wall_s', 'wall_e', 'wall_n', 'wall_w'];
-function bedroomScene({ doorOn, desk } = {}) {
+/** A 6√2 × 4√2 m room turned 45°. */
+const DIAMOND_ROOM = [
+    [0, 0],
+    [6, 6],
+    [2, 10],
+    [-4, 4],
+];
+/**
+ * A room of `outline`, a wall on each edge (`wall_s`, `wall_e`, `wall_n`, `wall_w` round a
+ * rectangle, `wall_<edge>` round any other outline) but the `open` ones and a repeated corner's,
+ * a door in the middle of each wall in `doorsOn`, and a desk if asked.
+ */
+function roomScene({ outline = BEDROOM, name = 'Bedroom', doorsOn = [], open = [], desk, } = {}) {
+    const wallIds = outline.map((_, i) => (outline.length === 4 ? ROOM_WALLS[i] : `wall_${i}`));
     return () => {
-        const door = doorOn
-            ? DoorNode.parse({ id: 'door_bed', parentId: doorOn, wallId: doorOn, position: [2.5, 1.05, 0] })
-            : null;
-        const walls = BEDROOM.map((start, i) => WallNode.parse({
-            id: BEDROOM_WALLS[i],
-            parentId: 'level_f',
-            start,
-            end: BEDROOM[(i + 1) % BEDROOM.length],
-            children: door && door.parentId === BEDROOM_WALLS[i] ? [door.id] : [],
-        }));
+        const doors = doorsOn.map((wallId) => {
+            const i = wallIds.indexOf(wallId);
+            const [a, b] = [outline[i], outline[(i + 1) % outline.length]];
+            const middle = Math.hypot(b[0] - a[0], b[1] - a[1]) / 2;
+            return DoorNode.parse({
+                id: `door_${wallId.slice(5)}`,
+                parentId: wallId,
+                wallId,
+                position: [middle, 1.05, 0],
+            });
+        });
+        const walls = outline.flatMap((start, i) => open.includes(wallIds[i]) || `${start}` === `${outline[(i + 1) % outline.length]}`
+            ? []
+            : WallNode.parse({
+                id: wallIds[i],
+                parentId: 'level_f',
+                start,
+                end: outline[(i + 1) % outline.length],
+                children: doors.filter((door) => door.parentId === wallIds[i]).map((door) => door.id),
+            }));
         const zone = ZoneNode.parse({
             id: 'zone_bed',
             parentId: 'level_f',
-            name: 'Bedroom',
-            polygon: BEDROOM,
+            name,
+            polygon: outline,
             spaceRole: 'room',
         });
         // Where the bed would stand against the north wall.
@@ -508,26 +708,54 @@ function bedroomScene({ doorOn, desk } = {}) {
             children: [...walls.map((wall) => wall.id), zone.id, ...(deskItem ? [deskItem.id] : [])],
         });
         const building = BuildingNode.parse({ id: 'building_f', children: [level.id] });
-        return graph(building, level, ...walls, zone, ...(door ? [door] : []), ...(deskItem ? [deskItem] : []));
+        return graph(building, level, ...walls, zone, ...doors, ...(deskItem ? [deskItem] : []));
     };
 }
+/**
+ * The piece's turned footprint inside the room, read by clipping it against the outline (not the
+ * operation's own test): what stands outside, under a square centimetre of rounding.
+ */
+const standsIn = (item, outline) => {
+    const corners = itemNodePlanCorners(item);
+    const [cx, cz] = [0, 1].map((axis) => corners.reduce((sum, c) => sum + c[axis], 0) / 4);
+    // Round the footprint, not across it: itemNodePlanCorners lists its corners by side.
+    const ring = corners.sort((a, b) => Math.atan2(a[1] - cz, a[0] - cx) - Math.atan2(b[1] - cz, b[0] - cx));
+    return clippedArea(difference(ring, outline)) < 1e-4;
+};
 const furnished = (result, nodes) => {
     const items = Object.values(nodes);
     const itemIds = result.itemIds;
     return problems([itemIds.length > 0, 'nothing placed'], [
         itemIds.every((id) => nodes[id]?.type === 'item' && nodes[id]?.parentId === 'level_f'),
         'an item is not on the room level',
-    ], [findBlockedDoors({ nodes: items }).length === 0, 'an item blocks a door'], [findItemItemCollisions({ nodes: items }).length === 0, 'two items overlap']);
+    ], [findBlockedDoors({ nodes: items }).length === 0, 'an item blocks a door'], [findItemItemCollisions({ nodes: items }).length === 0, 'two items overlap'], [
+        findItemsMidRoom({ nodes: items, levelId: 'level_f' }).length === 0,
+        'a wall-bound piece stands in the middle of the room',
+    ], [
+        itemIds.every((id) => {
+            const [item, zone] = [nodes[id], nodes.zone_bed];
+            return (item?.type === 'item' && zone?.type === 'zone' && standsIn(item, zone.polygon));
+        }),
+        'an item stands outside the room',
+    ]);
 };
-const bedPosition = (nodes) => {
-    const bed = Object.values(nodes).find((node) => node.type === 'item' && node.asset.id === 'double-bed');
-    return bed?.type === 'item' ? bed.position : null;
+/** Where the piece of `assetId` stands, null when it was not placed. */
+const positionOf = (nodes, assetId) => {
+    const piece = Object.values(nodes).find((node) => node.type === 'item' && node.asset.id === assetId);
+    return piece?.type === 'item' ? piece.position : null;
+};
+const bedPosition = (nodes) => positionOf(nodes, 'double-bed');
+/** The sofa and the TV placed, the coffee table and the TV straight across from the sofa. */
+const livingGroupKept = (nodes) => {
+    const [sofa, table, tv] = ['sofa', 'coffee-table', 'tv-stand'].map((id) => positionOf(nodes, id));
+    const across = (piece) => !!sofa && !!piece && Math.abs(piece[0] - sofa[0]) < 0.01;
+    return problems([sofa !== null, 'the sofa was skipped'], [tv !== null, 'the TV stand was skipped'], [across(table) && across(tv), 'the coffee table and the TV are not across from the sofa']);
 };
 export const FURNISH_ROOM_CASES = [
     {
         name: 'a room named by its zone: its level and outline; the bed faces the door from the far wall',
         tool: 'furnish_room',
-        scene: bedroomScene({ doorOn: 'wall_s' }),
+        scene: roomScene({ doorsOn: ['wall_s'] }),
         input: { zoneId: 'zone_bed', roomType: 'bedroom' },
         context: { catalog: CATALOG },
         expect: {
@@ -541,7 +769,7 @@ export const FURNISH_ROOM_CASES = [
     {
         name: 'the door it finds sets the furniture wall, whichever edge it is on',
         tool: 'furnish_room',
-        scene: bedroomScene({ doorOn: 'wall_n' }),
+        scene: roomScene({ doorsOn: ['wall_n'] }),
         input: { zoneId: 'zone_bed', roomType: 'bedroom' },
         context: { catalog: CATALOG },
         expect: {
@@ -555,7 +783,7 @@ export const FURNISH_ROOM_CASES = [
     {
         name: 'doorWallIndex names the door wall of a room with no door yet, and keeps it clear',
         tool: 'furnish_room',
-        scene: bedroomScene(),
+        scene: roomScene(),
         input: { zoneId: 'zone_bed', roomType: 'bedroom', doorWallIndex: 1 },
         context: { catalog: CATALOG },
         expect: {
@@ -569,7 +797,7 @@ export const FURNISH_ROOM_CASES = [
     {
         name: 'a polygon instead of a zone, on the lowest storey when no level is named',
         tool: 'furnish_room',
-        scene: bedroomScene({ doorOn: 'wall_s' }),
+        scene: roomScene({ doorsOn: ['wall_s'] }),
         input: { polygon: BEDROOM, roomType: 'bedroom' },
         context: { catalog: CATALOG },
         expect: { result: { ok: true, doorWallIndex: 0 }, check: furnished },
@@ -577,15 +805,157 @@ export const FURNISH_ROOM_CASES = [
     {
         name: 'an item already in the room is never overlapped',
         tool: 'furnish_room',
-        scene: bedroomScene({ doorOn: 'wall_s', desk: true }),
+        scene: roomScene({ doorsOn: ['wall_s'], desk: true }),
         input: { zoneId: 'zone_bed', roomType: 'bedroom' },
         context: { catalog: CATALOG },
         expect: { result: { ok: true }, check: furnished },
     },
+    {
+        name: 'a door in the sofa wall and in the TV wall: the sofa slides along its wall, the table and the TV with it, nothing into the room',
+        tool: 'furnish_room',
+        scene: roomScene({
+            outline: roomOutline(7, 4.5),
+            name: 'Living room',
+            doorsOn: ['wall_s', 'wall_n'],
+        }),
+        input: { zoneId: 'zone_bed', roomType: 'living' },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, doorWallIndex: 0, doorsDetected: 2 },
+            check: (result, nodes) => [...furnished(result, nodes), ...livingGroupKept(nodes)],
+        },
+    },
+    {
+        name: 'a skip names the other sources, and a set with no skip does not',
+        tool: 'furnish_room',
+        scene: roomScene({
+            outline: roomOutline(7, 4.5),
+            name: 'Living room',
+            open: ['wall_s', 'wall_e', 'wall_w'],
+        }),
+        input: { zoneId: 'zone_bed', roomType: 'living', doorWallIndex: 0 },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true },
+            check: (result) => problems([result.skipped.length > 0, 'nothing was skipped: no case here'], [
+                String(result.message).includes('For what was skipped: add_object builds an object of any shape and size'),
+                'a skip does not name the sources',
+            ]),
+        },
+    },
+    {
+        name: 'every piece placed comes with its name, size and id',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: roomOutline(7, 4.5), name: 'Living room', doorsOn: ['wall_s'] }),
+        input: { zoneId: 'zone_bed', roomType: 'living' },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, skipped: [] },
+            mentions: ['sofa (2.5 × 1.5 m): item_'],
+            check: (result) => {
+                const pieces = result.pieces;
+                const ids = result.itemIds;
+                return problems([pieces.length === ids.length && ids.length > 0, 'pieces and ids differ'], [
+                    pieces.every((piece, i) => piece.endsWith(`: ${ids[i]}`) && / \(\d[\d.]* × \d[\d.]* m\): /.test(piece)),
+                    `a piece lacks its size or its id: ${pieces}`,
+                ], [!String(result.message).includes('add_object'), 'a set with no skip names the sources']);
+            },
+        },
+    },
+    {
+        name: 'a wall-bound piece where no wall stands is skipped, and says so: the TV of a living room open to the south',
+        tool: 'furnish_room',
+        scene: roomScene({
+            outline: roomOutline(7, 4.5),
+            name: 'Living room',
+            open: ['wall_s', 'wall_e', 'wall_w'],
+        }),
+        input: { zoneId: 'zone_bed', roomType: 'living', doorWallIndex: 0 },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true },
+            mentions: ['tv-stand (2 × 0.5 m): no wall to stand against there'],
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([positionOf(nodes, 'sofa') !== null, 'the sofa was skipped']),
+            ],
+        },
+    },
+    {
+        name: 'an L-shaped bedroom: nothing lands in the corner the L leaves out',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: L_ROOM, doorsOn: ['wall_0'] }),
+        input: { zoneId: 'zone_bed', roomType: 'bedroom' },
+        context: { catalog: CATALOG },
+        expect: { result: { ok: true, doorWallIndex: 0 }, check: furnished },
+    },
+    {
+        name: 'an outline drawn closed (its first corner repeated) is the same room: the closet stands against its far wall',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: [...roomOutline(6, 4), [0, 0]], name: 'Storage' }),
+        input: { zoneId: 'zone_bed', roomType: 'storage', doorWallIndex: 0 },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, placed: 1 },
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([
+                    (positionOf(nodes, 'closet')?.[2] ?? 0) > 3,
+                    'the closet is not against the far wall',
+                ]),
+            ],
+        },
+    },
+    {
+        name: 'a U-shaped room: nothing stands in the notch between its arms, though its corners touch the outline',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: U_ROOM, name: 'Dining room' }),
+        input: { zoneId: 'zone_bed', roomType: 'dining', doorWallIndex: 0 },
+        context: {
+            catalog: [
+                ...CATALOG,
+                item('dining-table', [2, 0.75, 4]),
+                item('dining-chair', [0.5, 0.9, 0.5]),
+            ],
+        },
+        expect: {
+            result: { ok: true },
+            mentions: ['dining-table (2 × 4 m): outside the room'],
+            check: furnished,
+        },
+    },
+    {
+        name: 'a room turned 45°: the closet stands inside it, against a wall',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: DIAMOND_ROOM, name: 'Storage', doorsOn: [] }),
+        input: { zoneId: 'zone_bed', roomType: 'storage', doorWallIndex: 0 },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true, placed: 1 },
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([positionOf(nodes, 'closet') !== null, 'the closet was skipped']),
+            ],
+        },
+    },
+    {
+        name: 'a bathroom under 6.5 m², which takes a shower and no tub: the shower stands against a wall, not in the middle',
+        tool: 'furnish_room',
+        scene: roomScene({ outline: roomOutline(2.4, 2.6), name: 'Bathroom', doorsOn: ['wall_s'] }),
+        input: { zoneId: 'zone_bed', roomType: 'bathroom' },
+        context: { catalog: CATALOG },
+        expect: {
+            result: { ok: true },
+            check: (result, nodes) => [
+                ...furnished(result, nodes),
+                ...problems([positionOf(nodes, 'shower-square') !== null, 'the shower was skipped'], [positionOf(nodes, 'bathtub') === null, 'a tub was placed']),
+            ],
+        },
+    },
     {
         name: 'a piece the catalog lacks is skipped and named',
         tool: 'furnish_room',
-        scene: bedroomScene({ doorOn: 'wall_s' }),
+        scene: roomScene({ doorsOn: ['wall_s'] }),
         input: { zoneId: 'zone_bed', roomType: 'bedroom' },
         context: { catalog: CATALOG.filter((entry) => entry.id !== 'bedside-table') },
         expect: { result: { ok: true }, mentions: ['bedside-table: not in the catalog'] },
@@ -593,7 +963,7 @@ export const FURNISH_ROOM_CASES = [
     {
         name: 'no room named: room_required',
         tool: 'furnish_room',
-        scene: bedroomScene(),
+        scene: roomScene(),
         input: { roomType: 'bedroom' },
         context: { catalog: CATALOG },
         expect: { refusal: 'room_required' },
@@ -601,7 +971,7 @@ export const FURNISH_ROOM_CASES = [
     {
         name: 'a wall id for the room: not_a_zone',
         tool: 'furnish_room',
-        scene: bedroomScene(),
+        scene: roomScene(),
         input: { zoneId: 'wall_s', roomType: 'bedroom' },
         context: { catalog: CATALOG },
         expect: { refusal: 'not_a_zone', mentions: ['wall_s'] },
@@ -609,7 +979,7 @@ export const FURNISH_ROOM_CASES = [
     {
         name: 'a zone id that does not exist: zone_not_found',
         tool: 'furnish_room',
-        scene: bedroomScene(),
+        scene: roomScene(),
         input: { zoneId: 'zone_nope', roomType: 'bedroom' },
         context: { catalog: CATALOG },
         expect: { refusal: 'zone_not_found' },
@@ -627,7 +997,7 @@ export const FURNISH_ROOM_CASES = [
     {
         name: 'a host without a catalog: no_catalog',
         tool: 'furnish_room',
-        scene: bedroomScene(),
+        scene: roomScene(),
         input: { zoneId: 'zone_bed', roomType: 'bedroom' },
         surfaces: ['core', 'chat'],
         expect: { refusal: 'no_catalog' },

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

@@ -1,9 +1,13 @@
 import { type AnyNode, type AssetInput } from '../../schema/index.js';
+import type { AgentContext } from '../types.js';
+import type { SessionRecord } from '../scene-checkpoint.js';
+import type { AssetViewFacts } from '../asset-views.js';
 /**
  * Edge cases of the agent tools that run as core operations, written before the operations. One
  * declarative table per tool; the core, MCP and chat runners each run every table, so the three
- * layers cannot disagree. `surfaces` narrows a case whose setup only one surface has (the chat
- * knows the floor a person is viewing; the MCP has no such thing and falls back to the lowest).
+ * layers cannot disagree. `surfaces` narrows a case whose setup only one surface has (the live
+ * stores close level gaps when a scene loads). `context.activeLevelId` is the floor the host's
+ * person views: the chat's, or an in-page MCP host's; a remote MCP has none, so the lowest storey.
  * `after` lists fields some nodes must have once the operation's changes are applied.
  */
 export type AgentSurface = 'core' | 'mcp' | 'chat';
@@ -16,12 +20,17 @@ export type AgentToolCase = {
     tool: string;
     scene: () => SceneGraph;
     input: Record<string, unknown>;
-    /** `catalog`: the item library the host hands search_assets. */
     context?: {
         activeLevelId?: string | null;
         catalog?: AssetInput[];
+        assetViews?: Record<string, AssetViewFacts>;
+        session?: () => SessionRecord;
+        designBrief?: AgentContext['designBrief'];
+        /** The person's words of the turn, where the host has a person (core and chat; not MCP). */
+        requestText?: string;
     };
     surfaces?: AgentSurface[];
+    readOnly?: boolean;
     expect: {
         refusal: string;
         mentions?: string[];
@@ -36,14 +45,20 @@ export type AgentToolCase = {
         /** Text the result must include. */
         mentions?: string[];
         /** What the table cannot state (minted ids, derived construction): the problems, if any. */
+        session?: (session: SessionRecord) => string[];
         check?: (result: Record<string, unknown>, nodes: Readonly<Record<string, AnyNode>>) => string[];
     };
 };
+/** Base chains are not the room/region finish, nor a promise that a ref renders. */
+export declare function finishReadbackScene(): SceneGraph;
+/** Reject non-finite layout endpoints before JSON can silently turn them into null. */
+export declare function finiteReadbackProblems(value: unknown, path?: string): string[];
 export declare const LIST_LEVELS_CASES: AgentToolCase[];
 export declare const GET_NODE_CASES: AgentToolCase[];
 export declare const LEVEL_TARGET_CASES: AgentToolCase[];
 export declare const GET_WALLS_CASES: AgentToolCase[];
 export declare const GET_ZONES_CASES: AgentToolCase[];
+export declare const FINISH_READBACK_CASES: AgentToolCase[];
 export declare const GET_LEVEL_SUMMARY_CASES: AgentToolCase[];
 export declare const DUPLICATE_LEVEL_CASES: AgentToolCase[];
 export declare const DELETE_NODE_CASES: AgentToolCase[];

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

@@ -1 +1 @@
-{"version":3,"file":"cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/cases.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,UAAU,EAgBhB,MAAM,cAAc,CAAA;AASrB;;;;;;GAMG;AAEH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAA;AAClD,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAElF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,UAAU,CAAA;IACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,gEAAgE;IAChE,OAAO,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,OAAO,CAAC,EAAE,UAAU,EAAE,CAAA;KAAE,CAAA;IACnE,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAA;IACzB,MAAM,EACF;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GACxC;QACE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC/B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;QAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;QAC/C,sFAAsF;QACtF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAA;QACpD,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAA;QACjD,oCAAoC;QACpC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;QACnB,4FAA4F;QAC5F,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,MAAM,EAAE,CAAA;KAChG,CAAA;CACN,CAAA;AAyLD,eAAO,MAAM,iBAAiB,EAAE,aAAa,EA0E5C,CAAA;AAED,eAAO,MAAM,cAAc,EAAE,aAAa,EAgCzC,CAAA;AAID,eAAO,MAAM,kBAAkB,EAAE,aAAa,EAkE7C,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,aAAa,EAkC1C,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,aAAa,EA0B1C,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,aAAa,EA8ElD,CAAA;AAiBD,eAAO,MAAM,qBAAqB,EAAE,aAAa,EAyGhD,CAAA;AAID,eAAO,MAAM,iBAAiB,EAAE,aAAa,EAiE5C,CAAA;AAED,yCAAyC;AACzC,eAAO,MAAM,gBAAgB,EAAE,SAAS,aAAa,EAmBpD,CAAA"}
+{"version":3,"file":"cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/cases.ts"],"names":[],"mappings":"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"}