@wix/agent-skills 1.15.1 → 1.16.1

package/skills/wix-vibe-headless/platforms/base44.md

@@ -1,142 +1,152 @@
 # Wix Managed Headless — Base44 build instructions
 
-You are building a **Wix Managed** headless site inside Base44. The business to build is
-described in your initial prompt. The Wix connector is already configured for this app — use
-it for all Wix API calls.
+You are building a **Wix Managed** headless site inside Base44 — the business is described in your
+initial prompt, and the Wix connector is already configured; use it for all admin API calls.
 
-Your Wix client id is given in your prompt. It's a public, buyer/visitor-facing credential (it
-only mints anonymous visitor tokens), so it's safe in the frontend — use that value directly for
-the Wix client setup.
+Your Wix client id is in your prompt — a public, buyer-facing credential (anonymous visitor tokens
+only), safe in the frontend; use it directly for the Wix client setup.
 
-Follow the steps below exactly.
+> **`wix-vibe-headless` and `wix-docs` are the complete build and seed path for this app — the Wix connector supplies the token for admin API calls.** **Do NOT use the Base44 commerce kit (or any Base44 solution kit).**
 
-## STEP 0 — Install the Wix skills locally
+Follow STEPs 1–5 below exactly (run STEP 4 in parallel with STEP 3).
 
-Install three skills — they land under `.agents/skills/` as:
-- **`wix-vibe-headless`** — the client build guide: how to build the frontend against the Wix
-  APIs. This is your main source of truth (STEP 1).
-- **`wix-headless`** — a broad skill for building full Wix apps with the Wix SDK packages, **most
-  of which does not apply to how you build here**. Use it **only** as a seeding/admin recipe
-  reference — its `references/SEED.md` and `references/inline-recipes/`, for STEP 2. **Ignore
-  everything else in it** — in particular do **not** follow its authentication / `@wix/cli` /
-  "managed project" setup (e.g. anything under `references/managed/`, such as `AUTHENTICATION.md`).
-  That is **not** how auth works here — auth is handled per STEP 2 below.
-- **`wix-docs`** — a **fallback**: how to search and read the Wix API reference docs, for anything
-  the seeding recipes above don't cover.
+## STEP 1 — Install the Wix skills locally
 
-**Option A — skills CLI.** This is the Base44-verified install path — run it first via
-exec_tool, exactly as written:
+Install two skills — they land under `.agents/skills/`:
+- **`wix-vibe-headless`** — the client build **and** seed guide (STEPs 3–4): your main source of
+  truth. Seeding lives here too, per-vertical under `references/<vertical>/seed/`.
+- **`wix-docs`** — a **fallback**: search + read the Wix API docs for anything `wix-vibe-headless`
+  doesn't cover.
+
+Run this through exec_tool, exactly as written — installs both skills, deploys REST scaffolds + UI into `src/`, writes `wix-config.js`, and pins the AGENTS.md note.
+
+**Set `VERTICALS`** to what the prompt asks for (too vague to tell? do STEP 2 first, then set it):
+
+| vertical | pick it when the app needs to |
+|---|---|
+| `storefront` | sell products |
+| `bookings` | take appointments or service bookings |
+| `blog` | publish articles |
+| `events` | publish events with RSVPs or ticket sales |
+| `portfolio` | showcase creative work |
+| `pricing-plans` | sell memberships or subscriptions |
+| `restaurants` | show a menu, take orders, book tables |
+| `members` | let visitors sign in — this is **auth** |
+| `cms` | keep its own structured content — user submissions, galleries, listings, anything the rows above don't already cover |
+
+**List every vertical the app uses.** `cms` for app-stored content, `members` for visitor sign-in — these often join the main vertical. Adding one later: re-run with the extra name.
 
 ```js
 const { execSync } = require('child_process');
-const { readdirSync } = require('fs');
-
-const skills = ['wix-headless', 'wix-vibe-headless', 'wix-docs'];
+const { existsSync, readdirSync } = require('fs');
+const VERTICALS = ['storefront'];        // ← set from the prompt; list every vertical the app uses
+// const VERTICALS = ['members', 'cms']; // ← e.g. visitors sign in AND the app stores what they submit
+// COPY these two straight from the prompt — deploy writes them into src/rest/wix-config.js, so never
+// retype either one into a file by hand afterwards.
+const WIX_CLIENT_ID = '<client id from the prompt>';
+const WIX_METASITE_ID = '<site id from the prompt>';
 const results = {};
-
-for (const skill of skills) {
+for (const skill of ['wix-vibe-headless', 'wix-docs']) {
+  if (existsSync(`/app/.agents/skills/${skill}/SKILL.md`)) { results[skill] = 'already_installed'; continue; }
   try {
-    const out = execSync(`CI=1 npx -y skills add wix/skills/skills/${skill} --yes 2>&1`, {
-      cwd: '/app', timeout: 60000, shell: '/bin/bash', stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    const text = out.toString().replace(/\x1b\[[0-9;]*m/g, '');
-    results[skill] = /installed 1 skill|found 1 skill/i.test(text)
-      ? 'success'
-      : text.includes('No valid skills') ? 'not_found' : 'unknown';
-  } catch (e) {
-    results[skill] = 'error: ' + e.message;
-  }
+    const out = execSync(`CI=1 npx -y skills add wix/skills/skills/${skill} --yes 2>&1`,
+      { cwd: '/app', timeout: 60000, shell: '/bin/bash' }).toString().replace(/\x1b\[[0-9;]*m/g, '');
+    results[skill] = /installed 1 skill|found 1 skill/i.test(out) ? 'success'
+      : out.includes('No valid skills') ? 'not_found' : 'unknown';
+  } catch (e) { results[skill] = 'error: ' + e.message; }
 }
-
-return { results, installed: readdirSync('/app/.agents/skills') };
+const deploy = execSync(`node /app/.agents/skills/wix-vibe-headless/install/deploy.cjs ${VERTICALS.join(' ')} --client-id ${WIX_CLIENT_ID} --metasite-id ${WIX_METASITE_ID}`, { cwd: '/app' }).toString();
+const agentsMd = execSync(`node /app/.agents/skills/wix-vibe-headless/install/pin-agents-md.cjs`, { cwd: '/app' }).toString();
+return { results, installed: readdirSync('/app/.agents/skills'), deploy: JSON.parse(deploy), agentsMd: JSON.parse(agentsMd) };
 ```
 
-**Option B — tarball.** Use this **only if Option A actually errored** (check its `results`) —
-do not skip Option A on a guess. Run via exec_tool:
+Read skills with **`read_file`** using workspace-relative paths (e.g. `.agents/skills/wix-vibe-headless/SKILL.md`) — absolute `/app/...` fails. Always read from `.agents/skills/` exactly on every turn; ignore stray copies like `agent/skills/`.
+
+## STEP 2 (optional) — Brief doesn't say what to build? Read the site
+
+Only when the business description is vague or missing (else skip to STEP 3). Don't guess the Wix
+Business Solution — **read the site in one call** via the connector (exec_tool):
 
 ```js
-const { execSync } = require('child_process');
-for (const s of ['headless', 'vibe-headless', 'docs']) {
-  execSync(`mkdir -p /app/.agents/skills/wix-${s} && curl -s "https://www.wix.com/skills/${s}.tgz" | tar xz -C /app/.agents/skills/wix-${s} --strip-components=1`);
-}
-return 'done';
+const { accessToken } = await base44.asServiceRole.connectors.getConnection("wix");
+const res = await fetch("https://www.wixapis.com/_api/dynamic-context/v1/dynamic-context/markdown", {
+  method: "POST",
+  headers: { Authorization: `Bearer ${accessToken}`, "Content-Type": "application/json" },
+  body: JSON.stringify({ siteId: "<metasite id from your prompt>" }),
+});
+return (await res.json()).markdown;
 ```
 
-Either way you end up with `.agents/skills/{wix-headless,wix-vibe-headless,wix-docs}`. **Read them
-with the `read_file` tool** — it caps by line (~5000, well above these docs, so each comes through
-whole; page with offset/limit only if ever needed), whereas `cat` through exec_tool caps output at
-~5000 chars and silently truncates, and web-fetch tools truncate/summarise. The path form depends
-on the tool:
-- **`read_file` (preferred):** rooted at `/app`, so use the workspace-relative path
-  `.agents/skills/wix-vibe-headless/SKILL.md` — an absolute `/app/...` double-prefixes and fails.
-- **exec_tool / shell** (only if you must): use the absolute path
-  `/app/.agents/skills/wix-vibe-headless/SKILL.md`.
+It returns a markdown report — installed apps (by name), status, URL, locale, CMS collections
+([docs](https://dev.wix.com/docs/api-reference/tools/dynamic-site-context/get-dynamic-context-markdown.md)).
+Build for the installed apps' solutions (several → prioritize by the user's words and which holds
+real, non-sample content); the same output drives STEP 4's seeding — never seed guessed ones. If it
+fails or shows nothing relevant, ask the user what they offer.
 
-## STEP 1 — Build the client
+## STEP 3 — Build the client
 
-Read `.agents/skills/wix-vibe-headless/SKILL.md` and follow it **EXACTLY** — it is the single
-source of truth for how the client app is built. To save time, prefer copying ready-made files
-the `wix-vibe-headless` skill provides (e.g. the Wix client setup) and adapting them over
-re-generating them from scratch.
+Read `.agents/skills/wix-vibe-headless/SKILL.md` and follow it **EXACTLY** — the single source of
+truth for how the client is built.
 
-## STEP 2 — Manage and seed the business
+**REST scaffolds + `wix-config.js` are already in `src/rest/`** (STEP 1 wrote them). Some verticals also ship a ready UI client in `src/` — theme + wire it per `INSTRUCTIONS.md`, don't rebuild. **Don't `read_file` deployed files** — every field shape is in `INSTRUCTIONS.md`; read one only on a real error or gap.
 
-Seed the site with real content by following the **`wix-headless` skill**'s
-`references/SEED.md` (`.agents/skills/wix-headless/references/SEED.md`). Where its seed recipes
-don't cover what you need, **fall back to the `wix-docs` skill** (`.agents/skills/wix-docs`) to
-search and read the relevant Wix API docs.
+**`src/App.jsx`: edit surgically, never rewrite.** It carries required platform auth scaffolding
+(`AuthProvider`/`useAuth` from `@/lib/AuthContext`); a full rewrite drops them → the validator
+rejects the write. Wire routes/imports in with `find_replace`, leave the rest as-is.
 
-**Seeding is additive.** You may clean up the app install's **obvious default sample/mock data**
-right after a fresh install, but the site may already hold **real content** (a prior run, or
-owner-added) — if what's there isn't obviously install sample data, or you're unsure, **do not
-delete or overwrite it without the user's explicit ask or approval** (ask first).
+## STEP 4 — Manage and seed the business
 
-**Auth for these admin calls is the already-configured Wix connector — and nothing else.** Get the
-access token from it and send it as a bearer token — do **not** hand-roll a token getter (e.g. a
-custom `getAdminToken()`):
+**Never delete or clean up anything on the user's site — seeding is additive only.** It's a live
+user-owned business, so never delete or overwrite existing content, even apparent sample data. If a
+cleanup truly seems needed, ask the user first.
+
+Seed by calling your vertical's ready-made seed module — read
+`.agents/skills/wix-vibe-headless/references/<vertical>/seed/SEED.md` and load its `seed-*.js` via
+its loader snippet (build-time exec_tool); call its functions with your data. Gaps or an unexpected
+shape → the **`wix-docs`** skill.
+
+**Auth for these admin calls is the already-configured Wix connector — nothing else.** Get its
+access token and send it as a bearer token; do **not** hand-roll a token getter (e.g.
+`getAdminToken()`), install/run the Wix CLI (`@wix/cli`), or device-login (no managed-project auth
+flow applies to Base44):
 
 ```js
 const { accessToken } = await base44.asServiceRole.connectors.getConnection("wix");
 // then: fetch(url, { headers: { Authorization: `Bearer ${accessToken}`, "Content-Type": "application/json" }, ... })
 ```
 
-Do **not** install or run the Wix CLI (`@wix/cli`), do a device-login, or follow `wix-headless`'s
-`references/managed/AUTHENTICATION.md` — that managed-project auth flow does not apply to Base44
-and will send you down the wrong path.
+Inline via exec_tool, `base44` is already declared — use it directly; do **not** import
+`@base44/sdk`, re-declare it, or call `createClient()` (that's for standalone `.js` files only;
+inline it throws *"Identifier 'base44' has already been declared."*).
 
-When you run seed/management code **inline via exec_tool**, `base44` is already declared — use
-it directly. Do **not** import `@base44/sdk`, re-declare `base44`, or call `createClient()` —
-that pattern is only for standalone `.js` skill files, and inline it throws *"Identifier
-'base44' has already been declared."*
+**Entity images.** For image-bearing entities (store products, blog covers, bookings services,
+restaurant items, portfolio projects, event heroes, CMS items), generate with **Base44's built-in
+image generation**, then attach via the vertical seed module's image-attach step — `wix-docs` if the
+module doesn't cover that entity.
 
-**IMPORTANT:** the Wix connector and the `wix-headless` skill's seeding instructions are for
-management/admin operations only (STEP 2) — they are **NOT** part of the client. The client is
-built solely per the `wix-vibe-headless` skill.
+**Seed images with the FINAL url, in one call.** Seeding writes to Wix, so use the real
+`https://media.base44.com/...` url from the **completed** `generate_image` result and pass it straight
+into your single `setupStore`/seed call (images included). A still-generating `/__generating__/<id>.png`
+placeholder is not a real url — Wix can't fetch it. `generate_image` runs in the background while you
+build the client, so the urls are ready by the time you seed.
 
-## Parallelism
+The connector + seeding are **admin-only** (STEP 4) — **not** part of the client, which is built
+solely per the `wix-vibe-headless` skill.
 
-If possible, run STEP 1 and STEP 2 in parallel — building the client and seeding the business
-are independent, so don't wait for one to start the other. Within each step, also work in
-parallel where possible (e.g. independent API calls, seeding multiple entities) instead of
-one-by-one, to finish faster.
-
-## STEP 3 — Wrap up
+## STEP 5 — Wrap up
 
 Once the site is built and seeded:
 
-1. **Leave a brief "Wix skills" note in `AGENTS.md`** (project root) so a future session has
-   context. If the file already exists, **`read_file` it first and only append your section** —
-   do **not** rewrite, reorder, or remove anything already there; if you can't append cleanly,
-   skip this rather than overwrite. Create the file only if none exists. Keep the note
-   high-level, e.g.: the Wix skills are installed under `.agents/skills/`; the client is built
-   per the `wix-vibe-headless` skill; seeding/management is done per the `wix-headless` +
-   `wix-docs` skills.
-2. **Ask the user to open** this URL to complete the setup in Wix (substitute the metasite id
-   you were given): `https://manage.wix.com/dashboard/{metaSiteId}`
+1. **Mount the preview-only manage banner** (required; links the app to its Wix back office; shipped,
+   self-gates to the preview, never on the published site): render the `<WixManageBanner/>` component
+   in your Layout's fixed top region, above the header, per your vertical's INSTRUCTIONS STEP 4.
+2. **Ask the user to open** `https://manage.wix.com/dashboard/{metaSiteId}` (substitute your
+   metasite id) to complete setup in Wix (required), and mention that the preview shows a dismissible
+   top banner linking to this same dashboard.
+
+**Preview briefly, don't chase images.** Broken images are expected — `generate_image` returns a `/__generating__/…` placeholder that the platform swaps for the final url automatically at turn end (failures get a stock fallback). **Do NOT edit, re-seed, or debug image urls.** Leave them and finish.
 
 ## Later admin requests
 
-For any later admin/management request the user makes, work the same way as STEP 2: check the
-`wix-headless` skill's inline recipes first (`.agents/skills/wix-headless/references/inline-recipes/`)
-and, where the operation isn't documented there, fall back to the `wix-docs` skill to search the
-Wix API docs — all over the Wix connector.
+For any later admin/management request, work as in STEP 4: your vertical's seed module first, else
+`wix-docs` — all over the connector.

package/skills/wix-vibe-headless/platforms/generic.md

@@ -1,87 +1,122 @@
-# Wix Managed Headless — build instructions
+# Wix Managed Headless — build instructions (any stack)
 
-You are building a **Wix Managed** headless site. The business to build, and your Wix client id
-and metasite id, are given in your initial prompt. Follow the steps below.
+You are building a **Wix Managed** headless site — the business, your `WIX_CLIENT_ID`, and metasite
+id are in your prompt. This skill is **client-only REST** over the public `WIX_CLIENT_ID`
+(visitor-facing, safe in the browser) — no `@wix/sdk`, no backend, no build step.
 
-## STEP 0 — Install the Wix skills locally
+## What you've got in the skill
 
-Install three skills — they land under `.agents/skills/` as:
-- **`wix-vibe-headless`** — the client build guide: how to build the frontend against the Wix
-  APIs. This is your main source of truth (STEP 1).
-- **`wix-headless`** — a broad skill for building full Wix apps with the Wix SDK packages, **most
-  of which does not apply to how you build here**. Use it **only** as a seeding/admin recipe
-  reference — its `references/SEED.md` and `references/inline-recipes/`, for STEP 2. **Ignore
-  everything else in it** — in particular do **not** follow its authentication / `@wix/cli` /
-  "managed project" setup (e.g. anything under `references/managed/`, such as `AUTHENTICATION.md`).
-  That is **not** how auth works here — auth is handled per STEP 2 below.
-- **`wix-docs`** — a **fallback**: how to search and read the Wix API reference docs, for anything
-  the seeding recipes above don't cover.
+The docs were authored for **one host stack** (Vite + react-router, `.jsx`, files pre-copied into
+`src/`) — you may be on another, so **adapt these assets to your stack; don't copy the host's setup.**
+Everything is under `.agents/skills/wix-vibe-headless/references/`.
 
-Install them so you can read them from files as you go (fetching skill docs over the web
-truncates or summarises large files).
+**Shared transport — both files, used by every vertical (`shared/app/rest/`):**
+
+| file | what's in it |
+|---|---|
+| `wix-client.js` | The transport: exchanges `WIX_CLIENT_ID` for an anonymous **visitor token**, persists + refreshes it (that token *is* the cart/session identity), and exposes `wixApiRequest(path, {method, body, query})` — plus the member-session swap (`setSessionTokens` / `clearSession` / `isMember`). Plain `fetch`; SSR-guards `window`/`localStorage`; maps 402 + error bodies. |
+| `wix-config.js` | Holds `WIX_CLIENT_ID` + `WIX_METASITE_ID` — the only values to fill in. |
+
+**Every `references/<vertical>/` holds the same four things:**
+
+- `app/rest/wix-*.js` — the vertical's **data layer**: named calls carrying the exact request/response
+  **shapes**, fieldsets, and paging.
+- `app/{components,pages,hooks,context}/…` — a **reference UI** (+ hooks/providers) built on that data
+  layer; the field shapes and route patterns it uses (e.g. `/product/:slug`) are the data contract.
+- `seed/seed-*.js` — build-time **seeding functions** that create content.
+- `INSTRUCTIONS.md` — the vertical's build guide + field-shape snippets; `seed/SEED.md` — how the seed
+  module is run.
+
+**The nine verticals — data layer (`app/rest/`) + seed module (`seed/`):**
+
+| vertical | `app/rest/` data layer | seed module |
+|---|---|---|
+| storefront | `wix-store-catalog.js`, `wix-store-cart.js` — products & variants; server cart + checkout redirect | `seed-store.js` |
+| bookings | `wix-bookings-services.js`, `wix-bookings-checkout.js` — services/categories/slots; booking + checkout | `seed-bookings.js` |
+| blog | `wix-blog.js` — posts (list + by-slug), categories, tags | `seed-blog.js` |
+| events | `wix-events-browse.js`, `wix-events-registration.js` — events & categories; RSVP / ticketing + checkout | `seed-events.js` |
+| portfolio | `wix-portfolio.js` — collections, projects, galleries | `seed-portfolio.js` |
+| restaurants | `wix-restaurants-menu.js`, `-ordering.js`, `-reservations.js` — menu; online ordering; table reservations | `seed-restaurants.js` |
+| cms | `wix-cms.js` — Wix Data collections: list / detail / filter + form CRUD | `seed-cms.js` |
+| pricing-plans | `wix-pricing-plans.js` — plans list + subscribe/checkout | `seed-pricing-plans.js` |
+| members | `wix-members-auth.js` — custom login/signup (email+password, social, SSO), session, account | *(none — members sign up at runtime; nothing to seed)* |
+
+Anything in the docs about the **host's own setup** — copying files into `src/`, its `@/` alias, its
+`import.meta.env` flags, a theming file, its build/exec/connector tooling — is that host's, not a
+rule: **adapt it to your stack or ignore it.** The `SKILL.md` **"shared model"** (public-client-id
+auth, money = objects → render `formattedValue`, visitor token = cart identity, member login swaps
+the token set) is **universal — follow it as-is**.
+
+## The flow — install → build client → seed → done
+
+Run **build the client** (step 2) and **seed** (step 3) in parallel; parallelize independent work within each.
+
+### 1 · Install the skills
+
+Two skills, into `.agents/skills/`: **`wix-vibe-headless`** (this build guide + the seed modules —
+self-contained) and **`wix-docs`** (fallback to search/read the Wix API reference).
 
-**Run the Skills CLI** — this is the install path to use:
 ```bash
-CI=1 npx skills@latest add wix/skills/skills/wix-headless --yes
 CI=1 npx skills@latest add wix/skills/skills/wix-vibe-headless --yes
 CI=1 npx skills@latest add wix/skills/skills/wix-docs --yes
 ```
 
-**Only if the CLI above actually errors** (not on a guess), fall back to curl + gzip — download
-each bundle and extract it into `.agents/skills/wix-<name>/`:
-```bash
-for s in headless vibe-headless docs; do
-  mkdir -p ".agents/skills/wix-$s"
-  curl -s "https://www.wix.com/skills/$s.tgz" | tar xz -C ".agents/skills/wix-$s" --strip-components=1
-done
-```
+### 2 · Build the client
 
-## STEP 1 — Build the client
+Pull the whole client reference into context in two reads — **this is basically your prompt: it's all
+the client code you need.** Build the client from it in your own stack's idiom (your router, file
+extensions, design tokens), and set `WIX_CLIENT_ID` + `WIX_METASITE_ID` in `wix-config`.
 
-Read `.agents/skills/wix-vibe-headless/SKILL.md` and follow it **exactly** — it is the single
-source of truth for how the client app is built against the Wix APIs (over the public
-`WIX_CLIENT_ID`, which is a buyer/visitor-facing credential, safe in the frontend). To save time,
-prefer copying the ready-made files the `wix-vibe-headless` skill provides (e.g. the Wix client
-setup) and adapting them over re-generating them from scratch.
+```bash
+V=<vertical>   # the vertical you're building
 
-## STEP 2 — Seed and manage the business
+# utils — transport + data layer (plain fetch, already SSR-guarded; use ~as-is)
+find .agents/skills/wix-vibe-headless/references/shared/app/rest \
+     .agents/skills/wix-vibe-headless/references/$V/app/rest \
+     -type f -name '*.js' -exec tail -n +1 {} +
 
-Seed the site with real content by following the `wix-headless` skill's `references/SEED.md`
-(`.agents/skills/wix-headless/references/SEED.md`). Where its seed recipes don't cover what you
-need, fall back to the `wix-docs` skill to search and read the relevant Wix API docs.
+# components/pages — a reference UI (rebuild for your framework; keep the field shapes + route patterns)
+find .agents/skills/wix-vibe-headless/references/$V/app \
+     -type f \( -name '*.jsx' -o -name '*.js' \) -not -path '*/rest/*' -exec tail -n +1 {} +
+```
 
-**Seeding is additive.** You may clean up the app install's **obvious default sample/mock data**
-right after a fresh install, but the site may already hold **real content** (a prior run, or
-owner-added) — if what's there isn't obviously install sample data, or you're unsure, **do not
-delete or overwrite it without the user's explicit ask or approval** (ask first).
+### 3 · Seed the content
 
-These management/admin calls need **elevated Wix credentials** — the public client id is not
-enough. If you don't already have a way to authenticate them, either **connect your platform's
-Wix connector** (if it has one) or **ask the user for a Wix API key / token** and store it in your
-platform's built-in **connector / secrets (env) manager** — never hardcode or commit it. **Once
-the connector is connected (or the API key is in place), you can make Wix REST admin calls
-directly** — authenticate each call with that credential (the `wix-docs` skill covers Wix API-key
-auth). Or, if the user prefers, tell them they can add this content themselves in the Wix
-dashboard instead.
+**⛔ NO CLEANUP — EVER.** Strictly **additive**: never delete, reset, or overwrite anything on the
+user's live site — not even apparent sample/demo content. If something looks wrong, leave it and tell
+the user.
 
-Authenticate admin calls with **only** that connector/API key. Do **not** install or run the Wix
-CLI (`@wix/cli`), do a device-login, or follow `wix-headless`'s `references/managed/AUTHENTICATION.md`
-— that managed-project auth flow does not apply here.
+**Auth** (the public client id won't do): if your platform has a **built-in Wix connector**, use it
+(it holds the credential). Otherwise take a **Wix API key** into your secrets manager (never hardcode
+or commit) — create one at **[account API keys → Add key](https://manage.wix.com/account/api-keys/addkey)**
+([how-to](https://dev.wix.com/docs/api-reference/articles/authentication/api-keys/generate-an-api-key)) —
+and send it **raw as `Authorization` (no `Bearer`)** with a **`wix-site-id`** header (`wix-account-id`
+only for account-level APIs — one, not both):
 
-Management/admin operations (seeding, `wix-headless`, `wix-docs`) are **separate from the
-client** — the client is built solely per the `wix-vibe-headless` skill.
+```bash
+curl -X POST 'https://www.wixapis.com/stores/v3/products/query' \
+  -H 'Authorization: <API_KEY>' -H 'wix-site-id: <METASITE_ID>' \
+  -H 'Content-Type: application/json' -d '{"query":{"cursorPaging":{"limit":10}}}'
+```
 
-If possible, run STEP 1 and STEP 2 in parallel — building the client and seeding the business
-are independent. Within each, also parallelize independent work (API calls, seeding multiple
-entities) to finish faster.
+Pull the seed code into context — **this is your seeding prompt: it's all the code you need.** Run
+these functions (adapting the exec + auth to your platform) to create the content:
 
-## Later admin requests
+```bash
+V=<vertical>
+find .agents/skills/wix-vibe-headless/references/$V/seed -name '*.js' -exec tail -n +1 {} +
+```
 
-For any later admin/management request, work the same way as STEP 2: check the `wix-headless`
-skill's inline recipes first (`.agents/skills/wix-headless/references/inline-recipes/`) and fall
-back to the `wix-docs` skill where the operation isn't documented there.
+They encode the Wix API sequences (incl. app-install + provisioning-race handling); use `wix-docs`
+for anything they don't cover. Content queries return `REQUIRED_APP_NOT_INSTALLED` until the app is
+installed + seeded (expected; the seed modules install it first). Image seeding = two Wix Media calls
+(`generate-upload-url` → `PUT` the bytes) before attaching.
 
-## When done
+### 4 · Done
 
-After the site is built and seeded, ask the user to open this URL to complete the setup in Wix
-(substitute the metasite id you were given): `https://manage.wix.com/dashboard/{metaSiteId}`
+Mount the preview-only manage banner (regenerate `WixManageBanner` for your stack — it reads
+`WIX_METASITE_ID` from `wix-config`, already set in step 2, and self-hides while it's still the
+placeholder; mount above the header, SSR-safe, portable preview-gate, **never on the published
+site**), then tell
+the user to open `https://manage.wix.com/dashboard/{metaSiteId}` to finish setup in Wix (payments,
+content).