**Note** from Bead: Taos Tooling · [canonical source](https://redfish.acequia.io/guerin/.agents/221f3fe2-f3ef-43e3-994d-c67f69d3da47/2026-06-10/notes/taos-skills-and-mcp-plan.md) · session 2026-06-10 · discussion: Talk: Taos Tooling
**Date:** 2026-06-10 · **Bead:** `221f3fe2-f3ef-43e3-994d-c67f69d3da47` (`taos-tooling`) · **Status:** plan / no code written yet **Source bead:** [`#taos-engine`](https://redfish.acequia.io/guerin/.agents/c66cbd1d-453c-41f8-8440-179502f25de4/about.md) (the MISB-port workshop; all API findings below come from there) **Mission parent:** [`#main-context`](https://redfish.acequia.io/guerin/.agents/c38c1239-bfd3-44dd-8d97-1a0aa39ac8da/about.md) (catalog + cataloging; TaosEngine is its test bed) > **Ask (Stephen, 2026-06-10):** "make a plan to make skills and mcp for taos-engine. info and skills in peer bead `#taos-engine`." This bead is the **tooling sibling** of `#taos-engine`: it does not port the MISB viewer — it builds the reusable substrate (skills + an MCP) that the port, and every later TaosEngine thread, runs on.
## 0. Why two deliverables, and how they relate Per [substrate-spine](https://redfish.acequia.io/skills/substrate-spine.md): **a skill is a catalyst** — read, not consumed; it lowers the activation barrier for a transformation an agent couldn't otherwise cross. The skills and the MCP are the **two faces of one capability surface**: | | **Skills** | **MCP** | |---|---|---| | Sigil | `#` — afferent read-edge | live affordance (machine `Modus Operandi`) | | Form | `SKILL.md` docs an agent/human **reads** | tools an agent **calls** | | Audience | any body (CB/CE/CV), any model | a tool-using agent at runtime | | Failure if absent | re-reverse-engineer the API every session | can't drive a live engine, can't connect layers | The MCP is the **machine form of the skills' Modus Operandi**: the same knowledge, exposed as callable verbs. Build the skills first (they're the spec the MCP implements), then the MCP.
## 1. Ground truth — the real source dissolves the old risk `#taos-engine`'s build plan was reverse-engineered from **minified dist bundles** (its Q6: brittle to bundle re-hashing). That risk is **gone**: Stephen cloned the full private repo to `c:/Users/steph/Documents/src/taos-engine` (2717 files). Every skill and MCP tool below is authored against **real source**, not guesses: - `docs/api-guide.md` — three API layers (Engine+preset / Engine+features / manual render graph), "Hello, Cube" verified end-to-end. - `docs/modules/{core,geo,terrain,physics,audio,sdf}.md` — per-subsystem guides. - generated **typedoc API ref** under `docs/site/api/` (`npm run build-api-ref`). - `book/chapters/` — theory (rendering architecture, game-engine design). - 67 runnable `samples/*.ts` (incl. `projector_test`, `geo_photo`, `geo_osm_buildings`, and our own `misb_step0`). - real TS: `src/geo/` (`geo_scene.ts`, `raster_dem.ts`, `cesium_ion.ts`, `google_tiles.ts`, `anchor.ts`), `src/renderer/features/projector_feature.ts`, `src/engine/`. - a `server/` (authoritative multiplayer **WebSocket** server) and an `editor/` subproject — **existing transports we can reuse for MCP-B.** Conventions to honor in any code we add (`CLAUDE.md` in the repo): `.js` import extension on TS files, `snake_case.ts` filenames, `strict` + `noUnusedLocals/Params`, US English, WGSL in `src/shaders/`. Run = `npm run dev` (Vite, :5173).
## 2. Part A — the Skills Five skills, each a `SKILL.md` (substrate format: ORIENTATION line → numbered sections → cold-start summary, like [webdav-context](https://redfish.acequia.io/skills/webdav-context/SKILL.md) / [beads](https://redfish.acequia.io/skills/beads/SKILL.md)). They map 1:1 onto the build-plan's component table, so the MISB port consumes them as catalysts. | # | Skill | Scope (what it makes runnable) | Source in clone | |---|---|---|---| | A1 | **`taos-engine-bootstrap`** | Cold-start orientation: the three API layers, `Engine.create({preset})`, `renderPreset({sky,ao,lighting,projectors,…})(app)`, the engine-owned frame loop (`beforeFrame`/`run`), repo conventions, how to add + run a sample, headless caveat. The entry skill. | `docs/api-guide.md`, `CLAUDE.md`, `src/engine/engine.ts` | | A2 | **`taos-geo-scene`** | Geodetic substrate: `new GeoScene(device, frame.atLonLat(lon,lat,elev))` (**lon,lat order**), `addRasterDemTerrain({imagery})`, `add3DTiles` (Cesium Ion / Google photoreal), `addVectorTiles` (OSM), `heightAt` (**RADIANS**), frame ECEF helpers (`atLonLat`/`worldFromEcefPoint`/`worldFromEcefDir`/`ecefFromWorldPoint`/`rebase`). Replaces all hand-rolled ECEF math. | `src/geo/geo_scene.ts`, `raster_dem.ts`, `cesium_ion.ts`, `anchor.ts`; samples `geo_osm_buildings`, `geo_photo` | | A3 | **`taos-projector`** | The Projector = FMV / slide-projector / decal primitive: `new Projector()` + `setPosition` + `rotation=lookRotation(dir)`, `shape`, `focalLength`(mm)/`fovY`/`aspect`, `crop`, `blend`, `opacity`, `edgeFalloff`, **live video** `source:{kind:'video',video,backend:'copy'}`, the ~6-line ported `lookRotation`, and the **MISB intrinsics mapping** (`focalLength=null`, `fovY=VFOV`, `aspect=tan(HFOV/2)/tan(VFOV/2)`). The central finding of `#taos-engine`. | `src/renderer/features/projector_feature.ts`; sample `projector_test`; note `projector-intrinsics-and-misb-fov.md` | | A4 | **`taos-camera-control`** | Camera + controls: `createPerspective(fov,near,far,aspect)` with mutable `.fov/.near/.far`, `FlyControls.create({yaw,pitch,speed,sensitivity})` + bind helper, per-frame imperative pose, the **follow-camera** pattern (gate `fly.update`, drive pose from telemetry), and **ground-pick** (`inverseViewProjectionMatrix` ray → bisect against `heightAt`). | samples `geo_photo`, `geo_osm_buildings`; `src/engine/components/` | | A5 | **`taos-verify-webgpu`** | Verification methodology: `tsc --noEmit` + Vite-serve check are necessary but **not** a render; headless Chrome has **no WebGPU adapter** → verify live features via **CDP**, not `--screenshot` (WASM/WebGPU + workers can't be driven by virtual time — same caveat as the DuckDB-pipeline skill). The `misb_step0` headless capture is the worked example of "page runs cleanly, GPU just absent." | `#taos-engine` step-0 artifacts | **Where they live.** Draft each in this bead's `skills/` first (workshop). On Stephen's sign-off, the ones that are genuinely substrate-tier (A1–A4) get **promoted to `redfish.acequia.io/skills/`** alongside `webdav-context`/`beads` — that promotion is Stephen's to make (don't self-publish to the shared commons). A5 may stay a bead skill or fold into an existing verification note. **Autocatalytic check (substrate-spine §7):** A1 bootstraps; A2 gives the world; A3 the layer-primitive; A4 the viewpoint; A5 closes the loop by verifying. Together they're a RAF set for "build a posed geo-media scene in TaosEngine" — each catalyzes the next, all buildable from the demand (the MISB port / the Sandy fire).
## 3. Part B — the MCP Two phases. **MCP-A is the de-risking, independently-valuable first cut; MCP-B is the real target** (the live "cataloging" interface the parent mission needs). ### Phase B1 — `taos-api` MCP (source/knowledge server) A read-only MCP over the **clone**, so any agent gets the authoritative API on demand instead of reverse-engineering minified dist. This **permanently closes `#taos-engine` Q6.** Tools: - `taos_search(query)` — ripgrep over `src/`, `samples/`, `docs/`; returns `file:line` hits. - `taos_symbol(name)` — pull the typedoc entry + source definition for a class/function (e.g. `Projector`, `GeoScene`, `FlyControls`). - `taos_sample(name)` — return a sample's full `.ts` (e.g. `projector_test`) as a worked reference. - `taos_module_guide(module)` — return `docs/modules/<module>.md`. - `taos_api_ref(symbol?)` — serve the generated typedoc (`docs/site/api/`). Transport: **stdio MCP server** (Node, in this bead's `artifacts/` or a small package), pointed at `TAOS_SRC=c:/Users/steph/Documents/src/taos-engine`. Cheap, no browser, no WebGPU. This is essentially a code-search MCP scoped to TaosEngine — buildable today. ### Phase B2 — `taos-scene` MCP (the cataloging interface) This is where the MCP becomes [**cataloging as a verb**](https://redfish.acequia.io/guerin/.agents/c38c1239-bfd3-44dd-8d97-1a0aa39ac8da/2026-06-08/notes/cataloging-as-a-verb.md): an agent **connects to layers** (FMV, fire-progression rasters, perimeters, posed photos) and **composes / sequences / subscribes** them in a live TaosEngine scene over one space+time frame — proved on the **Sandy fire**. Tool surface (verbs over a running engine instance): - `scene_create({lon,lat,elev, basemap})` → anchored `GeoScene` + terrain (raster-DEM or photoreal 3D-tiles). - `add_projector({pose, intrinsics, source})` → a Projector layer (image or `{kind:'video',…}`) — wraps skill A3. - `add_layer({type, uri})` → connect a typed **catalog** entry (the parent bead's [event-catalog format](https://redfish.acequia.io/guerin/.agents/c38c1239-bfd3-44dd-8d97-1a0aa39ac8da/2026-06-08/notes/event-catalog-format-design.md)) — FMV, raster, perimeter, photo-quad. - `set_camera({pose|follow})` → free-fly or follow a layer (skill A4). - `set_time(utc)` / `play()` / `pause()` → drive the master UTC clock (the "sequence/subscribe" half of cataloging). - `capture()` → frame grab for verification / hand-back. **Architecture — this is the real design decision.** TaosEngine is WebGPU-first; the MCP can't render in a bare Node process. Options: 1. **CDP bridge (recommended first):** MCP server drives a real Chrome (WebGPU on) running a TaosEngine harness page via the Chrome DevTools Protocol; tools translate to `Runtime.evaluate` calls against a small JS API on the page. Reuses skill A5's CDP discipline. Lowest new infra. 2. **Reuse the repo's `server/` (WebSocket):** the clone already ships an authoritative WS server + `shared/net_protocol.ts`. Model scene state as messages; an MCP server is a second WS client. Heavier, but aligns with the engine's own multiplayer state model. 3. **WebDAV-native (most on-ecology):** the scene is a **catalog document** at a bead URI; the MCP `PUT`s layer entries and the browser harness `observe`s the path and renders — i.e. the MCP doesn't talk to the engine at all, it edits the catalog and the engine subscribes (paths-as-event-bus). This is the purest expression of catalog+cataloging but the most to build. Recommendation: **prototype B2 over CDP (option 1)** to prove the verbs, then migrate state to **option 3 (WebDAV catalog)** once the layer schema is stable — option 3 is the ecology's end state, option 1 is the fastest path to a moving Sandy-fire demo.
## 4. Sequencing ``` A1 bootstrap ─┐ A2 geo-scene ─┼─► (skills land the spec) ─► B1 taos-api MCP (kills Q6, cheap) A3 projector ─┤ │ A4 camera ────┘ ▼ A5 verify ───────────────────────────► B2 taos-scene MCP (CDP first → WebDAV catalog) │ ▼ Sandy-fire proof (parent mission) ``` - **Skills A1–A5** are the immediate, low-risk deliverable — they exist to be written from real source now, and they de-risk everything downstream. - **B1** can be built in parallel with the skills (it serves the same source the skills cite). - **B2** depends on the skills (it implements them as verbs) and on a layer-schema decision from `#main-context`.
## 5. Decisions needed from Stephen (don't proceed past these without a call) 1. **Bead vs. promote:** draft all skills in this bead's `skills/`, or some directly toward `redfish.acequia.io/skills/`? (Default: draft here, you promote.) 2. **Skill granularity:** five skills as scoped above, or fold A4/A5 into fewer? (Five is the current recommendation.) 3. **MCP scope now:** build **B1 only** (source MCP, safe, today), or greenlight **B2** (live scene control) and pick a transport (CDP / WS / WebDAV-catalog)? 4. **B2 layer schema:** does the `taos-scene` MCP consume the `#main-context` event-catalog format directly, or define its own and reconcile later?
## 6. Connections - Source/info: [`#taos-engine`](https://redfish.acequia.io/guerin/.agents/c66cbd1d-453c-41f8-8440-179502f25de4/about.md) — build plan, projector intrinsics, step-0. - Mission: [`#main-context`](https://redfish.acequia.io/guerin/.agents/c38c1239-bfd3-44dd-8d97-1a0aa39ac8da/about.md) — [catalog format](https://redfish.acequia.io/guerin/.agents/c38c1239-bfd3-44dd-8d97-1a0aa39ac8da/2026-06-08/notes/event-catalog-format-design.md) · [cataloging-as-a-verb](https://redfish.acequia.io/guerin/.agents/c38c1239-bfd3-44dd-8d97-1a0aa39ac8da/2026-06-08/notes/cataloging-as-a-verb.md). - Skill format + theory: [substrate-spine](https://redfish.acequia.io/skills/substrate-spine.md) · [webdav-context](https://redfish.acequia.io/skills/webdav-context/SKILL.md) · [beads](https://redfish.acequia.io/skills/beads/SKILL.md). - Real source (outside the bead, by path): `c:/Users/steph/Documents/src/taos-engine`.
## References (bead cross-links) - Bead: Taos Engine · [canonical](https://redfish.acequia.io/guerin/.agents/c66cbd1d-453c-41f8-8440-179502f25de4/) - Bead: Incident Cataloging · [canonical](https://redfish.acequia.io/guerin/.agents/c38c1239-bfd3-44dd-8d97-1a0aa39ac8da/)