# Seefood development and Muse integration

Seefood provides a versioned method. Muse performs restaurant research, uses its existing user context and creates the interactive menu using its own tools. Website publication, remote MCP connectivity, Muse installation and connector-directory approval are different outcomes.

## Public reading contract

An agent can read the homepage's For agents link or `/llms.txt` without running the 3D scene. Read these root-relative resources:

- `/agents/seefood.md`: canonical instructions, version 0.2.0.
- `/workflow.json`: modes, source policy, stages, mapping rules and acceptance criteria.
- `/prompts/manifest.json`: the four stage prompt URLs.
- `/menu.schema.json`: checkpoint schema; version 0.2.0 with legacy 0.1.0 accepted.
- `/.well-known/seefood.json`: entry points and actual connection status.

The four stages establish the primary menu inventory, attach evidence, personalize, and render/enrich a Muse artifact. All readable original menu entries retain names, sections, IDs and order. Delivery evidence is supplemental. Photos, reviews, historical claims, beverage availability and weather carry sources/uncertainty. User profiles stay in Muse; static instructions need no account or profile upload.

The setup page copies a short start prompt with the current site origin. It starts the method in the conversation; it does not establish a permanent skill, verified connector or automatic triggers. If the user wants reuse, Muse must use its actual supported skill/preference facilities and report what was saved.

## Local website

From the repository root:

```sh
python3 scripts/build-public.py
python3 -m http.server 8766 --bind 127.0.0.1 --directory sites/seefood/dist
```

Open `http://127.0.0.1:8766/`. The main experience is real WebGL, backed by locally vendored Three.js 0.180.0. It includes layer controls, pause, reduced motion, a static illustrated fallback and viewport-bounded animation. The model is always labeled an abstract illustration. The Piatti photo/menu sample is historical research, not today's menu or a freshly verified recommendation. Story/pairing demo content is explicitly illustrative. Source photos may fail; source links and dish names remain visible.

`build-public.py` copies only public assets and selected instructions into `sites/seefood/dist`, creates the discovery route, and removes personal context from the exported sample JSON. Raw research, credentials, Python environment and source checkout metadata are not website assets. The founder essay and historical menu prototype retain their independent reading styles.

## Optional local MCP adapter

Official MCP Python SDK v1, Python 3.10+:

```sh
uv run agents/server.py
```

Generic local MCP client configuration (substitute the actual checkout path):

```json
{"mcpServers":{"seefood":{"command":"uv","args":["--directory","/absolute/path/to/seefood.bot","run","agents/server.py"]}}}
```

For local Streamable HTTP:

```sh
uv run agents/server.py --transport streamable-http
```

Endpoint: `http://127.0.0.1:8767/mcp`, bound to loopback. This is not a public endpoint that Muse's cloud can access. The static website deployment does not run this Python process.

Tools and resources:

- `get_workflow`: returns canonical instructions, all four full stage prompts, selected mode/sources and output schema. Missing sources use public defaults; an explicit empty list means official menu only. Exclusions and actual host permissions still apply. Personal context is optional; no server persistence.
- `validate_menu`: schema and referential/order checks. Checks one-to-one IDs, original names, sections, source order and valid recommendation references. Does not verify restaurant facts, allergen safety, actual completeness or image display.
- `explore_menu`: prompt entry using the agent's actual tools.
- `seefood://workflow`, `seefood://menu-schema`, `seefood://instructions`: read-only resources.

## Muse official documentation review — October 10, 2026

[Meta's technical explanation](https://research.meta.ai/blog/security-and-safety-for-ai-agents-our-approach-with-muse) describes Muse's cloud computer, browser, SKILL instructions and custom connectors for APIs/CLIs. This supports a workflow-first product, but does not prove this Seefood adapter was installed.

[Muse Connector Platform guidelines](https://muse.ai/platform/docs) accept API or MCP documentation in submissions and require demonstrable value beyond ordinary browsing. A links-only wrapper is insufficient. Seefood's proposed differentiator is repeatable evidence matching, primary-menu preservation and relevant recommendations. Directory approval requires a separate submission/review, not just a readable site. Public documentation does not settle the exact custom connector transport/authentication for this project; actual Muse testing remains necessary.

Historical browser observations stay in `docs/muse-research-learnings.md`. They must not be relabeled as freshly verified platform behavior. No runtime test here establishes automatic restaurant triggers or persistent Muse skill installation.

## Verification

```sh
uv run python tests/mcp_smoke.py
node --check web/app.js
node --check web/guide.js
node --check web/scene.js
```

The MCP test uses a real stdio session: discovery, sources, stage prompts, legacy/current checkpoints, reordered/missing/renamed dishes, duplicate IDs, unknown recommendation references, invalid timestamps and unsupported pairing/weather claims.

For browser checks install Playwright outside the website source, point `SEEFOOD_PLAYWRIGHT_PATH` to its module path, and run `node tests/browser-smoke.cjs` against the local server. `SEEFOOD_CHROME_PATH` overrides the browser executable. Checks cover 1440/390 layouts, actual WebGL, layer and dish/detail controls, copy prompt, resource links, reduced motion and WebGL fallback. The public site package itself has no Playwright dependency.

## Hosting

Sites identity is in `sites/seefood/.openai/hosting.json`; source/publishing use the Sites source helper. Use the exact returned project ID and pushed source SHA. A public reading website requires anonymous access; a private preview is not readable by arbitrary agents.

Requested custom domain: `seefood.bot`, DNS hosted at GoDaddy. Site-side domain registration provides the DNS records to configure. Do not claim that the custom domain is active until DNS/certificate/routing are verified. No account login or DNS credentials are collected by Seefood.

## Anonymous HTTP API — local implementation

`uv run python api/server.py` serves workflow and menu validation at localhost:8768 without a key or OAuth. `GET /openapi.json` supplies the contract with explicit `security: []`. See [API deployment and Muse test instructions](../api/README.md). Verify with `uv run python tests/http_api_smoke.py`. Public HTTPS deployment and anonymous Muse custom-connector installation remain unverified; the existing static Sites deployment does not run this API.
