@pascal-app/mcp 1.0.1 → 1.0.4

package/dist/tools/construction-tools.js

@@ -1,7 +1,8 @@
-import { resolveStairTotalRise } from '@pascal-app/core';
-import { CeilingNode, getActiveRoofHeight, LevelNode, RoofNode, RoofSegmentNode, SlabNode, StairNode, StairSegmentNode, WallNode, } from '@pascal-app/core/schema';
+import { createZone, generateId } from '@pascal-app/core';
+import { unknownMaterialPresetRefusal } from '@pascal-app/core/agent-operations';
+import { getActiveRoofHeight, LevelNode, RoofNode, RoofSegmentNode } from '@pascal-app/core/schema';
 import { z } from 'zod';
-import { ADDITIVE_TOOL_ANNOTATIONS, DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { ADDITIVE_TOOL_ANNOTATIONS } from './annotations.js';
 import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
 import { measurement } from './measurement.js';
 import { NodeIdSchema, Vec2Schema, Vec3Schema } from './schemas.js';
@@ -15,7 +16,6 @@ const ROOF_TYPES = [
     'flat',
     'conical',
 ];
-const RAILING_MODES = ['none', 'left', 'right', 'both'];
 export const createStoryShellInput = {
     levelId: NodeIdSchema,
     footprint: z.array(Vec2Schema).min(3),
@@ -27,9 +27,17 @@ export const createStoryShellInput = {
         positive: true,
         description: 'Wall thickness.',
     }).default(0.16),
-    createSlab: z.boolean().default(true),
-    createCeiling: z.boolean().default(true),
-    slabElevation: measurement('length', 'm', { description: 'Slab elevation.' }).default(0.1),
+    createSlab: z
+        .boolean()
+        .default(true)
+        .describe('Floor intent for the rooms inside the shell. False records hasFloor: false.'),
+    createCeiling: z
+        .boolean()
+        .default(true)
+        .describe('Ceiling intent for the rooms inside the shell. False records hasCeiling: false.'),
+    slabElevation: measurement('length', 'm', {
+        description: "Walking surface of the derived plate, stored as the room's floor elevation.",
+    }).default(0.1),
     ceilingHeight: measurement('length', 'm', {
         positive: true,
         description: 'Ceiling height.',
@@ -42,7 +50,11 @@ export const createStoryShellInput = {
 export const createStoryShellOutput = {
     levelId: z.string(),
     wallIds: z.array(z.string()),
+    /** Zones the reconciler derived for the enclosed faces. */
+    zoneIds: z.array(z.string()),
+    /** Derived floor plate. `null` when floors were declined or nothing reconciled. */
     slabId: z.string().nullable(),
+    /** Derived ceiling. `null` when ceilings were declined or nothing reconciled. */
     ceilingId: z.string().nullable(),
     createdIds: z.array(z.string()),
     ...liveSyncOutput,
@@ -80,48 +92,6 @@ export const createRoofOutput = {
     roofSegmentId: z.string(),
     ...liveSyncOutput,
 };
-export const createStairBetweenLevelsInput = {
-    fromLevelId: NodeIdSchema,
-    toLevelId: NodeIdSchema,
-    position: Vec3Schema,
-    rotation: measurement('angle', 'rad', { description: 'Y-axis rotation.' }).default(0),
-    width: measurement('length', 'm', { positive: true, description: 'Stair width.' }).default(1),
-    runLength: measurement('length', 'm', {
-        positive: true,
-        description: 'Horizontal run length.',
-    }).default(3),
-    totalRise: measurement('length', 'm', {
-        positive: true,
-        description: 'Total vertical rise.',
-    }).optional(),
-    stepCount: z.number().int().positive().default(14),
-    railingMode: z.enum(RAILING_MODES).default('both'),
-    destinationSlabId: NodeIdSchema.optional(),
-    sourceCeilingId: NodeIdSchema.optional(),
-    createDestinationSlabOpening: z.boolean().default(true),
-    createSourceCeilingOpening: z.boolean().default(true),
-    openingWidth: measurement('length', 'm', {
-        positive: true,
-        description: 'Floor opening width.',
-    }).optional(),
-    openingLength: measurement('length', 'm', {
-        positive: true,
-        description: 'Floor opening length.',
-    }).optional(),
-    openingOffset: measurement('length', 'm', { min: 0, description: 'Opening offset.' }).default(0),
-    openingCenter: Vec2Schema.optional(),
-    openingRotation: measurement('angle', 'rad', { description: 'Opening rotation.' }).optional(),
-    materialPreset: z.string().optional(),
-    name: z.string().optional(),
-};
-export const createStairBetweenLevelsOutput = {
-    stairId: z.string(),
-    stairSegmentId: z.string(),
-    destinationSlabId: z.string().nullable(),
-    sourceCeilingId: z.string().nullable(),
-    openingPolygon: z.array(Vec2Schema),
-    ...liveSyncOutput,
-};
 function textResult(payload) {
     return {
         content: [{ type: 'text', text: JSON.stringify(payload) }],
@@ -159,114 +129,124 @@ function nextLevelIndex(bridge, buildingId, referenceLevel) {
     const candidate = referenceIndex + 1;
     return existing.includes(candidate) ? Math.max(candidate, ...existing) + 1 : candidate;
 }
-function nodesOnLevel(bridge, levelId) {
-    return Object.values(bridge.getNodes()).filter((node) => node.id !== levelId && bridge.resolveLevelId(node.id) === levelId);
-}
-function firstNodeOnLevel(bridge, levelId, type) {
-    return nodesOnLevel(bridge, levelId).find((node) => node.type === type) ?? null;
+/** Room zones that appeared on the level while this tool call ran. */
+function newRoomZoneIds(bridge, levelId, before) {
+    return Object.values(bridge.getNodes())
+        .filter((node) => node.type === 'zone' &&
+        node.parentId === levelId &&
+        node.spaceRole === 'room' &&
+        !before.has(node.id))
+        .map((node) => node.id)
+        .sort();
 }
-function rotatePoint(x, z, rotation) {
-    const cos = Math.cos(rotation);
-    const sin = Math.sin(rotation);
-    return [x * cos + z * sin, -x * sin + z * cos];
-}
-function rectangularOpening(args) {
-    const width = args.width + args.offset * 2;
-    const length = args.length + args.offset * 2;
-    const center = args.center ?? [
-        args.position[0],
-        args.position[2] + args.length / 2,
-    ];
-    const rotation = args.openingRotation ?? args.rotation;
-    const halfW = width / 2;
-    const halfL = length / 2;
-    const local = [
-        [-halfW, -halfL],
-        [halfW, -halfL],
-        [halfW, halfL],
-        [-halfW, halfL],
-    ];
-    return local.map(([x, z]) => {
-        const [rx, rz] = rotatePoint(x, z, rotation);
-        return [center[0] + rx, center[1] + rz];
-    });
-}
-function withHole(surface, hole) {
-    return {
-        holes: [...(surface.holes ?? []), hole],
-        holeMetadata: [...(surface.holeMetadata ?? []), { source: 'manual' }],
-    };
+function derivedShellSurfaces(bridge, levelId, zoneIds) {
+    const children = Object.values(bridge.getNodes()).filter((node) => node.parentId === levelId);
+    const plate = children
+        .filter((node) => node.type === 'slab')
+        .sort((a, b) => Number(a.plateRole === 'base') - Number(b.plateRole === 'base'))
+        .find((node) => node.type === 'slab' &&
+        node.boundary === 'auto' &&
+        (node.zoneIds ?? []).some((id) => zoneIds.includes(id)));
+    const ceiling = children.find((node) => node.type === 'ceiling' && node.boundary === 'auto' && zoneIds.includes(node.zoneId ?? ''));
+    return { slabId: plate?.id ?? null, ceilingId: ceiling?.id ?? null };
 }
 export function registerConstructionTools(server, bridge) {
     server.registerTool('create_story_shell', {
         title: 'Create story shell',
-        description: 'Create one level-owned building shell from a footprint: perimeter walls plus optional slab and ceiling. Use once per story; do not make first-floor walls span multiple stories.',
+        description: 'Create one level-owned building shell from a footprint: the perimeter walls. The floor plate and the ceiling are DERIVED from the rooms the walls enclose — never author a slab or a ceiling here, and never pass boundary/autoFromWalls; createSlab / createCeiling / slabElevation are recorded as room intent instead. Use once per story; do not make first-floor walls span multiple stories.',
         inputSchema: createStoryShellInput,
         outputSchema: createStoryShellOutput,
         annotations: ADDITIVE_TOOL_ANNOTATIONS,
     }, async ({ levelId, footprint, wallHeight, wallThickness, createSlab, createCeiling, slabElevation, ceilingHeight, namePrefix, wallMaterialPreset, slabMaterialPreset, ceilingMaterialPreset, }) => {
+        const preset = unknownMaterialPresetRefusal({
+            wallMaterialPreset,
+            slabMaterialPreset,
+            ceilingMaterialPreset,
+        });
+        if (preset)
+            throw new Error(preset);
         const level = assertNode(bridge, levelId, 'level');
         if (isRoofLevel(level)) {
             throw new Error(`Cannot create a story shell on roof support level ${levelId}; create or choose an occupied story level instead`);
         }
         const points = footprint;
-        const wallIds = [];
-        const patches = [];
-        for (let i = 0; i < points.length; i++) {
-            const wall = WallNode.parse({
-                name: namePrefix ? `${namePrefix} Wall ${i + 1}` : undefined,
-                start: points[i],
-                end: points[(i + 1) % points.length],
+        const before = new Set(Object.keys(bridge.getNodes()));
+        const plan = createZone(bridge.getNodes(), {
+            levelId,
+            polygon: points,
+            name: namePrefix ?? 'Room',
+            enclose: true,
+            mintId: generateId,
+            wall: {
                 thickness: wallThickness,
                 ...(wallHeight !== undefined ? { height: wallHeight } : {}),
-                frontSide: 'exterior',
-                backSide: 'interior',
-                ...(wallMaterialPreset ? { materialPreset: wallMaterialPreset } : {}),
-                metadata: { role: 'exterior', storyShell: true },
-            });
-            wallIds.push(wall.id);
-            patches.push({ op: 'create', node: wall, parentId: levelId });
-        }
-        let slabId = null;
-        if (createSlab) {
-            const slab = SlabNode.parse({
-                name: namePrefix ? `${namePrefix} Slab` : undefined,
-                polygon: points,
-                elevation: slabElevation,
-                // Grounded solid: underside on the level plane, so the created
-                // story slab occupies [0, slabElevation] like the legacy
-                // extrude-from-zero model.
-                thickness: Math.max(slabElevation, 0),
-                recessed: slabElevation < 0,
-                ...(slabMaterialPreset ? { materialPreset: slabMaterialPreset } : {}),
-                metadata: { role: 'story-slab' },
-            });
-            slabId = slab.id;
-            patches.push({ op: 'create', node: slab, parentId: levelId });
-        }
-        let ceilingId = null;
-        if (createCeiling) {
-            // Height-less unless the caller pinned one: a new story ceiling
-            // follows the level top automatically.
-            const explicitCeilingHeight = ceilingHeight ?? wallHeight;
-            const ceiling = CeilingNode.parse({
-                name: namePrefix ? `${namePrefix} Ceiling` : undefined,
-                polygon: points,
-                ...(explicitCeilingHeight !== undefined ? { height: explicitCeilingHeight } : {}),
-                ...(ceilingMaterialPreset ? { materialPreset: ceilingMaterialPreset } : {}),
-                metadata: { role: 'story-ceiling' },
-            });
-            ceilingId = ceiling.id;
-            patches.push({ op: 'create', node: ceiling, parentId: levelId });
-        }
-        const result = bridge.applyPatch(patches);
+            },
+            intent: {
+                floor: { elevation: slabElevation },
+                hasFloor: createSlab,
+                hasCeiling: createCeiling,
+            },
+        });
+        const wallIds = plan.changes.flatMap((change) => change.op === 'create' && change.node.type === 'wall' ? [change.node.id] : []);
+        bridge.runAsSingleHistoryStep(() => {
+            bridge.applyPatch(plan.changes.map((change) => change.op === 'create'
+                ? {
+                    ...change,
+                    parentId: change.node.parentId,
+                    node: change.node.type === 'wall'
+                        ? {
+                            ...change.node,
+                            ...(namePrefix
+                                ? { name: `${namePrefix} Wall ${wallIds.indexOf(change.node.id) + 1}` }
+                                : {}),
+                            ...(wallMaterialPreset ? { materialPreset: wallMaterialPreset } : {}),
+                            metadata: { role: 'exterior', storyShell: true },
+                        }
+                        : change.node,
+                }
+                : change));
+            bridge.deriveStructure([levelId]);
+        });
+        const zoneIds = newRoomZoneIds(bridge, levelId, before);
+        // Finishes and an explicit ceiling height stay editable on derived
+        // construction, so they are applied to whatever the reconciler built.
+        const derived = derivedShellSurfaces(bridge, levelId, zoneIds);
+        const explicitCeilingHeight = ceilingHeight ?? wallHeight;
+        const finishes = [
+            ...(derived.slabId && slabMaterialPreset
+                ? [
+                    {
+                        op: 'update',
+                        id: derived.slabId,
+                        data: {
+                            ...(slabMaterialPreset ? { materialPreset: slabMaterialPreset } : {}),
+                        },
+                    },
+                ]
+                : []),
+            ...(derived.ceilingId && (ceilingMaterialPreset || explicitCeilingHeight !== undefined)
+                ? [
+                    {
+                        op: 'update',
+                        id: derived.ceilingId,
+                        data: {
+                            ...(ceilingMaterialPreset ? { materialPreset: ceilingMaterialPreset } : {}),
+                            ...(explicitCeilingHeight !== undefined ? { height: explicitCeilingHeight } : {}),
+                        },
+                    },
+                ]
+                : []),
+        ];
+        if (finishes.length > 0)
+            bridge.applyPatch(finishes);
         const persistence = await publishLiveSceneSnapshot(bridge, 'create_story_shell');
         return textResult({
             levelId,
             wallIds,
-            slabId,
-            ceilingId,
-            createdIds: result.createdIds,
+            zoneIds,
+            slabId: derived.slabId,
+            ceilingId: derived.ceilingId,
+            createdIds: Object.keys(bridge.getNodes()).filter((id) => !before.has(id)),
             ...persistencePayload(persistence),
         });
     });
@@ -277,6 +257,9 @@ export function registerConstructionTools(server, bridge) {
         outputSchema: createRoofOutput,
         annotations: ADDITIVE_TOOL_ANNOTATIONS,
     }, async ({ levelId, roofLevelId, useDedicatedRoofLevel, roofLevelLabel, roofLevelElevation, roofLevelHeight, center, width, depth, roofType, pitch, wallHeight, wallThickness, overhang, materialPreset, name, }) => {
+        const preset = unknownMaterialPresetRefusal({ materialPreset });
+        if (preset)
+            throw new Error(preset);
         const effectiveWidth = roofType === 'conical' ? Math.max(width, depth) : width;
         const effectiveDepth = roofType === 'conical' ? effectiveWidth : depth;
         // Peak height is derived from pitch + footprint + type; we still
@@ -350,97 +333,4 @@ export function registerConstructionTools(server, bridge) {
             ...persistencePayload(persistence),
         });
     });
-    server.registerTool('create_stair_between_levels', {
-        title: 'Create stair between levels',
-        description: 'Create a straight stair and a single rectangular manual opening in the destination slab/source ceiling. This disables stair auto-opening mode to avoid duplicate or irregular holes.',
-        inputSchema: createStairBetweenLevelsInput,
-        outputSchema: createStairBetweenLevelsOutput,
-        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
-    }, async ({ fromLevelId, toLevelId, position, rotation, width, runLength, totalRise, stepCount, railingMode, destinationSlabId, sourceCeilingId, createDestinationSlabOpening, createSourceCeilingOpening, openingWidth, openingLength, openingOffset, openingCenter, openingRotation, materialPreset, name, }) => {
-        const fromLevel = assertNode(bridge, fromLevelId, 'level');
-        const toLevel = assertNode(bridge, toLevelId, 'level');
-        if (isRoofLevel(fromLevel) || isRoofLevel(toLevel)) {
-            throw new Error('Roof support levels are not occupied stories; create a separate occupied attic/story level if a stair-accessible attic is required');
-        }
-        const stairDraft = StairNode.parse({
-            name: name ?? 'Stair',
-            position: position,
-            rotation,
-            stairType: 'straight',
-            fromLevelId,
-            toLevelId,
-            slabOpeningMode: 'none',
-            openingOffset,
-            width,
-            ...(totalRise !== undefined ? { totalRise } : {}),
-            stepCount,
-            railingMode,
-            children: [],
-            ...(materialPreset ? { materialPreset } : {}),
-            metadata: {
-                openingManaged: 'manual-rectangular',
-            },
-        });
-        const riseNodes = {
-            ...bridge.getNodes(),
-            [fromLevel.id]: {
-                ...fromLevel,
-                children: [...fromLevel.children, stairDraft.id],
-            },
-            [stairDraft.id]: stairDraft,
-        };
-        const resolvedTotalRise = resolveStairTotalRise(stairDraft, riseNodes);
-        const segment = StairSegmentNode.parse({
-            segmentType: 'stair',
-            width,
-            length: runLength,
-            height: resolvedTotalRise,
-            stepCount,
-            ...(materialPreset ? { materialPreset } : {}),
-        });
-        const stair = { ...stairDraft, children: [segment.id] };
-        const openingPolygon = rectangularOpening({
-            position: position,
-            rotation,
-            width: openingWidth ?? width,
-            length: openingLength ?? runLength,
-            offset: openingOffset,
-            center: openingCenter,
-            openingRotation,
-        });
-        const patches = [
-            { op: 'create', node: stair, parentId: fromLevelId },
-            { op: 'create', node: segment, parentId: stair.id },
-        ];
-        const destinationSlab = destinationSlabId !== undefined
-            ? assertNode(bridge, destinationSlabId, 'slab')
-            : firstNodeOnLevel(bridge, toLevelId, 'slab');
-        if (createDestinationSlabOpening && destinationSlab?.type === 'slab') {
-            patches.push({
-                op: 'update',
-                id: destinationSlab.id,
-                data: withHole(destinationSlab, openingPolygon),
-            });
-        }
-        const sourceCeiling = sourceCeilingId !== undefined
-            ? assertNode(bridge, sourceCeilingId, 'ceiling')
-            : firstNodeOnLevel(bridge, fromLevelId, 'ceiling');
-        if (createSourceCeilingOpening && sourceCeiling?.type === 'ceiling') {
-            patches.push({
-                op: 'update',
-                id: sourceCeiling.id,
-                data: withHole(sourceCeiling, openingPolygon),
-            });
-        }
-        bridge.applyPatch(patches);
-        const persistence = await publishLiveSceneSnapshot(bridge, 'create_stair_between_levels');
-        return textResult({
-            stairId: stair.id,
-            stairSegmentId: segment.id,
-            destinationSlabId: destinationSlab?.id ?? null,
-            sourceCeilingId: sourceCeiling?.id ?? null,
-            openingPolygon,
-            ...persistencePayload(persistence),
-        });
-    });
 }

package/dist/tools/create-unit.d.ts

@@ -14,6 +14,8 @@ export declare const createUnitInput: {
     memberZoneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
 export declare const createUnitOutput: {
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsaved: z.ZodOptional<z.ZodString>;
     persistence: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
             unbound: "unbound";

package/dist/tools/create-unit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-unit.d.ts","sourceRoot":"","sources":["../../src/tools/create-unit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAMpD,eAAO,MAAM,eAAe;;;;;;;;;;;CAM3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;CAG5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAuBnF"}
+{"version":3,"file":"create-unit.d.ts","sourceRoot":"","sources":["../../src/tools/create-unit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAMpD,eAAO,MAAM,eAAe;;;;;;;;;;;CAM3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAG5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAuBnF"}

package/dist/tools/describe-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"describe-node.d.ts","sourceRoot":"","sources":["../../src/tools/describe-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAMpD,eAAO,MAAM,iBAAiB;;CAE7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;CAQ9B,CAAA;AA0CD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAiDrF"}
+{"version":3,"file":"describe-node.d.ts","sourceRoot":"","sources":["../../src/tools/describe-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAIxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,eAAO,MAAM,iBAAiB;;CAE7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;CAQ9B,CAAA;AA4CD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAiDrF"}

package/dist/tools/describe-node.js

@@ -1,8 +1,8 @@
-import { resolveCeilingHeight } from '@pascal-app/core';
+import { floorFootprintName, getLevelDisplayName, resolveCeilingHeight } from '@pascal-app/core';
+import { wallResolvedHeight } from '@pascal-app/core/agent-operations';
 import { z } from 'zod';
 import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
 import { ErrorCode, throwMcpError } from './errors.js';
-import { resolveReportedWallHeight } from './scene-query.js';
 import { NodeIdSchema } from './schemas.js';
 export const describeNodeInput = {
     id: NodeIdSchema,
@@ -26,11 +26,11 @@ function describe(node, bridge) {
             const [x1, z1] = node.start;
             const [x2, z2] = node.end;
             const t = node.thickness ?? 0.1;
-            const h = resolveReportedWallHeight(bridge, node);
+            const h = wallResolvedHeight(bridge.getNodes(), node);
             return `Wall from (${x1},${z1}) to (${x2},${z2}), thickness ${t.toFixed(2)}m, height ${h.toFixed(2)}m`;
         }
         case 'level':
-            return `Level ${node.level}`;
+            return getLevelDisplayName(node);
         case 'building': {
             const [x, y, z] = node.position;
             return `Building at (${x},${y},${z})`;
@@ -40,7 +40,9 @@ function describe(node, bridge) {
         case 'zone':
             return `Zone "${node.name}" with ${node.polygon.length} vertices`;
         case 'slab':
-            return `Slab with ${node.polygon.length} vertices`;
+            return node.plateRole === 'base'
+                ? `Floor footprint "${floorFootprintName(bridge.getNodes(), node)}" with ${node.polygon.length} vertices`
+                : `Slab with ${node.polygon.length} vertices`;
         case 'ceiling':
             return `Ceiling with ${node.polygon.length} vertices, height ${resolveCeilingHeight(node, bridge.getNodes()).toFixed(2)}m`;
         case 'door':
@@ -76,7 +78,7 @@ export function registerDescribeNode(server, bridge) {
         const properties = n.type === 'wall'
             ? {
                 ...n,
-                resolvedHeight: resolveReportedWallHeight(bridge, n),
+                resolvedHeight: wallResolvedHeight(bridge.getNodes(), n),
                 heightIsExplicit: n.height !== undefined,
             }
             : n;

package/dist/tools/errors.d.ts

@@ -16,5 +16,16 @@ export declare function toolError(message: string, data?: Record<string, unknown
     }[];
     isError: true;
 };
+/**
+ * A core operation's refusal (`AgentRefusal`) as the same `{ error, code, ...details }` answer the
+ * hosted chat returns; anything else is a real failure and is rethrown.
+ */
+export declare function refusalResult(error: unknown): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: true;
+};
 export { ErrorCode, McpError };
 //# sourceMappingURL=errors.d.ts.map

package/dist/tools/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/tools/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAA;AAExE;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,KAAK,CAErF;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzC,OAAO,EAAE,IAAI,CAAA;CACd,CAUA;AAED,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAA"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/tools/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAA;AAGxE;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,KAAK,CAErF;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzC,OAAO,EAAE,IAAI,CAAA;CACd,CAUA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO;aAlBjC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE;aAChC,IAAI;EAoBd;AAED,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAA"}

package/dist/tools/errors.js

@@ -1,4 +1,5 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { isAgentRefusal } from '@pascal-app/core/agent-tools';
 /**
  * Throw a structured MCP error. The SDK translates `McpError` into a
  * JSON-RPC error response automatically.
@@ -22,4 +23,13 @@ export function toolError(message, data) {
         isError: true,
     };
 }
+/**
+ * A core operation's refusal (`AgentRefusal`) as the same `{ error, code, ...details }` answer the
+ * hosted chat returns; anything else is a real failure and is rethrown.
+ */
+export function refusalResult(error) {
+    if (isAgentRefusal(error))
+        return toolError(error.message, { code: error.code, ...error.details });
+    throw error;
+}
 export { ErrorCode, McpError };

package/dist/tools/find-nodes.d.ts

@@ -2,28 +2,12 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
 export declare const findNodesInput: {
-    type: z.ZodOptional<z.ZodEnum<{
-        site: "site";
-        building: "building";
-        level: "level";
-        wall: "wall";
-        fence: "fence";
-        slab: "slab";
-        door: "door";
-        item: "item";
-        zone: "zone";
-        stair: "stair";
-        ceiling: "ceiling";
-        roof: "roof";
-        "roof-segment": "roof-segment";
-        "stair-segment": "stair-segment";
-        scan: "scan";
-        guide: "guide";
-        window: "window";
-    }>>;
+    type: z.ZodOptional<z.ZodString>;
     parentId: z.ZodOptional<z.ZodString>;
     levelId: z.ZodOptional<z.ZodString>;
     zoneId: z.ZodOptional<z.ZodString>;
+    sourceId: z.ZodOptional<z.ZodString>;
+    sourceIdPrefix: z.ZodOptional<z.ZodString>;
 };
 export declare const findNodesOutput: {
     nodes: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;

package/dist/tools/find-nodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find-nodes.d.ts","sourceRoot":"","sources":["../../src/tools/find-nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAwBpD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;CAK1B,CAAA;AAED,eAAO,MAAM,eAAe;;CAE3B,CAAA;AAkCD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAwDlF"}
+{"version":3,"file":"find-nodes.d.ts","sourceRoot":"","sources":["../../src/tools/find-nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAKxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,cAAc;;;;;;;CAyB1B,CAAA;AAED,eAAO,MAAM,eAAe;;CAE3B,CAAA;AAmHD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAuFlF"}