@pascal-app/core 1.0.4 → 1.0.5

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

@@ -1,3 +1,313 @@
-import type { AgentToolCase } from './cases.js';
+import { type AnyNode } from '../../schema/index.js';
+import type { AgentToolCase, SceneGraph } from './cases.js';
+/**
+ * `verify_scene`: the MCP's checks and the chat's, merged, each issue typed so it can be counted.
+ * A case names the issue types a scene must raise (`contains`) or must not (`lacks`).
+ */
+type Pt = [number, number];
+export declare const ROOM: Pt[];
+/** Links parents' children and returns the graph, buildings as roots. */
+export declare function scene(...nodes: AnyNode[]): SceneGraph;
+export declare const building: (id?: string) => {
+    object: "node";
+    name?: string | undefined;
+    parentId: string | null;
+    visible: boolean;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "orthographic" | "perspective";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    metadata: Record<string, unknown>;
+    provenance?: {
+        refs: {
+            ns?: string | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+        }[];
+        lineage?: {
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
+    id: `building_${string}`;
+    type: "building";
+    children: (`elevator_${string}` | `level_${string}` | `unit_${string}`)[];
+    position: [number, number, number];
+    rotation: [number, number, number];
+    groundLevelId?: `level_${string}` | undefined;
+};
+export declare const level: (id: string, index: number, extra?: Record<string, unknown>) => {
+    object: "node";
+    name?: string | undefined;
+    parentId: string | null;
+    visible: boolean;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "orthographic" | "perspective";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    metadata: Record<string, unknown>;
+    provenance?: {
+        refs: {
+            ns?: string | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+        }[];
+        lineage?: {
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+            fromIds: string[];
+        } | undefined;
+    } | 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}`)[];
+    level: number;
+    baseElevation: number;
+    height?: number | undefined;
+};
+/** A finished room on a level: four closed walls, a centred door, its zone, slab and ceiling. */
+export declare function room(levelId: string, tag: string): AnyNode[];
+export declare const stairOn: (levelId: string, extra?: Record<string, unknown>) => ({
+    object: "node";
+    name?: string | undefined;
+    parentId: string | null;
+    visible: boolean;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "orthographic" | "perspective";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    metadata: Record<string, unknown>;
+    provenance?: {
+        refs: {
+            ns?: string | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+        }[];
+        lineage?: {
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
+    id: `stair_${string}`;
+    type: "stair";
+    material?: {
+        id?: string | undefined;
+        preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "back" | "double" | "front";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    materialPreset?: string | undefined;
+    railingMaterial?: {
+        id?: string | undefined;
+        preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "back" | "double" | "front";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    railingMaterialPreset?: string | undefined;
+    treadMaterial?: {
+        id?: string | undefined;
+        preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "back" | "double" | "front";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    treadMaterialPreset?: string | undefined;
+    sideMaterial?: {
+        id?: string | undefined;
+        preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "back" | "double" | "front";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    sideMaterialPreset?: string | undefined;
+    slots?: Record<string, string> | undefined;
+    position: [number, number, number];
+    rotation: number;
+    supportSlabId?: string | undefined;
+    stairType: "curved" | "spiral" | "straight";
+    fromLevelId: string | null;
+    toLevelId: string | null;
+    deckSlabId?: string | undefined;
+    slabOpeningMode: "destination" | "none";
+    openingOffset: number;
+    width: number;
+    totalRise?: number | undefined;
+    designTargets?: {
+        maxRiserHeight: number;
+        minimumGoing: number;
+        targetGoing: number;
+        minimumHeadroom: number;
+    } | undefined;
+    uniformRisers?: boolean | undefined;
+    stepCount: number;
+    autoSurfaceSnap?: boolean | undefined;
+    destinationSurfaceId?: string | undefined;
+    thickness: number;
+    fillToFloor: boolean;
+    construction?: {
+        mode: "center-stringer" | "open" | "side-stringers" | "solid" | "waist";
+        waistThickness: number;
+        treadThickness: number;
+        riserThickness: number;
+        nosing: number;
+        finishThickness: number;
+        closedRisers: boolean;
+        stringerWidth: number;
+        stringerDepth: number;
+    } | undefined;
+    innerRadius: number;
+    sweepAngle: number;
+    topLandingMode: "integrated" | "none";
+    topLandingDepth: number;
+    showCenterColumn: boolean;
+    showStepSupports: boolean;
+    railingMode: "both" | "left" | "none" | "right";
+    railingHeight: number;
+    railingStyle?: "balusters" | "boards" | "cable" | "glass" | "metal" | "post-and-rail" | undefined;
+    railingPath?: "continuous" | "original" | undefined;
+    handrail?: {
+        mode: "both" | "left" | "none" | "right";
+        height: number;
+        diameter: number;
+        offset: number;
+        bottom?: {
+            extension: number;
+            return: "floor" | "none" | "post" | "wall";
+            returnLength: number;
+        } | undefined;
+        top?: {
+            extension: number;
+            return: "floor" | "none" | "post" | "wall";
+            returnLength: number;
+        } | undefined;
+    } | undefined;
+    railingTopPost?: boolean | undefined;
+    railingTopReach?: number | undefined;
+    railingPostThrough?: boolean | undefined;
+    children: `sseg_${string}`[];
+} | {
+    object: "node";
+    name?: string | undefined;
+    parentId: string | null;
+    visible: boolean;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "orthographic" | "perspective";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    metadata: Record<string, unknown>;
+    provenance?: {
+        refs: {
+            ns?: string | undefined;
+            id: string;
+            role?: "absorbed" | "alias" | "derived" | "piece" | "primary" | undefined;
+        }[];
+        lineage?: {
+            op: "attach" | "convert" | "duplicate" | "import" | "make-independent" | "merge" | "promote" | "split";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
+    id: `sseg_${string}`;
+    type: "stair-segment";
+    material?: {
+        id?: string | undefined;
+        preset?: "brick" | "concrete" | "custom" | "glass" | "marble" | "metal" | "plaster" | "tile" | "white" | "wood" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "back" | "double" | "front";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    materialPreset?: string | undefined;
+    slots?: Record<string, string> | undefined;
+    position: [number, number, number];
+    rotation: number;
+    segmentType: "landing" | "stair";
+    width: number;
+    length: number;
+    height: number;
+    stepCount: number;
+    attachmentSide: "front" | "left" | "right";
+    fillToFloor: boolean;
+    construction?: {
+        mode: "center-stringer" | "open" | "side-stringers" | "solid" | "waist";
+        waistThickness: number;
+        treadThickness: number;
+        riserThickness: number;
+        nosing: number;
+        finishThickness: number;
+        closedRisers: boolean;
+        stringerWidth: number;
+        stringerDepth: number;
+    } | undefined;
+    winder?: {
+        turn: "left" | "right";
+        innerGap: number;
+        walkingLineOffset: number;
+        division: "equal-angle" | "equal-going";
+    } | undefined;
+    thickness: number;
+})[];
 export declare const VERIFY_SCENE_CASES: AgentToolCase[];
+export {};
 //# sourceMappingURL=verify-scene-cases.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"verify-scene-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/verify-scene-cases.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,SAAS,CAAA;AA8IxD,eAAO,MAAM,kBAAkB,EAAE,aAAa,EA+a7C,CAAA"}
+{"version":3,"file":"verify-scene-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/verify-scene-cases.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAeb,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAExD;;;GAGG;AAEH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAC1B,eAAO,MAAM,IAAI,EAAE,EAAE,EAKpB,CAAA;AAED,yEAAyE;AACzE,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,OAAO,EAAE,GAAG,UAAU,CAcrD;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAuD,CAAA;AAC5E,eAAO,MAAM,KAAK,OAAQ,MAAM,SAAS,MAAM,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ3E,CAAA;AAEJ,iGAAiG;AACjG,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,EAAE,CAwB5D;AAoBD,eAAO,MAAM,OAAO,YAAa,MAAM,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiBtE,CAAA;AAgDD,eAAO,MAAM,kBAAkB,EAAE,aAAa,EA+mB7C,CAAA"}

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

@@ -1,13 +1,13 @@
-import { BuildingNode, CeilingNode, DoorNode, FloorOpeningNode, ItemNode, LevelNode, RoofNode, SlabNode, StairNode, StairSegmentNode, WallNode, WindowNode, ZoneNode, } from '../../schema/index.js';
+import { BuildingNode, CeilingNode, DoorNode, FloorOpeningNode, ItemNode, LevelNode, RoofNode, RoofSegmentNode, SlabNode, StairNode, StairSegmentNode, WallNode, WindowNode, ZoneNode, } from '../../schema/index.js';
 import { authoredItem } from './add-object-cases.js';
-const ROOM = [
+export const ROOM = [
     [0, 0],
     [4, 0],
     [4, 3],
     [0, 3],
 ];
 /** Links parents' children and returns the graph, buildings as roots. */
-function scene(...nodes) {
+export function scene(...nodes) {
     const byId = Object.fromEntries(nodes.map((node) => [node.id, { ...node }]));
     for (const node of Object.values(byId)) {
         const parent = node.parentId ? byId[node.parentId] : undefined;
@@ -19,8 +19,8 @@ function scene(...nodes) {
         rootNodeIds: nodes.filter((node) => node.type === 'building').map((node) => node.id),
     };
 }
-const building = (id = 'building_main') => BuildingNode.parse({ id });
-const level = (id, index, extra = {}) => LevelNode.parse({
+export const building = (id = 'building_main') => BuildingNode.parse({ id });
+export const level = (id, index, extra = {}) => LevelNode.parse({
     id,
     parentId: 'building_main',
     level: index,
@@ -29,7 +29,7 @@ const level = (id, index, extra = {}) => LevelNode.parse({
     ...extra,
 });
 /** A finished room on a level: four closed walls, a centred door, its zone, slab and ceiling. */
-function room(levelId, tag) {
+export function room(levelId, tag) {
     const [wall, ...walls] = ROOM.map((start, i) => WallNode.parse({
         id: i === 0 ? `wall_${tag}` : `wall_${tag}_${i}`,
         parentId: levelId,
@@ -47,18 +47,28 @@ function room(levelId, tag) {
         wall,
         ...walls,
         door,
-        ZoneNode.parse({ id: `zone_${tag}`, parentId: levelId, name: 'Room', polygon: ROOM }),
+        ZoneNode.parse({ id: `zone_${tag}`, parentId: levelId, name: 'Living', polygon: ROOM }),
         SlabNode.parse({ id: `slab_${tag}`, parentId: levelId, polygon: ROOM }),
         CeilingNode.parse({ id: `ceiling_${tag}`, parentId: levelId, polygon: ROOM }),
     ];
 }
+/** A roof over the 4 × 3 m room, held by `levelId`, its segment bearing `y` above that floor. */
+const roofOver = (levelId, y) => [
+    RoofNode.parse({
+        id: 'roof_low',
+        parentId: levelId,
+        position: [2, y, 1.5],
+        children: ['rseg_low'],
+    }),
+    RoofSegmentNode.parse({ id: 'rseg_low', parentId: 'roof_low', width: 4, depth: 3, wallHeight: 0 }),
+];
 const STAIR_HOLE = [
     [1.5, 0.2],
     [2.5, 0.2],
     [2.5, 2.2],
     [1.5, 2.2],
 ];
-const stairOn = (levelId, extra = {}) => {
+export const stairOn = (levelId, extra = {}) => {
     const flight = StairSegmentNode.parse({
         id: `sseg_${levelId}`,
         parentId: `stair_${levelId}`,
@@ -113,7 +123,7 @@ export const VERIFY_SCENE_CASES = [
             hasIssues: false,
         },
     }),
-    verify('the viewed floor is marked', oneStorey, { result: { activeLevelId: 'level_0', levels: [{ levelId: 'level_0', isActive: true }] } }, { context: { activeLevelId: 'level_0' }, surfaces: ['core', 'chat'] }),
+    verify('the viewed floor is marked', oneStorey, { result: { activeLevelId: 'level_0', levels: [{ levelId: 'level_0', isActive: true }] } }, { context: { activeLevelId: 'level_0' } }),
     verify('walls with no room and no door are reported', () => scene(building(), level('level_0', 0), WallNode.parse({ id: 'wall_bare', parentId: 'level_0', start: [0, 0], end: [4, 0] })), {
         contains: ['walls_no_zones', 'walls_no_doors'],
         lacks: ['wall_open_end'],
@@ -131,6 +141,13 @@ export const VERIFY_SCENE_CASES = [
     verify('a stair on a storey connects them', () => twoStoreys(...stairOn('level_0')), {
         lacks: ['missing_stair'],
     }),
+    // A flight to no level names the level it rises from and none it arrives on (create_stair's
+    // toLevelId null): porch or deck steps, whatever their rise.
+    verify('porch steps to no level connect no storeys', () => twoStoreys(...stairOn('level_0', { fromLevelId: 'level_0', totalRise: 0.54 })), { contains: ['missing_stair'] }),
+    verify('a flight to no level as tall as the storey connects no storeys', () => twoStoreys(...stairOn('level_0', { fromLevelId: 'level_0', totalRise: 2.8 })), { contains: ['missing_stair'] }),
+    verify("an older stair naming no level at its storey's rise connects them", () => twoStoreys(...stairOn('level_0', { totalRise: 2.8 })), { lacks: ['missing_stair'] }),
+    verify('an older stair on the top storey, at its rise, climbs to the roof level and no storey', () => twoStoreys(level('level_roof', 2, { name: 'Roof', metadata: { role: 'roof' } }), RoofNode.parse({ id: 'roof_main', parentId: 'level_roof' }), ...stairOn('level_1', { totalRise: 2.8 })), { contains: ['missing_stair'] }),
+    verify('an older stair naming no level, twice as tall as its storey, does not', () => twoStoreys(...stairOn('level_0', { totalRise: 5.6 })), { contains: ['missing_stair'] }),
     verify('a roof-only level is neither a storey nor empty: one storey needs no stair', () => scene(building(), level('level_0', 0), level('level_roof', 1, { name: 'Roof' }), ...room('level_0', 'ground'), RoofNode.parse({ id: 'roof_main', parentId: 'level_roof' })), {
         result: { occupiedStoryCount: 1, roofLevelIds: ['level_roof'], hasIssues: false },
         lacks: ['missing_stair', 'empty_levels'],
@@ -138,10 +155,28 @@ export const VERIFY_SCENE_CASES = [
     verify('two single-storey buildings need no stair', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), building('building_annex'), level('level_annex', 0, { parentId: 'building_annex' }), ...room('level_annex', 'annex')), { lacks: ['missing_stair'] }),
     verify('a roof level with storey content is reported', () => scene(building(), level('level_0', 0), level('level_roof', 1, { metadata: { role: 'roof' } }), ...room('level_0', 'ground'), RoofNode.parse({ id: 'roof_main', parentId: 'level_roof' }), WallNode.parse({ id: 'wall_attic', parentId: 'level_roof', start: [0, 0], end: [4, 0] })), { contains: ['roof_level_occupied'] }),
     verify('a declared roof level with no roof is reported', () => scene(building(), level('level_0', 0), level('level_roof', 1, { metadata: { role: 'roof' } }), ...room('level_0', 'ground')), { contains: ['roof_level_no_roof'] }),
-    verify('a roof on a storey is reported', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), RoofNode.parse({ id: 'roof_low', parentId: 'level_0' })), {
+    verify("a roof level holding a plugin's roof planes has its roof", () => scene(building(), level('level_0', 0), level('level_roof', 1, { metadata: { role: 'roof' } }), ...room('level_0', 'ground'), {
+        object: 'node',
+        id: 'roofplane_south',
+        type: 'procedural:roof-plane',
+        parentId: 'level_roof',
+        visible: true,
+    }), { lacks: ['roof_level_no_roof'] }),
+    verify('a roof level below a storey of its building is reported', () => scene(building(), level('level_0', 0), level('level_roof', 1, { metadata: { role: 'roof' } }), level('level_2', 2), ...room('level_0', 'ground'), ...room('level_2', 'upper'), ...stairOn('level_0'), RoofNode.parse({ id: 'roof_main', parentId: 'level_roof' })), { contains: ['roof_level_not_on_top'], mentions: ['level_2'] }),
+    verify('a roof level below an empty storey, a floor still to be built, is reported', () => scene(building(), level('level_0', 0), level('level_roof', 1, { metadata: { role: 'roof' } }), level('level_2', 2), ...room('level_0', 'ground'), RoofNode.parse({ id: 'roof_main', parentId: 'level_roof' })), { contains: ['roof_level_not_on_top'], mentions: ['level_2'] }),
+    verify('a roof level on top of its storeys is quiet', () => scene(building(), level('level_0', 0), level('level_roof', 1, { metadata: { role: 'roof' } }), ...room('level_0', 'ground'), RoofNode.parse({ id: 'roof_main', parentId: 'level_roof' })), { lacks: ['roof_level_not_on_top'] }),
+    verify('a basement the stack stands at grade is reported, with the tool that seats the building', () => scene(building(), level('level_b', -1), level('level_0', 0), ...room('level_0', 'ground')), { contains: ['basement_at_grade'], mentions: ['set_ground_level'] }),
+    verify('a basement standing under the ground is quiet', () => scene(building(), level('level_b', -1, { baseElevation: -2.8 }), level('level_0', 0), ...room('level_0', 'ground')), { lacks: ['basement_at_grade', 'ground_level_unseated'] }),
+    verify('a roof with no segments on a storey stands on no walls, so nothing is reported to move', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), RoofNode.parse({ id: 'roof_low', parentId: 'level_0' })), { lacks: ['roof_mixed_in_storey'] }),
+    verify('a roof on the walls of the storey holding it is reported, naming the move', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), ...roofOver('level_0', 2.5)), {
         contains: ['roof_mixed_in_storey'],
-        mentions: ['dedicated roof level'],
+        mentions: ['dedicated roof level', 'move_roofs_to_roof_level', 'Move to the roof level'],
     }),
+    verify("a lower wing's roof at the upper storey's floor, where the Roof tool puts it, is quiet", () => twoStoreys(...stairOn('level_0'), RoofNode.parse({ id: 'roof_porch', parentId: 'level_1' })), { lacks: ['roof_mixed_in_storey'] }),
+    verify("a lower storey's roof on the storey above it, bearing on the lower walls, is quiet", () => scene(building(), level('level_0', 0), level('level_1', 1), ...room('level_0', 'ground'), ...room('level_1', 'upper'), ...stairOn('level_0'), 
+    // the upper storey's floor is 2.8 m up; the ground floor's walls top out at 2.5 m
+    ...roofOver('level_1', -0.3)), { lacks: ['roof_mixed_in_storey'] }),
+    verify('a porch roof on its beam, under the walls’ tops, stays on its storey unreported', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), ...roofOver('level_0', 2.1)), { lacks: ['roof_mixed_in_storey'] }),
     verify('a wall taller than its storey in a multi-storey building is reported', () => twoStoreys(...stairOn('level_0'), WallNode.parse({
         id: 'wall_tall',
         parentId: 'level_0',
@@ -177,6 +212,7 @@ export const VERIFY_SCENE_CASES = [
         contains: ['stair_outside_slab'],
         mentions: ['Stair Main Stair footprint extends outside source floor slab'],
     }),
+    verify('porch steps off the floor slab are not reported', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), ...stairOn('level_0', { fromLevelId: 'level_0', totalRise: 0.54, position: [2, 0, 4] })), { lacks: ['stair_outside_slab'] }),
     verify('a wall across a stair is reported', () => twoStoreys(...stairOn('level_0'), WallNode.parse({
         id: 'wall_blocker',
         parentId: 'level_0',
@@ -265,6 +301,18 @@ export const VERIFY_SCENE_CASES = [
         position: [1.3, 0, 2.1],
         asset: asset('closet', [2, 2.5, 1]),
     })), { contains: ['item_overlap'] }),
+    verify('a fridge standing in the middle of a room is reported', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), ItemNode.parse({
+        id: 'item_fridge',
+        parentId: 'level_0',
+        position: [3, 0, 1.6],
+        asset: asset('fridge', [0.7, 1.8, 0.72]),
+    })), { contains: ['item_mid_room'], mentions: ['item_fridge'] }),
+    verify('a fridge against a wall is not reported', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), ItemNode.parse({
+        id: 'item_fridge',
+        parentId: 'level_0',
+        position: [3.6, 0, 1.5],
+        asset: asset('fridge', [0.7, 1.8, 0.72]),
+    })), { lacks: ['item_mid_room'] }),
     verify('a node its schema rejects fails validation', () => scene(building(), level('level_0', 0), ...room('level_0', 'ground'), {
         ...WallNode.parse({ id: 'wall_broken', parentId: 'level_0', start: [0, 3], end: [4, 3] }),
         thickness: 'thick',

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

@@ -0,0 +1,3 @@
+import type { AgentToolCase } from './cases.js';
+export declare const VIEW_ASSETS_CASES: AgentToolCase[];
+//# sourceMappingURL=view-assets-cases.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"view-assets-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/view-assets-cases.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,SAAS,CAAA;AAwCxD,eAAO,MAAM,iBAAiB,EAAE,aAAa,EA+H5C,CAAA"}

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

@@ -0,0 +1,155 @@
+/**
+ * `view_assets`: a picture of catalog items by id, with their size and the names of their
+ * paintable surfaces. The host reads the pictures and the surfaces before the call (`assetViews`);
+ * the operation says what it was given and what it was not, as facts. What goes wrong, written
+ * first: an id the library lacks answered with nothing; an item with no named surfaces read as one
+ * whose surfaces are unknown; a host that cannot fetch pictures answering as if it had.
+ */
+const item = (id, name, dimensions) => ({
+    id,
+    name,
+    category: 'furniture',
+    tags: [],
+    thumbnail: `https://library.test/${id}/thumbnail.png`,
+    src: `https://library.test/${id}/model.glb`,
+    dimensions,
+});
+const LIBRARY = [
+    item('single-bed', 'Single Bed', [1.5, 0.7, 2.5]),
+    item('bunkbed', 'Bunkbed', [1.2, 1.8, 2.1]),
+    item('sofa', 'Sofa', [2.5, 0.8, 1.5]),
+    item('desk', 'Desk', [1.4, 0.75, 0.7]),
+    item('dresser', 'Dresser', [1.5, 0.8, 1]),
+    item('lamp', 'Lamp', [0.3, 1.5, 0.3]),
+];
+const PICTURE = 'data:image/webp;base64,UklGRg==';
+const seen = (...surfaces) => ({ picture: PICTURE, surfaces });
+const noScene = () => ({ nodes: {}, rootNodeIds: [] });
+const library = (assetViews) => ({
+    activeLevelId: null,
+    catalog: LIBRARY,
+    ...(assetViews ? { assetViews } : {}),
+});
+export const VIEW_ASSETS_CASES = [
+    {
+        name: 'one item: its size, category and surface names, and a picture shown',
+        tool: 'view_assets',
+        scene: noScene,
+        input: { ids: ['single-bed'] },
+        context: library({ 'single-bed': seen('sheet', 'pillow', 'matress', 'frame') }),
+        readOnly: true,
+        expect: {
+            result: {
+                shown: 1,
+                items: [
+                    {
+                        id: 'single-bed',
+                        name: 'Single Bed',
+                        category: 'furniture',
+                        dimensions: [1.5, 0.7, 2.5],
+                        surfaces: ['sheet', 'pillow', 'matress', 'frame'],
+                        picture: true,
+                    },
+                ],
+            },
+            check: (result) => ('note' in result ? ['a note on a call that showed everything'] : []),
+        },
+    },
+    {
+        name: 'six items in one call, each with a picture, in the order asked',
+        tool: 'view_assets',
+        scene: noScene,
+        input: { ids: LIBRARY.map((entry) => entry.id) },
+        context: library(Object.fromEntries(LIBRARY.map((entry) => [entry.id, seen('body')]))),
+        readOnly: true,
+        expect: {
+            result: { shown: 6 },
+            check: (result) => {
+                const ids = result.items.map((entry) => entry.id);
+                return ids.join() === LIBRARY.map((entry) => entry.id).join()
+                    ? []
+                    : [`items came back as ${ids.join()}`];
+            },
+        },
+    },
+    {
+        name: 'an id twice is one picture',
+        tool: 'view_assets',
+        scene: noScene,
+        input: { ids: ['sofa', 'sofa'] },
+        context: library({ sofa: seen('body', 'cushion', 'pillow') }),
+        readOnly: true,
+        expect: { result: { shown: 1, items: [{ id: 'sofa' }] } },
+    },
+    {
+        name: 'an id the library lacks is refused with the fact, and nothing is shown',
+        tool: 'view_assets',
+        scene: noScene,
+        input: { ids: ['sofa', 'throne'] },
+        context: library({ sofa: seen('body') }),
+        readOnly: true,
+        expect: {
+            refusal: 'unknown_asset',
+            mentions: ['"throne" is not in the item library', 'search_assets', 'Nothing was shown'],
+        },
+    },
+    {
+        name: 'an item whose model names no surface says so',
+        tool: 'view_assets',
+        scene: noScene,
+        input: { ids: ['bunkbed'] },
+        context: library({ bunkbed: seen() }),
+        readOnly: true,
+        expect: { result: { shown: 1, items: [{ id: 'bunkbed', surfaces: [], picture: true }] } },
+    },
+    {
+        name: 'a host that read nothing gives the sizes, and says no picture is shown',
+        tool: 'view_assets',
+        scene: noScene,
+        input: { ids: ['desk', 'lamp'] },
+        context: library(),
+        readOnly: true,
+        expect: {
+            result: {
+                shown: 0,
+                items: [
+                    { id: 'desk', dimensions: [1.4, 0.75, 0.7], surfaces: null, picture: false },
+                    { id: 'lamp', surfaces: null, picture: false },
+                ],
+            },
+            mentions: ['2 of 2 items show no picture here'],
+        },
+    },
+    {
+        name: 'a picture that could not be fetched leaves the surfaces and names why',
+        tool: 'view_assets',
+        scene: noScene,
+        input: { ids: ['dresser', 'sofa'] },
+        context: library({
+            dresser: { surfaces: ['drawers', 'body'], unavailable: 'its picture could not be fetched (the file answered 404)' },
+            sofa: seen('body'),
+        }),
+        readOnly: true,
+        expect: {
+            result: {
+                shown: 1,
+                items: [
+                    { id: 'dresser', surfaces: ['drawers', 'body'], picture: false },
+                    { id: 'sofa', picture: true },
+                ],
+            },
+            mentions: ['1 of 2 items show no picture here', 'the file answered 404'],
+        },
+    },
+    {
+        name: 'a host with no library has nothing to look in',
+        tool: 'view_assets',
+        scene: noScene,
+        input: { ids: ['sofa'] },
+        context: { activeLevelId: null },
+        // The standalone MCP always has its built-in list.
+        surfaces: ['core', 'chat'],
+        readOnly: true,
+        expect: { refusal: 'no_catalog' },
+    },
+];