@pascal-app/mcp 1.0.1 → 1.0.4

package/dist/tools/find-nodes.js

@@ -1,84 +1,179 @@
+import { measurementCentroid, nodeRegistry } from '@pascal-app/core';
+import { nodeLevelFrame, transformPoint } from '@pascal-app/core/procedural-items';
+import { AnyNode, nodeKindOf } from '@pascal-app/core/schema';
 import { pointInPolygon } from '@pascal-app/core/spatial-grid';
 import { z } from 'zod';
 import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
+import { ErrorCode, throwMcpError } from './errors.js';
 import { NodeIdSchema } from './schemas.js';
-const ALL_NODE_TYPES = [
-    'site',
-    'building',
-    'level',
-    'wall',
-    'fence',
-    'zone',
-    'slab',
-    'ceiling',
-    'roof',
-    'roof-segment',
-    'stair',
-    'stair-segment',
-    'item',
-    'door',
-    'window',
-    'scan',
-    'guide',
-];
+const CORE_NODE_KINDS = AnyNode.options.map(nodeKindOf);
 export const findNodesInput = {
-    type: z.enum(ALL_NODE_TYPES).optional(),
+    type: z
+        .string()
+        .min(1)
+        .optional()
+        .describe(`Node kind: a core kind (${CORE_NODE_KINDS.join(', ')}) or a plugin kind such as "fixture:bench".`),
     parentId: NodeIdSchema.optional(),
     levelId: NodeIdSchema.optional(),
     zoneId: NodeIdSchema.optional(),
+    sourceId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Exact match on any import source id of the node: provenance.refs[].id or legacy metadata.sourceIds. Characters outside printable ASCII also match their percent-encoded form.'),
+    sourceIdPrefix: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Prefix match on any import source id of the node (provenance.refs[].id or legacy metadata.sourceIds).'),
 };
 export const findNodesOutput = {
     nodes: z.array(z.record(z.string(), z.unknown())),
 };
-/** Compute a representative 2D point (x, z) for zone-filtering. */
-function getPointForZoneFilter(node) {
-    if (node.type === 'wall' || node.type === 'fence') {
-        const [x1, z1] = node.start;
-        const [x2, z2] = node.end;
+/**
+ * A source id as importers must write it for typed provenance: printable
+ * ASCII kept, every other character percent-encoded as UTF-8 bytes.
+ */
+function encodeSourceId(id) {
+    let out = '';
+    for (const char of id) {
+        if (/^[\x20-\x7E]$/.test(char)) {
+            out += char;
+            continue;
+        }
+        for (const byte of new TextEncoder().encode(char)) {
+            out += `%${byte.toString(16).toUpperCase().padStart(2, '0')}`;
+        }
+    }
+    return out;
+}
+/** A node's import source ids: typed `provenance.refs[].id`, then legacy `metadata.sourceIds`. */
+function nodeSourceIds(node) {
+    const typed = (node.provenance?.refs ?? []).map((ref) => ref.id);
+    const legacy = node.metadata?.sourceIds;
+    return Array.isArray(legacy)
+        ? [...typed, ...legacy.filter((id) => typeof id === 'string')]
+        : typed;
+}
+function centre(points) {
+    if (points.length === 0)
+        return null;
+    const area = measurementCentroid(points.map(([x, z]) => [x, 0, z]));
+    if (area)
+        return [area[0], area[2]];
+    let cx = 0;
+    let cz = 0;
+    for (const [x, z] of points) {
+        cx += x;
+        cz += z;
+    }
+    return [cx / points.length, cz / points.length];
+}
+function boundsCentre3(points) {
+    if (points.length === 0)
+        return null;
+    const centre = [0, 0, 0];
+    for (let axis = 0; axis < 3; axis++) {
+        const values = points.map((p) => p[axis]);
+        centre[axis] = (Math.min(...values) + Math.max(...values)) / 2;
+    }
+    return centre;
+}
+/**
+ * The node's plan point in its level's frame, for zone filtering: a polygon's
+ * area centroid, a segment's midpoint, a path's centre, or the origin of a
+ * positioned node resolved through its hosts by core's `nodeLevelFrame` (a
+ * window in its wall, a module in its cabinet); blocks and imported meshes
+ * use their vertex-bounds centre, transformed in 3D before projecting.
+ * Frames are plan-only (no slab support or floor lift, which only move
+ * heights) and `frames` is shared across one query, so each host resolves once.
+ */
+function levelPlanPoint(node, nodes, frames) {
+    const n = node;
+    if (Array.isArray(n.polygon))
+        return centre(n.polygon);
+    if (Array.isArray(n.start) && Array.isArray(n.end)) {
+        const [x1, z1] = n.start;
+        const [x2, z2] = n.end;
         return [(x1 + x2) / 2, (z1 + z2) / 2];
     }
-    if (node.type === 'item' ||
-        node.type === 'door' ||
-        node.type === 'window' ||
-        node.type === 'building' ||
-        node.type === 'stair' ||
-        node.type === 'roof') {
-        const [x, , z] = node.position;
-        return [x, z];
+    if (Array.isArray(n.path)) {
+        const path = boundsCentre3(n.path);
+        return path ? [path[0], path[2]] : null;
     }
-    if (node.type === 'slab' || node.type === 'ceiling' || node.type === 'zone') {
-        const poly = node.polygon;
-        if (!poly || poly.length === 0)
-            return null;
-        let cx = 0;
-        let cz = 0;
-        for (const [x, z] of poly) {
-            cx += x;
-            cz += z;
-        }
-        return [cx / poly.length, cz / poly.length];
+    if (!Array.isArray(n.position))
+        return null;
+    let frame;
+    try {
+        frame = nodeLevelFrame(node.id, nodes, undefined, { cache: frames, planOnly: true });
     }
-    return null;
+    catch {
+        return null;
+    }
+    const local = node.type === 'block'
+        ? boundsCentre3(node.topology.vertices.map((v) => v.position))
+        : node.type === 'imported-mesh'
+            ? boundsCentre3(node.primitives.flatMap((primitive) => {
+                const out = [];
+                for (let i = 0; i + 2 < primitive.positions.length; i += 3) {
+                    out.push([
+                        primitive.positions[i],
+                        primitive.positions[i + 1],
+                        primitive.positions[i + 2],
+                    ]);
+                }
+                return out;
+            }))
+            : null;
+    const [x, , z] = transformPoint(frame, local ?? [0, 0, 0]);
+    return [x, z];
+}
+/** Node kinds `type` accepts: core kinds, registered plugin kinds, and kinds in the scene. */
+function knownNodeKinds(nodes) {
+    const kinds = new Set(CORE_NODE_KINDS);
+    for (const node of Object.values(nodes))
+        kinds.add(node.type);
+    return kinds;
 }
 export function registerFindNodes(server, bridge) {
     server.registerTool('find_nodes', {
         title: 'Find nodes',
-        description: 'Find nodes matching any combination of type, parentId, levelId, or zoneId filters.',
+        description: 'Find nodes matching any combination of type, parentId, levelId, zoneId, sourceId or sourceIdPrefix filters. sourceId / sourceIdPrefix match the ids an importer recorded for the source elements: provenance.refs[].id, or legacy metadata.sourceIds.',
         inputSchema: findNodesInput,
         outputSchema: findNodesOutput,
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
     }, async (args) => {
-        const { type, parentId, levelId, zoneId } = args;
+        const { type, parentId, levelId, zoneId, sourceId, sourceIdPrefix } = args;
         // Delegate type/parent/level filtering to the bridge.
         const baseFilter = {};
-        if (type !== undefined)
+        if (type !== undefined) {
+            if (!(knownNodeKinds(bridge.getNodes()).has(type) || nodeRegistry.get(type))) {
+                throwMcpError(ErrorCode.InvalidParams, `unknown node type "${type}": not a core kind, a registered plugin kind or a kind in this scene`);
+            }
             baseFilter.type = type;
+        }
         if (parentId !== undefined)
             baseFilter.parentId = parentId;
         if (levelId !== undefined)
             baseFilter.levelId = levelId;
         let results = bridge.findNodes(baseFilter);
-        // Zone-polygon filter: point-in-polygon on a representative 2D point.
+        if (sourceId !== undefined || sourceIdPrefix !== undefined) {
+            // Legacy ids may be stored raw, typed-provenance ones percent-encoded.
+            const exact = sourceId === undefined ? [] : [sourceId, encodeSourceId(sourceId)];
+            const prefixes = sourceIdPrefix === undefined ? [] : [sourceIdPrefix, encodeSourceId(sourceIdPrefix)];
+            results = results.filter((n) => {
+                const ids = nodeSourceIds(n);
+                if (sourceId !== undefined && !ids.some((id) => exact.includes(id)))
+                    return false;
+                if (sourceIdPrefix !== undefined &&
+                    !ids.some((id) => prefixes.some((prefix) => id.startsWith(prefix)))) {
+                    return false;
+                }
+                return true;
+            });
+        }
+        // Zone filter: nodes on the zone's level whose level-frame plan point
+        // falls inside the zone polygon.
         if (zoneId) {
             const zone = bridge.getNode(zoneId);
             if (zone?.type !== 'zone') {
@@ -87,12 +182,14 @@ export function registerFindNodes(server, bridge) {
                 results = [];
             }
             else {
-                const poly = zone.polygon;
+                const nodes = bridge.getNodes();
+                const frames = new Map();
+                const zoneLevelId = bridge.resolveLevelId(zone.id);
                 results = results.filter((n) => {
-                    const pt = getPointForZoneFilter(n);
-                    if (!pt)
+                    if (bridge.resolveLevelId(n.id) !== zoneLevelId)
                         return false;
-                    return pointInPolygon(pt[0], pt[1], poly);
+                    const pt = levelPlanPoint(n, nodes, frames);
+                    return pt !== null && pointInPolygon(pt[0], pt[1], zone.polygon);
                 });
             }
         }

package/dist/tools/geometry-script-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=geometry-script-worker.d.ts.map

package/dist/tools/geometry-script-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-script-worker.d.ts","sourceRoot":"","sources":["../../src/tools/geometry-script-worker.ts"],"names":[],"mappings":""}

package/dist/tools/geometry-script-worker.js

@@ -0,0 +1,21 @@
+import { Console } from 'node:console';
+import { compileGeometryScript } from '@pascal-app/geometry-script/compile';
+const stdout = process.stdout;
+// stdout carries only the result; a script's own logging goes to stderr.
+globalThis.console = new Console({ stdout: process.stderr, stderr: process.stderr });
+const chunks = [];
+for await (const chunk of process.stdin)
+    chunks.push(chunk);
+const input = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+for (const name of ['fetch', 'WebSocket', 'EventSource', 'XMLHttpRequest', 'Request', 'Response']) {
+    Reflect.deleteProperty(globalThis, name);
+}
+for (const name of ['getBuiltinModule', 'binding', 'dlopen'])
+    Reflect.deleteProperty(process, name);
+try {
+    const { glb, ...compiled } = await compileGeometryScript(input);
+    stdout.write(JSON.stringify({ ok: true, compiled, glb: Buffer.from(glb).toString('base64') }));
+}
+catch (error) {
+    stdout.write(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+}

package/dist/tools/get-scene.d.ts

@@ -6,6 +6,7 @@ export declare const getSceneOutput: {
     nodes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     rootNodeIds: z.ZodArray<z.ZodString>;
     collections: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    installedPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
 export declare function registerGetScene(server: McpServer, bridge: SceneOperations): void;
 //# sourceMappingURL=get-scene.d.ts.map

package/dist/tools/get-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-scene.d.ts","sourceRoot":"","sources":["../../src/tools/get-scene.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;AAGpD,eAAO,MAAM,aAAa,IAAK,CAAA;AAE/B,eAAO,MAAM,cAAc;;;;CAI1B,CAAA;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAwBjF"}
+{"version":3,"file":"get-scene.d.ts","sourceRoot":"","sources":["../../src/tools/get-scene.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;AAGpD,eAAO,MAAM,aAAa,IAAK,CAAA;AAE/B,eAAO,MAAM,cAAc;;;;;CAK1B,CAAA;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyBjF"}

package/dist/tools/get-scene.js

@@ -5,11 +5,12 @@ export const getSceneOutput = {
     nodes: z.record(z.string(), z.unknown()),
     rootNodeIds: z.array(z.string()),
     collections: z.record(z.string(), z.unknown()).optional(),
+    installedPlugins: z.array(z.string()).optional(),
 };
 export function registerGetScene(server, bridge) {
     server.registerTool('get_scene', {
         title: 'Get scene',
-        description: 'Returns the full scene graph: flat node dictionary, root node IDs, and collections.',
+        description: 'Returns the full scene graph: flat node dictionary, root node IDs, collections, and explicit installed plugin IDs when present.',
         inputSchema: getSceneInput,
         outputSchema: getSceneOutput,
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
@@ -19,6 +20,7 @@ export function registerGetScene(server, bridge) {
             nodes: scene.nodes,
             rootNodeIds: scene.rootNodeIds,
             collections: (scene.collections ?? {}),
+            ...(scene.installedPlugins ? { installedPlugins: scene.installedPlugins } : {}),
         };
         return {
             content: [{ type: 'text', text: JSON.stringify(payload) }],

package/dist/tools/honest-patch-guard.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=honest-patch-guard.d.ts.map

package/dist/tools/honest-patch-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"honest-patch-guard.d.ts","sourceRoot":"","sources":["../../src/tools/honest-patch-guard.ts"],"names":[],"mappings":""}

package/dist/tools/honest-patch-guard.js

@@ -0,0 +1,32 @@
+import { honestNodePatch } from '@pascal-app/core/agent-operations';
+import { isAgentRefusal } from '@pascal-app/core/agent-tools';
+import { PatchRefusedError, registerPatchGuard } from './patch-guards.js';
+/**
+ * Each update checked to do what it says, in the batch's order (a node an earlier op created is
+ * the one updated): a field the node would drop, a material the library lacks or a field a set
+ * one hides is refused, naming it; `null` clears. The cleaned data is what is written.
+ */
+function honestUpdates(patches, scene) {
+    const nodes = { ...scene };
+    for (const [index, patch] of patches.entries()) {
+        if (patch.op === 'create')
+            nodes[patch.node.id] = patch.node;
+        else if (patch.op === 'delete')
+            delete nodes[patch.id];
+        else if (patch.op === 'update') {
+            const current = nodes[patch.id];
+            if (!current)
+                continue;
+            try {
+                patch.data = honestNodePatch(current, patch.data);
+            }
+            catch (error) {
+                if (!isAgentRefusal(error))
+                    throw error;
+                throw new PatchRefusedError(error.code, index, patch.id, error.message);
+            }
+            nodes[patch.id] = { ...current, ...patch.data };
+        }
+    }
+}
+registerPatchGuard({ name: 'honest-updates', order: 20, run: honestUpdates });

package/dist/tools/hosted-services.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type HostedServiceExecutor } from '@pascal-app/core/agent-operations';
+export declare function registerHostedServiceTools(server: McpServer, execute: HostedServiceExecutor): void;
+//# sourceMappingURL=hosted-services.d.ts.map

package/dist/tools/hosted-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-services.d.ts","sourceRoot":"","sources":["../../src/tools/hosted-services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,mCAAmC,CAAA;AAQ1C,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,qBAAqB,GAC7B,IAAI,CA8BN"}

package/dist/tools/hosted-services.js

@@ -0,0 +1,30 @@
+import { executeHostedServiceTool, } from '@pascal-app/core/agent-operations';
+import { HOSTED_SERVICE_TOOL_CONTRACTS, isAgentRefusal, refusalPayload, } from '@pascal-app/core/agent-tools';
+import { z } from 'zod';
+export function registerHostedServiceTools(server, execute) {
+    for (const contract of HOSTED_SERVICE_TOOL_CONTRACTS) {
+        server.registerTool(contract.name, {
+            title: contract.title,
+            description: contract.description,
+            inputSchema: z.object(contract.input).strict(),
+            annotations: contract.annotations,
+        }, async (input, extra) => {
+            try {
+                const result = await executeHostedServiceTool(contract.name, input, execute, extra.signal);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (error) {
+                const result = isAgentRefusal(error)
+                    ? refusalPayload(error)
+                    : {
+                        error: 'Pascal could not complete this service request. Check its retained result before repeating paid work.',
+                        code: 'service_error',
+                    };
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                };
+            }
+        });
+    }
+}

package/dist/tools/index.d.ts

@@ -1,5 +1,8 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { SceneOperations } from '../operations/index.js';
+import { type GeometryScriptHost } from './add-object.js';
+import type { AssetCatalog } from './asset-catalog.js';
+import { type SceneViewHost } from './view-scene.js';
 /**
  * Register every non-vision MCP tool against the given server.
  * Vision tools (analyze_floorplan_image, analyze_room_photo) are registered
@@ -8,5 +11,11 @@ import type { SceneOperations } from '../operations/index.js';
  * Scene-lifecycle tools (save/load/list/delete/rename scene) are registered
  * when persistence operations are available.
  */
-export declare function registerTools(server: McpServer, operations: SceneOperations): void;
+/** What the host lends the tools: its item library, script compiles, a view. */
+export type ToolHosts = {
+    catalog?: AssetCatalog;
+    geometryScripts?: GeometryScriptHost;
+    sceneViews?: SceneViewHost;
+};
+export declare function registerTools(server: McpServer, operations: SceneOperations, { catalog, geometryScripts, sceneViews }?: ToolHosts): void;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AA+BpD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CAgClF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,OAAO,EAAE,KAAK,kBAAkB,EAAwC,MAAM,cAAc,CAAA;AAE5F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAyBnD,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAA;AAEpE;;;;;;;GAOG;AACH,gFAAgF;AAChF,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,CAAC,EAAE,YAAY,CAAA;IACtB,eAAe,CAAC,EAAE,kBAAkB,CAAA;IACpC,UAAU,CAAC,EAAE,aAAa,CAAA;CAC3B,CAAA;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,eAAe,EAC3B,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,GAAE,SAAc,GACvD,IAAI,CAgCN"}

package/dist/tools/index.js

@@ -1,65 +1,56 @@
+import { registerAddColumn } from './add-column.js';
+import { registerAddObject, registerGetSource } from './add-object.js';
 import { registerApplyPatch } from './apply-patch.js';
 import { registerCheckCollisions } from './check-collisions.js';
+import { registerClearScene } from './clear-scene.js';
 import { registerConstructionTools } from './construction-tools.js';
-import { registerCreateLevel } from './create-level.js';
 import { registerCreateUnit } from './create-unit.js';
-import { registerCreateWall } from './create-wall.js';
-import { registerCutOpening } from './cut-opening.js';
-import { registerDeleteNode } from './delete-node.js';
 import { registerDescribeNode } from './describe-node.js';
-import { registerDuplicateLevel } from './duplicate-level.js';
 import { registerExportGlb } from './export-glb.js';
 import { registerExportJson } from './export-json.js';
 import { registerFindNodes } from './find-nodes.js';
-import { registerGetNode } from './get-node.js';
 import { registerGetScene } from './get-scene.js';
 import { registerListUnits } from './list-units.js';
 import { registerMeasure } from './measure.js';
 import { registerPhotoToSceneTool } from './photo-to-scene/index.js';
-import { registerPlaceItem } from './place-item.js';
+import { registerPlaceDesign } from './place-design.js';
 import { registerRedo } from './redo.js';
 import { registerRoomTools } from './room-tools.js';
 import { registerSceneLifecycleTools } from './scene-lifecycle/index.js';
-import { registerSceneQueryTools } from './scene-query.js';
 import { registerSetUnitMembers } from './set-unit-members.js';
 import { registerSetZone } from './set-zone.js';
+import { registerSharedTools } from './shared-tools.js';
 import { registerTemplateTools } from './templates/index.js';
 import { registerUndo } from './undo.js';
+import { registerValidateDesign } from './validate-design.js';
 import { registerValidateScene } from './validate-scene.js';
 import { registerVariantTools } from './variants/index.js';
-/**
- * Register every non-vision MCP tool against the given server.
- * Vision tools (analyze_floorplan_image, analyze_room_photo) are registered
- * separately via `registerVisionTools` (Agent E).
- *
- * Scene-lifecycle tools (save/load/list/delete/rename scene) are registered
- * when persistence operations are available.
- */
-export function registerTools(server, operations) {
+import { registerViewScene } from './view-scene.js';
+export function registerTools(server, operations, { catalog, geometryScripts, sceneViews } = {}) {
     registerGetScene(server, operations);
-    registerGetNode(server, operations);
     registerDescribeNode(server, operations);
     registerFindNodes(server, operations);
-    registerSceneQueryTools(server, operations);
+    registerSharedTools(server, operations, catalog);
+    registerAddColumn(server, operations, geometryScripts);
+    registerAddObject(server, operations, geometryScripts);
+    registerGetSource(server, operations, geometryScripts);
     registerMeasure(server, operations);
+    registerViewScene(server, operations, sceneViews);
     registerConstructionTools(server, operations);
-    registerRoomTools(server, operations);
+    registerRoomTools(server, operations, geometryScripts);
     registerApplyPatch(server, operations);
-    registerCreateLevel(server, operations);
+    registerClearScene(server, operations);
     registerCreateUnit(server, operations);
     registerSetUnitMembers(server, operations);
     registerListUnits(server, operations);
-    registerCreateWall(server, operations);
-    registerPlaceItem(server, operations);
-    registerCutOpening(server, operations);
+    registerPlaceDesign(server, operations);
     registerSetZone(server, operations);
-    registerDuplicateLevel(server, operations);
-    registerDeleteNode(server, operations);
     registerUndo(server, operations);
     registerRedo(server, operations);
     registerExportJson(server, operations);
     registerExportGlb(server, operations);
     registerValidateScene(server, operations);
+    registerValidateDesign(server, operations);
     registerCheckCollisions(server, operations);
     registerTemplateTools(server, operations);
     if (operations.hasStore) {

package/dist/tools/live-sync.d.ts

@@ -1,8 +1,12 @@
 import type { SceneGraph } from '@pascal-app/core/clone-scene-graph';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
-export declare function syncDerivedStairOpenings(operations: SceneOperations): number;
 export type LiveSyncStatus = 'published' | 'unbound' | 'events_unsupported';
+/** Where a write went: the project it reached, or none (a scratch scene). */
+export type LiveSync = {
+    status: LiveSyncStatus;
+    project: string | null;
+};
 type LiveSyncSkip = Exclude<LiveSyncStatus, 'published'>;
 /**
  * Output-schema fragment for every tool that mutates the scene. Spread into
@@ -10,6 +14,8 @@ type LiveSyncSkip = Exclude<LiveSyncStatus, 'published'>;
  * structured-content validation.
  */
 export declare const liveSyncOutput: {
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsaved: z.ZodOptional<z.ZodString>;
     persistence: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
             unbound: "unbound";
@@ -19,15 +25,24 @@ export declare const liveSyncOutput: {
     }, z.core.$strip>>;
 };
 /**
- * Payload fragment matching `liveSyncOutput`: empty after a successful
- * publish, a `persistence` warning when the mutation stayed in-memory.
+ * Payload fragment matching `liveSyncOutput`: the project the write reached, or `null` and a note
+ * when none is bound; a `persistence` warning when the mutation stayed in-memory.
  */
-export declare function persistencePayload(status: LiveSyncStatus): {
+export declare function persistencePayload({ status, project }: LiveSync): {
+    project: string | null;
+    unsaved?: string;
     persistence?: {
         status: LiveSyncSkip;
         warning: string;
     };
 };
+/** Where the session's writes go, for a call that publishes nothing (an undo with nothing to undo). */
+export declare function currentLiveSync(operations: SceneOperations): LiveSync;
+/**
+ * Whether a tool call failed because the stored scene changed after the session
+ * loaded it. The store refuses before writing, so nothing from the call persisted.
+ */
+export declare function isLiveSyncVersionConflict(error: unknown): boolean;
 /**
  * Persist the bridge's current graph to the active scene and append a live
  * event for browser subscribers. Skips persistence — reporting why — when the
@@ -35,7 +50,11 @@ export declare function persistencePayload(status: LiveSyncStatus): {
  * append scene events; callers surface that through `persistencePayload` so
  * the skip is never silent (#725).
  */
-export declare function publishLiveSceneSnapshot(operations: SceneOperations, kind: string): Promise<LiveSyncStatus>;
+export declare function publishLiveSceneSnapshot(operations: SceneOperations, kind: string, 
+/** `allowSceneWipe`: the write empties the project on purpose (clear_scene). */
+options?: {
+    allowSceneWipe?: boolean;
+}): Promise<LiveSync>;
 export declare function appendLiveSceneEvent(operations: SceneOperations, sceneId: string, version: number, kind: string, graph: SceneGraph): Promise<void>;
 export {};
 //# sourceMappingURL=live-sync.d.ts.map

package/dist/tools/live-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live-sync.d.ts","sourceRoot":"","sources":["../../src/tools/live-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAA;AAEpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAIpD,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,eAAe,GAAG,MAAM,CAW5E;AAED,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,SAAS,GAAG,oBAAoB,CAAA;AAE3E,KAAK,YAAY,GAAG,OAAO,CAAC,cAAc,EAAE,WAAW,CAAC,CAAA;AAExD;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;CAO1B,CAAA;AASD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,GAAG;IAC1D,WAAW,CAAC,EAAE;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CACxD,CAGA;AAED;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,cAAc,CAAC,CAwCzB;AAED,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,IAAI,CAAC,CAGf"}
+{"version":3,"file":"live-sync.d.ts","sourceRoot":"","sources":["../../src/tools/live-sync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAA;AACpE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAIpD,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,SAAS,GAAG,oBAAoB,CAAA;AAE3E,6EAA6E;AAC7E,MAAM,MAAM,QAAQ,GAAG;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAA;AAEzE,KAAK,YAAY,GAAG,OAAO,CAAC,cAAc,EAAE,WAAW,CAAC,CAAA;AAExD;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;CAS1B,CAAA;AASD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,QAAQ,GAAG;IACjE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE;QAAE,MAAM,EAAE,YAAY,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CACxD,CAOA;AAED,uGAAuG;AACvG,wBAAgB,eAAe,CAAC,UAAU,EAAE,eAAe,GAAG,QAAQ,CAGrE;AAID;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEjE;AAED;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,UAAU,EAAE,eAAe,EAC3B,IAAI,EAAE,MAAM;AACZ,gFAAgF;AAChF,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GACzC,OAAO,CAAC,QAAQ,CAAC,CAsDnB;AAED,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,IAAI,CAAC,CAGf"}