@smartsoft001-mobilems/claude-plugins 2.86.0 → 2.87.0

package/plugins/mobilems/skills/mobilems-project-init/scripts/classify-shared-components.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""classify-shared-components.py <shared-lib components dir>
+
+Split a MobilEMS shared-lib `components` tree into FOUNDATION shared components (mobilems-project-init
+builds these) and FEATURE-OWNED shared components (built by the owning mobilems-<module> skill,
+because they depend on a feature package).
+
+A "component" is a directory holding a non-spec *.component.ts. It is FEATURE-OWNED when it:
+  1. imports a feature package (objects/articles/public-collections/news/partners domain|shell,
+     or a @.../museum-<x> subpath), OR
+  2. imports another FEATURE-OWNED component — by relative path or by that component's exported
+     symbol (transitive, to a fixpoint).
+
+Trust this over any hand-maintained table: if the reference repo diverges, this is authoritative.
+Exit 0 on success; prints two sections (FEATURE-OWNED, FOUNDATION), one path per line, relative to <dir>.
+"""
+import os
+import re
+import sys
+
+FEATURE_RE = re.compile(
+    r"(objects|articles|public-collections|news|partners)-(domain|shell-angular|shell-dtos)"
+    r"|/museum-[a-z-]+"
+)
+EXPORT_RE = re.compile(r"export\s+(?:class|const|interface|type)\s+([A-Za-z0-9_]+)")
+IMPORT_LINE_RE = re.compile(r"^\s*import\b|from\s+['\"]")
+REL_IMPORT_RE = re.compile(r"from\s+['\"](\.\.?/[^'\"]+)['\"]")
+
+
+def unit_ts_files(unit):
+    return [
+        os.path.join(unit, f)
+        for f in os.listdir(unit)
+        if f.endswith(".ts") and not f.endswith(".spec.ts")
+    ]
+
+
+def read(files):
+    out = []
+    for f in files:
+        try:
+            with open(f, encoding="utf-8") as fh:
+                out.append(fh.read())
+        except OSError:
+            pass
+    return "\n".join(out)
+
+
+def main():
+    if len(sys.argv) != 2:
+        sys.exit("usage: classify-shared-components.py <shared-lib/src/lib/components>")
+    root = os.path.abspath(sys.argv[1])
+    if not os.path.isdir(root):
+        sys.exit(f"ERROR: not a directory: {root}")
+
+    # discover units (dirs with a non-spec *.component.ts)
+    units = sorted(
+        {
+            dirpath
+            for dirpath, _, files in os.walk(root)
+            if any(f.endswith(".component.ts") and not f.endswith(".spec.ts") for f in files)
+        }
+    )
+
+    text = {u: read(unit_ts_files(u)) for u in units}
+    imports = {u: "\n".join(l for l in text[u].splitlines() if IMPORT_LINE_RE.search(l)) for u in units}
+    exports = {
+        u: set(EXPORT_RE.findall(text[u])) for u in units
+    }
+
+    feature_owned = {u for u in units if FEATURE_RE.search(imports[u])}
+
+    changed = True
+    while changed:
+        changed = False
+        feature_owned_symbols = {}
+        for d in feature_owned:
+            for s in exports[d]:
+                feature_owned_symbols.setdefault(s, d)
+        for u in units:
+            if u in feature_owned:
+                continue
+            hit = False
+            # (a) relative import into a feature_owned unit's directory
+            for rel in REL_IMPORT_RE.findall(imports[u]):
+                target = os.path.normpath(os.path.join(u, rel))
+                if any(target == d or target.startswith(d + os.sep) for d in feature_owned):
+                    hit = True
+                    break
+            # (b) imports a symbol exported by a feature_owned unit
+            if not hit:
+                for s in feature_owned_symbols:
+                    if re.search(r"\b" + re.escape(s) + r"\b", imports[u]):
+                        hit = True
+                        break
+            if hit:
+                feature_owned.add(u)
+                changed = True
+
+    def rel(u):
+        return os.path.relpath(u, root)
+
+    print("FEATURE-OWNED:")
+    for u in units:
+        if u in feature_owned:
+            print("  " + rel(u))
+    print("FOUNDATION:")
+    for u in units:
+        if u not in feature_owned:
+            print("  " + rel(u))
+
+
+if __name__ == "__main__":
+    main()

package/plugins/mobilems/skills/mobilems-project-init/scripts/detect-base.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+#
+# detect-base.sh <workspace-root>
+#
+# Precondition gate for mobilems-project-init. Confirms the target is a scaffold-nx-workspace BASE
+# (generic Nx + Angular-SSR shell) that has NOT yet had the MobilEMS delta applied. Portable to the
+# macOS system bash (3.2) — no bash-4 features.
+#
+# Exit 0  → base detected, OK to apply the delta.
+# Exit 3  → no base shell found (tell the user to run /smart:scaffold-nx-workspace first).
+# Exit 4  → MobilEMS delta already present (init looks already applied).
+set -eu
+
+ROOT="${1:?usage: detect-base.sh <workspace-root>}"
+cd "$ROOT" 2>/dev/null || { echo "ERROR: no such dir: $ROOT" >&2; exit 2; }
+
+fail_no_base() {
+  echo "NOT A BASE: $1" >&2
+  echo "Run /smart:scaffold-nx-workspace first to create the generic Nx + Angular-SSR shell." >&2
+  exit 3
+}
+
+# --- base shell signals ---
+[ -f apps/web/src/server.ts ]            || fail_no_base "apps/web/src/server.ts missing"
+[ -f apps/web/src/app/app.config.ts ]    || fail_no_base "apps/web/src/app/app.config.ts missing"
+[ -f apps/web/src/app/app.routes.ts ]    || fail_no_base "apps/web/src/app/app.routes.ts missing"
+[ -f libs/shared/angular/src/index.ts ]  || fail_no_base "libs/shared/angular/src/index.ts missing"
+[ -f tsconfig.base.json ]                || fail_no_base "tsconfig.base.json missing"
+
+# base app.routes.ts has no feature loadChildren yet
+if grep -qE "loadChildren" apps/web/src/app/app.routes.ts; then
+  echo "WARNING: app.routes.ts already has loadChildren — base may already be extended." >&2
+fi
+
+# --- already-applied signals (any one → likely already MobilEMS) ---
+applied=0
+[ -f tailwind.config.js ] && grep -q "smart-" tailwind.config.js 2>/dev/null && applied=1
+grep -q "@smartsoft001-mobilems/angular" package.json 2>/dev/null && applied=1
+[ -d libs/museum-objects ] && applied=1
+if [ "$applied" = 1 ]; then
+  echo "ALREADY APPLIED: MobilEMS signals found (tailwind smart- prefix / mobilems dep / libs/museum-*)." >&2
+  echo "If you meant to re-run, revert the delta first." >&2
+  exit 4
+fi
+
+# --- report the detected prefix (from the single tsconfig path) ---
+PREFIX="$(grep -oE '@[a-z0-9-]+/angular' tsconfig.base.json | head -1 | sed -E 's#@([a-z0-9-]+)/angular#\1#')"
+echo "BASE OK. Detected prefix: ${PREFIX:-<unknown — inspect tsconfig.base.json paths>}"
+exit 0

package/plugins/mobilems/skills/mobilems-project-init/scripts/verify-init.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+#
+# verify-init.sh <workspace-root> <PREFIX>
+#
+# Post-condition check for mobilems-project-init. Asserts the MobilEMS delta landed AND the hard
+# foundation is self-contained (no feature modules / no feature routes / shared lib imports no
+# feature package).
+# Portable to macOS system bash (3.2). Exit 0 = all pass; exit 1 = one or more checks failed.
+set -eu
+
+ROOT="${1:?usage: verify-init.sh <workspace-root> <PREFIX>}"
+PREFIX="${2:?usage: verify-init.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; }
+
+echo "== Delta applied =="
+[ -f tailwind.config.js ] && grep -q "prefix: 'smart-'" tailwind.config.js && pass "tailwind smart- prefix" || bad "tailwind.config.js with smart- prefix"
+grep -q "@smartsoft001-mobilems/angular" package.json && pass "mobilems framework dep" || bad "@smartsoft001-mobilems/angular in package.json"
+grep -q "@ngrx/store" package.json && pass "ngrx dep" || bad "@ngrx/store in package.json"
+grep -q "SharedModule.forRoot" apps/web/src/app/app.config.ts && pass "SharedModule.forRoot in app.config" || bad "SharedModule.forRoot in app.config.ts"
+grep -q "SEARCH_CONFIG_TOKEN" apps/web/src/app/app.config.ts && pass "SEARCH_CONFIG_TOKEN" || bad "SEARCH_CONFIG_TOKEN in app.config.ts"
+grep -q "multimediaUrl" apps/web/src/server.ts && pass "multimediaUrl in server.ts" || bad "multimediaUrl in server.ts"
+grep -q "/api/translations" apps/web/src/server.ts && pass "/api/translations endpoint" || bad "/api/translations in server.ts"
+grep -q "./lib/components" libs/shared/angular/src/index.ts && pass "shared-lib components barrel populated" || bad "components barrel in shared-lib index.ts"
+[ -f .claude/settings.json ] && grep -q "flow@mobilems" .claude/settings.json && pass "flow@mobilems enabled" || bad "flow@mobilems in .claude/settings.json"
+
+echo "== Foundation scope (no feature modules yet) =="
+if ls -d libs/museum-* >/dev/null 2>&1; then bad "libs/museum-* present (feature modules are built by the module skills)"; else pass "no libs/museum-*"; fi
+# feature routes reference a museum-* lib; loadChildren + the import often span lines, so match museum- anywhere
+if grep -qE "museum-" apps/web/src/app/app.routes.ts; then bad "feature route (museum-*) in app.routes.ts"; else pass "no feature routes"; fi
+
+echo "== Foundation shared library is self-contained =="
+COMP=libs/shared/angular/src/lib/components
+# the widget container registers only foundation widgets (feature gallery widgets are added by module skills)
+WID="$COMP/widget/widget.component.ts"
+if [ -f "$WID" ]; then
+  if grep -qE "WidgetGalleryObjectComponent|WidgetGalleryArticleComponent" "$WID"; then
+    bad "widget container references a feature gallery widget — build it with foundation widgets only"
+  else
+    pass "widget container has foundation widgets only"
+  fi
+else
+  bad "widget container missing"
+fi
+# objects.model holds only the foundation model types (the object-specific ISpecificObject is feature code)
+OBJMODEL=libs/shared/angular/src/lib/models/objects.model.ts
+if [ -f "$OBJMODEL" ]; then
+  grep -qE "from '[^']*objects-domain'" "$OBJMODEL" && bad "objects.model imports MsObject — foundation holds only the generic types" || pass "objects.model holds foundation types only"
+  grep -qE "AdvancedFilterType|KeyValue" "$OBJMODEL" && pass "foundation model types present" || bad "foundation model types missing from objects.model.ts"
+fi
+
+echo "== Build-safety invariant: shared lib imports no feature package =="
+LEAK="$(grep -rlnE "from '@[^']*/(objects|articles|public-collections)-(domain|shell-angular|shell-dtos)'" libs/shared/angular/src 2>/dev/null || true)"
+if [ -n "$LEAK" ]; then
+  bad "shared lib still imports a feature package — foundation will not build without it:"
+  printf '        %s\n' $LEAK >&2
+else
+  pass "shared lib imports no feature package"
+fi
+
+echo "== Prefix threaded =="
+if grep -rq "@msr/" libs/shared/angular/src apps/web/src 2>/dev/null && [ "$PREFIX" != "msr" ]; then
+  bad "stray @msr/ imports (prefix not fully threaded to @$PREFIX/)"
+else
+  pass "no stray reference-prefix imports"
+fi
+
+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-thematic-publications/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: mobilems-thematic-publications
+description: Add the museum THEMATIC PATHS / PUBLICATIONS feature module (ścieżki tematyczne) to a MobilEMS app initialized with mobilems-project-init. Use whenever the user wants to add / scaffold / wire the thematic paths / thematic publications module, the "ścieżki tematyczne" pages (list + paged publication reader with widgets), or asks to "dodaj moduł ścieżek tematycznych / publikacji tematycznych". Creates libs/museum-thematic-paths (domain + shell/angular), registers the /sciezki-tematyczne route, and adds the Articles npm packages it reuses. Requires the MobilEMS foundation to exist first.
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion
+---
+
+# MobilEMS thematic paths / publications module
+
+Add the **thematic paths / publications** (ścieżki tematyczne) feature module on top of a MobilEMS
+foundation produced by `mobilems-project-init`. This module's entire UI lives inside its own
+`libs/museum-thematic-paths` library, so this skill builds that library and registers a single
+top-level route.
+
+> **Naming heads-up.** This skill is named _thematic-publications_ (the museum-domain term users say),
+> but the artifact it generates is **thematic-paths**: folder `libs/museum-thematic-paths`, class
+> `MuseumThematicPathsModule`, route `sciezki-tematyczne`, entity `'thematicPaths'`. Always emit the
+> _thematic-paths_ names — "publications" is only the spoken alias.
+
+The module is a list/detail feature where each entry is a multi-page publication: a `ListComponent`
+of thematic paths plus an `ItemComponent` that renders a paged reader (intro, menu, page, widgets —
+page-header, text, image, video, audio, image-gallery) backed by `ArticlesSharedModule.forFeature`
+over the `MuseumThematicPath` entity. It REUSES the Articles shared module (like news) but with its
+OWN domain entity, 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`).
+   Match the installed mobilems line; resolve versions at run time; do not `npm install` unless
+   asked. Adding is idempotent — if `mobilems-articles` already installed these, nothing changes.
+2. **Library** — create `libs/museum-thematic-paths/{domain,shell/angular}` per
+   `references/lib-contents.md`: copy the domain entity/interfaces/enums and the shell
+   (`MuseumThematicPathsModule`, routes, `+state/*`, `components/*`, `pages/{list,item}`, `services`,
+   `directives`), thread `<PREFIX>`. Add the two `tsconfig.base.json` paths and the
+   `museum-thematic-paths` commit scope.
+3. **Module + routes** — see `references/module-and-routes.md`: `MuseumThematicPathsModule` wraps
+   `ArticlesSharedModule.forFeature({ routing: false, config: { reducerFactory: getReducer, type: MuseumThematicPath, apiUrl, entity: 'thematicPaths' } })`
+   (note: **no baseQuery**) with the `Masonry` SSR factory and provides `ThematicPathsFacade` +
+   `SERVICES`. Add the lazy `sciezki-tematyczne` 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 lib + entity
+   exist, the tsconfig path is added, `ArticlesSharedModule.forFeature` is wired with
+   `entity: 'thematicPaths'` + `MuseumThematicPath` + `reducerFactory`, `ThematicPathsFacade` is
+   provided, the `+state` files are present, the `sciezki-tematyczne` route is registered as a single
+   top-level route, and the three Articles deps are in `package.json`. Fix and re-run.
+
+## Notes
+
+- This skill ONLY touches the thematic-paths 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-thematic-publications/references/lib-contents.md

@@ -0,0 +1,134 @@
+# libs/museum-thematic-paths — structure to create
+
+Copy from the reference repo's `libs/museum-thematic-paths` and thread `<PREFIX>`. The lib has two
+projects: a `domain` (entity/interfaces/enums) and a `shell/angular` (the Angular module + NgRx
+`+state` + UI).
+
+```
+libs/museum-thematic-paths/
+├── domain/                              # project: museum-thematic-paths-domain
+│   ├── package.json                     # "name": "museum-thematic-paths-domain"
+│   └── src/
+│       ├── index.ts                     # export * from './lib/entities'; './lib/enums'; './lib/interfaces';
+│       ├── features.ts                  # export const DOMAIN_SERVICES = [];
+│       └── lib/
+│           ├── entities/                # MuseumThematicPath (+ index)
+│           ├── enums/                   # WidgetType enum (+ index)
+│           └── interfaces.ts            # IThematicPath, IPage, IMenu, IImageFile, ICopyright, IDictionaryEntity, …
+└── shell/angular/                       # project: museum-thematic-paths-shell-angular
+    └── src/
+        ├── index.ts                     # export * from './lib/pages'; export * from './lib/thematic-paths.module';
+        └── lib/
+            ├── thematic-paths.module.ts # MuseumThematicPathsModule (references/module-and-routes.md)
+            ├── thematic-paths.routes.ts
+            ├── +state/                  # thematic-paths.facade.ts (ThematicPathsFacade), thematic-paths.reducer.ts (getReducer), thematic-paths.selectors.ts
+            ├── components/              # intro, main, menu, page, show-widgets, list-item, filters,
+            │                            #   widgets/{page-header,text,image,video,audio,image-gallery/*} (+ index)
+            ├── directives/             # scroll-intersection.directive.ts (+ .spec)
+            ├── pages/                   # list (ListComponent), item (ItemComponent) + index
+            └── services/               # thematic-paths.service.ts + index (SERVICES)
+```
+
+> There is **no `src/__mocks__/` dir** in this lib (objects had one; thematic-paths does not). Copy
+> only what the reference has.
+
+## Domain entity (verbatim — thread nothing; pure types)
+
+Unlike objects' `MuseumObject extends MsObject`, this entity `implements` the local interfaces — it
+does NOT extend a feature base class:
+
+```ts
+import { IEntity } from '@smartsoft001/domain-core';
+import { Field, Model } from '@smartsoft001/models';
+
+import {
+  ICopyright,
+  IDictionaryEntity,
+  IImageFile,
+  IMenu,
+  IThematicPath,
+} from '../interfaces';
+
+@Model({})
+export class MuseumThematicPath implements IEntity<any>, IThematicPath {
+  id!: any;
+
+  @Field() title!: string;
+  @Field() textColor!: string;
+  @Field() subTitle!: string;
+  @Field() shortDescription!: string;
+  @Field() author!: string;
+  @Field() backgroundColor!: string;
+  @Field() backgroundColorEnabled!: boolean;
+  @Field() backgroundImage!: IImageFile | null;
+  @Field() copyright!: ICopyright;
+  @Field() cycles!: IDictionaryEntity[];
+  @Field() image?: IImageFile;
+  @Field() keywords!: IDictionaryEntity[];
+  @Field() landingPageEnabled!: boolean;
+  @Field() menuBackgroundColor!: string;
+  @Field() menuBackgroundImage!: string;
+  @Field() menuType!: 'vertical' | 'horizontal';
+  @Field() publicationDate!: string;
+  @Field() sections!: IMenu[];
+}
+```
+
+Copy `domain/src/lib/interfaces.ts` verbatim (defines `IThematicPath`, `IPage`, `IMenu`, `IImageFile`,
+`ICopyright`, `IDictionaryEntity`, and the page/widget shapes the reducer + components consume) and
+`domain/src/lib/enums/index.ts` (`WidgetType`).
+
+## Shell `+state` (NgRx — copy verbatim, thread `<PREFIX>`)
+
+- `thematic-paths.reducer.ts` exports `getReducer()` — wraps `@smartsoft001/crud-shell-angular`'s
+  `getReducer('thematicPaths')` and adds thematic-specific cases (page loading, page desc, menu
+  display, widget id, etc.). This is the function passed as `reducerFactory` in the module config.
+- `thematic-paths.facade.ts` exports `ThematicPathsFacade extends CrudFacade<MuseumThematicPath>`
+  with the paged-reader actions (`loadPage`, `loadPageDesc`, `setPage`, `setWidget`,
+  `setMenuDisplay`, `openPageDesc`) and signal accessors.
+- `thematic-paths.selectors.ts` — the `getThematic*` selectors the facade reads.
+
+## Services — `services/index.ts` exports a `SERVICES` array (copy verbatim)
+
+The service extends `CrudBaseService` and 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 { ThematicPathsService } from './thematic-paths.service';
+
+export * from './thematic-paths.service';
+
+export const SERVICES = [
+  ThematicPathsService,
+  { provide: CrudService, useClass: ThematicPathsService },
+  { provide: ArticlesService, useClass: ThematicPathsService },
+];
+```
+
+`ThematicPathsService extends CrudBaseService<MuseumThematicPath>` (from
+`@smartsoft001-mobilems/angular`) and adds `getPage`/`getPageDesc` for the paged reader.
+
+## Wiring
+
+- **tsconfig.base.json paths** (add both):
+  ```json
+  "@<PREFIX>/museum-thematic-paths/domain": ["libs/museum-thematic-paths/domain/src/index.ts"],
+  "@<PREFIX>/museum-thematic-paths/shell/angular": ["libs/museum-thematic-paths/shell/angular/src/index.ts"]
+  ```
+- **project.json / build config** — copy each project's config (names `museum-thematic-paths-domain`,
+  `museum-thematic-paths-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-thematic-paths/...`. 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. 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-thematic-paths`
+  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 (see SKILL.md step 1). It does NOT need `online-3d-viewer`; `leaflet`/`openseadragon`/
+`swiper` are foundation deps used by the gallery widgets if present.

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

@@ -0,0 +1,107 @@
+# MuseumThematicPathsModule + route registration
+
+## `libs/museum-thematic-paths/shell/angular/src/lib/thematic-paths.module.ts`
+
+Thread `<PREFIX>` (the `environment` + domain imports). This module REUSES `ArticlesSharedModule`
+(the same shared module the news/articles modules use) but configures it over its OWN
+`MuseumThematicPath` entity 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).
+
+```ts
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { SharedModule as SmartSharedModule } from '@smartsoft001/angular';
+import { ArticlesSharedModule } from '@smartsoft001-mobilems/articles-shell-angular';
+import { Masonry } from '@thisissoon/angular-masonry';
+
+import { environment } from '@<PREFIX>/angular';
+import { MuseumThematicPath } from '@<PREFIX>/museum-thematic-paths/domain';
+
+import { ThematicPathsFacade } from './+state/thematic-paths.facade';
+import { getReducer } from './+state/thematic-paths.reducer';
+import { SERVICES } from './services';
+import { routes } from './thematic-paths.routes';
+
+@NgModule({
+  providers: [
+    ThematicPathsFacade,
+    ...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,
+    SmartSharedModule,
+    ArticlesSharedModule.forFeature({
+      routing: false,
+      config: {
+        reducerFactory: getReducer,
+        type: MuseumThematicPath,
+        apiUrl: environment.apiUrl,
+        entity: 'thematicPaths',
+      },
+    }),
+    RouterModule.forChild(routes),
+  ],
+})
+export class MuseumThematicPathsModule {}
+```
+
+> Contrast with `mobilems-objects` (`ObjectsSharedModule.forFeature` over `MsObject`, no
+> `reducerFactory`): here the module reuses `ArticlesSharedModule`, supplies `reducerFactory: getReducer`,
+> and there is deliberately **no `baseQuery`** in the config.
+
+## `thematic-paths.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`
+
+This module registers a single **top-level** route. Add the `sciezki-tematyczne` route to the
+`appRoutes` array (idempotently — if a `sciezki-tematyczne` route already exists, skip). It is a
+content publication browsed from the top level, so it is NOT added under the `wyszukaj/:text` search
+route — thematic-paths does not appear in the search results.
+
+Top-level — add to `appRoutes`:
+
+```ts
+  {
+    path: 'sciezki-tematyczne',
+    loadChildren: () =>
+      import('@<PREFIX>/museum-thematic-paths/shell/angular').then(
+        (m) => m.MuseumThematicPathsModule,
+      ),
+  },
+```

package/plugins/mobilems/skills/mobilems-thematic-publications/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-thematic-publications/scripts/verify-module.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+#
+# verify-module.sh <workspace-root> <PREFIX>
+#
+# Post-condition check for mobilems-thematic-publications: library created, ArticlesSharedModule
+# wired over MuseumThematicPath with its own reducer, facade + +state present, the
+# sciezki-tematyczne route registered as a single top-level route, and the Articles 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-thematic-paths/shell/angular/src/lib/thematic-paths.module.ts
+
+echo "== Library =="
+[ -f "$MOD" ] && pass "MuseumThematicPathsModule present" || bad "thematic-paths.module.ts missing"
+[ -f libs/museum-thematic-paths/domain/src/lib/entities/museum-thematic-path.entity.ts ] && pass "MuseumThematicPath entity present" || bad "domain entity missing"
+grep -q "class MuseumThematicPath" libs/museum-thematic-paths/domain/src/lib/entities/museum-thematic-path.entity.ts 2>/dev/null && pass "MuseumThematicPath class declared" || bad "MuseumThematicPath class not declared"
+grep -q "museum-thematic-paths/shell/angular" tsconfig.base.json && pass "tsconfig shell path added" || bad "tsconfig shell path missing"
+grep -q "museum-thematic-paths/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: 'thematicPaths'" "$MOD" 2>/dev/null && pass "entity 'thematicPaths' configured" || bad "entity 'thematicPaths' missing"
+grep -q "type: MuseumThematicPath" "$MOD" 2>/dev/null && pass "type MuseumThematicPath configured" || bad "type MuseumThematicPath missing"
+grep -q "reducerFactory: getReducer" "$MOD" 2>/dev/null && pass "reducerFactory: getReducer configured" || bad "reducerFactory: getReducer missing"
+grep -q "ThematicPathsFacade" "$MOD" 2>/dev/null && pass "ThematicPathsFacade provided" || bad "ThematicPathsFacade not provided"
+
+echo "== +state =="
+STATE=libs/museum-thematic-paths/shell/angular/src/lib/+state
+[ -f "$STATE/thematic-paths.facade.ts" ] && pass "facade present" || bad "thematic-paths.facade.ts missing"
+[ -f "$STATE/thematic-paths.reducer.ts" ] && pass "reducer present" || bad "thematic-paths.reducer.ts missing"
+grep -q "export function getReducer" "$STATE/thematic-paths.reducer.ts" 2>/dev/null && pass "getReducer exported" || bad "getReducer not exported in reducer"
+
+echo "== Route registration =="
+ROUTES=apps/web/src/app/app.routes.ts
+grep -q "museum-thematic-paths/shell/angular" "$ROUTES" && pass "thematic-paths route registered" || bad "thematic-paths route not in app.routes.ts"
+# single top-level route — expect exactly 1 occurrence
+n=$(grep -c "museum-thematic-paths/shell/angular" "$ROUTES" || true)
+[ "${n:-0}" -eq 1 ] && pass "registered as a single top-level route ($n)" || bad "expected exactly 1 route registration, found $n"
+grep -q "sciezki-tematyczne" "$ROUTES" && pass "sciezki-tematyczne path present" || bad "sciezki-tematyczne 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"
+
+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"