@pascal-app/mcp 0.2.0

package/dist/prompts/iterate-on-feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate-on-feedback.d.ts","sourceRoot":"","sources":["../../src/prompts/iterate-on-feedback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAiBpD;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE/E;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAuB3F"}

package/dist/prompts/iterate-on-feedback.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { SCENE_DESIGN_GUIDANCE } from './scene-guidance';
+const PREAMBLE = [
+    'You are iterating on an existing Pascal scene based on user feedback.',
+    'Given the current state (read via the `pascal://scene/current` resource) and the user feedback below, propose the MINIMUM set of `apply_patch` operations that satisfies the feedback.',
+    'Rules:',
+    '  - Prefer updates over create+delete pairs when a field change will do.',
+    '  - Do not re-create nodes that already exist.',
+    '  - Do not touch nodes that are unrelated to the feedback.',
+    '  - Prefer semantic tools such as create_room, add_door, add_window, furnish_room, and place_item when they match the request.',
+    '  - Bundle related mutations into a single `apply_patch` call so they share one undo step.',
+    '  - For multi-room changes, call verify_scene after the mutation and fix reported issues.',
+    SCENE_DESIGN_GUIDANCE,
+    '  - Respond ONLY with tool calls. No prose.',
+].join('\n');
+/**
+ * Build the user-facing prompt text for `iterate_on_feedback`.
+ * Pure function for testability.
+ */
+export function buildIterateOnFeedbackPrompt(args) {
+    return [PREAMBLE, '', '## User feedback', args.feedback.trim()].join('\n');
+}
+export function registerIterateOnFeedback(server, _bridge) {
+    server.registerPrompt('iterate_on_feedback', {
+        title: 'Iterate on a scene from user feedback',
+        description: 'Produces a minimal-diff plan of apply_patch calls in response to user feedback on the current scene.',
+        argsSchema: {
+            feedback: z.string(),
+        },
+    }, async ({ feedback }) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: buildIterateOnFeedbackPrompt({ feedback }),
+                },
+            },
+        ],
+    }));
+}

package/dist/prompts/renovation-from-photos.d.ts

@@ -0,0 +1,24 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../operations';
+type PromptContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+    mimeType: string;
+};
+/**
+ * Build the full messages array. Pure function for testability.
+ */
+export declare function buildRenovationMessages(args: {
+    currentPhotos: string[] | string | undefined;
+    referencePhotos: string[] | string | undefined;
+    goals: string;
+}): Array<{
+    role: 'user';
+    content: PromptContent;
+}>;
+export declare function registerRenovationFromPhotos(server: McpServer, _bridge: SceneOperations): void;
+export {};
+//# sourceMappingURL=renovation-from-photos.d.ts.map

package/dist/prompts/renovation-from-photos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renovation-from-photos.d.ts","sourceRoot":"","sources":["../../src/prompts/renovation-from-photos.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAgCpD,KAAK,aAAa,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AA6CrD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,aAAa,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAAA;IAC5C,eAAe,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAAA;IAC9C,KAAK,EAAE,MAAM,CAAA;CACd,GAAG,KAAK,CAAC;IACR,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,aAAa,CAAA;CACvB,CAAC,CA+CD;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAmB9F"}

package/dist/prompts/renovation-from-photos.js

@@ -0,0 +1,135 @@
+import { z } from 'zod';
+const PREAMBLE = [
+    'You are renovating an existing room based on photos of the current space and reference photos of the target aesthetic.',
+    '',
+    'Follow this procedure:',
+    '  1. Call `analyze_floorplan_image` and/or `analyze_room_photo` on EACH current photo to extract walls, rooms, fixtures, and approximate dimensions. Do the same for reference photos.',
+    '  2. Compare the current-state analyses to the reference-state analyses. Identify concrete deltas (materials, fixtures, layout changes) that align with the renovation goals.',
+    '  3. Emit a single `apply_patch` call containing the minimum set of patches needed to converge the current scene toward the goals.',
+    '',
+    'Rules:',
+    '  - Do not invent dimensions. Pull them from the analysis tool results.',
+    '  - Do not modify nodes that are unrelated to the goals.',
+    '  - Respond ONLY with tool calls. No prose.',
+].join('\n');
+function isDataUrl(s) {
+    return s.startsWith('data:');
+}
+function isHttpUrl(s) {
+    return s.startsWith('http://') || s.startsWith('https://');
+}
+/**
+ * Rough base64 detector: length multiple of 4, only base64 chars, at least 32 chars long.
+ * Deliberately conservative — when in doubt we fall back to text `URL: ...`.
+ */
+function looksLikeBase64(s) {
+    if (s.length < 32)
+        return false;
+    if (s.length % 4 !== 0)
+        return false;
+    return /^[A-Za-z0-9+/=]+$/.test(s);
+}
+/** Extract a base64 payload from a data-URL, or return the raw string. */
+function toImageContent(source) {
+    if (isDataUrl(source)) {
+        const match = /^data:([^;,]+)?(?:;base64)?,(.*)$/.exec(source);
+        if (match) {
+            const mimeType = match[1] && match[1].length > 0 ? match[1] : 'image/jpeg';
+            const data = match[2] ?? '';
+            return { type: 'image', data, mimeType };
+        }
+        return { type: 'text', text: `URL: ${source}` };
+    }
+    if (isHttpUrl(source)) {
+        return { type: 'text', text: `URL: ${source}` };
+    }
+    if (looksLikeBase64(source)) {
+        return { type: 'image', data: source, mimeType: 'image/jpeg' };
+    }
+    return { type: 'text', text: `URL: ${source}` };
+}
+/** Parse the stringified list argument (JSON array or comma-separated fallback). */
+function parsePhotoList(raw) {
+    if (Array.isArray(raw)) {
+        return raw.map((s) => String(s)).filter((s) => s.length > 0);
+    }
+    const str = (raw ?? '').trim();
+    if (str.length === 0)
+        return [];
+    if (str.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(str);
+            if (Array.isArray(parsed)) {
+                return parsed.map((s) => String(s)).filter((s) => s.length > 0);
+            }
+        }
+        catch {
+            /* fall through to comma-split */
+        }
+    }
+    return str
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+/**
+ * Build the full messages array. Pure function for testability.
+ */
+export function buildRenovationMessages(args) {
+    const current = parsePhotoList(args.currentPhotos);
+    const reference = parsePhotoList(args.referencePhotos);
+    const intro = [
+        PREAMBLE,
+        '',
+        '## Goals',
+        args.goals.trim(),
+        '',
+        '## Inputs',
+        `Current photos: ${current.length} item(s)`,
+        `Reference photos: ${reference.length} item(s)`,
+    ].join('\n');
+    const messages = [
+        { role: 'user', content: { type: 'text', text: intro } },
+    ];
+    if (current.length > 0) {
+        messages.push({
+            role: 'user',
+            content: { type: 'text', text: '## Current photos' },
+        });
+        for (const src of current) {
+            messages.push({ role: 'user', content: toImageContent(src) });
+        }
+    }
+    if (reference.length > 0) {
+        messages.push({
+            role: 'user',
+            content: { type: 'text', text: '## Reference photos' },
+        });
+        for (const src of reference) {
+            messages.push({ role: 'user', content: toImageContent(src) });
+        }
+    }
+    messages.push({
+        role: 'user',
+        content: {
+            type: 'text',
+            text: '## Task\nProduce `apply_patch` operations that drive the current scene toward the goals, using only dimensions and fixtures you derived from the analysis tools.',
+        },
+    });
+    return messages;
+}
+export function registerRenovationFromPhotos(server, _bridge) {
+    server.registerPrompt('renovation_from_photos', {
+        title: 'Plan a renovation from photos',
+        description: 'Plan a minimal-patch renovation given current-state photos, reference-state photos, and free-form goals.',
+        argsSchema: {
+            // MCP prompt arguments are stringly-typed; accept a JSON array or a
+            // comma-separated list of base64 payloads / data URLs / http(s) URLs.
+            currentPhotos: z.string(),
+            referencePhotos: z.string(),
+            goals: z.string(),
+        },
+    }, async ({ currentPhotos, referencePhotos, goals }) => ({
+        messages: buildRenovationMessages({ currentPhotos, referencePhotos, goals }),
+    }));
+}

package/dist/prompts/scene-guidance.d.ts

@@ -0,0 +1,2 @@
+export declare const SCENE_DESIGN_GUIDANCE: string;
+//# sourceMappingURL=scene-guidance.d.ts.map

package/dist/prompts/scene-guidance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-guidance.d.ts","sourceRoot":"","sources":["../../src/prompts/scene-guidance.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,QAuBtB,CAAA"}

package/dist/prompts/scene-guidance.js

@@ -0,0 +1,24 @@
+export const SCENE_DESIGN_GUIDANCE = [
+    'Scene design workflow:',
+    '  - Use meters. X/Z are horizontal floor-plan axes; Y is vertical.',
+    '  - Read `pascal://agent/guide` when you need construction rules; do not inspect repository code for ordinary scene editing.',
+    '  - Door default: 0.9m wide by 2.1m high, floor-mounted.',
+    '  - Window default: 1.5m wide by 1.5m high with a 0.9m sill height.',
+    '  - For clear concrete requests, act with reasonable defaults instead of asking for clarification.',
+    '  - For full homes/apartments, include realistic support spaces: kitchen, living/dining, bathrooms, hallway/entry, storage/laundry where appropriate.',
+    '  - For multi-story buildings, create separate level-owned story shells. Do not stretch first-floor exterior walls to cover upper floors.',
+    '  - Treat requested story count as occupied stories, not raw level count; dedicated roof/support levels are allowed and must not be deleted just to match a story count.',
+    '',
+    'Preferred phased tool workflow:',
+    '  - Query first with list_levels, get_level_summary, get_walls, or get_zones when editing an existing scene.',
+    '  - Create visible massing early: create_level as needed, then create_story_shell once per story.',
+    '  - For rooms, prefer create_room, then add_door/add_window, then furnish_room.',
+    '  - For stairs between floors, prefer create_stair_between_levels so slab/ceiling openings stay rectangular and do not duplicate auto-generated holes.',
+    '  - For roofs, prefer create_roof and let it create/use a dedicated roof level above the top occupied story so solo/exploded level views can isolate the roof.',
+    '  - verify_scene reports both levelCount and occupiedStoryCount. Use occupiedStoryCount when checking whether a one-story/two-story brief was satisfied.',
+    '  - add_door/add_window use t = 0..1 along a wall: 0 is start, 0.5 is center, 1 is end.',
+    '  - Use search_assets before place_item when placing a specific catalog item.',
+    '  - Use apply_patch for precise bulk edits that the semantic tools cannot express.',
+    '  - After each major phase, call get_level_summary or pascal://scene/current/summary so progress is visible and errors are easier to localize.',
+    '  - After multi-room or full-floor work, call validate_scene and verify_scene, then fix reported issues before finishing.',
+].join('\n');

package/dist/resources/agent-guide.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../operations';
+export declare const AGENT_GUIDE: string;
+export declare function registerAgentGuide(server: McpServer, _bridge: SceneOperations): void;
+//# sourceMappingURL=agent-guide.d.ts.map

package/dist/resources/agent-guide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-guide.d.ts","sourceRoot":"","sources":["../../src/resources/agent-guide.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,eAAO,MAAM,WAAW,QAwDZ,CAAA;AAEZ,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAuCpF"}

package/dist/resources/agent-guide.js

@@ -0,0 +1,85 @@
+export const AGENT_GUIDE = [
+    '# Pascal MCP Agent Guide',
+    '',
+    'You are editing Pascal architectural projects. Use MCP tools only; do not inspect the Pascal repository unless the user explicitly asks.',
+    '',
+    '## Standard Workflow',
+    '',
+    '1. Read this guide or call `get_capabilities` if available.',
+    '2. If the user asks for a new project, call `create_project` first.',
+    '3. For quick starts, call `create_house_from_brief`. For precise edits, build with semantic tools: `create_story_shell`, `create_room`, `add_door`, `add_window`, `furnish_room`, `create_roof`, `place_item`.',
+    '4. Let semantic tools update the browser-visible draft. Call `save_scene` with `saveMode: "draft"` for autosave-style progress, or `saveMode: "checkpoint"` only for meaningful milestones.',
+    '5. Call `validate_scene`, `verify_scene`, then `get_project_status`.',
+    '6. Return the final `editorUrl` from tool output. Do not infer routes.',
+    '',
+    '## Important Concepts',
+    '',
+    '- A project is the browser-visible container.',
+    '- A scene graph is the architectural model.',
+    '- A draft is the browser-visible working model and may be overwritten many times.',
+    '- A version/checkpoint is a meaningful saved model revision.',
+    '- The browser editor opens the current draft when one exists, otherwise the published version.',
+    '- Always return the `editorUrl`, not an internal API URL.',
+    '',
+    '## URLs',
+    '',
+    '- Use `editorUrl` returned by tools.',
+    '- If a tool returns only an id, call `get_project_status` to get the browser URL.',
+    '- Hosted editor URLs use `/editor/<projectId>`.',
+    '',
+    '## Scene Creation Rules',
+    '',
+    '- Prefer semantic tools over raw graph patches.',
+    '- Do not hand-write node graphs unless no semantic tool exists.',
+    '- For rooms, use `create_room` -> `add_door` -> `add_window` -> `furnish_room`.',
+    '- For complete homes, create exterior shell, interior rooms, openings, roof, furniture, then landscaping.',
+    '- For doors/windows, use `t` or `position` from 0 to 1 along the wall unless a tool explicitly says otherwise.',
+    '- X/Z are floor-plan axes and Y is vertical; dimensions are meters.',
+    '- Use `create_roof` for roofs. A dedicated roof support level is valid and should not count as an occupied story.',
+    '',
+    '## Required Final Checks',
+    '',
+    '- `save_scene` must succeed. Use `saveMode: "checkpoint"` before final handoff only if the user asked for a durable version.',
+    '- `verify_scene.hasIssues` should be false; otherwise explain remaining issues.',
+    '- `get_project_status.nodeCount` must be greater than 0 for a non-empty design.',
+    '- Return `editorUrl` in the final user response.',
+    '',
+    '## If Something Looks Empty',
+    '',
+    '1. Call `get_project_status`.',
+    '2. Compare `publishedVersion`, `latestVersion`, `browserVisibleVersion`, `nodeCount`, and `graphHash`.',
+    '3. If the graph is non-empty but the browser appears empty, call `get_project_status` to re-bind the session, then `save_scene` with `saveMode: "draft"`.',
+    '4. Re-run `verify_scene`.',
+    '',
+    '## Output Contract',
+    '',
+    'Final user response should include: project name, `editorUrl`, version, node/room summary, and any known limitations.',
+].join('\n');
+export function registerAgentGuide(server, _bridge) {
+    server.registerResource('agent-guide', 'pascal://agent-guide', {
+        title: 'Pascal MCP agent guide',
+        description: 'Short MCP-first project creation, save/publish, validation, and output workflow for external agents.',
+        mimeType: 'text/markdown',
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: 'text/markdown',
+                text: AGENT_GUIDE,
+            },
+        ],
+    }));
+    server.registerResource('agent-guide-legacy', 'pascal://agent/guide', {
+        title: 'Pascal MCP agent guide',
+        description: 'Legacy URI for the Pascal MCP agent guide. Prefer pascal://agent-guide.',
+        mimeType: 'text/markdown',
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: 'text/markdown',
+                text: AGENT_GUIDE,
+            },
+        ],
+    }));
+}

package/dist/resources/catalog-items.d.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../operations';
+/**
+ * `pascal://catalog/items` — small built-in item catalog for standalone MCP.
+ *
+ * The editor UI owns the full catalog. MCP intentionally keeps a dependency-free
+ * subset so headless agents can still place realistic furniture and fixtures.
+ */
+export declare function registerCatalogItems(server: McpServer, _bridge: SceneOperations): void;
+//# sourceMappingURL=catalog-items.d.ts.map

package/dist/resources/catalog-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-items.d.ts","sourceRoot":"","sources":["../../src/resources/catalog-items.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CA2BtF"}

package/dist/resources/catalog-items.js

@@ -0,0 +1,29 @@
+import { MCP_CATALOG_ITEMS } from '../tools/asset-catalog';
+/**
+ * `pascal://catalog/items` — small built-in item catalog for standalone MCP.
+ *
+ * The editor UI owns the full catalog. MCP intentionally keeps a dependency-free
+ * subset so headless agents can still place realistic furniture and fixtures.
+ */
+export function registerCatalogItems(server, _bridge) {
+    server.registerResource('catalog-items', 'pascal://catalog/items', {
+        title: 'Item catalog',
+        description: 'Dependency-free catalog subset of placeable items available in standalone MCP mode.',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const payload = {
+            status: 'ok',
+            items: MCP_CATALOG_ITEMS,
+            note: 'Standalone MCP catalog subset; host applications can still expose a larger catalog separately.',
+        };
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(payload),
+                },
+            ],
+        };
+    });
+}

package/dist/resources/constraints.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../operations';
+/**
+ * `pascal://constraints/{levelId}` — per-level geometric constraints used as
+ * input hints for agents: slab nodes (with polygons/holes/elevation) + each
+ * wall's plan-view footprint polygon.
+ */
+export declare function registerConstraints(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=constraints.d.ts.map

package/dist/resources/constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../../src/resources/constraints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAIxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAoEpD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyBpF"}

package/dist/resources/constraints.js

@@ -0,0 +1,69 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { getWallPlanFootprint } from '@pascal-app/core/wall';
+/**
+ * Empty `WallMiterData` — we don't compute junctions here. The footprint
+ * falls back to a simple rectangle based on start/end + thickness, which is
+ * correct for non-intersecting walls and an acceptable approximation for
+ * constraint hints.
+ *
+ * Typed via `Parameters<typeof getWallPlanFootprint>[1]` to avoid `any` and
+ * to stay in sync with the core signature.
+ */
+const EMPTY_MITER_DATA = {
+    junctionData: new Map(),
+    junctions: new Map(),
+};
+function buildPayload(bridge, levelId) {
+    const level = bridge.getNode(levelId);
+    if (!level || level.type !== 'level') {
+        return {
+            error: 'level_not_found',
+            levelId,
+            slabs: [],
+            wallPolygons: [],
+        };
+    }
+    const all = bridge.findNodes({ levelId: levelId });
+    const slabs = [];
+    const walls = [];
+    for (const n of all) {
+        if (n.type === 'slab')
+            slabs.push(n);
+        else if (n.type === 'wall')
+            walls.push(n);
+    }
+    const wallPolygons = [];
+    for (const wall of walls) {
+        const points = getWallPlanFootprint(wall, EMPTY_MITER_DATA);
+        wallPolygons.push({
+            wallId: wall.id,
+            footprint: points.map((p) => [p.x, p.y]),
+        });
+    }
+    return { levelId, slabs, wallPolygons };
+}
+/**
+ * `pascal://constraints/{levelId}` — per-level geometric constraints used as
+ * input hints for agents: slab nodes (with polygons/holes/elevation) + each
+ * wall's plan-view footprint polygon.
+ */
+export function registerConstraints(server, bridge) {
+    server.registerResource('constraints', new ResourceTemplate('pascal://constraints/{levelId}', { list: undefined }), {
+        title: 'Level constraints',
+        description: 'Per-level constraints: slab nodes and wall plan footprints. Returns {error:"level_not_found"} if the level id is unknown.',
+        mimeType: 'application/json',
+    }, async (uri, variables) => {
+        const rawLevelId = variables.levelId;
+        const levelId = Array.isArray(rawLevelId) ? rawLevelId[0] : rawLevelId;
+        const payload = buildPayload(bridge, levelId ?? '');
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(payload),
+                },
+            ],
+        };
+    });
+}

package/dist/resources/index.d.ts

@@ -0,0 +1,15 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../operations';
+/**
+ * Registers all MCP resources exposed by `@pascal-app/mcp`.
+ *
+ * Resources:
+ * - `pascal://scene/current`          — application/json, full snapshot
+ * - `pascal://scene/current/summary`  — text/markdown, human summary
+ * - `pascal://catalog/items`          — application/json, host-supplied catalog
+ * - `pascal://constraints/{levelId}`  — application/json, per-level constraints
+ * - `pascal://agent-guide`            — text/markdown, MCP-first agent guide
+ * - `pascal://agent/guide`            — text/markdown, legacy alias
+ */
+export declare function registerResources(server: McpServer, operations: SceneOperations): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CAMtF"}

package/dist/resources/index.js

@@ -0,0 +1,23 @@
+import { registerAgentGuide } from './agent-guide';
+import { registerCatalogItems } from './catalog-items';
+import { registerConstraints } from './constraints';
+import { registerSceneCurrent } from './scene-current';
+import { registerSceneSummary } from './scene-summary';
+/**
+ * Registers all MCP resources exposed by `@pascal-app/mcp`.
+ *
+ * Resources:
+ * - `pascal://scene/current`          — application/json, full snapshot
+ * - `pascal://scene/current/summary`  — text/markdown, human summary
+ * - `pascal://catalog/items`          — application/json, host-supplied catalog
+ * - `pascal://constraints/{levelId}`  — application/json, per-level constraints
+ * - `pascal://agent-guide`            — text/markdown, MCP-first agent guide
+ * - `pascal://agent/guide`            — text/markdown, legacy alias
+ */
+export function registerResources(server, operations) {
+    registerAgentGuide(server, operations);
+    registerSceneCurrent(server, operations);
+    registerSceneSummary(server, operations);
+    registerCatalogItems(server, operations);
+    registerConstraints(server, operations);
+}

package/dist/resources/scene-current.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../operations';
+/**
+ * `pascal://scene/current` — full `{ nodes, rootNodeIds, collections }` snapshot.
+ *
+ * Static URI (not a template). MIME `application/json`.
+ */
+export declare function registerSceneCurrent(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=scene-current.d.ts.map

package/dist/resources/scene-current.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-current.d.ts","sourceRoot":"","sources":["../../src/resources/scene-current.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAoBrF"}

package/dist/resources/scene-current.js

@@ -0,0 +1,20 @@
+/**
+ * `pascal://scene/current` — full `{ nodes, rootNodeIds, collections }` snapshot.
+ *
+ * Static URI (not a template). MIME `application/json`.
+ */
+export function registerSceneCurrent(server, bridge) {
+    server.registerResource('scene-current', 'pascal://scene/current', {
+        title: 'Current scene',
+        description: 'Complete snapshot of the live Pascal scene: nodes dict, rootNodeIds, collections.',
+        mimeType: 'application/json',
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: 'application/json',
+                text: JSON.stringify(bridge.exportJSON()),
+            },
+        ],
+    }));
+}

package/dist/resources/scene-summary.d.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../operations';
+/** Build the markdown summary. Pure over the SceneGraph snapshot. */
+export declare function buildSceneSummaryMarkdown(snapshot: ReturnType<SceneOperations['exportJSON']>): string;
+/**
+ * `pascal://scene/current/summary` — human-readable scene overview.
+ * MIME `text/markdown`.
+ */
+export declare function registerSceneSummary(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=scene-summary.d.ts.map

package/dist/resources/scene-summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-summary.d.ts","sourceRoot":"","sources":["../../src/resources/scene-summary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AA4EpD,qEAAqE;AACrE,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,UAAU,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,GAClD,MAAM,CAgGR;AAgBD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAoBrF"}