@smartsoft001-mobilems/claude-plugins 2.86.0 → 2.87.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartsoft001-mobilems/claude-plugins",
-  "version": "2.86.0",
+  "version": "2.87.0",
   "publishConfig": {
     "access": "public"
   },

package/plugins/mobilems/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "mobilems",
   "description": "MobilEMS-specific Claude Code skills (MuzaCMS / MobileMS indexer API)",
-  "version": "2.86.0"
+  "version": "2.87.0"
 }

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

@@ -0,0 +1,84 @@
+---
+name: mobilems-articles
+description: Add an article (content) feature module to a MobilEMS app initialized with mobilems-project-init. The module is parametrized — you give it a NAME and a TEMPLATE value, and it builds an Article-backed list+detail module whose API requests are filtered by that template. Use whenever the user wants to add / scaffold / wire an articles, news (aktualności), education, or any template-filtered content module, or asks to "dodaj moduł artykułów / aktualności". One run builds one named module; run it again for each additional content type. Creates libs/museum-<name> (domain + shell/angular), registers its route, builds its article card shared components, and adds the articles npm packages. Requires the MobilEMS foundation to exist first.
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion
+---
+
+# MobilEMS article module
+
+Build a **parametrized article module** on top of a MobilEMS foundation produced by
+`mobilems-project-init`. An article module is an Article-backed list + detail feature whose API
+requests carry a fixed `template` filter, so the same module shape powers any number of content
+types — you choose the **name** and the **template value**. A project may have several article
+modules under different names (e.g. one per content category), and the same skill builds each.
+
+The module wraps `ArticlesSharedModule.forFeature` over the npm `Article` entity. The only thing that
+distinguishes one article module from another is its name, its route, its `entity` key, the
+`template` value it filters on, and whether it keeps feature-local ngrx state.
+
+## Parameters
+
+Collect these in Step 1 with `AskUserQuestion` (or accept them from the invocation if the user already
+gave them). The first two are the essentials:
+
+| Parameter      | What it is                                                                                                                | Example       |
+| -------------- | ------------------------------------------------------------------------------------------------------------------------- | ------------- |
+| **name**       | the module name → folder `museum-<name>`, class `Museum<Name>Module`, lib alias `@<PREFIX>/museum-<name>`                 | `news`        |
+| **template**   | the value sent in the API request filter `baseQuery: [{ key: 'template', value: '<template>', type: '=', hidden: true }]` | `AKTUALNOŚCI` |
+| route          | the URL path segment for the module's pages                                                                               | `aktualnosci` |
+| entity         | the `forFeature` `entity` key (API entity + ngrx state key); often equals the name                                        | `news`        |
+| feature state? | whether the module keeps its own ngrx state (adds a `reducerFactory`)                                                     | yes / no      |
+
+> The filter **key is always `template`** — only the **value** changes per module. Copy the file
+> structure from any existing article module in the reference MobilEMS app the project was built from,
+> adapting its name/route/entity/template; don't treat that app's particular modules as a fixed set to
+> reproduce.
+
+## 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. **Gather the parameters** above. Ask for the **name** and **template** at minimum; default `route`
+   and `entity` to the name unless the user specifies otherwise; ask whether the module needs feature
+   state.
+2. **npm deps** — add `@smartsoft001-mobilems/articles-domain`, `@smartsoft001-mobilems/articles-shell-angular`,
+   `@smartsoft001-mobilems/articles-shell-dtos` (match the installed mobilems line). Every article
+   module shares these three — if a previous article module already added them, skip. Resolve versions
+   at run time; do not `npm install` unless asked. (`@thisissoon/angular-masonry` is already a foundation dep.)
+   Also add any **extra third-party packages the copied pages import** that aren't already in the
+   workspace — e.g. the reference list page uses `lodash-decorators` (`@debounce`); grep the pages you
+   copy for non-`@angular`/`@smartsoft001` imports and add the missing ones.
+3. **Library** — create `libs/museum-<name>/{domain,shell/angular}` per `references/lib-contents.md`:
+   the thin domain entity (`Museum<Name> extends Article`), the shell (`Museum<Name>Module`, routes,
+   `pages/{list,item}`, services, and — if the module keeps feature state — `+state/<name>.reducer.ts`),
+   threading `<PREFIX>` and the chosen name/entity. Add the two `tsconfig.base.json` paths
+   (`@<PREFIX>/museum-<name>/domain` + `/shell/angular`).
+4. **Module + route** — see `references/module-and-routes.md`: `Museum<Name>Module` wraps
+   `ArticlesSharedModule.forFeature` with `type: Article`, the chosen `entity`, and
+   `baseQuery: [{ key: 'template', value: '<template>', type: '=', hidden: true }]`, plus the `Masonry`
+   SSR factory. Add the lazy `<route>` route to `appRoutes` in `apps/web/src/app/app.routes.ts`, and a
+   matching child under the `wyszukaj/:text` search route if the module's results belong in site search.
+   Also build the app's **`/article-preview` page** if it isn't there yet (it previews an `Article`, so
+   it belongs to the articles feature, not the foundation) — idempotent across runs; see
+   `references/module-and-routes.md`.
+5. **Article card shared components** — see `references/shared-components.md`: build the module's grid
+   and list cards (`<name>-grid-item`, `<name>-list-item`) in `libs/shared/angular` and export them; if
+   the module renders article-gallery content blocks, also build the article gallery widget and register
+   it in the widget content-type map (build once, idempotent across article modules).
+6. **Verify** — run `scripts/verify-module.sh <workspace-root> <PREFIX> <name> [template]`: asserts the
+   library exists, the `forFeature` carries the chosen `entity` (and template, if given), the route is
+   registered, and the article card shared components are built and exported. Fix and re-run.
+
+## Notes
+
+- One run builds one named article module. Run the skill again — with a different name + template — for
+  each additional content type the project needs.
+- Article modules reuse the foundation's generic `IArticle` model and the foundation's news carousel —
+  this skill does not rebuild them.
+- Bundled `references/` + `scripts/` ship automatically. Do not hand-edit `plugin.json`.

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

@@ -0,0 +1,164 @@
+# libs/museum-<name> — structure to create
+
+Copy from an existing article module in the reference MobilEMS app and substitute the module's
+`<name>` / `<entity>`, threading `<PREFIX>`. The library has two projects: a
+thin `domain` (one entity extending the npm `Article`) and a `shell/angular` (the Angular module +
+list/item pages + service). Article modules use the npm `Article` entity directly through
+`ArticlesSharedModule.forFeature`; the local domain entity is a near-empty subclass.
+
+```
+libs/museum-<name>/
+├── domain/                              # project: museum-<name>-domain
+│   └── src/
+│       ├── index.ts                     # export * from './lib/entities';
+│       └── lib/
+│           ├── entities/                # Museum<Name> extends Article (+ index)
+│           ├── enums/                   # .gitkeep
+│           ├── specifications/          # .gitkeep
+│           └── value-objects/           # .gitkeep
+└── shell/angular/                       # project: museum-<name>-shell-angular
+    └── src/
+        ├── index.ts                     # public barrel (pages + module [+ service])
+        └── lib/
+            ├── <name>.module.ts         # Museum<Name>Module (references/module-and-routes.md)
+            ├── <name>.routes.ts
+            ├── index.ts                 # SERVICES const + barrel (see below)
+            ├── +state/                  # ONLY if the module keeps feature state: <name>.reducer.ts
+            ├── pages/                   # list (ListComponent), item (ItemComponent) + index (PAGES)
+            └── services/                # optional module service (e.g. a visit logger)
+```
+
+## Domain entity (thin subclass of the npm `Article`)
+
+`domain/src/lib/entities/museum-<name>.entity.ts`:
+
+```ts
+import { Model } from '@smartsoft001/models';
+import { Article } from '@smartsoft001-mobilems/articles-domain';
+
+@Model({})
+export class Museum<Name> extends Article {}
+```
+
+Then `entities/index.ts` re-exports it and `domain/src/index.ts` does `export * from './lib/entities';`.
+(If the module needs extra fields, add them to this subclass.)
+
+## shell `lib/index.ts` — `SERVICES` + barrel
+
+Define a `SERVICES` const here binding `ArticlesService` as the `CrudService`; a module that keeps
+feature state spreads it into its providers:
+
+```ts
+import { CrudService } from '@smartsoft001/crud-shell-angular';
+import { ArticlesService } from '@smartsoft001-mobilems/articles-shell-angular';
+
+export * from './pages/index';
+export * from './<name>.module';
+
+export const SERVICES = [
+  ArticlesService,
+  { provide: CrudService, useClass: ArticlesService },
+];
+```
+
+## shell `src/index.ts` (public barrel)
+
+`export * from './lib/pages';` + `export * from './lib/<name>.module';` (plus the module's own service
+if it ships one — see below).
+
+## `pages/index.ts`
+
+```ts
+import { ItemComponent } from './item/item.component';
+import { ListComponent } from './list/list.component';
+
+export * from './item/item.component';
+export * from './list/list.component';
+
+export const PAGES = [ListComponent, ItemComponent];
+```
+
+Copy the `list/` and `item/` `.component.ts` + `.html` from a reference article module, threading
+`<PREFIX>`.
+
+## Optional: `+state/<name>.reducer.ts` (feature-local ngrx state)
+
+Build this only if the module keeps its own ngrx state (Step 1 "feature state? = yes"). It wraps the
+smart CRUD reducer keyed by the module's `<entity>`:
+
+```ts
+import { Action } from '@ngrx/store';
+import {
+  State as SmartState,
+  initialState as smartInitialState,
+  getReducer as smartGetReducer,
+} from '@smartsoft001/crud-shell-angular';
+import { Article } from '@smartsoft001-mobilems/articles-domain';
+
+export type State = SmartState<Article>;
+
+export const initialState = { ...smartInitialState };
+
+const reducer = (state = initialState, action: any) => {
+  switch (action.type) {
+    default:
+      return smartGetReducer('<entity>')(state, action);
+  }
+};
+
+export function getReducer() {
+  return (state: any, action: Action) => reducer(state, action);
+}
+```
+
+The module then passes `reducerFactory: getReducer` to `forFeature` (see
+`references/module-and-routes.md`). A module without feature state omits `+state/` entirely.
+
+## Optional: a module service
+
+A module may ship a small injectable (for example, a visit logger). Copy it from the reference module
+if it has one, threading `<PREFIX>`, and export it from `src/index.ts`:
+
+```ts
+import { HttpClient } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+
+import { environment } from '@<PREFIX>/angular';
+
+@Injectable({ providedIn: 'root' })
+export class Museum<Name>Service {
+  private http = inject(HttpClient);
+
+  logVisit(id: string | number): Promise<void> {
+    const url = environment.apiUrl + 'api/article/' + id + '/visit';
+    return firstValueFrom(this.http.post<void>(url, {}));
+  }
+}
+```
+
+> **Watch for cross-module service imports.** In the reference, some article modules' pages inject
+> _another_ article module's service (e.g. a `news` page importing `MuseumArticlesService` from
+> `@<ref-prefix>/museum-articles/shell/angular`). A generic article module must be self-contained — when
+> a copied page injects a sibling module's service, give this module its **own** `Museum<Name>Service`
+> (the template above) and rewire the page's import to it, rather than depending on a module that may
+> not exist in the target.
+
+## Wiring
+
+- **tsconfig.base.json paths** (add both):
+  ```json
+  "@<PREFIX>/museum-<name>/domain": ["libs/museum-<name>/domain/src/index.ts"],
+  "@<PREFIX>/museum-<name>/shell/angular": ["libs/museum-<name>/shell/angular/src/index.ts"]
+  ```
+- **project.json / build config** — copy each project's build config 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-<name>/...`. Some reference modules carry
+  stale values (e.g. a `sourceRoot` missing the `shell/angular` segment, or a `coverageDirectory`
+  under `packages/...`) while others are already correct — verify each against a known-good sibling and
+  fix only the stale ones. Set each `package.json` `name` to match (`museum-<name>-domain` /
+  `museum-<name>-shell-angular`) — a copied `package.json` may carry a stale name. A `domain` with no
+  `project.json` (Nx-inferred) is fine.
+- **commit scope** — `commitlint.config.js` reads `libs/` dir names, so `museum-<name>` becomes a valid
+  scope automatically; no edit needed.
+- **jest** — keep the reference `jest.config.ts` / `tsconfig.spec.json` so the shell unit-tests run.

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

@@ -0,0 +1,146 @@
+# `Museum<Name>Module` + route registration
+
+An article module wraps `ArticlesSharedModule.forFeature` over the npm `Article` entity and filters
+its API requests with a `template` value. Thread `<PREFIX>` (the `environment` import) and the chosen
+`<name>` / `<entity>` / `<template>`. The `Masonry` factory returns the real library in the browser
+and a no-op mock during SSR. Copy the file structure from an existing article module in the reference
+MobilEMS app and substitute the parameters.
+
+## `libs/museum-<name>/shell/angular/src/lib/<name>.module.ts`
+
+```ts
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { SharedModule as SmartSharedModule } from '@smartsoft001/angular';
+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 { routes } from './<name>.routes';
+
+@NgModule({
+  providers: [
+    {
+      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,
+    SmartSharedModule,
+    ArticlesSharedModule.forFeature({
+      routing: false,
+      config: {
+        type: Article,
+        apiUrl: environment.apiUrl,
+        entity: '<entity>',
+        baseQuery: [
+          { value: '<template>', key: 'template', type: '=', hidden: true },
+        ],
+      },
+    }),
+    RouterModule.forChild(routes),
+  ],
+})
+export class Museum<Name>Module {}
+```
+
+The **`baseQuery`** is what scopes the module to its content: `key` is always `'template'`, `type` is
+`'='`, `hidden` is `true`, and `value` is the module's `<template>` (the API then returns only records
+matching that template). Change only the `value` between modules.
+
+### Optional: feature-local ngrx state
+
+If the module keeps its own ngrx state, build `+state/<name>.reducer.ts` (see
+`references/lib-contents.md`) exporting a `getReducer`, then in the module:
+
+- pass `reducerFactory: getReducer` inside the `forFeature` `config`,
+- define a `SERVICES` const in `lib/index.ts` that binds `ArticlesService` as the `CrudService`, and
+  spread it into the `providers` (alongside the `Masonry` provider).
+
+(In the reference, the stateful article module also omits `SmartSharedModule` from its `imports` and
+imports `ConfigsModule` from `@<PREFIX>/angular` — mirror whichever the reference module you copy
+uses.) A module with no feature state omits `+state/` and the `reducerFactory` entirely.
+
+## `<name>.routes.ts`
+
+```ts
+import { Route } from '@angular/router';
+
+import { ItemComponent, ListComponent } from './pages';
+
+export const routes: Route[] = [
+  { path: ':id/:slug', component: ItemComponent },
+  { path: ':id', component: ItemComponent },
+  { path: '', component: ListComponent },
+];
+```
+
+## Register in `apps/web/src/app/app.routes.ts`
+
+Add the module's `<route>` to the `appRoutes` array (idempotently — if a `<route>` route already
+exists, skip). Add it as a top-level route, and — if the module's results belong in site search — as a
+child of the `wyszukaj/:text` route so `/wyszukaj/:text/<route>` works.
+
+Top-level — add to `appRoutes`:
+
+```ts
+  {
+    path: '<route>',
+    loadChildren: () =>
+      import('@<PREFIX>/museum-<name>/shell/angular').then(
+        (m) => m.Museum<Name>Module,
+      ),
+  },
+```
+
+Search child — add to the `children` of the `wyszukaj/:text` route, before the
+`{ path: '', redirectTo: ... }` default:
+
+```ts
+          {
+            path: '<route>',
+            loadChildren: () =>
+              import('@<PREFIX>/museum-<name>/shell/angular').then(
+                (m) => m.Museum<Name>Module,
+              ),
+          },
+```
+
+## The `/article-preview` page (build once)
+
+The app's content-preview page (`apps/web/src/app/article-preview/`) renders an `Article` for CMS
+preview mode, so it imports `@smartsoft001-mobilems/articles-domain` and belongs to the articles
+feature — the foundation deliberately leaves it out. Build it the first time an article module is
+added, and skip it if it already exists (idempotent across article-module runs):
+
+1. Copy `apps/web/src/app/article-preview/` (`.component.ts` + `.html`) from the reference app, thread
+   `<PREFIX>`.
+2. Add its route to `appRoutes` in `apps/web/src/app/app.routes.ts` (a plain top-level route, before
+   the `**` catch-all):
+
+```ts
+  {
+    path: 'article-preview',
+    loadComponent: () =>
+      import('./article-preview/article-preview.component').then(
+        (m) => m.ArticlePreviewComponent,
+      ),
+  },
+```

package/plugins/mobilems/skills/mobilems-articles/references/shared-components.md

@@ -0,0 +1,56 @@
+# Article module shared components
+
+An article module renders its records as cards in the grid view and rows in the list view, so it
+contributes a pair of shared components to `libs/shared/angular` named after the module. Build them by
+copying the card components of an existing article module in the reference MobilEMS app and adapting
+them to the module's `<name>` and `<PREFIX>`. Every step is idempotent — if the target already exists,
+leave it.
+
+All paths below are under `libs/shared/angular/src/lib`.
+
+## Article card components — build + export
+
+Build these two component directories and export them from `components/index.ts`:
+
+| Component                     | Renders                          |
+| ----------------------------- | -------------------------------- |
+| `components/<name>-grid-item` | an article card in the grid view |
+| `components/<name>-list-item` | an article row in the list view  |
+
+```ts
+// components/index.ts — these exports belong to the <name> module:
+export * from './<name>-grid-item';
+export * from './<name>-list-item';
+```
+
+These render an `Article` (via the foundation's generic `IArticle` model), so they depend on
+`@smartsoft001-mobilems/articles-domain` — which this skill installs. There is no module-specific
+model type to add (contrast `mobilems-objects`, which adds `ISpecificObject` to `objects.model.ts`).
+
+## Optional: article gallery widget
+
+If the project renders **article-gallery content blocks** (a page widget that embeds a gallery of
+articles), build the article gallery widget once and register it in the widget content-type map. This
+is shared by all article modules — build it the first time an article module needs it, and skip if a
+previous article module already added it.
+
+```ts
+// components/widget/index.ts:
+export * from './gallery-article/widget-gallery-article.component';
+```
+
+Register it in the widget content-type map in `components/widget/widget.component.ts`:
+
+```ts
+import { WidgetGalleryArticleComponent } from './gallery-article/widget-gallery-article.component';
+// …in the ArticleWidgetType → component map:
+[ArticleWidgetType.GALLERY_ARTICLE]: WidgetGalleryArticleComponent,
+```
+
+The widget container renders sub-widgets via `NgComponentOutlet`, so the gallery widget goes in the
+type-map only — it does **not** go in the container's `imports` array.
+
+## Verify
+
+`scripts/verify-module.sh <workspace> <PREFIX> <name>` checks the module's `<name>-grid-item` and
+`<name>-list-item` exist and are exported from the components barrel.

package/plugins/mobilems/skills/mobilems-articles/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.
+#
+# 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-articles/scripts/verify-module.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+#
+# verify-module.sh <workspace-root> <PREFIX> <name> [template]
+#
+# Post-condition check for one article module named <name>: library created, ArticlesSharedModule
+# .forFeature wired (with the template value if given), route registered, and the module's article
+# card shared components built + exported.
+set -eu
+
+ROOT="${1:?usage: verify-module.sh <workspace-root> <PREFIX> <name> [template]}"
+PREFIX="${2:?usage: verify-module.sh <workspace-root> <PREFIX> <name> [template]}"
+NAME="${3:?usage: verify-module.sh <workspace-root> <PREFIX> <name> [template]}"
+TEMPLATE="${4:-}"
+cd "$ROOT" 2>/dev/null || { echo "ERROR: no such dir: $ROOT" >&2; exit 2; }
+
+LIBF="museum-$NAME"
+fail=0
+pass() { echo "  PASS: $1"; }
+bad()  { echo "  FAIL: $1" >&2; fail=1; }
+info() { echo "  INFO: $1"; }
+
+echo "== Verifying article module: name=$NAME lib=$LIBF =="
+
+echo "== Library =="
+MOD="$(ls libs/$LIBF/shell/angular/src/lib/*.module.ts 2>/dev/null | head -1)"
+[ -n "$MOD" ] && pass "module file present ($MOD)" || bad "no *.module.ts in libs/$LIBF/shell/angular/src/lib"
+[ -f "libs/$LIBF/domain/src/lib/entities/index.ts" ] && pass "domain entity present" || bad "domain entity missing"
+grep -q "$LIBF/shell/angular" tsconfig.base.json && pass "tsconfig shell path added" || bad "tsconfig.base.json shell path missing"
+grep -q "$LIBF/domain" tsconfig.base.json && pass "tsconfig domain path added" || bad "tsconfig.base.json domain path missing"
+
+echo "== forFeature wiring =="
+if [ -n "$MOD" ]; then
+  grep -q "ArticlesSharedModule.forFeature" "$MOD" && pass "ArticlesSharedModule.forFeature wired" || bad "ArticlesSharedModule.forFeature missing"
+  grep -q "key: 'template'" "$MOD" && pass "baseQuery filters on key 'template'" || bad "baseQuery key 'template' missing"
+  if [ -n "$TEMPLATE" ]; then
+    grep -q "$TEMPLATE" "$MOD" && pass "template value '$TEMPLATE' present" || bad "template value '$TEMPLATE' missing"
+  fi
+  grep -q "reducerFactory" "$MOD" && info "module keeps feature state (reducerFactory present)" || info "module has no feature state"
+fi
+
+echo "== Route registration =="
+ROUTES=apps/web/src/app/app.routes.ts
+n=$(grep -c "$LIBF/shell/angular" "$ROUTES" 2>/dev/null || true)
+[ "${n:-0}" -ge 1 ] && pass "route registered ($n occurrence(s) — top-level$([ "${n:-0}" -ge 2 ] && echo ' + search child'))" || bad "route not in app.routes.ts"
+
+echo "== Article card shared components =="
+COMP=libs/shared/angular/src/lib/components
+for d in "$NAME-grid-item" "$NAME-list-item"; do
+  [ -d "$COMP/$d" ] && pass "built $d" || bad "missing $COMP/$d"
+done
+grep -q "$NAME-grid-item" "$COMP/index.ts" && pass "$NAME-grid-item exported" || bad "$NAME-grid-item export missing"
+grep -q "$NAME-list-item" "$COMP/index.ts" && pass "$NAME-list-item exported" || bad "$NAME-list-item export missing"
+
+echo "== Deps =="
+for p in articles-domain articles-shell-angular articles-shell-dtos; do
+  grep -q "@smartsoft001-mobilems/$p" package.json && pass "$p dep" || bad "$p dep missing"
+done
+
+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-events/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: mobilems-events
+description: Add the museum EVENTS feature module (wydarzenia) to a MobilEMS app initialized with mobilems-project-init. Use whenever the user wants to add / scaffold / wire the events module, the "wydarzenia" pages (event list + event detail + booking/reservation flow with confirm + cancel), event booking, event reservation, an event calendar / available-dates picker, or asks to "dodaj moduł wydarzeń / rezerwacji wydarzeń". Creates libs/museum-events (shell/angular only — a standalone booking module), registers the /wydarzenia route, and confirms the foundation packages it reuses are present. Requires the MobilEMS foundation to exist first.
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion
+---
+
+# MobilEMS events module
+
+Add the **events** (wydarzenia) feature module to a MobilEMS app whose foundation was built by
+`mobilems-project-init`. Events is a self-contained booking / reservation system: a list of events,
+an event detail page, and a reservation flow (booking form -> confirmation -> cancellation) driven by
+its own `EventsReservationService` over the event / event-periods / event-reservations API. This
+skill builds the `libs/museum-events` library and registers a single top-level `/wydarzenia` route.
+
+Events has a leaner shape than the other feature modules: a pure `RouterModule.forChild` module with
+**lazy `loadComponent` routes** and **no shared-module `forFeature`**, and it ships **only a
+`shell/angular` project** (there is no `domain` library). All of its UI and data access live inside
+its own `shell/angular`.
+
+## 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`; the reference
+MobilEMS app uses `@msr`) and the reference repo path (same one init used).
+
+## Steps
+
+1. **npm deps (precondition check)** — events imports only foundation packages:
+   `@smartsoft001-mobilems/angular`, `@smartsoft001-mobilems/models`, `@smartsoft001/angular`,
+   `@thisissoon/angular-masonry`, and `@ngx-translate/core` — all already installed by
+   `mobilems-project-init`. So this step is a CHECK: confirm those lines are in `package.json`; there
+   is nothing new to add. As a safeguard, grep the copied lib for any third-party import not in that
+   foundation set and add only what is genuinely missing. Do not `npm install` unless asked.
+2. **Library** — create `libs/museum-events/shell/angular` per `references/lib-contents.md`: copy the
+   shell (`MuseumEventsModule`, `events.routes.ts`, `pages/{list,item,booking,confirm,cancel}`,
+   `services/events-reservation.service.ts`, `models/events.models.ts`, `pipes/time-format.pipe.ts`,
+   and the `src/__mocks__/@smartsoft001-mobilems/{angular,models}.ts` jest mocks), thread `<PREFIX>`.
+   Add the single `tsconfig.base.json` path `@<PREFIX>/museum-events/shell/angular` and the
+   `museum-events` commit scope.
+3. **Module + routes** — see `references/module-and-routes.md`: `MuseumEventsModule` is just
+   `@NgModule({ imports: [RouterModule.forChild(eventsRoutes)] })`; `eventsRoutes` uses lazy
+   `loadComponent` for every page and provides the `Masonry` SSR factory on the list route. Add the
+   lazy `wydarzenia` route to the `appRoutes` array in `apps/web/src/app/app.routes.ts` as a single
+   top-level route.
+4. **Verify** — run `scripts/verify-module.sh <workspace-root> <PREFIX>`: asserts the
+   `libs/museum-events/shell/angular` lib exists with `MuseumEventsModule` (`RouterModule.forChild`)
+   and `events.routes.ts`, the `@<PREFIX>/museum-events/shell/angular` tsconfig path is added, the
+   five pages + `EventsReservationService` + `events.models.ts` + `TimeFormatPipe` are present, the
+   `wydarzenia` route is registered as a single top-level route, and the foundation deps it reuses are
+   in `package.json`. Fix and re-run.
+
+## Notes
+
+- Events is a standalone booking module: it owns its data access (`EventsReservationService` calling
+  the events API) and contributes **nothing** to `libs/shared/angular`. The shared lib stays
+  untouched.
+- Events ships **only** a `shell/angular` project — there is no `domain` library and no shared-module
+  `forFeature`; its event/reservation types live in `shell/angular/src/lib/models/events.models.ts`.
+- `/wydarzenia` is a top-level route only. Events is a booking destination, not a search result, so it
+  is NOT added under the `wyszukaj/:text` search children.
+- This skill ONLY touches the events 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`.