@pascal-app/mcp 1.0.3 → 1.0.4

package/dist/tools/add-object.d.ts

@@ -0,0 +1,60 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type CompiledGeometryScript, GeometryArtifactMetadata, type GeometryScriptLanguage, type GeometryScriptParamValue } from '@pascal-app/core/schema';
+import type { SceneOperations } from '../operations/index.js';
+/**
+ * How a host runs `add_object`'s module and keeps the result. Running
+ * model-written code is the host's call: it decides the isolation, and where
+ * artifacts live for the active scene.
+ */
+export type GeometryScriptHost = {
+    compile(input: {
+        code: string;
+        language: GeometryScriptLanguage;
+        params?: Record<string, GeometryScriptParamValue>;
+    }): Promise<CompiledGeometryScript & {
+        glb: Uint8Array;
+    }>;
+    storeArtifact(input: {
+        sceneId: string;
+        sha256: string;
+        bytes: Uint8Array;
+        mimeType: string;
+        nodeId?: string;
+        metadata?: GeometryArtifactMetadata;
+    }): Promise<string>;
+    /** A stored artifact's bytes (an object's script), or null when missing; only for principals who may edit the scene. */
+    readArtifact(input: {
+        sceneId: string;
+        sha256: string;
+    }): Promise<Uint8Array | null>;
+    /**
+     * Compiles and stores in one step, for a host whose compiler keeps the artifacts itself (the
+     * hosted MCP's user editor tab); preferred over `compile` + `storeArtifact` when present.
+     */
+    build?(input: {
+        sceneId: string;
+        code: string;
+        language: GeometryScriptLanguage;
+        params?: Record<string, GeometryScriptParamValue>;
+        /** What the script builds, for the host to name it to the user. */
+        kind: ScriptedKind;
+        nodeId: string;
+        metadata?: GeometryArtifactMetadata;
+    }): Promise<CompiledGeometryScript>;
+};
+export type ScriptedKind = 'object' | 'window' | 'door' | 'column';
+/** Compiles a module on the host and stores its GLB and text for the scene: the step every scripted tool shares. */
+export declare function compileAndStore(host: GeometryScriptHost, sceneId: string, { code, language, params, }: {
+    code: string;
+    language: GeometryScriptLanguage;
+    params: Record<string, GeometryScriptParamValue> | undefined;
+}, kind: ScriptedKind, context?: {
+    nodeId?: string;
+    metadata?: GeometryArtifactMetadata;
+}): Promise<CompiledGeometryScript>;
+export declare function readScript(host: GeometryScriptHost, sceneId: string, bridge: SceneOperations, nodeId: string): Promise<string>;
+/** `add_object` on the MCP: the shared contract and operation, with the host's compile in front. */
+export declare function registerAddObject(server: McpServer, bridge: SceneOperations, host: GeometryScriptHost | undefined): void;
+/** `get_source` on the MCP: the object's module text, read back through the host's store. */
+export declare function registerGetSource(server: McpServer, bridge: SceneOperations, host: GeometryScriptHost | undefined): void;
+//# sourceMappingURL=add-object.d.ts.map

package/dist/tools/add-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-object.d.ts","sourceRoot":"","sources":["../../src/tools/add-object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAcxE,OAAO,EAEL,KAAK,sBAAsB,EAE3B,wBAAwB,EAExB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAE9B,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAMpD;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,KAAK,EAAE;QACb,IAAI,EAAE,MAAM,CAAA;QACZ,QAAQ,EAAE,sBAAsB,CAAA;QAChC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAA;KAClD,GAAG,OAAO,CAAC,sBAAsB,GAAG;QAAE,GAAG,EAAE,UAAU,CAAA;KAAE,CAAC,CAAA;IACzD,aAAa,CAAC,KAAK,EAAE;QACnB,OAAO,EAAE,MAAM,CAAA;QACf,MAAM,EAAE,MAAM,CAAA;QACd,KAAK,EAAE,UAAU,CAAA;QACjB,QAAQ,EAAE,MAAM,CAAA;QAChB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,QAAQ,CAAC,EAAE,wBAAwB,CAAA;KACpC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACnB,wHAAwH;IACxH,YAAY,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAA;IACpF;;;OAGG;IACH,KAAK,CAAC,CAAC,KAAK,EAAE;QACZ,OAAO,EAAE,MAAM,CAAA;QACf,IAAI,EAAE,MAAM,CAAA;QACZ,QAAQ,EAAE,sBAAsB,CAAA;QAChC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAA;QACjD,mEAAmE;QACnE,IAAI,EAAE,YAAY,CAAA;QAClB,MAAM,EAAE,MAAM,CAAA;QACd,QAAQ,CAAC,EAAE,wBAAwB,CAAA;KACpC,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,CAAA;AAElE,oHAAoH;AACpH,wBAAsB,eAAe,CACnC,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,MAAM,EACf,EACE,IAAI,EACJ,QAAQ,EACR,MAAM,GACP,EAAE;IACD,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,sBAAsB,CAAA;IAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,GAAG,SAAS,CAAA;CAC7D,EACD,IAAI,EAAE,YAAY,EAClB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,wBAAwB,CAAA;CAAO,GACrE,OAAO,CAAC,sBAAsB,CAAC,CAgCjC;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAKjB;AAED,oGAAoG;AACpG,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,kBAAkB,GAAG,SAAS,GACnC,IAAI,CAsEN;AASD,6FAA6F;AAC7F,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,kBAAkB,GAAG,SAAS,GACnC,IAAI,CAgCN"}

package/dist/tools/add-object.js

@@ -0,0 +1,156 @@
+import { isScriptedNode, scriptedObjectMeta } from '@pascal-app/core';
+import { achievedChanges, addObject, authoredObject, editedScriptLanguage, editedScriptParams, readSourceResult, requireAddObjectReason, } from '@pascal-app/core/agent-operations';
+import { addObjectTool, getSourceTool, isAgentRefusal, refuse } from '@pascal-app/core/agent-tools';
+import { GEOMETRY_SCRIPT_MIME_TYPES, GeometryArtifactMetadata, GeometryReuseFields, generateId, } from '@pascal-app/core/schema';
+import { DESTRUCTIVE_TOOL_ANNOTATIONS, READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
+import { refusalResult, toolError } from './errors.js';
+import { persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { toPatches } from './shared-tools.js';
+/** Compiles a module on the host and stores its GLB and text for the scene: the step every scripted tool shares. */
+export async function compileAndStore(host, sceneId, { code, language, params, }, kind, context = {}) {
+    const nodeId = context.nodeId ?? generateId(kind === 'object' ? 'item' : kind);
+    const metadata = GeometryArtifactMetadata.parse({
+        ...context.metadata,
+        kind: kind === 'object' ? 'item' : kind,
+    });
+    if (host.build)
+        return {
+            ...(await host.build({ sceneId, code, language, params, kind, nodeId, metadata })),
+            nodeId,
+        };
+    const { glb, ...compiled } = await host.compile({ code, language, params });
+    metadata.mount = compiled.mount;
+    const [sha256] = await Promise.all([
+        host.storeArtifact({
+            sceneId,
+            nodeId,
+            metadata,
+            sha256: compiled.sha256,
+            bytes: glb,
+            mimeType: 'model/gltf-binary',
+        }),
+        host.storeArtifact({
+            sceneId,
+            nodeId,
+            metadata,
+            sha256: compiled.script,
+            bytes: new TextEncoder().encode(code),
+            mimeType: GEOMETRY_SCRIPT_MIME_TYPES[language],
+        }),
+    ]);
+    return { ...compiled, sha256, nodeId };
+}
+export async function readScript(host, sceneId, bridge, nodeId) {
+    const node = authoredObject(bridge.getNodes(), nodeId);
+    const bytes = await host.readArtifact({ sceneId, sha256: node.source.script });
+    if (!bytes)
+        throw new Error(`The script of ${nodeId} could not be read`);
+    return new TextDecoder().decode(bytes);
+}
+/** `add_object` on the MCP: the shared contract and operation, with the host's compile in front. */
+export function registerAddObject(server, bridge, host) {
+    server.registerTool(addObjectTool.name, {
+        title: addObjectTool.title,
+        description: addObjectTool.description,
+        inputSchema: addObjectTool.input,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    }, async (input) => {
+        if (!host) {
+            return toolError('This Pascal server cannot run geometry scripts.', {
+                code: 'scripts_unavailable',
+            });
+        }
+        const scene = bridge.getActiveScene();
+        if (!scene) {
+            return toolError('Open or save a scene first: authored objects are stored with a scene.', {
+                code: 'no_active_scene',
+            });
+        }
+        const args = input;
+        let compiled;
+        try {
+            requireAddObjectReason(args);
+            const code = args.code ??
+                (args.nodeId
+                    ? await readScript(host, scene.id, bridge, args.nodeId)
+                    : refuseMissingCode());
+            const nodes = bridge.getNodes();
+            const previous = args.nodeId ? nodes[args.nodeId] : undefined;
+            const language = editedScriptLanguage(previous, args);
+            const params = editedScriptParams(previous, args.params);
+            compiled = await compileAndStore(host, scene.id, { code, language, params }, 'object', {
+                nodeId: args.nodeId,
+                metadata: {
+                    ...(isScriptedNode(previous) ? scriptedObjectMeta(previous) : {}),
+                    ...GeometryReuseFields.parse(args),
+                },
+            });
+        }
+        catch (error) {
+            if (isAgentRefusal(error))
+                return refusalResult(error);
+            return toolError(error instanceof Error ? error.message : String(error), {
+                code: 'script_failed',
+            });
+        }
+        // A copy: the hosted bridge writes its map in place, and a "before" that grows with the call
+        // reads every creation as unchanged.
+        const before = { ...bridge.getNodes() };
+        let outcome;
+        try {
+            outcome = addObject(before, { ...args, compiled }, { activeLevelId: null });
+        }
+        catch (error) {
+            return refusalResult(error);
+        }
+        const patches = outcome.changes ? toPatches(outcome.changes) : [];
+        if (patches.length)
+            bridge.applyPatch(patches);
+        const payload = {
+            ...outcome.result,
+            // What the scene holds now, as every write answers.
+            achieved: achievedChanges(before, outcome.changes ?? {}),
+            ...persistencePayload(await publishLiveSceneSnapshot(bridge, addObjectTool.name)),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}
+function refuseMissingCode() {
+    refuse('code_required', 'Pass code to build a new object; params alone rebuild an existing one (nodeId).');
+}
+/** `get_source` on the MCP: the object's module text, read back through the host's store. */
+export function registerGetSource(server, bridge, host) {
+    server.registerTool(getSourceTool.name, {
+        title: getSourceTool.title,
+        description: getSourceTool.description,
+        inputSchema: getSourceTool.input,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    }, async ({ nodeId }) => {
+        if (!host) {
+            return toolError('This Pascal server cannot read geometry scripts.', {
+                code: 'scripts_unavailable',
+            });
+        }
+        const scene = bridge.getActiveScene();
+        if (!scene)
+            return toolError('Open a scene first.', { code: 'no_active_scene' });
+        try {
+            const node = authoredObject(bridge.getNodes(), nodeId);
+            const payload = readSourceResult(node, await readScript(host, scene.id, bridge, nodeId));
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (error) {
+            if (isAgentRefusal(error))
+                return refusalResult(error);
+            return toolError(error instanceof Error ? error.message : String(error), {
+                code: 'script_unreadable',
+            });
+        }
+    });
+}

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

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
+import './honest-patch-guard.js';
 export declare const applyPatchInput: {
     patches: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         op: z.ZodLiteral<"create">;
@@ -17,6 +18,8 @@ export declare const applyPatchInput: {
     }, z.core.$strip>], "op">>;
 };
 export declare const applyPatchOutput: {
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsaved: z.ZodOptional<z.ZodString>;
     persistence: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
             unbound: "unbound";

package/dist/tools/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;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"}
+{"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;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD,OAAO,sBAAsB,CAAA;AAK7B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;CAE3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAK5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA+EnF"}

package/dist/tools/apply-patch.js

@@ -1,7 +1,10 @@
+import { isAgentRefusal } from '@pascal-app/core/agent-tools';
 import { z } from 'zod';
 import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
-import { ErrorCode, throwMcpError } from './errors.js';
+import { ErrorCode, McpError, refusalResult, throwMcpError } from './errors.js';
+import './honest-patch-guard.js';
 import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { assertPatchKeepsIdentity, PatchRefusedError, runPatchGuards } from './patch-guards.js';
 import { PatchSchema } from './schemas.js';
 export const applyPatchInput = {
     patches: z.array(PatchSchema),
@@ -15,7 +18,7 @@ export const applyPatchOutput = {
 export function registerApplyPatch(server, bridge) {
     server.registerTool('apply_patch', {
         title: 'Apply patch',
-        description: 'Apply a batch of create/update/delete operations atomically. All patches are validated before any are applied; the entire batch forms a single undo step. Batch-first is the default: prefer one apply_patch call containing all create/update/delete ops for a build step, in stable order so later ops can reference ids created by earlier ops. A single call is atomic (all or nothing) and pays the snapshot and save cost once; do not loop one-op calls.',
+        description: "Apply a batch of create/update/delete operations atomically. All patches are validated before any are applied; the entire batch forms a single undo step. Batch-first is the default: prefer one apply_patch call containing all create/update/delete ops for a build step, in stable order so later ops can reference ids created by earlier ops. A single call is atomic (all or nothing) and pays the snapshot and save cost once; do not loop one-op calls. A create whose id already exists fails the whole patch with node_exists; to replace a node, delete it earlier in the same patch. An update cannot change id or type (identity_change) or object or children (immutable_field); restating the current value is fine. A parentId change must name an existing node that holds children (invalid_parent). An update cannot add schema issues to a node (invalid_update). After a delete or a roof update that regenerates a roof's default gutters, those gutters and their downspouts are addressable only in a later call (regenerated_default). Refusals come back as a tool error whose text is JSON {code, patchIndex, id, message}.",
         inputSchema: applyPatchInput,
         outputSchema: applyPatchOutput,
         annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
@@ -42,6 +45,10 @@ export function registerApplyPatch(server, bridge) {
             };
         });
         try {
+            runPatchGuards(bridgePatches, bridge.getNodes());
+            const planDeletion = bridge
+                .planDeletion;
+            assertPatchKeepsIdentity(bridgePatches, bridge.getNodes(), bridge.getRootNodeIds(), typeof planDeletion === 'function' ? planDeletion.bind(bridge) : undefined);
             const result = bridge.applyPatch(bridgePatches);
             const persistence = await publishLiveSceneSnapshot(bridge, 'apply_patch');
             const payload = {
@@ -56,6 +63,25 @@ export function registerApplyPatch(server, bridge) {
             };
         }
         catch (err) {
+            if (err instanceof PatchRefusedError) {
+                // A tool error, not an McpError: the SDK keeps only an McpError's
+                // message, and clients need the code, index and id to act on it.
+                const refusal = {
+                    code: err.code,
+                    patchIndex: err.patchIndex,
+                    id: err.nodeId,
+                    message: err.message,
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(refusal) }],
+                    isError: true,
+                };
+            }
+            // A refusal the store made (an accidental wipe) answers with its code, as the shared tools'.
+            if (isAgentRefusal(err))
+                return refusalResult(err);
+            if (err instanceof McpError)
+                throw err;
             const msg = err instanceof Error ? err.message : String(err);
             throwMcpError(ErrorCode.InvalidParams, msg);
         }

package/dist/tools/asset-catalog.d.ts

@@ -8,9 +8,13 @@ import type { AssetInput } from '@pascal-app/core/schema';
  * common AI-generated residential layouts.
  */
 export declare const MCP_CATALOG_ITEMS: AssetInput[];
-export declare function findCatalogItem(id: string): AssetInput | undefined;
-export declare function searchCatalogItems(args: {
-    query: string;
-    category?: string | undefined;
-}): AssetInput[];
+/**
+ * The items search_assets, place_items and furnish_room draw from. A host passes its own (the hosted
+ * app: its published library, as the chat searches); a standalone server keeps the built-in list.
+ */
+export type AssetCatalog = () => Promise<readonly AssetInput[]>;
+export declare const builtInCatalog: AssetCatalog;
+/** A host's catalog, read once by the first call that needs it; a failed read is tried again. */
+export declare function cachedCatalog(load: AssetCatalog): AssetCatalog;
+export declare function findCatalogItem(items: readonly AssetInput[], id: string): AssetInput | undefined;
 //# sourceMappingURL=asset-catalog.d.ts.map

package/dist/tools/asset-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asset-catalog.d.ts","sourceRoot":"","sources":["../../src/tools/asset-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,UAAU,EA6RzC,CAAA;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAElE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC9B,GAAG,UAAU,EAAE,CAUf"}
+{"version":3,"file":"asset-catalog.d.ts","sourceRoot":"","sources":["../../src/tools/asset-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,UAAU,EA6RzC,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,SAAS,UAAU,EAAE,CAAC,CAAA;AAE/D,eAAO,MAAM,cAAc,EAAE,YAA4C,CAAA;AAEzE,iGAAiG;AACjG,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAO9D;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAEhG"}

package/dist/tools/asset-catalog.js

@@ -292,17 +292,15 @@ export const MCP_CATALOG_ITEMS = [
         scale: [1, 1, 1],
     },
 ];
-export function findCatalogItem(id) {
-    return MCP_CATALOG_ITEMS.find((item) => item.id === id);
+export const builtInCatalog = async () => MCP_CATALOG_ITEMS;
+/** A host's catalog, read once by the first call that needs it; a failed read is tried again. */
+export function cachedCatalog(load) {
+    let items = null;
+    return () => (items ??= load().catch((error) => {
+        items = null;
+        throw error;
+    }));
 }
-export function searchCatalogItems(args) {
-    const terms = args.query.trim().toLowerCase().split(/\s+/).filter(Boolean);
-    return MCP_CATALOG_ITEMS.filter((item) => {
-        if (args.category && item.category !== args.category)
-            return false;
-        const haystack = [item.id, item.name, item.category, ...(item.tags ?? [])]
-            .join(' ')
-            .toLowerCase();
-        return terms.every((term) => haystack.includes(term));
-    });
+export function findCatalogItem(items, id) {
+    return items.find((item) => item.id === id);
 }

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

@@ -64,8 +64,8 @@ export declare const checkCollisionsOutput: {
         bId: z.ZodString;
         kind: z.ZodString;
         violation: z.ZodEnum<{
-            overlap: "overlap";
             clearance: "clearance";
+            overlap: "overlap";
         }>;
         minimumClearanceMeters: z.ZodNumber;
     }, z.core.$strip>>;

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;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"}
+{"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;AAOxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AA4BpD,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,9 +1,8 @@
+import { findItemItemCollisions, inspectItemPlanFootprint, resolveNodeLevelId, } from '@pascal-app/core/agent-operations';
 import { ItemNode } from '@pascal-app/core/schema';
 import { z } from 'zod';
 import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
-import { inspectItemPlanFootprint, resolveNodeLevelId } from './door-clearance.js';
 import { ErrorCode, throwMcpError } from './errors.js';
-import { findItemItemCollisions } from './layout-clearance.js';
 import { measurement } from './measurement.js';
 import { computeGraphHash } from './scene-lifecycle/metadata.js';
 import { NodeIdSchema } from './schemas.js';

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

@@ -0,0 +1,9 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../operations/index.js';
+/**
+ * `clear_scene`: the scene goes back to the host's default scaffold (a site, a building, a level),
+ * then is saved with `allowSceneWipe`, so a store that refuses an accidental wipe takes this one.
+ * The project's installed plugins stay, and its undo history goes, as the editor's own clear does.
+ */
+export declare function registerClearScene(server: McpServer, operations: SceneOperations): void;
+//# sourceMappingURL=clear-scene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clear-scene.d.ts","sourceRoot":"","sources":["../../src/tools/clear-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CAmDvF"}

package/dist/tools/clear-scene.js

@@ -0,0 +1,59 @@
+import { clearSceneTool } from '@pascal-app/core/agent-tools';
+import { z } from 'zod';
+import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { refusalResult } from './errors.js';
+import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+/**
+ * `clear_scene`: the scene goes back to the host's default scaffold (a site, a building, a level),
+ * then is saved with `allowSceneWipe`, so a store that refuses an accidental wipe takes this one.
+ * The project's installed plugins stay, and its undo history goes, as the editor's own clear does.
+ */
+export function registerClearScene(server, operations) {
+    server.registerTool(clearSceneTool.name, {
+        title: clearSceneTool.title,
+        description: clearSceneTool.description,
+        inputSchema: clearSceneTool.input,
+        outputSchema: {
+            cleared: z.object({ removed: z.number() }),
+            version: z.number().nullable(),
+            graphHash: z.string().nullable(),
+            ...liveSyncOutput,
+        },
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    }, async () => {
+        try {
+            const before = Object.keys(operations.getNodes()).length;
+            const { installedPlugins } = operations.exportSceneGraph();
+            operations.setScene({}, []);
+            operations.loadDefault();
+            // Resetting drops the plugin state on every host; the scaffold is applied again with it.
+            if (installedPlugins)
+                operations.loadJSON({
+                    ...operations.exportSceneGraph(),
+                    collections: {},
+                    materials: {},
+                    installedPlugins,
+                });
+            // Nothing to undo back into: the empty intermediate or the old scene, saved over the clear.
+            operations.clearHistory();
+            const removed = Math.max(0, before - Object.keys(operations.getNodes()).length);
+            const persistence = await publishLiveSceneSnapshot(operations, clearSceneTool.name, {
+                allowSceneWipe: true,
+            });
+            const active = operations.getActiveScene();
+            const payload = {
+                cleared: { removed },
+                version: active?.version ?? null,
+                graphHash: active?.graphHash ?? null,
+                ...persistencePayload(persistence),
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (error) {
+            return refusalResult(error);
+        }
+    });
+}

package/dist/tools/collections.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../operations/index.js';
+export declare function registerCollectionTools(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=collections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/tools/collections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAWxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAgBpD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA+CxF"}

package/dist/tools/collections.js

@@ -0,0 +1,52 @@
+import { editCollection, listCollections, writeCollections, } from '@pascal-app/core/agent-operations';
+import { editCollectionTool, listCollectionsTool } from '@pascal-app/core/agent-tools';
+import { DESTRUCTIVE_TOOL_ANNOTATIONS, READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
+import { refusalResult } from './errors.js';
+import { persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+// The collection tools share contracts and operations with the chat; they read the scene's
+// collections beside its nodes, which the node-only shared operations never see.
+function sceneOf(bridge) {
+    return { nodes: bridge.getNodes(), collections: bridge.getCollections() };
+}
+function reply(payload) {
+    return { content: [{ type: 'text', text: JSON.stringify(payload) }] };
+}
+export function registerCollectionTools(server, bridge) {
+    server.registerTool(listCollectionsTool.name, {
+        title: listCollectionsTool.title,
+        description: listCollectionsTool.description,
+        inputSchema: listCollectionsTool.input,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    }, async (input) => {
+        try {
+            return reply(listCollections(sceneOf(bridge), input).result);
+        }
+        catch (error) {
+            return refusalResult(error);
+        }
+    });
+    server.registerTool(editCollectionTool.name, {
+        title: editCollectionTool.title,
+        description: editCollectionTool.description,
+        inputSchema: editCollectionTool.input,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    }, async (input) => {
+        let outcome;
+        try {
+            outcome = editCollection(sceneOf(bridge), input);
+        }
+        catch (error) {
+            return refusalResult(error);
+        }
+        const { update, collections = {} } = outcome.changes ?? {};
+        bridge.runAsSingleHistoryStep(() => {
+            if (update?.length)
+                bridge.applyPatch(update.map(({ id, data }) => ({ op: 'update', id: id, data })));
+            bridge.setCollections(writeCollections(bridge.getCollections(), collections));
+        });
+        return reply({
+            ...outcome.result,
+            ...persistencePayload(await publishLiveSceneSnapshot(bridge, editCollectionTool.name)),
+        });
+    });
+}

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

@@ -16,6 +16,8 @@ export declare const createStoryShellInput: {
     ceilingMaterialPreset: z.ZodOptional<z.ZodString>;
 };
 export declare const createStoryShellOutput: {
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsaved: z.ZodOptional<z.ZodString>;
     persistence: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
             unbound: "unbound";
@@ -25,7 +27,11 @@ export declare const createStoryShellOutput: {
     }, z.core.$strip>>;
     levelId: z.ZodString;
     wallIds: z.ZodArray<z.ZodString>;
+    /** Zones the reconciler derived for the enclosed faces. */
+    zoneIds: z.ZodArray<z.ZodString>;
+    /** Derived floor plate. `null` when floors were declined or nothing reconciled. */
     slabId: z.ZodNullable<z.ZodString>;
+    /** Derived ceiling. `null` when ceilings were declined or nothing reconciled. */
     ceilingId: z.ZodNullable<z.ZodString>;
     createdIds: z.ZodArray<z.ZodString>;
 };
@@ -57,6 +63,8 @@ export declare const createRoofInput: {
     name: z.ZodOptional<z.ZodString>;
 };
 export declare const createRoofOutput: {
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsaved: z.ZodOptional<z.ZodString>;
     persistence: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
             unbound: "unbound";
@@ -70,46 +78,5 @@ export declare const createRoofOutput: {
     roofId: z.ZodString;
     roofSegmentId: z.ZodString;
 };
-export declare const createStairBetweenLevelsInput: {
-    fromLevelId: z.ZodString;
-    toLevelId: z.ZodString;
-    position: z.ZodArray<z.ZodNumber>;
-    rotation: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    width: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    runLength: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    totalRise: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    stepCount: z.ZodDefault<z.ZodNumber>;
-    railingMode: z.ZodDefault<z.ZodEnum<{
-        none: "none";
-        both: "both";
-        right: "right";
-        left: "left";
-    }>>;
-    destinationSlabId: z.ZodOptional<z.ZodString>;
-    sourceCeilingId: z.ZodOptional<z.ZodString>;
-    createDestinationSlabOpening: z.ZodDefault<z.ZodBoolean>;
-    createSourceCeilingOpening: z.ZodDefault<z.ZodBoolean>;
-    openingWidth: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    openingLength: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    openingOffset: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    openingCenter: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    openingRotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    materialPreset: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-};
-export declare const createStairBetweenLevelsOutput: {
-    persistence: z.ZodOptional<z.ZodObject<{
-        status: z.ZodEnum<{
-            unbound: "unbound";
-            events_unsupported: "events_unsupported";
-        }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    stairId: z.ZodString;
-    stairSegmentId: z.ZodString;
-    destinationSlabId: z.ZodNullable<z.ZodString>;
-    sourceCeilingId: z.ZodNullable<z.ZodString>;
-    openingPolygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
-};
 export declare function registerConstructionTools(server: McpServer, bridge: SceneOperations): void;
 //# sourceMappingURL=construction-tools.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"construction-tools.d.ts","sourceRoot":"","sources":["../../src/tools/construction-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAcxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAkBpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;CAsBjC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;CAOlC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAO5B,CAAA;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCzC,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;CAO1C,CAAA;AA4GD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgV1F"}
+{"version":3,"file":"construction-tools.d.ts","sourceRoot":"","sources":["../../src/tools/construction-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAKxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAgBpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;CA8BjC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;IAGjC,2DAA2D;;IAE3D,mFAAmF;;IAEnF,iFAAiF;;;CAIlF,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;CAO5B,CAAA;AAgFD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA2O1F"}