feat(mcp,editor): Option A+B storage + 10 agent deliverables (Phase 7)

Ships the combined filesystem/Supabase storage adapter + MCP scene
lifecycle tools + Next.js API routes + editor /scene/[id] route, so
an MCP save is directly openable at /scene/<id> without any
injection hack. End-to-end verified: 10/10 e2e steps pass.

Storage (A1/A2/A3):
- SceneStore interface + error classes + slug helpers
- FilesystemSceneStore at $PASCAL_DATA_DIR (defaults XDG/~/.pascal)
  with atomic writes, .index sidecar, optimistic locking
- SupabaseSceneStore with scenes + scene_revisions tables, RLS
  migration SQL, mock-backed unit tests
- createSceneStore(env) auto-selects based on SUPABASE_URL +
  SUPABASE_SERVICE_ROLE_KEY

MCP tools (A4, A8, A9, A10):
- save_scene / load_scene / list_scenes / delete_scene / rename_scene
- list_templates / create_from_template (3 seed templates:
  empty-studio, two-bedroom, garden-house)
- generate_variants (7 mutation kinds, seeded RNG, save=true|false)
- photo_to_scene (vision sampling → scene graph → save)

Editor (A5, A6):
- /api/scenes + /api/scenes/[id] with RFC 7232 If-Match locking
- /scene/[id] and /scenes route pages with save button, SceneLoader
- Removed the window.__pascalScene dev injection hack

Security + UX edges (A7, A8):
- AssetUrl Zod validator: asset:// blob: data:image/ /path https:
  (http://localhost for dev) + PASCAL_ALLOWED_ASSET_ORIGINS env
  allowlist. Hardens scan.url, guide.url, item.asset.src,
  material.texture.url, MaterialMaps.*Map
- Auto-frame camera on empty→non-empty scene transition
  (camera-controls:fit-scene emitter event)

Shared utilities:
- rehydrateSiteChildren() extracted to packages/mcp/src/lib/ and
  used by both create-from-template and generate-variants to work
  around the SiteNode.children-as-objects vs. ids inconsistency
  (CROSS_CUTTING §2)
- Storage + MCP subpath exports added to packages/mcp/package.json
  (CROSS_CUTTING §4)

Tests: 293 pass / 0 fail across 40 files (was 142 pre-Phase-7).
Biome: clean.

Phase-7 e2e script at packages/mcp/test-reports/phase7-e2e.ts:
MCP HTTP + editor Next.js both point at $PASCAL_DATA_DIR =
/tmp/pascal-e2e, save_scene from MCP, GET /api/scenes/<id> from
editor server, /scenes list page renders all saved scenes, scene
page renders SceneLoader, delete_scene works.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

packages/mcp/src/tools/scene-lifecycle/save-scene.ts

@@ -0,0 +1,111 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { SceneGraph } from '@pascal-app/core/clone-scene-graph'
+import { z } from 'zod'
+import type { SceneBridge } from '../../bridge/scene-bridge'
+import { type SceneStore, SceneVersionConflictError } from '../../storage/types'
+import { ErrorCode, throwMcpError } from '../errors'
+
+export const saveSceneInput = {
+  id: z.string().min(1).max(64).optional(),
+  name: z.string().min(1).max(200),
+  projectId: z.string().optional(),
+  expectedVersion: z.number().int().positive().optional(),
+  thumbnail: z.string().url().optional(),
+  includeCurrentScene: z
+    .boolean()
+    .default(true)
+    .describe('If true, save the bridge current scene. If false, use the graph arg.'),
+  graph: z
+    .record(z.string(), z.unknown())
+    .optional()
+    .describe(
+      'Full SceneGraph { nodes, rootNodeIds, collections? } to save instead of the bridge state.',
+    ),
+}
+
+export const saveSceneOutput = {
+  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(),
+}
+
+export function registerSaveScene(server: McpServer, bridge: SceneBridge, store: SceneStore): void {
+  server.registerTool(
+    'save_scene',
+    {
+      title: 'Save scene',
+      description:
+        'Persist the current scene (or a provided graph) to the SceneStore. Returns the SceneMeta along with a `url` pointing to `/scene/<id>`.',
+      inputSchema: saveSceneInput,
+      outputSchema: saveSceneOutput,
+    },
+    async ({ id, name, projectId, expectedVersion, thumbnail, includeCurrentScene, graph }) => {
+      let sceneGraph: SceneGraph
+      if (includeCurrentScene) {
+        const validation = bridge.validateScene()
+        if (!validation.valid) {
+          throwMcpError(ErrorCode.InvalidRequest, 'scene_invalid', { errors: validation.errors })
+        }
+        const exported = bridge.exportJSON()
+        sceneGraph = {
+          nodes: exported.nodes,
+          rootNodeIds: exported.rootNodeIds,
+          collections: exported.collections as SceneGraph['collections'],
+        }
+      } else {
+        if (!graph) {
+          throwMcpError(
+            ErrorCode.InvalidParams,
+            'graph_required: pass `graph` when includeCurrentScene is false',
+          )
+        }
+        sceneGraph = graph as unknown as SceneGraph
+      }
+
+      try {
+        const meta = await store.save({
+          ...(id !== undefined ? { id } : {}),
+          name,
+          ...(projectId !== undefined ? { projectId } : {}),
+          graph: sceneGraph,
+          ...(thumbnail !== undefined ? { thumbnailUrl: thumbnail } : {}),
+          ...(expectedVersion !== undefined ? { expectedVersion } : {}),
+        })
+        const payload = {
+          id: meta.id,
+          name: meta.name,
+          projectId: meta.projectId,
+          thumbnailUrl: meta.thumbnailUrl,
+          version: meta.version,
+          createdAt: meta.createdAt,
+          updatedAt: meta.updatedAt,
+          ownerId: meta.ownerId,
+          sizeBytes: meta.sizeBytes,
+          nodeCount: meta.nodeCount,
+          url: `/scene/${meta.id}`,
+        }
+        return {
+          content: [{ type: 'text' as const, text: JSON.stringify(payload) }],
+          structuredContent: payload,
+        }
+      } catch (err) {
+        if (err instanceof SceneVersionConflictError) {
+          throwMcpError(ErrorCode.InvalidRequest, 'version_conflict', {
+            expectedVersion,
+            id,
+          })
+        }
+        const msg = err instanceof Error ? err.message : String(err)
+        throwMcpError(ErrorCode.InvalidRequest, msg)
+      }
+    },
+  )
+}