Reset core/viewer/editor/mcp packages and apps/editor from private-editor

Wholesale swap of packages/{core,viewer,editor,mcp} and apps/editor with the
versions from the private editor repo, which is the production source of truth.

Setup changes:
- packages/{core,viewer,editor} versions held at 0.7.0 baseline (matching
  the most recent published release) so a bump=minor publishes 0.8.0
- packages/mcp held at 0.1.1 (never published; first publish will go through
  the new release.yml flow)
- peerDependencies and devDependencies for inter-package @pascal-app/*
  references pinned to ^0.7.0 instead of '*' / 'workspace:*' so they are
  valid for npm consumers
- Root package.json: TypeScript bumped to 6.0.2, added overrides for
  @types/react, @types/react-dom, @types/three to prevent JSX namespace
  fragmentation across the workspace
- release.yml extended to also publish editor and mcp; 'both' option renamed
  to 'all'; added a sync step that updates inter-package peerDeps/devDeps to
  match the new versions on every bump (so viewer/editor/mcp tarballs always
  reference the version of core they were built against)
- Root scripts gained release:editor and release:mcp shortcuts

Verification:
- bun install --frozen-lockfile is consistent
- packages/{core,viewer,mcp} build cleanly, dist/index.d.ts emitted
- packages/editor check-types reports 21 pre-existing errors, identical to
  what private-editor currently reports

Open PRs against editor-v2 will need rebasing/conflict resolution.

packages/mcp/src/tools/scene-lifecycle/create-project.ts

@@ -0,0 +1,85 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z } from 'zod'
+import type { SceneOperations } from '../../operations'
+import { ErrorCode, throwMcpError } from '../errors'
+import { currentLevelContext, projectStatusPayload } from './metadata'
+
+export const createProjectInput = {
+  name: z.string().min(1).max(200),
+  id: z.string().min(1).max(64).optional(),
+  isPrivate: z.boolean().default(true),
+}
+
+export const createProjectOutput = {
+  id: z.string(),
+  projectId: z.string(),
+  name: z.string(),
+  editorUrl: z.string(),
+  url: z.string(),
+  ownerId: z.string().nullable(),
+  thumbnailUrl: z.string().nullable(),
+  publishedVersion: z.number().nullable(),
+  latestVersion: z.number().nullable(),
+  draftVersion: z.number().nullable(),
+  browserVisibleVersion: z.number().nullable(),
+  version: z.number(),
+  isEmpty: z.boolean(),
+  sizeBytes: z.number(),
+  nodeCount: z.number(),
+  graphHash: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  levelIds: z.array(z.string()),
+  defaultLevelId: z.string().nullable(),
+  nextStep: z.string(),
+}
+
+export function registerCreateProject(server: McpServer, operations: SceneOperations): void {
+  server.registerTool(
+    'create_project',
+    {
+      title: 'Create project',
+      description:
+        'Create a browser-visible Pascal project for the authenticated user. Use this before save_scene when the user asks for a new project.',
+      inputSchema: createProjectInput,
+      outputSchema: createProjectOutput,
+    },
+    async ({ name, id, isPrivate }) => {
+      if (!operations.canCreateProject) {
+        throwMcpError(
+          ErrorCode.InvalidRequest,
+          'create_project_unavailable: this MCP store cannot create hosted projects',
+        )
+      }
+      try {
+        const status = await operations.createProject({
+          name,
+          ...(id !== undefined ? { id } : {}),
+          isPrivate,
+        })
+        operations.setActiveScene({
+          id: status.id,
+          name: status.name,
+          projectId: status.projectId,
+          ownerId: status.ownerId,
+          thumbnailUrl: status.thumbnailUrl,
+          version: status.version,
+        })
+        const payload = {
+          ...projectStatusPayload(
+            status,
+            'The project is now bound to this MCP session. Open editorUrl now; semantic tools will update the browser-visible draft. Call save_scene with saveMode: "checkpoint" only when you want a meaningful version.',
+          ),
+          ...currentLevelContext(operations),
+        }
+        return {
+          content: [{ type: 'text' as const, text: JSON.stringify(payload) }],
+          structuredContent: payload,
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        throwMcpError(ErrorCode.InvalidRequest, msg)
+      }
+    },
+  )
+}