@pascal-app/mcp 1.0.3 → 1.0.5

package/dist/tools/errors.js

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

package/dist/tools/export-glb.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
 export declare const exportGlbInput: {};

package/dist/tools/export-glb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"export-glb.d.ts","sourceRoot":"","sources":["../../src/tools/export-glb.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,cAAc,IAAK,CAAA;AAEhC,eAAO,MAAM,eAAe;;;CAG3B,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAuBnF"}
+{"version":3,"file":"export-glb.d.ts","sourceRoot":"","sources":["../../src/tools/export-glb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD,eAAO,MAAM,cAAc,IAAK,CAAA;AAEhC,eAAO,MAAM,eAAe;IAC1B,MAAM;IACN,MAAM;CACP,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAuBnF"}

package/dist/tools/export-glb.js

@@ -9,8 +9,8 @@ export function registerExportGlb(server, _bridge) {
     server.registerTool('export_glb', {
         title: 'Export GLB',
         description: 'GLB export is not available in headless mode — it requires the Three.js renderer, which is browser-only. Returns a structured `not_implemented` tool error.',
-        inputSchema: exportGlbInput,
-        outputSchema: exportGlbOutput,
+        inputSchema: z.object(exportGlbInput),
+        outputSchema: z.object(exportGlbOutput),
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
     }, async () => {
         const payload = {

package/dist/tools/export-json.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
 export declare const exportJsonInput: {

package/dist/tools/export-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"export-json.d.ts","sourceRoot":"","sources":["../../src/tools/export-json.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,eAAe;;CAE3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAqBnF"}
+{"version":3,"file":"export-json.d.ts","sourceRoot":"","sources":["../../src/tools/export-json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD,eAAO,MAAM,eAAe;IAC1B,MAAM;CACP,CAAA;AAED,eAAO,MAAM,gBAAgB;IAC3B,IAAI;CACL,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAqBnF"}

package/dist/tools/export-json.js

@@ -10,8 +10,8 @@ export function registerExportJson(server, bridge) {
     server.registerTool('export_json', {
         title: 'Export JSON',
         description: 'Return the scene as a serialized JSON string. Pass `pretty: true` to indent with 2 spaces.',
-        inputSchema: exportJsonInput,
-        outputSchema: exportJsonOutput,
+        inputSchema: z.object(exportJsonInput),
+        outputSchema: z.object(exportJsonOutput),
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
     }, async ({ pretty }) => {
         const scene = bridge.exportJSON();

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

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
 export declare const getSceneInput: {};
@@ -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,8BAA8B,CAAA;AAC7D,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;IACzB,KAAK;IACL,WAAW;IACX,WAAW;IACX,gBAAgB;CACjB,CAAA;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyBjF"}

package/dist/tools/get-scene.js

@@ -5,13 +5,14 @@ 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.',
-        inputSchema: getSceneInput,
-        outputSchema: getSceneOutput,
+        description: 'Returns the full scene graph: flat node dictionary, root node IDs, collections, and explicit installed plugin IDs when present.',
+        inputSchema: z.object(getSceneInput),
+        outputSchema: z.object(getSceneOutput),
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
     }, async () => {
         const scene = bridge.exportJSON();
@@ -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/server';
+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,8BAA8B,CAAA;AAC7D,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,mCAAmC,CAAA;AAQ1C,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,qBAAqB,GAC7B,IAAI,CA8CN"}

package/dist/tools/hosted-services.js

@@ -0,0 +1,40 @@
+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, ctx) => {
+            try {
+                const result = await executeHostedServiceTool(contract.name, input, execute, ctx.mcpReq.signal);
+                // A render's preview, inline in the result, is the picture the client shows the model.
+                const { preview, ...rest } = (result ?? {});
+                const picture = typeof preview === 'string' ? /^data:(image\/[a-z]+);base64,(.+)$/.exec(preview) : null;
+                if (!picture)
+                    return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+                return {
+                    content: [
+                        { type: 'text', text: JSON.stringify(rest) },
+                        { type: 'image', data: picture[2], mimeType: picture[1] },
+                    ],
+                };
+            }
+            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,9 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import type { SceneOperations } from '../operations/index.js';
+import { type GeometryScriptHost } from './add-object.js';
+import type { AssetCatalog } from './asset-catalog.js';
+import { type PlanReadingHosts } from './shared-tools.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 +12,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 = PlanReadingHosts & {
+    catalog?: AssetCatalog;
+    geometryScripts?: GeometryScriptHost;
+    sceneViews?: SceneViewHost;
+};
+export declare function registerTools(server: McpServer, operations: SceneOperations, { catalog, geometryScripts, sceneViews, assetViews }?: 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,8BAA8B,CAAA;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,OAAO,EAEL,KAAK,kBAAkB,EAGxB,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAiBnD,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,gBAAgB,CAAA;AAI3E,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAA;AAEpE;;;;;;;GAOG;AACH,gFAAgF;AAChF,MAAM,MAAM,SAAS,GAAG,gBAAgB,GAAG;IACzC,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,UAAU,EAAE,GAAE,SAAc,GACnE,IAAI,CA+BN"}

package/dist/tools/index.js

@@ -1,65 +1,51 @@
+import { registerAddColumn } from './add-column.js';
+import { compileObjectOnHost, registerAddObject, registerGetSource, } from './add-object.js';
 import { registerApplyPatch } from './apply-patch.js';
+import { registerAuthorScene } from './author-scene.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 { 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 { 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, assetViews } = {}) {
     registerGetScene(server, operations);
-    registerGetNode(server, operations);
-    registerDescribeNode(server, operations);
-    registerFindNodes(server, operations);
-    registerSceneQueryTools(server, operations);
+    registerSharedTools(server, operations, catalog, {
+        assetViews,
+        buildObject: (input) => compileObjectOnHost(geometryScripts, operations, input),
+    });
+    registerAddColumn(server, operations, geometryScripts);
+    registerAddObject(server, operations, geometryScripts);
+    registerAuthorScene(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);
     registerSetZone(server, operations);
-    registerDuplicateLevel(server, operations);
-    registerDeleteNode(server, operations);
     registerUndo(server, operations);
     registerRedo(server, operations);
     registerExportJson(server, operations);
     registerExportGlb(server, operations);
-    registerValidateScene(server, operations);
     registerCheckCollisions(server, operations);
     registerTemplateTools(server, operations);
     if (operations.hasStore) {

package/dist/tools/level-height-guard.d.ts

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

package/dist/tools/level-height-guard.d.ts.map

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

package/dist/tools/level-height-guard.js

@@ -0,0 +1,11 @@
+import { fillLevelHeights } from '@pascal-app/core/agent-operations';
+import { registerPatchGuard } from './patch-guards.js';
+/**
+ * A level is written with a height: a create without one, or an update clearing it, gets the height
+ * the editor's load would derive, said in the answer's notes. After the honest-update check, which
+ * turns a `null` into a cleared field.
+ */
+function levelHeights(patches, scene) {
+    return fillLevelHeights(patches, scene);
+}
+registerPatchGuard({ name: 'level-heights', order: 30, run: levelHeights });

package/dist/tools/list-units.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
 export declare const listUnitsInput: {
@@ -10,9 +10,9 @@ export declare const listUnitsOutput: {
         name: z.ZodString;
         kind: z.ZodDefault<z.ZodEnum<{
             apartment: "apartment";
-            "hotel-room": "hotel-room";
             commercial: "commercial";
             common: "common";
+            "hotel-room": "hotel-room";
         }>>;
         color: z.ZodString;
         members: z.ZodArray<z.ZodString>;

package/dist/tools/list-units.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-units.d.ts","sourceRoot":"","sources":["../../src/tools/list-units.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,eAAO,MAAM,cAAc;;CAE1B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3B,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgClF"}
+{"version":3,"file":"list-units.d.ts","sourceRoot":"","sources":["../../src/tools/list-units.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAG7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,eAAO,MAAM,cAAc;IACzB,UAAU;CACX,CAAA;AAED,eAAO,MAAM,eAAe;IAC1B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBN,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgClF"}

package/dist/tools/list-units.js

@@ -34,8 +34,8 @@ export function registerListUnits(server, bridge) {
     server.registerTool('list_units', {
         title: 'List units',
         description: 'List units with their member zones and current area reports, optionally filtered by building.',
-        inputSchema: listUnitsInput,
-        outputSchema: listUnitsOutput,
+        inputSchema: z.object(listUnitsInput),
+        outputSchema: z.object(listUnitsOutput),
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
     }, async ({ buildingId }) => {
         if (buildingId !== undefined)

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,24 +14,35 @@ 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";
             events_unsupported: "events_unsupported";
+            unbound: "unbound";
         }>;
         warning: z.ZodString;
     }, 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;IACzB,OAAO;IACP,OAAO;IACP,WAAW;;;;;;;CAMZ,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"}

package/dist/tools/live-sync.js

@@ -1,24 +1,15 @@
-import { syncAutoStairOpenings } from '@pascal-app/core/stair-openings';
+import { refuse, writeTarget } from '@pascal-app/core/agent-tools';
 import { z } from 'zod';
-import { SceneVersionConflictError } from '../storage/types.js';
-import { ErrorCode, throwMcpError } from './errors.js';
-export function syncDerivedStairOpenings(operations) {
-    const updates = syncAutoStairOpenings(operations.getNodes());
-    if (updates.length === 0)
-        return 0;
-    operations.applyPatch(updates.map((update) => ({
-        op: 'update',
-        id: update.id,
-        data: update.data,
-    })));
-    return updates.length;
-}
+import { SceneVersionConflictError, SceneWipeBlockedError } from '../storage/types.js';
+import { ProtocolError, ProtocolErrorCode, throwMcpError } from './errors.js';
 /**
  * Output-schema fragment for every tool that mutates the scene. Spread into
  * the tool's `outputSchema` so `persistencePayload` fields survive the SDK's
  * structured-content validation.
  */
 export const liveSyncOutput = {
+    project: z.string().nullable().optional(),
+    unsaved: z.string().optional(),
     persistence: z
         .object({
         status: z.enum(['unbound', 'events_unsupported']),
@@ -31,13 +22,29 @@ const LIVE_SYNC_WARNINGS = {
     events_unsupported: 'The change was applied to the in-memory session only: the attached scene store does not support live scene events, so nothing was persisted.',
 };
 /**
- * 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 function persistencePayload({ status, project }) {
+    return {
+        ...writeTarget(project),
+        ...(status === 'published'
+            ? {}
+            : { persistence: { status, warning: LIVE_SYNC_WARNINGS[status] } }),
+    };
+}
+/** Where the session's writes go, for a call that publishes nothing (an undo with nothing to undo). */
+export function currentLiveSync(operations) {
+    const project = operations.getActiveScene()?.projectId ?? null;
+    return { status: project ? 'published' : 'unbound', project };
+}
+const LIVE_SYNC_VERSION_CONFLICT = 'live_sync_version_conflict';
+/**
+ * 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 function persistencePayload(status) {
-    if (status === 'published')
-        return {};
-    return { persistence: { status, warning: LIVE_SYNC_WARNINGS[status] } };
+export function isLiveSyncVersionConflict(error) {
+    return error instanceof ProtocolError && error.message.endsWith(LIVE_SYNC_VERSION_CONFLICT);
 }
 /**
  * Persist the bridge's current graph to the active scene and append a live
@@ -46,13 +53,15 @@ export function persistencePayload(status) {
  * append scene events; callers surface that through `persistencePayload` so
  * the skip is never silent (#725).
  */
-export async function publishLiveSceneSnapshot(operations, kind) {
-    syncDerivedStairOpenings(operations);
+export async function publishLiveSceneSnapshot(operations, kind, 
+/** `allowSceneWipe`: the write empties the project on purpose (clear_scene). */
+options = {}) {
     const active = operations.getActiveScene();
     if (!active)
-        return 'unbound';
+        return { status: 'unbound', project: null };
+    const project = active.projectId ?? active.id;
     if (!operations.canAppendSceneEvents)
-        return 'events_unsupported';
+        return { status: 'events_unsupported', project };
     const graph = operations.exportSceneGraph();
     try {
         const meta = await operations.saveScene({
@@ -63,9 +72,11 @@ export async function publishLiveSceneSnapshot(operations, kind) {
             thumbnailUrl: active.thumbnailUrl,
             graph,
             expectedVersion: active.version,
+            ...(active.graphHash !== undefined ? { expectedGraphHash: active.graphHash } : {}),
             saveMode: 'draft',
             publish: false,
             operation: kind,
+            ...(options.allowSceneWipe ? { allowSceneWipe: true } : {}),
         });
         operations.setActiveScene(meta);
         await operations.appendSceneEvent({
@@ -76,16 +87,26 @@ export async function publishLiveSceneSnapshot(operations, kind) {
         });
     }
     catch (error) {
+        if (error instanceof SceneWipeBlockedError) {
+            // The store kept what it held; the session goes back to it, so the agent's next write builds
+            // on the project as stored rather than on the refused one (deleting the only room, say).
+            const stored = await operations.loadStoredScene(active.id).catch(() => null);
+            if (stored)
+                operations.loadJSON(stored.graph);
+            refuse('scene_wipe_blocked', stored
+                ? 'This write would leave the project empty, so it was blocked and nothing changed. To empty the project on purpose, call clear_scene. To remove only part of it, such as its only room, build what replaces it first, then remove it.'
+                : 'This write would leave the project empty, so it was blocked and not saved. Call load_scene before writing again. To empty the project on purpose, call clear_scene.', { sceneId: active.id, mutationApplied: false, sessionRestored: !!stored });
+        }
         if (error instanceof SceneVersionConflictError) {
-            throwMcpError(ErrorCode.InvalidRequest, 'live_sync_version_conflict', {
+            throwMcpError(ProtocolErrorCode.InvalidRequest, LIVE_SYNC_VERSION_CONFLICT, {
                 sceneId: active.id,
                 expectedVersion: active.version,
             });
         }
         const message = error instanceof Error ? error.message : String(error);
-        throwMcpError(ErrorCode.InternalError, `live_sync_failed: ${message}`);
+        throwMcpError(ProtocolErrorCode.InternalError, `live_sync_failed: ${message}`);
     }
-    return 'published';
+    return { status: 'published', project };
 }
 export async function appendLiveSceneEvent(operations, sceneId, version, kind, graph) {
     if (!operations.canAppendSceneEvents)