@pascal-app/mcp 1.0.0-beta.6 → 1.0.1

package/dist/tools/apply-patch.js

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import { ErrorCode, throwMcpError } from './errors';
-import { publishLiveSceneSnapshot } from './live-sync';
-import { PatchSchema } from './schemas';
+import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { ErrorCode, throwMcpError } from './errors.js';
+import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { PatchSchema } from './schemas.js';
 export const applyPatchInput = {
     patches: z.array(PatchSchema),
 };
@@ -9,13 +10,15 @@ export const applyPatchOutput = {
     appliedOps: z.number(),
     deletedIds: z.array(z.string()),
     createdIds: z.array(z.string()),
+    ...liveSyncOutput,
 };
 export function registerApplyPatch(server, bridge) {
     server.registerTool('apply_patch', {
         title: 'Apply patch',
-        description: 'Apply a batch of create/update/delete operations atomically. All patches are validated before any are applied; the entire batch forms a single undo step.',
+        description: 'Apply a batch of create/update/delete operations atomically. All patches are validated before any are applied; the entire batch forms a single undo step. Batch-first is the default: prefer one apply_patch call containing all create/update/delete ops for a build step, in stable order so later ops can reference ids created by earlier ops. A single call is atomic (all or nothing) and pays the snapshot and save cost once; do not loop one-op calls.',
         inputSchema: applyPatchInput,
         outputSchema: applyPatchOutput,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
     }, async ({ patches }) => {
         const bridgePatches = patches.map((p) => {
             if (p.op === 'create') {
@@ -40,11 +43,12 @@ export function registerApplyPatch(server, bridge) {
         });
         try {
             const result = bridge.applyPatch(bridgePatches);
-            await publishLiveSceneSnapshot(bridge, 'apply_patch');
+            const persistence = await publishLiveSceneSnapshot(bridge, 'apply_patch');
             const payload = {
                 appliedOps: result.appliedOps,
                 deletedIds: result.deletedIds,
                 createdIds: result.createdIds,
+                ...persistencePayload(persistence),
             };
             return {
                 content: [{ type: 'text', text: JSON.stringify(payload) }],

package/dist/tools/check-collisions.d.ts

@@ -1,14 +1,73 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import type { SceneOperations } from '../operations';
+import type { SceneOperations } from '../operations/index.js';
 export declare const checkCollisionsInput: {
     levelId: z.ZodOptional<z.ZodString>;
+    minimumClearance: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    floorOnly: z.ZodDefault<z.ZodBoolean>;
+    candidate: z.ZodOptional<z.ZodObject<{
+        id: z.ZodDefault<z.ZodString>;
+        name: z.ZodDefault<z.ZodString>;
+        levelId: z.ZodString;
+        position: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>, z.ZodTransform<[number, number, number], number[]>>;
+        dimensions: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>, z.ZodTransform<[number, number, number], number[]>>;
+        rotationY: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        source: z.ZodOptional<z.ZodObject<{
+            assetId: z.ZodOptional<z.ZodString>;
+            uri: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 };
 export declare const checkCollisionsOutput: {
+    status: z.ZodEnum<{
+        checked: "checked";
+        partial: "partial";
+        insufficient_evidence: "insufficient_evidence";
+    }>;
+    units: z.ZodLiteral<"meters">;
+    method: z.ZodLiteral<"rotation-aware-plan-aabb">;
+    assessmentGraphHash: z.ZodString;
+    minimumClearanceMeters: z.ZodNumber;
+    floorOnly: z.ZodBoolean;
+    candidateItemId: z.ZodNullable<z.ZodString>;
+    checkedItems: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        levelId: z.ZodNullable<z.ZodString>;
+        positionMeters: z.ZodArray<z.ZodNumber>;
+        rotationYRadians: z.ZodNumber;
+        source: z.ZodObject<{
+            assetId: z.ZodString;
+            uri: z.ZodString;
+            catalog: z.ZodString;
+        }, z.core.$strip>;
+        sourceDimensionsMeters: z.ZodArray<z.ZodNumber>;
+        effectiveDimensionsMeters: z.ZodArray<z.ZodNumber>;
+        footprintBoundsMeters: z.ZodObject<{
+            minX: z.ZodNumber;
+            maxX: z.ZodNumber;
+            minZ: z.ZodNumber;
+            maxZ: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    skippedItems: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    unsupportedChecks: z.ZodArray<z.ZodObject<{
+        check: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
     collisions: z.ZodArray<z.ZodObject<{
         aId: z.ZodString;
         bId: z.ZodString;
         kind: z.ZodString;
+        violation: z.ZodEnum<{
+            overlap: "overlap";
+            clearance: "clearance";
+        }>;
+        minimumClearanceMeters: z.ZodNumber;
     }, z.core.$strip>>;
 };
 export declare function registerCheckCollisions(server: McpServer, bridge: SceneOperations): void;

package/dist/tools/check-collisions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-collisions.d.ts","sourceRoot":"","sources":["../../src/tools/check-collisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAIpD,eAAO,MAAM,oBAAoB;;CAEhC,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;CAQjC,CAAA;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA4CxF"}
+{"version":3,"file":"check-collisions.d.ts","sourceRoot":"","sources":["../../src/tools/check-collisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AA8BpD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;CA+BhC,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDjC,CAAA;AA6BD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyKxF"}

package/dist/tools/check-collisions.js

@@ -1,46 +1,267 @@
+import { ItemNode } from '@pascal-app/core/schema';
 import { z } from 'zod';
-import { findItemItemCollisions } from './layout-clearance';
-import { NodeIdSchema } from './schemas';
+import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
+import { inspectItemPlanFootprint, resolveNodeLevelId } from './door-clearance.js';
+import { ErrorCode, throwMcpError } from './errors.js';
+import { findItemItemCollisions } from './layout-clearance.js';
+import { measurement } from './measurement.js';
+import { computeGraphHash } from './scene-lifecycle/metadata.js';
+import { NodeIdSchema } from './schemas.js';
+const candidatePosition = measurement('length', 'm', {
+    description: 'Candidate position coordinate.',
+});
+const candidateDimension = measurement('length', 'm', {
+    positive: true,
+    description: 'Candidate declared size.',
+});
+const vector3 = (component) => z
+    .array(component)
+    .length(3)
+    .transform((values, ctx) => {
+    const [x, y, zValue] = values;
+    if (x === undefined || y === undefined || zValue === undefined) {
+        ctx.addIssue({ code: 'custom', message: 'Expected exactly three values.' });
+        return z.NEVER;
+    }
+    return [x, y, zValue];
+});
+const outputVector3 = z.array(z.number()).length(3);
 export const checkCollisionsInput = {
     levelId: NodeIdSchema.optional(),
+    minimumClearance: measurement('length', 'm', {
+        min: 0,
+        description: 'Minimum free plan-space required between item footprints.',
+    }).default(0),
+    floorOnly: z
+        .boolean()
+        .default(false)
+        .describe('When true, wall-, wall-side-, and ceiling-attached items are excluded.'),
+    candidate: z
+        .object({
+        id: z.string().min(1).max(120).default('candidate'),
+        name: z.string().min(1).max(200).default('Candidate item'),
+        levelId: NodeIdSchema,
+        position: vector3(candidatePosition),
+        dimensions: vector3(candidateDimension),
+        rotationY: measurement('angle', 'rad', {
+            description: 'Candidate yaw around the vertical axis.',
+        }).default(0),
+        source: z
+            .object({
+            assetId: z.string().min(1).optional(),
+            uri: z.string().min(1).optional(),
+        })
+            .optional(),
+    })
+        .optional()
+        .describe('Read-only prospective furniture item. It is checked against the target level but never added to the scene.'),
 };
 export const checkCollisionsOutput = {
+    status: z.enum(['checked', 'partial', 'insufficient_evidence']),
+    units: z.literal('meters'),
+    method: z.literal('rotation-aware-plan-aabb'),
+    assessmentGraphHash: z.string(),
+    minimumClearanceMeters: z.number(),
+    floorOnly: z.boolean(),
+    candidateItemId: z.string().nullable(),
+    checkedItems: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        levelId: z.string().nullable(),
+        positionMeters: outputVector3,
+        rotationYRadians: z.number(),
+        source: z.object({
+            assetId: z.string(),
+            uri: z.string(),
+            catalog: z.string(),
+        }),
+        sourceDimensionsMeters: outputVector3,
+        effectiveDimensionsMeters: outputVector3,
+        footprintBoundsMeters: z.object({
+            minX: z.number(),
+            maxX: z.number(),
+            minZ: z.number(),
+            maxZ: z.number(),
+        }),
+    })),
+    skippedItems: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        reason: z.string(),
+    })),
+    unsupportedChecks: z.array(z.object({
+        check: z.string(),
+        reason: z.string(),
+    })),
     collisions: z.array(z.object({
         aId: z.string(),
         bId: z.string(),
         kind: z.string(),
+        violation: z.enum(['overlap', 'clearance']),
+        minimumClearanceMeters: z.number(),
     })),
 };
+const unsupportedChecks = [
+    {
+        check: 'vertical_clearance',
+        reason: 'This check uses the X/Z plan footprint only and does not prove height clearance.',
+    },
+    {
+        check: 'room_boundary_clearance',
+        reason: 'The tool compares items with other items and does not prove containment in a room.',
+    },
+    {
+        check: 'door_swing_envelope',
+        reason: 'Door swing geometry is not evaluated by check_collisions.',
+    },
+    {
+        check: 'delivery_path',
+        reason: 'No route, turning-radius, stair, or opening traversal is evaluated.',
+    },
+    {
+        check: 'mesh_geometry',
+        reason: 'Asset meshes are not loaded; the check uses declared rectangular dimensions.',
+    },
+    {
+        check: 'hosted_item_world_transform',
+        reason: 'Items positioned in a non-level parent frame are skipped instead of approximated.',
+    },
+];
 export function registerCheckCollisions(server, bridge) {
     server.registerTool('check_collisions', {
         title: 'Check collisions',
-        description: 'Detect overlapping item footprints via a rotation-aware plan AABB test. Optionally scoped to a single level (items parented to that level).',
+        description: 'Assess declared item footprints with a rotation-aware plan AABB test. Supports an explicit minimum clearance and reports units, source dimensions, skipped evidence, and unsupported checks. Optionally scope to one level or floor-standing items.',
         inputSchema: checkCollisionsInput,
         outputSchema: checkCollisionsOutput,
-    }, async ({ levelId }) => {
-        const nodes = Object.values(bridge.getNodes());
-        let scoped = nodes;
-        if (levelId) {
-            const levelItems = new Set(bridge
-                .findNodes({ type: 'item', levelId: levelId })
-                .map((n) => n.id));
-            scoped = nodes.filter((n) => n.type !== 'item' || levelItems.has(n.id));
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    }, async ({ levelId, minimumClearance, floorOnly, candidate }) => {
+        const sceneNodes = Object.values(bridge.getNodes());
+        if (candidate && levelId && candidate.levelId !== levelId) {
+            throwMcpError(ErrorCode.InvalidParams, 'candidate.levelId must match levelId when both are provided');
+        }
+        const scopeLevelId = candidate?.levelId ?? levelId;
+        if (scopeLevelId) {
+            const target = sceneNodes.find((node) => node.id === scopeLevelId);
+            if (target?.type !== 'level') {
+                throwMcpError(ErrorCode.InvalidParams, `Level not found: ${scopeLevelId}`);
+            }
         }
-        // gap: 0 keeps this tool's contract — it reports *actual* overlap.
-        // findItemItemCollisions defaults to DEFAULT_ITEM_GAP (8cm), which is the
-        // breathing room furnish_room wants when placing new items; applied here
-        // it would report items merely standing close together as colliding.
+        if (candidate) {
+            if (sceneNodes.some((node) => node.id === candidate.id)) {
+                throwMcpError(ErrorCode.InvalidParams, `Candidate id already exists: ${candidate.id}`);
+            }
+        }
+        const candidateNode = candidate
+            ? ItemNode.parse({
+                object: 'node',
+                type: 'item',
+                parentId: candidate.levelId,
+                visible: true,
+                metadata: {},
+                name: candidate.name,
+                position: candidate.position,
+                rotation: [0, candidate.rotationY, 0],
+                scale: [1, 1, 1],
+                children: [],
+                asset: {
+                    id: candidate.source?.assetId ?? 'supplied-dimensions',
+                    name: candidate.name,
+                    category: 'furniture',
+                    thumbnail: '',
+                    source: 'library',
+                    src: 'asset://supplied-dimensions',
+                    dimensions: candidate.dimensions,
+                    offset: [0, 0, 0],
+                    rotation: [0, 0, 0],
+                    scale: [1, 1, 1],
+                },
+            })
+            : null;
+        const nodes = candidateNode ? [...sceneNodes, candidateNode] : sceneNodes;
+        const byId = new Map(nodes.map((node) => [node.id, node]));
+        const scoped = nodes.filter((node) => {
+            if (node.type !== 'item' || !scopeLevelId)
+                return true;
+            return resolveNodeLevelId(node.id, byId) === scopeLevelId;
+        });
+        const checkedItems = [];
+        const skippedItems = [];
+        for (const node of scoped) {
+            if (node.type !== 'item')
+                continue;
+            const resolvedLevelId = node === candidateNode ? candidate.levelId : bridge.resolveLevelId(node.id);
+            if (!resolvedLevelId) {
+                skippedItems.push({
+                    id: node.id,
+                    name: node.name ?? node.asset.name ?? node.id,
+                    reason: 'unresolved_level',
+                });
+                continue;
+            }
+            const immediateParent = node === candidateNode ? byId.get(candidate.levelId) : bridge.getAncestry(node.id)[1];
+            if (immediateParent && immediateParent.type !== 'level') {
+                skippedItems.push({
+                    id: node.id,
+                    name: node.name ?? node.asset.name ?? node.id,
+                    reason: floorOnly ? 'unsupported_attachment' : 'parent_local_coordinates',
+                });
+                continue;
+            }
+            const inspected = inspectItemPlanFootprint(node, { floorOnly });
+            const name = node.name ?? node.asset.name ?? node.id;
+            if (!inspected.ok) {
+                skippedItems.push({ id: node.id, name, reason: inspected.reason });
+                continue;
+            }
+            checkedItems.push({
+                id: node === candidateNode ? candidate.id : node.id,
+                name,
+                levelId: resolvedLevelId,
+                positionMeters: node.position,
+                rotationYRadians: inspected.rotationY,
+                source: {
+                    assetId: node === candidateNode
+                        ? (candidate.source?.assetId ?? 'supplied-dimensions')
+                        : node.asset.id,
+                    uri: node === candidateNode
+                        ? (candidate.source?.uri ?? 'supplied://dimensions')
+                        : node.asset.src,
+                    catalog: node === candidateNode ? 'supplied' : (node.asset.source ?? 'unknown'),
+                },
+                sourceDimensionsMeters: inspected.sourceDimensions,
+                effectiveDimensionsMeters: inspected.effectiveDimensions,
+                footprintBoundsMeters: inspected.aabb,
+            });
+        }
+        const checkedItemIds = new Set(checkedItems.map((item) => (item.id === candidate?.id ? candidateNode.id : item.id)));
         const found = findItemItemCollisions({
-            nodes: scoped,
-            levelId: levelId,
-            gap: 0,
+            nodes: scoped.filter((node) => (node.type === 'item' ? checkedItemIds.has(node.id) : true)),
+            gap: minimumClearance,
         });
         const collisions = found.map((c) => ({
-            aId: c.aId,
-            bId: c.bId,
+            aId: c.aId === candidateNode?.id ? candidate.id : c.aId,
+            bId: c.bId === candidateNode?.id ? candidate.id : c.bId,
             kind: c.kind,
+            violation: c.violation,
+            minimumClearanceMeters: c.minimumClearanceMeters,
         }));
-        const payload = { collisions };
+        const payload = {
+            status: checkedItems.length === 0 && skippedItems.length > 0
+                ? 'insufficient_evidence'
+                : skippedItems.length > 0
+                    ? 'partial'
+                    : 'checked',
+            units: 'meters',
+            method: 'rotation-aware-plan-aabb',
+            assessmentGraphHash: computeGraphHash(bridge.exportJSON()),
+            minimumClearanceMeters: minimumClearance,
+            floorOnly,
+            candidateItemId: candidate?.id ?? null,
+            checkedItems,
+            skippedItems,
+            unsupportedChecks: [...unsupportedChecks],
+            collisions,
+        };
         return {
             content: [{ type: 'text', text: JSON.stringify(payload) }],
             structuredContent: payload,

package/dist/tools/construction-tools.d.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import type { SceneOperations } from '../operations';
+import type { SceneOperations } from '../operations/index.js';
 export declare const createStoryShellInput: {
     levelId: z.ZodString;
     footprint: z.ZodArray<z.ZodArray<z.ZodNumber>>;
@@ -16,6 +16,13 @@ export declare const createStoryShellInput: {
     ceilingMaterialPreset: z.ZodOptional<z.ZodString>;
 };
 export declare const createStoryShellOutput: {
+    persistence: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            unbound: "unbound";
+            events_unsupported: "events_unsupported";
+        }>;
+        warning: z.ZodString;
+    }, z.core.$strip>>;
     levelId: z.ZodString;
     wallIds: z.ZodArray<z.ZodString>;
     slabId: z.ZodNullable<z.ZodString>;
@@ -33,13 +40,14 @@ export declare const createRoofInput: {
     width: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
     depth: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
     roofType: z.ZodDefault<z.ZodEnum<{
+        gable: "gable";
         flat: "flat";
         hip: "hip";
-        gable: "gable";
         shed: "shed";
         gambrel: "gambrel";
         dutch: "dutch";
         mansard: "mansard";
+        conical: "conical";
     }>>;
     pitch: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     wallHeight: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
@@ -49,6 +57,13 @@ export declare const createRoofInput: {
     name: z.ZodOptional<z.ZodString>;
 };
 export declare const createRoofOutput: {
+    persistence: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            unbound: "unbound";
+            events_unsupported: "events_unsupported";
+        }>;
+        warning: z.ZodString;
+    }, z.core.$strip>>;
     referenceLevelId: z.ZodString;
     roofLevelId: z.ZodString;
     createdRoofLevelId: z.ZodNullable<z.ZodString>;
@@ -83,6 +98,13 @@ export declare const createStairBetweenLevelsInput: {
     name: z.ZodOptional<z.ZodString>;
 };
 export declare const createStairBetweenLevelsOutput: {
+    persistence: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            unbound: "unbound";
+            events_unsupported: "events_unsupported";
+        }>;
+        warning: z.ZodString;
+    }, z.core.$strip>>;
     stairId: z.ZodString;
     stairSegmentId: z.ZodString;
     destinationSlabId: z.ZodNullable<z.ZodString>;

package/dist/tools/construction-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"construction-tools.d.ts","sourceRoot":"","sources":["../../src/tools/construction-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAcxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAQpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;CAsBjC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;CAMlC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCzC,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;;CAM1C,CAAA;AA4GD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAmU1F"}
+{"version":3,"file":"construction-tools.d.ts","sourceRoot":"","sources":["../../src/tools/construction-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAcxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAkBpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;CAsBjC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;CAOlC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAO5B,CAAA;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCzC,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;CAO1C,CAAA;AA4GD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgV1F"}

package/dist/tools/construction-tools.js

@@ -1,10 +1,20 @@
 import { resolveStairTotalRise } from '@pascal-app/core';
 import { CeilingNode, getActiveRoofHeight, LevelNode, RoofNode, RoofSegmentNode, SlabNode, StairNode, StairSegmentNode, WallNode, } from '@pascal-app/core/schema';
 import { z } from 'zod';
-import { publishLiveSceneSnapshot } from './live-sync';
-import { measurement } from './measurement';
-import { NodeIdSchema, Vec2Schema, Vec3Schema } from './schemas';
-const ROOF_TYPES = ['hip', 'gable', 'shed', 'gambrel', 'dutch', 'mansard', 'flat'];
+import { ADDITIVE_TOOL_ANNOTATIONS, DESTRUCTIVE_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';
+const ROOF_TYPES = [
+    'hip',
+    'gable',
+    'shed',
+    'gambrel',
+    'dutch',
+    'mansard',
+    'flat',
+    'conical',
+];
 const RAILING_MODES = ['none', 'left', 'right', 'both'];
 export const createStoryShellInput = {
     levelId: NodeIdSchema,
@@ -35,6 +45,7 @@ export const createStoryShellOutput = {
     slabId: z.string().nullable(),
     ceilingId: z.string().nullable(),
     createdIds: z.array(z.string()),
+    ...liveSyncOutput,
 };
 export const createRoofInput = {
     levelId: NodeIdSchema,
@@ -67,6 +78,7 @@ export const createRoofOutput = {
     createdRoofLevelId: z.string().nullable(),
     roofId: z.string(),
     roofSegmentId: z.string(),
+    ...liveSyncOutput,
 };
 export const createStairBetweenLevelsInput = {
     fromLevelId: NodeIdSchema,
@@ -108,6 +120,7 @@ export const createStairBetweenLevelsOutput = {
     destinationSlabId: z.string().nullable(),
     sourceCeilingId: z.string().nullable(),
     openingPolygon: z.array(Vec2Schema),
+    ...liveSyncOutput,
 };
 function textResult(payload) {
     return {
@@ -190,6 +203,7 @@ export function registerConstructionTools(server, bridge) {
         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.',
         inputSchema: createStoryShellInput,
         outputSchema: createStoryShellOutput,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
     }, async ({ levelId, footprint, wallHeight, wallThickness, createSlab, createCeiling, slabElevation, ceilingHeight, namePrefix, wallMaterialPreset, slabMaterialPreset, ceilingMaterialPreset, }) => {
         const level = assertNode(bridge, levelId, 'level');
         if (isRoofLevel(level)) {
@@ -246,13 +260,14 @@ export function registerConstructionTools(server, bridge) {
             patches.push({ op: 'create', node: ceiling, parentId: levelId });
         }
         const result = bridge.applyPatch(patches);
-        await publishLiveSceneSnapshot(bridge, 'create_story_shell');
+        const persistence = await publishLiveSceneSnapshot(bridge, 'create_story_shell');
         return textResult({
             levelId,
             wallIds,
             slabId,
             ceilingId,
             createdIds: result.createdIds,
+            ...persistencePayload(persistence),
         });
     });
     server.registerTool('create_roof', {
@@ -260,10 +275,18 @@ export function registerConstructionTools(server, bridge) {
         description: 'Create a roof container with one roof segment. By default creates a dedicated roof level above the reference level so exploded/solo level views can isolate the roof.',
         inputSchema: createRoofInput,
         outputSchema: createRoofOutput,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
     }, async ({ levelId, roofLevelId, useDedicatedRoofLevel, roofLevelLabel, roofLevelElevation, roofLevelHeight, center, width, depth, roofType, pitch, wallHeight, wallThickness, overhang, materialPreset, name, }) => {
+        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
         // need it to size the auto-generated roof level container below.
-        const peakHeight = getActiveRoofHeight({ roofType, pitch, width, depth });
+        const peakHeight = getActiveRoofHeight({
+            roofType,
+            pitch,
+            width: effectiveWidth,
+            depth: effectiveDepth,
+        });
         const referenceLevel = assertNode(bridge, levelId, 'level');
         const patches = [];
         let targetRoofLevelId = levelId;
@@ -294,8 +317,8 @@ export function registerConstructionTools(server, bridge) {
         }
         const segment = RoofSegmentNode.parse({
             roofType,
-            width,
-            depth,
+            width: effectiveWidth,
+            depth: effectiveDepth,
             wallHeight,
             pitch,
             wallThickness,
@@ -317,13 +340,14 @@ export function registerConstructionTools(server, bridge) {
             { op: 'create', node: roof, parentId: targetRoofLevelId },
             { op: 'create', node: segment, parentId: roof.id },
         ]);
-        await publishLiveSceneSnapshot(bridge, 'create_roof');
+        const persistence = await publishLiveSceneSnapshot(bridge, 'create_roof');
         return textResult({
             referenceLevelId: levelId,
             roofLevelId: targetRoofLevelId,
             createdRoofLevelId,
             roofId: roof.id,
             roofSegmentId: segment.id,
+            ...persistencePayload(persistence),
         });
     });
     server.registerTool('create_stair_between_levels', {
@@ -331,6 +355,7 @@ export function registerConstructionTools(server, bridge) {
         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');
@@ -408,13 +433,14 @@ export function registerConstructionTools(server, bridge) {
             });
         }
         bridge.applyPatch(patches);
-        await publishLiveSceneSnapshot(bridge, 'create_stair_between_levels');
+        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-level.d.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import type { SceneOperations } from '../operations';
+import type { SceneOperations } from '../operations/index.js';
 export declare const createLevelInput: {
     buildingId: z.ZodString;
     elevation: z.ZodOptional<z.ZodNumber>;
@@ -8,6 +8,13 @@ export declare const createLevelInput: {
     label: z.ZodOptional<z.ZodString>;
 };
 export declare const createLevelOutput: {
+    persistence: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            unbound: "unbound";
+            events_unsupported: "events_unsupported";
+        }>;
+        warning: z.ZodString;
+    }, z.core.$strip>>;
     levelId: z.ZodString;
 };
 export declare function registerCreateLevel(server: McpServer, bridge: SceneOperations): void;

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

@@ -1 +1 @@
-{"version":3,"file":"create-level.d.ts","sourceRoot":"","sources":["../../src/tools/create-level.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;AAMpD,eAAO,MAAM,gBAAgB;;;;;CAW5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;CAE7B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA+CpF"}
+{"version":3,"file":"create-level.d.ts","sourceRoot":"","sources":["../../src/tools/create-level.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;AAOpD,eAAO,MAAM,gBAAgB;;;;;CAW5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;CAG7B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgDpF"}