{
  "skill_name": "pascal-3d",
  "evals": [
    {
      "id": 1,
      "prompt": "Set up Pascal locally for Codex on this Mac, create a small room, validate it, and return the editor link. Keep all project data local.",
      "expected_output": "Uses the local CLI and stable MCP connector, creates no hosted account, validates and saves the scene, and returns only a tool-provided editorUrl.",
      "files": [],
      "expectations": [
        "Chooses the local CLI path and does not request or create a hosted credential.",
        "Uses pascal mcp setup codex or the pascal mcp connect configuration.",
        "Runs validate_scene, verify_scene, save_scene, and get_project_status before claiming success.",
        "Does not claim GLB export or cloud synchronization."
      ]
    },
    {
      "id": 2,
      "prompt": "I have a Pascal project in my company workspace. Connect Claude Code and add exactly one window without changing anything else.",
      "expected_output": "Uses a Settings-created workspace key, preserves scope, verifies the one-node edit, and returns the reported hosted editor URL.",
      "files": [],
      "expectations": [
        "Explains that the key must belong to the target user or organization workspace.",
        "Does not self-register a separate account.",
        "Reads the target and records a version or graph hash before the edit.",
        "Reports the changed node ID and post-save verification evidence."
      ]
    },
    {
      "id": 3,
      "prompt": "I don't have a Pascal account. You are authorized to create a private agent-owned workspace for this modeling task; keep the API key safe and don't show it to me.",
      "expected_output": "Uses the autonomous registration path once, stores the returned key securely without echoing it, and accurately describes separate account ownership.",
      "files": [],
      "expectations": [
        "Treats the prompt as explicit authorization for autonomous registration.",
        "Does not claim an email address or browser login for the agent account.",
        "Does not print the API key or place it in source control.",
        "States that the project will not automatically appear in another Pascal account."
      ]
    },
    {
      "id": 4,
      "prompt": "Tell me what Pascal can do before I decide whether to connect anything.",
      "expected_output": "Describes public capabilities and limitations without creating an account, configuring a client, or mutating a project.",
      "files": [],
      "expectations": [
        "Does not register an account or request a credential.",
        "Separates local, hosted, and custom MCP storage paths.",
        "States that headless GLB export is currently not implemented.",
        "Does not claim that every MCP host supports sampling or the same release version."
      ]
    }
  ]
}

{
  "skill_name": "pascal-3d",
  "evals": [
    {
      "query": "Connect Codex to Pascal locally, build a two-room floor plan, validate it, and give me the editor link.",
      "should_trigger": true
    },
    {
      "query": "Open my existing Pascal project and add one window to the west wall without changing the rest of the scene.",
      "should_trigger": true
    },
    {
      "query": "I authorize a private agent-owned Pascal account for this task. Create a small studio model and keep the key secret.",
      "should_trigger": true
    },
    {
      "query": "Inspect this Pascal scene for schema and practical layout problems, but do not save any changes.",
      "should_trigger": true
    },
    {
      "query": "Set up the Pascal MCP server in Claude Code for a project that must stay in my company workspace.",
      "should_trigger": true
    },
    {
      "query": "Optimize the frame rate of my Three.js particle demo.",
      "should_trigger": false
    },
    {
      "query": "Write a Blender Python script that renders a rotating logo.",
      "should_trigger": false
    },
    {
      "query": "Summarize this architecture magazine article; no modeling work is needed.",
      "should_trigger": false
    },
    {
      "query": "Help me choose paint colors for a living room from a text description.",
      "should_trigger": false
    },
    {
      "query": "Convert 84 inches to meters.",
      "should_trigger": false
    }
  ]
}

# Example: authorized autonomous project

User request:

> You may create a separate Pascal agent account for this task. Build a private studio model and keep the credential for later agent runs.

Expected workflow:

1. Confirm that the instruction authorizes a separate agent-owned account.
2. Register once through the HTTPS registration endpoint without echoing the returned key.
3. Store the key in the host's secret store or a user-only credential file and configure the hosted MCP endpoint.
4. Use the returned starter project or create a project, build the studio, validate it, save it, and retrieve project status.
5. Explain that the project belongs to the agent account and does not automatically appear in the user's browser account.

Do not claim that the agent has an email inbox, can sign into the browser, or transferred project ownership.

# Example: edit an existing hosted project

User request:

> Add one window to the project in my Pascal workspace and leave everything else alone.

Expected workflow:

1. Use a Settings-created key for the same user or organization that owns the project.
2. Load the exact project, record its version or graph hash, and identify the target wall.
3. Add one window with the semantic opening tool.
4. Re-read the target, verify that unrelated node counts remain stable, then run `validate_scene` and `verify_scene`.
5. Save a draft and return the `editorUrl`, changed node ID, and validation result.

Self-registration is the wrong path because it creates a separate owner account.

# Example: create a local project

User request:

> Keep this on my Mac. Create a 4 m by 3 m room with one door, validate it, and give me the local editor link.

Expected workflow:

1. Select the local CLI path; do not request an account or API key.
2. If needed, install with `npm install --global @pascal-app/cli`, run `pascal editor --no-open`, then configure the active host with `pascal mcp setup <host>`. Use one active agent client per local service; concurrent clients share active scene state.
3. Read `pascal://agent-guide`.
4. Call `create_project`, `create_room`, and `add_door` with meter values.
5. Call `validate_scene`, `verify_scene`, `save_scene` in draft mode, and `get_project_status`.
6. Return the exact local `editorUrl` and any unresolved verification issues.

The answer should not claim cloud backup, account creation, publication, or GLB export.

# Pascal connection and credential setup

Source and public-documentation review date: 2026-09-10. Native task results are recorded separately with the evaluated source hash; source review alone does not prove every host or published runtime works.

Choose one path. Do not switch storage boundaries without the user's instruction.

## Local Pascal CLI

Use local mode when the project should remain on the current machine. It requires Node.js 22.13 or newer and does not require a Pascal account or API key.

Install the published CLI:

```bash
npm install --global @pascal-app/cli
pascal editor --no-open
```

The npm package keeps the MCP service inside it and downloads the roughly 64 MB web editor runtime only when a command starts the editor, so `pascal mcp connect` needs no runtime download: an agent-only host can list, load, and save local scenes without one. Run `pascal editor` when a person needs the visual editor, and add `--runtime <archive>` when the host has no network access.

The Claude Code plugin supplies this local connector automatically. Keep `pascal` on the `PATH` used to launch Claude Code; the plugin does not install or start the Pascal editor. Claude Code 2.1.258 loads both the user-scoped `pascal` server created by `pascal mcp setup claude` and the plugin-provided server. Remove the manual entry with `claude mcp remove --scope user pascal` before reloading or restarting Claude Code. Use `/mcp` to remove or disable other manual Pascal connections. Leaving both connections active violates the one-active-agent-client-per-local-service requirement. If the intended project is hosted, disable the plugin-provided local server in `/mcp` before configuring the hosted connection below.

Claude Code users who installed the skill without the plugin can run `pascal mcp setup claude`. Codex users can run `pascal mcp setup codex`. Run only the setup command for the active host. For another JSON-based MCP client, use:

```json
{
  "mcpServers": {
    "pascal": {
      "command": "pascal",
      "args": ["mcp", "connect"]
    }
  }
}
```

OpenClaw:

```bash
openclaw mcp add pascal \
  --command pascal \
  --arg mcp \
  --arg connect
openclaw mcp doctor pascal --probe
```

The stable connector discovers the managed loopback service and its private local token. Diagnose without exposing secrets:

```bash
pascal mcp status --json
pascal doctor --json
```

Local project data is stored under `~/.pascal/data/pascal.db` by default. Do not upload or synchronize it implicitly.

Use only one active agent client with each local CLI service. The standalone HTTP service shares active scene state across clients; do not run concurrent agents against that process. Separate processes need separate local data stores for independent work. The hosted endpoint below uses a different session-isolated bridge.

## Hosted Pascal for an existing user or organization

Use the hosted endpoint when the user wants the agent to work in a Pascal account or organization:

```text
https://editor.pascal.app/api/mcp
```

Cursor users follow the browser sign-in instructions below. For other clients, the user creates an API key in Pascal Settings (`https://editor.pascal.app/settings`) and chooses the intended personal or organization workspace. Set `PASCAL_API_KEY` to that key without printing it. If you assign it in a shell command, avoid or remove that command from shell history.

Codex CLI:

Replace `paste_key_here` with the API key before running this example.

```bash
export PASCAL_API_KEY="paste_key_here"
codex mcp add pascal \
  --url https://editor.pascal.app/api/mcp \
  --bearer-token-env-var PASCAL_API_KEY
```

Codex stores the environment-variable name, not its value. Set `PASCAL_API_KEY` again in each new terminal before starting Codex, or supply it through the user's existing shell or secret-manager configuration.

Run this command even when the Codex plugin is installed. The plugin's portable `mcp.json` follows Agent Plugins 1.0.0, which forbids credentials and placeholder expansion in `headers` and reserves `Authorization` for the client, so a plugin cannot carry a hosted key. The plugin therefore supplies only the local `pascal` server, and `codex mcp add` owns the hosted connection.

Claude Code:

Plugin users set the key once in the configuration prompt shown when `pascal-agent-skills@pascal` is enabled. To add or change it later, reinstall with `claude plugin install pascal-agent-skills@pascal --config pascal_api_key=<key>`, or open `/plugin` in a session and use its configure flow; there is no `claude plugin config` command. The hosted tools then load under the plugin's `pascal-hosted` server beside the local `pascal` server, and Claude Code keeps the key in the OS keychain, falling back to `~/.claude/.credentials.json`, rather than writing it into `settings.json` or any project file.

Without the plugin, register the hosted endpoint manually:

```bash
: "${PASCAL_API_KEY:?Set PASCAL_API_KEY to the apiKey returned by Pascal}" && \
claude mcp add --scope user --transport http pascal https://editor.pascal.app/api/mcp \
  --header "Authorization: Bearer $PASCAL_API_KEY"
```

The guard exits before changing Claude Code configuration when the variable is unset or empty. Claude Code expands the variable during registration and stores the static Authorization header, including the key, in its private user configuration. The connection is then available in all Claude Code projects for that user. Keep the configuration private; use `--scope local` instead when the connection should remain local to the current project.

OpenClaw:

```bash
: "${PASCAL_API_KEY:?Set PASCAL_API_KEY to a key from Pascal Settings}" && \
openclaw mcp add pascal \
  --url https://editor.pascal.app/api/mcp \
  --transport streamable-http \
  --header "Authorization=Bearer $PASCAL_API_KEY"
openclaw mcp doctor pascal --probe
```

The current OpenClaw static-header path stores the expanded key in its private MCP configuration and may warn about the literal credential during `doctor`. Do not commit or share that configuration. Remove the server with `openclaw mcp unset pascal` and rotate the Pascal key if the configuration is exposed. Skill installation alone does not configure this connection or authorize an account, upload, save, publication, or paid operation.

Cursor:

The Cursor marketplace installs this repository's `skills/` directory. Its `.cursor-plugin/plugin.json` explicitly selects the Cursor MCP configuration, so the Claude-only `${user_config.pascal_api_key}` header is never used by Cursor. The local server runs `npx --yes --package=@pascal-app/cli@1.0.0 pascal mcp connect`; Node.js 22.13 or newer and npm must be available to Cursor. No global `pascal` installation or web-editor runtime is required. The first connection downloads the pinned CLI from npm, and later connections reuse npm's cache. This starts only the local MCP service and keeps existing local project storage. If Cursor reports `spawn npx ENOENT`, install Node.js/npm and fully restart Cursor so it picks up the executable path. For an older installed bundle that still runs `pascal`, update the plugin; `npm install --global @pascal-app/cli@1.0.0` followed by **Customize → MCPs → pascal → Reload** repairs that legacy local command.

The hosted `pascal-hosted` server uses browser sign-in. In **Customize → MCPs**, choose **Authenticate** (or **Connect**) beside `pascal-hosted`. Pascal opens in your browser: sign in or create an account with Google or email, choose the intended workspace, review access, then return to Cursor. No API key or plugin variable is required. Let the user approve the account and workspace shown in consent. Ordinary access covers reading and editing projects; it does not authorize publishing, credit spending, external AI processing, community posting, or account management. Disconnect at `https://editor.pascal.app/settings/connected-apps`.

For local-only work, use `pascal` and leave `pascal-hosted` disconnected. Local project storage stays on this machine. If browser sign-in is unavailable, verify that the installed plugin and hosted service support this flow; do not create another account or fall back to a different workspace implicitly.

For Cursor without the plugin, add this to `.cursor/mcp.json` and start authentication in Cursor:

```json
{
  "mcpServers": {
    "pascal-hosted": {
      "type": "http",
      "url": "https://editor.pascal.app/api/mcp",
      "auth": {
        "CLIENT_ID": "pascal-cursor",
        "scopes": [
          "openid",
          "profile",
          "offline_access",
          "scene:read",
          "scene:write"
        ]
      }
    }
  }
}
```

Existing manually configured API-key connections remain supported. Do not combine an Authorization header with this OAuth configuration.

## Autonomous private work

Pascal exposes `POST https://editor.pascal.app/api/auth/agent/register` with:

```json
{
  "name": "required display name",
  "purpose": "optional task purpose",
  "agentClient": "claude-code"
}
```

Use it only after the current task authorizes creating a separate private agent-owned account. Capture the returned API key without printing it, store it with user-only permissions or in the host's secret store, and discard any temporary response containing the key. Never repeat the key in the final answer.

The response includes `userId`, `apiKey`, `starterProjectId`, `mcpEndpoint`, and `sceneApiUrl`. Preserve the canonical `agentId` when returned. It does not provide an agent email or browser session. The resulting projects belong to the separate agent account and will not appear in another user's workspace unless a later, explicit collaboration or handoff flow grants access.

## Connection recovery

- `401 Unauthorized` in Cursor: authenticate again and confirm the intended workspace. With API-key clients, verify the endpoint, the `Bearer` prefix, and whether the client sent the environment-backed secret. Rotate or revoke exposed keys.
- Project missing in the browser: verify that the credential belongs to the same user or organization that is opening the URL.
- Expired MCP session: reconnect, then call `get_project_status` with the project ID to bind the new session.
- Empty or stale browser: load the intended scene, inspect its state, call `get_project_status`, and use the returned URL. Save a draft only when the user authorized the underlying edit; a read-only assessment needs no save.
- Missing sampling support: image-to-scene tools cannot use host vision. Use semantic construction from user-supplied measurements or report the missing capability.

Current hosted instructions: `https://editor.pascal.app/docs/developers/mcp`.

# Pascal MCP tool workflows

Source reviewed on 2026-09-08 against repository code whose package version field is `@pascal-app/mcp` 1.0.0-beta.6. This is not a claim that the package was published or natively host-tested. Installed and hosted releases may expose a different schema, so inspect the advertised tools first.

Inspect the server's advertised tools because hosted and local releases may differ. Never call a guessed tool.

## Inspect an existing project

1. `list_scenes`
2. `load_scene`
3. `get_project_status`
4. `list_levels`
5. `get_level_summary`, `get_walls`, `get_zones`, `find_nodes`, or `get_node`
6. `validate_scene`
7. `verify_scene`

`get_scene` returns the full graph and is useful when a compact summary omits a field needed for a calculation, such as an item's scale.

## Open a room scan (hosted only)

These three tools exist only on the hosted Pascal server. A local CLI connection does not advertise them, so inspect the advertised tools before assuming this path is available.

1. `list_captures`, optionally narrowed by `projectId`, `status`, or `limit`.
2. `get_capture` with the `captureId`, adding `includeScanMetrics` when the answer needs scan quality numbers.
3. `open_capture_as_project` once the capture reports `processed`, to bind the owning project's persisted draft into the session.
4. Continue with the project workflows above.

All three require edit access on the scan's own project; view access, including a public project owned by someone else, is refused as not found. The first two are read-only. `open_capture_as_project` creates nothing and is idempotent, but it carries the same non-read-only annotation as `get_project_status` because it changes the project the session is bound to.

## Create an editable project

1. `create_project`
2. `create_house_from_brief` for a supported quick start, or semantic construction tools for precise control
3. Add openings and furniture with semantic tools
4. `validate_scene`
5. `verify_scene`
6. `save_scene` with `saveMode: "draft"`
7. `get_project_status`

Use `checkpoint` only at a meaningful milestone. A browser-visible draft and a durable checkpoint are distinct states.

## Make a bounded edit

1. Read the target and its surrounding level.
2. Record the pre-edit project version or graph hash when available.
3. Apply one semantic edit. Use `apply_patch` only when necessary; its batch is atomic and forms one undo step.
4. Re-read the target and validate the scene.
5. Save and report the changed IDs.

If a live-sync version conflict occurs, call `load_scene`, inspect the newer graph, and rebase the requested edit. Do not retry an old whole-scene write blindly.

## Read-only spatial answer

Do not mutate just to make a report unless the user authorizes a temporary or saved layout change. Use scene queries, `measure`, `check_collisions`, and `verify_scene`. Name the exact check and units. A plan-footprint check is not a detailed 3D, structural, regulatory, or delivery-path analysis.

## Outputs and limitations

- `export_json` returns the editable scene graph.
- `export_glb` in the open-source headless server currently reports `status: "not_implemented"`; protocol success is not artifact success.
- `photo_to_scene` needs host sampling. Without it, expect `sampling_unavailable`.
- `place_item` uses catalog dimensions. If a catalog item is unavailable, its placeholder dimensions are not evidence for a real product.
- `check_collisions` checks rotation-aware scaled item footprints using plan AABBs. Pass `minimumClearance` explicitly: zero reports overlap; a positive measurement also reports pairs closer than that gap. Inspect `status`, `checkedItems`, `skippedItems`, and `unsupportedChecks` before drawing a conclusion.
- `verify_scene` adds practical issues, including item separation and rectangular door-access keep-outs. It does not model a door-leaf swing arc or a delivery route.
- No tool starts a room scan or clones a scan into a new project. Scans are created only by the Pascal iOS app, and `open_capture_as_project` opens the scan's existing owning project.

When a requested deliverable is unsupported, return `partial` or `failed` with the tool status and the next supported action. Do not substitute an invented file, URL, or capability.