@pascal-app/mcp 0.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;GAGG;AAEH,iFAAiF;AACjF,eAAO,MAAM,YAAY,aAAoB,CAAA;AAE7C;;;;GAIG;AACH,eAAO,MAAM,UAAU,yBAAoC,CAAA;AAE3D,6BAA6B;AAC7B,eAAO,MAAM,UAAU,yBAAoC,CAAA;AAE3D;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;yBAItB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/dist/tools/schemas.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+/**
+ * Shared Zod schemas used by multiple MCP tools. Keep DRY — if a shape is
+ * referenced by more than one tool, define it here.
+ */
+/** A node identifier — non-empty string. The core uses `${prefix}_${nanoid}`. */
+export const NodeIdSchema = z.string().min(1);
+/**
+ * 2D point as [x, z] (floor plane). Use array length constraints instead of
+ * `z.tuple()` so MCP hosts that only accept JSON Schema's common `items` shape
+ * can register the tools.
+ */
+export const Vec2Schema = z.array(z.number()).min(2).max(2);
+/** 3D point as [x, y, z]. */
+export const Vec3Schema = z.array(z.number()).min(3).max(3);
+/**
+ * A single patch operation. Union of create / update / delete.
+ *
+ * For `create`, the node object must include `type` so Zod can discriminate at
+ * the bridge layer — we accept a plain object here and let the bridge's Zod
+ * re-parse catch structural issues. For `update`, `data` is a partial merge.
+ */
+export const CreatePatchSchema = z.object({
+    op: z.literal('create'),
+    node: z.record(z.string(), z.unknown()),
+    parentId: NodeIdSchema.optional(),
+});
+export const UpdatePatchSchema = z.object({
+    op: z.literal('update'),
+    id: NodeIdSchema,
+    data: z.record(z.string(), z.unknown()),
+});
+export const DeletePatchSchema = z.object({
+    op: z.literal('delete'),
+    id: NodeIdSchema,
+    cascade: z.boolean().optional(),
+});
+export const PatchSchema = z.discriminatedUnion('op', [
+    CreatePatchSchema,
+    UpdatePatchSchema,
+    DeletePatchSchema,
+]);

package/dist/tools/set-zone.d.ts

@@ -0,0 +1,14 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const setZoneInput: {
+    levelId: z.ZodString;
+    polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+    label: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export declare const setZoneOutput: {
+    zoneId: z.ZodString;
+};
+export declare function registerSetZone(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=set-zone.d.ts.map

package/dist/tools/set-zone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-zone.d.ts","sourceRoot":"","sources":["../../src/tools/set-zone.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,YAAY;;;;;CAKxB,CAAA;AAED,eAAO,MAAM,aAAa;;CAEzB,CAAA;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgDhF"}

package/dist/tools/set-zone.js

@@ -0,0 +1,48 @@
+import { ZoneNode } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from './errors';
+import { publishLiveSceneSnapshot } from './live-sync';
+import { NodeIdSchema, Vec2Schema } from './schemas';
+export const setZoneInput = {
+    levelId: NodeIdSchema,
+    polygon: z.array(Vec2Schema).min(3),
+    label: z.string().min(1),
+    properties: z.record(z.string(), z.unknown()).optional(),
+};
+export const setZoneOutput = {
+    zoneId: z.string(),
+};
+export function registerSetZone(server, bridge) {
+    server.registerTool('set_zone', {
+        title: 'Set zone',
+        description: 'Create a polygonal zone on the given level. label is stored as the zone name and properties are merged into metadata.',
+        inputSchema: setZoneInput,
+        outputSchema: setZoneOutput,
+    }, async ({ levelId, polygon, label, properties }) => {
+        const parent = bridge.getNode(levelId);
+        if (!parent) {
+            throwMcpError(ErrorCode.InvalidParams, `Level not found: ${levelId}`);
+        }
+        if (parent.type !== 'level') {
+            throwMcpError(ErrorCode.InvalidParams, `Node ${levelId} is a ${parent.type}, expected level`);
+        }
+        if (typeof parent.metadata === 'object' &&
+            parent.metadata !== null &&
+            'role' in parent.metadata &&
+            parent.metadata.role === 'roof') {
+            throwMcpError(ErrorCode.InvalidParams, `Roof support level ${levelId} is not an occupied story; create zones on an occupied level instead`);
+        }
+        const zone = ZoneNode.parse({
+            name: label,
+            polygon: polygon,
+            metadata: properties ?? {},
+        });
+        const id = bridge.createNode(zone, levelId);
+        await publishLiveSceneSnapshot(bridge, 'set_zone');
+        const payload = { zoneId: id };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/templates/create-from-template.d.ts

@@ -0,0 +1,54 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../../operations';
+export declare const createFromTemplateInput: {
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    /**
+     * When persistence operations are wired into the MCP server, set this flag to
+     * `true` to immediately save the instantiated template and return its
+     * `SceneMeta`. When `false` (default) the template is applied to the bridge
+     * only.
+     */
+    save: z.ZodDefault<z.ZodBoolean>;
+    projectId: z.ZodOptional<z.ZodString>;
+};
+export declare const createFromTemplateOutput: {
+    templateId: z.ZodString;
+    rootNodeIds: z.ZodArray<z.ZodString>;
+    nodeCount: z.ZodNumber;
+    /** Present when `save: true` (and a store was available). */
+    scene: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        thumbnailUrl: z.ZodNullable<z.ZodString>;
+        version: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        ownerId: z.ZodNullable<z.ZodString>;
+        sizeBytes: z.ZodNumber;
+        nodeCount: z.ZodNumber;
+        url: z.ZodString;
+        editorUrl: z.ZodString;
+        published: z.ZodBoolean;
+        isDraft: z.ZodBoolean;
+        saveMode: z.ZodEnum<{
+            draft: "draft";
+            checkpoint: "checkpoint";
+        }>;
+        graphHash: z.ZodOptional<z.ZodString>;
+        levelIds: z.ZodArray<z.ZodString>;
+        defaultLevelId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+};
+/**
+ * `create_from_template` — instantiate a seed template into the bridge, and
+ * optionally persist it via the attached scene operations.
+ *
+ * The source template is cloned with fresh ids (`cloneSceneGraph`) so the
+ * deterministic placeholders (`site_empty`, `wall_n`, …) don't collide
+ * across repeated calls or with other scenes.
+ */
+export declare function registerCreateFromTemplate(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=create-from-template.d.ts.map

package/dist/tools/templates/create-from-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-from-template.d.ts","sourceRoot":"","sources":["../../../src/tools/templates/create-from-template.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,kBAAkB,CAAA;AAMvD,eAAO,MAAM,uBAAuB;;;IAYlC;;;;;OAKG;;;CAGJ,CAAA;AAED,eAAO,MAAM,wBAAwB;;;;IAInC,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;CAuB9D,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA8F3F"}

package/dist/tools/templates/create-from-template.js

@@ -0,0 +1,145 @@
+import { cloneSceneGraph } from '@pascal-app/core/clone-scene-graph';
+import { z } from 'zod';
+import { rehydrateSiteChildren } from '../../lib/rehydrate-site-children';
+import { isTemplateId, TEMPLATES } from '../../templates';
+import { ErrorCode, throwMcpError } from '../errors';
+import { appendLiveSceneEvent } from '../live-sync';
+import { currentLevelContext, sceneMetaPayload } from '../scene-lifecycle/metadata';
+export const createFromTemplateInput = {
+    id: z
+        .string()
+        .describe('Template id (see `list_templates`). Currently one of: "empty-studio", "two-bedroom", "garden-house".'),
+    name: z
+        .string()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe('Optional display name for the saved scene. Defaults to the template name.'),
+    /**
+     * When persistence operations are wired into the MCP server, set this flag to
+     * `true` to immediately save the instantiated template and return its
+     * `SceneMeta`. When `false` (default) the template is applied to the bridge
+     * only.
+     */
+    save: z.boolean().default(false),
+    projectId: z.string().optional(),
+};
+export const createFromTemplateOutput = {
+    templateId: z.string(),
+    rootNodeIds: z.array(z.string()),
+    nodeCount: z.number(),
+    /** Present when `save: true` (and a store was available). */
+    scene: z
+        .object({
+        id: z.string(),
+        name: z.string(),
+        projectId: z.string().nullable(),
+        thumbnailUrl: z.string().nullable(),
+        version: z.number(),
+        createdAt: z.string(),
+        updatedAt: z.string(),
+        ownerId: z.string().nullable(),
+        sizeBytes: z.number(),
+        nodeCount: z.number(),
+        url: z.string(),
+        editorUrl: z.string(),
+        published: z.boolean(),
+        isDraft: z.boolean(),
+        saveMode: z.enum(['draft', 'checkpoint']),
+        graphHash: z.string().optional(),
+        levelIds: z.array(z.string()),
+        defaultLevelId: z.string().nullable(),
+    })
+        .optional(),
+};
+/**
+ * `create_from_template` — instantiate a seed template into the bridge, and
+ * optionally persist it via the attached scene operations.
+ *
+ * The source template is cloned with fresh ids (`cloneSceneGraph`) so the
+ * deterministic placeholders (`site_empty`, `wall_n`, …) don't collide
+ * across repeated calls or with other scenes.
+ */
+export function registerCreateFromTemplate(server, bridge) {
+    server.registerTool('create_from_template', {
+        title: 'Create scene from template',
+        description: 'Instantiate a seed Pascal scene template into the bridge. Regenerates all ids before applying. When `save: true` and a SceneStore is wired, also persists the new scene and returns the SceneMeta.',
+        inputSchema: createFromTemplateInput,
+        outputSchema: createFromTemplateOutput,
+    }, async ({ id, name, save, projectId }) => {
+        if (!isTemplateId(id)) {
+            throwMcpError(ErrorCode.InvalidParams, `unknown_template: ${id}. Call list_templates for the set of valid ids.`);
+        }
+        const entry = TEMPLATES[id];
+        // Clone: regenerate ids so each instantiation is independent.
+        // `cloneSceneGraph` flattens SiteNode.children to string ids; rehydrate
+        // them back to embedded objects to satisfy the SiteNode schema (see
+        // CROSS_CUTTING §2).
+        const cloned = rehydrateSiteChildren(cloneSceneGraph(entry.template));
+        const nodes = cloned.nodes;
+        const rootNodeIds = cloned.rootNodeIds;
+        try {
+            bridge.setScene(nodes, rootNodeIds);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throwMcpError(ErrorCode.InternalError, `apply_failed: ${msg}`);
+        }
+        const basePayload = {
+            templateId: entry.id,
+            rootNodeIds: rootNodeIds,
+            nodeCount: Object.keys(nodes).length,
+        };
+        if (!save) {
+            bridge.clearActiveScene();
+            return {
+                content: [{ type: 'text', text: JSON.stringify(basePayload) }],
+                structuredContent: basePayload,
+            };
+        }
+        if (!bridge.hasStore) {
+            // Graceful no-store mode: report that save was skipped rather than
+            // erroring — this makes the tool usable in headless bridge-only
+            // deployments (tests, smoke scripts) without crashing.
+            bridge.clearActiveScene();
+            const payload = { ...basePayload, saveSkipped: true };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        try {
+            let saveProjectId = projectId;
+            if (!saveProjectId && bridge.canCreateProject) {
+                const project = await bridge.createProject({ name: name ?? entry.name });
+                saveProjectId = project.projectId;
+            }
+            const meta = await bridge.saveScene({
+                ...(saveProjectId !== undefined ? { id: saveProjectId, projectId: saveProjectId } : {}),
+                name: name ?? entry.name,
+                graph: { nodes, rootNodeIds },
+                saveMode: 'draft',
+                publish: false,
+                operation: 'create_from_template',
+            });
+            bridge.setActiveScene(meta);
+            await appendLiveSceneEvent(bridge, meta.id, meta.version, 'create_from_template', {
+                nodes,
+                rootNodeIds,
+            });
+            const scene = {
+                ...sceneMetaPayload(meta, { nodes, rootNodeIds }),
+                ...currentLevelContext(bridge),
+            };
+            const payload = { ...basePayload, scene };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throwMcpError(ErrorCode.InternalError, `save_failed: ${msg}`);
+        }
+    });
+}

package/dist/tools/templates/create-house-from-brief.d.ts

@@ -0,0 +1,35 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../../operations';
+export declare const createHouseFromBriefInput: {
+    brief: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    projectName: z.ZodOptional<z.ZodString>;
+    bedroomCount: z.ZodOptional<z.ZodNumber>;
+    rooms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    style: z.ZodOptional<z.ZodString>;
+    landscaping: z.ZodOptional<z.ZodBoolean>;
+    constraints: z.ZodOptional<z.ZodString>;
+};
+export declare const createHouseFromBriefOutput: {
+    projectId: z.ZodNullable<z.ZodString>;
+    editorUrl: z.ZodNullable<z.ZodString>;
+    url: z.ZodNullable<z.ZodString>;
+    version: z.ZodNullable<z.ZodNumber>;
+    published: z.ZodBoolean;
+    isDraft: z.ZodBoolean;
+    templateId: z.ZodString;
+    nodeCount: z.ZodNumber;
+    roomCount: z.ZodNumber;
+    levelIds: z.ZodArray<z.ZodString>;
+    defaultLevelId: z.ZodNullable<z.ZodString>;
+    validation: z.ZodObject<{
+        valid: z.ZodBoolean;
+        errors: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    summary: z.ZodString;
+    limitations: z.ZodArray<z.ZodString>;
+    nextStep: z.ZodString;
+};
+export declare function registerCreateHouseFromBrief(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=create-house-from-brief.d.ts.map

package/dist/tools/templates/create-house-from-brief.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-house-from-brief.d.ts","sourceRoot":"","sources":["../../../src/tools/templates/create-house-from-brief.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,kBAAkB,CAAA;AAMvD,eAAO,MAAM,yBAAyB;;;;;;;;;CASrC,CAAA;AAED,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;CAmBtC,CAAA;AAmCD,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAqI7F"}

package/dist/tools/templates/create-house-from-brief.js

@@ -0,0 +1,170 @@
+import { cloneSceneGraph } from '@pascal-app/core/clone-scene-graph';
+import { z } from 'zod';
+import { rehydrateSiteChildren } from '../../lib/rehydrate-site-children';
+import { isTemplateId, TEMPLATES } from '../../templates';
+import { ErrorCode, throwMcpError } from '../errors';
+import { appendLiveSceneEvent } from '../live-sync';
+import { currentLevelContext, sceneMetaPayload } from '../scene-lifecycle/metadata';
+export const createHouseFromBriefInput = {
+    brief: z.string().min(1),
+    projectId: z.string().optional(),
+    projectName: z.string().min(1).max(200).optional(),
+    bedroomCount: z.number().int().min(0).max(12).optional(),
+    rooms: z.array(z.string().min(1)).optional(),
+    style: z.string().optional(),
+    landscaping: z.boolean().optional(),
+    constraints: z.string().optional(),
+};
+export const createHouseFromBriefOutput = {
+    projectId: z.string().nullable(),
+    editorUrl: z.string().nullable(),
+    url: z.string().nullable(),
+    version: z.number().nullable(),
+    published: z.boolean(),
+    isDraft: z.boolean(),
+    templateId: z.string(),
+    nodeCount: z.number(),
+    roomCount: z.number(),
+    levelIds: z.array(z.string()),
+    defaultLevelId: z.string().nullable(),
+    validation: z.object({
+        valid: z.boolean(),
+        errors: z.array(z.string()),
+    }),
+    summary: z.string(),
+    limitations: z.array(z.string()),
+    nextStep: z.string(),
+};
+function chooseTemplate(args) {
+    const requested = new Set((args.rooms ?? []).map((room) => room.toLowerCase()));
+    if (args.landscaping ||
+        requested.has('garden') ||
+        requested.has('patio') ||
+        requested.has('yard')) {
+        return 'garden-house';
+    }
+    if ((args.bedroomCount ?? 0) <= 1)
+        return 'empty-studio';
+    if ((args.bedroomCount ?? 0) <= 2)
+        return 'two-bedroom';
+    return 'garden-house';
+}
+function countNodeTypes(nodes) {
+    let roomCount = 0;
+    for (const node of Object.values(nodes)) {
+        if (node.type === 'zone')
+            roomCount++;
+    }
+    return {
+        nodeCount: Object.keys(nodes).length,
+        roomCount,
+    };
+}
+export function registerCreateHouseFromBrief(server, bridge) {
+    server.registerTool('create_house_from_brief', {
+        title: 'Create house from brief',
+        description: 'High-level hosted workflow for external agents: choose a starter house from a brief, create/save/publish it, and return the editor URL. Use semantic tools afterward for exact customization.',
+        inputSchema: createHouseFromBriefInput,
+        outputSchema: createHouseFromBriefOutput,
+    }, async ({ brief, projectId, projectName, bedroomCount, rooms, style, landscaping, constraints, }) => {
+        const templateId = chooseTemplate({
+            ...(bedroomCount !== undefined ? { bedroomCount } : {}),
+            ...(rooms !== undefined ? { rooms } : {}),
+            ...(landscaping !== undefined ? { landscaping } : {}),
+        });
+        if (!isTemplateId(templateId)) {
+            throwMcpError(ErrorCode.InternalError, `unknown_template: ${templateId}`);
+        }
+        const entry = TEMPLATES[templateId];
+        const cloned = rehydrateSiteChildren(cloneSceneGraph(entry.template));
+        const nodes = cloned.nodes;
+        const rootNodeIds = cloned.rootNodeIds;
+        const counts = countNodeTypes(nodes);
+        try {
+            bridge.setScene(nodes, rootNodeIds);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throwMcpError(ErrorCode.InternalError, `apply_failed: ${msg}`);
+        }
+        const rawValidation = bridge.validateScene();
+        const validation = {
+            valid: rawValidation.valid,
+            errors: rawValidation.errors.map((error) => `${error.nodeId}:${error.path}: ${error.message}`),
+        };
+        const limitations = [];
+        if ((bedroomCount ?? 0) > 2) {
+            limitations.push('MVP create_house_from_brief uses the closest built-in template for 3+ bedroom requests; refine with create_room/add_door/add_window for exact room count.');
+        }
+        if (style || constraints) {
+            limitations.push('Style and constraints are recorded in the summary but not yet fully synthesized into custom geometry.');
+        }
+        if (!bridge.hasStore) {
+            const payload = {
+                projectId: null,
+                editorUrl: null,
+                url: null,
+                version: null,
+                published: false,
+                isDraft: false,
+                templateId,
+                nodeCount: counts.nodeCount,
+                roomCount: counts.roomCount,
+                ...currentLevelContext(bridge),
+                validation,
+                summary: `Applied ${entry.name} starter scene from brief: ${brief}`,
+                limitations,
+                nextStep: 'No SceneStore is attached. Call save_scene later in a hosted MCP session to publish.',
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        try {
+            let saveProjectId = projectId;
+            if (!saveProjectId && bridge.canCreateProject) {
+                const project = await bridge.createProject({ name: projectName ?? entry.name });
+                saveProjectId = project.projectId;
+            }
+            const meta = await bridge.saveScene({
+                ...(saveProjectId !== undefined ? { id: saveProjectId, projectId: saveProjectId } : {}),
+                name: projectName ?? entry.name,
+                graph: { nodes, rootNodeIds },
+                saveMode: 'draft',
+                publish: false,
+                operation: 'create_house_from_brief',
+            });
+            bridge.setActiveScene(meta);
+            await appendLiveSceneEvent(bridge, meta.id, meta.version, 'create_house_from_brief', {
+                nodes,
+                rootNodeIds,
+            });
+            const scene = sceneMetaPayload(meta, { nodes, rootNodeIds });
+            const payload = {
+                projectId: scene.projectId ?? scene.id,
+                editorUrl: scene.editorUrl,
+                url: scene.url,
+                version: scene.version,
+                published: scene.published,
+                isDraft: scene.isDraft,
+                templateId,
+                nodeCount: scene.nodeCount,
+                roomCount: counts.roomCount,
+                ...currentLevelContext(bridge),
+                validation,
+                summary: `Created ${scene.name} from ${entry.name}. Brief: ${brief}`,
+                limitations,
+                nextStep: 'Call verify_scene and get_project_status. If the brief needs more specificity, refine with semantic tools and save_scene again.',
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throwMcpError(ErrorCode.InternalError, `save_failed: ${msg}`);
+        }
+    });
+}

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

@@ -0,0 +1,14 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../../operations';
+/**
+ * Register the template MCP tools (`list_templates`, `create_from_template`)
+ * against the given server.
+ *
+ * When persistence operations are unavailable, `create_from_template` still
+ * applies the template to the bridge but skips the save step.
+ */
+export declare function registerTemplateTools(server: McpServer, bridge: SceneOperations): void;
+export { createFromTemplateInput, createFromTemplateOutput, registerCreateFromTemplate, } from './create-from-template';
+export { createHouseFromBriefInput, createHouseFromBriefOutput, registerCreateHouseFromBrief, } from './create-house-from-brief';
+export { listTemplatesInput, listTemplatesOutput, registerListTemplates, } from './list-templates';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/templates/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAKvD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAItF;AAED,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,0BAA0B,GAC3B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,yBAAyB,EACzB,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,2BAA2B,CAAA;AAClC,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,kBAAkB,CAAA"}

package/dist/tools/templates/index.js

@@ -0,0 +1,18 @@
+import { registerCreateFromTemplate } from './create-from-template';
+import { registerCreateHouseFromBrief } from './create-house-from-brief';
+import { registerListTemplates } from './list-templates';
+/**
+ * Register the template MCP tools (`list_templates`, `create_from_template`)
+ * against the given server.
+ *
+ * When persistence operations are unavailable, `create_from_template` still
+ * applies the template to the bridge but skips the save step.
+ */
+export function registerTemplateTools(server, bridge) {
+    registerListTemplates(server);
+    registerCreateFromTemplate(server, bridge);
+    registerCreateHouseFromBrief(server, bridge);
+}
+export { createFromTemplateInput, createFromTemplateOutput, registerCreateFromTemplate, } from './create-from-template';
+export { createHouseFromBriefInput, createHouseFromBriefOutput, registerCreateHouseFromBrief, } from './create-house-from-brief';
+export { listTemplatesInput, listTemplatesOutput, registerListTemplates, } from './list-templates';

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

@@ -0,0 +1,18 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+export declare const listTemplatesInput: {};
+export declare const listTemplatesOutput: {
+    templates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        nodeCount: z.ZodNumber;
+    }, z.core.$strip>>;
+};
+/**
+ * `list_templates` — enumerate the seed templates shipped with the MCP server.
+ * Stateless; used by the `from_brief` prompt and by the UI to populate a
+ * "start from a template" picker.
+ */
+export declare function registerListTemplates(server: McpServer): void;
+//# sourceMappingURL=list-templates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-templates.d.ts","sourceRoot":"","sources":["../../../src/tools/templates/list-templates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,kBAAkB,IAAc,CAAA;AAE7C,eAAO,MAAM,mBAAmB;;;;;;;CAS/B,CAAA;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAwB7D"}

package/dist/tools/templates/list-templates.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { TEMPLATES } from '../../templates';
+export const listTemplatesInput = {};
+export const listTemplatesOutput = {
+    templates: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        description: z.string(),
+        nodeCount: z.number(),
+    })),
+};
+/**
+ * `list_templates` — enumerate the seed templates shipped with the MCP server.
+ * Stateless; used by the `from_brief` prompt and by the UI to populate a
+ * "start from a template" picker.
+ */
+export function registerListTemplates(server) {
+    server.registerTool('list_templates', {
+        title: 'List scene templates',
+        description: 'List the seed Pascal scene templates available to `create_from_template`. Returns the id, display name, one-line description and node count for each.',
+        inputSchema: listTemplatesInput,
+        outputSchema: listTemplatesOutput,
+    }, async () => {
+        const templates = Object.values(TEMPLATES).map((entry) => ({
+            id: entry.id,
+            name: entry.name,
+            description: entry.description,
+            nodeCount: Object.keys(entry.template.nodes).length,
+        }));
+        const payload = { templates };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/undo.d.ts

@@ -0,0 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const undoInput: {
+    steps: z.ZodOptional<z.ZodNumber>;
+};
+export declare const undoOutput: {
+    undone: z.ZodNumber;
+};
+export declare function registerUndo(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=undo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"undo.d.ts","sourceRoot":"","sources":["../../src/tools/undo.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,SAAS;;CAErB,CAAA;AAED,eAAO,MAAM,UAAU;;CAEtB,CAAA;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAoB7E"}