@smartsoft001-mobilems/claude-plugins 2.86.0 → 2.88.0

package/plugins/mobilems/skills/mobilems-partners/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: mobilems-partners
+description: Add the museum PARTNERS feature module (partnerzy) to a MobilEMS app initialized with mobilems-project-init. Use whenever the user wants to add / scaffold / wire the partners (partnerzy) module, the museum partners list + detail pages (partner cards, map, connected objects), or asks to "dodaj moduł partnerów / partnerzy". Creates libs/museum-partners (domain + shell/angular), registers the /partnerzy route (top-level + search child), and adds the Articles + objects-domain npm packages it reuses. Requires the MobilEMS foundation to exist first.
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion
+---
+
+# MobilEMS partners module
+
+Add the **partners** (partnerzy) feature module on top of a MobilEMS foundation produced by
+`mobilems-project-init`. This module's entire UI lives inside its own `libs/museum-partners`
+library, so this skill builds that library and registers the `partnerzy` route.
+
+Partners is a list/detail feature where each entry is a partnering institution: a `ListComponent`
+with grid/list partner cards (sortable, paged, masonry layout) plus an `ItemComponent` that renders
+the partner detail (logo, description, map location, and the museum objects connected to that
+partner). It is backed by `ArticlesSharedModule.forFeature` over the Articles `Article` type — it
+REUSES the Articles shared module (like the thematic-paths module) but with its OWN domain entity
+(`MuseumPartner`), its OWN reducer (`getReducer`), and **no `baseQuery`**.
+
+## Precondition
+
+Run `scripts/detect-init.sh <workspace-root>`. It confirms the MobilEMS foundation is present
+(`SharedModule.forRoot` in `app.config.ts`, a populated shared-lib barrel). If not, tell the user to
+run `/mobilems:project-init` first. Hold `<PREFIX>` (from `tsconfig.base.json`; reference uses
+`@msr`) and the reference repo path (same one init used).
+
+## Steps
+
+1. **npm deps** — add `@smartsoft001-mobilems/articles-domain`,
+   `@smartsoft001-mobilems/articles-shell-angular`, `@smartsoft001-mobilems/articles-shell-dtos`
+   (this module reuses the Articles shared module — `ArticlesSharedModule` + `ArticlesService`) and
+   `@smartsoft001-mobilems/objects-domain` (the `MuseumPartner` entity types its `connections` with
+   `IMsObjectConnection` from objects-domain). Also add `lodash-decorators` (the list page uses
+   `@debounce` for its date filter). Grep the copied pages/components for any other third-party
+   imports and add those too. Match the installed mobilems line; resolve versions at run time; do
+   not `npm install` unless asked. Adding is idempotent — if a sibling module already installed
+   these, nothing changes. (`@smartsoft001-mobilems/{angular,models}` and
+   `@thisissoon/angular-masonry` are already foundation deps.)
+2. **Library** — create `libs/museum-partners/{domain,shell/angular}` per
+   `references/lib-contents.md`: copy the domain entity (`MuseumPartner`) and the shell
+   (`MuseumPartnersModule`, routes, `+state/partners.reducer.ts`, `components/{grid-item,list-item}`,
+   `pages/{list,item}`, `services/partners`), thread `<PREFIX>`. Add the two `tsconfig.base.json`
+   paths and the `museum-partners` commit scope.
+3. **Module + routes** — see `references/module-and-routes.md`: `MuseumPartnersModule` wraps
+   `ArticlesSharedModule.forFeature({ routing: false, config: { reducerFactory: getReducer, type: Article, apiUrl, entity: 'partners' } })`
+   (note: **no baseQuery**) with the `Masonry` SSR factory and provides `SERVICES`. Add the lazy
+   `partnerzy` route to the `appRoutes` array in `apps/web/src/app/app.routes.ts` as a top-level
+   route, and a matching child under the `wyszukaj/:text` search route (partners appears in site
+   search).
+4. **Verify** — run `scripts/verify-module.sh <workspace-root> <PREFIX>`: asserts the lib + entity
+   exist, both tsconfig paths are added, `ArticlesSharedModule.forFeature` is wired with
+   `entity: 'partners'` + `reducerFactory: getReducer`, the `+state/partners.reducer.ts` exports
+   `getReducer`, the `components/{grid-item,list-item}` cards are present in the partners lib, the
+   `partnerzy` route is registered (top-level + search child), and the Articles + objects-domain deps
+   are in `package.json`. Fix and re-run.
+
+## Notes
+
+- Partners contributes nothing to `libs/shared/angular`: its grid/list cards live in its own lib, and
+  the `partners-carousel` foundation component is already built by `mobilems-project-init`. So this
+  skill builds only the partners module + its route — there is no shared-components reference.
+- This skill ONLY touches the partners module + its route. It never adds other feature modules,
+  never re-runs the foundation, and never edits `libs/shared/angular`.
+- Bundled `references/` + `scripts/` ship automatically. Do not hand-edit `plugin.json`.

package/plugins/mobilems/skills/mobilems-partners/references/lib-contents.md

@@ -0,0 +1,160 @@
+# libs/museum-partners — structure to create
+
+Copy from the reference MobilEMS app's `libs/museum-partners` and thread `<PREFIX>`. The lib has two
+projects: a `domain` (the entity) and a `shell/angular` (the Angular module + NgRx `+state` + UI).
+
+```
+libs/museum-partners/
+├── domain/                              # project: museum-partners-domain
+│   ├── package.json                     # "name": "museum-partners-domain"
+│   ├── jest.config.js                   # displayName + coverageDirectory under libs/museum-partners/domain
+│   └── src/
+│       ├── index.ts                     # export * from './lib/entities';
+│       ├── features.ts                  # export const DOMAIN_SERVICES = [];
+│       └── lib/
+│           └── entities/                # museum-partner.entity.ts (MuseumPartner) + index
+└── shell/angular/                       # project: museum-partners-shell-angular
+    └── src/
+        ├── index.ts                     # export * from './lib/pages'; export * from './lib/partners.module';
+        └── lib/
+            ├── index.ts                 # export * from './pages'; './components'; './partners.module';
+            ├── partners.module.ts       # MuseumPartnersModule (references/module-and-routes.md)
+            ├── partners.routes.ts
+            ├── +state/                  # partners.reducer.ts (getReducer)
+            ├── components/              # grid-item (GridItemComponent), list-item (ListItemComponent) + index
+            ├── pages/                   # list (ListComponent), item (ItemComponent) + index
+            └── services/               # partners/partners.service.ts + index (SERVICES)
+```
+
+> The partner cards (`grid-item`, `list-item`) live in **this** lib, not in `libs/shared/angular`.
+> Copy only what the reference has — there is no `+state/*.facade.ts`/`*.selectors.ts` and no
+> `directives/` dir in this module; the only `+state` file is `partners.reducer.ts`.
+
+## Domain entity (verbatim — thread nothing; pure types)
+
+This entity `implements IEntity<string>` — it does NOT extend the Articles `Article` base class. It
+pulls `MsFile` from `@smartsoft001-mobilems/models` and **`IMsObjectConnection` from
+`@smartsoft001-mobilems/objects-domain`** (the cross-module type that drives the SKILL.md
+objects-domain dep). Copy `domain/src/lib/entities/museum-partner.entity.ts` verbatim:
+
+```ts
+import { IEntity } from '@smartsoft001/domain-core';
+import { Model, Field } from '@smartsoft001/models';
+import { MsFile } from '@smartsoft001-mobilems/models';
+import { IMsObjectConnection } from '@smartsoft001-mobilems/objects-domain';
+
+@Model({})
+export class MuseumPartner implements IEntity<string> {
+  id!: string;
+
+  @Field()
+  name!: string;
+
+  @Field()
+  additionalInfo!: string;
+
+  @Field()
+  geoLocation!: any;
+
+  @Field()
+  latitude!: number;
+
+  @Field()
+  longitude!: number;
+
+  @Field()
+  objectCount!: number;
+
+  @Field()
+  extraData!: {
+    name: string;
+    phone: string;
+    emailAddress?: string;
+    description: string;
+    shortDescription: string;
+    address: string;
+    openingHours: number;
+    ticketPrices: number;
+    logo: MsFile;
+    image: MsFile;
+    website: string;
+  };
+
+  @Field()
+  connections?: Array<IMsObjectConnection>;
+}
+```
+
+## Shell `+state` (NgRx — copy verbatim, thread `<PREFIX>`)
+
+- `partners.reducer.ts` exports `getReducer()` — wraps `@smartsoft001/crud-shell-angular`'s
+  `getReducer('partners')` and returns a `(state, action) => …` reducer. This is the function passed
+  as `reducerFactory` in the module config. The reducer's `State` type is `SmartState<Article>`
+  (from `@smartsoft001-mobilems/articles-domain`), since the module is configured over `Article`.
+
+## Services — `services/index.ts` exports a `SERVICES` array (copy verbatim)
+
+`PartnersService extends CrudBaseService<MuseumPartner>` (from `@smartsoft001-mobilems/angular`) and
+points its list/detail URLs at the partners (`dictionary/Department`) endpoints, enriching list items
+with geodata. It is bound to BOTH `CrudService` and `ArticlesService` (the reused Articles shared
+module resolves `ArticlesService`):
+
+```ts
+import { CrudService } from '@smartsoft001/crud-shell-angular';
+import { ArticlesService } from '@smartsoft001-mobilems/articles-shell-angular';
+
+import { PartnersService } from './partners/partners.service';
+
+export * from './partners/partners.service';
+
+export const SERVICES = [
+  PartnersService,
+  {
+    provide: CrudService,
+    useClass: PartnersService,
+  },
+  {
+    provide: ArticlesService,
+    useClass: PartnersService,
+  },
+];
+```
+
+## UI components & pages
+
+- `components/grid-item` (`GridItemComponent`, selector `app-partners-grid-item`) and
+  `components/list-item` (`ListItemComponent`, selector `app-partners-list-item`) are the partner
+  cards used by the list page; `components/index.ts` re-exports both. Copy verbatim, thread
+  `<PREFIX>`.
+- `pages/list` (`ListComponent extends ArticlesListComponent`) renders the sortable/paged masonry
+  grid; it uses `@debounce` from `lodash-decorators` (the SKILL.md dep) for its date filter.
+- `pages/item` (`ItemComponent extends ArticlesItemComponent`) renders the partner detail with map
+  and connected objects (it composes foundation components from `@<PREFIX>/angular` such as
+  `MapComponent` and `ObjectsGridItemComponent`).
+
+## Wiring
+
+- **tsconfig.base.json paths** (add both):
+  ```json
+  "@<PREFIX>/museum-partners/domain": ["libs/museum-partners/domain/src/index.ts"],
+  "@<PREFIX>/museum-partners/shell/angular": ["libs/museum-partners/shell/angular/src/index.ts"]
+  ```
+- **project.json / build config** — copy each project's config (names `museum-partners-domain`,
+  `museum-partners-shell-angular`) and normalize every path field the reference baked to its origin
+  location — `sourceRoot`, `dest`, `outputPath`, `coverageDirectory`, `jestConfig`,
+  `lintFilePatterns`, and the jest `displayName` — to `libs/museum-partners/...`. Some reference
+  fields are stale and need fixing: the shell `project.json` `sourceRoot` reads
+  `libs/museum-partners/src` (correct it to `libs/museum-partners/shell/angular/src`), and the shell
+  `jest.config.ts` `coverageDirectory` points at a sibling's `coverage/packages/...` path (correct it
+  to `coverage/libs/museum-partners/shell/angular`); the domain `package.json` `name` reads
+  `museum-objects-domain` (correct it to `museum-partners-domain`). Others are already correct (the
+  domain `jest.config.js` `displayName`/`coverageDirectory` are right) — verify each against a
+  known-good sibling and fix only the stale ones. A `domain` with no `project.json` (Nx-inferred) is
+  fine — just set its `package.json` `name`.
+- **commit scope** — `commitlint.config.js` reads `libs/` dir names, so `museum-partners` becomes a
+  valid scope automatically; no edit needed.
+
+This module reuses the Articles shared module, so it needs the three `@smartsoft001-mobilems/articles-*`
+npm packages plus `@smartsoft001-mobilems/objects-domain` (for `IMsObjectConnection`) and
+`lodash-decorators` (see SKILL.md step 1). `@angular/cdk`, `@thisissoon/angular-masonry`,
+`@ngx-translate/core`, and `@smartsoft001-mobilems/{angular,models}` are already foundation deps.

package/plugins/mobilems/skills/mobilems-partners/references/module-and-routes.md

@@ -0,0 +1,125 @@
+# MuseumPartnersModule + route registration
+
+## `libs/museum-partners/shell/angular/src/lib/partners.module.ts`
+
+Thread `<PREFIX>` (the `environment` import). This module REUSES `ArticlesSharedModule` (the same
+shared module the news/articles/thematic-paths modules use) but configures it over the Articles
+`Article` type with its OWN `getReducer` and **no `baseQuery`**. The `Masonry` factory returns the
+real library in the browser and a no-op mock during SSR (identical to objects). It provides the
+`SERVICES` array (which binds both `CrudService` and `ArticlesService` to `PartnersService`).
+
+```ts
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { Article } from '@smartsoft001-mobilems/articles-domain';
+import { ArticlesSharedModule } from '@smartsoft001-mobilems/articles-shell-angular';
+import { Masonry } from '@thisissoon/angular-masonry';
+
+import { environment } from '@<PREFIX>/angular';
+
+import { getReducer } from './+state/partners.reducer';
+import { routes } from './partners.routes';
+import { SERVICES } from './services';
+
+@NgModule({
+  providers: [
+    ...SERVICES,
+    {
+      provide: Masonry,
+      useFactory: () => {
+        if (typeof window !== 'undefined' && (window as any)['Masonry']) {
+          return (window as any)['Masonry'];
+        }
+        // Return a mock for SSR
+        return class {
+          constructor() {
+            // no-op
+          }
+          layout() {
+            return;
+          }
+          reloadItems() {
+            return;
+          }
+          destroy() {
+            return;
+          }
+        };
+      },
+    },
+  ],
+  imports: [
+    FormsModule,
+    ArticlesSharedModule.forFeature({
+      routing: false,
+      config: {
+        reducerFactory: getReducer,
+        type: Article,
+        apiUrl: environment.apiUrl,
+        entity: 'partners',
+      },
+    }),
+    RouterModule.forChild(routes),
+  ],
+})
+export class MuseumPartnersModule {}
+```
+
+> Contrast with `mobilems-objects` (`ObjectsSharedModule.forFeature` over `MsObject`, no
+> `reducerFactory`): here the module reuses `ArticlesSharedModule`, supplies `type: Article` with
+> `reducerFactory: getReducer`, and there is deliberately **no `baseQuery`** in the config.
+
+## `partners.routes.ts`
+
+```ts
+import { Route } from '@angular/router';
+
+import { ItemComponent, ListComponent } from './pages';
+
+export const routes: Route[] = [
+  {
+    path: ':id',
+    component: ItemComponent,
+  },
+  {
+    path: ':id/:slug',
+    component: ItemComponent,
+  },
+  {
+    path: '',
+    component: ListComponent,
+  },
+];
+```
+
+## Register in `apps/web/src/app/app.routes.ts`
+
+Add the partners route to the `appRoutes` array (idempotently — if a `partnerzy` route already
+exists, skip). Add it as a top-level route, and as a child of the `wyszukaj/:text` search route so
+`/wyszukaj/:text/partnerzy` works and partners shows up among the search results.
+
+Top-level — add to `appRoutes`:
+
+```ts
+  {
+    path: 'partnerzy',
+    loadChildren: () =>
+      import('@<PREFIX>/museum-partners/shell/angular').then(
+        (m) => m.MuseumPartnersModule,
+      ),
+  },
+```
+
+Search child — add to the `children` of the `wyszukaj/:text` route, before the
+`{ path: '', redirectTo: 'obiekty' }` default:
+
+```ts
+          {
+            path: 'partnerzy',
+            loadChildren: () =>
+              import('@<PREFIX>/museum-partners/shell/angular').then(
+                (m) => m.MuseumPartnersModule,
+              ),
+          },
+```

package/plugins/mobilems/skills/mobilems-partners/scripts/detect-init.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+#
+# detect-init.sh <workspace-root>
+#
+# Precondition gate for mobilems-objects (and the other module skills follow the same shape):
+# confirm the MobilEMS foundation from mobilems-project-init is present. Portable to macOS bash 3.2.
+#
+# Exit 0 → foundation present, OK to add the module.
+# Exit 3 → foundation missing (tell the user to run /mobilems:project-init first).
+set -eu
+
+ROOT="${1:?usage: detect-init.sh <workspace-root>}"
+cd "$ROOT" 2>/dev/null || { echo "ERROR: no such dir: $ROOT" >&2; exit 2; }
+
+miss() {
+  echo "FOUNDATION MISSING: $1" >&2
+  echo "Run /mobilems:project-init first to lay down the MobilEMS foundation." >&2
+  exit 3
+}
+
+[ -f apps/web/src/app/app.config.ts ] || miss "app.config.ts missing"
+grep -q "SharedModule.forRoot" apps/web/src/app/app.config.ts || miss "SharedModule.forRoot not in app.config.ts (foundation not applied)"
+grep -q "./lib/components" libs/shared/angular/src/index.ts 2>/dev/null || miss "shared-lib components barrel not populated"
+[ -f apps/web/src/app/app.routes.ts ] || miss "app.routes.ts missing"
+
+PREFIX="$(grep -oE '@[a-z0-9-]+/angular' tsconfig.base.json | head -1 | sed -E 's#@([a-z0-9-]+)/angular#\1#')"
+echo "FOUNDATION OK. Detected prefix: ${PREFIX:-<unknown>}"
+[ -d libs/museum-objects ] && echo "NOTE: libs/museum-objects already exists — build steps must be idempotent." >&2
+exit 0

package/plugins/mobilems/skills/mobilems-partners/scripts/verify-module.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+#
+# verify-module.sh <workspace-root> <PREFIX>
+#
+# Post-condition check for mobilems-partners: library created, ArticlesSharedModule wired over the
+# Article type with its own reducer, the partner cards present in the partners lib, the partnerzy
+# route registered (top-level + search child), and the Articles + objects-domain deps installed.
+# macOS bash 3.2 safe.
+set -eu
+
+ROOT="${1:?usage: verify-module.sh <workspace-root> <PREFIX>}"
+PREFIX="${2:?usage: verify-module.sh <workspace-root> <PREFIX>}"
+cd "$ROOT" 2>/dev/null || { echo "ERROR: no such dir: $ROOT" >&2; exit 2; }
+
+fail=0
+pass() { echo "  PASS: $1"; }
+bad()  { echo "  FAIL: $1" >&2; fail=1; }
+
+MOD=libs/museum-partners/shell/angular/src/lib/partners.module.ts
+
+echo "== Library =="
+[ -f "$MOD" ] && pass "MuseumPartnersModule present" || bad "partners.module.ts missing"
+[ -f libs/museum-partners/domain/src/lib/entities/museum-partner.entity.ts ] && pass "MuseumPartner entity present" || bad "domain entity missing"
+grep -q "class MuseumPartner" libs/museum-partners/domain/src/lib/entities/museum-partner.entity.ts 2>/dev/null && pass "MuseumPartner class declared" || bad "MuseumPartner class not declared"
+grep -q "museum-partners/shell/angular" tsconfig.base.json && pass "tsconfig shell path added" || bad "tsconfig shell path missing"
+grep -q "museum-partners/domain" tsconfig.base.json && pass "tsconfig domain path added" || bad "tsconfig domain path missing"
+
+echo "== Module wiring =="
+grep -q "ArticlesSharedModule.forFeature" "$MOD" 2>/dev/null && pass "ArticlesSharedModule.forFeature wired" || bad "ArticlesSharedModule.forFeature missing"
+grep -q "entity: 'partners'" "$MOD" 2>/dev/null && pass "entity 'partners' configured" || bad "entity 'partners' missing"
+grep -q "reducerFactory: getReducer" "$MOD" 2>/dev/null && pass "reducerFactory: getReducer configured" || bad "reducerFactory: getReducer missing"
+
+echo "== +state =="
+STATE=libs/museum-partners/shell/angular/src/lib/+state
+[ -f "$STATE/partners.reducer.ts" ] && pass "reducer present" || bad "partners.reducer.ts missing"
+grep -q "export function getReducer" "$STATE/partners.reducer.ts" 2>/dev/null && pass "getReducer exported" || bad "getReducer not exported in reducer"
+
+echo "== UI components =="
+COMP=libs/museum-partners/shell/angular/src/lib/components
+[ -f "$COMP/grid-item/grid-item.component.ts" ] && pass "grid-item card present" || bad "components/grid-item missing"
+[ -f "$COMP/list-item/list-item.component.ts" ] && pass "list-item card present" || bad "components/list-item missing"
+
+echo "== Route registration =="
+ROUTES=apps/web/src/app/app.routes.ts
+grep -q "museum-partners/shell/angular" "$ROUTES" && pass "partners route registered" || bad "partners route not in app.routes.ts"
+# top-level + search child — expect at least 2 occurrences
+n=$(grep -c "museum-partners/shell/angular" "$ROUTES" || true)
+[ "${n:-0}" -ge 2 ] && pass "registered top-level + search child ($n)" || bad "expected >=2 route registrations (top-level + search child), found $n"
+grep -q "partnerzy" "$ROUTES" && pass "partnerzy path present" || bad "partnerzy path missing"
+
+echo "== Deps =="
+grep -q "@smartsoft001-mobilems/articles-domain" package.json && pass "articles-domain dep" || bad "articles-domain dep missing"
+grep -q "@smartsoft001-mobilems/articles-shell-angular" package.json && pass "articles-shell-angular dep" || bad "articles-shell-angular dep missing"
+grep -q "@smartsoft001-mobilems/articles-shell-dtos" package.json && pass "articles-shell-dtos dep" || bad "articles-shell-dtos dep missing"
+grep -q "@smartsoft001-mobilems/objects-domain" package.json && pass "objects-domain dep" || bad "objects-domain dep missing"
+
+echo
+if [ "$fail" = 0 ]; then echo "VERIFY: all checks passed."; else echo "VERIFY: FAILED — fix the items above and re-run." >&2; fi
+exit "$fail"

package/plugins/mobilems/skills/mobilems-project-init/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: mobilems-project-init
+description: Turn a generic scaffold-nx-workspace base into a MobilEMS museum web-app foundation — the MobilEMS DELTA (deps, Tailwind, runtime env, app.config providers, shared lib, static pages, app shell, .claude). Use whenever the user wants to initialize / bootstrap / set up a NEW MobilEMS or MuzaCMS museum app, "skonfiguruj projekt muzealny / mobilems", port a museum frontend, or asks to add the MobilEMS foundation on top of an existing Nx + Angular SSR scaffold. Produces the foundation ONLY — NO feature modules (objects, collections, articles, thematic publications); those are added by the mobilems-<module> skills afterwards.
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion
+---
+
+# MobilEMS project init
+
+Apply the **MobilEMS delta** on top of a base produced by `scaffold-nx-workspace` (the generic
+smartsoft Nx + Angular-SSR shell). The base gives you a buildable empty workspace: prefix already
+threaded, scss-only, minimal `app.config.ts`, empty `app.routes.ts`, a generic `server.ts`, and a
+shared lib that exports only `environment` + `EnvironmentService`. This skill upgrades that shell
+into a MobilEMS museum **foundation** — everything the museum app needs _except_ the feature
+modules.
+
+**Why a delta (not a from-scratch generator):** the museum shared lib is ~15k lines of bespoke
+Angular (header, footer, page renderer, filters, gallery, map, widgets, WCAG, SEO, …) that is
+**not** published to npm. It cannot be regenerated from prose, so reference mode copies it from an
+existing MobilEMS repo and threads the workspace prefix. Foundation-only mode is a degraded
+fallback when no reference is available.
+
+## Scope — the foundation only
+
+This skill builds the museum **foundation**: the workspace it produces builds and runs on its own,
+with **no `libs/museum-*` libraries, no feature shared components, and no feature routes** yet. The
+feature modules are built by `mobilems-objects`, `mobilems-object-collections`, `mobilems-articles`,
+and `mobilems-thematic-publications`, each of which adds its own library, shared components, npm
+package, and routes. Keeping feature code out of the foundation is the layering rule that lets the
+foundation build standalone (its shared library imports no feature package).
+
+## Steps
+
+### 0. Precondition — confirm a scaffold-nx-workspace base
+
+Run `scripts/detect-base.sh <workspace-root>`. It checks for the base shell (`apps/web/src/server.ts`,
+an empty-ish `app.routes.ts`, a shared lib barrel exporting only environment/EnvironmentService) and
+that the MobilEMS delta is **not** already applied. If the base is missing, stop and tell the user to
+run `/smart:scaffold-nx-workspace` first — do not try to create the Nx workspace here.
+
+### 1. Detect the prefix (never re-propose)
+
+The base already derived/confirmed/threaded the import-alias prefix. Read it from
+`tsconfig.base.json` `paths` — the key `@<PREFIX>/angular`. Hold `<PREFIX>`; thread it into every
+copied file (the reference repo uses `@msr`, so replacing `@msr` → `@<PREFIX>` is the main rewrite).
+
+### 2. Choose mode
+
+Default = **reference mode**. Ask the user (`AskUserQuestion`) for the path/URL of an existing
+MobilEMS repo to copy the shared lib + static pages from (a local clone of one of the team's museum
+apps). If they decline, or if invoked with a `foundation-only` argument, use **foundation-only** mode
+(see "Modes" below).
+
+### 3. npm dependencies
+
+Add the MobilEMS framework + state + i18n + shared-UI deps per `references/npm-deps.md`. Versions
+are resolved at run time to match the installed `@smartsoft001/angular` line — **never hardcode**.
+Do NOT add the per-feature packages (`*-objects-*`, `*-articles-*`, `*-public-collections-*`) or
+`online-3d-viewer` — those belong to the module skills.
+
+### 4. Tailwind on top of scss
+
+Layer Tailwind (class prefix `smart-`) onto the base's scss per `references/tailwind-styles.md`:
+add `tailwind.config.js` + postcss wiring, and overwrite `apps/web/src/styles.scss` with the museum
+global stylesheet (font-fallbacks, `.smart-container`, WCAG, masonry, fullscreen-dialog rules). The
+stylesheet is pure CSS — copying it verbatim is safe even before the components it targets exist.
+
+### 5. Runtime env — multimediaUrl + translations
+
+Extend the base runtime-env infra per `references/server-env.md`: add `multimediaUrl` to
+`environment.ts`/`.prod.ts`, the `/env.js` template, and the SSR allowed-hosts list; and add the
+`/api/translations` endpoint to `server.ts`.
+
+### 6. app.config.ts → MobilEMS providers
+
+Replace the base's minimal providers with the full MobilEMS provider set per
+`references/config-providers.md` (ngrx root + devtools, ngx-translate + `provideAppInitializer`
+translation bootstrap, `MasonryModule`, `SharedModule.forRoot`, the three HTTP interceptors, the
+`StyleService`/`AppService`→`NoOpAppService`/`ErrorService` overrides, `SEARCH_CONFIG_TOKEN`, and
+`withI18nSupport()` on hydration).
+
+### 7. Shared lib — populate the placeholders (reference mode)
+
+Follow `references/shared-lib.md`. Build the **foundation shared components** — every shared
+component that depends only on Angular + the framework packages + other foundation shared components.
+Run `python3 scripts/classify-shared-components.py` against the reference's
+`libs/shared/angular/src/lib/components` to list which shared components are FOUNDATION (build here)
+vs FEATURE-OWNED (built by a module skill, because they import a feature package). Build the
+foundation components (including the home-page carousels) + all services/pipes/directives/tools/models
+
+- `configs.module.ts`, thread `<PREFIX>`, export them from the barrels, and build the `widget`
+  container + `models/objects.model.ts` with their foundation parts. A shared component that imports a
+  feature domain package is feature code — a module skill builds it.
+
+### 8. App shell + static pages + routes
+
+Follow `references/app-shell.md`: copy the `App` root component (`app.ts`/`app.html`/`app.scss`) and
+the static pages (`home`, `page`, `contact`, `search`, `not-found`) + their resolvers, thread
+`<PREFIX>`, and build `app.routes.ts` with the app's static routes (home, pages, contact, search,
+catch-all). Each module skill adds its own feature route to the `appRoutes` array when it runs
+(`article-preview` is articles-coupled — `mobilems-articles` adds it, not the foundation).
+
+### 9. QA hardening — SEO, i18n, WCAG, branding
+
+Apply `references/qa-hardening.md` — a checklist distilled from real QA bug reports on live museum
+deployments. The copied foundation carries the _reference museum's_ identity, so this step removes
+leftovers and closes the recurring gaps QA always finds:
+
+- dynamic `/sitemap.xml` + `/robots.txt` SSR endpoints driven by `SITE_URL` (never static copies —
+  they shipped another museum's domain twice),
+- og/twitter images + URLs on the target domain, favicon set, skip links rewritten for this app,
+- meta description + OpenGraph on home in both languages; `og:locale` follows the active language,
+- default language = Polish, `<html lang>` synced on switch, zero hardcoded UI strings,
+- WCAG: one `h1`, no skipped heading levels, contrast ≥4.5:1 (reference greys fail), heading font
+  with full Polish diacritics,
+- warning-clean build & console (NG8107/NG8112/NG8113/NG0100/NG0913, Swiper loop, duplicate API
+  calls).
+
+### 10. .claude extension
+
+Apply `references/claude-config.md`: add `flow@mobilems` to `enabledPlugins`, grow the
+MobilEMS-specific permissions / MCP allow-lists, and seed `tools/specs` + `tools/prompts` pointers.
+
+### 11. Verify
+
+Run `scripts/verify-init.sh <workspace-root> <PREFIX>`. It asserts the delta landed (Tailwind,
+multimediaUrl, MobilEMS providers, populated shared-lib barrel), the QA-hardening basics (sitemap +
+robots endpoints, favicon, non-empty heading font), AND the foundation is self-contained (no
+`libs/museum-*`, no feature routes, and the build-safety invariant — no file under
+`libs/shared/angular/src` imports a feature package). Fix and re-run until it passes. Gate
+`npm install` behind an explicit ask — skip it during self-validation/eval.
+
+## Modes
+
+- **Reference mode (default):** copies the shared lib + pages from a real MobilEMS repo and threads
+  the prefix. This is the only mode that regenerates the full foundation, because the shared lib is
+  not in npm.
+- **Foundation-only (fallback):** do steps 1, 3, 4, 5, 9 (deps, Tailwind, env, .claude) and scaffold a
+  reduced `app.config.ts` that does NOT import local shared-lib code (omit the interceptors + the
+  `App` shell that need it). Leave a `MOBILEMS-FOUNDATION-TODO.md` listing what reference mode would
+  have copied (shared lib, pages, full app.config, app shell) so the user can supply a reference
+  later. Be honest that this mode does not produce a runnable museum UI on its own.
+
+## Notes
+
+- This skill assumes the base Nx + Angular-SSR workspace already exists — it patches MobilEMS onto
+  it and never runs `create-nx-workspace`.
+- Bundled `references/` + `scripts/` ship automatically (the whole `src/plugins/**` tree is copied to
+  dist). Do NOT hand-edit `plugin.json` — the version is auto-synced at build.
+- The feature work — feature libs, their npm packages, routes, and feature shared components — is
+  built by the `mobilems-<module>` skills, not here.