@pikku/skills 0.12.54 → 0.12.55

package/skills/pikku-concepts/SKILL.md

@@ -65,7 +65,7 @@ which is what decides whether a thrown error becomes a 409 or a 500.
 
 - **Worked examples are sparse.** Most exports show a signature and keys, not usage.
 - **`pikkuFunc` lists keys that belong elsewhere.** `before`, `after`, `skip`, `surfaces` and
-  `requiresActor` apply only to scenarios; `workflowQueued`, `workflowRetries` and
+  `requiresVirtualUser` apply only to scenarios; `workflowQueued`, `workflowRetries` and
   `workflowTimeout` only to a workflow step. One shared config type offers all of them to
   every function — each key says which it belongs to.
 
@@ -96,35 +96,34 @@ flags; the "Read" column is the skill that teaches the thing, where one does.
 
 **Running**
 
-| Command                      | What it does                                                                   | Read                                    |
-| ---------------------------- | ------------------------------------------------------------------------------ | --------------------------------------- |
-| `dev`                        | Local dev server, all services wired, watch + HMR                              | `pikku-build`                           |
-| `serve`                      | Bundled bun/node runner — no watch, no codegen                                 | `pikku-deploy`                          |
-| `watch`                      | Regenerate on file change, without a server                                    | —                                       |
-| `scenario list\|run`         | Scenarios as e2e tests and health checks                                       | `pikku-scenario`                        |
-| `persona run`                | A declared persona as a model-driven virtual user against a stage              | `pikku-scenario`, persona-run reference |
-| `persona list\|sync\|secret` | Who is declared; what an environment will provision; minting their credentials | `pikku-scenario`, persona-run reference |
-| `db`                         | Local development database                                                     | `pikku-kysely`                          |
+| Command                           | What it does                                                                   | Read                                         |
+| --------------------------------- | ------------------------------------------------------------------------------ | -------------------------------------------- |
+| `dev`                             | Local dev server, all services wired, watch + HMR                              | `pikku-build`                                |
+| `serve`                           | Bundled bun/node runner — no watch, no codegen                                 | `pikku-deploy`                               |
+| `watch`                           | Regenerate on file change, without a server                                    | —                                            |
+| `scenario list\|run`              | Scenarios as e2e tests and health checks                                       | `pikku-scenario`                             |
+| `virtual-user run`                | A declared virtual user, model-driven, against a stage                         | `pikku-scenario`, virtual-user-run reference |
+| `virtual-user list\|sync\|secret` | Who is declared; what an environment will provision; minting their credentials | `pikku-scenario`, virtual-user-run reference |
+| `db`                              | Local development database                                                     | `pikku-kysely`                               |
 
 **Inspecting and evolving**
 
-| Command               | What it does                                                            | Read                         |
-| --------------------- | ----------------------------------------------------------------------- | ---------------------------- |
-| `doc`                 | The installed API surface                                               | this skill                   |
-| `meta` / `info`       | What the project declares, machine- and human-readable                  | `pikku-meta`                 |
-| `validate`            | Every check that applies — app structure, an addon's published file set | `pikku-build`, `pikku-addon` |
-| `versions` / `release` | Contract hashes, breaking-change detection, versioned releases        | `pikku-meta`                 |
-| `audit` / `update`    | Advisories; which `@pikku/*` can move and what peers that needs         | `pikku-meta`                 |
-| `scopes` / `roles`    | Declared authorization scopes; roles from `defineSystemRole`            | `pikku-auth`                 |
-| `knowledge`           | The knowledge base — what this app is, in its users' language           | `pikku-knowledge`            |
-| `emails`              | Email template generation                                               | `pikku-emails`               |
+| Command                | What it does                                                            | Read                         |
+| ---------------------- | ----------------------------------------------------------------------- | ---------------------------- |
+| `doc`                  | The installed API surface                                               | this skill                   |
+| `meta` / `info`        | What the project declares, machine- and human-readable                  | `pikku-meta`                 |
+| `validate`             | Every check that applies — app structure, an addon's published file set | `pikku-build`, `pikku-addon` |
+| `versions` / `release` | Contract hashes, breaking-change detection, versioned releases          | `pikku-meta`                 |
+| `audit` / `update`     | Advisories; which `@pikku/*` can move and what peers that needs         | `pikku-meta`                 |
+| `scopes` / `roles`     | Declared authorization scopes; roles from `defineSystemRole`            | `pikku-auth`                 |
+| `knowledge`            | The knowledge base — what this app is, in its users' language           | `pikku-knowledge`            |
+| `emails`               | Email template generation                                               | `pikku-emails`               |
 
 **Shipping, and the CLI itself**
 
 | Command                       | What it does                                                                                                                                   | Read           |
 | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------- |
 | `deploy`                      | Deploy to cloud infrastructure                                                                                                                 | `pikku-deploy` |
-| `fabric`                      | PikkuFabric: login, link, deploy, domains, secrets, logs                                                                                       | `pikku-fabric` |
 | `binary`                      | Compile an entrypoint to a native binary (`bun build --compile`)                                                                               | —              |
 | `dist`                        | Copy what `tsc` cannot emit — `.gen.json` meta, hand-authored `.d.ts` — into the build output. Run it after `tsc`, as a package's build script | —              |
 | `login` / `logout` / `whoami` | The CLI's session against a pikku server                                                                                                       | —              |
@@ -298,7 +297,7 @@ a Workers or serverless stage needs done belongs on the request path that needs
 where Pikku is embedded in a server you own. Lifecycle hooks do not run on this path; do the
 startup work in the entrypoint.
 
-`pikku validate` warns when a project starts a server by hand *and* depends on no runtime adapter,
+`pikku validate` warns when a project starts a server by hand _and_ depends on no runtime adapter,
 because that means the first path was available and unused.
 
 **`references/bootstrap.md`** has both entrypoints in full.
@@ -355,17 +354,17 @@ src/
 Three different things in a Pikku project have a human language, and they are **not** the same
 language. Collapsing them is the common mistake:
 
-| Axis            | Covers                                                                        | Decided by                                     |
-| --------------- | ----------------------------------------------------------------------------- | ---------------------------------------------- |
-| **Identifiers** | Function, component, type and file names; tables and columns; commit messages | Nothing. **Always English.** There is no setting |
-| **Meta**        | Prose authored inside the code — `description`, `title`, step `template`      | `metaLocale` in `pikku.config.json` (default `en`) |
+| Axis            | Covers                                                                        | Decided by                                                    |
+| --------------- | ----------------------------------------------------------------------------- | ------------------------------------------------------------- |
+| **Identifiers** | Function, component, type and file names; tables and columns; commit messages | Nothing. **Always English.** There is no setting              |
+| **Meta**        | Prose authored inside the code — `description`, `title`, step `template`      | `metaLocale` in `pikku.config.json` (default `en`)            |
 | **Product UI**  | Every string the app shows a user                                             | `messages/<locale>.json`, and `active.json`'s `defaultLocale` |
 
 Identifiers are the surface every other tool binds to — the generated clients, the RPC map a
 scenario is typed over, the SQL types — and unlike a string an identifier cannot be translated
 later: renaming one is a migration. `metaLocale` exists so a team can read their own Console in
 their own language; it is not licence to rename anything. And `baseLocale` in
-`project.inlang/settings.json` stays `en`, because it names the message *source* every other
+`project.inlang/settings.json` stays `en`, because it names the message _source_ every other
 language is cloned from.
 
 **When a brief tells you the product speaks a language, it is telling you about the third axis and

package/skills/pikku-concepts/references/language.md

@@ -5,11 +5,11 @@ Three different things in a Pikku project have a human language, and they are
 prevent, and it has already shipped in a real product — the failure is at the
 bottom.
 
-| Axis            | What it covers                                                                                                                                                    | What decides it                                                                                             |
-| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
-| **Identifiers** | Function, component, type, variable and file names. Database tables and columns. Branch names and commit messages.                                                | Nothing. **Always English.** There is no setting.                                                           |
-| **Meta**        | The prose authored _inside_ the code: `description` on functions and steps, `name`/`title` on features and scenarios, step `template`, role/persona descriptions. | `metaLocale` in `pikku.config.json`. Defaults to `en`.                                                      |
-| **Product UI**  | Every string the app shows a user.                                                                                                                                | `messages/<locale>.json`, with `active.json`'s `defaultLocale` choosing what a first-time visitor opens in. |
+| Axis            | What it covers                                                                                                                                                         | What decides it                                                                                             |
+| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
+| **Identifiers** | Function, component, type, variable and file names. Database tables and columns. Branch names and commit messages.                                                     | Nothing. **Always English.** There is no setting.                                                           |
+| **Meta**        | The prose authored _inside_ the code: `description` on functions and steps, `name`/`title` on features and scenarios, step `template`, role/virtual-user descriptions. | `metaLocale` in `pikku.config.json`. Defaults to `en`.                                                      |
+| **Product UI**  | Every string the app shows a user.                                                                                                                                     | `messages/<locale>.json`, with `active.json`'s `defaultLocale` choosing what a first-time visitor opens in. |
 
 ## Identifiers are English, and nothing changes that
 
@@ -19,7 +19,7 @@ all get `getOverview`, `AttentionStripe`, `case`, `event`.
 
 This is not linguistic preference, it is mechanics. Identifiers are the surface
 every other tool binds to: the generated `#pikku/*` clients, `pikku info` and
-`pikku meta`, the RPC map a scenario's `actor.invoke` is typed over, the
+`pikku meta`, the RPC map a scenario's `virtualUser.invoke` is typed over, the
 generated SQL types, every skill and every agent that ever picks the project up.
 A `vorgang` table types as `Vorgang` in Kysely and reads as noise to everyone who
 did not name it, and unlike a string it cannot be translated later — renaming an

package/skills/pikku-deploy/references/nextjs.md

@@ -88,7 +88,7 @@ route definitions.
 
 - **`PikkuNextJSWorkerRPC({ fetcher })`** — same surface as `PikkuNextJS`, but
   every call is dispatched through a `Fetcher` (a Cloudflare service binding, a
-  local HTTP client, a fabric dispatcher) instead of loading function code
+  local HTTP client, a dispatcher worker) instead of loading function code
   in-process. Use it to keep functions out of the SSR bundle. A non-2xx response
   throws with the status and body text.
 - **`toNextJsAuthHandler(auth)`** — wraps a better-auth instance or handler

package/skills/pikku-guide/SKILL.md

@@ -20,11 +20,11 @@ A guide is the app explained to the people who use it, with the scenario suite
 as its evidence. The suite proves what the product does and photographs it
 doing it; the pages say what that means for the reader and how to do it.
 
-| Input | Comes from | Owned by |
-|---|---|---|
-| Structure | `pikkuFeature` meta — which features exist, and that every one is cited | the suite |
-| Evidence | the latest passing run under `.pikku/scenario-runs/` — recordings and screenshots | the run |
-| Prose | markdown pages under `docs/` (or `--docs <dir>`) — **every word the reader reads** | you |
+| Input     | Comes from                                                                         | Owned by  |
+| --------- | ---------------------------------------------------------------------------------- | --------- |
+| Structure | `pikkuFeature` meta — which features exist, and that every one is cited            | the suite |
+| Evidence  | the latest passing run under `.pikku/scenario-runs/` — recordings and screenshots  | the run   |
+| Prose     | markdown pages under `docs/` (or `--docs <dir>`) — **every word the reader reads** | you       |
 
 **The run contributes pictures, never words.** Step sentences, scenario
 descriptions and feature names are written to prove a test; none of them
@@ -108,7 +108,7 @@ mechanical, and skipping it is how sections end up with no figure or with a
 figure of something else.
 
 1. **Inventory.** List every `pikkuFeature` and, under each, its scenarios with
-   their actor and the screen each one ends on. Read the scenario files, not
+   their virtual user and the screen each one ends on. Read the scenario files, not
    just the names.
 2. **Outline.** Group the scenarios into reader jobs (pages) and tasks
    (sections). A section is usually one scenario; two scenarios that show the
@@ -161,10 +161,10 @@ covers, or mark it `document: false`.
 
 Two strings from the suite reach the page as captions:
 
-| Figure | Caption |
-|---|---|
-| Screenshot | the `name` it was taken under |
-| Recording | the scenario's `title` (plus ` — ` and the actor, when there are several) |
+| Figure     | Caption                                                                        |
+| ---------- | ------------------------------------------------------------------------------ |
+| Screenshot | the `name` it was taken under                                                  |
+| Recording  | the scenario's `title` (plus `—` and the virtual user, when there are several) |
 
 Write both as a reader-facing caption in the app's language: "Die Buchung mit
 Status, Eckdaten und Reitern", "the course list, with places left on each
@@ -179,6 +179,7 @@ Every scenario a section cites should take one showcase screenshot of the state
 the section describes. Add the capture step once:
 
 ```ts snippet:guideCaptureStep
+
 ```
 
 - Without `path` it photographs the screen the flow is on. Call it **after the
@@ -194,11 +195,11 @@ the section describes. Add the capture step once:
 
 ### The camera sees your seed data
 
-Every figure shows whatever the scenario's personas and seed rows contain, so
+Every figure shows whatever the scenario's virtual users and seed rows contain, so
 they are part of the documentation:
 
-- A persona's display name is in the header of every shot. "Scenario Admin" or
-  "test-user-3" is on every page of the guide; give personas plausible names
+- A virtual user's display name is in the header of every shot. "Scenario Admin" or
+  "test-user-3" is on every page of the guide; give virtual users plausible names
   and roles.
 - Seed rows are the example data a reader sees: in the app's language, the
   shape real data takes — no lorem ipsum, no English description inside a
@@ -208,14 +209,14 @@ they are part of the documentation:
 ### Traps that make a figure missing or wrong
 
 - **RPC-only scenarios file no screenshot.** The command warns `whose run filed
-  no screenshot — the block renders empty`. Add a browser capture, or do not
+no screenshot — the block renders empty`. Add a browser capture, or do not
   cite that scenario.
 - **A capture loop must iterate a named const.** `for (const s of [ … ])` with
   an inline array literal cannot be extracted (PKU679) and the scenario is
   silently empty. `const screens = [ … ] as const`, then `for (const s of screens)`.
 - **A capture before an assertion moves the page from under it.** Capture last,
   or re-navigate.
-- **A redirect photographs the wrong screen.** A first-time actor bounced to
+- **A redirect photographs the wrong screen.** A first-time virtual user bounced to
   onboarding, a consent dialog, a login — the shot is named "the map" and shows
   something else. Finish the redirecting flow in the scenario first, and look
   at the image.
@@ -284,8 +285,8 @@ the second is clean. Commit the lock; never hand-edit or hand-merge it.
       language: why and when, numbered steps naming controls as they read,
       what you see, what goes wrong.
 - [ ] Captions (screenshot names, scenario titles) are reader copy — no routes,
-      sizes, test ids or actor names.
-- [ ] Personas and seed data on camera look like real use, in the app's
+      sizes, test ids or virtual user names.
+- [ ] Virtual users and seed data on camera look like real use, in the app's
       language.
 - [ ] Every feature is cited or `document: false`; no `--allow-undocumented`.
 - [ ] Built from a full, passing `--run browser --screenshots` run; no "block

package/skills/pikku-i18n/references/messages.md

@@ -49,7 +49,7 @@ like it works, because the app does come up in that language, and then:
 - a message missing from a locale falls back to a catalogue nobody wrote
 
 The setting that actually decides what a first-time visitor sees is
-`defaultLocale`, held in `apps/app/src/i18n/active.json` in the Fabric app
+`defaultLocale`, held in `apps/app/src/i18n/active.json` in the app
 template and read by `src/i18n/config.ts`. It is deliberately a separate file
 from `settings.json` for exactly this reason — the source language and the
 served language are different questions.
@@ -67,12 +67,11 @@ So a German medical portal is **three** settings, not one:
 { "metaLocale": "de" }
 ```
 
-In the Fabric template both of the first two have a command, so you rarely edit
-them by hand:
+Edit the first two by hand:
 
 ```sh
-fabric i18n --add-locale de       # adds "de" to locales, seeds messages/de.json from en.json
-fabric i18n --default-locale de   # writes active.json — the app now OPENS in German
+# add "de" to locales and seed messages/de.json from en.json
+# set defaultLocale to "de" in active.json — the app now OPENS in German
 ```
 
 ### The failure this is written from
@@ -190,7 +189,7 @@ The gate catches _invalid_ messages but not _inlined_ strings. The starter templ
 2. Add `"fr"` to `locales` in `project.inlang/settings.json`. **Leave `baseLocale` at `en`** — step 1 only works because there is an English catalogue to mirror.
 3. Recompile (restart/`vite dev` or the CLI compile). A locale file missing keys falls back to the base locale per message.
 4. Content is reachable via the `/<lang>` URL prefix (`detectLocale` already resolves it); the base locale needs no prefix. Expose the switcher via `useLocale().setLocale`.
-5. Only if the app should **open** in the new language rather than merely offer it: set `defaultLocale` (`active.json` / `fabric i18n --default-locale fr`). Adding a locale and changing the default are different asks — do the second only when asked.
+5. Only if the app should **open** in the new language rather than merely offer it: set `defaultLocale` (`active.json`). Adding a locale and changing the default are different asks — do the second only when asked.
 
 ## i18n debug mode (find inlined strings)
 

package/skills/pikku-knowledge/SKILL.md

@@ -205,7 +205,7 @@ It is a **summary, not the note** — the argument continues in prose underneath
 | `table:`    | a table name                                       | the generated db schema                                                                    |
 | `addon:`    | `@pikku/addon-x` or bare `x`                       | the manifests that declare the dependency                                                  |
 | `scope:`    | a scope name                                       | the `scopes:` a function gates itself with, plus the scopes a `defineSystemRole()` confers |
-| `persona:`  | a persona name                                     | `definePersonas()`                                                                         |
+| `virtualUser:`  | a virtual user name                                     | `defineVirtualUsers()`                                                                         |
 
 Ids are case-sensitive: `createEntry` is not `createentry`.
 
@@ -219,7 +219,7 @@ These are all things that exist somewhere better, so a note is always the copy t
 
 | Do not write                        | Because it lives in                                        |
 | ----------------------------------- | ---------------------------------------------------------- |
-| a `personas/` section               | `definePersonas()` in the project's own code               |
+| a `virtual users/` section               | `defineVirtualUsers()` in the project's own code               |
 | a `scenarios/` section              | the `scenarios` of the plan for the changeset that builds it |
 | a `permissions/` section            | a decision note under `decisions/security/`                |
 | a list of tables, columns or routes | `pikku meta` — the generated schema _is_ the schema        |
@@ -270,4 +270,4 @@ Notes are different: they say what the app is now, so they change whenever it do
 
 OKF permits frontmatter fields a reader does not know, and the parser ignores them rather than failing. That is the extension point: a tool layered on Pikku can add its own sections and fields on top of everything above without forking the format.
 
-Fabric is the one that exists. It adds `decisions/design/` — rules about how the app looks and behaves — and a `screens/` section. Both are Fabric's to validate; `pikku knowledge validate` passes them through untouched. Everything else in this skill is the same in both.
+One exists: it adds `decisions/design/` — rules about how the app looks and behaves — and a `screens/` section. Both are the extending tool's to validate; `pikku knowledge validate` passes them through untouched. Everything else in this skill is the same in both.

package/skills/pikku-meta/references/audit.md

@@ -115,7 +115,7 @@ is admin-only), so the host must have Better Auth wired — see `pikku-auth`.
   **remediation slot**.
 - `renderRemediation({ pkg, version, issue })` — the extension seam. OSS default
   is `UpdateDependencyButton` (the free bump + `bun install`). Downstream
-  consoles (Fabric) pass their own sandbox-verified action here — replace the
+  consoles pass their own sandbox-verified action here — replace the
   action, keep the view.
 - Hooks: `useSecurityAudit` (read), `useRunSecurityAudit` (run),
   `useUpdateDependency` (bump). All are `useMutation`/`useQuery` — surface

package/skills/pikku-permissions/SKILL.md

@@ -3,7 +3,7 @@ name: pikku-permissions
 description: >-
   Use when deciding WHO may call a function: resource ownership, role gates, admin-only actions, or any "only their own rows" rule. Covers the `permissions` field, `pikkuPermission`, `pikkuAuth`, scopes and `defineScope`, `addGlobalPermission`, the three gates, `permissionsInBody`, and where ownership belongs versus where it does not.
   TRIGGER when: writing or reviewing any function that touches a row a user owns, gating an action on a role, building the permissions half of a contract in build PHASE 2, about to write an `if` in a function body that decides whether the caller is allowed, or hitting `MissingScopeError`.
-  DO NOT TRIGGER when: the question is how a caller proves who they are, such as sign-in, sessions, tokens, API keys or seeding a persona (use pikku-auth), or how to shape a paginated list (use pikku-list-query).
+  DO NOT TRIGGER when: the question is how a caller proves who they are, such as sign-in, sessions, tokens, API keys or seeding a virtual user (use pikku-auth), or how to shape a paginated list (use pikku-list-query).
 installGroups: [core]
 ---
 

package/skills/pikku-react/SKILL.md

@@ -3,10 +3,8 @@ name: pikku-react
 description: >-
   Use when a React frontend talks to a Pikku backend — PikkuProvider and createPikku at the app
   root, the generated React Query hooks (usePikkuQuery, usePikkuMutation, usePikkuInfiniteQuery),
-  direct usePikkuRPC / usePikkuFetch calls, realtime subscriptions, agent and workflow hooks, and
-  the dev actor switcher. TRIGGER when: writing a React component that fetches or mutates backend
-  data, wiring PikkuProvider, paginating, running or tracking a workflow from the client, or
-  asking about useDevActors / DevActorSwitcher / quick login. DO NOT TRIGGER when: working on the
+  direct usePikkuRPC / usePikkuFetch calls, realtime subscriptions, and agent and workflow hooks. TRIGGER when: writing a React component that fetches or mutates backend
+  data, wiring PikkuProvider, paginating, running or tracking a workflow from the client. DO NOT TRIGGER when: working on the
   backend (use pikku-wiring), defining the workflow itself (use pikku-workflow), rendering fetched values such as
   dates (use pikku-tailwind), or writing user-facing copy (use pikku-i18n).
 installGroups: [client]
@@ -21,25 +19,25 @@ stops.
 
 ## Pick the reference
 
-| You are… | Read |
-| --- | --- |
-| Wiring the app root, resolving the server URL, authenticating, or subscribing to realtime | `references/client.md` |
-| Fetching, mutating or paginating data | `references/react-query.md` |
-| Starting a workflow and showing its progress | `references/workflows.md` |
+| You are…                                                                                  | Read                        |
+| ----------------------------------------------------------------------------------------- | --------------------------- |
+| Wiring the app root, resolving the server URL, authenticating, or subscribing to realtime | `references/client.md`      |
+| Fetching, mutating or paginating data                                                     | `references/react-query.md` |
+| Starting a workflow and showing its progress                                              | `references/workflows.md`   |
 
 ## Reach for what
 
-| Need | Use |
-| --- | --- |
-| Render data, dedupe and cache | `usePikkuQuery` |
-| Trigger a write and wait for the result | `usePikkuMutation` |
-| Paginate | `usePikkuInfiniteQuery` |
-| One-off call from an event handler | `usePikkuRPC()` |
-| Hit a REST endpoint rather than an RPC | `usePikkuFetch()` |
-| Talk to one named AI agent | `usePikkuAgent(name)` → `.run` / `.stream` / `.approve` |
-| Run one named workflow | `usePikkuWorkflow(name)` → `.start` / `.run` / `.status` |
-| A workflow long enough to need progress UI | `references/workflows.md` |
-| Subscribe to events, SSE or a channel | `usePikkuRealtime()` |
+| Need                                       | Use                                                      |
+| ------------------------------------------ | -------------------------------------------------------- |
+| Render data, dedupe and cache              | `usePikkuQuery`                                          |
+| Trigger a write and wait for the result    | `usePikkuMutation`                                       |
+| Paginate                                   | `usePikkuInfiniteQuery`                                  |
+| One-off call from an event handler         | `usePikkuRPC()`                                          |
+| Hit a REST endpoint rather than an RPC     | `usePikkuFetch()`                                        |
+| Talk to one named AI agent                 | `usePikkuAgent(name)` → `.run` / `.stream` / `.approve`  |
+| Run one named workflow                     | `usePikkuWorkflow(name)` → `.start` / `.run` / `.status` |
+| A workflow long enough to need progress UI | `references/workflows.md`                                |
+| Subscribe to events, SSE or a channel      | `usePikkuRealtime()`                                     |
 
 A workflow that finishes in a moment can be awaited; one that does not needs
 start-plus-observe, or the component holds a pending state with nothing to show.

package/skills/pikku-react/references/client.md

@@ -1,6 +1,5 @@
 # Pikku React
 
-
 What is here:
 
 - [What ships](#what-ships)
@@ -174,8 +173,8 @@ helpers live in **pikku-wiring**.
 | Hit a REST endpoint (not RPC)       | `usePikkuFetch()`                                  |
 | Run one named workflow              | `usePikkuWorkflow('name')` → `.start/.run/.status` |
 | Talk to one named AI agent          | `usePikkuAgent('name')` → `.run/.stream/.approve`  |
-| Longer-running workflow UX          | `references/workflows.md`               |
-| Subscribe to events / SSE / channel | `usePikkuRealtime()` (see **pikku-wiring**)      |
+| Longer-running workflow UX          | `references/workflows.md`                          |
+| Subscribe to events / SSE / channel | `usePikkuRealtime()` (see **pikku-wiring**)        |
 
 The first three live in your generated `api.gen.ts` (see the
 `references/react-query.md`). This reference covers the rest.
@@ -240,40 +239,6 @@ pikku.fetch.setHeader('x-tenant', tenantId)
 `authHeaders.jwt` becomes `Authorization: Bearer …` and `authHeaders.apiKey`
 becomes `X-API-KEY`; setting a JWT takes precedence over an API key.
 
-### Dev actor sign-in (`useDevActors`)
-
-The dev-only "Sign in as …" control: one click signs in as a declared scenario
-persona with no password, so the app can be reviewed as each kind of user.
-`pikku fabric validate` **requires** any frontend with a login screen to ship one
-(`app-missing-actor-quick-login-<app>`) — without it a reviewer is locked out of
-their own sandbox.
-
-```tsx
-import { useDevActors } from '@pikku/react'
-
-const { actors, signInAs, pendingId, isPending, error } = useDevActors({
-  apiUrl: apiUrl(),
-  app: appSlug,
-  onSignedIn: () => navigate({ to: '/' }),
-})
-```
-
-- **It is UI-free**, so render it however you like. For the default rendering use
-  the starter template's `<DevActorSwitcher />` (`components/dev/DevActorSwitcher.tsx`).
-- **No credential reaches the bundle.** It lists from `/auth/sign-in/personas`
-  and `signInAs(id)` posts only the persona id to `/auth/sign-in/persona`. The
-  server decides who is offered and who may sign in, and offers nobody in
-  production — see **pikku-scenario** for `personaSignIn`.
-- **It takes `onSignedIn` rather than a router**, since every app lands
-  somewhere different.
-- `listDevActors()` and `signInAsPersona()` are exported too, for a non-React
-  caller. The endpoint only
-  signs in rows flagged `actor: true`, so it can never impersonate a real user —
-  see **pikku-auth**.
-
-Do not hand-write the list-and-sign-in pair per app; that copy-paste is exactly
-what this replaced.
-
 ## What NOT to do
 
 - Don't instantiate `PikkuFetch`/`PikkuRPC` inside a component — `createPikku`

package/skills/pikku-report/SKILL.md

@@ -3,17 +3,17 @@ name: pikku-report
 description: >-
   Use when pikku itself cost you time — wrong generated types, a check that passes when it should
   not, output that is quietly wrong, a skill that misled you — or when the user asks you to report
-  a framework bug or file a finding. Owns `pikku fabric report` (a finding is about pikku, not the
+  a framework bug or file a finding. Owns `pikku cloud report` (a finding is about pikku, not the
   app), the product-vs-harness kinds, the workaround-first ladder, and asking the user at hand-over
   whether to send what was filed. TRIGGER when: the framework fought you, codegen produced
   something broken, a skill told you to run something that does not exist, the user says "report
   this to pikku" / "file a finding", or you are handing over a build. DO NOT TRIGGER when: the bug
-  is in the app you are building (fix it there), you are debugging a deployed stage (use
-  pikku-fabric), or you are tempted to patch pikku's source (never do that from an app).
+  is in the app you are building (fix it there), you are debugging a deployed stage,
+  or you are tempted to patch pikku's source (never do that from an app).
 installGroups: [core]
 ---
 
-# Report a finding to Fabric
+# Report a finding to Pikku Studio Cloud
 
 A finding is about **pikku**, not about the app you are building. It is how the
 framework learns what cost its users time — the bug, the misleading skill, the
@@ -21,7 +21,7 @@ silence where a check should have complained.
 
 File each one the moment it happens. Nothing leaves the machine until the user
 says so at hand-over, and nothing is written to the repository. The command is
-spelled `pikku fabric report` — there is no top-level report command.
+spelled `pikku cloud report` — there is no top-level report command.
 
 ## Report at the moment it happens
 
@@ -75,7 +75,7 @@ follows it. Quote the heredoc delimiter (`<<'EOF'`, never `<<EOF`) so the shell
 leaves the body alone.
 
 ```bash
-pikku fabric report --stdin <<'EOF'
+pikku cloud report --stdin <<'EOF'
 {
   "title": "<one-line title>",
   "kind": "product",
@@ -88,7 +88,7 @@ pikku fabric report --stdin <<'EOF'
 EOF
 ```
 
-The same fields exist as flags for a finding short enough to type; `pikku fabric
+The same fields exist as flags for a finding short enough to type; `pikku cloud
 report --help` lists them. Whichever path you use, the rules below are checked
 before anything is sent:
 
@@ -116,7 +116,7 @@ The last thing in the hand-over — after the app runs, and is deployed if they
 chose to — is:
 
 ```bash
-pikku fabric report
+pikku cloud report
 ```
 
 With no finding, it lists what this build filed. What happens next depends on
@@ -130,12 +130,12 @@ what the user said before, which the CLI keeps on their machine:
   **Never**. Then run it again with their answer:
 
   ```bash
-  pikku fabric report --consent yes|no|always|never
+  pikku cloud report --consent yes|no|always|never
   ```
 
   Yes sends and No discards what is held now; Always and Never are saved and the
   question is not asked again. If nobody answers, leave them held and say that
-  `pikku fabric report` sends them later.
+  `pikku cloud report` sends them later.
 
 Findings are anonymous: no account, no project. The receipt printed when you
 filed each one is exactly what leaves the machine. A send that fails keeps what