@smartsoft001-mobilems/claude-plugins 2.86.0 → 2.87.0

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,134 @@
+---
+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. .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.
+
+### 10. Verify
+
+Run `scripts/verify-init.sh <workspace-root> <PREFIX>`. It asserts the delta landed (Tailwind,
+multimediaUrl, MobilEMS providers, populated shared-lib barrel) 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.

package/plugins/mobilems/skills/mobilems-project-init/references/app-shell.md

@@ -0,0 +1,107 @@
+# App shell + static pages + routes
+
+Build the root `App` component, the static pages, and the app routing by copying from the reference's
+`apps/web/src/app` and threading `<PREFIX>`. The foundation owns the shell, the static pages, and the
+routing table's static routes; each feature module skill adds its own routes.
+
+## App root — `app.ts` / `app.html` / `app.scss`
+
+Copy verbatim and thread `<PREFIX>`. The root component imports the `COMPONENTS` array +
+`SkipLinksComponent` from `@<PREFIX>/angular`, injects `ConfigsFacade` + `SeoService` (from
+`@smartsoft001-mobilems/angular`), `LocalStorageService` (shared lib) and `Router`; it inits the
+language, loads the global `Config` in `ngOnInit`, and focuses `#skip-links` on each `NavigationEnd`.
+`app.html`:
+
+```html
+<app-skip-links></app-skip-links>
+<app-app [options]="options">
+  <header tabindex="-1"><app-header></app-header></header>
+  <footer><app-footer></app-footer></footer>
+</app-app>
+```
+
+## Static pages
+
+Copy `pages/{home,page,contact,search,not-found}` + the `home` and `page` resolvers, and thread
+`<PREFIX>`. These use only foundation shared components:
+
+- `home.component` uses the foundation carousels (`NewObjectsCarouselComponent`,
+  `NewsCarouselComponent`, `PartnersCarouselComponent`) and the `IObject`/`IArticle`/`IPartner` types
+  from the shared `models/` dir, plus the `DataService` home loaders — all foundation code (see
+  `references/shared-lib.md`). The home page renders fully; its carousels populate from the API at
+  runtime.
+- `search.component` renders results through a `<router-outlet>`; it has no feature import.
+
+Run a feature-package grep over the pages you copy as a guard. **Do not copy `article-preview`** — the
+reference's `article-preview` page imports `@smartsoft001-mobilems/articles-domain` (it previews an
+Article), so it is feature code, not foundation. The `mobilems-articles` skill builds it (and its
+route) when it adds an article module. If your reference has any other page that imports a feature
+package, leave it for the owning module skill too.
+
+## `app.routes.ts` — the app routing table
+
+Build `appRoutes` with the app's static routes — home, dynamic pages, contact, search, and the
+catch-all. Each feature module skill adds its own route (a lazy `loadChildren`) to this `appRoutes`
+array and a matching child under the `wyszukaj/:text` search route when it runs (and `mobilems-articles`
+adds the `article-preview` route).
+
+```ts
+import { Route } from '@angular/router';
+
+import { homeResolver } from './pages/home/home.resolver';
+import { pageResolver } from './pages/page/page.resolver';
+
+export const appRoutes: Route[] = [
+  { path: '', pathMatch: 'full', redirectTo: 'strona-glowna' },
+  {
+    path: 'strona/:id',
+    loadComponent: () =>
+      import('./pages/page/page.component').then((m) => m.PageComponent),
+    resolve: { pageData: pageResolver },
+  },
+  {
+    path: 'strona/:id/:slug',
+    loadComponent: () =>
+      import('./pages/page/page.component').then((m) => m.PageComponent),
+    resolve: { pageData: pageResolver },
+  },
+  {
+    path: 'strona-glowna',
+    loadComponent: () =>
+      import('./pages/home/home.component').then((m) => m.HomeComponent),
+    resolve: { pageData: homeResolver },
+  },
+  {
+    path: 'kontakt',
+    loadComponent: () =>
+      import('./pages/contact/contact.component').then(
+        (m) => m.ContactComponent,
+      ),
+  },
+  {
+    path: 'wyszukaj',
+    children: [
+      {
+        path: ':text',
+        loadComponent: () =>
+          import('./pages/search/search.component').then(
+            (m) => m.SearchComponent,
+          ),
+        children: [{ path: '', redirectTo: 'obiekty', pathMatch: 'full' }],
+      },
+    ],
+  },
+  {
+    path: '**',
+    loadComponent: () =>
+      import('./pages/not-found/not-found.component').then(
+        (m) => m.NotFoundComponent,
+      ),
+  },
+];
+```
+
+> The search view defaults to the objects results (`redirectTo: 'obiekty'`); the route resolves once
+> the objects module is present. A module skill adds its route by inserting a `loadChildren` entry
+> into `appRoutes` (top level) and into the `wyszukaj/:text` `children` array, immediately before the
+> `{ path: '', redirectTo: 'obiekty' }` default — see each module skill's `module-and-routes.md`.

package/plugins/mobilems/skills/mobilems-project-init/references/claude-config.md

@@ -0,0 +1,44 @@
+# .claude extension — flow@mobilems + MobilEMS perms
+
+The base seeded a generic `.claude/settings.json` (smart@smartsoft + nx plugins, safety/audit hooks,
+a generic allow-list). MobilEMS adds the `flow@mobilems` plugin and the museum-specific
+permission / MCP allow-lists. **Extend, do not replace** the base file — keep its hooks and `env`.
+
+## `.claude/settings.json`
+
+1. **`enabledPlugins`** — add `flow@mobilems` (keep the existing `smart@smartsoft` + `nx@nx-claude-plugins`):
+   ```json
+   "enabledPlugins": {
+     "flow@mobilems": true,
+     "smart@smartsoft": true,
+     "nx@nx-claude-plugins": true
+   }
+   ```
+2. **`permissions.allow`** — add the MobilEMS working set on top of the base git/nx/fs allows:
+   - Playwright MCP (`mcp__playwright__browser_*`) + accessibility-scanner MCP
+     (`mcp__accessibility-scanner__*`) — used by the UI / a11y skills.
+   - `WebSearch`, and `WebFetch(domain:…)` for `www.npmjs.com`, `github.com`,
+     `docs.anthropic.com`, `linear.app`, plus the project's own museum portal domain (ask the user
+     for it, or leave a placeholder comment) and `localhost`.
+   - `Bash(npm start)`, `Bash(nx:*)`, `Bash(lsof:*)`, `Bash(mkdir:*)` for serve/screenshot flows.
+   - Keep `permissions.ask` (`git commit`/`git push`/`gh pr create`) from the base.
+3. **`extraKnownMarketplaces`** — keep the base's `nx-claude-plugins`. The `mobilems` and `smart`
+   marketplaces are resolved from the installed `@smartsoft001*/claude-plugins` packages.
+
+> Don't copy the reference's full domain allow-list verbatim — it carries one museum's specific
+> hosts (its own portal domain, project n8n/maia webhooks). Seed the generic-useful entries and let
+> the project grow its own.
+
+## tools/specs + tools/prompts
+
+Seed pointers so the museum conventions are discoverable (the framework repo keeps the canonical
+copies under `tools/specs/{layers,styles,tests}.md` + `tools/prompts/*`). Either copy those files
+from the reference repo, or drop a short `tools/README.md` linking to them. These are documentation
+aids — not required for the build, so keep this light.
+
+## CLAUDE.md / AGENTS.md
+
+The base wrote a trimmed generic `CLAUDE.md` + the Nx `AGENTS.md`. Optionally append a short
+"MobilEMS" section to `CLAUDE.md` noting: feature modules are added by the `mobilems-<module>`
+skills, styling is Tailwind (`smart-` prefix) on scss, and runtime env adds `multimediaUrl`. Keep it
+brief — the authoritative guidance lives in the plugin skills.