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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pascal Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bridge/scene-bridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-bridge.d.ts","sourceRoot":"","sources":["../../src/bridge/scene-bridge.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"scene-bridge.d.ts","sourceRoot":"","sources":["../../src/bridge/scene-bridge.ts"],"names":[],"mappings":"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"}

package/dist/bridge/scene-bridge.js

@@ -1,6 +1,6 @@
 // Side-effect import MUST come first: installs RAF polyfill before core loads.
 import './node-shims';
-import { AnyNode as AnyNodeSchema } from '@pascal-app/core/schema';
+import { AnyNode as AnyNodeSchema, parseNode, } from '@pascal-app/core/schema';
 // Per PLAN §0.6: `useScene` is the DEFAULT export from `@pascal-app/core/store`.
 import useScene from '@pascal-app/core/store';
 /**
@@ -294,7 +294,7 @@ export class SceneBridge {
             if (!p)
                 throw new Error(`invalid patch: patches[${i}] is undefined`);
             if (p.op === 'create') {
-                const res = AnyNodeSchema.safeParse(p.node);
+                const res = parseNode(p.node);
                 if (!res.success) {
                     throw new Error(`invalid patch: patches[${i}] create node failed schema: ${res.error.message}`);
                 }

package/dist/server.d.ts

@@ -2,6 +2,11 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { SceneBridge } from './bridge/scene-bridge';
 import { type SceneOperations } from './operations';
 import type { SceneStore } from './storage/types';
+export type PascalMcpToolExecutor = <Result>(input: {
+    name: string;
+    signal: AbortSignal;
+    execute: () => Promise<Result>;
+}) => Promise<Result>;
 export type CreatePascalMcpServerOptions = {
     bridge: SceneBridge;
     operations?: SceneOperations;
@@ -9,6 +14,12 @@ export type CreatePascalMcpServerOptions = {
     store?: SceneStore;
     name?: string;
     version?: string;
+    /**
+     * Wrap every regular tool handler, including callback updates.
+     * Tool renames fail closed because the SDK registration lifecycle cannot safely rename twice.
+     * Experimental task-based tool registrations are outside this hook.
+     */
+    executeTool?: PascalMcpToolExecutor;
 };
 export declare function createPascalMcpServer(opts: CreatePascalMcpServerOptions): McpServer;
 //# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,cAAc,CAAA;AAG1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAKjD,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,WAAW,CAAA;IACnB,UAAU,CAAC,EAAE,eAAe,CAAA;IAC5B,mFAAmF;IACnF,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,4BAA4B,GAAG,SAAS,CAYnF"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAuB,MAAM,yCAAyC,CAAA;AACxF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,cAAc,CAAA;AAG1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAKjD,MAAM,MAAM,qBAAqB,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE;IAClD,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,WAAW,CAAA;IACnB,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CAC/B,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;AAErB,MAAM,MAAM,4BAA4B,GAAG;IACzC,MAAM,EAAE,WAAW,CAAA;IACnB,UAAU,CAAC,EAAE,eAAe,CAAA;IAC5B,mFAAmF;IACnF,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,WAAW,CAAC,EAAE,qBAAqB,CAAA;CACpC,CAAA;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,4BAA4B,GAAG,SAAS,CAanF"}

package/dist/server.js

@@ -10,6 +10,8 @@ export function createPascalMcpServer(opts) {
         name: opts.name ?? 'pascal-mcp-server',
         version: opts.version ?? version,
     });
+    if (opts.executeTool)
+        installToolExecutor(server, opts.executeTool);
     const operations = opts.operations ?? createSceneOperations({ bridge: opts.bridge, store: opts.store });
     registerTools(server, operations);
     registerVisionTools(server, operations);
@@ -17,3 +19,53 @@ export function createPascalMcpServer(opts) {
     registerPrompts(server, operations);
     return server;
 }
+function installToolExecutor(server, executeTool) {
+    const registerTool = server.registerTool.bind(server);
+    const wrappedRegisterTool = (name, config, callback) => {
+        const runtimeCallback = callback;
+        const registration = registerTool(name, config, wrapToolCallback(name, runtimeCallback, executeTool));
+        return wrapRegisteredTool(registration, name, runtimeCallback, executeTool);
+    };
+    server.registerTool = wrappedRegisterTool;
+    const tool = server.tool.bind(server);
+    server.tool = ((name, ...args) => {
+        const callback = args.at(-1);
+        if (typeof callback !== 'function') {
+            return Reflect.apply(tool, undefined, [name, ...args]);
+        }
+        const runtimeCallback = callback;
+        args[args.length - 1] = wrapToolCallback(name, runtimeCallback, executeTool);
+        const registration = Reflect.apply(tool, undefined, [name, ...args]);
+        return wrapRegisteredTool(registration, name, runtimeCallback, executeTool);
+    });
+}
+function wrapToolCallback(name, callback, executeTool) {
+    return (...args) => executeTool({
+        name,
+        signal: toolRequestSignal(args),
+        execute: () => Promise.resolve(Reflect.apply(callback, undefined, args)),
+    });
+}
+function wrapRegisteredTool(registration, initialName, initialCallback, executeTool) {
+    let currentCallback = initialCallback;
+    const update = registration.update.bind(registration);
+    registration.update = ((updates) => {
+        if (typeof updates.name === 'string') {
+            throw new Error('MCP tool renaming is unsupported when executeTool is configured');
+        }
+        const callbackUpdate = updates.callback;
+        if (typeof callbackUpdate === 'function') {
+            currentCallback = callbackUpdate;
+        }
+        update({
+            ...updates,
+            ...(typeof callbackUpdate === 'function'
+                ? { callback: wrapToolCallback(initialName, currentCallback, executeTool) }
+                : {}),
+        });
+    });
+    return registration;
+}
+function toolRequestSignal(args) {
+    return args.at(-1).signal;
+}

package/dist/tools/annotations.d.ts

@@ -0,0 +1,28 @@
+export declare const READ_ONLY_TOOL_ANNOTATIONS: {
+    readonly readOnlyHint: true;
+    readonly destructiveHint: false;
+    readonly idempotentHint: true;
+    readonly openWorldHint: false;
+};
+export declare const READ_ONLY_OPEN_WORLD_TOOL_ANNOTATIONS: {
+    readonly readOnlyHint: true;
+    readonly destructiveHint: false;
+    readonly idempotentHint: true;
+    readonly openWorldHint: true;
+};
+export declare const ADDITIVE_TOOL_ANNOTATIONS: {
+    readonly readOnlyHint: false;
+    readonly destructiveHint: false;
+    readonly openWorldHint: false;
+};
+export declare const DESTRUCTIVE_TOOL_ANNOTATIONS: {
+    readonly readOnlyHint: false;
+    readonly destructiveHint: true;
+    readonly openWorldHint: false;
+};
+export declare const DESTRUCTIVE_OPEN_WORLD_TOOL_ANNOTATIONS: {
+    readonly readOnlyHint: false;
+    readonly destructiveHint: true;
+    readonly openWorldHint: true;
+};
+//# sourceMappingURL=annotations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"annotations.d.ts","sourceRoot":"","sources":["../../src/tools/annotations.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B;;;;;CAK7B,CAAA;AAEV,eAAO,MAAM,qCAAqC;;;;;CAKxC,CAAA;AAEV,eAAO,MAAM,yBAAyB;;;;CAI5B,CAAA;AAEV,eAAO,MAAM,4BAA4B;;;;CAI/B,CAAA;AAEV,eAAO,MAAM,uCAAuC;;;;CAI1C,CAAA"}

package/dist/tools/annotations.js

@@ -0,0 +1,27 @@
+export const READ_ONLY_TOOL_ANNOTATIONS = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+export const READ_ONLY_OPEN_WORLD_TOOL_ANNOTATIONS = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true,
+};
+export const ADDITIVE_TOOL_ANNOTATIONS = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: false,
+};
+export const DESTRUCTIVE_TOOL_ANNOTATIONS = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    openWorldHint: false,
+};
+export const DESTRUCTIVE_OPEN_WORLD_TOOL_ANNOTATIONS = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    openWorldHint: true,
+};

package/dist/tools/apply-patch.d.ts

@@ -17,6 +17,13 @@ export declare const applyPatchInput: {
     }, z.core.$strip>], "op">>;
 };
 export declare const applyPatchOutput: {
+    persistence: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            unbound: "unbound";
+            events_unsupported: "events_unsupported";
+        }>;
+        warning: z.ZodString;
+    }, z.core.$strip>>;
     appliedOps: z.ZodNumber;
     deletedIds: z.ZodArray<z.ZodString>;
     createdIds: z.ZodArray<z.ZodString>;

package/dist/tools/apply-patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply-patch.d.ts","sourceRoot":"","sources":["../../src/tools/apply-patch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;CAE3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;CAI5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAmDnF"}
+{"version":3,"file":"apply-patch.d.ts","sourceRoot":"","sources":["../../src/tools/apply-patch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAMpD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;CAE3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAK5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAqDnF"}

package/dist/tools/apply-patch.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
+import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations';
 import { ErrorCode, throwMcpError } from './errors';
-import { publishLiveSceneSnapshot } from './live-sync';
+import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync';
 import { PatchSchema } from './schemas';
 export const applyPatchInput = {
     patches: z.array(PatchSchema),
@@ -9,6 +10,7 @@ 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', {
@@ -16,6 +18,7 @@ export function registerApplyPatch(server, bridge) {
         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.',
         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

@@ -3,12 +3,71 @@ import { z } from 'zod';
 import type { SceneOperations } from '../operations';
 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 { READ_ONLY_TOOL_ANNOTATIONS } from './annotations';
+import { inspectItemPlanFootprint, resolveNodeLevelId } from './door-clearance';
+import { ErrorCode, throwMcpError } from './errors';
 import { findItemItemCollisions } from './layout-clearance';
+import { measurement } from './measurement';
+import { computeGraphHash } from './scene-lifecycle/metadata';
 import { NodeIdSchema } from './schemas';
+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,