feat(template): thin app template to UIManager built-ins + AI quickstart + beta-only gate

Re-sync the `app` scaffold to the current thin bim-viewer: the side panels
(tree, properties, files/models-list, data-table, objects, settings) and the
viewer toolbar are now platform built-ins composed via `<top-*>` web
components, so the scaffold drops their in-repo setups (−8.3k lines). Loaders
stay app-side (the .3tz reality-capture loader is registered into
<top-models-list>).

- main.ts: compose built-ins; strip the dev-only :4100 local-bundle block.
- create: require --beta for every template; scaffolding without it errors
  "Non-beta projects are not available yet" (public engine lands in October).
- docs: add docs/ai-quickstart.md — a single URL that lets an AI go from
  nothing to a running app using only a platform token (no npm token); link it
  from the README; update create.md for the beta-only requirement.

Validated end-to-end: `create --beta` → `vite build` (87 modules, clean).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: agviegas

README.md

@@ -2,6 +2,9 @@
 
 Client library and CLI for building BIM apps and cloud components on [That Open Platform](https://platform.thatopen.com). Apps run inside the platform's browser environment; cloud components run server-side and can be triggered from any app.
 
+> **Using an AI assistant?** Point it at this single file and it can take you from nothing to a running app:
+> → [`docs/ai-quickstart.md`](https://raw.githubusercontent.com/ThatOpen/engine_services/main/docs/ai-quickstart.md)
+
 ## Quick Start
 
 ### 1. Install the CLI

docs/ai-quickstart.md

@@ -0,0 +1,86 @@
+# That Open Platform — AI Quick Start (zero to a running app)
+
+You are an AI assistant. A user pointed you at this URL so you can scaffold and run a
+**BIM app** on the [That Open Platform](https://platform.thatopen.com) from scratch, using
+`@thatopen/services` (the `thatopen` CLI + client library). Follow the steps below in order.
+
+> The only secret you need is a **platform API token** — **not** an npm token. The CLI
+> derives private beta-registry access from the platform token automatically.
+
+---
+
+## 0. Prerequisites (check, don't assume)
+
+- **Node.js ≥ 18** and **npm** — verify with `node -v`.
+- A **That Open Platform API token**. The user creates it themselves:
+  → **https://platform.thatopen.com/dashboard/data → API Tokens → create → copy.**
+  Ask the user to paste it. **Never print it back, never write it into a file, never commit it.**
+
+## 1. Install the CLI
+
+```bash
+npm install -g @thatopen/services@latest
+```
+
+## 2. Log in (do this BEFORE creating the project)
+
+```bash
+thatopen login --token <platform-token>
+```
+
+This validates the token and stores it in `~/.thatopen/config.json`. Login **must** come
+first: the next step's install pulls the private `@thatopen-platform/*-beta` packages, and
+`create` uses your logged-in token to write an authenticated `.npmrc` so that install can
+resolve them. No npm account or manual npm token is involved.
+
+## 3. Scaffold a beta app
+
+```bash
+thatopen create my-app --beta
+cd my-app
+```
+
+`--beta` is required for now: the bundled viewer uses engine APIs that currently live only
+in the beta libraries (public engine support lands with the October release). `create`
+configures private beta access from your platform token and runs `npm install` for you.
+
+## 4. Run it
+
+```bash
+npm run dev
+```
+
+This serves the app and opens it inside the platform. **You now have a complete, working
+viewer** — model loading, spatial tree, properties, measurement, sectioning, and more.
+
+## 5. Then build — read the in-project agent guide
+
+The scaffold is a real app, not a blank page. **Before changing anything**, open and follow:
+
+```
+node_modules/@thatopen/services/resources/AGENTS.md
+```
+
+(The scaffolded project's own `AGENTS.md` points here too.) It is the canonical guide: it
+indexes every platform built-in, the client API, the CLI, and the engine / UI example sets.
+Load those indexes before writing code. **All UI must be built with Lit + `@thatopen/ui`
+(`BUI`)** — consult the design system before writing any UI. Run the app first, then extend
+it; don't rebuild a viewer from scratch.
+
+## 6. Publish (when ready)
+
+```bash
+npm run publish
+```
+
+Builds the app, zips it (`dist/bundle.zip`), and uploads a new version to the platform.
+
+---
+
+## Rules for you, the assistant
+
+- **Platform token only.** Never introduce, request, or store an npm token.
+- **Never echo or persist the user's token.** It belongs only in `~/.thatopen/config.json` /
+  `.npmrc`, both of which the CLI manages and git-ignores.
+- **Propose a short plan and get the user's OK** before changing files.
+- The scaffold already works — **extend it, don't replace it.**

docs/cli/create.md

@@ -17,12 +17,13 @@ thatopen create .             # scaffold into the current directory
 - `--template <template>`, `-t` — Template to use. Default: `app`.
   - `app` — Browser BIM app running inside the platform iframe.
   - `cloud-component` — Server-side component executed by the platform's cloud engine and consumed in apps and/or automations.
-- `--beta` — Use private beta engine libraries (`@thatopen-platform/*-beta`) instead of the public ones. Sets `beta: true` in `.thatopen` so `serve`, `local-server`, and `vite build` all resolve to beta packages automatically. Requires beta npm access configured.
+- `--beta` — Use private beta engine libraries (`@thatopen-platform/*-beta`) instead of the public ones. Sets `beta: true` in `.thatopen` so `serve`, `local-server`, and `vite build` all resolve to beta packages automatically. Requires beta npm access configured (handled automatically once you `thatopen login`).
+
+> **`--beta` is currently required.** The templates depend on engine APIs that only exist in the beta libraries, so scaffolding without `--beta` errors out for now. Public (non-beta) support is coming with the October release.
 
 **Examples:**
 ```bash
-thatopen create my-app
-thatopen create my-app -t cloud-component
 thatopen create my-app --beta
+thatopen create my-app -t cloud-component --beta
 thatopen create . --beta
 ```

package.json

@@ -15,7 +15,7 @@
     "access": "public"
   },
   "private": false,
-  "version": "0.3.1",
+  "version": "0.3.2",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "types": "dist/index.d.ts",

src/cli/commands/create.ts

@@ -34,15 +34,16 @@ export const createCommand = new Command('create')
       process.exit(1);
     }
 
-    // The app template (the full BIM viewer) currently depends on engine APIs
-    // that only exist in the beta libraries. Until the public engine catches up
-    // (October release), scaffolding the app without --beta would produce a
-    // project that doesn't type-check or run — so require --beta explicitly.
-    if (template === 'app' && !opts.beta) {
+    // The templates currently depend on engine APIs that only exist in the beta
+    // libraries. Until the public engine catches up (October release),
+    // scaffolding without --beta would produce a project that doesn't type-check
+    // or run — so require --beta explicitly for every template.
+    if (!opts.beta) {
       console.error(
-        'The "app" template currently requires the beta engine libraries.\n\n' +
+        'Non-beta projects are not available yet.\n\n' +
         `  thatopen create ${projectName} --beta\n\n` +
-        'Public (non-beta) engine support is coming with the October release.',
+        'The templates currently require the beta engine libraries. Public ' +
+        '(non-beta) engine support is coming with the October release.',
       );
       process.exit(1);
     }