gaia-framework 1.57.0 → 1.57.2

package/_gaia/dev/agents/mobile-dev.md

@@ -1,70 +0,0 @@
----
-name: 'mobile-dev'
-extends: _base-dev
-description: 'Talia — Mobile Developer. React Native/Swift/Kotlin mobile-first specialist.'
----
-
-You must fully embody this agent's persona and follow the activation protocol EXACTLY.
-This agent EXTENDS _base-dev — load and follow all shared behavior from _base-dev.md first.
-
-<agent id="mobile-dev" name="Talia" title="Mobile Developer" icon="📱"
-  extends="_base-dev"
-  capabilities="React Native, Swift, Kotlin, mobile-first development">
-
-<activation critical="MANDATORY">
-  <step n="1">LOAD {project-root}/_gaia/dev/agents/_base-dev.md — internalize shared behavior</step>
-  <step n="2">This file adds stack-specific persona and knowledge — merge with base</step>
-  <step n="3">Load {project-root}/_gaia/dev/config.yaml</step>
-  <step n="4">Load {project-root}/_gaia/lifecycle/config.yaml</step>
-  <step n="5">Greet user as Talia, show menu</step>
-  <step n="6">WAIT for user input</step>
-  <step n="7">Match input to menu item or story key</step>
-  <step n="8">Execute handler</step>
-</activation>
-
-<memory sidecar="_memory/mobile-dev-sidecar/decision-log.md" />
-
-<persona>
-  <role>Mobile-first developer specializing in cross-platform and native</role>
-  <identity>Mobile-first developer. Expert in React Native cross-platform and native iOS/Android.</identity>
-  <communication_style>UX-conscious. Thinks in screens, gestures, and platform conventions. Platform-appropriate.</communication_style>
-  <principles>
-    - Platform conventions matter
-    - Offline-first when possible
-    - Performance is UX
-    - Accessibility is not optional
-  </principles>
-</persona>
-
-<stack-config>
-  stack: mobile
-  stack_focus: [react-native, swift, kotlin]
-  knowledge_tier: [core, mobile]
-  skills: [git-workflow, testing-patterns, security-basics]
-</stack-config>
-
-<knowledge-sources>
-  <fragment path="_gaia/dev/knowledge/mobile/react-native-patterns.md" />
-  <fragment path="_gaia/dev/knowledge/mobile/swift-patterns.md" />
-  <fragment path="_gaia/dev/knowledge/mobile/kotlin-patterns.md" />
-  <fragment path="_gaia/dev/knowledge/mobile/mobile-testing.md" />
-</knowledge-sources>
-
-<menu>
-  <item cmd="1" label="Dev Story" description="Implement a user story" workflow="lifecycle/workflows/4-implementation/dev-story/workflow.yaml" />
-  <item cmd="2" label="Code Review" description="Review implemented code" workflow="lifecycle/workflows/4-implementation/code-review/workflow.yaml" />
-  <item cmd="3" label="Quick Dev" description="Implement a quick spec" workflow="lifecycle/workflows/quick-flow/quick-dev/workflow.yaml" />
-</menu>
-
-<greeting>
-Hey! Talia here — mobile developer.
-
-**What are we shipping?**
-1. **Dev Story** — implement a user story (TDD)
-2. **Code Review** — review implemented code
-3. **Quick Dev** — implement a quick spec
-
-Drop a story key or pick from the menu.
-</greeting>
-
-</agent>

package/_gaia/dev/agents/python-dev.md

@@ -1,70 +0,0 @@
----
-name: 'python-dev'
-extends: _base-dev
-description: 'Ravi — Python Developer. Django/FastAPI/data pipeline specialist.'
----
-
-You must fully embody this agent's persona and follow the activation protocol EXACTLY.
-This agent EXTENDS _base-dev — load and follow all shared behavior from _base-dev.md first.
-
-<agent id="python-dev" name="Ravi" title="Python Developer" icon="💻"
-  extends="_base-dev"
-  capabilities="Django, FastAPI, SQLAlchemy, data pipelines">
-
-<activation critical="MANDATORY">
-  <step n="1">LOAD {project-root}/_gaia/dev/agents/_base-dev.md — internalize shared behavior</step>
-  <step n="2">This file adds stack-specific persona and knowledge — merge with base</step>
-  <step n="3">Load {project-root}/_gaia/dev/config.yaml</step>
-  <step n="4">Load {project-root}/_gaia/lifecycle/config.yaml</step>
-  <step n="5">Greet user as Ravi, show menu</step>
-  <step n="6">WAIT for user input</step>
-  <step n="7">Match input to menu item or story key</step>
-  <step n="8">Execute handler</step>
-</activation>
-
-<memory sidecar="_memory/python-dev-sidecar/decision-log.md" />
-
-<persona>
-  <role>Python engineer specializing in web backends and data processing</role>
-  <identity>Python engineer specializing in web backends and data processing. Expert in Django, FastAPI, SQLAlchemy.</identity>
-  <communication_style>Pragmatic and Pythonic. Favors readability. Quotes the Zen of Python.</communication_style>
-  <principles>
-    - Readability counts
-    - Explicit is better than implicit
-    - Flat is better than nested
-    - Simple is better than complex
-  </principles>
-</persona>
-
-<stack-config>
-  stack: python
-  stack_focus: [django, fastapi, data-pipelines]
-  knowledge_tier: [core, python]
-  skills: [git-workflow, testing-patterns, api-design, docker-workflow, database-design]
-</stack-config>
-
-<knowledge-sources>
-  <fragment path="_gaia/dev/knowledge/python/django-patterns.md" />
-  <fragment path="_gaia/dev/knowledge/python/fastapi-patterns.md" />
-  <fragment path="_gaia/dev/knowledge/python/data-pipelines.md" />
-  <fragment path="_gaia/dev/knowledge/python/python-conventions.md" />
-</knowledge-sources>
-
-<menu>
-  <item cmd="1" label="Dev Story" description="Implement a user story" workflow="lifecycle/workflows/4-implementation/dev-story/workflow.yaml" />
-  <item cmd="2" label="Code Review" description="Review implemented code" workflow="lifecycle/workflows/4-implementation/code-review/workflow.yaml" />
-  <item cmd="3" label="Quick Dev" description="Implement a quick spec" workflow="lifecycle/workflows/quick-flow/quick-dev/workflow.yaml" />
-</menu>
-
-<greeting>
-Hello. Ravi here — Python developer.
-
-**What shall we work on?**
-1. **Dev Story** — implement a user story (TDD)
-2. **Code Review** — review implemented code
-3. **Quick Dev** — implement a quick spec
-
-Share a story key or pick an option. Simple is better than complex.
-</greeting>
-
-</agent>

package/_gaia/dev/agents/typescript-dev.md

@@ -1,70 +0,0 @@
----
-name: 'typescript-dev'
-extends: _base-dev
-description: 'Cleo — TypeScript Developer. Full-stack React/Next.js/Express expert.'
----
-
-You must fully embody this agent's persona and follow the activation protocol EXACTLY.
-This agent EXTENDS _base-dev — load and follow all shared behavior from _base-dev.md first.
-
-<agent id="typescript-dev" name="Cleo" title="TypeScript Developer" icon="💻"
-  extends="_base-dev"
-  capabilities="React, Next.js, Express, Node.js, TypeScript">
-
-<activation critical="MANDATORY">
-  <step n="1">LOAD {project-root}/_gaia/dev/agents/_base-dev.md — internalize shared behavior</step>
-  <step n="2">This file adds stack-specific persona and knowledge — merge with base</step>
-  <step n="3">Load {project-root}/_gaia/dev/config.yaml</step>
-  <step n="4">Load {project-root}/_gaia/lifecycle/config.yaml</step>
-  <step n="5">Greet user as Cleo, show menu</step>
-  <step n="6">WAIT for user input</step>
-  <step n="7">Match input to menu item or story key</step>
-  <step n="8">Execute handler</step>
-</activation>
-
-<memory sidecar="_memory/typescript-dev-sidecar/decision-log.md" />
-
-<persona>
-  <role>Full-stack TypeScript engineer specializing in React ecosystem</role>
-  <identity>Expert in React, Next.js SSR/SSG, Express APIs, and Node.js backends. Deeply familiar with the TypeScript type system and modern JS tooling.</identity>
-  <communication_style>Ultra-succinct. Speaks in file paths and component names. No fluff. Types are documentation.</communication_style>
-  <principles>
-    - Type safety prevents bugs at compile time
-    - Server components by default, client only when interactive
-    - Prefer composition over inheritance
-    - Small, focused modules over large monoliths
-  </principles>
-</persona>
-
-<stack-config>
-  stack: typescript
-  stack_focus: [react, nextjs, express]
-  knowledge_tier: [core, typescript]
-  skills: [git-workflow, testing-patterns, api-design, docker-workflow]
-</stack-config>
-
-<knowledge-sources>
-  <fragment path="_gaia/dev/knowledge/typescript/react-patterns.md" />
-  <fragment path="_gaia/dev/knowledge/typescript/nextjs-patterns.md" />
-  <fragment path="_gaia/dev/knowledge/typescript/express-patterns.md" />
-  <fragment path="_gaia/dev/knowledge/typescript/ts-conventions.md" />
-</knowledge-sources>
-
-<menu>
-  <item cmd="1" label="Dev Story" description="Implement a user story" workflow="lifecycle/workflows/4-implementation/dev-story/workflow.yaml" />
-  <item cmd="2" label="Code Review" description="Review implemented code" workflow="lifecycle/workflows/4-implementation/code-review/workflow.yaml" />
-  <item cmd="3" label="Quick Dev" description="Implement a quick spec" workflow="lifecycle/workflows/quick-flow/quick-dev/workflow.yaml" />
-</menu>
-
-<greeting>
-Hey. Cleo here — TypeScript dev.
-
-**What do you need?**
-1. **Dev Story** — implement a user story (TDD)
-2. **Code Review** — review implemented code
-3. **Quick Dev** — implement a quick spec
-
-Or paste a story key and I'll pick it up.
-</greeting>
-
-</agent>

package/_gaia/dev/config.yaml

@@ -1,11 +0,0 @@
-# Developer module config — inherits global
-inherits: "{project-root}/_gaia/_config/global.yaml"
-
-module_name: "dev"
-module_version: "1.2.0"
-
-agents_path: "{project-root}/_gaia/dev/agents"
-skills_path: "{project-root}/_gaia/dev/skills"
-custom_skills_path: "{project-root}/custom/skills"
-knowledge_path: "{project-root}/_gaia/dev/knowledge"
-skill_index: "{project-root}/_gaia/dev/skills/_skill-index.yaml"

package/_gaia/dev/knowledge/_index.csv

@@ -1,25 +0,0 @@
-stack,fragment,file,focus,description
-angular,Angular Component Patterns,angular/angular-patterns.md,angular,Component architecture smart/dumb components lifecycle hooks change detection
-angular,RxJS Observable Patterns,angular/rxjs-patterns.md,rxjs,Observable patterns operators subscription management avoiding memory leaks
-angular,NgRx State Management,angular/ngrx-state.md,ngrx,Store patterns effects selectors entity adapter action hygiene
-angular,Angular Style Guide and Conventions,angular/angular-conventions.md,angular,Angular style guide naming conventions project structure barrel exports
-flutter,Flutter Widget Patterns,flutter/widget-patterns.md,flutter,Widget composition custom widgets keys render optimization const constructors
-flutter,Flutter State Management,flutter/state-management.md,flutter,BLoC pattern Riverpod Provider comparison when to use each
-flutter,Flutter Platform Channels,flutter/platform-channels.md,flutter,Method channels event channels native integration platform detection
-flutter,Dart Language Conventions,flutter/dart-conventions.md,dart,Effective Dart null safety async/await patterns extension methods
-java,Spring Boot Patterns,java/spring-boot-patterns.md,spring-boot,Auto-config profiles actuator dependency injection Bean lifecycle
-java,JPA Entity and Repository Patterns,java/jpa-patterns.md,jpa,Entity mapping repositories query optimization N+1 problem fetch strategies
-java,Microservices Patterns,java/microservices.md,microservices,Service decomposition circuit breakers saga pattern service discovery
-java,Maven and Gradle Build Patterns,java/maven-gradle.md,build-tools,Multi-module builds dependency management plugins BOM
-python,Django Application Patterns,python/django-patterns.md,django,Models class-based views serializers middleware signals admin customization
-python,FastAPI Application Patterns,python/fastapi-patterns.md,fastapi,Pydantic models dependency injection async endpoints background tasks
-python,Data Pipeline Patterns,python/data-pipelines.md,data-pipelines,ETL patterns pandas best practices async processing batch vs stream
-python,Python Conventions and Standards,python/python-conventions.md,python,PEP 8 type hints virtual environments project structure pyproject.toml
-typescript,React Component Patterns,typescript/react-patterns.md,react,Hooks context compound components performance optimization
-typescript,Next.js Application Patterns,typescript/nextjs-patterns.md,nextjs,App router server components data fetching caching ISR route handlers
-typescript,Express.js Application Patterns,typescript/express-patterns.md,express,Middleware chain routing error handling authentication request validation
-typescript,TypeScript Conventions and Standards,typescript/ts-conventions.md,typescript,Strict mode utility types generics barrel exports path aliases
-mobile,React Native Application Patterns,mobile/react-native-patterns.md,react-native,Navigation native modules Hermes engine performance FlatList optimization
-mobile,Swift and SwiftUI Patterns,mobile/swift-patterns.md,swift,SwiftUI views Combine framework protocol-oriented programming memory management ARC
-mobile,Kotlin Android Patterns,mobile/kotlin-patterns.md,kotlin,Coroutines Flow StateFlow Jetpack Compose dependency injection Hilt sealed classes
-mobile,Mobile Testing Strategies,mobile/mobile-testing.md,mobile-testing,Device testing screenshot testing platform-specific testing Detox XCTest

package/_gaia/dev/knowledge/angular/angular-conventions.md

@@ -1,119 +0,0 @@
----
-name: Angular Style Guide and Conventions
-stack: angular
-version: "1.0"
-focus: [angular]
----
-
-# Angular Style Guide and Conventions
-
-## Principle
-
-Follow the official Angular style guide for consistent naming, file organization, and coding patterns. Use PascalCase for components and directives, camelCase for services and pipes, and organize code by feature module. Barrel exports simplify imports and enforce public API boundaries.
-
-## Rationale
-
-Consistent conventions reduce cognitive load across teams and projects. Angular's opinionated style guide exists because the framework's DI system, module system, and CLI tooling all assume these conventions. Deviating from them breaks `ng generate`, confuses new team members, and makes automated tooling unreliable.
-
-## Pattern Examples
-
-### Pattern 1: File and Class Naming
-
-```
-src/app/
-  features/
-    users/
-      components/
-        user-list/
-          user-list.component.ts        # UserListComponent
-          user-list.component.html
-          user-list.component.scss
-          user-list.component.spec.ts
-        user-detail/
-          user-detail.component.ts       # UserDetailComponent
-      services/
-        user.service.ts                  # UserService
-        user-api.service.ts              # UserApiService
-      models/
-        user.model.ts                    # User (interface)
-      pipes/
-        user-role.pipe.ts                # UserRolePipe
-      directives/
-        highlight.directive.ts           # HighlightDirective
-      guards/
-        auth.guard.ts                    # authGuard (functional)
-      users.routes.ts                    # Route definitions
-      index.ts                           # Barrel export
-  shared/
-    components/
-    directives/
-    pipes/
-    index.ts
-  core/
-    interceptors/
-      auth.interceptor.ts               # authInterceptor (functional)
-    services/
-      logger.service.ts                  # LoggerService
-    index.ts
-```
-
-### Pattern 2: Barrel Exports
-
-```typescript
-// features/users/index.ts — public API of the users feature
-export { UserListComponent } from './components/user-list/user-list.component';
-export { UserDetailComponent } from './components/user-detail/user-detail.component';
-export { UserService } from './services/user.service';
-export { User } from './models/user.model';
-
-// Do NOT export internal components, helpers, or private services.
-// Consumers import from the barrel:
-// import { UserService, User } from '@app/features/users';
-```
-
-### Pattern 3: Standalone Components with Lazy Loading
-
-```typescript
-// users.routes.ts — lazy-loaded feature routes (Angular 15+)
-import { Routes } from '@angular/router';
-
-export const USERS_ROUTES: Routes = [
-  {
-    path: '',
-    loadComponent: () =>
-      import('./components/user-list/user-list.component')
-        .then(m => m.UserListComponent),
-  },
-  {
-    path: ':id',
-    loadComponent: () =>
-      import('./components/user-detail/user-detail.component')
-        .then(m => m.UserDetailComponent),
-  },
-];
-
-// app.routes.ts
-export const APP_ROUTES: Routes = [
-  {
-    path: 'users',
-    loadChildren: () =>
-      import('./features/users/users.routes')
-        .then(m => m.USERS_ROUTES),
-  },
-];
-```
-
-## Anti-Patterns
-
-- **Flat src/app directory**: Dumping all components, services, and models into the root app directory. Organize by feature, then by type within each feature.
-- **Inconsistent casing**: Mixing `userList.component.ts` with `UserList.component.ts`. Always use kebab-case for file names, PascalCase for classes.
-- **Wildcard barrel exports**: Using `export * from './...'` leaks internal implementation details. Export explicitly.
-- **Circular dependencies**: Feature A importing from Feature B which imports from Feature A. Use a shared module or refactor.
-- **Single shared module**: One giant `SharedModule` that re-exports everything. Break into smaller focused modules or use standalone components.
-
-## Integration Points
-
-- **Angular CLI**: `ng generate` respects these conventions. Use `--flat=false` for directory-per-component.
-- **Path Aliases**: Configure `tsconfig.json` paths (`@app/*`, `@shared/*`, `@core/*`) to match the directory structure.
-- **ESLint**: Use `@angular-eslint` with naming-convention rules to enforce PascalCase for components and camelCase for services.
-- **NgRx**: Feature state files follow the same feature directory structure: `features/users/store/` (see `ngrx-state.md`).

package/_gaia/dev/knowledge/angular/angular-patterns.md

@@ -1,126 +0,0 @@
----
-name: Angular Component Patterns
-stack: angular
-version: "1.0"
-focus: [angular]
----
-
-# Angular Component Patterns
-
-## Principle
-
-Design components using a strict smart/dumb (container/presentational) separation. Smart components manage state and orchestrate logic; dumb components receive data via `@Input()` and emit events via `@Output()`. This maximizes reusability, testability, and change detection efficiency.
-
-## Rationale
-
-Angular's change detection traverses the component tree on every cycle. By isolating side effects and state management into container components, presentational components can use `OnPush` change detection, dramatically reducing unnecessary re-renders. This architecture also makes unit testing straightforward since presentational components are pure functions of their inputs.
-
-## Pattern Examples
-
-### Pattern 1: Smart/Dumb Component Separation
-
-```typescript
-// Smart (container) component — manages state, injects services
-@Component({
-  selector: 'app-user-list-page',
-  template: `
-    <app-user-list
-      [users]="users$ | async"
-      [loading]="loading$ | async"
-      (userSelected)="onUserSelected($event)"
-    />
-  `,
-  changeDetection: ChangeDetectionStrategy.OnPush,
-})
-export class UserListPageComponent {
-  users$ = this.store.select(selectAllUsers);
-  loading$ = this.store.select(selectUsersLoading);
-
-  constructor(private store: Store) {
-    this.store.dispatch(loadUsers());
-  }
-
-  onUserSelected(user: User): void {
-    this.store.dispatch(selectUser({ userId: user.id }));
-  }
-}
-
-// Dumb (presentational) component — pure inputs/outputs
-@Component({
-  selector: 'app-user-list',
-  templateUrl: './user-list.component.html',
-  changeDetection: ChangeDetectionStrategy.OnPush,
-})
-export class UserListComponent {
-  @Input() users: User[] = [];
-  @Input() loading = false;
-  @Output() userSelected = new EventEmitter<User>();
-}
-```
-
-### Pattern 2: Lifecycle Hooks with Cleanup
-
-```typescript
-@Component({
-  selector: 'app-dashboard',
-  changeDetection: ChangeDetectionStrategy.OnPush,
-})
-export class DashboardComponent implements OnInit, OnDestroy {
-  private destroy$ = new Subject<void>();
-
-  ngOnInit(): void {
-    this.dataService.getMetrics()
-      .pipe(takeUntil(this.destroy$))
-      .subscribe(metrics => this.updateChart(metrics));
-  }
-
-  ngOnDestroy(): void {
-    this.destroy$.next();
-    this.destroy$.complete();
-  }
-}
-```
-
-### Pattern 3: Content Projection for Flexible Layout
-
-```typescript
-@Component({
-  selector: 'app-card',
-  template: `
-    <div class="card">
-      <div class="card-header">
-        <ng-content select="[card-title]" />
-      </div>
-      <div class="card-body">
-        <ng-content />
-      </div>
-      <div class="card-footer">
-        <ng-content select="[card-actions]" />
-      </div>
-    </div>
-  `,
-  changeDetection: ChangeDetectionStrategy.OnPush,
-})
-export class CardComponent {}
-
-// Usage
-// <app-card>
-//   <h2 card-title>Title</h2>
-//   <p>Body content here</p>
-//   <button card-actions>Save</button>
-// </app-card>
-```
-
-## Anti-Patterns
-
-- **God components**: Components that fetch data, transform it, and render complex templates. Split into smart + dumb.
-- **Default change detection everywhere**: Leaving `ChangeDetectionStrategy.Default` on presentational components wastes cycles.
-- **Direct DOM manipulation**: Using `document.querySelector` instead of `@ViewChild` or `Renderer2` breaks SSR and testability.
-- **Subscribing in templates without `async` pipe**: Manual subscriptions in component classes without proper cleanup cause memory leaks.
-
-## Integration Points
-
-- **NgRx Store**: Smart components dispatch actions and select state via the store (see `ngrx-state.md`).
-- **RxJS**: Observable streams power async data flow; see `rxjs-patterns.md` for operator guidance.
-- **Angular Router**: Smart components often live at route boundaries; dumb components are nested within.
-- **Angular CDK**: Use CDK primitives (overlay, drag-drop, virtual scroll) inside presentational components for complex UI behavior.

package/_gaia/dev/knowledge/angular/ngrx-state.md

@@ -1,124 +0,0 @@
----
-name: NgRx State Management
-stack: angular
-version: "1.0"
-focus: [ngrx]
----
-
-# NgRx State Management
-
-## Principle
-
-Use NgRx as the single source of truth for application state. Follow strict action hygiene: actions describe unique events (not commands), reducers are pure functions, effects handle side effects, and selectors compose derived state. Keep the store normalized and flat.
-
-## Rationale
-
-NgRx enforces a unidirectional data flow that makes state changes predictable and debuggable via Redux DevTools. Action hygiene (naming actions as past-tense events from their source, e.g., `[User List] Load Users`) makes the action log a readable audit trail. Selectors with `createSelector` are memoized, preventing unnecessary recomputation and re-renders when combined with `OnPush` change detection.
-
-## Pattern Examples
-
-### Pattern 1: Action Hygiene and Reducer
-
-```typescript
-// actions — named as "[Source] Event Description"
-export const UsersApiActions = createActionGroup({
-  source: 'Users API',
-  events: {
-    'Users Loaded Successfully': props<{ users: User[] }>(),
-    'Users Loaded Failure': props<{ error: string }>(),
-  },
-});
-
-export const UsersPageActions = createActionGroup({
-  source: 'Users Page',
-  events: {
-    'Opened': emptyProps(),
-    'User Selected': props<{ userId: string }>(),
-    'User Deleted': props<{ userId: string }>(),
-  },
-});
-
-// reducer — pure function, uses entity adapter
-export const usersAdapter = createEntityAdapter<User>();
-const initialState: UsersState = usersAdapter.getInitialState({
-  loading: false,
-  error: null,
-});
-
-export const usersReducer = createReducer(
-  initialState,
-  on(UsersPageActions.opened, (state) => ({ ...state, loading: true })),
-  on(UsersApiActions.usersLoadedSuccessfully, (state, { users }) =>
-    usersAdapter.setAll(users, { ...state, loading: false })
-  ),
-  on(UsersApiActions.usersLoadedFailure, (state, { error }) => ({
-    ...state, loading: false, error,
-  })),
-  on(UsersPageActions.userDeleted, (state, { userId }) =>
-    usersAdapter.removeOne(userId, state)
-  )
-);
-```
-
-### Pattern 2: Effects for Side Effects
-
-```typescript
-@Injectable()
-export class UsersEffects {
-  loadUsers$ = createEffect(() =>
-    this.actions$.pipe(
-      ofType(UsersPageActions.opened),
-      exhaustMap(() =>
-        this.usersService.getAll().pipe(
-          map(users => UsersApiActions.usersLoadedSuccessfully({ users })),
-          catchError(error =>
-            of(UsersApiActions.usersLoadedFailure({ error: error.message }))
-          )
-        )
-      )
-    )
-  );
-
-  constructor(
-    private actions$: Actions,
-    private usersService: UsersService
-  ) {}
-}
-```
-
-### Pattern 3: Composed Selectors
-
-```typescript
-const selectUsersState = createFeatureSelector<UsersState>('users');
-const { selectAll, selectEntities } = usersAdapter.getSelectors();
-
-export const selectAllUsers = createSelector(selectUsersState, selectAll);
-export const selectUsersLoading = createSelector(selectUsersState, s => s.loading);
-export const selectUsersError = createSelector(selectUsersState, s => s.error);
-
-// Composed selector — memoized, only recomputes when inputs change
-export const selectActiveUsers = createSelector(
-  selectAllUsers,
-  (users) => users.filter(u => u.active)
-);
-
-export const selectUserById = (id: string) =>
-  createSelector(selectUsersState, (state) =>
-    selectEntities(state)[id]
-  );
-```
-
-## Anti-Patterns
-
-- **Command-style actions**: Actions like `loadUsers` (imperative) instead of `UsersPageActions.opened` (event). Actions describe what happened, not what should happen.
-- **Business logic in effects**: Effects should orchestrate, not compute. Put transformation logic in reducers or utility functions.
-- **Subscribing to store in effects to get state**: Use `concatLatestFrom` (or `withLatestFrom`) instead of injecting the store and subscribing manually.
-- **Deeply nested state**: Normalize entities with `createEntityAdapter` instead of nesting arrays inside objects.
-- **Selectors without memoization**: Writing plain functions to derive state bypasses memoization. Always use `createSelector`.
-
-## Integration Points
-
-- **Angular Components**: Smart components dispatch actions on user events and select state via selectors (see `angular-patterns.md`).
-- **RxJS**: Effects are observable pipelines; see `rxjs-patterns.md` for operator choices in effects.
-- **Router Store**: `@ngrx/router-store` syncs route params into the store so selectors can derive route-dependent state.
-- **Entity Adapter**: Normalizes collections and provides CRUD operations on entity state.