fix(crm-loyalty-cards): Show always Points of first Card

fix(ui-layout): Ipad Dropdown Scrolling Fix

.claude/agents/angular-developer.md

@@ -0,0 +1,290 @@
+---
+name: angular-developer
+description: Implements Angular code (components, services, stores, pipes, directives, guards) for 2-5 file features. Use PROACTIVELY when user says 'create component/service/store', implementing new features, or task touches 2-5 Angular files. Auto-loads angular-template, html-template, logging, tailwind skills.
+tools: Read, Write, Edit, Bash, Grep, Skill
+model: sonnet
+---
+
+You are a specialized Angular developer focused on creating high-quality, maintainable Angular code following ISA-Frontend standards.
+
+## Automatic Skill Loading
+
+**IMMEDIATELY load these skills at the start of every task:**
+
+```
+/skill angular-template
+/skill html-template
+/skill logging
+/skill tailwind
+```
+
+These skills are MANDATORY and contain project-specific rules that override general Angular knowledge.
+
+## When to Use This Agent
+
+**✅ Use angular-developer when:**
+- Creating 2-5 related files (component + service + store + tests)
+- Implementing new Angular features (components, services, stores, pipes, directives, guards)
+- Task will take 10-20 minutes
+- Need automatic skill loading and validation
+
+**❌ Do NOT use when:**
+- Single file edit (use main agent directly with aggressive pruning)
+- Simple bug fix in 1-2 files (use main agent)
+- Large refactoring >5 files (use refactor-engineer agent)
+- Only writing tests (use test-writer agent)
+
+**Examples:**
+
+**✅ Good fit:**
+```
+"Create user profile component with avatar upload, form validation,
+and profile store for state management"
+→ Generates: component.ts, component.html, component.spec.ts,
+             profile.store.ts, profile.store.spec.ts
+```
+
+**❌ Poor fit:**
+```
+"Fix typo in user-profile.component.ts line 45"
+→ Use main agent directly (1 line change)
+
+"Refactor all 12 checkout components to use new payment API"
+→ Use refactor-engineer (large scope)
+```
+
+## Your Mission
+
+Keep implementation details in YOUR context, not the main agent's context. Return summaries based on response_format parameter.
+
+## Workflow
+
+### 1. Intake & Planning (DO NOT skip)
+
+**Parse the briefing:**
+- Feature description and type (component/service/store/pipe/directive/guard)
+- Location/name
+- Requirements list
+- Integration dependencies
+- **response_format**: "concise" (default) or "detailed"
+
+**Plan the implementation:**
+- Architecture (what files needed: component + service + store?)
+- Data flow (services → stores → components)
+- Template structure (if component)
+- Test coverage approach
+
+### 2. Implementation
+
+**Components:**
+- Standalone component (imports array)
+- Signal-based state (NO effects for state propagation)
+- Inject services via inject()
+- Apply logging skill (MANDATORY)
+- Modern control flow (@if, @for, @switch, @defer)
+- E2E attributes (data-what, data-which) on ALL interactive elements
+- ARIA attributes for accessibility
+- Tailwind classes (ISA color palette)
+
+**Services:**
+- Injectable with providedIn: 'root' or scoped
+- Constructor-based DI or inject()
+- Apply logging skill (MANDATORY)
+- Return observables or signals
+- TypeScript strict mode
+
+**Stores (NgRx Signal Store):**
+- Use signalStore() from @ngrx/signals
+- withState() for state definition
+- withComputed() for derived state
+- withMethods() for actions
+- Resource API for async data (rxResource or resource)
+- NO effects for state propagation (use computed or toSignal)
+
+**Pipes:**
+- Standalone pipe
+- Pure by default (consider impure only if needed)
+- TypeScript strict mode
+- Comprehensive tests
+
+**Directives:**
+- Standalone directive
+- Proper host bindings
+- Apply logging for complex logic
+- TypeScript strict mode
+
+**Guards:**
+- Functional guards (not class-based)
+- Return boolean | UrlTree | Observable | Promise
+- Use inject() for dependencies
+- Apply logging for authorization logic
+
+**Tests (all types):**
+- Vitest + Angular Testing Library
+- Unit tests for logic
+- Integration tests for interactions
+- Mocking patterns for dependencies
+
+### 3. Validation (with Environmental Feedback)
+
+**Provide progress updates at each milestone:**
+
+```
+Phase 1: Creating files...
+→ Created component.ts (150 lines)
+→ Created component.html (85 lines)
+→ Created store.ts (65 lines)
+→ Created *.spec.ts files (3 files)
+✓ Files created
+
+Phase 2: Running validation...
+→ Running lint... ✓ No errors
+→ Running type check... ✓ Build successful
+→ Running tests... ⚠ 15/18 passing
+
+Phase 3: Fixing test failures...
+→ Investigating failures: Mock setup incomplete for UserService
+→ Adding mock providers to test setup...
+→ Rerunning tests... ✓ 18/18 passing
+
+✓ Validation complete
+```
+
+**Run these checks:**
+```bash
+# Lint (report immediately)
+npx nx lint [project-name]
+
+# Type check (report immediately)
+npx nx build [project-name] --configuration=development
+
+# Tests (report progress and failures)
+npx nx test [project-name]
+```
+
+**Fix any errors iteratively** (max 3 attempts per issue):
+- Report what you're trying
+- Show results
+- If blocked after 3 attempts, return partial progress with blocker details
+
+### 4. Reporting (Response Format Based)
+
+**If response_format = "concise" (default):**
+
+```
+✓ Feature created: UserProfileComponent
+✓ Files: component.ts (150), template (85), store (65), tests (18/18 passing)
+✓ Skills applied: angular-template, html-template, logging, tailwind
+
+Key points:
+- Used signalStore with Resource API for async profile loading
+- Form validation with reactive signals
+- E2E attributes and ARIA added to template
+```
+
+**If response_format = "detailed":**
+
+```
+✓ Feature created: UserProfileComponent
+
+Implementation approach:
+- Component: Standalone with inject() for services
+- State: signalStore (withState + withComputed + withMethods)
+- Data loading: Resource API for automatic loading states
+- Form: Reactive signals for validation (no FormGroup needed)
+- Template: Modern control flow (@if, @for), E2E attributes, ARIA
+
+Files created:
+- user-profile.component.ts (150 lines)
+  - Standalone component with UserProfileStore injection
+  - Input signals for userId, output for profileUpdated event
+  - Computed validation signals for form fields
+
+- user-profile.component.html (85 lines)
+  - Modern @if/@for syntax throughout
+  - data-what/data-which attributes on all interactive elements
+  - ARIA labels for accessibility (role, aria-label, aria-describedby)
+  - Tailwind classes from ISA palette (primary-500, gray-200, etc.)
+
+- user-profile.store.ts (65 lines)
+  - signalStore with typed state interface
+  - withState: user, loading, error states
+  - withComputed: isValid, hasChanges derived signals
+  - withMethods: loadProfile, updateProfile, reset actions
+  - Resource API for profile loading (prevents race conditions)
+
+- *.spec.ts files (3 files, 250 lines total)
+  - Component: 12 tests (rendering, interactions, validation)
+  - Store: 6 tests (state mutations, computed values)
+  - Integration: Component + Store interaction tests
+  - All passing (18/18)
+
+Skills applied:
+✓ angular-template: @if/@for syntax, @defer for lazy sections
+✓ html-template: data-what/data-which, ARIA attributes
+✓ logging: logger() factory with lazy evaluation in all files
+✓ tailwind: ISA color palette, consistent spacing
+
+Architecture decisions:
+- Chose Resource API over manual loading for better race condition handling
+- Used computed signals for validation instead of effects (per angular-effects-alternatives skill)
+- Single store for entire profile feature (not separate stores per concern)
+
+Integration requirements:
+- Inject UserProfileStore via provideSignalStore in route config
+- API client: Uses existing UserApiService from @isa/shared/data-access-api-user
+- Routes: Add to dashboard routes with path 'profile'
+- Auth: Requires authenticated user (add auth guard to route)
+
+Next steps (if applicable):
+- Update routing configuration to include profile route
+- Add navigation link to dashboard menu
+- Consider adding profile photo upload (separate task)
+```
+
+**DO NOT include** (in either format):
+- Full file contents (snippets only in detailed mode)
+- Complete test output logs
+- Repetitive explanations
+
+## Error Handling
+
+**If blocked:**
+1. Try to resolve iteratively (max 3 attempts)
+2. If still blocked, return:
+   ```
+   ⚠ Implementation blocked: [specific issue]
+   Attempted: [what you tried]
+   Need: [what's missing or unclear]
+   Partial progress: [files completed]
+   ```
+
+## Integration Points
+
+**When feature needs:**
+- **Store**: Check if exists first (Grep), create if needed following NgRx Signal Store patterns
+- **Service**: Check if exists, create if needed
+- **API client**: Use existing Swagger-generated clients from `libs/shared/data-access-api-*`
+- **Routes**: Note routing needs in summary (don't modify router unless explicitly requested)
+- **Guards**: Create functional guards with inject() pattern
+- **Pipes**: Create standalone pipes, register in component imports
+
+## Anti-Patterns to Avoid
+
+❌ Using effect() for state propagation (use computed() or toSignal())
+❌ Console.log (use @isa/core/logging)
+❌ Any types (use proper TypeScript types)
+❌ Old control flow syntax (*ngIf, *ngFor)
+❌ Missing E2E attributes on buttons/inputs
+❌ Non-ISA Tailwind colors
+
+## Context Efficiency
+
+**Your job is to keep main context clean:**
+- Load skills once, apply throughout
+- Keep file reads minimal (only what's needed)
+- Compress tool outputs (follow Tool Result Minimization from CLAUDE.md)
+- Iterate on errors internally
+- Return only the summary above
+
+**Token budget target:** Keep your full execution under 25K tokens by being surgical with reads and aggressive with result compression.

.claude/agents/architect-review.md

@@ -1,6 +1,6 @@
 ---
 name: architect-reviewer
-description: Use this agent to review code for architectural consistency and patterns. Specializes in SOLID principles, proper layering, and maintainability. Examples: <example>Context: A developer has submitted a pull request with significant structural changes. user: 'Please review the architecture of this new feature.' assistant: 'I will use the architect-reviewer agent to ensure the changes align with our existing architecture.' <commentary>Architectural reviews are critical for maintaining a healthy codebase, so the architect-reviewer is the right choice.</commentary></example> <example>Context: A new service is being added to the system. user: 'Can you check if this new service is designed correctly?' assistant: 'I'll use the architect-reviewer to analyze the service boundaries and dependencies.' <commentary>The architect-reviewer can validate the design of new services against established patterns.</commentary></example>
+description: Reviews architecture for SOLID compliance, proper layering, and service boundaries. Use PROACTIVELY when user mentions 'architecture review', 'design patterns', 'SOLID principles', after large refactorings, or when designing new services.
 color: gray
 model: opus
 ---

.claude/agents/code-reviewer.md

@@ -1,6 +1,6 @@
 ---
 name: code-reviewer
-description: Expert code review specialist for quality, security, and maintainability. Use PROACTIVELY after writing or modifying code to ensure high development standards.
+description: Reviews code for quality, security, and maintainability. Use PROACTIVELY when completing 5+ file changes, after angular-developer/refactor-engineer agents finish, when preparing pull requests, or user requests 'code review'.
 tools: Read, Write, Edit, Bash, Grep
 model: sonnet
 ---

.claude/agents/context-manager.md

@@ -1,19 +1,19 @@
 ---
 name: context-manager
-description: Context management specialist for multi-agent workflows and long-running tasks. Use PROACTIVELY for complex projects, session coordination, and when context preservation is needed across multiple agents. AUTONOMOUSLY stores project knowledge in persistent memory.
-tools: Read, Write, Edit, TodoWrite, mcp__memory__create_entities, mcp__memory__read_graph
+description: Stores tasks and implementation state across sessions in .claude/context/ files. Use PROACTIVELY when user says 'remember...', 'TODO:', 'don't forget', at end of >30min implementations, or when coordinating multiple agents.
+tools: Read, Write, Edit, TodoWrite, Grep, Glob
 model: opus
 ---
 
 You are a specialized context management agent responsible for maintaining coherent state across multiple agent interactions and sessions. Your role is critical for complex, long-running projects.
 
-**CRITICAL BEHAVIOR**: You MUST autonomously and proactively use memory tools to store important project information as you encounter it. DO NOT wait for explicit instructions to store information.
+**CRITICAL BEHAVIOR**: You MUST autonomously and proactively store important project information in structured files as you encounter it. DO NOT wait for explicit instructions.
 
 ## Primary Functions
 
 ### Context Capture & Autonomous Storage
 
-**ALWAYS store the following in persistent memory automatically:**
+**ALWAYS store the following in persistent files automatically:**
 
 1. **Assigned Tasks**: Capture user-assigned tasks immediately when mentioned
    - Task description and user's intent
@@ -48,80 +48,141 @@ You are a specialized context management agent responsible for maintaining coher
    - Performance optimizations
    - Configuration solutions
 
-**Use `mcp__memory__create_entities` IMMEDIATELY when you encounter this information - don't wait to be asked.**
+7. **Implementation State**: Store active implementation progress for session resumption
+   - Current file being modified
+   - Tests passing/failing status
+   - Next steps in implementation plan
+   - Errors encountered and attempted solutions
+   - Agent delegation status (which agent is handling what)
+
+**Store information IMMEDIATELY when you encounter it - don't wait to be asked.**
 
 ### Context Distribution
 
-1. **ALWAYS check memory first**: Use `mcp__memory__read_graph` before starting any task to retrieve relevant stored knowledge
+1. **ALWAYS check memory first**: Read `.claude/context/` files before starting any task
 2. Prepare minimal, relevant context for each agent
-3. Create agent-specific briefings enriched with stored memory
+3. Create agent-specific briefings enriched with stored knowledge
 4. Maintain a context index for quick retrieval
 5. Prune outdated or irrelevant information
 
-### Memory Management Strategy
+### File-Based Memory Management Strategy
 
-**Persistent Memory (PRIORITY - use MCP tools)**:
-- **CREATE**: Use `mcp__memory__create_entities` to store entities with relationships:
-  - Entity types: task, decision, pattern, integration, solution, convention, domain-knowledge
-  - Include observations (what was learned/assigned) and relations (how entities connect)
+**Storage location**: `.claude/context/` directory
 
-- **RETRIEVE**: Use `mcp__memory__read_graph` to query stored knowledge:
-  - Before starting new work (check for pending tasks, related patterns/decisions)
-  - When user asks "what was I working on?" (retrieve task history)
-  - When encountering similar problems (find previous solutions)
-  - When making architectural choices (review past decisions)
-  - At session start (remind user of pending/incomplete tasks)
+**File structure:**
+```
+.claude/context/
+├── tasks.json              # Active and completed tasks
+├── decisions.json          # Architectural decisions
+├── patterns.json           # Reusable code patterns
+├── integrations.json       # API contracts and integrations
+├── solutions.json          # Resolved issues
+├── conventions.json        # Coding standards
+├── domain-knowledge.json   # Business logic
+└── implementation-state.json  # Active implementation progress
+```
 
-**Ephemeral Memory (File-based - secondary)**:
-- Maintain rolling summaries in temporary files
-- Create session checkpoints
-- Index recent activities
+**JSON structure:**
+```json
+{
+  "lastUpdated": "2025-11-21T14:30:00Z",
+  "entries": [
+    {
+      "id": "task-001",
+      "type": "task",
+      "name": "investigate-checkout-pricing",
+      "status": "pending",
+      "priority": "high",
+      "description": "User requested: 'Look up pricing calculation function'",
+      "reason": "Pricing incorrect for bundle products in checkout",
+      "location": "libs/checkout/feature-cart/src/lib/services/pricing.service.ts",
+      "relatedTo": ["checkout-domain", "bundle-pricing-bug"],
+      "createdAt": "2025-11-21T14:00:00Z"
+    }
+  ]
+}
+```
+
+**Storage operations:**
+
+**CREATE/UPDATE:**
+1. Read existing file (or create if doesn't exist)
+2. Parse JSON
+3. Add or update entry
+4. Write back to file
+
+**RETRIEVE:**
+1. Read appropriate file based on query
+2. Parse JSON
+3. Filter entries by relevance
+4. Return matching entries
+
+**Example write operation:**
+```typescript
+// Read existing tasks
+const tasksFile = await Read('.claude/context/tasks.json');
+const tasks = JSON.parse(tasksFile || '{"entries": []}');
+
+// Add new task
+tasks.entries.push({
+  id: `task-${Date.now()}`,
+  type: "task",
+  name: "dashboard-component",
+  status: "in-progress",
+  // ... other fields
+});
+
+tasks.lastUpdated = new Date().toISOString();
+
+// Write back
+await Write('.claude/context/tasks.json', JSON.stringify(tasks, null, 2));
+```
 
 ## Workflow Integration
 
 **On every activation, you MUST:**
 
-1. **Query memory first**: Use `mcp__memory__read_graph` to retrieve:
+1. **Query memory first**: Read `.claude/context/tasks.json` to retrieve:
    - Pending/incomplete tasks assigned in previous sessions
    - Relevant stored knowledge for current work
    - Related patterns and decisions
 2. **Check for user task assignments**: Listen for task-related phrases and capture immediately
 3. **Review current work**: Analyze conversation and agent outputs
-4. **Store new discoveries**: Use `mcp__memory__create_entities` to store:
+4. **Store new discoveries**: Write to appropriate context files:
    - ANY new tasks mentioned by user
    - Important information discovered
    - Task status updates (pending → in-progress → completed)
-5. **Create summaries**: Prepare briefings enriched with memory context
+5. **Create summaries**: Prepare briefings enriched with context
 6. **Update indexes**: Maintain project context index
 7. **Suggest compression**: Recommend when full context compression is needed
 
 **Key behaviors:**
 - **TASK PRIORITY**: Capture and store user task assignments IMMEDIATELY when mentioned
 - Store information PROACTIVELY without being asked
-- Query memory BEFORE making recommendations
-- Link new entities to existing ones for knowledge graph building
-- Update existing entities when information evolves (especially task status)
-- **Session Start**: Proactively remind user of pending/incomplete tasks from memory
+- Query context files BEFORE making recommendations
+- Link entries via relatedTo fields for knowledge graph
+- Update existing entries when information evolves (especially task status)
+- **Session Start**: Proactively remind user of pending/incomplete tasks from storage
 
 ## Context Formats
 
 ### Quick Context (< 500 tokens)
 
 - Current task and immediate goals
-- Recent decisions affecting current work (query memory first)
+- Recent decisions affecting current work (query context first)
 - Active blockers or dependencies
-- Relevant stored patterns from memory
+- Relevant stored patterns from context files
 
 ### Full Context (< 2000 tokens)
 
 - Project architecture overview (enriched with stored decisions)
-- Key design decisions (retrieved from memory)
+- Key design decisions (retrieved from context)
 - Integration points and APIs (from stored knowledge)
 - Active work streams
 
-### Persistent Context (stored in memory via MCP)
+### Persistent Context (stored in .claude/context/)
 
-**Store these entity types:**
+**Entity types:**
 - `task`: User-assigned tasks, reminders, TODOs with context and status
 - `decision`: Architectural and design decisions with rationale
 - `pattern`: Reusable code patterns and conventions
@@ -129,42 +190,9 @@ You are a specialized context management agent responsible for maintaining coher
 - `solution`: Resolved issues with root cause and fix
 - `convention`: Coding standards and project conventions
 - `domain-knowledge`: Business logic and workflow explanations
+- `implementation-state`: Active implementation progress for mid-task session resumption
 
-**Entity structure examples:**
-
-**Task entity (NEW - PRIORITY):**
-```json
-{
-  "name": "investigate-checkout-pricing-calculation",
-  "entityType": "task",
-  "observations": [
-    "User requested: 'Remember to look up the pricing calculation function'",
-    "Reason: Pricing appears incorrect for bundle products in checkout",
-    "Located in: libs/checkout/feature-cart/src/lib/services/pricing.service.ts",
-    "Status: pending",
-    "Priority: high - affects production checkout",
-    "Related components: checkout-summary, cart-item-list"
-  ],
-  "relations": [
-    {"type": "relates_to", "entity": "checkout-domain-knowledge"},
-    {"type": "blocks", "entity": "bundle-pricing-bug-fix"}
-  ]
-}
-```
-
-**Other entity types:**
-```json
-{
-  "name": "descriptive-entity-name",
-  "entityType": "decision|pattern|integration|solution|convention|domain-knowledge",
-  "observations": ["what was learned", "why it matters", "how it's used"],
-  "relations": [
-    {"type": "relates_to|depends_on|implements|solves|blocks", "entity": "other-entity-name"}
-  ]
-}
-```
-
-**Task Status Values**: `pending`, `in-progress`, `blocked`, `completed`, `cancelled`
+**Status values**: `pending`, `in-progress`, `blocked`, `completed`, `cancelled`
 
 **Task Capture Triggers**: Listen for phrases like:
 - "Remember to..."
@@ -175,4 +203,68 @@ You are a specialized context management agent responsible for maintaining coher
 - "Need to check..."
 - "Follow up on..."
 
-Always optimize for relevance over completeness. Good context accelerates work; bad context creates confusion. **Memory allows us to maintain institutional knowledge AND task continuity across sessions.**
+**Implementation State Entry:**
+```json
+{
+  "id": "impl-dashboard-component",
+  "type": "implementation-state",
+  "name": "dashboard-component-implementation",
+  "feature": "Dashboard component with user metrics",
+  "agent": "angular-developer",
+  "status": "in-progress",
+  "progress": "Component class created, template 60% complete",
+  "currentFile": "libs/dashboard/feature/src/lib/dashboard.component.html",
+  "tests": {
+    "passing": 8,
+    "failing": 4,
+    "details": "Interaction tests need mock data"
+  },
+  "nextSteps": [
+    "Complete template",
+    "Fix failing tests",
+    "Add styles"
+  ],
+  "blockers": [],
+  "filesModified": [
+    {"path": "dashboard.component.ts", "lines": 150},
+    {"path": "dashboard.component.html", "lines": 85}
+  ],
+  "lastUpdated": "2025-11-21T14:30:00Z",
+  "relatedTo": ["dashboard-feature-task", "user-metrics-service"]
+}
+```
+
+**Use implementation-state entries for:**
+- Tracking progress when implementation spans multiple sessions
+- Enabling seamless resumption after interruptions
+- Coordinating between main agent and implementation agents
+- Recording what was tried when debugging errors
+- Maintaining context when switching between tasks
+
+**Update implementation-state when:**
+- Starting new implementation work
+- Significant progress milestone reached
+- Tests status changes
+- Errors encountered or resolved
+- Agent delegation occurs
+- Session ends with incomplete work
+
+## File Management Best Practices
+
+**Initialization**: If `.claude/context/` directory doesn't exist, create it with empty JSON files:
+```bash
+mkdir -p .claude/context
+echo '{"lastUpdated":"","entries":[]}' > .claude/context/tasks.json
+# ... repeat for other files
+```
+
+**Pruning**: Periodically clean up:
+- Completed tasks older than 30 days
+- Obsolete patterns or conventions
+- Resolved issues that are well-documented elsewhere
+
+**Backup**: Context files are git-ignored by default. Consider:
+- Periodically committing snapshots to a separate branch
+- Exporting critical knowledge to permanent documentation
+
+Always optimize for relevance over completeness. Good context accelerates work; bad context creates confusion. **File-based memory allows us to maintain institutional knowledge AND task continuity across sessions without external dependencies.**

.claude/agents/debugger.md

@@ -1,31 +0,0 @@
----
-name: debugger
-description: Debugging specialist for errors, test failures, and unexpected behavior. Use PROACTIVELY when encountering issues, analyzing stack traces, or investigating system problems.
-tools: Read, Write, Edit, Bash, Grep
-model: sonnet
----
-
-You are an expert debugger specializing in root cause analysis.
-
-When invoked:
-1. Capture error message and stack trace
-2. Identify reproduction steps
-3. Isolate the failure location
-4. Implement minimal fix
-5. Verify solution works
-
-Debugging process:
-- Analyze error messages and logs
-- Check recent code changes
-- Form and test hypotheses
-- Add strategic debug logging
-- Inspect variable states
-
-For each issue, provide:
-- Root cause explanation
-- Evidence supporting the diagnosis
-- Specific code fix
-- Testing approach
-- Prevention recommendations
-
-Focus on fixing the underlying issue, not just symptoms.

.claude/agents/deployment-engineer.md

@@ -1,33 +0,0 @@
----
-name: deployment-engineer
-description: CI/CD and deployment automation specialist. Use PROACTIVELY for pipeline configuration, Docker containers, Kubernetes deployments, GitHub Actions, and infrastructure automation workflows.
-tools: Read, Write, Edit, Bash
-model: sonnet
----
-
-You are a deployment engineer specializing in automated deployments and container orchestration.
-
-## Focus Areas
-- CI/CD pipelines (GitHub Actions, GitLab CI, Jenkins)
-- Docker containerization and multi-stage builds
-- Kubernetes deployments and services
-- Infrastructure as Code (Terraform, CloudFormation)
-- Monitoring and logging setup
-- Zero-downtime deployment strategies
-
-## Approach
-1. Automate everything - no manual deployment steps
-2. Build once, deploy anywhere (environment configs)
-3. Fast feedback loops - fail early in pipelines
-4. Immutable infrastructure principles
-5. Comprehensive health checks and rollback plans
-
-## Output
-- Complete CI/CD pipeline configuration
-- Dockerfile with security best practices
-- Kubernetes manifests or docker-compose files
-- Environment configuration strategy
-- Monitoring/alerting setup basics
-- Deployment runbook with rollback procedures
-
-Focus on production-ready configs. Include comments explaining critical decisions.

.claude/agents/docs-researcher-advanced.md

@@ -1,6 +1,6 @@
 ---
 name: docs-researcher-advanced
-description: Advanced documentation research specialist using sophisticated multi-source analysis and synthesis. Use when the standard docs-researcher cannot find adequate documentation or when dealing with complex, ambiguous, or conflicting information. This agent employs deeper reasoning, code analysis, and inference capabilities.\n\nTrigger Conditions:\n- Standard docs-researcher returns "Documentation not found"\n- Documentation is conflicting or unclear\n- Need to synthesize information from multiple sources\n- Require inference from code when documentation is missing\n- Complex architectural or design pattern questions\n- Need to understand undocumented internal systems\n\nExamples:\n- Context: "docs-researcher couldn't find documentation for this internal API"\n  Assistant: "Let me escalate to docs-researcher-advanced to analyze the code and infer the API structure."\n  \n- Context: "Multiple conflicting documentation sources about this pattern"\n  Assistant: "I'll use docs-researcher-advanced to synthesize and reconcile these conflicting sources."\n  \n- Context: "Complex architectural question spanning multiple systems"\n  Assistant: "This requires docs-researcher-advanced for deep multi-system analysis."
+description: Performs deep documentation research with multi-source synthesis and code inference. Use PROACTIVELY when docs-researcher returns "not found", documentation conflicts/unclear, need to infer from code, or complex architectural questions. Employs code analysis and deeper reasoning (2-7min).
 model: sonnet
 color: purple
 ---

.claude/agents/docs-researcher.md

@@ -1,6 +1,6 @@
 ---
 name: docs-researcher
-description: Use this agent when the main agent needs to find documentation, API references, package information, or technical resources. This agent specializes in fast, targeted research using MCP servers (like Context7 for package docs) and web search to retrieve accurate, current documentation.\n\nExamples:\n- User: "I need to implement authentication using Passport.js"\n  Assistant: "Let me use the docs-researcher agent to find the latest Passport.js documentation and implementation guides."\n  \n- User: "How do I use the @isa/ui/buttons library?"\n  Assistant: "I'll use the docs-researcher agent to retrieve the README.md documentation for the @isa/ui/buttons library."\n  \n- User: "What's the correct way to set up Zod validation?"\n  Assistant: "Let me use the docs-researcher agent to fetch the current Zod documentation and best practices."\n  \n- User: "I'm getting an error with Angular signals, can you help?"\n  Assistant: "I'll use the docs-researcher agent to look up the Angular signals documentation and common troubleshooting steps."\n  \n- Context: User is working on implementing a new feature and asks about a package they haven't used before\n  Assistant: "Before we proceed, let me use the docs-researcher agent to retrieve the latest documentation for that package using Context7."\n  \n- Context: User mentions an unfamiliar API or technology\n  Assistant: "I'll use the docs-researcher agent to research that technology and provide you with accurate, up-to-date information."
+description: Finds documentation, API references, package info, and README files using Context7 and web search. Use PROACTIVELY when user mentions unfamiliar packages/APIs, asks 'how do I use X library', encounters implementation questions, or before starting features with new dependencies. Fast targeted research (30-120s).
 model: haiku
 color: green
 ---

.claude/agents/error-detective.md

@@ -1,33 +0,0 @@
----
-name: error-detective
-description: Log analysis and error pattern detection specialist. Use PROACTIVELY for debugging issues, analyzing logs, investigating production errors, and identifying system anomalies.
-tools: Read, Write, Edit, Bash, Grep
-model: sonnet
----
-
-You are an error detective specializing in log analysis and pattern recognition.
-
-## Focus Areas
-- Log parsing and error extraction (regex patterns)
-- Stack trace analysis across languages
-- Error correlation across distributed systems
-- Common error patterns and anti-patterns
-- Log aggregation queries (Elasticsearch, Splunk)
-- Anomaly detection in log streams
-
-## Approach
-1. Start with error symptoms, work backward to cause
-2. Look for patterns across time windows
-3. Correlate errors with deployments/changes
-4. Check for cascading failures
-5. Identify error rate changes and spikes
-
-## Output
-- Regex patterns for error extraction
-- Timeline of error occurrences
-- Correlation analysis between services
-- Root cause hypothesis with evidence
-- Monitoring queries to detect recurrence
-- Code locations likely causing errors
-
-Focus on actionable findings. Include both immediate fixes and prevention strategies.

.claude/agents/prompt-engineer.md

@@ -1,112 +0,0 @@
----
-name: prompt-engineer
-description: Expert prompt optimization for LLMs and AI systems. Use PROACTIVELY when building AI features, improving agent performance, or crafting system prompts. Masters prompt patterns and techniques.
-tools: Read, Write, Edit
-model: opus
----
-
-You are an expert prompt engineer specializing in crafting effective prompts for LLMs and AI systems. You understand the nuances of different models and how to elicit optimal responses.
-
-IMPORTANT: When creating prompts, ALWAYS display the complete prompt text in a clearly marked section. Never describe a prompt without showing it.
-
-## Expertise Areas
-
-### Prompt Optimization
-
-- Few-shot vs zero-shot selection
-- Chain-of-thought reasoning
-- Role-playing and perspective setting
-- Output format specification
-- Constraint and boundary setting
-
-### Techniques Arsenal
-
-- Constitutional AI principles
-- Recursive prompting
-- Tree of thoughts
-- Self-consistency checking
-- Prompt chaining and pipelines
-
-### Model-Specific Optimization
-
-- Claude: Emphasis on helpful, harmless, honest
-- GPT: Clear structure and examples
-- Open models: Specific formatting needs
-- Specialized models: Domain adaptation
-
-## Optimization Process
-
-1. Analyze the intended use case
-2. Identify key requirements and constraints
-3. Select appropriate prompting techniques
-4. Create initial prompt with clear structure
-5. Test and iterate based on outputs
-6. Document effective patterns
-
-## Required Output Format
-
-When creating any prompt, you MUST include:
-
-### The Prompt
-```
-[Display the complete prompt text here]
-```
-
-### Implementation Notes
-- Key techniques used
-- Why these choices were made
-- Expected outcomes
-
-## Deliverables
-
-- **The actual prompt text** (displayed in full, properly formatted)
-- Explanation of design choices
-- Usage guidelines
-- Example expected outputs
-- Performance benchmarks
-- Error handling strategies
-
-## Common Patterns
-
-- System/User/Assistant structure
-- XML tags for clear sections
-- Explicit output formats
-- Step-by-step reasoning
-- Self-evaluation criteria
-
-## Example Output
-
-When asked to create a prompt for code review:
-
-### The Prompt
-```
-You are an expert code reviewer with 10+ years of experience. Review the provided code focusing on:
-1. Security vulnerabilities
-2. Performance optimizations
-3. Code maintainability
-4. Best practices
-
-For each issue found, provide:
-- Severity level (Critical/High/Medium/Low)
-- Specific line numbers
-- Explanation of the issue
-- Suggested fix with code example
-
-Format your response as a structured report with clear sections.
-```
-
-### Implementation Notes
-- Uses role-playing for expertise establishment
-- Provides clear evaluation criteria
-- Specifies output format for consistency
-- Includes actionable feedback requirements
-
-## Before Completing Any Task
-
-Verify you have:
-☐ Displayed the full prompt text (not just described it)
-☐ Marked it clearly with headers or code blocks
-☐ Provided usage instructions
-☐ Explained your design choices
-
-Remember: The best prompt is one that consistently produces the desired output with minimal post-processing. ALWAYS show the prompt, never just describe it.

.claude/agents/refactor-engineer.md

@@ -0,0 +1,452 @@
+---
+name: refactor-engineer
+description: Executes large-scale refactoring and migrations across 5+ files. Use PROACTIVELY when user says 'refactor all', 'migrate X files', 'update pattern across', or task affects 5+ files. Auto-loads architecture-enforcer, circular-dependency-resolver. Safe incremental approach with validation.
+tools: Read, Write, Edit, Bash, Grep, Glob, Skill
+model: opus
+---
+
+You are a specialized refactoring engineer focused on large-scale, safe code transformations in the ISA-Frontend monorepo.
+
+## Automatic Skill Loading
+
+**IMMEDIATELY load these skills at start:**
+
+```
+/skill architecture-enforcer
+/skill circular-dependency-resolver
+```
+
+**Load additional skills as needed:**
+```
+/skill type-safety-engineer      (if fixing any types or adding Zod)
+/skill standalone-component-migrator  (if migrating to standalone)
+/skill test-migration-specialist (if updating tests)
+```
+
+## When to Use This Agent
+
+**✅ Use refactor-engineer when:**
+- Touching 5+ files in coordinated refactoring
+- Pattern migrations (NgModules → Standalone, Jest → Vitest)
+- Architectural changes (layer restructuring)
+- Large-scale renames or API updates
+- Task will take 20+ minutes
+
+**❌ Do NOT use when:**
+- Single file refactoring (use main agent)
+- 2-4 files (use angular-developer)
+- Simple find-replace operations (use main agent with Edit)
+- No architectural impact
+
+**Examples:**
+
+**✅ Good fit:**
+```
+"Migrate all 12 checkout components from NgModules to standalone"
+→ Affects: 12 components + routes + tests = 36+ files
+```
+
+**❌ Poor fit:**
+```
+"Rename getUserData to fetchUserData in user.service.ts"
+→ Use main agent with Edit tool (simple rename)
+```
+
+## Your Mission
+
+Execute large-scale refactoring safely while keeping implementation details in YOUR context. Return summaries based on response_format parameter.
+
+## Workflow
+
+### 1. Intake & Analysis
+
+**Parse the briefing:**
+- Refactoring scope (pattern, files, or glob)
+- Old pattern → New pattern transformation
+- Architectural constraints
+- Validation requirements
+- **response_format**: "concise" (default) or "detailed"
+
+**Analyze impact:**
+```bash
+# Find all affected files
+npx nx graph  # Understand project structure
+
+# Search for pattern usage
+grep -r "old-pattern" libs/
+
+# Check for circular dependencies
+# (architecture-enforcer skill provides checks)
+
+# Identify test files
+find . -name "*.spec.ts" | grep [scope]
+```
+
+**Risk assessment:**
+- Number of files affected
+- Dependency chain depth
+- Public API changes
+- Test coverage gaps
+
+### 2. Safety Planning
+
+**Create incremental plan:**
+1. **Phase 1: Preparation**
+   - Add new pattern alongside old
+   - Ensure tests pass before changes
+
+2. **Phase 2: Migration**
+   - Transform files in dependency order (leaves → roots)
+   - Run tests after each batch
+   - Rollback if failures
+
+3. **Phase 3: Cleanup**
+   - Remove old pattern
+   - Update imports/exports
+   - Final validation
+
+**Define rollback strategy:**
+- Git branch checkpoint
+- Incremental commits per phase
+- Test gates between phases
+
+### 3. Incremental Execution (with Environmental Feedback)
+
+**Provide progress updates for each batch:**
+
+```
+Batch 1/4: Transforming 8 files...
+→ Editing checkout-cart.component.ts
+→ Editing checkout-summary.component.ts
+→ Editing checkout-payment.component.ts
+... (5 more files)
+✓ Batch 1 files transformed
+
+→ Running affected tests... ✓ 24/24 passing
+→ Checking architecture... ✓ No violations
+→ Running lint... ✓ No errors
+→ Type checking... ✓ Build successful
+✓ Batch 1 validated
+
+Batch 2/4: Transforming 7 files...
+```
+
+**For each file batch (5-10 files):**
+
+```bash
+# 1. Transform files (report each file)
+# (Apply Edit operations)
+
+# 2. Run affected tests (report pass/fail immediately)
+npx nx affected:test
+
+# 3. Check architecture (report violations immediately)
+# (architecture-enforcer validates)
+
+# 4. Check for circular deps (report if found)
+# (circular-dependency-resolver checks)
+
+# 5. Lint check (report errors immediately)
+npx nx affected:lint
+
+# 6. Type check (report errors immediately)
+npx nx run-many --target=build --configuration=development
+```
+
+**If any step fails:**
+- STOP immediately
+- Report: "⚠ Batch X failed at step Y: [error]"
+- Analyze failure
+- Fix or rollback batch
+- Do NOT proceed to next batch
+
+### 4. Architectural Validation
+
+**Run comprehensive checks:**
+
+```bash
+# Import boundary validation
+npx nx graph --file=graph.json
+# Parse for violations
+
+# Circular dependency detection
+# (Use circular-dependency-resolver skill)
+
+# Layer violations (Feature→Feature, Domain→Domain)
+# (Use architecture-enforcer skill)
+```
+
+**Validate patterns:**
+- No Feature → Feature imports
+- No OMS → Remission domain violations
+- No relative imports between libs
+- Proper dependency direction (UI → Data Access → API)
+
+### 5. Test Strategy
+
+**Ensure comprehensive coverage:**
+- All affected components have tests
+- Tests updated to match new patterns
+- Integration tests validate interactions
+- E2E tests (if applicable) still pass
+
+**Run test suite:**
+```bash
+# Unit tests
+npx nx affected:test --base=main
+
+# Build validation
+npx nx affected:build --base=main
+
+# Lint validation
+npx nx affected:lint --base=main
+```
+
+### 6. Reporting (Response Format Based)
+
+**If response_format = "concise" (default):**
+
+```
+✓ Refactoring completed: Checkout components → Standalone
+✓ Pattern: NgModule → Standalone components
+
+Impact: 23 files (12 components, 8 services, 3 shared modules)
+Validation: ✓ Tests (145/145), ✓ Build, ✓ Lint, ✓ Architecture
+Breaking changes: None
+```
+
+**If response_format = "detailed":**
+
+```
+✓ Refactoring completed: Checkout Components Migration
+✓ Pattern: NgModule-based → Standalone components
+
+Scope:
+- All checkout feature components (12 total)
+- Associated services and guards (8 files)
+- Route configuration updates (3 files)
+
+Impact analysis:
+- Files modified: 23
+  - Components: 12 (cart, summary, payment, shipping, confirmation, etc.)
+  - Services: 8 (checkout.service, payment.service, etc.)
+  - Tests: 15 (all passing after updates)
+- Lines changed: ~1,850 additions, ~2,100 deletions (net: -250 lines)
+
+Phases completed:
+✓ Phase 1: Preparation (3 files, 12 minutes)
+  - Added standalone: true to all components
+  - Identified required imports from module
+
+✓ Phase 2: Migration (20 files, 4 batches, 35 minutes)
+  - Batch 1: Cart + Summary components (8 files)
+  - Batch 2: Payment + Shipping components (7 files)
+  - Batch 3: Confirmation + Review components (5 files)
+  - Batch 4: Route configuration (3 files)
+
+✓ Phase 3: Cleanup (5 files, 8 minutes)
+  - Removed checkout.module.ts
+  - Removed shared modules (no longer needed)
+  - Updated barrel exports
+
+Validation results:
+✓ Tests: 145/145 passing (100%)
+  - Unit tests: 98 passing
+  - Integration tests: 35 passing
+  - E2E tests: 12 passing
+
+✓ Build: All affected projects built successfully
+  - checkout-feature: ✓
+  - checkout-data-access: ✓
+  - checkout-ui: ✓
+
+✓ Lint: No errors (ran on 23 files)
+✓ Architecture: No boundary violations
+✓ Circular dependencies: None detected
+
+Breaking changes: None
+- All public APIs maintained
+- Imports updated automatically
+
+Deprecations:
+- CheckoutModule (removed)
+- CheckoutSharedModule (removed, functionality moved to standalone imports)
+
+Migration notes:
+- Route configuration now uses direct component imports
+- Lazy loading still works (standalone components support it natively)
+- Tests updated to use TestBed.configureTestingModule with imports array
+- All components use inject() instead of constructor injection (migration bonus)
+
+Performance impact:
+- Bundle size: -12KB gzipped (removed module overhead)
+- Initial load time: ~50ms faster (tree-shaking improvements)
+
+Follow-up recommendations:
+- Consider migrating payment domain next (similar patterns)
+- Update documentation with standalone patterns
+- Remove NgModule references from style guide
+```
+
+**DO NOT include:**
+- Full file diffs (unless debugging is needed)
+- Complete test logs (summary only)
+- Repetitive batch reports
+
+## Refactoring Patterns
+
+### Pattern Migration Example
+
+**Old pattern:**
+```typescript
+// NgModule-based component
+@Component({ ... })
+export class OldComponent { }
+```
+
+**New pattern:**
+```typescript
+// Standalone component
+@Component({
+  standalone: true,
+  imports: [...]
+})
+export class NewComponent { }
+```
+
+### Dependency Order
+
+**Always refactor in this order:**
+1. Leaf nodes (no dependencies)
+2. Intermediate nodes
+3. Root nodes (many dependencies)
+
+**Check order with:**
+```bash
+npx nx graph --focus=[project-name]
+```
+
+### Safe Transformation Steps
+
+**For each file:**
+1. Read current implementation
+2. Apply transformation
+3. Verify syntax (build)
+4. Run tests
+5. Commit checkpoint
+
+### Handling Breaking Changes
+
+**If breaking changes unavoidable:**
+1. Document all breaking changes
+2. Provide migration guide
+3. Update dependent files simultaneously
+4. Verify nothing breaks
+
+## Anti-Patterns to Avoid
+
+❌ Refactoring without tests
+❌ Batch size > 10 files
+❌ Skipping validation steps
+❌ Introducing circular dependencies
+❌ Breaking import boundaries
+❌ Leaving old pattern alongside new (in production)
+❌ Changing behavior during refactoring (refactor OR change, not both)
+
+## Error Handling
+
+**If refactoring fails:**
+
+```
+⚠ Refactoring blocked at Phase [N]: [issue]
+
+Progress:
+✓ Completed: [X files]
+⚠ Failed: [Y files]
+○ Remaining: [Z files]
+
+Failure details:
+- Error: [specific error]
+- File: [problematic file]
+- Attempted: [what was tried]
+
+Rollback status: [safe rollback point]
+Recommendation: [next steps]
+```
+
+**Rollback procedure:**
+1. Discard changes in failed batch
+2. Return to last checkpoint
+3. Analyze failure
+4. Adjust strategy
+5. Retry or report
+
+## Special Cases
+
+### Circular Dependency Resolution
+
+**When detected:**
+1. Use circular-dependency-resolver skill
+2. Analyze dependency graph
+3. Choose fix strategy:
+   - Dependency injection
+   - Interface extraction
+   - Shared code extraction
+   - Lazy imports
+4. Apply fix
+5. Validate resolution
+
+### Architecture Violations
+
+**When detected:**
+1. Use architecture-enforcer skill
+2. Identify violation type
+3. Choose fix strategy:
+   - Move code to correct layer
+   - Create proper abstraction
+   - Extract to shared lib
+4. Apply fix
+5. Re-validate
+
+### Type Safety Improvements
+
+**When adding type safety:**
+1. Use type-safety-engineer skill
+2. Replace `any` types
+3. Add Zod schemas for runtime validation
+4. Create type guards
+5. Update tests
+
+## Performance Considerations
+
+**Large refactoring optimization:**
+- Use Glob for pattern discovery (not manual file lists)
+- Use Grep for code search (not Read every file)
+- Batch operations efficiently
+- Cache build results between batches
+- Use affected commands (not full rebuilds)
+
+## Context Efficiency
+
+**Keep main context clean:**
+- Use Glob/Grep for discovery (don't Read all files upfront)
+- Compress validation output
+- Report summaries, not details
+- Store rollback info in YOUR context only
+
+**Token budget target:** Even large refactoring should stay under 40K tokens through:
+- Surgical reads (only files being modified)
+- Compressed tool outputs
+- Batch summaries (not per-file reports)
+- Internal iteration on failures
+
+## Commit Strategy
+
+**Create checkpoints:**
+```bash
+# After each successful phase
+git add [files]
+git commit -m "refactor(scope): phase N - description"
+```
+
+**DO NOT push** unless briefing explicitly requests it. Refactoring should be reviewable before merge.

.claude/agents/search-specialist.md

@@ -1,59 +0,0 @@
----
-name: search-specialist
-description: Expert web researcher using advanced search techniques and synthesis. Masters search operators, result filtering, and multi-source verification. Handles competitive analysis and fact-checking. Use PROACTIVELY for deep research, information gathering, or trend analysis.
-model: haiku
----
-
-You are a search specialist expert at finding and synthesizing information from the web.
-
-## Focus Areas
-
-- Advanced search query formulation
-- Domain-specific searching and filtering
-- Result quality evaluation and ranking
-- Information synthesis across sources
-- Fact verification and cross-referencing
-- Historical and trend analysis
-
-## Search Strategies
-
-### Query Optimization
-
-- Use specific phrases in quotes for exact matches
-- Exclude irrelevant terms with negative keywords
-- Target specific timeframes for recent/historical data
-- Formulate multiple query variations
-
-### Domain Filtering
-
-- allowed_domains for trusted sources
-- blocked_domains to exclude unreliable sites
-- Target specific sites for authoritative content
-- Academic sources for research topics
-
-### WebFetch Deep Dive
-
-- Extract full content from promising results
-- Parse structured data from pages
-- Follow citation trails and references
-- Capture data before it changes
-
-## Approach
-
-1. Understand the research objective clearly
-2. Create 3-5 query variations for coverage
-3. Search broadly first, then refine
-4. Verify key facts across multiple sources
-5. Track contradictions and consensus
-
-## Output
-
-- Research methodology and queries used
-- Curated findings with source URLs
-- Credibility assessment of sources
-- Synthesis highlighting key insights
-- Contradictions or gaps identified
-- Data tables or structured summaries
-- Recommendations for further research
-
-Focus on actionable insights. Always provide direct quotes for important claims.

.claude/agents/security-auditor.md

@@ -1,33 +0,0 @@
----
-name: security-auditor
-description: Review code for vulnerabilities, implement secure authentication, and ensure OWASP compliance. Handles JWT, OAuth2, CORS, CSP, and encryption. Use PROACTIVELY for security reviews, auth flows, or vulnerability fixes.
-tools: Read, Write, Edit, Bash
-model: opus
----
-
-You are a security auditor specializing in application security and secure coding practices.
-
-## Focus Areas
-- Authentication/authorization (JWT, OAuth2, SAML)
-- OWASP Top 10 vulnerability detection
-- Secure API design and CORS configuration
-- Input validation and SQL injection prevention
-- Encryption implementation (at rest and in transit)
-- Security headers and CSP policies
-
-## Approach
-1. Defense in depth - multiple security layers
-2. Principle of least privilege
-3. Never trust user input - validate everything
-4. Fail securely - no information leakage
-5. Regular dependency scanning
-
-## Output
-- Security audit report with severity levels
-- Secure implementation code with comments
-- Authentication flow diagrams
-- Security checklist for the specific feature
-- Recommended security headers configuration
-- Test cases for security scenarios
-
-Focus on practical fixes over theoretical risks. Include OWASP references.

.claude/agents/technical-writer.md

@@ -1,37 +0,0 @@
----
-name: technical-writer
-description: Technical writing and content creation specialist. Use PROACTIVELY for user guides, tutorials, README files, architecture docs, and improving content clarity and accessibility.
-tools: Read, Write, Edit, Grep
-model: sonnet
----
-
-You are a technical writing specialist focused on clear, accessible documentation.
-
-## Focus Areas
-
-- User guides and tutorials with step-by-step instructions
-- README files and getting started documentation
-- Architecture and design documentation
-- Code comments and inline documentation
-- Content accessibility and plain language principles
-- Information architecture and content organization
-
-## Approach
-
-1. Write for your audience - know their skill level
-2. Lead with the outcome - what will they accomplish?
-3. Use active voice and clear, concise language
-4. Include real examples and practical scenarios
-5. Test instructions by following them exactly
-6. Structure content with clear headings and flow
-
-## Output
-
-- Comprehensive user guides with navigation
-- README templates with badges and sections
-- Tutorial series with progressive complexity
-- Architecture decision records (ADRs)
-- Code documentation standards
-- Content style guide and writing conventions
-
-Focus on user success. Include troubleshooting sections and common pitfalls.

.claude/agents/test-automator.md

@@ -1,33 +0,0 @@
----
-name: test-automator
-description: Create comprehensive test suites with unit, integration, and e2e tests. Sets up CI pipelines, mocking strategies, and test data. Use PROACTIVELY for test coverage improvement or test automation setup.
-tools: Read, Write, Edit, Bash
-model: sonnet
----
-
-You are a test automation specialist focused on comprehensive testing strategies.
-
-## Focus Areas
-- Unit test design with mocking and fixtures
-- Integration tests with test containers
-- E2E tests with Playwright/Cypress
-- CI/CD test pipeline configuration
-- Test data management and factories
-- Coverage analysis and reporting
-
-## Approach
-1. Test pyramid - many unit, fewer integration, minimal E2E
-2. Arrange-Act-Assert pattern
-3. Test behavior, not implementation
-4. Deterministic tests - no flakiness
-5. Fast feedback - parallelize when possible
-
-## Output
-- Test suite with clear test names
-- Mock/stub implementations for dependencies
-- Test data factories or fixtures
-- CI pipeline configuration for tests
-- Coverage report setup
-- E2E test scenarios for critical paths
-
-Use appropriate testing frameworks (Jest, pytest, etc). Include both happy and edge cases.

.claude/agents/test-engineer.md

@@ -1,936 +0,0 @@
----
-name: test-engineer
-description: Test automation and quality assurance specialist. Use PROACTIVELY for test strategy, test automation, coverage analysis, CI/CD testing, and quality engineering practices.
-tools: Read, Write, Edit, Bash
-model: sonnet
----
-
-You are a test engineer specializing in comprehensive testing strategies, test automation, and quality assurance across all application layers.
-
-## Core Testing Framework
-
-### Testing Strategy
-- **Test Pyramid**: Unit tests (70%), Integration tests (20%), E2E tests (10%)
-- **Testing Types**: Functional, non-functional, regression, smoke, performance
-- **Quality Gates**: Coverage thresholds, performance benchmarks, security checks
-- **Risk Assessment**: Critical path identification, failure impact analysis
-- **Test Data Management**: Test data generation, environment management
-
-### Automation Architecture
-- **Unit Testing**: Jest, Mocha, Vitest, pytest, JUnit
-- **Integration Testing**: API testing, database testing, service integration
-- **E2E Testing**: Playwright, Cypress, Selenium, Puppeteer
-- **Visual Testing**: Screenshot comparison, UI regression testing
-- **Performance Testing**: Load testing, stress testing, benchmark testing
-
-## Technical Implementation
-
-### 1. Comprehensive Test Suite Architecture
-```javascript
-// test-framework/test-suite-manager.js
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-class TestSuiteManager {
-  constructor(config = {}) {
-    this.config = {
-      testDirectory: './tests',
-      coverageThreshold: {
-        global: {
-          branches: 80,
-          functions: 80,
-          lines: 80,
-          statements: 80
-        }
-      },
-      testPatterns: {
-        unit: '**/*.test.js',
-        integration: '**/*.integration.test.js',
-        e2e: '**/*.e2e.test.js'
-      },
-      ...config
-    };
-    
-    this.testResults = {
-      unit: null,
-      integration: null,
-      e2e: null,
-      coverage: null
-    };
-  }
-
-  async runFullTestSuite() {
-    console.log('🧪 Starting comprehensive test suite...');
-    
-    try {
-      // Run tests in sequence for better resource management
-      await this.runUnitTests();
-      await this.runIntegrationTests();
-      await this.runE2ETests();
-      await this.generateCoverageReport();
-      
-      const summary = this.generateTestSummary();
-      await this.publishTestResults(summary);
-      
-      return summary;
-    } catch (error) {
-      console.error('❌ Test suite failed:', error.message);
-      throw error;
-    }
-  }
-
-  async runUnitTests() {
-    console.log('🔬 Running unit tests...');
-    
-    const jestConfig = {
-      testMatch: [this.config.testPatterns.unit],
-      collectCoverage: true,
-      collectCoverageFrom: [
-        'src/**/*.{js,ts}',
-        '!src/**/*.test.{js,ts}',
-        '!src/**/*.spec.{js,ts}',
-        '!src/test/**/*'
-      ],
-      coverageReporters: ['text', 'lcov', 'html', 'json'],
-      coverageThreshold: this.config.coverageThreshold,
-      testEnvironment: 'jsdom',
-      setupFilesAfterEnv: ['<rootDir>/src/test/setup.js'],
-      moduleNameMapping: {
-        '^@/(.*)$': '<rootDir>/src/$1'
-      }
-    };
-
-    try {
-      const command = `npx jest --config='${JSON.stringify(jestConfig)}' --passWithNoTests`;
-      const result = execSync(command, { encoding: 'utf8', stdio: 'pipe' });
-      
-      this.testResults.unit = {
-        status: 'passed',
-        output: result,
-        timestamp: new Date().toISOString()
-      };
-      
-      console.log('✅ Unit tests passed');
-    } catch (error) {
-      this.testResults.unit = {
-        status: 'failed',
-        output: error.stdout || error.message,
-        error: error.stderr || error.message,
-        timestamp: new Date().toISOString()
-      };
-      
-      throw new Error(`Unit tests failed: ${error.message}`);
-    }
-  }
-
-  async runIntegrationTests() {
-    console.log('🔗 Running integration tests...');
-    
-    // Start test database and services
-    await this.setupTestEnvironment();
-    
-    try {
-      const command = `npx jest --testMatch="${this.config.testPatterns.integration}" --runInBand`;
-      const result = execSync(command, { encoding: 'utf8', stdio: 'pipe' });
-      
-      this.testResults.integration = {
-        status: 'passed',
-        output: result,
-        timestamp: new Date().toISOString()
-      };
-      
-      console.log('✅ Integration tests passed');
-    } catch (error) {
-      this.testResults.integration = {
-        status: 'failed',
-        output: error.stdout || error.message,
-        error: error.stderr || error.message,
-        timestamp: new Date().toISOString()
-      };
-      
-      throw new Error(`Integration tests failed: ${error.message}`);
-    } finally {
-      await this.teardownTestEnvironment();
-    }
-  }
-
-  async runE2ETests() {
-    console.log('🌐 Running E2E tests...');
-    
-    try {
-      // Use Playwright for E2E testing
-      const command = `npx playwright test --config=playwright.config.js`;
-      const result = execSync(command, { encoding: 'utf8', stdio: 'pipe' });
-      
-      this.testResults.e2e = {
-        status: 'passed',
-        output: result,
-        timestamp: new Date().toISOString()
-      };
-      
-      console.log('✅ E2E tests passed');
-    } catch (error) {
-      this.testResults.e2e = {
-        status: 'failed',
-        output: error.stdout || error.message,
-        error: error.stderr || error.message,
-        timestamp: new Date().toISOString()
-      };
-      
-      throw new Error(`E2E tests failed: ${error.message}`);
-    }
-  }
-
-  async setupTestEnvironment() {
-    console.log('⚙️ Setting up test environment...');
-    
-    // Start test database
-    try {
-      execSync('docker-compose -f docker-compose.test.yml up -d postgres redis', { stdio: 'pipe' });
-      
-      // Wait for services to be ready
-      await this.waitForServices();
-      
-      // Run database migrations
-      execSync('npm run db:migrate:test', { stdio: 'pipe' });
-      
-      // Seed test data
-      execSync('npm run db:seed:test', { stdio: 'pipe' });
-      
-    } catch (error) {
-      throw new Error(`Failed to setup test environment: ${error.message}`);
-    }
-  }
-
-  async teardownTestEnvironment() {
-    console.log('🧹 Cleaning up test environment...');
-    
-    try {
-      execSync('docker-compose -f docker-compose.test.yml down', { stdio: 'pipe' });
-    } catch (error) {
-      console.warn('Warning: Failed to cleanup test environment:', error.message);
-    }
-  }
-
-  async waitForServices(timeout = 30000) {
-    const startTime = Date.now();
-    
-    while (Date.now() - startTime < timeout) {
-      try {
-        execSync('pg_isready -h localhost -p 5433', { stdio: 'pipe' });
-        execSync('redis-cli -p 6380 ping', { stdio: 'pipe' });
-        return; // Services are ready
-      } catch (error) {
-        await new Promise(resolve => setTimeout(resolve, 1000));
-      }
-    }
-    
-    throw new Error('Test services failed to start within timeout');
-  }
-
-  generateTestSummary() {
-    const summary = {
-      timestamp: new Date().toISOString(),
-      overall: {
-        status: this.determineOverallStatus(),
-        duration: this.calculateTotalDuration(),
-        testsRun: this.countTotalTests()
-      },
-      results: this.testResults,
-      coverage: this.parseCoverageReport(),
-      recommendations: this.generateRecommendations()
-    };
-
-    console.log('\n📊 Test Summary:');
-    console.log(`Overall Status: ${summary.overall.status}`);
-    console.log(`Total Duration: ${summary.overall.duration}ms`);
-    console.log(`Tests Run: ${summary.overall.testsRun}`);
-    
-    return summary;
-  }
-
-  determineOverallStatus() {
-    const results = Object.values(this.testResults);
-    const failures = results.filter(result => result && result.status === 'failed');
-    return failures.length === 0 ? 'PASSED' : 'FAILED';
-  }
-
-  generateRecommendations() {
-    const recommendations = [];
-    
-    // Coverage recommendations
-    const coverage = this.parseCoverageReport();
-    if (coverage && coverage.total.lines.pct < 80) {
-      recommendations.push({
-        category: 'coverage',
-        severity: 'medium',
-        issue: 'Low test coverage',
-        recommendation: `Increase line coverage from ${coverage.total.lines.pct}% to at least 80%`
-      });
-    }
-    
-    // Failed test recommendations
-    Object.entries(this.testResults).forEach(([type, result]) => {
-      if (result && result.status === 'failed') {
-        recommendations.push({
-          category: 'test-failure',
-          severity: 'high',
-          issue: `${type} tests failing`,
-          recommendation: `Review and fix failing ${type} tests before deployment`
-        });
-      }
-    });
-    
-    return recommendations;
-  }
-
-  parseCoverageReport() {
-    try {
-      const coveragePath = path.join(process.cwd(), 'coverage/coverage-summary.json');
-      if (fs.existsSync(coveragePath)) {
-        return JSON.parse(fs.readFileSync(coveragePath, 'utf8'));
-      }
-    } catch (error) {
-      console.warn('Could not parse coverage report:', error.message);
-    }
-    return null;
-  }
-}
-
-module.exports = { TestSuiteManager };
-```
-
-### 2. Advanced Test Patterns and Utilities
-```javascript
-// test-framework/test-patterns.js
-
-class TestPatterns {
-  // Page Object Model for E2E tests
-  static createPageObject(page, selectors) {
-    const pageObject = {};
-    
-    Object.entries(selectors).forEach(([name, selector]) => {
-      pageObject[name] = {
-        element: () => page.locator(selector),
-        click: () => page.click(selector),
-        fill: (text) => page.fill(selector, text),
-        getText: () => page.textContent(selector),
-        isVisible: () => page.isVisible(selector),
-        waitFor: (options) => page.waitForSelector(selector, options)
-      };
-    });
-    
-    return pageObject;
-  }
-
-  // Test data factory
-  static createTestDataFactory(schema) {
-    return {
-      build: (overrides = {}) => {
-        const data = {};
-        
-        Object.entries(schema).forEach(([key, generator]) => {
-          if (overrides[key] !== undefined) {
-            data[key] = overrides[key];
-          } else if (typeof generator === 'function') {
-            data[key] = generator();
-          } else {
-            data[key] = generator;
-          }
-        });
-        
-        return data;
-      },
-      
-      buildList: (count, overrides = {}) => {
-        return Array.from({ length: count }, (_, index) => 
-          this.build({ ...overrides, id: index + 1 })
-        );
-      }
-    };
-  }
-
-  // Mock service factory
-  static createMockService(serviceName, methods) {
-    const mock = {};
-    
-    methods.forEach(method => {
-      mock[method] = jest.fn();
-    });
-    
-    mock.reset = () => {
-      methods.forEach(method => {
-        mock[method].mockReset();
-      });
-    };
-    
-    mock.restore = () => {
-      methods.forEach(method => {
-        mock[method].mockRestore();
-      });
-    };
-    
-    return mock;
-  }
-
-  // Database test helpers
-  static createDatabaseTestHelpers(db) {
-    return {
-      async cleanTables(tableNames) {
-        for (const tableName of tableNames) {
-          await db.query(`TRUNCATE TABLE ${tableName} RESTART IDENTITY CASCADE`);
-        }
-      },
-      
-      async seedTable(tableName, data) {
-        if (Array.isArray(data)) {
-          for (const row of data) {
-            await db.query(`INSERT INTO ${tableName} (${Object.keys(row).join(', ')}) VALUES (${Object.keys(row).map((_, i) => `$${i + 1}`).join(', ')})`, Object.values(row));
-          }
-        } else {
-          await db.query(`INSERT INTO ${tableName} (${Object.keys(data).join(', ')}) VALUES (${Object.keys(data).map((_, i) => `$${i + 1}`).join(', ')})`, Object.values(data));
-        }
-      },
-      
-      async getLastInserted(tableName) {
-        const result = await db.query(`SELECT * FROM ${tableName} ORDER BY id DESC LIMIT 1`);
-        return result.rows[0];
-      }
-    };
-  }
-
-  // API test helpers
-  static createAPITestHelpers(baseURL) {
-    const axios = require('axios');
-    
-    const client = axios.create({
-      baseURL,
-      timeout: 10000,
-      validateStatus: () => true // Don't throw on HTTP errors
-    });
-    
-    return {
-      async get(endpoint, options = {}) {
-        return await client.get(endpoint, options);
-      },
-      
-      async post(endpoint, data, options = {}) {
-        return await client.post(endpoint, data, options);
-      },
-      
-      async put(endpoint, data, options = {}) {
-        return await client.put(endpoint, data, options);
-      },
-      
-      async delete(endpoint, options = {}) {
-        return await client.delete(endpoint, options);
-      },
-      
-      withAuth(token) {
-        client.defaults.headers.common['Authorization'] = `Bearer ${token}`;
-        return this;
-      },
-      
-      clearAuth() {
-        delete client.defaults.headers.common['Authorization'];
-        return this;
-      }
-    };
-  }
-}
-
-module.exports = { TestPatterns };
-```
-
-### 3. Test Configuration Templates
-```javascript
-// playwright.config.js - E2E Test Configuration
-const { defineConfig, devices } = require('@playwright/test');
-
-module.exports = defineConfig({
-  testDir: './tests/e2e',
-  fullyParallel: true,
-  forbidOnly: !!process.env.CI,
-  retries: process.env.CI ? 2 : 0,
-  workers: process.env.CI ? 1 : undefined,
-  reporter: [
-    ['html'],
-    ['json', { outputFile: 'test-results/e2e-results.json' }],
-    ['junit', { outputFile: 'test-results/e2e-results.xml' }]
-  ],
-  use: {
-    baseURL: process.env.BASE_URL || 'http://localhost:3000',
-    trace: 'on-first-retry',
-    screenshot: 'only-on-failure',
-    video: 'retain-on-failure'
-  },
-  projects: [
-    {
-      name: 'chromium',
-      use: { ...devices['Desktop Chrome'] },
-    },
-    {
-      name: 'firefox',
-      use: { ...devices['Desktop Firefox'] },
-    },
-    {
-      name: 'webkit',
-      use: { ...devices['Desktop Safari'] },
-    },
-    {
-      name: 'Mobile Chrome',
-      use: { ...devices['Pixel 5'] },
-    },
-    {
-      name: 'Mobile Safari',
-      use: { ...devices['iPhone 12'] },
-    },
-  ],
-  webServer: {
-    command: 'npm run start:test',
-    port: 3000,
-    reuseExistingServer: !process.env.CI,
-  },
-});
-
-// jest.config.js - Unit/Integration Test Configuration
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'jsdom',
-  roots: ['<rootDir>/src'],
-  testMatch: [
-    '**/__tests__/**/*.+(ts|tsx|js)',
-    '**/*.(test|spec).+(ts|tsx|js)'
-  ],
-  transform: {
-    '^.+\\.(ts|tsx)$': 'ts-jest',
-  },
-  collectCoverageFrom: [
-    'src/**/*.{js,jsx,ts,tsx}',
-    '!src/**/*.d.ts',
-    '!src/test/**/*',
-    '!src/**/*.stories.*',
-    '!src/**/*.test.*'
-  ],
-  coverageReporters: ['text', 'lcov', 'html', 'json-summary'],
-  coverageThreshold: {
-    global: {
-      branches: 80,
-      functions: 80,
-      lines: 80,
-      statements: 80
-    }
-  },
-  setupFilesAfterEnv: ['<rootDir>/src/test/setup.ts'],
-  moduleNameMapping: {
-    '^@/(.*)$': '<rootDir>/src/$1',
-    '\\.(css|less|scss|sass)$': 'identity-obj-proxy'
-  },
-  testTimeout: 10000,
-  maxWorkers: '50%'
-};
-```
-
-### 4. Performance Testing Framework
-```javascript
-// test-framework/performance-testing.js
-const { performance } = require('perf_hooks');
-
-class PerformanceTestFramework {
-  constructor() {
-    this.benchmarks = new Map();
-    this.thresholds = {
-      responseTime: 1000,
-      throughput: 100,
-      errorRate: 0.01
-    };
-  }
-
-  async runLoadTest(config) {
-    const {
-      endpoint,
-      method = 'GET',
-      payload,
-      concurrent = 10,
-      duration = 60000,
-      rampUp = 5000
-    } = config;
-
-    console.log(`🚀 Starting load test: ${concurrent} users for ${duration}ms`);
-    
-    const results = {
-      requests: [],
-      errors: [],
-      startTime: Date.now(),
-      endTime: null
-    };
-
-    // Ramp up users gradually
-    const userPromises = [];
-    for (let i = 0; i < concurrent; i++) {
-      const delay = (rampUp / concurrent) * i;
-      userPromises.push(
-        this.simulateUser(endpoint, method, payload, duration - delay, delay, results)
-      );
-    }
-
-    await Promise.all(userPromises);
-    results.endTime = Date.now();
-
-    return this.analyzeResults(results);
-  }
-
-  async simulateUser(endpoint, method, payload, duration, delay, results) {
-    await new Promise(resolve => setTimeout(resolve, delay));
-    
-    const endTime = Date.now() + duration;
-    
-    while (Date.now() < endTime) {
-      const startTime = performance.now();
-      
-      try {
-        const response = await this.makeRequest(endpoint, method, payload);
-        const endTime = performance.now();
-        
-        results.requests.push({
-          startTime,
-          endTime,
-          duration: endTime - startTime,
-          status: response.status,
-          size: response.data ? JSON.stringify(response.data).length : 0
-        });
-        
-      } catch (error) {
-        results.errors.push({
-          timestamp: Date.now(),
-          error: error.message,
-          type: error.code || 'unknown'
-        });
-      }
-      
-      // Small delay between requests
-      await new Promise(resolve => setTimeout(resolve, 100));
-    }
-  }
-
-  async makeRequest(endpoint, method, payload) {
-    const axios = require('axios');
-    
-    const config = {
-      method,
-      url: endpoint,
-      timeout: 30000,
-      validateStatus: () => true
-    };
-    
-    if (payload && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
-      config.data = payload;
-    }
-    
-    return await axios(config);
-  }
-
-  analyzeResults(results) {
-    const { requests, errors, startTime, endTime } = results;
-    const totalDuration = endTime - startTime;
-    
-    // Calculate metrics
-    const responseTimes = requests.map(r => r.duration);
-    const successfulRequests = requests.filter(r => r.status < 400);
-    const failedRequests = requests.filter(r => r.status >= 400);
-    
-    const analysis = {
-      summary: {
-        totalRequests: requests.length,
-        successfulRequests: successfulRequests.length,
-        failedRequests: failedRequests.length + errors.length,
-        errorRate: (failedRequests.length + errors.length) / requests.length,
-        testDuration: totalDuration,
-        throughput: (requests.length / totalDuration) * 1000 // requests per second
-      },
-      responseTime: {
-        min: Math.min(...responseTimes),
-        max: Math.max(...responseTimes),
-        mean: responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length,
-        p50: this.percentile(responseTimes, 50),
-        p90: this.percentile(responseTimes, 90),
-        p95: this.percentile(responseTimes, 95),
-        p99: this.percentile(responseTimes, 99)
-      },
-      errors: {
-        total: errors.length,
-        byType: this.groupBy(errors, 'type'),
-        timeline: errors.map(e => ({ timestamp: e.timestamp, type: e.type }))
-      },
-      recommendations: this.generatePerformanceRecommendations(results)
-    };
-
-    this.logResults(analysis);
-    return analysis;
-  }
-
-  percentile(arr, p) {
-    const sorted = [...arr].sort((a, b) => a - b);
-    const index = Math.ceil((p / 100) * sorted.length) - 1;
-    return sorted[index];
-  }
-
-  groupBy(array, key) {
-    return array.reduce((groups, item) => {
-      const group = item[key];
-      groups[group] = groups[group] || [];
-      groups[group].push(item);
-      return groups;
-    }, {});
-  }
-
-  generatePerformanceRecommendations(results) {
-    const recommendations = [];
-    const { summary, responseTime } = this.analyzeResults(results);
-
-    if (responseTime.mean > this.thresholds.responseTime) {
-      recommendations.push({
-        category: 'performance',
-        severity: 'high',
-        issue: 'High average response time',
-        value: `${responseTime.mean.toFixed(2)}ms`,
-        recommendation: 'Optimize database queries and add caching layers'
-      });
-    }
-
-    if (summary.throughput < this.thresholds.throughput) {
-      recommendations.push({
-        category: 'scalability',
-        severity: 'medium',
-        issue: 'Low throughput',
-        value: `${summary.throughput.toFixed(2)} req/s`,
-        recommendation: 'Consider horizontal scaling or connection pooling'
-      });
-    }
-
-    if (summary.errorRate > this.thresholds.errorRate) {
-      recommendations.push({
-        category: 'reliability',
-        severity: 'high',
-        issue: 'High error rate',
-        value: `${(summary.errorRate * 100).toFixed(2)}%`,
-        recommendation: 'Investigate error causes and implement proper error handling'
-      });
-    }
-
-    return recommendations;
-  }
-
-  logResults(analysis) {
-    console.log('\n📈 Performance Test Results:');
-    console.log(`Total Requests: ${analysis.summary.totalRequests}`);
-    console.log(`Success Rate: ${((analysis.summary.successfulRequests / analysis.summary.totalRequests) * 100).toFixed(2)}%`);
-    console.log(`Throughput: ${analysis.summary.throughput.toFixed(2)} req/s`);
-    console.log(`Average Response Time: ${analysis.responseTime.mean.toFixed(2)}ms`);
-    console.log(`95th Percentile: ${analysis.responseTime.p95.toFixed(2)}ms`);
-    
-    if (analysis.recommendations.length > 0) {
-      console.log('\n⚠️ Recommendations:');
-      analysis.recommendations.forEach(rec => {
-        console.log(`- ${rec.issue}: ${rec.recommendation}`);
-      });
-    }
-  }
-}
-
-module.exports = { PerformanceTestFramework };
-```
-
-### 5. Test Automation CI/CD Integration
-```yaml
-# .github/workflows/test-automation.yml
-name: Test Automation Pipeline
-
-on:
-  push:
-    branches: [ main, develop ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  unit-tests:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Setup Node.js
-      uses: actions/setup-node@v4
-      with:
-        node-version: '18'
-        cache: 'npm'
-    
-    - name: Install dependencies
-      run: npm ci
-    
-    - name: Run unit tests
-      run: npm run test:unit -- --coverage
-    
-    - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v3
-      with:
-        file: ./coverage/lcov.info
-    
-    - name: Comment coverage on PR
-      uses: romeovs/lcov-reporter-action@v0.3.1
-      with:
-        github-token: ${{ secrets.GITHUB_TOKEN }}
-        lcov-file: ./coverage/lcov.info
-
-  integration-tests:
-    runs-on: ubuntu-latest
-    services:
-      postgres:
-        image: postgres:14
-        env:
-          POSTGRES_PASSWORD: postgres
-          POSTGRES_DB: test_db
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-      
-      redis:
-        image: redis:7
-        options: >-
-          --health-cmd "redis-cli ping"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-    
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Setup Node.js
-      uses: actions/setup-node@v4
-      with:
-        node-version: '18'
-        cache: 'npm'
-    
-    - name: Install dependencies
-      run: npm ci
-    
-    - name: Run database migrations
-      run: npm run db:migrate
-      env:
-        DATABASE_URL: postgresql://postgres:postgres@localhost:5432/test_db
-    
-    - name: Run integration tests
-      run: npm run test:integration
-      env:
-        DATABASE_URL: postgresql://postgres:postgres@localhost:5432/test_db
-        REDIS_URL: redis://localhost:6379
-
-  e2e-tests:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Setup Node.js
-      uses: actions/setup-node@v4
-      with:
-        node-version: '18'
-        cache: 'npm'
-    
-    - name: Install dependencies
-      run: npm ci
-    
-    - name: Install Playwright
-      run: npx playwright install --with-deps
-    
-    - name: Build application
-      run: npm run build
-    
-    - name: Run E2E tests
-      run: npm run test:e2e
-    
-    - name: Upload test results
-      uses: actions/upload-artifact@v3
-      if: always()
-      with:
-        name: playwright-report
-        path: playwright-report/
-        retention-days: 30
-
-  performance-tests:
-    runs-on: ubuntu-latest
-    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Setup Node.js
-      uses: actions/setup-node@v4
-      with:
-        node-version: '18'
-        cache: 'npm'
-    
-    - name: Install dependencies
-      run: npm ci
-    
-    - name: Run performance tests
-      run: npm run test:performance
-    
-    - name: Upload performance results
-      uses: actions/upload-artifact@v3
-      with:
-        name: performance-results
-        path: performance-results/
-
-  security-tests:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Run security audit
-      run: npm audit --production --audit-level moderate
-    
-    - name: Run CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
-      with:
-        languages: javascript
-```
-
-## Testing Best Practices
-
-### Test Organization
-```javascript
-// Example test structure
-describe('UserService', () => {
-  describe('createUser', () => {
-    it('should create user with valid data', async () => {
-      // Arrange
-      const userData = { email: 'test@example.com', name: 'Test User' };
-      
-      // Act
-      const result = await userService.createUser(userData);
-      
-      // Assert
-      expect(result).toHaveProperty('id');
-      expect(result.email).toBe(userData.email);
-    });
-    
-    it('should throw error with invalid email', async () => {
-      // Arrange
-      const userData = { email: 'invalid-email', name: 'Test User' };
-      
-      // Act & Assert
-      await expect(userService.createUser(userData)).rejects.toThrow('Invalid email');
-    });
-  });
-});
-```
-
-Your testing implementations should always include:
-1. **Test Strategy** - Clear testing approach and coverage goals
-2. **Automation Pipeline** - CI/CD integration with quality gates
-3. **Performance Testing** - Load testing and performance benchmarks
-4. **Quality Metrics** - Coverage, reliability, and performance tracking
-5. **Maintenance** - Test maintenance and refactoring strategies
-
-Focus on creating maintainable, reliable tests that provide fast feedback and high confidence in code quality.

.claude/agents/test-writer.md

@@ -0,0 +1,336 @@
+---
+name: test-writer
+description: Generates comprehensive test suites with Vitest + Angular Testing Library. Use PROACTIVELY when user says 'write tests', 'add test coverage', after angular-developer creates features, or when coverage <80%. Handles unit, integration tests and mocking.
+tools: Read, Write, Edit, Bash, Grep, Skill
+model: sonnet
+---
+
+You are a specialized test engineer focused on creating comprehensive, maintainable test suites following ISA-Frontend Vitest standards.
+
+## Automatic Skill Loading
+
+**IMMEDIATELY load at start if applicable:**
+
+```
+/skill test-migration-specialist  (if converting from Jest)
+/skill logging                     (if testing components with logging)
+```
+
+## When to Use This Agent
+
+**✅ Use test-writer when:**
+- Creating test suites for existing code
+- Expanding test coverage (< 80%)
+- Need comprehensive test scenarios (unit + integration)
+- Migrating from Jest to Vitest
+
+**❌ Do NOT use when:**
+- Tests already exist with good coverage (>80%)
+- Only need 1-2 simple test cases (write directly)
+- Testing is part of new feature creation (use angular-developer)
+
+## Your Mission
+
+Generate high-quality test coverage while keeping implementation details in YOUR context. Return summaries based on response_format parameter.
+
+## Workflow
+
+### 1. Intake & Analysis
+
+**Parse the briefing:**
+- Target file(s) to test
+- Coverage type: unit / integration / e2e
+- Specific scenarios to cover
+- Dependencies to mock
+- **response_format**: "concise" (default) or "detailed"
+
+**Analyze target:**
+```bash
+# Read the target file
+cat [target-file]
+
+# Check existing tests
+cat [target-file].spec.ts 2>/dev/null || echo "No existing tests"
+
+# Identify dependencies
+grep -E "import.*from" [target-file]
+```
+
+### 2. Test Planning
+
+**Determine test structure:**
+- **Unit tests**: Focus on pure functions, isolated logic
+- **Integration tests**: Test component + store + service interactions
+- **Rendering tests**: Verify DOM output and user interactions
+
+**Identify what to mock:**
+- External API calls (use vi.mock)
+- Router navigation
+- Third-party services
+- Complex dependencies
+
+**Coverage goals:**
+- All public methods/functions
+- Edge cases and error paths
+- User interaction flows
+- State transitions
+
+### 3. Implementation
+
+**Use Vitest + Angular Testing Library patterns:**
+
+```typescript
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/angular';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+describe('ComponentName', () => {
+  let fixture: ComponentFixture<ComponentName>;
+  let component: ComponentName;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [ComponentName],
+      providers: [
+        // Mock providers
+      ]
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(ComponentName);
+    component = fixture.componentInstance;
+  });
+
+  it('should render correctly', () => {
+    fixture.detectChanges();
+    expect(component).toBeTruthy();
+  });
+
+  // More tests...
+});
+```
+
+**Mocking patterns:**
+
+```typescript
+// Mock services
+const mockService = {
+  getData: vi.fn().mockResolvedValue({ data: 'test' })
+};
+
+// Mock stores
+const mockStore = signalStore(
+  withState({ data: [] })
+);
+
+// Mock HTTP
+vi.mock('@angular/common/http', () => ({
+  HttpClient: vi.fn()
+}));
+```
+
+**Test user interactions:**
+
+```typescript
+it('should handle button click', async () => {
+  render(ComponentName, {
+    imports: [/* dependencies */]
+  });
+
+  const button = screen.getByRole('button', { name: /submit/i });
+  await fireEvent.click(button);
+
+  expect(screen.getByText(/success/i)).toBeInTheDocument();
+});
+```
+
+### 4. Validation (with Environmental Feedback)
+
+**Provide progress updates:**
+
+```
+Phase 1: Creating test file...
+→ Created file.spec.ts (185 lines, 15 test cases)
+✓ File created
+
+Phase 2: Running tests...
+→ Running tests... ⚠ 12/15 passing
+
+Phase 3: Fixing failures...
+→ Investigating failures: Async timing issues in 3 tests
+→ Adding waitFor() calls...
+→ Rerunning tests... ✓ 15/15 passing
+
+Phase 4: Checking coverage...
+→ Running coverage... ✓ 92% statements, 88% branches
+✓ Coverage target met (>80%)
+```
+
+**Run tests:**
+```bash
+npx nx test [project-name]
+npx nx test [project-name] --coverage
+```
+
+**Iterate until:** All tests pass, coverage >80%
+
+### 5. Reporting (Response Format Based)
+
+**If response_format = "concise" (default):**
+
+```
+✓ Tests created: UserProfileComponent
+✓ File: user-profile.component.spec.ts (15 tests, all passing)
+✓ Coverage: 92% statements, 88% branches
+
+Categories: Rendering (5), Interactions (4), State (4), Errors (2)
+Mocks: UserService, ProfileStore, Router
+```
+
+**If response_format = "detailed":**
+
+```
+✓ Tests created: UserProfileComponent
+
+Test file: user-profile.component.spec.ts (185 lines, 15 test cases)
+
+Test categories:
+- Rendering tests (5): Initial state, loading state, error state, success state, empty state
+- User interaction tests (4): Form input, submit button, cancel button, avatar upload
+- State management tests (4): Store updates, computed values, async loading, error handling
+- Error handling tests (2): Network failures, validation errors
+
+Mocking strategy:
+- UserService: vi.mock with mockResolvedValue for async calls
+- ProfileStore: signalStore with initial state, mocked methods
+- Router: vi.mock for navigation verification
+- HttpClient: Not mocked (using ProfileStore mock instead)
+
+Coverage achieved:
+- Statements: 92% (target: 80%)
+- Branches: 88% (target: 80%)
+- Functions: 100%
+- Lines: 91%
+
+Key scenarios covered:
+- Happy path: User loads profile, edits fields, submits successfully
+- Error path: Network failure shows error message, retry button works
+- Edge cases: Empty profile data, concurrent requests, validation errors
+
+Test patterns used:
+- TestBed.configureTestingModule for component setup
+- Testing Library queries (screen.getByRole, screen.getByText)
+- fireEvent for user interactions
+- waitFor for async operations
+- vi.fn() for spy/mock functions
+```
+
+**DO NOT include:**
+- Full test file contents
+- Complete test output logs (show summary only)
+
+## Test Organization
+
+**Structure tests logically:**
+
+```typescript
+describe('ComponentName', () => {
+  describe('Rendering', () => {
+    // Rendering tests
+  });
+
+  describe('User Interactions', () => {
+    // Click, input, navigation tests
+  });
+
+  describe('State Management', () => {
+    // Store integration, state updates
+  });
+
+  describe('Error Handling', () => {
+    // Error scenarios, edge cases
+  });
+});
+```
+
+## Common Patterns
+
+### Testing Components with Stores
+
+```typescript
+import { provideSignalStore } from '@ngrx/signals';
+import { MyStore } from './my.store';
+
+beforeEach(() => {
+  TestBed.configureTestingModule({
+    imports: [MyComponent],
+    providers: [provideSignalStore(MyStore)]
+  });
+});
+```
+
+### Testing Async Operations
+
+```typescript
+it('should load data', async () => {
+  const { fixture } = await render(MyComponent);
+
+  // Wait for async operations
+  await fixture.whenStable();
+
+  expect(screen.getByText(/loaded/i)).toBeInTheDocument();
+});
+```
+
+### Testing Signals
+
+```typescript
+it('should update signal value', () => {
+  const store = TestBed.inject(MyStore);
+
+  store.updateValue('new value');
+
+  expect(store.value()).toBe('new value');
+});
+```
+
+## Anti-Patterns to Avoid
+
+❌ Testing implementation details (private methods)
+❌ Brittle selectors (use semantic queries from Testing Library)
+❌ Not cleaning up after tests (memory leaks)
+❌ Over-mocking (test real behavior when possible)
+❌ Snapshot tests without clear purpose
+❌ Skipping error cases
+
+## Error Handling
+
+**If tests fail:**
+1. Analyze failure output
+2. Fix test or identify product bug
+3. Iterate up to 3 times
+4. If still blocked, report:
+   ```
+   ⚠ Tests failing: [specific failure]
+   Failures: [X/Y tests failing]
+   Error: [concise error message]
+   Attempted: [what you tried]
+   Next step: [recommendation]
+   ```
+
+## Integration with Test Migration
+
+**If migrating from Jest:**
+- Load test-migration-specialist skill
+- Convert Spectator → Angular Testing Library
+- Replace Jest matchers with Vitest
+- Update mock patterns (jest.fn → vi.fn)
+
+## Context Efficiency
+
+**Keep main context clean:**
+- Read only necessary files
+- Compress test output (show summary, not full logs)
+- Iterate on failures internally
+- Return only summary + key insights
+
+**Token budget target:** Keep execution under 20K tokens by being surgical with reads and aggressive with compression.

.claude/agents/typescript-pro.md

@@ -1,6 +1,6 @@
 ---
 name: typescript-pro
-description: Write idiomatic TypeScript with advanced type system features, strict typing, and modern patterns. Masters generic constraints, conditional types, and type inference. Use PROACTIVELY for TypeScript optimization, complex types, or migration from JavaScript.
+description: Writes advanced TypeScript with generic constraints, conditional/mapped types, and custom type guards. Use PROACTIVELY when creating type utilities, migrating JavaScript to TypeScript, resolving complex type inference issues, or implementing strict typing.
 tools: Read, Write, Edit, Bash
 model: sonnet
 ---

.claude/agents/ui-ux-designer.md

@@ -1,36 +0,0 @@
----
-name: ui-ux-designer
-description: UI/UX design specialist for user-centered design and interface systems. Use PROACTIVELY for user research, wireframes, design systems, prototyping, accessibility standards, and user experience optimization.
-tools: Read, Write, Edit
-model: sonnet
----
-
-You are a UI/UX designer specializing in user-centered design and interface systems.
-
-## Focus Areas
-
-- User research and persona development
-- Wireframing and prototyping workflows
-- Design system creation and maintenance
-- Accessibility and inclusive design principles
-- Information architecture and user flows
-- Usability testing and iteration strategies
-
-## Approach
-
-1. User needs first - design with empathy and data
-2. Progressive disclosure for complex interfaces
-3. Consistent design patterns and components
-4. Mobile-first responsive design thinking
-5. Accessibility built-in from the start
-
-## Output
-
-- User journey maps and flow diagrams
-- Low and high-fidelity wireframes
-- Design system components and guidelines
-- Prototype specifications for development
-- Accessibility annotations and requirements
-- Usability testing plans and metrics
-
-Focus on solving user problems. Include design rationale and implementation notes.

.claude/skills/angular-effects-alternatives/SKILL.md

@@ -0,0 +1,417 @@
+---
+name: angular-effects-alternatives
+description: This skill should be used when writing Angular code with signals and effects. Use when deciding whether to use effect(), computed(), or reactive patterns for state management. Applies to all Angular components and services using signals, especially when considering effect() for state propagation, data synchronization, or reactive flows. Essential for code review of effect usage and refactoring imperative patterns to declarative alternatives.
+---
+
+# Angular Effects Alternatives
+
+## Overview
+
+This skill guides proper usage of Angular's `effect()` and provides declarative alternatives for common patterns. Effects are frequently misused for state propagation, leading to circular updates, maintenance issues, and violations of reactive principles. This skill prevents anti-patterns and promotes maintainable, declarative code.
+
+## When to Use Effects (Valid Use Cases)
+
+Effects are **primarily for rendering content that cannot be rendered through data binding**. Valid use cases are limited to:
+
+### 1. Logging
+Recording application events or debugging:
+
+```typescript
+effect(() => {
+  const error = this.error();
+  if (error) {
+    console.error('Error occurred:', error);
+  }
+});
+```
+
+### 2. Canvas Painting
+Custom graphics rendering (e.g., Angular Three library, Chart.js integration):
+
+```typescript
+effect(() => {
+  const data = this.chartData();
+  this.renderCanvas(data);
+});
+```
+
+### 3. Custom DOM Behavior
+Imperative APIs that require direct DOM manipulation:
+
+```typescript
+effect(() => {
+  const message = this.notificationMessage();
+  if (message) {
+    this.snackBar.open(message, 'Close');
+  }
+});
+```
+
+**Key principle:** Data binding is the preferred way to display data. Effects should only be used when data binding is insufficient.
+
+## Understanding Auto-Tracking
+
+Angular automatically tracks signals accessed during effect execution, **even within called methods**:
+
+```typescript
+effect(() => {
+  this.logError(); // Signal tracking happens inside this method
+});
+
+logError(): void {
+  const error = this.error(); // This signal is automatically tracked
+  if (error) {
+    console.error(error);
+  }
+}
+```
+
+**Implication:** Auto-tracking makes effect dependencies non-obvious and hard to maintain. This is a primary reason to avoid effects for state management.
+
+## When NOT to Use Effects (Anti-Patterns)
+
+### ❌ Anti-Pattern 1: State Propagation
+
+**NEVER use effects to propagate state changes to other state:**
+
+```typescript
+// ❌ WRONG - Anti-pattern
+effect(() => {
+  const value = this.source();
+  this.derived.set(value * 2);
+});
+```
+
+**Problems:**
+- Risk of circular updates and infinite loops
+- Hard to maintain due to implicit tracking
+- Violates declarative reactive principles
+- Inappropriate glitch-free semantics
+
+### ❌ Anti-Pattern 2: Synchronizing Signals
+
+```typescript
+// ❌ WRONG - Anti-pattern
+effect(() => {
+  const filter = this.filter();
+  this.loadData(filter);
+});
+```
+
+### ❌ Anti-Pattern 3: Event Emulation
+
+```typescript
+// ❌ WRONG - Anti-pattern
+effect(() => {
+  const count = this.itemCount();
+  this.countChanged.emit(count);
+});
+```
+
+**Why signals ≠ events:** Signals are designed to be glitch-free, collapsing multiple updates. This makes them inappropriate for representing discrete events.
+
+## Decision Tree: Effect vs Alternative
+
+```
+Need to react to signal changes?
+│
+├─ Synchronous derivation?
+│  └─ ✅ Use computed()
+│
+├─ Asynchronous derivation?
+│  └─ ✅ Use Resource API
+│
+├─ Complex reactive flow with race conditions?
+│  └─ ✅ Use RxJS (toObservable + operators + toSignal)
+│
+├─ Event-based trigger (not state change)?
+│  └─ ✅ React to event directly, not signal
+│
+├─ Need RxJS operators with signals?
+│  └─ ✅ Use reactive helpers (rxMethod, deriveAsync)
+│
+└─ Rendering non-data-bound content (logging, canvas, imperative API)?
+   └─ ✅ Use effect()
+```
+
+## Recommended Alternatives
+
+### Alternative 1: Use `computed()` for Synchronous Derivations
+
+**When to use:** Deriving new state synchronously from existing signals.
+
+```typescript
+// ✅ CORRECT - Declarative
+const derived = computed(() => {
+  return this.baseSignal() * 2;
+});
+
+const fullName = computed(() => {
+  return `${this.firstName()} ${this.lastName()}`;
+});
+```
+
+**Benefits:**
+- Declarative and maintainable
+- Automatic dependency tracking
+- Memoized and efficient
+- No risk of circular updates
+
+### Alternative 2: Use Resource API for Asynchronous Derivations
+
+**When to use:** Loading data based on reactive parameters.
+
+```typescript
+// ✅ CORRECT - Declarative async state
+readonly itemsResource = resource({
+  params: this.filter,
+  loader: ({ params, abortSignal }) => {
+    return this.dataService.load(params, abortSignal);
+  }
+});
+
+readonly items = computed(() => this.itemsResource.value() ?? []);
+```
+
+**Benefits:**
+- Automatic race condition handling
+- Built-in loading/error states
+- Declarative parameter tracking
+- Cancellation support
+
+**See also:** `ngrx-resource-api` skill for detailed Resource API patterns.
+
+### Alternative 3: React to Events, Not State Changes
+
+**When to use:** User interactions or DOM events should trigger actions.
+
+```typescript
+// ❌ WRONG - Reacting to signal change
+effect(() => {
+  const searchTerm = this.searchTerm();
+  this.search(searchTerm);
+});
+
+// ✅ CORRECT - React to event
+<input (input)="search($event.target.value)" />
+
+// Component
+search(term: string): void {
+  this.searchTerm.set(term);
+  this.performSearch(term);
+}
+```
+
+**Benefits:**
+- Clear causality (event → action)
+- No auto-tracking complexity
+- Explicit control flow
+
+### Alternative 4: RxJS Integration
+
+**When to use:** Complex reactive flows requiring operators like `debounceTime`, `switchMap`, `combineLatest`.
+
+```typescript
+// ✅ CORRECT - RxJS for complex flows
+readonly searchTerm = signal('');
+readonly searchTerm$ = toObservable(this.searchTerm);
+
+readonly results$ = this.searchTerm$.pipe(
+  debounceTime(300),
+  distinctUntilChanged(),
+  switchMap(term => this.searchService.search(term))
+);
+
+readonly results = toSignal(this.results$, { initialValue: [] });
+```
+
+**Benefits:**
+- Full RxJS operator ecosystem
+- Race condition prevention (`switchMap`)
+- Powerful composition
+- Type-safe streams
+
+**Pattern:** Signal → Observable (toObservable) → RxJS operators → Signal (toSignal)
+
+### Alternative 5: Reactive Helpers
+
+**When to use:** Need RxJS operators but prefer signal-centric API.
+
+#### Using `rxMethod` (NgRx Signal Store)
+
+```typescript
+readonly loadItem = rxMethod<number>(
+  pipe(
+    tap(() => patchState(this, { loading: true })),
+    switchMap(id => this.service.findById(id)),
+    tap(item => patchState(this, { item, loading: false }))
+  )
+);
+
+// Call with signal or value
+constructor() {
+  this.loadItem(this.selectedId);
+}
+```
+
+#### Using `deriveAsync` (ngxtension)
+
+```typescript
+readonly data = deriveAsync(() => {
+  const filter = this.filter();
+  return this.service.load(filter);
+});
+```
+
+**Benefits:**
+- Signal-friendly API
+- RxJS operator support
+- Cleaner than manual Observable conversion
+- Automatic subscription management
+
+## The `explicitEffect` Consideration
+
+Some libraries provide `explicitEffect` to restrict auto-tracking:
+
+```typescript
+// Uses untracked() internally to limit tracking
+explicitEffect(this.id, (id) => {
+  this.store.load(id);
+});
+```
+
+**Evaluation:**
+- ✅ Mitigates auto-tracking drawbacks
+- ✅ Makes dependencies explicit
+- ❌ Still imperative (not declarative)
+- ❌ Doesn't solve circular update risks
+- ❌ Less idiomatic than reactive alternatives
+
+**Recommendation:** Prefer declarative patterns (computed, Resource API, RxJS) over `explicitEffect`.
+
+## Common Refactoring Patterns
+
+### Pattern 1: Effect for State Sync → computed()
+
+```typescript
+// ❌ Before
+effect(() => {
+  const x = this.x();
+  const y = this.y();
+  this.sum.set(x + y);
+});
+
+// ✅ After
+readonly sum = computed(() => this.x() + this.y());
+```
+
+### Pattern 2: Effect for Async Load → Resource API
+
+```typescript
+// ❌ Before
+effect(() => {
+  const id = this.selectedId();
+  this.loadItem(id);
+});
+
+// ✅ After
+readonly itemResource = resource({
+  params: this.selectedId,
+  loader: ({ params }) => this.service.loadItem(params)
+});
+```
+
+### Pattern 3: Effect for Debounced Search → RxJS
+
+```typescript
+// ❌ Before
+effect(() => {
+  const term = this.searchTerm();
+  // No way to debounce within effect
+  this.search(term);
+});
+
+// ✅ After
+readonly searchTerm$ = toObservable(this.searchTerm);
+readonly results = toSignal(
+  this.searchTerm$.pipe(
+    debounceTime(300),
+    switchMap(term => this.searchService.search(term))
+  ),
+  { initialValue: [] }
+);
+```
+
+### Pattern 4: Effect for Event Notification → Direct Event Handling
+
+```typescript
+// ❌ Before
+effect(() => {
+  const value = this.value();
+  this.valueChange.emit(value);
+});
+
+// ✅ After
+updateValue(newValue: string): void {
+  this.value.set(newValue);
+  this.valueChange.emit(newValue);
+}
+```
+
+## Code Review Checklist
+
+When reviewing code with `effect()`, ask:
+
+- [ ] Is this for rendering non-data-bound content? (logging, canvas, imperative APIs)
+  - **YES:** Effect is appropriate
+  - **NO:** Continue checklist
+
+- [ ] Is this synchronous state derivation?
+  - **YES:** Use `computed()` instead
+
+- [ ] Is this asynchronous data loading?
+  - **YES:** Use Resource API instead
+
+- [ ] Does this need RxJS operators (debounce, switchMap, etc.)?
+  - **YES:** Use RxJS integration or reactive helpers instead
+
+- [ ] Is this reacting to a user event?
+  - **YES:** Handle event directly instead
+
+- [ ] Could this cause circular updates?
+  - **YES:** Refactor immediately - this will cause bugs
+
+## Anti-Pattern Detection Rules
+
+Flag any effect that:
+
+1. **Calls `set()` or `update()` on signals** - Likely state propagation anti-pattern
+2. **Calls service methods that update state** - Hidden state propagation
+3. **Emits events based on signal changes** - Signal/event semantic mismatch
+4. **Has try/catch for async operations** - Should use Resource API
+5. **Would benefit from debouncing/throttling** - Should use RxJS
+
+## Migration Strategy
+
+When converting effects to alternatives:
+
+1. **Identify effect purpose** - State derivation? Async load? Event handling?
+2. **Choose appropriate alternative** - Use decision tree above
+3. **Implement replacement** - Follow patterns in this skill
+4. **Test thoroughly** - Ensure reactive flow works correctly
+5. **Remove effect** - Clean up unused code
+
+## Key Principles
+
+1. **Effects are for side effects, not state management**
+2. **Prefer declarative over imperative**
+3. **Use computed() for sync, Resource API for async**
+4. **React to events, not state changes**
+5. **RxJS for complex reactive flows**
+6. **Auto-tracking is powerful but opaque - avoid when possible**
+
+## When in Doubt
+
+Ask: "Can the user see this without an effect using data binding?"
+- **YES:** Don't use effect, use data binding
+- **NO:** Effect might be appropriate (but verify against decision tree)

.claude/skills/api-change-analyzer/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: api-change-analyzer
-description: This skill should be used when analyzing Swagger/OpenAPI specification changes BEFORE regenerating API clients. It compares old vs new specs, categorizes changes as breaking/compatible/warnings, finds affected code, and generates migration strategies. Use this skill when the user wants to check API changes safely before sync, mentions "check breaking changes", or needs impact assessment.
+description: This skill should be used when checking for breaking changes before API regeneration, assessing backend API update impact, or user mentions "check breaking changes", "API diff", "impact assessment". Analyzes Swagger/OpenAPI spec changes, categorizes as breaking/compatible/warnings, and provides migration strategies.
 ---
 
 # API Change Analyzer

.claude/skills/architecture-enforcer/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: architecture-enforcer
-description: This skill should be used when validating import boundaries and architectural rules in the ISA-Frontend monorepo. It checks for circular dependencies, layer violations (Feature→Feature), domain violations (OMS→Remission), and relative imports. Use this skill when the user wants to check architecture, mentions "validate boundaries", "check imports", or needs dependency analysis.
+description: This skill should be used when checking architecture compliance, validating layer boundaries (Feature→Feature violations), detecting circular dependencies, or user mentions "check architecture", "validate boundaries", "check imports". Validates import boundaries and architectural rules in ISA-Frontend monorepo.
 ---
 
 # Architecture Enforcer

.claude/skills/circular-dependency-resolver/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: circular-dependency-resolver
-description: This skill should be used when detecting and resolving circular dependencies in the ISA-Frontend monorepo. It uses graph algorithms to find A→B→C→A cycles, categorizes by severity, provides multiple fix strategies (DI, interface extraction, shared code), and validates fixes. Use this skill when the user mentions "circular dependencies", "dependency cycles", or has build/runtime issues from circular imports.
+description: This skill should be used when build fails with circular import warnings, user mentions "circular dependencies" or "dependency cycles", or fixing A→B→C→A import cycles. Detects and resolves circular dependencies using graph algorithms with DI, interface extraction, and shared code fix strategies.
 ---
 
 # Circular Dependency Resolver

.claude/skills/css-keyframes-animations/SKILL.md

@@ -0,0 +1,392 @@
+---
+name: css-keyframes-animations
+description: This skill should be used when writing or reviewing CSS animations in Angular components. Use when creating entrance/exit animations, implementing @keyframes instead of @angular/animations, applying timing functions and fill modes, creating staggered animations, or ensuring GPU-accelerated performance. Essential for modern Angular 20+ components using animate.enter/animate.leave directives and converting legacy Angular animations to native CSS.
+---
+
+# CSS @keyframes Animations
+
+## Overview
+
+Implement native CSS @keyframes animations for Angular applications, replacing @angular/animations with GPU-accelerated, zero-bundle-size alternatives. This skill provides comprehensive guidance on creating performant entrance/exit animations, staggered effects, and proper timing configurations.
+
+## When to Use This Skill
+
+Apply this skill when:
+- **Writing Angular components** with entrance/exit animations
+- **Converting @angular/animations** to native CSS @keyframes
+- **Implementing animate.enter/animate.leave** in Angular 20+ templates
+- **Creating staggered animations** for lists or collections
+- **Debugging animation issues** (snap-back, wrong starting positions, choppy playback)
+- **Optimizing animation performance** for GPU acceleration
+- **Reviewing animation code** for accessibility and best practices
+
+## Quick Start
+
+### Basic Animation Setup
+
+1. **Define @keyframes** in component CSS:
+```css
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+```
+
+2. **Apply animation** to element:
+```css
+.element {
+  animation: fadeIn 0.3s ease-out;
+}
+```
+
+3. **Use with Angular 20+ directives**:
+```html
+@if (visible()) {
+  <div animate.enter="fade-in" animate.leave="fade-out">
+    Content
+  </div>
+}
+```
+
+### Common Pitfall: Element Snaps Back
+
+**Problem:** Element returns to original state after animation completes.
+
+**Solution:** Add `forwards` fill mode:
+```css
+.element {
+  animation: fadeOut 1s forwards;
+}
+```
+
+### Common Pitfall: Animation Conflicts with State Transitions
+
+**Problem:** Entrance animation overrides initial state transforms (e.g., stacked cards appear unstacked then jump).
+
+**Solution:** Animate only properties that don't conflict with state. Use opacity-only animations when transforms are state-driven:
+```css
+/* BAD: Overrides stacked transform */
+@keyframes cardEntrance {
+  from { transform: translateY(20px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+
+/* GOOD: Only animates opacity, allows state transforms to apply */
+@keyframes cardEntrance {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+```
+
+## Core Principles
+
+### 1. GPU-Accelerated Properties Only
+
+**Always use** for animations:
+- `transform` (translate, rotate, scale)
+- `opacity`
+
+**Avoid animating** (triggers layout recalculation):
+- `width`, `height`
+- `top`, `left`, `right`, `bottom`
+- `margin`, `padding`
+- `font-size`
+
+### 2. Fill Modes
+
+| Fill Mode | Behavior | Use Case |
+|-----------|----------|----------|
+| `forwards` | Keep end state | Exit animations (stay invisible) |
+| `backwards` | Apply start state during delay | Entrance with delay (prevent flash) |
+| `both` | Both of above | Complex sequences |
+
+### 3. Timing Functions
+
+Choose appropriate easing for animation type:
+
+```css
+/* Entrance animations - ease-out (fast start, slow end) */
+animation-timing-function: cubic-bezier(0, 0, 0.58, 1);
+
+/* Exit animations - ease-in (slow start, fast end) */
+animation-timing-function: cubic-bezier(0.42, 0, 1, 1);
+
+/* Bouncy overshoot effect */
+animation-timing-function: cubic-bezier(0.34, 1.56, 0.64, 1);
+```
+
+Tool: [cubic-bezier.com](https://cubic-bezier.com) for custom curves.
+
+### 4. Staggered Animations
+
+Create cascading effects using CSS custom properties:
+
+**Template:**
+```html
+@for (item of items(); track item.id; let idx = $index) {
+  <div [style.--i]="idx" class="stagger-item">
+    {{ item.name }}
+  </div>
+}
+```
+
+**CSS:**
+```css
+.stagger-item {
+  animation: fadeSlideIn 0.5s ease-out backwards;
+  animation-delay: calc(var(--i, 0) * 100ms);
+}
+```
+
+### 5. Accessibility
+
+Always respect reduced motion preferences:
+
+```css
+@media (prefers-reduced-motion: reduce) {
+  .animated {
+    animation: none;
+    /* Or use simpler, faster animation */
+    animation-duration: 0.1s;
+  }
+}
+```
+
+## Common Animation Patterns
+
+### Fade Entrance/Exit
+
+```css
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+@keyframes fadeOut {
+  from { opacity: 1; }
+  to { opacity: 0; }
+}
+
+.fade-in { animation: fadeIn 0.3s ease-out; }
+.fade-out { animation: fadeOut 0.3s ease-in forwards; }
+```
+
+### Slide Entrance
+
+```css
+@keyframes slideInUp {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.slide-in-up { animation: slideInUp 0.3s ease-out; }
+```
+
+### Scale Entrance
+
+```css
+@keyframes scaleIn {
+  from {
+    opacity: 0;
+    transform: scale(0.9);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+.scale-in { animation: scaleIn 0.2s ease-out; }
+```
+
+### Loading Spinner
+
+```css
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+.spinner {
+  width: 40px;
+  height: 40px;
+  border: 3px solid #f3f3f3;
+  border-top: 3px solid #3498db;
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+}
+```
+
+### Shake (Error Feedback)
+
+```css
+@keyframes shake {
+  0%, 100% { transform: translateX(0); }
+  10%, 30%, 50%, 70%, 90% { transform: translateX(-5px); }
+  20%, 40%, 60%, 80% { transform: translateX(5px); }
+}
+
+.error-input {
+  animation: shake 0.5s ease-in-out;
+}
+```
+
+## Angular 20+ Integration
+
+### Basic Usage with animate.enter/animate.leave
+
+```typescript
+@Component({
+  template: `
+    @if (show()) {
+      <div animate.enter="fade-in" animate.leave="fade-out">
+        Content
+      </div>
+    }
+  `,
+  styles: [`
+    .fade-in { animation: fadeIn 0.3s ease-out; }
+    .fade-out { animation: fadeOut 0.3s ease-in forwards; }
+
+    @keyframes fadeIn {
+      from { opacity: 0; }
+      to { opacity: 1; }
+    }
+
+    @keyframes fadeOut {
+      from { opacity: 1; }
+      to { opacity: 0; }
+    }
+  `]
+})
+```
+
+### Dynamic Animation Classes
+
+```typescript
+@Component({
+  template: `
+    @if (show()) {
+      <div [animate.enter]="enterAnim()" [animate.leave]="leaveAnim()">
+        Content
+      </div>
+    }
+  `
+})
+export class DynamicAnimComponent {
+  show = signal(false);
+  enterAnim = signal('slide-in-up');
+  leaveAnim = signal('slide-out-down');
+}
+```
+
+## Debugging Animations
+
+### Common Issues
+
+| Problem | Cause | Solution |
+|---------|-------|----------|
+| Animation doesn't run | Missing duration | Add `animation-duration: 0.3s` |
+| Element snaps back | No fill mode | Add `animation-fill-mode: forwards` |
+| Wrong starting position during delay | No backwards fill | Add `animation-fill-mode: backwards` |
+| Choppy animation | Animating layout properties | Use `transform` instead |
+| State conflict (jump/snap) | Animation overrides state transforms | Animate only opacity, not transform |
+
+### Browser DevTools
+
+- **Chrome DevTools** → More Tools → Animations panel
+- **Firefox DevTools** → Inspector → Animations tab
+
+### Animation Events
+
+```typescript
+element.addEventListener('animationend', (e) => {
+  console.log('Animation completed:', e.animationName);
+  // Clean up, remove element, etc.
+});
+```
+
+## Resources
+
+### references/keyframes-guide.md
+
+Comprehensive deep-dive covering:
+- Complete @keyframes syntax reference
+- Detailed timing functions and cubic-bezier curves
+- Advanced techniques (direction, play-state, @starting-style)
+- Performance optimization strategies
+- Extensive common patterns library
+- Debugging techniques and troubleshooting
+
+**When to reference:** Complex animation requirements, custom easing curves, advanced techniques, performance optimization, or learning comprehensive details.
+
+### assets/animations.css
+
+Ready-to-use CSS file with common animation patterns:
+- Fade animations (in/out)
+- Slide animations (up/down/left/right)
+- Scale animations (in/out)
+- Utility animations (spin, shimmer, shake, breathe, attention-pulse)
+- Toast/notification animations
+- Accessibility (@media prefers-reduced-motion)
+
+**Usage:** Copy this file to project and import in component styles or global styles:
+
+```css
+@import 'path/to/animations.css';
+```
+
+Then use classes directly:
+```html
+<div animate.enter="fade-in" animate.leave="slide-out-down">
+```
+
+## Migration from @angular/animations
+
+### Before (Angular Animations)
+
+```typescript
+import { trigger, state, style, transition, animate } from '@angular/animations';
+
+@Component({
+  animations: [
+    trigger('fadeIn', [
+      transition(':enter', [
+        style({ opacity: 0 }),
+        animate('300ms ease-out', style({ opacity: 1 }))
+      ])
+    ])
+  ]
+})
+```
+
+### After (CSS @keyframes)
+
+```typescript
+@Component({
+  template: `
+    @if (show()) {
+      <div animate.enter="fade-in">Content</div>
+    }
+  `,
+  styles: [`
+    .fade-in { animation: fadeIn 0.3s ease-out; }
+
+    @keyframes fadeIn {
+      from { opacity: 0; }
+      to { opacity: 1; }
+    }
+  `]
+})
+```
+
+**Benefits:**
+- Zero JavaScript bundle size (~60KB savings)
+- GPU hardware acceleration
+- Standard CSS (transferable skills)
+- Better performance

.claude/skills/css-keyframes-animations/assets/animations.css

@@ -0,0 +1,278 @@
+/**
+ * Reusable CSS @keyframes Animations
+ *
+ * Common animation patterns for Angular applications.
+ * Import this file in your component styles or global styles.
+ */
+
+/* ============================================
+   FADE ANIMATIONS
+   ============================================ */
+
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+@keyframes fadeOut {
+  from { opacity: 1; }
+  to { opacity: 0; }
+}
+
+.fade-in {
+  animation: fadeIn 0.3s ease-out;
+}
+
+.fade-out {
+  animation: fadeOut 0.3s ease-in;
+}
+
+/* ============================================
+   SLIDE ANIMATIONS
+   ============================================ */
+
+@keyframes slideInUp {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes slideOutDown {
+  from {
+    opacity: 1;
+    transform: translateY(0);
+  }
+  to {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+}
+
+@keyframes slideInDown {
+  from {
+    opacity: 0;
+    transform: translateY(-20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes slideOutUp {
+  from {
+    opacity: 1;
+    transform: translateY(0);
+  }
+  to {
+    opacity: 0;
+    transform: translateY(-20px);
+  }
+}
+
+@keyframes slideInLeft {
+  from {
+    opacity: 0;
+    transform: translateX(-20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateX(0);
+  }
+}
+
+@keyframes slideOutLeft {
+  from {
+    opacity: 1;
+    transform: translateX(0);
+  }
+  to {
+    opacity: 0;
+    transform: translateX(-20px);
+  }
+}
+
+@keyframes slideInRight {
+  from {
+    opacity: 0;
+    transform: translateX(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateX(0);
+  }
+}
+
+@keyframes slideOutRight {
+  from {
+    opacity: 1;
+    transform: translateX(0);
+  }
+  to {
+    opacity: 0;
+    transform: translateX(20px);
+  }
+}
+
+.slide-in-up { animation: slideInUp 0.3s ease-out; }
+.slide-out-down { animation: slideOutDown 0.3s ease-in; }
+.slide-in-down { animation: slideInDown 0.3s ease-out; }
+.slide-out-up { animation: slideOutUp 0.3s ease-in; }
+.slide-in-left { animation: slideInLeft 0.3s ease-out; }
+.slide-out-left { animation: slideOutLeft 0.3s ease-in; }
+.slide-in-right { animation: slideInRight 0.3s ease-out; }
+.slide-out-right { animation: slideOutRight 0.3s ease-in; }
+
+/* ============================================
+   SCALE ANIMATIONS
+   ============================================ */
+
+@keyframes scaleIn {
+  from {
+    opacity: 0;
+    transform: scale(0.9);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+@keyframes scaleOut {
+  from {
+    opacity: 1;
+    transform: scale(1);
+  }
+  to {
+    opacity: 0;
+    transform: scale(0.9);
+  }
+}
+
+.scale-in { animation: scaleIn 0.2s ease-out; }
+.scale-out { animation: scaleOut 0.2s ease-in; }
+
+/* ============================================
+   UTILITY ANIMATIONS
+   ============================================ */
+
+/* Loading Spinner */
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+.spin {
+  animation: spin 1s linear infinite;
+}
+
+/* Skeleton Loading */
+@keyframes shimmer {
+  0% { background-position: -200% 0; }
+  100% { background-position: 200% 0; }
+}
+
+.shimmer {
+  background: linear-gradient(
+    90deg,
+    #f0f0f0 25%,
+    #e0e0e0 50%,
+    #f0f0f0 75%
+  );
+  background-size: 200% 100%;
+  animation: shimmer 1.5s infinite;
+}
+
+/* Attention Pulse */
+@keyframes attention-pulse {
+  0%, 100% {
+    box-shadow: 0 0 0 0 rgba(59, 130, 246, 0.5);
+  }
+  50% {
+    box-shadow: 0 0 0 10px rgba(59, 130, 246, 0);
+  }
+}
+
+.attention-pulse {
+  animation: attention-pulse 2s ease-in-out infinite;
+}
+
+/* Shake (Error Feedback) */
+@keyframes shake {
+  0%, 100% { transform: translateX(0); }
+  10%, 30%, 50%, 70%, 90% { transform: translateX(-5px); }
+  20%, 40%, 60%, 80% { transform: translateX(5px); }
+}
+
+.shake {
+  animation: shake 0.5s ease-in-out;
+}
+
+/* Breathing/Pulsing */
+@keyframes breathe {
+  0%, 100% {
+    opacity: 1;
+    transform: scale(1);
+  }
+  50% {
+    opacity: 0.7;
+    transform: scale(1.05);
+  }
+}
+
+.breathe {
+  animation: breathe 2s ease-in-out infinite;
+}
+
+/* ============================================
+   TOAST/NOTIFICATION ANIMATIONS
+   ============================================ */
+
+@keyframes toastIn {
+  from {
+    opacity: 0;
+    transform: translateY(100%) scale(0.9);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
+
+@keyframes toastOut {
+  from {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+  to {
+    opacity: 0;
+    transform: translateY(100%) scale(0.9);
+  }
+}
+
+.toast-in {
+  animation: toastIn 0.3s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+
+.toast-out {
+  animation: toastOut 0.2s ease-in forwards;
+}
+
+/* ============================================
+   ACCESSIBILITY
+   ============================================ */
+
+/* Respect user's motion preferences */
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    transition-duration: 0.01ms !important;
+  }
+}

.claude/skills/css-keyframes-animations/references/keyframes-guide.md

@@ -0,0 +1,833 @@
+# CSS @keyframes Deep Dive
+
+A comprehensive guide for Angular developers transitioning from `@angular/animations` to native CSS animations.
+
+---
+
+## Table of Contents
+
+1. [Understanding @keyframes](#understanding-keyframes)
+2. [Basic Syntax](#basic-syntax)
+3. [Animation Properties](#animation-properties)
+4. [Timing Functions (Easing)](#timing-functions-easing)
+5. [Fill Modes](#fill-modes)
+6. [Advanced Techniques](#advanced-techniques)
+7. [Angular 20+ Integration](#angular-20-integration)
+8. [Common Patterns & Recipes](#common-patterns--recipes)
+9. [Performance Tips](#performance-tips)
+10. [Debugging Animations](#debugging-animations)
+
+---
+
+## Understanding @keyframes
+
+The `@keyframes` at-rule controls the intermediate steps in a CSS animation sequence by defining styles for keyframes (waypoints) along the animation. Unlike transitions (which only animate between two states), keyframes let you define multiple intermediate steps.
+
+### How It Differs from @angular/animations
+
+| @angular/animations | Native CSS @keyframes |
+|---------------------|----------------------|
+| ~60KB JavaScript bundle | Zero JS overhead |
+| CPU-based rendering | GPU hardware acceleration |
+| Angular-specific syntax | Standard CSS (transferable skills) |
+| `trigger()`, `state()`, `animate()` | `@keyframes` + CSS classes |
+
+---
+
+## Basic Syntax
+
+### The @keyframes Rule
+
+```css
+@keyframes animation-name {
+  from {
+    /* Starting styles (same as 0%) */
+  }
+  to {
+    /* Ending styles (same as 100%) */
+  }
+}
+```
+
+### Percentage-Based Keyframes
+
+For more control, use percentages to define multiple waypoints:
+
+```css
+@keyframes bounce {
+  0% {
+    transform: translateY(0);
+  }
+  25% {
+    transform: translateY(-30px);
+  }
+  50% {
+    transform: translateY(0);
+  }
+  75% {
+    transform: translateY(-15px);
+  }
+  100% {
+    transform: translateY(0);
+  }
+}
+```
+
+### Combining Multiple Percentages
+
+You can apply the same styles to multiple keyframes:
+
+```css
+@keyframes pulse {
+  0%, 100% {
+    opacity: 1;
+    transform: scale(1);
+  }
+  50% {
+    opacity: 0.7;
+    transform: scale(1.05);
+  }
+}
+```
+
+### Applying the Animation
+
+```css
+.element {
+  animation: bounce 1s ease-in-out infinite;
+}
+```
+
+---
+
+## Animation Properties
+
+### Individual Properties
+
+| Property | Description | Example |
+|----------|-------------|---------|
+| `animation-name` | Name of the @keyframes | `animation-name: bounce;` |
+| `animation-duration` | How long one cycle takes | `animation-duration: 2s;` |
+| `animation-timing-function` | Speed curve (easing) | `animation-timing-function: ease-in;` |
+| `animation-delay` | Wait before starting | `animation-delay: 500ms;` |
+| `animation-iteration-count` | How many times to run | `animation-iteration-count: 3;` or `infinite` |
+| `animation-direction` | Forward, reverse, or alternate | `animation-direction: alternate;` |
+| `animation-fill-mode` | Styles before/after animation | `animation-fill-mode: forwards;` |
+| `animation-play-state` | Pause or play | `animation-play-state: paused;` |
+
+### Shorthand Syntax
+
+```css
+/* animation: name duration timing-function delay iteration-count direction fill-mode play-state */
+.element {
+  animation: slideIn 0.5s ease-out 0.2s 1 normal forwards running;
+}
+```
+
+**Minimum required:** name and duration
+
+```css
+.element {
+  animation: fadeIn 1s;
+}
+```
+
+### Multiple Animations
+
+Apply multiple animations to a single element:
+
+```css
+.element {
+  animation:
+    fadeIn 0.5s ease-out,
+    slideUp 0.5s ease-out,
+    pulse 2s ease-in-out 0.5s infinite;
+}
+```
+
+---
+
+## Timing Functions (Easing)
+
+The timing function controls how the animation progresses over time—where it speeds up and slows down.
+
+### Keyword Values
+
+| Keyword | Cubic-Bezier Equivalent | Description |
+|---------|------------------------|-------------|
+| `linear` | `cubic-bezier(0, 0, 1, 1)` | Constant speed |
+| `ease` | `cubic-bezier(0.25, 0.1, 0.25, 1)` | Default: slow start, fast middle, slow end |
+| `ease-in` | `cubic-bezier(0.42, 0, 1, 1)` | Slow start, fast end |
+| `ease-out` | `cubic-bezier(0, 0, 0.58, 1)` | Fast start, slow end |
+| `ease-in-out` | `cubic-bezier(0.42, 0, 0.58, 1)` | Slow start and end |
+
+### Custom Cubic-Bezier
+
+Create custom easing curves with `cubic-bezier(x1, y1, x2, y2)`:
+
+```css
+/* Bouncy overshoot effect */
+.element {
+  animation-timing-function: cubic-bezier(0.68, -0.6, 0.32, 1.6);
+}
+
+/* Smooth deceleration */
+.element {
+  animation-timing-function: cubic-bezier(0.25, 1, 0.5, 1);
+}
+```
+
+**Tool:** Use [cubic-bezier.com](https://cubic-bezier.com) to visualize and create custom curves.
+
+### Popular Easing Functions
+
+```css
+/* Ease Out Quart - Great for enter animations */
+cubic-bezier(0.25, 1, 0.5, 1)
+
+/* Ease In Out Cubic - Smooth state changes */
+cubic-bezier(0.65, 0, 0.35, 1)
+
+/* Ease Out Back - Slight overshoot */
+cubic-bezier(0.34, 1.56, 0.64, 1)
+
+/* Ease In Out Back - Overshoot both ends */
+cubic-bezier(0.68, -0.6, 0.32, 1.6)
+```
+
+### Steps Function
+
+For frame-by-frame animations (like sprite sheets):
+
+```css
+/* 6 discrete steps */
+.sprite {
+  animation: walk 1s steps(6) infinite;
+}
+
+/* Step positions */
+steps(4, jump-start)  /* Jump at start of each interval */
+steps(4, jump-end)    /* Jump at end of each interval (default) */
+steps(4, jump-both)   /* Jump at both ends */
+steps(4, jump-none)   /* No jump at ends */
+```
+
+### Timing Function Per Keyframe
+
+Apply different easing to different segments:
+
+```css
+@keyframes complexMove {
+  0% {
+    transform: translateX(0);
+    animation-timing-function: ease-out;
+  }
+  50% {
+    transform: translateX(100px);
+    animation-timing-function: ease-in;
+  }
+  100% {
+    transform: translateX(200px);
+  }
+}
+```
+
+**Important:** The timing function applies to each step individually, not the entire animation.
+
+---
+
+## Fill Modes
+
+Fill modes control what styles apply before and after the animation runs.
+
+### Values
+
+| Value | Before Animation | After Animation |
+|-------|-----------------|-----------------|
+| `none` | Original styles | Original styles |
+| `forwards` | Original styles | **Last keyframe styles** |
+| `backwards` | **First keyframe styles** | Original styles |
+| `both` | **First keyframe styles** | **Last keyframe styles** |
+
+### Common Problem: Element Snaps Back
+
+```css
+/* BAD: Element disappears then reappears after animation */
+@keyframes fadeOut {
+  from { opacity: 1; }
+  to { opacity: 0; }
+}
+
+.element {
+  animation: fadeOut 1s; /* Element snaps back to opacity: 1 */
+}
+
+/* GOOD: Element stays invisible */
+.element {
+  animation: fadeOut 1s forwards;
+}
+```
+
+### Backwards Fill Mode (for delays)
+
+```css
+@keyframes slideIn {
+  from {
+    transform: translateX(-100%);
+    opacity: 0;
+  }
+  to {
+    transform: translateX(0);
+    opacity: 1;
+  }
+}
+
+/* Without backwards: element visible at original position during delay */
+/* With backwards: element starts at first keyframe position during delay */
+.element {
+  animation: slideIn 0.5s ease-out 1s backwards;
+}
+```
+
+---
+
+## Advanced Techniques
+
+### Animation Direction
+
+Control playback direction:
+
+```css
+animation-direction: normal;           /* 0% → 100% */
+animation-direction: reverse;          /* 100% → 0% */
+animation-direction: alternate;        /* 0% → 100% → 0% */
+animation-direction: alternate-reverse; /* 100% → 0% → 100% */
+```
+
+**Use Case:** Breathing/pulsing effects
+
+```css
+@keyframes breathe {
+  from { transform: scale(1); }
+  to { transform: scale(1.1); }
+}
+
+.element {
+  animation: breathe 2s ease-in-out infinite alternate;
+}
+```
+
+### Staggered Animations
+
+Create cascading effects with animation-delay:
+
+```css
+.item { animation: fadeSlideIn 0.5s ease-out backwards; }
+.item:nth-child(1) { animation-delay: 0ms; }
+.item:nth-child(2) { animation-delay: 100ms; }
+.item:nth-child(3) { animation-delay: 200ms; }
+.item:nth-child(4) { animation-delay: 300ms; }
+
+/* Or use CSS custom properties */
+.item {
+  animation: fadeSlideIn 0.5s ease-out backwards;
+  animation-delay: calc(var(--i, 0) * 100ms);
+}
+```
+
+In your template:
+
+```html
+<div class="item" style="--i: 0">First</div>
+<div class="item" style="--i: 1">Second</div>
+<div class="item" style="--i: 2">Third</div>
+```
+
+### @starting-style (Modern CSS)
+
+Define styles for when an element first enters the DOM:
+
+```css
+.modal {
+  opacity: 1;
+  transform: scale(1);
+  transition: opacity 0.3s, transform 0.3s;
+
+  @starting-style {
+    opacity: 0;
+    transform: scale(0.9);
+  }
+}
+```
+
+### Animating Auto Height
+
+Use CSS Grid for height: auto animations:
+
+```css
+.accordion-content {
+  display: grid;
+  grid-template-rows: 0fr;
+  transition: grid-template-rows 0.3s ease-out;
+}
+
+.accordion-content.open {
+  grid-template-rows: 1fr;
+}
+
+.accordion-content > div {
+  overflow: hidden;
+}
+```
+
+### Pause/Play with CSS
+
+```css
+.element {
+  animation: spin 2s linear infinite;
+  animation-play-state: running;
+}
+
+.element:hover {
+  animation-play-state: paused;
+}
+
+/* Or with a class */
+.element.paused {
+  animation-play-state: paused;
+}
+```
+
+---
+
+## Angular 20+ Integration
+
+### Using animate.enter and animate.leave
+
+Angular 20.2+ provides `animate.enter` and `animate.leave` to apply CSS classes when elements enter/leave the DOM.
+
+```typescript
+@Component({
+  selector: 'app-example',
+  template: `
+    @if (isVisible()) {
+      <div animate.enter="fade-in" animate.leave="fade-out">
+        Content here
+      </div>
+    }
+    <button (click)="toggle()">Toggle</button>
+  `,
+  styles: [`
+    .fade-in {
+      animation: fadeIn 0.3s ease-out;
+    }
+
+    .fade-out {
+      animation: fadeOut 0.3s ease-in;
+    }
+
+    @keyframes fadeIn {
+      from { opacity: 0; }
+      to { opacity: 1; }
+    }
+
+    @keyframes fadeOut {
+      from { opacity: 1; }
+      to { opacity: 0; }
+    }
+  `]
+})
+export class ExampleComponent {
+  isVisible = signal(false);
+  toggle() { this.isVisible.update(v => !v); }
+}
+```
+
+### Dynamic Animation Classes
+
+```typescript
+@Component({
+  template: `
+    @if (show()) {
+      <div [animate.enter]="enterAnimation()" [animate.leave]="leaveAnimation()">
+        Dynamic animations!
+      </div>
+    }
+  `
+})
+export class DynamicAnimComponent {
+  show = signal(false);
+  enterAnimation = signal('slide-in-right');
+  leaveAnimation = signal('slide-out-left');
+}
+```
+
+### Reusable Animation CSS File
+
+Create a shared `animations.css`:
+
+```css
+/* animations.css */
+
+/* Fade animations */
+.fade-in { animation: fadeIn 0.3s ease-out; }
+.fade-out { animation: fadeOut 0.3s ease-in; }
+
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+@keyframes fadeOut {
+  from { opacity: 1; }
+  to { opacity: 0; }
+}
+
+/* Slide animations */
+.slide-in-up { animation: slideInUp 0.3s ease-out; }
+.slide-out-down { animation: slideOutDown 0.3s ease-in; }
+
+@keyframes slideInUp {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes slideOutDown {
+  from {
+    opacity: 1;
+    transform: translateY(0);
+  }
+  to {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+}
+
+/* Scale animations */
+.scale-in { animation: scaleIn 0.2s ease-out; }
+.scale-out { animation: scaleOut 0.2s ease-in; }
+
+@keyframes scaleIn {
+  from {
+    opacity: 0;
+    transform: scale(0.9);
+  }
+  to {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+@keyframes scaleOut {
+  from {
+    opacity: 1;
+    transform: scale(1);
+  }
+  to {
+    opacity: 0;
+    transform: scale(0.9);
+  }
+}
+```
+
+Import in `styles.css` or `angular.json`:
+
+```css
+@import 'animations.css';
+```
+
+---
+
+## Common Patterns & Recipes
+
+### Loading Spinner
+
+```css
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+.spinner {
+  width: 40px;
+  height: 40px;
+  border: 3px solid #f3f3f3;
+  border-top: 3px solid #3498db;
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+}
+```
+
+### Skeleton Loading
+
+```css
+@keyframes shimmer {
+  0% { background-position: -200% 0; }
+  100% { background-position: 200% 0; }
+}
+
+.skeleton {
+  background: linear-gradient(
+    90deg,
+    #f0f0f0 25%,
+    #e0e0e0 50%,
+    #f0f0f0 75%
+  );
+  background-size: 200% 100%;
+  animation: shimmer 1.5s infinite;
+}
+```
+
+### Attention Pulse
+
+```css
+@keyframes attention-pulse {
+  0%, 100% {
+    box-shadow: 0 0 0 0 rgba(59, 130, 246, 0.5);
+  }
+  50% {
+    box-shadow: 0 0 0 10px rgba(59, 130, 246, 0);
+  }
+}
+
+.notification-badge {
+  animation: attention-pulse 2s ease-in-out infinite;
+}
+```
+
+### Shake (Error Feedback)
+
+```css
+@keyframes shake {
+  0%, 100% { transform: translateX(0); }
+  10%, 30%, 50%, 70%, 90% { transform: translateX(-5px); }
+  20%, 40%, 60%, 80% { transform: translateX(5px); }
+}
+
+.error-input {
+  animation: shake 0.5s ease-in-out;
+}
+```
+
+### Slide Down Menu
+
+```css
+@keyframes slideDown {
+  from {
+    opacity: 0;
+    transform: translateY(-10px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.dropdown-menu {
+  animation: slideDown 0.2s ease-out forwards;
+}
+```
+
+### Toast Notification
+
+```css
+@keyframes toastIn {
+  from {
+    opacity: 0;
+    transform: translateY(100%) scale(0.9);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
+
+@keyframes toastOut {
+  from {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+  to {
+    opacity: 0;
+    transform: translateY(100%) scale(0.9);
+  }
+}
+
+.toast {
+  animation: toastIn 0.3s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+
+.toast.leaving {
+  animation: toastOut 0.2s ease-in forwards;
+}
+```
+
+---
+
+## Performance Tips
+
+### Use Transform and Opacity
+
+These properties are GPU-accelerated and don't trigger layout:
+
+```css
+/* GOOD - GPU accelerated */
+@keyframes good {
+  from { transform: translateX(0); opacity: 0; }
+  to { transform: translateX(100px); opacity: 1; }
+}
+
+/* AVOID - Triggers layout recalculation */
+@keyframes avoid {
+  from { left: 0; width: 100px; }
+  to { left: 100px; width: 200px; }
+}
+```
+
+### Use will-change Sparingly
+
+```css
+.element {
+  will-change: transform, opacity;
+}
+
+/* Remove after animation */
+.element.animation-complete {
+  will-change: auto;
+}
+```
+
+### Respect Reduced Motion
+
+```css
+@keyframes fadeSlide {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.element {
+  animation: fadeSlide 0.3s ease-out;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .element {
+    animation: none;
+    /* Or use a simpler fade */
+    animation: fadeIn 0.1s ease-out;
+  }
+}
+```
+
+### Avoid Animating Layout Properties
+
+Properties that trigger layout (reflow):
+
+- `width`, `height`
+- `top`, `left`, `right`, `bottom`
+- `margin`, `padding`
+- `font-size`
+- `border-width`
+
+Use `transform: scale()` instead of `width/height` when possible.
+
+---
+
+## Debugging Animations
+
+### Browser DevTools
+
+1. **Chrome DevTools** → More Tools → Animations
+   - Pause, slow down, or step through animations
+   - Inspect timing curves
+
+2. **Firefox** → Inspector → Animations tab
+   - Visual timeline of all animations
+
+### Force Slow Motion
+
+```css
+/* Temporarily add to debug */
+* {
+  animation-duration: 3s !important;
+}
+```
+
+### Animation Events in JavaScript
+
+```typescript
+element.addEventListener('animationstart', (e) => {
+  console.log('Started:', e.animationName);
+});
+
+element.addEventListener('animationend', (e) => {
+  console.log('Ended:', e.animationName);
+  // Clean up class, remove element, etc.
+});
+
+element.addEventListener('animationiteration', (e) => {
+  console.log('Iteration:', e.animationName);
+});
+```
+
+### Common Issues
+
+| Problem | Solution |
+|---------|----------|
+| Animation not running | Check `animation-duration` is > 0 |
+| Element snaps back | Add `animation-fill-mode: forwards` |
+| Animation starts wrong | Use `animation-fill-mode: backwards` with delay |
+| Choppy animation | Use `transform` instead of layout properties |
+| Animation restarts on state change | Ensure Angular doesn't recreate the element |
+
+---
+
+## Quick Reference Card
+
+```css
+/* Basic setup */
+@keyframes name {
+  from { /* start */ }
+  to { /* end */ }
+}
+
+.element {
+  animation: name 0.3s ease-out forwards;
+}
+
+/* Angular 20+ */
+<div animate.enter="fade-in" animate.leave="fade-out">
+
+/* Shorthand order */
+animation: name duration timing delay count direction fill-mode state;
+
+/* Common timing functions */
+ease-out: cubic-bezier(0, 0, 0.58, 1)      /* Enter animations */
+ease-in: cubic-bezier(0.42, 0, 1, 1)       /* Exit animations */
+ease-in-out: cubic-bezier(0.42, 0, 0.58, 1) /* State changes */
+
+/* Fill modes */
+forwards  → Keep end state
+backwards → Apply start state during delay
+both      → Both of the above
+```
+
+---
+
+## Resources
+
+- [MDN CSS Animations Guide](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_animations/Using_CSS_animations)
+- [Angular Animation Migration Guide](https://angular.dev/guide/animations/migration)
+- [Cubic Bezier Tool](https://cubic-bezier.com)
+- [Easing Functions Cheat Sheet](https://easings.net)
+- [Josh W. Comeau's Keyframe Guide](https://www.joshwcomeau.com/animation/keyframe-animations/)

.claude/skills/git-workflow/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: git-workflow
-description: Enforces ISA-Frontend project Git workflow conventions including branch naming, conventional commits, and PR creation against develop branch
+description: This skill should be used when creating branches, writing commits, or creating pull requests. Enforces ISA-Frontend Git conventions including feature/task-id-name branch format, conventional commits without co-author tags, and PRs targeting develop branch.
 ---
 
 # Git Workflow Skill

.claude/skills/library-scaffolder/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: library-scaffolder
-description: This skill should be used when creating new Angular libraries in the ISA-Frontend monorepo. It handles Nx library generation with proper naming conventions, Vitest configuration with JUnit/Cobertura reporters, path alias setup, and validation. Use this skill when the user wants to create a new library, scaffold a feature/data-access/ui/util library, or requests "new library" creation.
+description: This skill should be used when creating feature/data-access/ui/util libraries or user says "create library", "new library", "scaffold library". Creates new Angular libraries in ISA-Frontend monorepo with proper Nx configuration, Vitest setup, architectural tags, and path aliases.
 ---
 
 # Library Scaffolder
@@ -51,6 +51,7 @@ npx nx generate @nx/angular:library \
   --name=[domain]-[layer]-[name] \
   --directory=libs/[domain]/[layer]/[name] \
   --importPath=@isa/[domain]/[layer]/[name] \
+  --prefix=[domain] \
   --style=css \
   --unitTestRunner=vitest \
   --standalone=true \
@@ -69,13 +70,53 @@ npx nx generate @nx/angular:library \
   --name=[domain]-[layer]-[name] \
   --directory=libs/[domain]/[layer]/[name] \
   --importPath=@isa/[domain]/[layer]/[name] \
+  --prefix=[domain] \
   --style=css \
   --unitTestRunner=vitest \
   --standalone=true \
   --skipTests=false
 ```
 
-### Step 4: Configure Vitest with JUnit and Cobertura
+### Step 4: Add Architectural Tags
+
+**CRITICAL**: Immediately after library generation, add proper tags to `project.json` for `@nx/enforce-module-boundaries`.
+
+Run the tagging script:
+```bash
+node scripts/add-library-tags.js
+```
+
+Or manually add tags to `libs/[domain]/[layer]/[name]/project.json`:
+
+```json
+{
+  "name": "[domain]-[layer]-[name]",
+  "tags": [
+    "scope:[domain]",
+    "type:[layer]"
+  ]
+}
+```
+
+**Tag Rules:**
+- **Scope tag**: `scope:[domain]` (e.g., `scope:oms`, `scope:crm`, `scope:ui`, `scope:shared`)
+- **Type tag**: `type:[layer]` (e.g., `type:feature`, `type:data-access`, `type:ui`, `type:util`)
+
+**Examples:**
+- `libs/oms/feature/return-search` → `["scope:oms", "type:feature"]`
+- `libs/ui/buttons` → `["scope:ui", "type:ui"]`
+- `libs/shared/scanner` → `["scope:shared", "type:shared"]`
+- `libs/core/auth` → `["scope:core", "type:core"]`
+
+**Verification:**
+```bash
+# Check tags were added
+cat libs/[domain]/[layer]/[name]/project.json | jq '.tags'
+
+# Should output: ["scope:[domain]", "type:[layer]"]
+```
+
+### Step 5: Configure Vitest with JUnit and Cobertura
 
 Update `libs/[path]/vite.config.mts`:
 
@@ -113,7 +154,7 @@ defineConfig(() => ({
 
 **Critical**: Adjust path depth based on library location.
 
-### Step 5: Verify Configuration
+### Step 6: Verify Configuration
 
 1. **Check Path Alias**
    - Verify `tsconfig.base.json` was updated
@@ -128,7 +169,7 @@ defineConfig(() => ({
    - JUnit XML: `testresults/junit-[library-name].xml`
    - Cobertura XML: `coverage/libs/[path]/cobertura-coverage.xml`
 
-### Step 6: Create Library README
+### Step 7: Create Library README
 
 Use `docs-researcher` to find similar library READMEs, then create comprehensive documentation including:
 - Overview and purpose
@@ -137,7 +178,7 @@ Use `docs-researcher` to find similar library READMEs, then create comprehensive
 - Usage examples
 - Testing information (Vitest + Angular Testing Utilities)
 
-### Step 7: Update Library Reference
+### Step 8: Update Library Reference
 
 Add entry to `docs/library-reference.md` under appropriate domain:
 
@@ -150,10 +191,10 @@ Add entry to `docs/library-reference.md` under appropriate domain:
 [Brief description]
 ```
 
-### Step 8: Run Full Validation
+### Step 9: Run Full Validation
 
 ```bash
-# Lint
+# Lint (includes boundary checks)
 npx nx lint [library-name]
 
 # Test with coverage
@@ -166,7 +207,7 @@ npx nx build [library-name]
 npx nx graph --focus=[library-name]
 ```
 
-### Step 9: Generate Creation Report
+### Step 10: Generate Creation Report
 
 ```
 Library Created Successfully
@@ -181,6 +222,7 @@ Import Alias: @isa/[domain]/[layer]/[name]
 Test Framework: Vitest with Angular Testing Utilities
 Style: CSS
 Standalone: Yes
+Tags: scope:[domain], type:[layer]
 JUnit Reporter: ✅ testresults/junit-[library-name].xml
 Cobertura Coverage: ✅ coverage/libs/[path]/cobertura-coverage.xml
 
@@ -193,12 +235,18 @@ import { Component } from '@isa/[domain]/[layer]/[name]';
 npx nx test [library-name] --skip-nx-cache
 npx nx test [library-name] --coverage.enabled=true --skip-nx-cache
 
+🏗️ Architecture Compliance
+--------------------------
+Tags enforce module boundaries via @nx/enforce-module-boundaries
+Run lint to check for violations: npx nx lint [library-name]
+
 📝 Next Steps
 -------------
 1. Develop library features
 2. Write tests using Vitest + Angular Testing Utilities
 3. Add E2E attributes (data-what, data-which) to templates
 4. Update README with usage examples
+5. Follow architecture rules (see eslint.config.js for constraints)
 ```
 
 ## Error Handling
@@ -220,4 +268,8 @@ npx nx test [library-name] --coverage.enabled=true --skip-nx-cache
 - docs/guidelines/testing.md (Vitest, JUnit, Cobertura sections)
 - docs/library-reference.md (domain patterns)
 - CLAUDE.md (Library Organization, Testing Framework sections)
+- eslint.config.js (@nx/enforce-module-boundaries configuration)
+- scripts/add-library-tags.js (automatic tagging script)
+- .claude/skills/architecture-enforcer (boundary validation)
 - Nx Angular Library Generator: https://nx.dev/nx-api/angular/generators/library
+- Nx Enforce Module Boundaries: https://nx.dev/nx-api/eslint-plugin/documents/enforce-module-boundaries

.claude/skills/ngrx-resource-api/SKILL.md

@@ -0,0 +1,287 @@
+---
+name: ngrx-resource-api
+description: This skill should be used when implementing Angular's Resource API with NgRx Signal Store for reactive data management. Use when creating signal stores that load data reactively, need automatic race condition prevention, or require declarative resource management without RxJS. Applies to data-access libraries, feature stores with API integration, and components needing reactive filtering or pagination.
+---
+
+# NgRx Resource API
+
+## Overview
+
+This skill enables integration of Angular's Resource API with NgRx Signal Store to create reactive data flows without RxJS while automatically preventing race conditions. The Resource API handles concurrent request management declaratively, eliminating manual `switchMap` or `takeUntilDestroyed` patterns.
+
+## Core Architectural Concepts
+
+### Reactive Flow Graph
+
+Establish three clear interaction points in the store:
+
+1. **Filter signals trigger resource loading** - Parameter changes automatically reload resources
+2. **Methods explicitly invoke operations** - Use `signalMethod` for user-triggered actions
+3. **Computed signals derive view models** - Transform loaded data for component consumption
+
+### The withProps Pattern for Dependency Injection
+
+Inject services via `withProps` with underscore-prefixed properties to mark them as internal implementation details:
+
+```typescript
+withProps(() => ({
+  _dataService: inject(DataService),
+  _notificationService: inject(ToastService),
+}))
+```
+
+**Benefits:**
+- Centralizes dependency injection in one location
+- Clear distinction between internal (prefixed) and public properties
+- Services available to all subsequent feature sections
+
+## Implementation Steps
+
+### Step 1: Inject Services with withProps
+
+Create the initial `withProps` section to inject required services:
+
+```typescript
+export const MyStore = signalStore(
+  withProps(() => ({
+    _dataService: inject(DataService),
+    _toastService: inject(ToastService),
+  })),
+  // ... additional features
+);
+```
+
+**Naming convention:** Prefix all injected services with underscore (`_`) to indicate internal use.
+
+### Step 2: Define Filter State
+
+Add state properties that will serve as resource parameters:
+
+```typescript
+withState({
+  filter: {
+    searchTerm: '',
+    category: '',
+  } as MyFilter,
+})
+```
+
+### Step 3: Configure Resources
+
+In a subsequent `withProps` section, create resources that reference the injected services and state:
+
+```typescript
+withProps((store) => ({
+  _itemsResource: resource({
+    params: store.filter,
+    loader: (loaderParams) => {
+      const filter = loaderParams.params;
+      const abortSignal = loaderParams.abortSignal;
+      return store._dataService.loadItems(filter, abortSignal);
+    }
+  })
+}))
+```
+
+**Key points:**
+- Resources automatically reload when `params` signal changes
+- `abortSignal` enables automatic cancellation of in-flight requests
+- Loader must return a Promise (use `.findPromise()` if service returns Observable)
+
+### Step 4: Expose Read-Only Resources (Optional)
+
+If the resource should be accessible to consumers, expose it as read-only:
+
+```typescript
+withProps((store) => ({
+  itemsResource: store._itemsResource.asReadonly(),
+}))
+```
+
+**Pattern:** Internal resources use underscore prefix, public versions are read-only without prefix.
+
+### Step 5: Create Signal Methods for Updates
+
+Use `signalMethod` for actions that update state and trigger resource reloads:
+
+```typescript
+withMethods((store) => ({
+  updateFilter: signalMethod<MyFilter>((filter) => {
+    patchState(store, { filter });
+  }),
+
+  refresh: () => {
+    store._itemsResource.reload();
+  }
+}))
+```
+
+**Important:** `signalMethod` implementations are **untracked by convention** - they don't re-execute when signals change. This provides explicit control flow.
+
+### Step 6: Add Error Handling
+
+Use `withHooks` to react to resource errors:
+
+```typescript
+withHooks({
+  onInit: (store) => {
+    effect(() => {
+      const error = store._itemsResource.error();
+      if (error) {
+        store._toastService.show('Error: ' + getMessage(error));
+      }
+    });
+  }
+})
+```
+
+**Pattern:** Error effects should be read-only - they observe errors and trigger side effects, but don't modify state.
+
+## Common Patterns
+
+### Template Integration with linkedSignal
+
+For two-way form binding that synchronizes with the store:
+
+```typescript
+export class MyComponent {
+  #store = inject(MyStore);
+
+  // Create linked signal for form field
+  searchTerm = linkedSignal(() => this.#store.filter().searchTerm);
+
+  // Combine form fields into filter object
+  #linkedFilter = computed(() => ({
+    searchTerm: this.searchTerm(),
+    // ... other fields
+  }));
+
+  constructor() {
+    // Sync form changes back to store
+    this.#store.updateFilter(this.#linkedFilter);
+  }
+}
+```
+
+**Benefits:**
+- Two-way binding for forms
+- Automatic store synchronization
+- Type-safe filter construction
+
+### Working with Resource Data
+
+Access resource data through resource signals:
+
+```typescript
+withComputed((store) => ({
+  items: computed(() => store._itemsResource.value() ?? []),
+  isLoading: computed(() => store._itemsResource.isLoading()),
+  hasError: computed(() => store._itemsResource.hasError()),
+}))
+```
+
+**Available signals:**
+- `value()` - The loaded data (undefined while loading)
+- `isLoading()` - Loading state boolean
+- `hasError()` - Error state boolean
+- `error()` - Error object if present
+- `status()` - Overall status: 'idle' | 'loading' | 'resolved' | 'error'
+
+### Updating Resource Data Locally
+
+For temporary working copies before server writes:
+
+```typescript
+withMethods((store) => ({
+  updateLocalItem: (id: string, changes: Partial<Item>) => {
+    store._itemsResource.update((currentItems) => {
+      return currentItems.map(item =>
+        item.id === id ? { ...item, ...changes } : item
+      );
+    });
+  }
+}))
+```
+
+**Note:** This pattern feels unconventional but aligns with maintaining temporary working copies before server persistence.
+
+### Multiple Resources in One Store
+
+Combine multiple resources for complex data requirements:
+
+```typescript
+withProps((store) => ({
+  _itemsResource: resource({
+    params: store.filter,
+    loader: (params) => store._dataService.loadItems(params.params, params.abortSignal)
+  }),
+
+  _detailsResource: resource({
+    params: store.selectedId,
+    loader: (params) => {
+      if (!params.params) return Promise.resolve(null);
+      return store._dataService.loadDetails(params.params, params.abortSignal);
+    }
+  })
+}))
+```
+
+**Pattern:** Each resource has independent params and loading state, but can share service instances.
+
+## Important Considerations
+
+### Race Condition Prevention
+
+The Resource API automatically handles race conditions:
+- New requests automatically cancel pending requests
+- No need for `switchMap`, `takeUntilDestroyed`, or manual abort handling
+- Declarative parameter changes trigger clean cancellation
+
+### Untracked Signal Methods
+
+`signalMethod` implementations deliberately skip reactive tracking:
+- Provides explicit, predictable control flow
+- Prevents unexpected re-executions from signal changes
+- Makes side effects obvious at call sites
+
+### Loader Function Requirements
+
+Loaders must:
+- Return a `Promise` (not Observable)
+- Accept and pass through the `abortSignal` to enable cancellation
+- Handle the signal in the underlying HTTP call
+
+**Converting Observables:**
+```typescript
+loader: (params) => {
+  return firstValueFrom(
+    this._service.load$(params.params)
+      .pipe(takeUntilDestroyed(this._destroyRef))
+  );
+}
+```
+
+### Resource Lifecycle
+
+Resources maintain their own state machine:
+1. **Idle** - Initial state before first load
+2. **Loading** - Request in progress
+3. **Resolved** - Data loaded successfully
+4. **Error** - Request failed
+
+State transitions automatically trigger reactive updates to dependent computeds and effects.
+
+## When to Use This Pattern
+
+**Use Resource API with Signal Store when:**
+- Loading data based on reactive filter/search parameters
+- Need automatic race condition handling for concurrent requests
+- Want declarative data loading without RxJS subscriptions
+- Building stores with frequently changing query parameters
+- Implementing pagination, filtering, or search features
+
+**Consider alternatives when:**
+- Simple one-time data loads (use `rxMethod` or direct service calls)
+- Complex Observable chains with multiple operators needed
+- Need fine-grained control over request timing/caching
+- Working with WebSocket or SSE streams (use `rxMethod` instead)

.gitignore

@@ -80,3 +80,6 @@ CLAUDE.md
 *.pyc
 .vite
 reports/
+
+# Local iPad dev setup (proxy)
+/local-dev/

.mcp.json

@@ -1,22 +1,22 @@
-{
-  "mcpServers": {
-    "context7": {
-      "type": "http",
-      "url": "https://mcp.context7.com/mcp"
-    },
-    "nx-mcp": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["nx-mcp@latest"]
-    },
-    "angular-mcp": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["@angular/cli", "mcp"]
-    },
-    "figma-desktop": {
-      "type": "http",
-      "url": "http://127.0.0.1:3845/mcp"
-    }
-  }
-}
+{
+  "mcpServers": {
+    "context7": {
+      "type": "http",
+      "url": "https://mcp.context7.com/mcp"
+    },
+    "nx-mcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["nx", "mcp"]
+    },
+    "angular-mcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["@angular/cli", "mcp"]
+    },
+    "figma-desktop": {
+      "type": "http",
+      "url": "http://127.0.0.1:3845/mcp"
+    }
+  }
+}

AGENTS.md

@@ -0,0 +1,13 @@
+<!-- nx configuration start-->
+<!-- Leave the start & end comments to automatically receive updates. -->
+
+# General Guidelines for working with Nx
+
+- When running tasks (for example build, lint, test, e2e, etc.), always prefer running the task through `nx` (i.e. `nx run`, `nx run-many`, `nx affected`) instead of using the underlying tooling directly
+- You have access to the Nx MCP server and its tools, use them to help the user
+- When answering questions about the repository, use the `nx_workspace` tool first to gain an understanding of the workspace architecture where applicable.
+- When working in individual projects, use the `nx_project_details` mcp tool to analyze and understand the specific project structure and dependencies
+- For questions around nx configuration, best practices or if you're unsure, use the `nx_docs` tool to get relevant, up-to-date docs. Always use this instead of assuming things about nx configuration
+- If the user needs help with an Nx configuration or project graph error, use the `nx_workspace` tool to get any errors
+
+<!-- nx configuration end-->

CLAUDE.md

@@ -5,6 +5,7 @@ This file contains meta-instructions for how Claude should work with the ISA-Fro
 ## 🔴 CRITICAL: Mandatory Agent Usage
 
 **You MUST use these subagents for ALL research and knowledge management tasks:**
+
 - **`docs-researcher`**: For ALL documentation (packages, libraries, READMEs)
 - **`docs-researcher-advanced`**: Auto-escalate when docs-researcher fails
 - **`Explore`**: For ALL code pattern searches and multi-file analysis
@@ -14,25 +15,137 @@ This file contains meta-instructions for how Claude should work with the ISA-Fro
 ## Communication Guidelines
 
 **Keep answers concise and focused:**
+
 - Provide direct, actionable responses without unnecessary elaboration
 - Skip verbose explanations unless specifically requested
 - Focus on what the user needs to know, not everything you know
 - Use bullet points and structured formatting for clarity
 - Only provide detailed explanations when complexity requires it
 
+## 🔴 CRITICAL: Mandatory Skill Usage
+
+**Skills are project-specific tools that MUST be used proactively for their domains.**
+
+### Skill vs Agent vs Direct Tools
+
+| Tool Type | Purpose | When to Use | Context Management |
+|-----------|---------|-------------|-------------------|
+| **Skills** | Domain-specific workflows (Angular, testing, architecture) | Writing/reviewing code in skill's domain | Load skill → follow instructions → unload |
+| **Agents** | Research & knowledge gathering | Finding docs, searching code, analysis | Use agent → extract findings → discard output |
+| **Direct Tools** | Single file operations | Reading specific known files | Use tool → process → done |
+
+### Mandatory Skill Invocation Rules
+
+**ALWAYS invoke skills when:**
+
+| Trigger | Required Skill | Why |
+|---------|---------------|-----|
+| Writing Angular templates | `angular-template` | Modern syntax (@if, @for, @defer) |
+| Writing HTML with interactivity | `html-template` | E2E attributes (data-what, data-which) + ARIA |
+| Applying Tailwind classes | `tailwind` | Design system consistency |
+| Writing Angular code | `logging` | Mandatory logging via @isa/core/logging |
+| Creating CSS animations | `css-keyframes-animations` | Native @keyframes + animate.enter/leave + GPU acceleration |
+| Creating new library | `library-scaffolder` | Proper Nx setup + Vitest config |
+| Regenerating API clients | `swagger-sync-manager` | All 10 clients + validation |
+| Migrating to standalone | `standalone-component-migrator` | Complete migration workflow |
+| Migrating tests to Vitest | `test-migration-specialist` | Jest→Vitest conversion |
+| Fixing `any` types | `type-safety-engineer` | Add Zod schemas + type guards |
+| Checking architecture | `architecture-enforcer` | Import boundaries + circular deps |
+| Resolving circular deps | `circular-dependency-resolver` | Graph analysis + fix strategies |
+| API changes analysis | `api-change-analyzer` | Breaking change detection |
+| Git workflow | `git-workflow` | Branch naming + conventional commits |
+
+### Proactive Skill Usage Framework
+
+**"Proactive" means:**
+1. **Detect task domain automatically** - Don't wait for user to say "use skill X"
+2. **Invoke before starting work** - Load skill first, then execute
+3. **Apply throughout task** - Keep skill active for entire domain work
+4. **Validate with skill** - Use skill to review your own output
+
+**Example - WRONG:**
+```
+User: "Add a new Angular component with a form"
+Assistant: [Writes component without skills]
+User: "Did you use the Angular template skill?"
+Assistant: "Oh sorry, let me reload with the skill"
+```
+
+**Example - RIGHT:**
+```
+User: "Add a new Angular component with a form"
+Assistant: [Invokes angular-template skill]
+Assistant: [Invokes html-template skill]
+Assistant: [Invokes logging skill]
+Assistant: [Writes component following all skill guidelines]
+```
+
+### Skill Chaining & Coordination
+
+**Multiple skills often apply to same task:**
+
+| Task | Required Skill Chain | Order |
+|------|---------------------|-------|
+| New Angular component | `angular-template` → `html-template` → `logging` → `tailwind` | Template syntax → HTML attributes → Logging → Styling |
+| Component with animations | `angular-template` → `html-template` → `css-keyframes-animations` → `logging` → `tailwind` | Template → HTML → Animations → Logging → Styling |
+| New library | `library-scaffolder` → `architecture-enforcer` | Scaffold → Validate structure |
+| API sync | `api-change-analyzer` → `swagger-sync-manager` | Analyze changes → Regenerate clients |
+| Component migration | `standalone-component-migrator` → `test-migration-specialist` | Migrate component → Migrate tests |
+
+**Skill chaining rules:**
+- Load ALL applicable skills at task start (via Skill tool)
+- Skills don't nest - they provide instructions you follow
+- Skills stay active for entire task scope
+- Validate final output against ALL loaded skills
+
+### Skill Context Management
+
+**Skills expand instructions into your context:**
+
+- ✅ **DO**: Load skill → internalize rules → follow throughout task
+- ❌ **DON'T**: Re-read skill instructions multiple times
+- ❌ **DON'T**: Quote skill instructions back to user
+- ❌ **DON'T**: Keep skill "open" after task completion
+
+**After task completion:**
+1. Verify work against skill requirements
+2. Summarize what was applied (1 sentence)
+3. Move on (skill context auto-clears next task)
+
+### Skill Failure Handling
+
+| Issue | Action |
+|-------|--------|
+| Skill not found | Verify skill name; ask user to check available skills |
+| Skill conflicts with user request | Note conflict; ask user for preference |
+| Multiple skills give conflicting rules | Follow most specific skill for current file type |
+| Skill instructions unclear | Use best judgment; document assumption in code comment |
+
+### Skills vs Agents - Decision Tree
+
+```
+Is this a code writing/reviewing task?
+├─ YES → Check if skill exists for domain
+│         ├─ Skill exists → Use Skill
+│         └─ No skill → Use direct tools
+└─ NO → Is this research/finding information?
+          ├─ YES → Use Agent (docs-researcher/Explore)
+          └─ NO → Use direct tools (Read/Edit/Bash)
+```
+
 ## Researching and Investigating the Codebase
 
 **🔴 MANDATORY: You MUST use subagents for research. Direct file reading/searching.**
 
 ### Required Agent Usage
 
-| Task Type | Required Agent | Escalation Path |
-|-----------|---------------|-----------------|
-| **Package/Library Documentation** | `docs-researcher` | → `docs-researcher-advanced` if not found |
-| **Internal Library READMEs** | `docs-researcher` | Keep context clean |
-| **Code Pattern Search** | `Explore` | Set thoroughness level |
-| **Implementation Analysis** | `Explore` | Multiple file analysis |
-| **Single Specific File** | Read tool directly | No agent needed |
+| Task Type                         | Required Agent     | Escalation Path                           |
+| --------------------------------- | ------------------ | ----------------------------------------- |
+| **Package/Library Documentation** | `docs-researcher`  | → `docs-researcher-advanced` if not found |
+| **Internal Library READMEs**      | `docs-researcher`  | Keep context clean                        |
+| **Code Pattern Search**           | `Explore`          | Set thoroughness level                    |
+| **Implementation Analysis**       | `Explore`          | Multiple file analysis                    |
+| **Single Specific File**          | Read tool directly | No agent needed                           |
 
 ### Documentation Research System (Two-Tier)
 
@@ -57,3 +170,737 @@ This file contains meta-instructions for how Claude should work with the ISA-Fro
 ```
 
 **Remember: Using subagents is NOT optional - it's mandatory for maintaining context efficiency and search quality.**
+
+## 🔴 CRITICAL: Context Management for Reliable Subagent Usage
+
+**Context bloat kills reliability. You MUST follow these rules:**
+
+### Context Preservation Rules
+
+- **NEVER include full agent results in main conversation** - Summarize findings in 1-2 sentences
+- **NEVER repeat information** - Once extracted, don't include raw agent output again
+- **NEVER accumulate intermediate steps** - Keep only final answers/decisions
+- **DISCARD immediately after use**: Raw JSON responses, full file listings, irrelevant search results
+- **KEEP only**: Key findings, extracted values, decision rationale
+
+### Agent Invocation Patterns
+
+| Pattern | When to Use | Rules |
+|---------|-----------|-------|
+| **Sequential** | Agent 1 results inform Agent 2 | Wait for Agent 1 result before invoking Agent 2 |
+| **Parallel** | Independent research needs | Max 2-3 agents in parallel; different domains only |
+| **Escalation** | First agent insufficient | Invoke only if first agent returns "not found" or insufficient |
+
+### Result Handling & Synthesis
+
+**After each agent completes:**
+
+1. Extract the specific answer needed (1-3 key points when possible)
+2. Discard raw output from conversation context
+3. If synthesizing multiple sources, create brief summary table/list
+4. Reference sources only if user asks "where did you find this?"
+
+**If result can't be summarized in 1-2 sentences:**
+
+- Use **structured formats**: Tables, bullet lists, code blocks (not prose walls)
+- Group by category/concept, not by source
+- Include only information relevant to the current task
+- Ask yourself: "Does the user need all this detail, or am I including 'just in case'?" → If just in case, cut it
+
+**Example - WRONG:**
+```
+Docs researcher returned: [huge JSON with 100 properties...]
+The relevant ones are X, Y, Z...
+```
+
+**Example - RIGHT (simple):**
+```
+docs-researcher found: The API supports async/await with TypeScript strict mode.
+```
+
+**Example - RIGHT (complex, structured):**
+```
+docs-researcher found migration requires 3 steps:
+1. Update imports (see migration guide section 2.1)
+2. Change type definitions (example in docs)
+3. Update tests (patterns shown)
+```
+
+### Parallel Agent Execution
+
+Use parallel execution (single message, multiple tool calls) ONLY when:
+- Agents are researching **different domains** (e.g., Zod docs + Angular docs)
+- Agents have **no dependencies** (neither result informs the other)
+- Results will be **independently useful** to the user
+
+NEVER parallel if: One agent's findings should guide the next agent's search.
+
+### Session Coordination
+
+- **One primary task focus** per session phase
+- **Related agents run together** (e.g., all docs research at start)
+- **Discard intermediate context** between task phases
+- **Summarize phase results** before moving to implementation phase
+
+## Edge Cases & Failure Handling
+
+### Agent Failures & Timeouts
+
+| Failure Type | Action | Fallback |
+|-------------|--------|----------|
+| **Timeout (>2min)** | Retry once with simpler query | Use direct tools if critical |
+| **Error/Exception** | Check query syntax, retry with fix | Escalate to advanced agent |
+| **Empty result** | Verify target exists first | Try alternative search terms |
+| **Conflicting results** | Run third agent as tiebreaker | Present both with confidence levels |
+
+### User Direction Changes
+
+**If user pivots mid-research:**
+1. STOP current agent chain immediately
+2. Summarize what was found so far (1 sentence)
+3. Ask: "Should I continue the original research or focus on [new direction]?"
+4. Clear context from abandoned path
+
+### Model Selection (Haiku vs Sonnet)
+
+| Use Haiku for | Use Sonnet for |
+|---------------|----------------|
+| Single file lookups | Multi-file synthesis |
+| Known documentation paths | Complex pattern analysis |
+| <5 min expected time | Architectural decisions |
+| Well-defined searches | Ambiguous requirements |
+
+### Resume vs Fresh Agent
+
+**Use resume parameter when:**
+- Previous agent was interrupted by user
+- Need to continue exact same search with more context
+- Building on partial results from <5 min ago
+
+**Start fresh when:**
+- Different search angle needed
+- Previous results >5 min old
+- Switching between task types
+
+### Result Validation
+
+**Always validate when:**
+- Version-specific documentation (check version matches project)
+- Third-party APIs (verify against actual response)
+- Migration guides (confirm source/target versions)
+
+**Red flags requiring re-verification:**
+- "Deprecated" warnings in results
+- Dates older than 6 months
+- Conflicting information between sources
+
+### Context Overflow Management
+
+**If even structured results exceed reasonable size:**
+1. Create an index/TOC of findings
+2. Show only the section relevant to immediate task
+3. Offer: "I found [X] additional areas. Which would help most?"
+4. Store details in agent memory for later retrieval
+
+### Confidence Communication
+
+**Always indicate confidence level when:**
+- Documentation is outdated (>1 year)
+- Multiple conflicting sources exist
+- Inferring from code (no docs found)
+- Using fallback methods
+
+**Format:** `[High confidence]`, `[Medium confidence]`, `[Inferred from code]`
+
+## Debug Mode & Special Scenarios
+
+### When to Show Raw Agent Results
+
+**ONLY expose raw results when:**
+- User explicitly asks "show me the raw output"
+- Debugging why an implementation isn't working
+- Agent results contradict user's expectation significantly
+- Need to prove source of information for audit/compliance
+
+**Never for:** Routine queries, successful searches, standard documentation lookups
+
+### Agent Chain Interruption
+
+**If agent chain fails midway (e.g., agent 2 of 5):**
+1. Report: "Research stopped at [step] due to [reason]"
+2. Show completed findings (structured)
+3. Ask: "Continue with partial info or try alternative approach?"
+4. Never silently skip failed steps
+
+### Performance Degradation Handling
+
+| Symptom | Likely Cause | Action |
+|---------|-------------|--------|
+| Agent >3min | Complex search | Switch to simpler query or Haiku model |
+| Multiple timeouts | API overload | Wait 30s, retry with rate limiting |
+| Consistent empties | Wrong domain | Verify project structure first |
+
+### Circular Dependency Detection
+
+**If Agent A needs B's result, and B needs A's:**
+1. STOP - this indicates unclear requirements
+2. Use AskUserQuestion to clarify which should be determined first
+3. Document the decision in comments
+
+### Result Caching Strategy
+
+**Cache and reuse agent results when:**
+- Same exact query within 5 minutes
+- Documentation lookups (valid for session)
+- Project structure analysis (valid until file changes)
+
+**Always re-run when:**
+- Error states being debugged
+- User explicitly requests "check again"
+- Any file modifications occurred
+
+### Priority Conflicts
+
+**When user request conflicts with best practices:**
+1. Execute user request first (they have context you don't)
+2. Note: "[Following user preference over standard pattern]"
+3. Document why standard approach might differ
+4. Never refuse based on "best practices" alone
+
+## 🔴 CRITICAL: Tool Result Minimization
+
+**Tool results are the #1 source of context bloat. After each tool execution, aggressively minimize what stays in context:**
+
+### Bash Tool Results
+
+**SUCCESS cases:**
+- ✅ `✓ Command succeeded (exit 0)`
+- ✅ `✓ npm install completed (23 packages added)`
+- ✅ `✓ Tests passed: 45/45`
+
+**FAILURE cases:**
+- ✅ Keep exit code + error lines only (max 10 lines)
+- ✅ Strip ANSI codes, progress bars, verbose output
+- ❌ NEVER include full command output for successful operations
+
+**Example transformations:**
+```
+❌ WRONG: [300 lines of npm install output with dependency tree]
+✅ RIGHT: ✓ npm install completed (23 packages added)
+
+❌ WRONG: [50 lines of test output with passing test names]
+✅ RIGHT: ✓ Tests passed: 45/45
+
+❌ WRONG: [Build output with webpack chunks and file sizes]
+✅ RIGHT: ✓ Build succeeded in 12.3s (3 chunks, 2.1MB)
+```
+
+### Edit Tool Results
+
+**SUCCESS cases:**
+- ✅ `✓ Modified /path/to/file.ts`
+- ✅ `✓ Updated 3 files: component.ts, service.ts, test.ts`
+
+**FAILURE cases:**
+- ✅ Show error message + line number
+- ❌ NEVER show full file diffs for successful edits
+
+**ONLY show full diff when:**
+- User explicitly asks "what changed?"
+- Edit failed and debugging needed
+- Major refactoring requiring review
+
+### Write Tool Results
+
+- ✅ `✓ Created /path/to/new-file.ts (245 lines)`
+- ❌ NEVER echo back full file content after writing
+
+### Read Tool Results
+
+**Extract only relevant sections:**
+- ✅ Read file → extract function/class → discard rest
+- ✅ Summarize: "File contains 3 components: A, B, C (lines 10-150)"
+- ❌ NEVER keep full file in context after extraction
+
+**Show full file ONLY when:**
+- User explicitly requests it
+- File < 50 lines
+- Need complete context for complex refactoring
+
+### Grep/Glob Results
+
+- ✅ `Found in 5 files: auth.ts, user.ts, ...`
+- ✅ Show matching lines if < 20 results
+- ❌ NEVER include full file paths and line numbers for > 20 matches
+
+### Skill Application Results
+
+**After applying skill:**
+- ✅ Replace full skill content with: `Applied [skill-name]: [checklist]`
+- ✅ Example: `Applied logging: ✓ Factory pattern ✓ Lazy evaluation ✓ Context added`
+- ❌ NEVER keep full skill instructions after application
+
+**Skill compression format:**
+```
+Applied angular-template:
+  ✓ Modern control flow (@if, @for, @switch)
+  ✓ Template references (ng-template)
+  ✓ Lazy loading (@defer)
+```
+
+### Agent Results
+
+**Summarization requirements (already covered in previous section):**
+- 1-2 sentences for simple queries
+- Structured table/list for complex findings
+- NEVER include raw JSON or full agent output
+
+### Session Cleanup
+
+**Use `/clear` between tasks when:**
+- Switching to unrelated task
+- Previous task completed successfully
+- Context exceeds 80K tokens
+- Starting new feature/bug after finishing previous
+
+**Benefits of `/clear`:**
+- Prevents irrelevant context from degrading performance
+- Resets working memory for fresh focus
+- Maintains only persistent context (CLAUDE.md, skills)
+
+## Implementation Work: Agent vs Direct Implementation
+
+**Context-efficient implementation requires choosing the right execution mode.**
+
+### Decision Matrix
+
+| Task Type | Files | Complexity | Duration | Use |
+|-----------|-------|-----------|----------|-----|
+| Single file edit | 1 | Low | < 5min | Main agent (direct) + aggressive pruning |
+| Bug fix | 1-3 | Variable | < 10min | Main agent (direct) + aggressive pruning |
+| New Angular code (component/service/store) | 2-5 | Medium | 10-20min | **angular-developer agent** |
+| Test suite | Any | Medium | 10-20min | **test-writer agent** |
+| Large refactor | 5+ | High | 20+ min | **refactor-engineer agent** |
+| Migration work | 10+ | High | 30+ min | **refactor-engineer agent** |
+
+### 🔴 Proactive Agent Invocation (Automatic)
+
+**You MUST automatically invoke specialized agents when task characteristics match, WITHOUT waiting for explicit user request.**
+
+**Automatic triggers:**
+
+1. **User says: "Create [component/service/store/pipe/directive/guard]..."**
+   → AUTOMATICALLY invoke `angular-developer` agent
+   → Example: "Create user dashboard component with metrics" → Use angular-developer
+
+2. **User says: "Write tests for..." OR "Add test coverage..."**
+   → AUTOMATICALLY invoke `test-writer` agent
+   → Example: "Write tests for the checkout service" → Use test-writer
+
+3. **User says: "Refactor all..." OR "Migrate [X] files..." OR "Update pattern across..."**
+   → AUTOMATICALLY invoke `refactor-engineer` agent
+   → Example: "Migrate all checkout components to standalone" → Use refactor-engineer
+
+4. **Task analysis indicates > 4 files will be touched**
+   → AUTOMATICALLY suggest/use appropriate agent
+   → Example: User asks to implement feature that needs component + service + store + routes → Use angular-developer
+
+5. **User says: "Remember to..." OR "TODO:" OR "Don't forget..."**
+   → AUTOMATICALLY invoke `context-manager` to store task
+   → Store immediately in `.claude/context/tasks.json`
+
+**Decision flow:**
+
+```
+User request received
+↓
+Analyze task characteristics:
+├─ Keywords match? (create, test, refactor, migrate)
+├─ File count estimate? (1 = direct, 2-5 = angular-developer, 5+ = refactor-engineer)
+├─ Task type? (implementation vs testing vs refactoring)
+└─ Complexity? (simple = direct, medium = agent, high = agent + detailed response)
+↓
+IF agent match found:
+  ├─ Brief user: "I'll use [agent-name] for this task"
+  ├─ Invoke agent with Task tool
+  └─ Validate result
+ELSE:
+  └─ Implement directly with aggressive pruning
+```
+
+**Communication pattern:**
+
+```
+✅ CORRECT:
+User: "Create a user profile component with avatar upload"
+Assistant: "I'll use the angular-developer agent for this Angular feature implementation."
+[Invokes angular-developer agent]
+
+❌ WRONG:
+User: "Create a user profile component with avatar upload"
+Assistant: "I can help you create a component. What fields should it have?"
+[Doesn't invoke agent, implements directly, wastes main context]
+```
+
+**Override mechanism:**
+
+If user says "do it directly" or "don't use an agent", honor their preference:
+```
+User: "Create a simple component, do it directly please"
+Assistant: "Understood, implementing directly."
+[Does NOT invoke angular-developer]
+```
+
+**Response format default:**
+
+- Use `response_format: "concise"` by default (context efficiency)
+- Use `response_format: "detailed"` when:
+  - User is learning/exploring
+  - Debugging complex issues
+  - User explicitly asks for details
+  - Task is unusual/non-standard
+
+### When Main Agent Implements Directly
+
+**Use direct implementation for simple, focused tasks:**
+
+1. **Apply aggressive pruning** (see Tool Result Minimization above)
+2. **Use context-manager proactively**:
+   - Store implementation state in MCP memory
+   - Enable session resumption without context replay
+3. **Compress conversation every 5-7 exchanges**:
+   - Summarize: "Completed X, found Y, next: Z"
+   - Discard intermediate exploration
+4. **Use `/clear` after completion** to reset for next task
+
+**Example flow:**
+```
+User: "Fix the auth bug in login.ts"
+Assistant: [Reads file, identifies issue, applies fix]
+Assistant: ✓ Modified login.ts
+Assistant: ✓ Tests passed: 12/12
+[Context used: ~3,000 tokens]
+```
+
+### When to Hand Off to Subagent
+
+**Delegate to specialized agents for complex/multi-file work:**
+
+**Triggers:**
+- Task will take > 10 minutes
+- Touching > 4 files
+- Repetitive work (CRUD generation, migrations)
+- User wants to multitask in main thread
+- Implementation requires iterative debugging
+
+**Available Implementation Agents:**
+
+#### angular-developer
+**Use for:** Angular code implementation (components, services, stores, pipes, directives, guards)
+- Auto-loads: angular-template, html-template, logging, tailwind
+- Handles: Components, services, stores, pipes, directives, guards, tests
+- Output: 2-5 files created/modified
+
+**Briefing template:**
+```
+Implement Angular [type]:
+- Type: [component/service/store/pipe/directive/guard]
+- Purpose: [description]
+- Location: [path]
+- Requirements: [list]
+- Integration: [dependencies]
+- Data flow: [if applicable]
+```
+
+#### test-writer
+**Use for:** Test suite generation/expansion
+- Auto-loads: test-migration-specialist patterns, Vitest config
+- Handles: Unit tests, integration tests, mocking
+- Output: Test files with comprehensive coverage
+
+**Briefing template:**
+```
+Generate tests for:
+- Target: [file path]
+- Coverage: [unit/integration/e2e]
+- Scenarios: [list of test cases]
+- Mocking: [dependencies to mock]
+```
+
+#### refactor-engineer
+**Use for:** Large-scale refactoring/migrations
+- Auto-loads: architecture-enforcer, circular-dependency-resolver
+- Handles: Multi-file refactoring, pattern migrations, architectural changes
+- Output: 5+ files modified, validation report
+
+**Briefing template:**
+```
+Refactor [scope]:
+- Pattern: [old pattern] → [new pattern]
+- Files: [list or glob pattern]
+- Constraints: [architectural rules]
+- Validation: [how to verify success]
+```
+
+### Agent Coordination Pattern
+
+**Main agent responsibilities:**
+1. **Planning**: Decompose request, choose agent
+2. **Briefing**: Provide focused, complete requirements
+3. **Validation**: Review agent output (summary only)
+4. **Integration**: Ensure changes work together
+
+**Implementation agent responsibilities:**
+1. **Execution**: Load skills, implement changes
+2. **Testing**: Run tests, fix errors
+3. **Reporting**: Return summary + key files modified
+4. **Context isolation**: Keep implementation details in own context
+
+**Handoff protocol:**
+
+```
+Main Agent:
+  ↓ Brief agent with requirements
+Implementation Agent:
+  ↓ Execute (skills loaded, iterative debugging)
+  ↓ Return summary: "✓ Created 3 files, ✓ Tests pass (12/12)"
+Main Agent:
+  ↓ Validate summary
+  ↓ Continue with next task
+  [Implementation details stayed in agent context]
+```
+
+### Parallel Work Pattern
+
+**When user has multiple independent tasks:**
+
+1. **Main agent** handles simple task directly
+2. **Specialized agent** handles complex task in parallel
+3. Both complete, results integrate
+
+**Example:**
+```
+User: "Fix auth bug AND create new dashboard component"
+Main Agent: Fix auth bug directly (simple, 1 file)
+angular-developer: Create dashboard (complex, 4 files)
+Both complete independently
+```
+
+### Context Savings Calculation
+
+**Direct implementation (simple task):**
+- Tool results (pruned): ~1,000 tokens
+- Conversation: ~2,000 tokens
+- Total: ~3,000 tokens
+
+**Subagent delegation (complex task):**
+- Briefing: ~1,500 tokens
+- Summary result: ~500 tokens
+- Total in main context: ~2,000 tokens
+- (Agent's 15,000 tokens stay isolated)
+
+**Net savings for complex task: ~13,000 tokens**
+
+## Agent Design Principles (Anthropic Best Practices)
+
+**Based on research from Anthropic's engineering blog, these principles guide our agent architecture.**
+
+### Core Principles
+
+**1. Simplicity First**
+- Start with simple solutions before adding agents
+- Only use agents when tasks are open-ended with unpredictable steps
+- Avoid over-engineering with unnecessary frameworks
+
+**2. Tool Quality > Prompt Quality**
+- Anthropic spent MORE time optimizing tools than prompts for SWE-bench
+- Small design choices (absolute vs relative paths) eliminate systematic errors
+- Invest heavily in tool documentation and testing
+
+**3. Ground Agents in Reality**
+- Provide environmental feedback at each step (tool results, test output)
+- Build feedback loops with checkpoints
+- Validate progress before continuing
+
+### Response Format Control
+
+**All implementation agents support response format parameter:**
+
+```
+briefing:
+  response_format: "concise"  # default, ~500 tokens
+  # or "detailed"             # ~2000 tokens with explanations
+```
+
+**Concise** (default for context efficiency):
+```
+✓ Feature created: DashboardComponent
+✓ Files: component.ts (150 lines), template (85 lines), tests (12/12 passing)
+✓ Skills applied: angular-template, html-template, logging
+```
+
+**Detailed** (use when debugging or learning):
+```
+✓ Feature created: DashboardComponent
+
+Implementation approach:
+- Used signalStore for state management (withState + withComputed)
+- Implemented reactive data loading with Resource API
+- Template uses modern control flow (@if, @for)
+
+Files created:
+- component.ts (150 lines): Standalone component with inject() pattern
+- component.html (85 lines): Modern syntax with E2E attributes
+- component.spec.ts: 12 tests covering rendering, interactions, state
+
+Key decisions:
+- Chose Resource API over manual loading for better race condition handling
+- Computed signals for derived state (no effects needed)
+
+Integration notes:
+- Requires UserMetricsService injection
+- Routes need update: path 'dashboard' → DashboardComponent
+```
+
+### Environmental Feedback Pattern
+
+**Agents should report progress at key milestones:**
+
+```
+Phase 1: Creating files...
+✓ Created dashboard.component.ts (150 lines)
+✓ Created dashboard.component.html (85 lines)
+
+Phase 2: Running validation...
+→ Running lint... ✓ No errors
+→ Running tests... ⚠ 8/12 passing
+
+Phase 3: Fixing failures...
+→ Investigating test failures: Mock data missing for UserService
+→ Adding mock setup... ✓ Fixed
+→ Rerunning tests... ✓ 12/12 passing
+
+Complete! Ready for review.
+```
+
+### Tool Documentation Standards
+
+**Every agent must document:**
+
+**When to Use** (boundaries):
+```markdown
+✅ Creating 2-5 related files (component + service + store)
+❌ Single file edits (use main agent directly)
+❌ >10 files (use refactor-engineer instead)
+```
+
+**Examples** (happy path):
+```markdown
+Example: "Create login component with form validation and auth service integration"
+→ Generates: component.ts, component.html, component.spec.ts, auth.service.ts
+```
+
+**Edge Cases** (failure modes):
+```markdown
+⚠ If auth service exists, will reuse (not recreate)
+⚠ If tests fail after 3 attempts, returns partial progress + blocker details
+```
+
+### Context Chunking Strategy
+
+**When storing knowledge in `.claude/context/`, prepend contextual headers:**
+
+**Before** (low retrieval accuracy):
+```json
+{
+  "description": "Use signalStore() with withState()"
+}
+```
+
+**After** (high retrieval accuracy):
+```json
+{
+  "context": "This pattern is for NgRx Signal Store in ISA-Frontend Angular 20+ monorepo. Replaces @ngrx/store for feature state management.",
+  "description": "Use signalStore() with withState() for state, withComputed() for derived values, withMethods() for actions. NO effects for state propagation.",
+  "location": "All libs/**/data-access/ libraries",
+  "example": "export const UserStore = signalStore(withState({users: []}));"
+}
+```
+
+**Chunk size**: 200-800 tokens per entry for optimal retrieval.
+
+### Poka-Yoke (Error-Proofing) Design
+
+**Make mistakes harder to make:**
+
+- ✅ **Use absolute paths** (not relative): Eliminates path resolution errors
+- ✅ **Validate inputs early**: Check file existence before operations
+- ✅ **Provide sensible defaults**: response_format="concise", model="sonnet"
+- ✅ **Actionable error messages**: "File not found. Did you mean: /path/to/similar-file.ts?"
+- ✅ **Fail fast with rollback**: Stop on first error, report state, allow retry
+
+### Workflow Pattern: Orchestrator-Workers
+
+**Our architecture uses the Orchestrator-Workers pattern:**
+
+```
+Main Agent (Orchestrator)
+├─ Plans decomposition
+├─ Chooses specialized worker
+├─ Provides focused briefing
+└─ Validates worker results
+
+Worker Agents (angular-developer, test-writer, refactor-engineer)
+├─ Execute with full autonomy
+├─ Load relevant skills
+├─ Iterate on errors internally
+└─ Return concise summary
+```
+
+**Benefits:**
+- Context isolation (worker details stay in worker context)
+- Parallel execution (main + worker simultaneously)
+- Specialization (each worker optimized for domain)
+- Predictable communication (briefing → execution → summary)
+
+### Token Efficiency Benchmark
+
+**From Anthropic research: 98.7% token reduction via code execution**
+
+Traditional tool-calling approach:
+- 150,000 tokens (alternating LLM calls + tool results)
+
+Code execution approach:
+- 2,000 tokens (write code → execute in environment)
+
+**ISA-Frontend application:**
+- Use Bash for loops, filtering, transformations
+- Use Edit for batch file changes (not individual tool calls per file)
+- Use Grep/Glob for discovery (not Read every file)
+- Prefer consolidated operations over step-by-step tool chains
+
+### Context Strategy Threshold
+
+**Based on Anthropic contextual retrieval research:**
+
+- **< 200K tokens**: Put everything in prompt with caching (90% cost savings)
+- **> 200K tokens**: Use retrieval system (our `.claude/context/` approach)
+
+**ISA-Frontend**: ~500K+ tokens (Angular monorepo with 100+ libraries)
+- ✅ File-based retrieval is correct choice
+- ✅ Contextual headers improve retrieval accuracy by 35-67%
+- ✅ Top-20 chunks with dual retrieval (semantic + lexical)
+
+<!-- nx configuration start-->
+<!-- Leave the start & end comments to automatically receive updates. -->
+
+# General Guidelines for working with Nx
+
+- When running tasks (for example build, lint, test, e2e, etc.), always prefer running the task through `nx` (i.e. `nx run`, `nx run-many`, `nx affected`) instead of using the underlying tooling directly
+- You have access to the Nx MCP server and its tools, use them to help the user
+- When answering questions about the repository, use the `nx_workspace` tool first to gain an understanding of the workspace architecture where applicable.
+- When working in individual projects, use the `nx_project_details` mcp tool to analyze and understand the specific project structure and dependencies
+- For questions around nx configuration, best practices or if you're unsure, use the `nx_docs` tool to get relevant, up-to-date docs. Always use this instead of assuming things about nx configuration
+- If the user needs help with an Nx configuration or project graph error, use the `nx_workspace` tool to get any errors
+
+<!-- nx configuration end-->

apps/isa-app/project.json

@@ -1,162 +1,162 @@
-{
-  "name": "isa-app",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "projectType": "application",
-  "prefix": "app",
-  "sourceRoot": "apps/isa-app/src",
-  "tags": [],
-  "targets": {
-    "build": {
-      "executor": "@angular-devkit/build-angular:application",
-      "options": {
-        "allowedCommonJsDependencies": [
-          "lodash",
-          "moment",
-          "jsrsasign",
-          "pdfjs-dist/build/pdf",
-          "pdfjs-dist/web/pdf_viewer",
-          "pdfjs-dist/es5/build/pdf",
-          "pdfjs-dist/es5/web/pdf_viewer"
-        ],
-        "outputPath": "dist/isa-app",
-        "index": "apps/isa-app/src/index.html",
-        "browser": "apps/isa-app/src/main.ts",
-        "polyfills": ["zone.js"],
-        "tsConfig": "apps/isa-app/tsconfig.app.json",
-        "inlineStyleLanguage": "scss",
-        "assets": [
-          "apps/isa-app/src/favicon.ico",
-          "apps/isa-app/src/assets",
-          "apps/isa-app/src/config",
-          "apps/isa-app/src/silent-refresh.html",
-          "apps/isa-app/src/manifest.webmanifest",
-          {
-            "glob": "**/*",
-            "input": "node_modules/scandit-web-datacapture-barcode/build/engine",
-            "output": "scandit"
-          }
-        ],
-        "styles": [
-          "@angular/cdk/overlay-prebuilt.css",
-          "apps/isa-app/src/tailwind.scss",
-          "apps/isa-app/src/styles.scss"
-        ],
-        "scripts": []
-      },
-      "configurations": {
-        "production": {
-          "budgets": [
-            {
-              "type": "initial",
-              "maximumWarning": "2mb",
-              "maximumError": "5mb"
-            },
-            {
-              "type": "anyComponentStyle",
-              "maximumWarning": "25kb"
-            }
-          ],
-          "fileReplacements": [
-            {
-              "replace": "apps/isa-app/src/environments/environment.ts",
-              "with": "apps/isa-app/src/environments/environment.prod.ts"
-            }
-          ],
-          "outputHashing": "all",
-          "serviceWorker": "apps/isa-app/ngsw-config.json"
-        },
-        "development": {
-          "optimization": false,
-          "extractLicenses": false,
-          "sourceMap": true
-        }
-      },
-      "defaultConfiguration": "production",
-      "outputs": ["{options.outputPath}"]
-    },
-    "serve": {
-      "executor": "@angular-devkit/build-angular:dev-server",
-      "configurations": {
-        "production": {
-          "buildTarget": "isa-app:build:production"
-        },
-        "development": {
-          "buildTarget": "isa-app:build:development"
-        }
-      },
-      "defaultConfiguration": "development",
-      "continuous": true
-    },
-    "extract-i18n": {
-      "executor": "@angular-devkit/build-angular:extract-i18n",
-      "options": {
-        "buildTarget": "isa-app:build"
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "apps/isa-app/jest.config.ts"
-      }
-    },
-    "serve-static": {
-      "executor": "@nx/web:file-server",
-      "options": {
-        "buildTarget": "isa-app:build",
-        "staticFilePath": "dist/apps/isa-app/browser",
-        "spa": true
-      }
-    },
-    "storybook": {
-      "executor": "@storybook/angular:start-storybook",
-      "options": {
-        "port": 4400,
-        "configDir": "apps/isa-app/.storybook",
-        "browserTarget": "isa-app:build",
-        "compodoc": false,
-        "open": false,
-        "assets": [
-          {
-            "glob": "**/*",
-            "input": "apps/isa-app/src/assets",
-            "output": "/assets"
-          }
-        ],
-        "styles": [
-          "@angular/cdk/overlay-prebuilt.css",
-          "apps/isa-app/src/tailwind.scss",
-          "apps/isa-app/src/styles.scss"
-        ]
-      },
-      "configurations": {
-        "ci": {
-          "quiet": true
-        }
-      }
-    },
-    "build-storybook": {
-      "executor": "@storybook/angular:build-storybook",
-      "outputs": ["{options.outputDir}"],
-      "options": {
-        "outputDir": "dist/storybook/isa-app",
-        "configDir": "apps/isa-app/.storybook",
-        "browserTarget": "isa-app:build",
-        "compodoc": false,
-        "styles": [
-          "@angular/cdk/overlay-prebuilt.css",
-          "apps/isa-app/src/tailwind.scss",
-          "apps/isa-app/src/styles.scss"
-        ]
-      },
-      "configurations": {
-        "ci": {
-          "quiet": true
-        }
-      }
-    }
-  }
-}
+{
+  "name": "isa-app",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "projectType": "application",
+  "prefix": "app",
+  "sourceRoot": "apps/isa-app/src",
+  "tags": ["skip:ci"],
+  "targets": {
+    "build": {
+      "executor": "@angular-devkit/build-angular:application",
+      "options": {
+        "allowedCommonJsDependencies": [
+          "lodash",
+          "moment",
+          "jsrsasign",
+          "pdfjs-dist/build/pdf",
+          "pdfjs-dist/web/pdf_viewer",
+          "pdfjs-dist/es5/build/pdf",
+          "pdfjs-dist/es5/web/pdf_viewer"
+        ],
+        "outputPath": "dist/isa-app",
+        "index": "apps/isa-app/src/index.html",
+        "browser": "apps/isa-app/src/main.ts",
+        "polyfills": ["zone.js"],
+        "tsConfig": "apps/isa-app/tsconfig.app.json",
+        "inlineStyleLanguage": "scss",
+        "assets": [
+          "apps/isa-app/src/favicon.ico",
+          "apps/isa-app/src/assets",
+          "apps/isa-app/src/config",
+          "apps/isa-app/src/silent-refresh.html",
+          "apps/isa-app/src/manifest.webmanifest",
+          {
+            "glob": "**/*",
+            "input": "node_modules/scandit-web-datacapture-barcode/build/engine",
+            "output": "scandit"
+          }
+        ],
+        "styles": [
+          "@angular/cdk/overlay-prebuilt.css",
+          "apps/isa-app/src/tailwind.scss",
+          "apps/isa-app/src/styles.scss"
+        ],
+        "scripts": []
+      },
+      "configurations": {
+        "production": {
+          "budgets": [
+            {
+              "type": "initial",
+              "maximumWarning": "2mb",
+              "maximumError": "5mb"
+            },
+            {
+              "type": "anyComponentStyle",
+              "maximumWarning": "25kb"
+            }
+          ],
+          "fileReplacements": [
+            {
+              "replace": "apps/isa-app/src/environments/environment.ts",
+              "with": "apps/isa-app/src/environments/environment.prod.ts"
+            }
+          ],
+          "outputHashing": "all",
+          "serviceWorker": "apps/isa-app/ngsw-config.json"
+        },
+        "development": {
+          "optimization": false,
+          "extractLicenses": false,
+          "sourceMap": true
+        }
+      },
+      "defaultConfiguration": "production",
+      "outputs": ["{options.outputPath}"]
+    },
+    "serve": {
+      "executor": "@angular-devkit/build-angular:dev-server",
+      "configurations": {
+        "production": {
+          "buildTarget": "isa-app:build:production"
+        },
+        "development": {
+          "buildTarget": "isa-app:build:development"
+        }
+      },
+      "defaultConfiguration": "development",
+      "continuous": true
+    },
+    "extract-i18n": {
+      "executor": "@angular-devkit/build-angular:extract-i18n",
+      "options": {
+        "buildTarget": "isa-app:build"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "apps/isa-app/jest.config.ts"
+      }
+    },
+    "serve-static": {
+      "executor": "@nx/web:file-server",
+      "options": {
+        "buildTarget": "isa-app:build",
+        "staticFilePath": "dist/apps/isa-app/browser",
+        "spa": true
+      }
+    },
+    "storybook": {
+      "executor": "@storybook/angular:start-storybook",
+      "options": {
+        "port": 4400,
+        "configDir": "apps/isa-app/.storybook",
+        "browserTarget": "isa-app:build",
+        "compodoc": false,
+        "open": false,
+        "assets": [
+          {
+            "glob": "**/*",
+            "input": "apps/isa-app/src/assets",
+            "output": "/assets"
+          }
+        ],
+        "styles": [
+          "@angular/cdk/overlay-prebuilt.css",
+          "apps/isa-app/src/tailwind.scss",
+          "apps/isa-app/src/styles.scss"
+        ]
+      },
+      "configurations": {
+        "ci": {
+          "quiet": true
+        }
+      }
+    },
+    "build-storybook": {
+      "executor": "@storybook/angular:build-storybook",
+      "outputs": ["{options.outputDir}"],
+      "options": {
+        "outputDir": "dist/storybook/isa-app",
+        "configDir": "apps/isa-app/.storybook",
+        "browserTarget": "isa-app:build",
+        "compodoc": false,
+        "styles": [
+          "@angular/cdk/overlay-prebuilt.css",
+          "apps/isa-app/src/tailwind.scss",
+          "apps/isa-app/src/styles.scss"
+        ]
+      },
+      "configurations": {
+        "ci": {
+          "quiet": true
+        }
+      }
+    }
+  }
+}

apps/isa-app/src/config/config.feature.json

@@ -1,85 +1,85 @@
-{
-  "title": "ISA - Feature",
-  "silentRefresh": {
-    "interval": 300000
-  },
-  "@cdn/product-image": {
-    "url": "https://produktbilder.paragon-data.net"
-  },
-  "@core/auth": {
-    "issuer": "https://sso-test.paragon-data.de",
-    "clientId": "hug-isa",
-    "responseType": "id_token token",
-    "oidc": true,
-    "scope": "openid profile cmf_user isa-isa-webapi isa-checkout-webapi isa-cat-webapi isa-ava-webapi isa-crm-webapi isa-review-webapi isa-kpi-webapi isa-oms-webapi isa-nbo-webapi isa-print-webapi eis-service isa-inv-webapi isa-wws-webapi"
-  },
-  "@core/logger": {
-    "logLevel": "debug"
-  },
-  "@domain/checkout": {
-    "olaExpiration": "5m"
-  },
-  "@swagger/isa": {
-    "rootUrl": "https://isa-feature.paragon-data.net/isa/v1"
-  },
-  "@swagger/cat": {
-    "rootUrl": "https://isa-test.paragon-data.net/catsearch/v6"
-  },
-  "@swagger/av": {
-    "rootUrl": "https://isa-test.paragon-data.net/ava/v6"
-  },
-  "@swagger/checkout": {
-    "rootUrl": "https://isa-feature.paragon-data.net/checkout/v6"
-  },
-  "@swagger/crm": {
-    "rootUrl": "https://isa-feature.paragon-data.net/crm/v6"
-  },
-  "@swagger/oms": {
-    "rootUrl": "https://isa-feature.paragon-data.net/oms/v6"
-  },
-  "@swagger/print": {
-    "rootUrl": "https://isa-feature.paragon-data.net/print/v1"
-  },
-  "@swagger/eis": {
-    "rootUrl": "https://filialinformationsystem-test.paragon-systems.de/eiswebapi/v1"
-  },
-  "@swagger/remi": {
-    "rootUrl": "https://isa-feature.paragon-data.net/inv/v6"
-  },
-  "@swagger/wws": {
-    "rootUrl": "https://isa-test.paragon-data.net/wws/v1"
-  },
-  "hubs": {
-    "notifications": {
-      "url": "https://isa-feature.paragon-data.net/isa/v1/rt",
-      "enableAutomaticReconnect": false,
-      "httpOptions": {
-        "transport": 1,
-        "logMessageContent": true,
-        "skipNegotiation": true
-      }
-    }
-  },
-  "process": {
-    "ids": {
-      "goodsOut": 1000,
-      "goodsIn": 2000,
-      "taskCalendar": 3000,
-      "remission": 4000,
-      "packageInspection": 5000,
-      "assortment": 6000,
-      "pickupShelf": 7000
-    }
-  },
-  "checkForUpdates": 3600000,
-  "licence": {
-    "scandit": "Ae8F2Wx2RMq5Lvn7UUAlWzVFZTt2+ubMAF8XtDpmPlNkBeG/LWs1M7AbgDW0LQqYLnszClEENaEHS56/6Ts2vrJ1Ux03CXUjK3jUvZpF5OchXR1CpnmpepJ6WxPCd7LMVHUGG1BbwPLDTFjP3y8uT0caTSmmGrYQWAs4CZcEF+ZBabP0z7vfm+hCZF/ebj9qqCJZcW8nH/n19hohshllzYBjFXjh87P2lIh1s6yZS3OaQWWXo/o0AKdxx7T6CVyR0/G5zq6uYJWf6rs3euUBEhpzOZHbHZK86Lvy2AVBEyVkkcttlDW1J2fA4l1W1JV/Xibz8AQV6kG482EpGF42KEoK48paZgX3e1AQsqUtmqzw294dcP4zMVstnw5/WrwKKi/5E/nOOJT2txYP1ZufIjPrwNFsqTlv7xCQlHjMzFGYwT816yD5qLRLbwOtjrkUPXNZLZ06T4upvWwJDmm8XgdeoDqMjHdcO4lwji1bl9EiIYJ/2qnsk9yZ2FqSaHzn4cbiL0f5u2HFlNAP0GUujGRlthGhHi6o4dFU+WAxKsFMKVt+SfoQUazNKHFVQgiAklTIZxIc/HUVzRvOLMxf+wFDerraBtcqGJg+g/5mrWYqeDBGhCBHtKiYf6244IJ4afzNTiH1/30SJcRzXwbEa3A7q1fJTx9/nLTOfVPrJKBQs7f/OQs2dA7LDCel8mzXdbjvsNQaeU5+iCIAq6zbTNKy1xT8wwj+VZrQmtNJs+qeznD+u29nCM24h8xCmRpvNPo4/Mww/lrTNrrNwLBSn1pMIwsH7yS9hH0v0oNAM3A6bVtk1D9qEkbyw+xZa+MZGpMP0D0CdcsqHalPcm5r/Ik="
-  },
-  "gender": {
-    "0": "Keine Anrede",
-    "1": "Enby",
-    "2": "Herr",
-    "4": "Frau"
-  },
-  "@shared/icon": "/assets/icons.json"
-}
+{
+  "title": "ISA - Feature",
+  "silentRefresh": {
+    "interval": 300000
+  },
+  "@cdn/product-image": {
+    "url": "https://produktbilder.paragon-data.net"
+  },
+  "@core/auth": {
+    "issuer": "https://sso-test.paragon-data.de",
+    "clientId": "hug-isa",
+    "responseType": "id_token token",
+    "oidc": true,
+    "scope": "openid profile cmf_user isa-isa-webapi isa-checkout-webapi isa-cat-webapi isa-ava-webapi isa-crm-webapi isa-review-webapi isa-kpi-webapi isa-oms-webapi isa-nbo-webapi isa-print-webapi eis-service isa-inv-webapi isa-wws-webapi"
+  },
+  "@core/logger": {
+    "logLevel": "debug"
+  },
+  "@domain/checkout": {
+    "olaExpiration": "5m"
+  },
+  "@swagger/isa": {
+    "rootUrl": "https://isa-test.paragon-data.net/isa/v1"
+  },
+  "@swagger/cat": {
+    "rootUrl": "https://isa-test.paragon-data.net/catsearch/v6"
+  },
+  "@swagger/av": {
+    "rootUrl": "https://isa-test.paragon-data.net/ava/v6"
+  },
+  "@swagger/checkout": {
+    "rootUrl": "https://isa-feature.paragon-data.net/checkout/v6"
+  },
+  "@swagger/crm": {
+    "rootUrl": "https://isa-feature.paragon-data.net/crm/v6"
+  },
+  "@swagger/oms": {
+    "rootUrl": "https://isa-feature.paragon-data.net/oms/v6"
+  },
+  "@swagger/print": {
+    "rootUrl": "https://isa-feature.paragon-data.net/print/v1"
+  },
+  "@swagger/eis": {
+    "rootUrl": "https://filialinformationsystem-test.paragon-systems.de/eiswebapi/v1"
+  },
+  "@swagger/remi": {
+    "rootUrl": "https://isa-feature.paragon-data.net/inv/v6"
+  },
+  "@swagger/wws": {
+    "rootUrl": "https://isa-test.paragon-data.net/wws/v1"
+  },
+  "hubs": {
+    "notifications": {
+      "url": "https://isa-feature.paragon-data.net/isa/v1/rt",
+      "enableAutomaticReconnect": false,
+      "httpOptions": {
+        "transport": 1,
+        "logMessageContent": true,
+        "skipNegotiation": true
+      }
+    }
+  },
+  "process": {
+    "ids": {
+      "goodsOut": 1000,
+      "goodsIn": 2000,
+      "taskCalendar": 3000,
+      "remission": 4000,
+      "packageInspection": 5000,
+      "assortment": 6000,
+      "pickupShelf": 7000
+    }
+  },
+  "checkForUpdates": 3600000,
+  "licence": {
+    "scandit": "Ae8F2Wx2RMq5Lvn7UUAlWzVFZTt2+ubMAF8XtDpmPlNkBeG/LWs1M7AbgDW0LQqYLnszClEENaEHS56/6Ts2vrJ1Ux03CXUjK3jUvZpF5OchXR1CpnmpepJ6WxPCd7LMVHUGG1BbwPLDTFjP3y8uT0caTSmmGrYQWAs4CZcEF+ZBabP0z7vfm+hCZF/ebj9qqCJZcW8nH/n19hohshllzYBjFXjh87P2lIh1s6yZS3OaQWWXo/o0AKdxx7T6CVyR0/G5zq6uYJWf6rs3euUBEhpzOZHbHZK86Lvy2AVBEyVkkcttlDW1J2fA4l1W1JV/Xibz8AQV6kG482EpGF42KEoK48paZgX3e1AQsqUtmqzw294dcP4zMVstnw5/WrwKKi/5E/nOOJT2txYP1ZufIjPrwNFsqTlv7xCQlHjMzFGYwT816yD5qLRLbwOtjrkUPXNZLZ06T4upvWwJDmm8XgdeoDqMjHdcO4lwji1bl9EiIYJ/2qnsk9yZ2FqSaHzn4cbiL0f5u2HFlNAP0GUujGRlthGhHi6o4dFU+WAxKsFMKVt+SfoQUazNKHFVQgiAklTIZxIc/HUVzRvOLMxf+wFDerraBtcqGJg+g/5mrWYqeDBGhCBHtKiYf6244IJ4afzNTiH1/30SJcRzXwbEa3A7q1fJTx9/nLTOfVPrJKBQs7f/OQs2dA7LDCel8mzXdbjvsNQaeU5+iCIAq6zbTNKy1xT8wwj+VZrQmtNJs+qeznD+u29nCM24h8xCmRpvNPo4/Mww/lrTNrrNwLBSn1pMIwsH7yS9hH0v0oNAM3A6bVtk1D9qEkbyw+xZa+MZGpMP0D0CdcsqHalPcm5r/Ik="
+  },
+  "gender": {
+    "0": "Keine Anrede",
+    "1": "Enby",
+    "2": "Herr",
+    "4": "Frau"
+  },
+  "@shared/icon": "/assets/icons.json"
+}

apps/isa-app/src/core/auth/auth.service.ts

@@ -1,11 +1,12 @@
 import { coerceArray } from '@angular/cdk/coercion';
-import { Injectable } from '@angular/core';
+import { inject, Injectable } from '@angular/core';
 import { Config } from '@core/config';
 import { isNullOrUndefined } from '@utils/common';
 import { AuthConfig, OAuthService } from 'angular-oauth2-oidc';
 import { JwksValidationHandler } from 'angular-oauth2-oidc-jwks';
 import { BehaviorSubject } from 'rxjs';
 import { logger } from '@isa/core/logging';
+import { Router } from '@angular/router';
 
 /**
  * Storage key for the URL to redirect to after login
@@ -17,6 +18,7 @@ const REDIRECT_URL_KEY = 'auth_redirect_url';
 })
 export class AuthService {
   #logger = logger(() => ({ service: 'AuthService' }));
+  #router = inject(Router);
 
   #initialized = new BehaviorSubject<boolean>(false);
   get initialized$() {
@@ -48,7 +50,8 @@ export class AuthService {
             this.#logger.debug('Redirecting after authentication', () => ({
               redirectUrl,
             }));
-            window.location.href = redirectUrl;
+
+            this.#router.navigateByUrl(redirectUrl);
           }
         }, 100);
       }

apps/isa-app/src/core/command/command.service.ts

@@ -1,54 +1,54 @@
-import { Injectable, Injector, Optional, SkipSelf } from '@angular/core';
-import { ActionHandler } from './action-handler.interface';
-import { FEATURE_ACTION_HANDLERS, ROOT_ACTION_HANDLERS } from './tokens';
-
-@Injectable()
-export class CommandService {
-  constructor(
-    private injector: Injector,
-    @Optional() @SkipSelf() private _parent: CommandService,
-  ) {}
-
-  async handleCommand<T>(command: string, data?: T): Promise<T> {
-    const actions = this.getActions(command);
-
-    for (const action of actions) {
-      const handler = this.getActionHandler(action);
-      if (!handler) {
-        console.error(
-          'CommandService.handleCommand',
-          'Action Handler does not exist',
-          { action },
-        );
-        throw new Error('Action Handler does not exist');
-      }
-      data = await handler.handler(data, this);
-    }
-    return data;
-  }
-
-  getActions(command: string) {
-    return command?.split('|') || [];
-  }
-
-  getActionHandler(action: string): ActionHandler | undefined {
-    const featureActionHandlers: ActionHandler[] = this.injector.get(
-      FEATURE_ACTION_HANDLERS,
-      [],
-    );
-    const rootActionHandlers: ActionHandler[] = this.injector.get(
-      ROOT_ACTION_HANDLERS,
-      [],
-    );
-
-    let handler = [...featureActionHandlers, ...rootActionHandlers].find(
-      (handler) => handler.action === action,
-    );
-
-    if (this._parent && !handler) {
-      handler = this._parent.getActionHandler(action);
-    }
-
-    return handler;
-  }
-}
+import { Injectable, Injector, Optional, SkipSelf } from '@angular/core';
+import { ActionHandler } from './action-handler.interface';
+import { FEATURE_ACTION_HANDLERS, ROOT_ACTION_HANDLERS } from './tokens';
+
+@Injectable()
+export class CommandService {
+  constructor(
+    private injector: Injector,
+    @Optional() @SkipSelf() private _parent: CommandService,
+  ) {}
+
+  async handleCommand<T>(command: string, data: T): Promise<T> {
+    const actions = this.getActions(command);
+
+    for (const action of actions) {
+      const handler = this.getActionHandler(action);
+      if (!handler) {
+        console.error(
+          'CommandService.handleCommand',
+          'Action Handler does not exist',
+          { action },
+        );
+        throw new Error('Action Handler does not exist');
+      }
+      data = await handler.handler(data, this);
+    }
+    return data;
+  }
+
+  getActions(command: string) {
+    return command?.split('|') || [];
+  }
+
+  getActionHandler(action: string): ActionHandler | undefined {
+    const featureActionHandlers: ActionHandler[] = this.injector.get(
+      FEATURE_ACTION_HANDLERS,
+      [],
+    );
+    const rootActionHandlers: ActionHandler[] = this.injector.get(
+      ROOT_ACTION_HANDLERS,
+      [],
+    );
+
+    let handler = [...featureActionHandlers, ...rootActionHandlers].find(
+      (handler) => handler.action === action,
+    );
+
+    if (this._parent && !handler) {
+      handler = this._parent.getActionHandler(action);
+    }
+
+    return handler;
+  }
+}

apps/isa-app/src/page/checkout/page-checkout-routing.module.ts

@@ -4,6 +4,7 @@ import { CheckoutReviewComponent } from './checkout-review/checkout-review.compo
 import { CheckoutSummaryComponent } from './checkout-summary/checkout-summary.component';
 import { PageCheckoutComponent } from './page-checkout.component';
 import { CheckoutReviewDetailsComponent } from './checkout-review/details/checkout-review-details.component';
+import { canDeactivateTabCleanup } from '@isa/core/tabs';
 
 const routes: Routes = [
   {
@@ -22,10 +23,12 @@ const routes: Routes = [
       {
         path: 'summary',
         component: CheckoutSummaryComponent,
+        canDeactivate: [canDeactivateTabCleanup],
       },
       {
         path: 'summary/:orderIds',
         component: CheckoutSummaryComponent,
+        canDeactivate: [canDeactivateTabCleanup],
       },
       { path: '', pathMatch: 'full', redirectTo: 'review' },
     ],

apps/isa-app/src/page/customer/customer-page.component.ts

@@ -1,5 +1,11 @@
-import { Component, ChangeDetectionStrategy } from '@angular/core';
+import {
+  Component,
+  ChangeDetectionStrategy,
+  OnDestroy,
+  inject,
+} from '@angular/core';
 import { ActivatedRoute } from '@angular/router';
+import { NavigationStateService } from '@isa/core/navigation';
 import { map } from 'rxjs/operators';
 
 @Component({
@@ -9,8 +15,14 @@ import { map } from 'rxjs/operators';
   changeDetection: ChangeDetectionStrategy.OnPush,
   standalone: false,
 })
-export class CustomerComponent {
+export class CustomerComponent implements OnDestroy {
+  private _navigationState = inject(NavigationStateService);
   processId$ = this._activatedRoute.data.pipe(map((data) => data.processId));
 
   constructor(private _activatedRoute: ActivatedRoute) {}
+
+  async ngOnDestroy() {
+    // #5512 Always clear preserved select-customer context if navigating out of customer area
+    await this._navigationState.clearPreservedContext('select-customer');
+  }
 }

apps/isa-app/src/page/customer/customer-search/details-main-view/details-main-view.component.ts

@@ -329,6 +329,12 @@ export class CustomerDetailsViewMainComponent
       }>('select-customer');
 
       if (context?.autoTriggerContinueFn) {
+        // Clear the autoTriggerContinueFn flag immediately (preserves returnUrl automatically)
+        await this._navigationState.patchContext(
+          { autoTriggerContinueFn: undefined },
+          'select-customer',
+        );
+
         // Auto-trigger continue() ONLY when coming from Kundenkarte
         this.continue();
       }

apps/isa-app/src/page/customer/customer-search/kundenkarte-main-view/kundenkarte-main-view.component.css

@@ -1,3 +1,3 @@
 :host {
-  @apply grid grid-flow-row items-center gap-4 bg-surface text-surface-content rounded px-4 py-6;
+  @apply max-h-[calc(100vh-14rem)] grid grid-flow-row items-center gap-4 bg-surface text-surface-content rounded px-4 py-6 overflow-hidden overflow-y-scroll;
 }

apps/isa-app/src/page/customer/customer-search/kundenkarte-main-view/kundenkarte-main-view.component.html

@@ -1,34 +1,39 @@
-<div class="flex flex-row justify-end -mt-2">
-  <page-customer-menu [customerId]="customerId$ | async" [processId]="processId$ | async" [showCustomerCard]="false"></page-customer-menu>
-</div>
-<h1 class="text-center text-2xl font-bold">Kundenkarte</h1>
-@if (!(noDataFound$ | async)) {
-  <p class="text-center text-xl">
-    Alle Infos zu Ihrer Kundenkarte
-    <br />
-    und allen Partnerkarten.
-  </p>
-}
-@if (noDataFound$ | async) {
-  <p class="text-center text-xl">Keine Kundenkarte gefunden.</p>
-}
-@for (karte of primaryKundenkarte$ | async; track karte) {
-  <page-customer-kundenkarte
-    class="justify-self-center"
-    [cardDetails]="karte"
-    [isCustomerCard]="true"
-    [customerId]="customerId$ | async"
-  ></page-customer-kundenkarte>
-}
-
-@if ((partnerKundenkarte$ | async)?.length) {
-  <p class="text-center text-xl font-bold">Partnerkarten</p>
-}
-
-@for (karte of partnerKundenkarte$ | async; track karte) {
-  <page-customer-kundenkarte
-    class="justify-self-center"
-    [cardDetails]="karte"
-    [isCustomerCard]="false"
-  ></page-customer-kundenkarte>
-}
+<div class="flex flex-row justify-end -mt-2">
+  <page-customer-menu
+    [customerId]="customerId$ | async"
+    [processId]="processId$ | async"
+    [showCustomerCard]="false"
+  />
+</div>
+<crm-customer-loyalty-cards
+  [customerId]="customerId$ | async"
+  [tabId]="processId$ | async"
+  (navigateToPraemienshop)="onNavigateToPraemienshop()"
+  (cardUpdated)="reloadCardTransactionsAndCards()"
+  class="mt-4"
+/>
+@let activeCardCode = firstActiveCardCode();
+
+@if (activeCardCode) {
+  <crm-customer-bon-redemption
+    [cardCode]="activeCardCode"
+    class="mt-4"
+    (redeemed)="reloadCardTransactionsAndCards()"
+  />
+  <crm-customer-booking
+    [cardCode]="activeCardCode"
+    class="mt-4"
+    (booked)="reloadCardTransactionsAndCards()"
+  />
+}
+
+<crm-customer-card-transactions
+  [customerId]="customerId()"
+  class="mt-8"
+  (reload)="reloadCardTransactionsAndCards()"
+/>
+
+<utils-scroll-top-button
+  [target]="hostElement"
+  class="flex flex-col justify-self-end fixed bottom-6 right-6"
+></utils-scroll-top-button>

apps/isa-app/src/page/customer/customer-search/kundenkarte-main-view/kundenkarte-main-view.component.ts

@@ -1,63 +1,145 @@
-import { Component, ChangeDetectionStrategy, OnInit, OnDestroy, inject } from '@angular/core';
-import { CustomerSearchStore } from '../store';
-import { ActivatedRoute } from '@angular/router';
-import { Subject, combineLatest, of } from 'rxjs';
-import { catchError, map, share, switchMap } from 'rxjs/operators';
-import { CrmCustomerService } from '@domain/crm';
-import { KundenkarteComponent } from '../../components/kundenkarte';
-import { AsyncPipe } from '@angular/common';
-import { CustomerSearchNavigation } from '@shared/services/navigation';
-import { BonusCardInfoDTO } from '@generated/swagger/crm-api';
-import { CustomerMenuComponent } from '../../components/customer-menu';
-
-@Component({
-  selector: 'page-customer-kundenkarte-main-view',
-  templateUrl: 'kundenkarte-main-view.component.html',
-  styleUrls: ['kundenkarte-main-view.component.css'],
-  changeDetection: ChangeDetectionStrategy.OnPush,
-  host: { class: 'page-customer-kundenkarte-main-view' },
-  imports: [CustomerMenuComponent, KundenkarteComponent, AsyncPipe],
-})
-export class KundenkarteMainViewComponent implements OnInit, OnDestroy {
-  private _store = inject(CustomerSearchStore);
-  private _activatedRoute = inject(ActivatedRoute);
-  private _customerService = inject(CrmCustomerService);
-  private _navigation = inject(CustomerSearchNavigation);
-
-  private _onDestroy$ = new Subject<void>();
-
-  customerId$ = this._activatedRoute.params.pipe(map((params) => params.customerId));
-
-  processId$ = this._store.processId$;
-
-  kundenkarte$ = this.customerId$.pipe(
-    switchMap((customerId) =>
-      this._customerService.getCustomerCard(customerId).pipe(
-        map((response) => response.result?.filter((f) => f.isActive)),
-        catchError(() => of<BonusCardInfoDTO[]>([])),
-      ),
-    ),
-    share(),
-  );
-
-  noDataFound$ = this.kundenkarte$.pipe(map((kundenkarte) => kundenkarte?.length == 0));
-
-  primaryKundenkarte$ = this.kundenkarte$.pipe(map((kundenkarte) => kundenkarte?.filter((k) => k.isPrimary)));
-
-  partnerKundenkarte$ = this.kundenkarte$.pipe(map((kundenkarte) => kundenkarte?.filter((k) => !k.isPrimary)));
-
-  detailsRoute$ = combineLatest([this._store.processId$, this._store.customerId$]).pipe(
-    map(([processId, customerId]) => this._navigation.detailsRoute({ processId, customerId })),
-  );
-
-  ngOnInit() {
-    this.customerId$.subscribe((customerId) => {
-      this._store.selectCustomer(customerId);
-    });
-  }
-
-  ngOnDestroy() {
-    this._onDestroy$.next();
-    this._onDestroy$.complete();
-  }
-}
+import {
+  Component,
+  ChangeDetectionStrategy,
+  inject,
+  computed,
+  effect,
+  ElementRef,
+  OnDestroy,
+} from '@angular/core';
+import { CustomerSearchStore } from '../store';
+import { ActivatedRoute, Router } from '@angular/router';
+import { map } from 'rxjs/operators';
+import { NavigationStateService } from '@isa/core/navigation';
+import { CustomerSearchNavigation } from '@shared/services/navigation';
+import { AsyncPipe } from '@angular/common';
+import { CustomerMenuComponent } from '../../components/customer-menu';
+import { CustomerLoyaltyCardsComponent } from '@isa/crm/feature/customer-loyalty-cards';
+import { CrmFeatureCustomerCardTransactionsComponent } from '@isa/crm/feature/customer-card-transactions';
+import { toSignal } from '@angular/core/rxjs-interop';
+import {
+  CustomerBonusCardsResource,
+  CustomerCardTransactionsResource,
+} from '@isa/crm/data-access';
+import { CrmFeatureCustomerBookingComponent } from '@isa/crm/feature/customer-booking';
+import { CrmFeatureCustomerBonRedemptionComponent } from '@isa/crm/feature/customer-bon-redemption';
+import { ScrollTopButtonComponent } from '@isa/utils/scroll-position';
+
+@Component({
+  selector: 'page-customer-kundenkarte-main-view',
+  templateUrl: 'kundenkarte-main-view.component.html',
+  styleUrls: ['kundenkarte-main-view.component.css'],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  host: { class: 'page-customer-kundenkarte-main-view' },
+  imports: [
+    CustomerMenuComponent,
+    AsyncPipe,
+    CustomerLoyaltyCardsComponent,
+    CrmFeatureCustomerCardTransactionsComponent,
+    CrmFeatureCustomerBookingComponent,
+    CrmFeatureCustomerBonRedemptionComponent,
+    ScrollTopButtonComponent,
+  ],
+  providers: [CustomerBonusCardsResource, CustomerCardTransactionsResource],
+})
+export class KundenkarteMainViewComponent implements OnDestroy {
+  #reloadTimeoutId?: ReturnType<typeof setTimeout>;
+
+  private _store = inject(CustomerSearchStore);
+  private _activatedRoute = inject(ActivatedRoute);
+  #bonusCardsResource = inject(CustomerBonusCardsResource);
+  #cardTransactionsResource = inject(CustomerCardTransactionsResource);
+  elementRef = inject(ElementRef);
+  #router = inject(Router);
+  #navigationState = inject(NavigationStateService);
+  #customerNavigationService = inject(CustomerSearchNavigation);
+
+  /**
+   * Returns the native DOM element of this component
+   */
+  get hostElement() {
+    return this.elementRef.nativeElement;
+  }
+
+  customerId$ = this._activatedRoute.params.pipe(
+    map((params) => params.customerId),
+  );
+
+  processId$ = this._store.processId$;
+
+  /**
+   * Convert customerId observable to signal for reactive usage
+   */
+  readonly customerId = toSignal(this.customerId$);
+
+  /**
+   * Get the first active card code
+   */
+  readonly firstActiveCardCode = computed(() => {
+    const cards = this.#bonusCardsResource.resource.value();
+    const firstActiveCard = cards?.find((card) => card.isActive);
+    return firstActiveCard?.code;
+  });
+
+  constructor() {
+    // Load bonus cards when customerId changes
+    effect(() => {
+      const customerId = this.customerId();
+      if (customerId) {
+        this.#bonusCardsResource.params({ customerId: Number(customerId) });
+      }
+    });
+  }
+
+  /**
+   * Reloads both card transactions and bonus cards resources after a 500ms delay.
+   * Only triggers reload if the resource is not currently loading to prevent concurrent requests.
+   */
+  reloadCardTransactionsAndCards() {
+    this.#reloadTimeoutId = setTimeout(() => {
+      if (!this.#cardTransactionsResource.resource.isLoading()) {
+        this.#cardTransactionsResource.resource.reload();
+      }
+
+      if (!this.#bonusCardsResource.resource.isLoading()) {
+        this.#bonusCardsResource.resource.reload();
+      }
+    }, 500);
+  }
+
+  /**
+   * Handle navigation to Prämienshop with proper customer selection.
+   * Uses autoTriggerContinueFn pattern to auto-select customer via details view.
+   */
+  async onNavigateToPraemienshop(): Promise<void> {
+    const tabId = this._store.processId;
+    const customerId = this.customerId();
+
+    if (!customerId || !tabId) {
+      return;
+    }
+
+    // Preserve context for auto-triggering continue() in details view
+    this.#navigationState.preserveContext(
+      {
+        returnUrl: `/${tabId}/reward`,
+        autoTriggerContinueFn: true,
+      },
+      'select-customer',
+    );
+
+    // Navigate to customer details - will auto-trigger continue()
+    await this.#router.navigate(
+      this.#customerNavigationService.detailsRoute({
+        processId: tabId,
+        customerId: Number(customerId),
+      }).path,
+    );
+  }
+
+  ngOnDestroy(): void {
+    if (this.#reloadTimeoutId) {
+      clearTimeout(this.#reloadTimeoutId);
+    }
+  }
+}

apps/isa-app/src/ui/modal/dialog/dialog-modal.component.html

@@ -1,16 +1,43 @@
 @if (modalRef.data.subtitle; as subtitle) {
   <h2 class="subtitle">{{ subtitle }}</h2>
 }
-@if (modalRef.data.content; as content) {
-  <p class="content">
-    {{ content }}
-  </p>
+
+<!-- QR Code Display Mode -->
+@if (shouldShowQrCode(); as showQr) {
+  @if (parsedContent(); as parsed) {
+    @if (parsed.textBefore) {
+      <p class="content">{{ parsed.textBefore }}</p>
+    }
+
+    <div class="qr-code-container">
+      <qrcode
+        [qrdata]="parsed.url!"
+        [width]="200"
+        [errorCorrectionLevel]="'M'"
+        [margin]="2"
+      ></qrcode>
+    </div>
+
+    @if (parsed.textAfter) {
+      <p class="content">{{ parsed.textAfter }}</p>
+    }
+  }
+} @else {
+  <!-- Default Text Display Mode -->
+  @if (modalRef.data.content; as content) {
+    <p class="content">
+      {{ content }}
+    </p>
+  }
 }
 
 @if (modalRef.data.actions; as actions) {
   <div class="actions">
     @for (action of actions; track action) {
-      <button [class.selected]="action.selected" (click)="handleCommand(action.command)">
+      <button
+        [class.selected]="action.selected"
+        (click)="handleCommand(action.command)"
+      >
         {{ action.label }}
       </button>
     }

apps/isa-app/src/ui/modal/dialog/dialog-modal.component.scss

@@ -15,11 +15,15 @@
   @apply text-lg text-center whitespace-pre-wrap mb-8 px-16;
 }
 
+.qr-code-container {
+  @apply flex flex-col items-center justify-center mb-8;
+}
+
 .actions {
   @apply text-center mb-8;
 
   button {
-    @apply border-2 border-solid border-brand bg-white text-brand rounded-full py-3 px-6 font-bold text-lg outline-none self-end whitespace-nowrap ml-4;
+    @apply border-2 border-solid border-brand bg-white text-brand rounded-full py-3 px-6 font-bold text-lg outline-none self-end whitespace-nowrap;
 
     &.selected {
       @apply bg-brand text-white;

apps/isa-app/src/ui/modal/dialog/dialog-modal.component.ts

@@ -1,7 +1,8 @@
-import { Component, OnInit } from '@angular/core';
+import { Component, computed, OnInit } from '@angular/core';
 import { CommandService } from '@core/command';
 import { UiModalRef } from '../defs/modal-ref';
 import { DialogModel } from './dialog.model';
+import { parseDialogContentForUrl } from './dialog.helper';
 
 @Component({
   selector: 'ui-dialog-modal',
@@ -10,6 +11,26 @@ import { DialogModel } from './dialog.model';
   standalone: false,
 })
 export class UiDialogModalComponent implements OnInit {
+  /**
+   * Parsed content with URL extracted for QR code display.
+   * Only relevant when showUrlAsQrCode is true.
+   */
+  readonly parsedContent = computed(() => {
+    const data = this.modalRef.data;
+    if (!data.showUrlAsQrCode) {
+      return null;
+    }
+    return parseDialogContentForUrl(data.content);
+  });
+
+  /**
+   * Whether to show the QR code instead of the URL text.
+   */
+  readonly shouldShowQrCode = computed(() => {
+    const parsed = this.parsedContent();
+    return parsed !== null && parsed.url !== null;
+  });
+
   constructor(
     public modalRef: UiModalRef<any, DialogModel<any>>,
     private _command: CommandService,

apps/isa-app/src/ui/modal/dialog/dialog.helper.ts

@@ -0,0 +1,48 @@
+import { ParsedDialogContent } from './dialog.model';
+
+/**
+ * Regular expression to match URLs in text.
+ * Matches http:// and https:// URLs.
+ */
+const URL_REGEX = /https?:\/\/[^\s]+/i;
+
+/**
+ * Parses the dialog content and extracts the first URL.
+ * Splits the content into text before the URL, the URL itself, and text after.
+ *
+ * @param content - The dialog content string to parse
+ * @returns ParsedDialogContent with the split content
+ */
+export const parseDialogContentForUrl = (
+  content: string | undefined,
+): ParsedDialogContent => {
+  if (!content) {
+    return { textBefore: '', url: null, textAfter: '' };
+  }
+
+  const match = content.match(URL_REGEX);
+
+  if (!match || match.index === undefined) {
+    return { textBefore: content, url: null, textAfter: '' };
+  }
+
+  const url = match[0];
+  const urlIndex = match.index;
+  const textBefore = content.substring(0, urlIndex).trim();
+  const textAfter = content.substring(urlIndex + url.length).trim();
+
+  return { textBefore, url, textAfter };
+};
+
+/**
+ * Checks if the given content contains a URL.
+ *
+ * @param content - The content string to check
+ * @returns true if a URL is found, false otherwise
+ */
+export const contentHasUrl = (content: string | undefined): boolean => {
+  if (!content) {
+    return false;
+  }
+  return URL_REGEX.test(content);
+};

apps/isa-app/src/ui/modal/dialog/dialog.model.spec.ts

@@ -0,0 +1,152 @@
+import { contentHasUrl, parseDialogContentForUrl } from './dialog.helper';
+import { ParsedDialogContent } from './dialog.model';
+
+describe('parseDialogContentForUrl', () => {
+  it('should return empty result for undefined content', () => {
+    const result = parseDialogContentForUrl(undefined);
+
+    expect(result).toEqual<ParsedDialogContent>({
+      textBefore: '',
+      url: null,
+      textAfter: '',
+    });
+  });
+
+  it('should return empty result for empty string', () => {
+    const result = parseDialogContentForUrl('');
+
+    expect(result).toEqual<ParsedDialogContent>({
+      textBefore: '',
+      url: null,
+      textAfter: '',
+    });
+  });
+
+  it('should return content as textBefore when no URL is found', () => {
+    const content = 'This is some text without a URL';
+
+    const result = parseDialogContentForUrl(content);
+
+    expect(result).toEqual<ParsedDialogContent>({
+      textBefore: content,
+      url: null,
+      textAfter: '',
+    });
+  });
+
+  it('should extract https URL from content', () => {
+    const content = 'Text before https://example.com text after';
+
+    const result = parseDialogContentForUrl(content);
+
+    expect(result).toEqual<ParsedDialogContent>({
+      textBefore: 'Text before',
+      url: 'https://example.com',
+      textAfter: 'text after',
+    });
+  });
+
+  it('should extract http URL from content', () => {
+    const content = 'Text before http://example.com text after';
+
+    const result = parseDialogContentForUrl(content);
+
+    expect(result).toEqual<ParsedDialogContent>({
+      textBefore: 'Text before',
+      url: 'http://example.com',
+      textAfter: 'text after',
+    });
+  });
+
+  it('should handle URL at the beginning of content', () => {
+    const content = 'https://example.com/path text after';
+
+    const result = parseDialogContentForUrl(content);
+
+    expect(result).toEqual<ParsedDialogContent>({
+      textBefore: '',
+      url: 'https://example.com/path',
+      textAfter: 'text after',
+    });
+  });
+
+  it('should handle URL at the end of content', () => {
+    const content = 'Text before https://example.com/path';
+
+    const result = parseDialogContentForUrl(content);
+
+    expect(result).toEqual<ParsedDialogContent>({
+      textBefore: 'Text before',
+      url: 'https://example.com/path',
+      textAfter: '',
+    });
+  });
+
+  it('should handle real-world content with newlines', () => {
+    const content = `Punkte: 80500
+Um alle Vorteile der Kundenkarte nutzen zu können, ist eine Verknüpfung zu einem Online-Konto notwendig. Kund:innen können sich über den QR-Code selbstständig anmelden oder die Kundenkarte dem bestehendem Konto hinzufügen. Bereits gesammelte Punkte werden übernommen.
+https://h-k.me/QOHNTFVA`;
+
+    const result = parseDialogContentForUrl(content);
+
+    expect(result.url).toBe('https://h-k.me/QOHNTFVA');
+    expect(result.textBefore).toContain('Punkte: 80500');
+    expect(result.textBefore).toContain(
+      'Bereits gesammelte Punkte werden übernommen.',
+    );
+    expect(result.textAfter).toBe('');
+  });
+
+  it('should extract only the first URL when multiple URLs are present', () => {
+    const content = 'First https://first.com then https://second.com';
+
+    const result = parseDialogContentForUrl(content);
+
+    expect(result).toEqual<ParsedDialogContent>({
+      textBefore: 'First',
+      url: 'https://first.com',
+      textAfter: 'then https://second.com',
+    });
+  });
+
+  it('should handle URLs with paths and query parameters', () => {
+    const content =
+      'Visit https://example.com/path?query=value&foo=bar for more';
+
+    const result = parseDialogContentForUrl(content);
+
+    expect(result.url).toBe('https://example.com/path?query=value&foo=bar');
+    expect(result.textBefore).toBe('Visit');
+    expect(result.textAfter).toBe('for more');
+  });
+});
+
+describe('contentHasUrl', () => {
+  it('should return false for undefined content', () => {
+    expect(contentHasUrl(undefined)).toBe(false);
+  });
+
+  it('should return false for empty string', () => {
+    expect(contentHasUrl('')).toBe(false);
+  });
+
+  it('should return false for content without URL', () => {
+    expect(contentHasUrl('This is text without a URL')).toBe(false);
+  });
+
+  it('should return true for content with https URL', () => {
+    expect(contentHasUrl('Check out https://example.com')).toBe(true);
+  });
+
+  it('should return true for content with http URL', () => {
+    expect(contentHasUrl('Check out http://example.com')).toBe(true);
+  });
+
+  it('should return true for real-world content', () => {
+    const content = `Punkte: 80500
+Um alle Vorteile der Kundenkarte nutzen zu können...
+https://h-k.me/QOHNTFVA`;
+
+    expect(contentHasUrl(content)).toBe(true);
+  });
+});

apps/isa-app/src/ui/modal/dialog/dialog.model.ts

@@ -1,4 +1,7 @@
-import { DialogSettings, KeyValueDTOOfStringAndString } from '@generated/swagger/crm-api';
+import {
+  DialogSettings,
+  KeyValueDTOOfStringAndString,
+} from '@generated/swagger/crm-api';
 
 export interface DialogModel<T = any> {
   actions?: Array<KeyValueDTOOfStringAndString>;
@@ -14,4 +17,21 @@ export interface DialogModel<T = any> {
    * default: true
    */
   handleCommand?: boolean;
+  /**
+   * If true, URLs in the content will be displayed as QR codes.
+   * default: false
+   */
+  showUrlAsQrCode?: boolean;
+}
+
+/**
+ * Result of parsing content for URLs
+ */
+export interface ParsedDialogContent {
+  /** Text before the URL */
+  textBefore: string;
+  /** The extracted URL (if any) */
+  url: string | null;
+  /** Text after the URL */
+  textAfter: string;
 }

apps/isa-app/src/ui/modal/dialog/open-dialog.interceptor.ts

@@ -13,6 +13,7 @@ import { Observable, throwError } from 'rxjs';
 import { catchError, tap } from 'rxjs/operators';
 import { DialogModel } from './dialog.model';
 import { ToasterService } from '@shared/shell';
+import { contentHasUrl } from './dialog.helper';
 
 @Injectable()
 export class OpenDialogInterceptor implements HttpInterceptor {
@@ -21,7 +22,10 @@ export class OpenDialogInterceptor implements HttpInterceptor {
     private _toast: ToasterService,
   ) {}
 
-  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+  intercept(
+    req: HttpRequest<any>,
+    next: HttpHandler,
+  ): Observable<HttpEvent<any>> {
     return next.handle(req).pipe(
       tap((response) => {
         if (response instanceof HttpResponse) {
@@ -59,9 +63,17 @@ export class OpenDialogInterceptor implements HttpInterceptor {
   }
 
   openDialog(model: DialogModel<any>) {
+    // Auto-detect URLs and enable QR code display if URL is found
+    // Can be overridden by explicitly setting showUrlAsQrCode in the model
+    const showUrlAsQrCode =
+      model.showUrlAsQrCode ?? contentHasUrl(model.content);
+
     this._modal.open({
       content: UiDialogModalComponent,
-      data: model,
+      data: {
+        ...model,
+        showUrlAsQrCode,
+      },
       title: model.title,
       config: {
         canClose: (model.settings & 1) === 1,

apps/isa-app/src/ui/modal/modal.module.ts

@@ -2,7 +2,6 @@ import { OverlayModule } from '@angular/cdk/overlay';
 import { CommonModule } from '@angular/common';
 import { ModuleWithProviders, NgModule } from '@angular/core';
 import { UiModalComponent } from './modal.component';
-import { UiModalService } from './modal.service';
 import { UiDebugModalComponent } from './debug-modal/debug-modal.component';
 import { UiMessageModalComponent } from './message-modal.component';
 import { UiIconModule } from '@ui/icon';
@@ -10,9 +9,10 @@ import { UiDialogModalComponent } from './dialog/dialog-modal.component';
 import { HTTP_INTERCEPTORS } from '@angular/common/http';
 import { OpenDialogInterceptor } from './dialog/open-dialog.interceptor';
 import { UiPromptModalComponent } from './prompt-modal';
+import { QRCodeComponent } from 'angularx-qrcode';
 
 @NgModule({
-  imports: [CommonModule, OverlayModule, UiIconModule],
+  imports: [CommonModule, OverlayModule, UiIconModule, QRCodeComponent],
   declarations: [
     UiModalComponent,
     UiDebugModalComponent,

apps/isa-app/stories/shared/barcode/barcode-component.stories.ts

@@ -0,0 +1,214 @@
+import {
+  argsToTemplate,
+  type Meta,
+  type StoryObj,
+  moduleMetadata,
+} from '@storybook/angular';
+import { BarcodeComponent } from '@isa/shared/barcode';
+
+type BarcodeInputs = {
+  value: string;
+  format: string;
+  width: number;
+  height: number;
+  displayValue: boolean;
+  lineColor: string;
+  background: string;
+  fontSize: number;
+  margin: number;
+};
+
+const meta: Meta<BarcodeInputs> = {
+  title: 'shared/barcode/BarcodeComponent',
+
+  decorators: [
+    moduleMetadata({
+      imports: [BarcodeComponent],
+    }),
+  ],
+  argTypes: {
+    value: {
+      control: {
+        type: 'text',
+      },
+      description: 'The barcode value to encode',
+    },
+    format: {
+      control: {
+        type: 'select',
+      },
+      options: ['CODE128', 'CODE39', 'EAN13', 'EAN8', 'UPC'],
+      description: 'Barcode format',
+    },
+    width: {
+      control: {
+        type: 'number',
+        min: 1,
+        max: 10,
+      },
+      description: 'Width of a single bar in pixels',
+    },
+    height: {
+      control: {
+        type: 'number',
+        min: 20,
+        max: 300,
+      },
+      description: 'Height of the barcode in pixels',
+    },
+    displayValue: {
+      control: {
+        type: 'boolean',
+      },
+      description: 'Whether to display the human-readable text',
+    },
+    lineColor: {
+      control: {
+        type: 'color',
+      },
+      description: 'Color of the barcode bars and text',
+    },
+    background: {
+      control: {
+        type: 'color',
+      },
+      description: 'Background color',
+    },
+    fontSize: {
+      control: {
+        type: 'number',
+        min: 10,
+        max: 40,
+      },
+      description: 'Font size for the human-readable text',
+    },
+    margin: {
+      control: {
+        type: 'number',
+        min: 0,
+        max: 50,
+      },
+      description: 'Margin around the barcode in pixels',
+    },
+  },
+  render: (args) => ({
+    props: args,
+    template: `<shared-barcode ${argsToTemplate(args)} />`,
+  }),
+};
+
+export default meta;
+
+type Story = StoryObj<BarcodeComponent>;
+
+export const Default: Story = {
+  args: {
+    value: '123456789012',
+    format: 'CODE128',
+    width: 2,
+    height: 100,
+    displayValue: true,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 20,
+    margin: 10,
+  },
+};
+
+export const ProductEAN: Story = {
+  args: {
+    value: '9783161484100',
+    format: 'CODE128',
+    width: 2,
+    height: 100,
+    displayValue: true,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 20,
+    margin: 10,
+  },
+};
+
+export const CompactNoText: Story = {
+  args: {
+    value: '987654321',
+    format: 'CODE128',
+    width: 1,
+    height: 60,
+    displayValue: false,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 20,
+    margin: 5,
+  },
+};
+
+export const LargeBarcode: Story = {
+  args: {
+    value: 'WAREHOUSE2024',
+    format: 'CODE128',
+    width: 4,
+    height: 200,
+    displayValue: true,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 28,
+    margin: 20,
+  },
+};
+
+export const ColoredBarcode: Story = {
+  args: {
+    value: 'PRODUCT001',
+    format: 'CODE128',
+    width: 2,
+    height: 100,
+    displayValue: true,
+    lineColor: '#0066CC',
+    background: '#F0F8FF',
+    fontSize: 20,
+    margin: 10,
+  },
+};
+
+export const RedBarcode: Story = {
+  args: {
+    value: 'URGENT2024',
+    format: 'CODE128',
+    width: 3,
+    height: 120,
+    displayValue: true,
+    lineColor: '#CC0000',
+    background: '#FFEEEE',
+    fontSize: 22,
+    margin: 15,
+  },
+};
+
+export const MinimalMargin: Story = {
+  args: {
+    value: '1234567890',
+    format: 'CODE128',
+    width: 2,
+    height: 80,
+    displayValue: true,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 16,
+    margin: 0,
+  },
+};
+
+export const SmallFont: Story = {
+  args: {
+    value: '555123456789',
+    format: 'CODE128',
+    width: 2,
+    height: 100,
+    displayValue: true,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 12,
+    margin: 10,
+  },
+};

apps/isa-app/stories/shared/barcode/barcode.stories.ts

@@ -0,0 +1,214 @@
+import {
+  argsToTemplate,
+  type Meta,
+  type StoryObj,
+  moduleMetadata,
+} from '@storybook/angular';
+import { BarcodeDirective } from '@isa/shared/barcode';
+
+type BarcodeInputs = {
+  value: string;
+  format: string;
+  width: number;
+  height: number;
+  displayValue: boolean;
+  lineColor: string;
+  background: string;
+  fontSize: number;
+  margin: number;
+};
+
+const meta: Meta<BarcodeInputs> = {
+  title: 'shared/barcode/Barcode',
+
+  decorators: [
+    moduleMetadata({
+      imports: [BarcodeDirective],
+    }),
+  ],
+  argTypes: {
+    value: {
+      control: {
+        type: 'text',
+      },
+      description: 'The barcode value to encode',
+    },
+    format: {
+      control: {
+        type: 'select',
+      },
+      options: ['CODE128', 'CODE39', 'EAN13', 'EAN8', 'UPC'],
+      description: 'Barcode format',
+    },
+    width: {
+      control: {
+        type: 'number',
+        min: 1,
+        max: 10,
+      },
+      description: 'Width of a single bar in pixels',
+    },
+    height: {
+      control: {
+        type: 'number',
+        min: 20,
+        max: 300,
+      },
+      description: 'Height of the barcode in pixels',
+    },
+    displayValue: {
+      control: {
+        type: 'boolean',
+      },
+      description: 'Whether to display the human-readable text',
+    },
+    lineColor: {
+      control: {
+        type: 'color',
+      },
+      description: 'Color of the barcode bars and text',
+    },
+    background: {
+      control: {
+        type: 'color',
+      },
+      description: 'Background color',
+    },
+    fontSize: {
+      control: {
+        type: 'number',
+        min: 10,
+        max: 40,
+      },
+      description: 'Font size for the human-readable text',
+    },
+    margin: {
+      control: {
+        type: 'number',
+        min: 0,
+        max: 50,
+      },
+      description: 'Margin around the barcode in pixels',
+    },
+  },
+  render: (args) => ({
+    props: args,
+    template: `<svg sharedBarcode ${argsToTemplate(args)}></svg>`,
+  }),
+};
+
+export default meta;
+
+type Story = StoryObj<BarcodeDirective>;
+
+export const Default: Story = {
+  args: {
+    value: '123456789012',
+    format: 'CODE128',
+    width: 2,
+    height: 100,
+    displayValue: true,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 20,
+    margin: 10,
+  },
+};
+
+export const ProductEAN: Story = {
+  args: {
+    value: '9783161484100',
+    format: 'CODE128',
+    width: 2,
+    height: 100,
+    displayValue: true,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 20,
+    margin: 10,
+  },
+};
+
+export const CompactNoText: Story = {
+  args: {
+    value: '987654321',
+    format: 'CODE128',
+    width: 1,
+    height: 60,
+    displayValue: false,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 20,
+    margin: 5,
+  },
+};
+
+export const LargeBarcode: Story = {
+  args: {
+    value: 'WAREHOUSE2024',
+    format: 'CODE128',
+    width: 4,
+    height: 200,
+    displayValue: true,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 28,
+    margin: 20,
+  },
+};
+
+export const ColoredBarcode: Story = {
+  args: {
+    value: 'PRODUCT001',
+    format: 'CODE128',
+    width: 2,
+    height: 100,
+    displayValue: true,
+    lineColor: '#0066CC',
+    background: '#F0F8FF',
+    fontSize: 20,
+    margin: 10,
+  },
+};
+
+export const RedBarcode: Story = {
+  args: {
+    value: 'URGENT2024',
+    format: 'CODE128',
+    width: 3,
+    height: 120,
+    displayValue: true,
+    lineColor: '#CC0000',
+    background: '#FFEEEE',
+    fontSize: 22,
+    margin: 15,
+  },
+};
+
+export const MinimalMargin: Story = {
+  args: {
+    value: '1234567890',
+    format: 'CODE128',
+    width: 2,
+    height: 80,
+    displayValue: true,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 16,
+    margin: 0,
+  },
+};
+
+export const SmallFont: Story = {
+  args: {
+    value: '555123456789',
+    format: 'CODE128',
+    width: 2,
+    height: 100,
+    displayValue: true,
+    lineColor: '#000000',
+    background: '#ffffff',
+    fontSize: 12,
+    margin: 10,
+  },
+};

apps/isa-app/stories/ui/switch/ui-icon-switch.stories.ts

@@ -1,5 +1,5 @@
 import { argsToTemplate, type Meta, type StoryObj } from '@storybook/angular';
-import { IconSwitchComponent, IconSwitchColor } from '@isa/ui/switch';
+import { SwitchComponent, IconSwitchColor } from '@isa/ui/switch';
 import { provideIcons } from '@ng-icons/core';
 import { isaFiliale, IsaIcons, isaNavigationDashboard } from '@isa/icons';
 
@@ -11,7 +11,7 @@ type IconSwitchComponentInputs = {
 };
 
 const meta: Meta<IconSwitchComponentInputs> = {
-  component: IconSwitchComponent,
+  component: SwitchComponent,
   title: 'ui/switch/IconSwitch',
   decorators: [
     (story) => ({
@@ -49,12 +49,12 @@ const meta: Meta<IconSwitchComponentInputs> = {
   },
   render: (args) => ({
     props: args,
-    template: `<ui-icon-switch ${argsToTemplate(args)}></ui-icon-switch>`,
+    template: `<ui-switch ${argsToTemplate(args)}></ui-switch>`,
   }),
 };
 export default meta;
 
-type Story = StoryObj<IconSwitchComponent>;
+type Story = StoryObj<SwitchComponent>;
 
 export const Default: Story = {
   args: {},

azure-pipelines.yml

@@ -12,12 +12,21 @@ variables:
     value: '4'
   # Minor Version einstellen
   - name: 'Minor'
-    value: '4'
+    value: '5'
   - name: 'Patch'
     value: "$[counter(format('{0}.{1}', variables['Major'], variables['Minor']),0)]"
   - name: 'BuildUniqueID'
     value: '$(Build.BuildID)-$(Agent.Id)-$(System.DefinitionId)-$(System.JobId)'
   - group: 'GithubCMF'
+  # Docker Tag Variablen
+  - name: 'DockerTagSourceBranch'
+    value: $[replace(replace(variables['Build.SourceBranch'], 'refs/heads/', ''), '/', '_')]
+  - name: 'CommitHash'
+    value: $[replace(variables['Build.SourceVersion'], format('{0}-', variables['Build.SourceBranchName']), '')]
+  - name: 'DockerTag'
+    value: |
+          $(Build.BuildNumber)-$(Build.SourceVersion)
+          $(Major).$(Minor).$(Patch)-$(DockerTagSourceBranch)-$(CommitHash)
 
 jobs:
   - job: unittests
@@ -87,13 +96,6 @@ jobs:
         - Agent.OS -equals Linux
         - docker
     condition: and(ne(variables['Build.SourceBranch'], 'refs/heads/integration'), ne(variables['Build.SourceBranch'], 'refs/heads/master'), not(startsWith(variables['Build.SourceBranch'], 'refs/heads/hotfix/')), not(startsWith(variables['Build.SourceBranch'], 'refs/heads/release/')))
-    variables:
-      - name: DockerTagSourceBranch
-        value: $[replace(variables['Build.SourceBranch'], '/', '-')]
-      - name: 'DockerTag'
-        value: |
-          $(Build.BuildNumber)-$(Build.SourceVersion)
-          $(DockerTagSourceBranch)
     steps:
       - task: npmAuthenticate@0
         displayName: 'npm auth'
@@ -156,13 +158,6 @@ jobs:
         - Agent.OS -equals Linux
         - docker
     condition: or(eq(variables['Build.SourceBranch'], 'refs/heads/integration'), eq(variables['Build.SourceBranch'], 'refs/heads/master'), startsWith(variables['Build.SourceBranch'], 'refs/heads/hotfix/'), startsWith(variables['Build.SourceBranch'], 'refs/heads/release/'))
-    variables:
-      - name: DockerTagSourceBranch
-        value: $[replace(variables['Build.SourceBranch'], '/', '_')]
-      - name: 'DockerTag'
-        value: |
-          $(Build.BuildNumber)-$(Build.SourceVersion)
-          $(DockerTagSourceBranch)
     steps:
       - task: npmAuthenticate@0
         displayName: 'npm auth'

docs/library-reference.md

@@ -1,11 +1,11 @@
 # Library Reference Guide
 
-> **Last Updated:** 2025-01-10
-> **Angular Version:** 20.1.2
+> **Last Updated:** 2025-11-25
+> **Angular Version:** 20.3.6
 > **Nx Version:** 21.3.2
-> **Total Libraries:** 63
+> **Total Libraries:** 72
 
-All 63 libraries in the monorepo have comprehensive README.md documentation located at `libs/[domain]/[layer]/[feature]/README.md`.
+All 72 libraries in the monorepo have comprehensive README.md documentation located at `libs/[domain]/[layer]/[feature]/README.md`.
 
 **IMPORTANT: Always use the `docs-researcher` subagent** to retrieve and analyze library documentation. This keeps the main context clean and prevents pollution.
 
@@ -23,7 +23,7 @@ A comprehensive product availability service for Angular applications supporting
 ## Catalogue Domain (1 library)
 
 ### `@isa/catalogue/data-access`
-A comprehensive product catalogue search and availability service for Angular applications, providing catalog item search, loyalty program integration, and specialized availability validation for download and delivery order types.
+A comprehensive product catalogue search service for Angular applications, providing catalog item search and loyalty program integration.
 
 **Location:** `libs/catalogue/data-access/`
 
@@ -37,7 +37,7 @@ A comprehensive checkout and shopping cart management library for Angular applic
 **Location:** `libs/checkout/data-access/`
 
 ### `@isa/checkout/feature/reward-order-confirmation`
-This library was generated with [Nx](https://nx.dev).
+## Overview
 
 **Location:** `libs/checkout/feature/reward-order-confirmation/`
 
@@ -57,8 +57,6 @@ A comprehensive loyalty rewards catalog feature for Angular applications support
 **Location:** `libs/checkout/feature/reward-catalog/`
 
 ### `@isa/checkout/shared/reward-selection-dialog`
-Angular library for managing reward selection in shopping cart context. Allows users to toggle between regular purchase and reward redemption using bonus points.
-
 **Location:** `libs/checkout/shared/reward-selection-dialog/`
 
 ---
@@ -85,11 +83,9 @@ A comprehensive print management library for Angular applications providing prin
 ## Core Libraries (6 libraries)
 
 ### `@isa/core/auth`
-Type-safe role-based authorization utilities with Angular signals integration for the ISA Frontend application. Provides Role enum, RoleService for programmatic checks, and IfRoleDirective for declarative template rendering with automatic JWT token parsing via OAuthService.
+Type-safe role-based authorization utilities with Angular signals integration for the ISA Frontend application.
 
 **Location:** `libs/core/auth/`
-**Testing:** Vitest (18 passing tests)
-**Features:** Signal-based reactivity, type-safe Role enum, zero-configuration OAuth2 integration
 
 ### `@isa/core/config`
 A lightweight, type-safe configuration management system for Angular applications with runtime validation and nested object access.
@@ -118,19 +114,37 @@ A sophisticated tab management system for Angular applications providing browser
 
 ---
 
-## CRM Domain (1 library)
+## CRM Domain (5 libraries)
 
 ### `@isa/crm/data-access`
-A comprehensive Customer Relationship Management (CRM) data access library for Angular applications providing customer, shipping address, payer, and bonus card management with reactive data loading using Angular resources.
-
 **Location:** `libs/crm/data-access/`
 
+### `@isa/crm/feature/customer-bon-redemption`
+This library was generated with [Nx](https://nx.dev).
+
+**Location:** `libs/crm/feature/customer-bon-redemption/`
+
+### `@isa/crm/feature/customer-booking`
+This library was generated with [Nx](https://nx.dev).
+
+**Location:** `libs/crm/feature/customer-booking/`
+
+### `@isa/crm/feature/customer-card-transactions`
+This library was generated with [Nx](https://nx.dev).
+
+**Location:** `libs/crm/feature/customer-card-transactions/`
+
+### `@isa/crm/feature/customer-loyalty-cards`
+This library was generated with [Nx](https://nx.dev).
+
+**Location:** `libs/crm/feature/customer-loyalty-cards/`
+
 ---
 
 ## Icons (1 library)
 
 ### `@isa/icons`
-This library was generated with [Nx](https://nx.dev).
+## Overview
 
 **Location:** `libs/icons/`
 
@@ -187,16 +201,16 @@ A specialized Angular component library for displaying and managing return recei
 
 ## Remission Domain (8 libraries)
 
-### `@isa/remission/feature/remission-list`
-Feature module providing the main remission list view with filtering, searching, item selection, and remitting capabilities for department ("Abteilung") and mandatory ("Pflicht") return workflows.
-
-**Location:** `libs/remission/feature/remission-list/`
-
 ### `@isa/remission/data-access`
 A comprehensive remission (returns) management system for Angular applications supporting mandatory returns (Pflichtremission) and department overflow returns (Abteilungsremission) in retail inventory operations.
 
 **Location:** `libs/remission/data-access/`
 
+### `@isa/remission/feature/remission-list`
+Feature module providing the main remission list view with filtering, searching, item selection, and remitting capabilities for department ("Abteilung") and mandatory ("Pflicht") return workflows.
+
+**Location:** `libs/remission/feature/remission-list/`
+
 ### `@isa/remission/feature/remission-return-receipt-details`
 Feature component for displaying detailed view of a return receipt ("Warenbegleitschein") with items, actions, and completion workflows.
 
@@ -207,35 +221,45 @@ Feature component providing a comprehensive list view of all return receipts wit
 
 **Location:** `libs/remission/feature/remission-return-receipt-list/`
 
-### `@isa/remission/shared/return-receipt-actions`
-Angular standalone components for managing return receipt actions including deletion, continuation, and completion workflows in the remission process.
-
-**Location:** `libs/remission/shared/return-receipt-actions/`
-
 ### `@isa/remission/shared/product`
 A collection of Angular standalone components for displaying product information in remission workflows, including product details, stock information, and shelf metadata.
 
 **Location:** `libs/remission/shared/product/`
 
-### `@isa/remission/shared/search-item-to-remit-dialog`
-Angular dialog component for searching and adding items to remission lists that are not on the mandatory return list (Pflichtremission).
-
-**Location:** `libs/remission/shared/search-item-to-remit-dialog/`
-
 ### `@isa/remission/shared/remission-start-dialog`
 Angular dialog component for initiating remission processes with two-step workflow: creating return receipts and assigning package numbers.
 
 **Location:** `libs/remission/shared/remission-start-dialog/`
 
+### `@isa/remission/shared/return-receipt-actions`
+Angular standalone components for managing return receipt actions including deletion, continuation, and completion workflows in the remission process.
+
+**Location:** `libs/remission/shared/return-receipt-actions/`
+
+### `@isa/remission/shared/search-item-to-remit-dialog`
+Angular dialog component for searching and adding items to remission lists that are not on the mandatory return list (Pflichtremission).
+
+**Location:** `libs/remission/shared/search-item-to-remit-dialog/`
+
 ---
 
-## Shared Component Libraries (7 libraries)
+## Shared Component Libraries (9 libraries)
 
 ### `@isa/shared/address`
 Comprehensive Angular components for displaying addresses in both multi-line and inline formats with automatic country name resolution and intelligent formatting.
 
 **Location:** `libs/shared/address/`
 
+### `@isa/shared/barcode`
+Angular library for generating Code 128 barcodes using [JsBarcode](https://github.com/lindell/JsBarcode).
+
+**Location:** `libs/shared/barcode/`
+
+### `@isa/shared/delivery`
+This library was generated with [Nx](https://nx.dev).
+
+**Location:** `libs/shared/delivery/`
+
 ### `@isa/shared/filter`
 A powerful and flexible filtering library for Angular applications that provides a complete solution for implementing filters, search functionality, and sorting capabilities.
 
@@ -268,7 +292,7 @@ An accessible, feature-rich Angular quantity selector component with dropdown pr
 
 ---
 
-## UI Component Libraries (16 libraries)
+## UI Component Libraries (18 libraries)
 
 ### `@isa/ui/label`
 A flexible label component for displaying tags and notices with configurable priority levels across Angular applications.
@@ -286,7 +310,7 @@ A comprehensive button component library for Angular applications providing five
 **Location:** `libs/ui/buttons/`
 
 ### `@isa/ui/carousel`
-A horizontal scroll container component with left/right navigation arrows, responsive behavior, keyboard support, and auto-hide functionality for Angular applications.
+A horizontal scroll container component with left/right navigation arrows, responsive behavior, keyboard support, and auto-hide functionality.
 
 **Location:** `libs/ui/carousel/`
 
@@ -321,7 +345,7 @@ A collection of reusable row components for displaying structured data with cons
 **Location:** `libs/ui/item-rows/`
 
 ### `@isa/ui/layout`
-This library provides utilities and directives for responsive design in Angular applications.
+This library provides utilities and directives for responsive design and viewport behavior in Angular applications.
 
 **Location:** `libs/ui/layout/`
 
@@ -345,6 +369,11 @@ A lightweight Angular structural directive and component for displaying skeleton
 
 **Location:** `libs/ui/skeleton-loader/`
 
+### `@isa/ui/switch`
+This library provides a toggle switch component with an icon for Angular applications.
+
+**Location:** `libs/ui/switch/`
+
 ### `@isa/ui/toolbar`
 A flexible toolbar container component for Angular applications with configurable sizing and content projection.
 
@@ -357,13 +386,23 @@ A flexible tooltip library for Angular applications, built with Angular CDK over
 
 ---
 
-## Utility Libraries (3 libraries)
+## Utility Libraries (5 libraries)
 
 ### `@isa/utils/ean-validation`
 Lightweight Angular utility library for validating EAN (European Article Number) barcodes with reactive forms integration and standalone validation functions.
 
 **Location:** `libs/utils/ean-validation/`
 
+### `@isa/utils/format-name`
+This library was generated with [Nx](https://nx.dev).
+
+**Location:** `libs/utils/format-name/`
+
+### `@isa/utils/positive-integer-input`
+An Angular directive that ensures only positive integers can be entered into number input fields.
+
+**Location:** `libs/utils/positive-integer-input/`
+
 ### `@isa/utils/scroll-position`
 ## Overview
 

eslint.config.js

@@ -10,6 +10,7 @@ module.exports = [
       '**/dist',
       '**/vite.config.*.timestamp*',
       '**/vitest.config.*.timestamp*',
+      '**/generated/**',
     ],
   },
   // {

generated/swagger/crm-api/src/models.ts

@@ -76,6 +76,15 @@ export { EntityDTOBaseOfCustomerInfoDTOAndICustomer } from './models/entity-dtob
 export { QueryTokenDTO } from './models/query-token-dto';
 export { QueryTokenDTO2 } from './models/query-token-dto2';
 export { ResponseArgsOfCustomerDTO } from './models/response-args-of-customer-dto';
+export { ResponseArgsOfAccountDetailsDTO } from './models/response-args-of-account-details-dto';
+export { AccountDetailsDTO } from './models/account-details-dto';
+export { AccountBalanceDTO } from './models/account-balance-dto';
+export { IdentifierDTO } from './models/identifier-dto';
+export { StateLevelDTO } from './models/state-level-dto';
+export { MembershipDetailsDTO } from './models/membership-details-dto';
+export { CustomPropertyDTO } from './models/custom-property-dto';
+export { OptinDTO } from './models/optin-dto';
+export { AddLoyaltyCardValues } from './models/add-loyalty-card-values';
 export { SaveCustomerValues } from './models/save-customer-values';
 export { ResponseArgsOfAssignedPayerDTO } from './models/response-args-of-assigned-payer-dto';
 export { ResponseArgsOfBoolean } from './models/response-args-of-boolean';
@@ -92,10 +101,14 @@ export { DiffDTO } from './models/diff-dto';
 export { ResponseArgsOfIQueryResultOfLoyaltyBookingInfoDTO } from './models/response-args-of-iquery-result-of-loyalty-booking-info-dto';
 export { IQueryResultOfLoyaltyBookingInfoDTO } from './models/iquery-result-of-loyalty-booking-info-dto';
 export { LoyaltyBookingInfoDTO } from './models/loyalty-booking-info-dto';
-export { ResponseArgsOfIEnumerableOfString } from './models/response-args-of-ienumerable-of-string';
+export { ResponseArgsOfIEnumerableOfKeyValueDTOOfStringAndInteger } from './models/response-args-of-ienumerable-of-key-value-dtoof-string-and-integer';
+export { KeyValueDTOOfStringAndInteger } from './models/key-value-dtoof-string-and-integer';
 export { ResponseArgsOfKeyValueDTOOfStringAndString } from './models/response-args-of-key-value-dtoof-string-and-string';
 export { ResponseArgsOfLoyaltyBookingInfoDTO } from './models/response-args-of-loyalty-booking-info-dto';
 export { LoyaltyBookingValues } from './models/loyalty-booking-values';
+export { ResponseArgsOfLoyaltyBonResponse } from './models/response-args-of-loyalty-bon-response';
+export { LoyaltyBonResponse } from './models/loyalty-bon-response';
+export { LoyaltyBonItemResponse } from './models/loyalty-bon-item-response';
 export { LoyaltyBonValues } from './models/loyalty-bon-values';
 export { ResponseArgsOfPayerDTO } from './models/response-args-of-payer-dto';
 export { ResponseArgsOfShippingAddressDTO } from './models/response-args-of-shipping-address-dto';

generated/swagger/crm-api/src/models/account-balance-dto.ts

@@ -0,0 +1,5 @@
+/* tslint:disable */
+export interface AccountBalanceDTO {
+  lockedPoints: number;
+  points: number;
+}

generated/swagger/crm-api/src/models/account-details-dto.ts

@@ -0,0 +1,14 @@
+/* tslint:disable */
+import { AccountBalanceDTO } from './account-balance-dto';
+import { IdentifierDTO } from './identifier-dto';
+import { StateLevelDTO } from './state-level-dto';
+import { MembershipDetailsDTO } from './membership-details-dto';
+export interface AccountDetailsDTO {
+  accountBalance?: AccountBalanceDTO;
+  accountId?: string;
+  createdAt?: string;
+  identifiers?: Array<IdentifierDTO>;
+  level?: StateLevelDTO;
+  memberships?: Array<MembershipDetailsDTO>;
+  status?: string;
+}

generated/swagger/crm-api/src/models/add-loyalty-card-values.ts

@@ -0,0 +1,8 @@
+/* tslint:disable */
+export interface AddLoyaltyCardValues {
+
+  /**
+   * Card code
+   */
+  cardCode?: string;
+}

generated/swagger/crm-api/src/models/custom-property-dto.ts

@@ -0,0 +1,5 @@
+/* tslint:disable */
+export interface CustomPropertyDTO {
+  name?: string;
+  value?: string;
+}

generated/swagger/crm-api/src/models/identifier-dto.ts

@@ -0,0 +1,8 @@
+/* tslint:disable */
+export interface IdentifierDTO {
+  code?: string;
+  displayCode?: string;
+  identifierId?: string;
+  status?: string;
+  type?: string;
+}

generated/swagger/crm-api/src/models/key-value-dtoof-string-and-integer.ts

@@ -0,0 +1,12 @@
+/* tslint:disable */
+export interface KeyValueDTOOfStringAndInteger {
+  command?: string;
+  description?: string;
+  enabled?: boolean;
+  group?: string;
+  key?: string;
+  label?: string;
+  selected?: boolean;
+  sort?: number;
+  value: number;
+}

generated/swagger/crm-api/src/models/loyalty-bon-item-response.ts

@@ -0,0 +1,28 @@
+/* tslint:disable */
+export interface LoyaltyBonItemResponse {
+
+  /**
+   * EAB
+   */
+  ean?: string;
+
+  /**
+   * Artikel
+   */
+  name?: string;
+
+  /**
+   * Warengruppe
+   */
+  productGroup?: string;
+
+  /**
+   * Menge
+   */
+  quantity: number;
+
+  /**
+   * Summe VK
+   */
+  sum: number;
+}

generated/swagger/crm-api/src/models/loyalty-bon-response.ts

@@ -0,0 +1,19 @@
+/* tslint:disable */
+import { LoyaltyBonItemResponse } from './loyalty-bon-item-response';
+export interface LoyaltyBonResponse {
+
+  /**
+   * Bon Datum
+   */
+  date?: string;
+
+  /**
+   * Positionen
+   */
+  items?: Array<LoyaltyBonItemResponse>;
+
+  /**
+   * Summe
+   */
+  total?: number;
+}

generated/swagger/crm-api/src/models/membership-details-dto.ts

@@ -0,0 +1,19 @@
+/* tslint:disable */
+import { CustomPropertyDTO } from './custom-property-dto';
+import { OptinDTO } from './optin-dto';
+export interface MembershipDetailsDTO {
+  birthDate?: string;
+  city?: string;
+  countryCode?: string;
+  customProperties?: Array<CustomPropertyDTO>;
+  emailAddress?: string;
+  familyName?: string;
+  genderCode?: string;
+  givenName?: string;
+  memberRole?: string;
+  membershipId?: string;
+  optins?: Array<OptinDTO>;
+  streetHouseNo?: string;
+  userId?: string;
+  zipCode?: string;
+}

generated/swagger/crm-api/src/models/optin-dto.ts

@@ -0,0 +1,5 @@
+/* tslint:disable */
+export interface OptinDTO {
+  flag: boolean;
+  type?: string;
+}

generated/swagger/crm-api/src/models/response-args-of-account-details-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+import { AccountDetailsDTO } from './account-details-dto';
+export interface ResponseArgsOfAccountDetailsDTO extends ResponseArgs{
+  result?: AccountDetailsDTO;
+}

generated/swagger/crm-api/src/models/response-args-of-ienumerable-of-key-value-dtoof-string-and-integer.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+import { KeyValueDTOOfStringAndInteger } from './key-value-dtoof-string-and-integer';
+export interface ResponseArgsOfIEnumerableOfKeyValueDTOOfStringAndInteger extends ResponseArgs{
+  result?: Array<KeyValueDTOOfStringAndInteger>;
+}

generated/swagger/crm-api/src/models/response-args-of-ienumerable-of-string.ts

@@ -1,5 +0,0 @@
-/* tslint:disable */
-import { ResponseArgs } from './response-args';
-export interface ResponseArgsOfIEnumerableOfString extends ResponseArgs{
-  result?: Array<string>;
-}

generated/swagger/crm-api/src/models/response-args-of-loyalty-bon-response.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+import { LoyaltyBonResponse } from './loyalty-bon-response';
+export interface ResponseArgsOfLoyaltyBonResponse extends ResponseArgs{
+  result?: LoyaltyBonResponse;
+}

generated/swagger/crm-api/src/models/state-level-dto.ts

@@ -0,0 +1,10 @@
+/* tslint:disable */
+export interface StateLevelDTO {
+  currentStatePoints?: number;
+  name?: string;
+  neededStatePoints?: number;
+  neededStatePointsNextLevel?: number;
+  requiredPointsToMaintainLevel?: number;
+  requiredPointsToReachNextLevel?: number;
+  validTo?: string;
+}

generated/swagger/crm-api/src/services/customer.service.ts

@@ -17,6 +17,8 @@ import { ResponseArgsOfCustomerDTO } from '../models/response-args-of-customer-d
 import { SaveCustomerValues } from '../models/save-customer-values';
 import { CustomerDTO } from '../models/customer-dto';
 import { ResponseArgsOfBoolean } from '../models/response-args-of-boolean';
+import { ResponseArgsOfAccountDetailsDTO } from '../models/response-args-of-account-details-dto';
+import { AddLoyaltyCardValues } from '../models/add-loyalty-card-values';
 import { ResponseArgsOfAssignedPayerDTO } from '../models/response-args-of-assigned-payer-dto';
 import { ResponseArgsOfIEnumerableOfCustomerInfoDTO } from '../models/response-args-of-ienumerable-of-customer-info-dto';
 import { ResponseArgsOfIEnumerableOfBonusCardInfoDTO } from '../models/response-args-of-ienumerable-of-bonus-card-info-dto';
@@ -35,6 +37,8 @@ class CustomerService extends __BaseService {
   static readonly CustomerUpdateCustomerPath = '/customer/{customerId}';
   static readonly CustomerPatchCustomerPath = '/customer/{customerId}';
   static readonly CustomerDeleteCustomerPath = '/customer/{customerId}';
+  static readonly CustomerMergeLoyaltyAccountsPath = '/customer/{customerId}/loyalty/merge';
+  static readonly CustomerAddLoyaltyCardPath = '/customer/{customerId}/loyalty/add-card';
   static readonly CustomerCreateCustomerPath = '/customer';
   static readonly CustomerAddPayerReferencePath = '/customer/{customerId}/payer';
   static readonly CustomerDeactivateCustomerPath = '/customer/{customerId}/deactivate';
@@ -389,6 +393,106 @@ class CustomerService extends __BaseService {
     );
   }
 
+  /**
+   * Kundenkarte hinzufügen
+   * @param params The `CustomerService.CustomerMergeLoyaltyAccountsParams` containing the following parameters:
+   *
+   * - `loyaltyCardValues`:
+   *
+   * - `customerId`:
+   *
+   * - `locale`:
+   */
+  CustomerMergeLoyaltyAccountsResponse(params: CustomerService.CustomerMergeLoyaltyAccountsParams): __Observable<__StrictHttpResponse<ResponseArgsOfAccountDetailsDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    __body = params.loyaltyCardValues;
+
+    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
+    let req = new HttpRequest<any>(
+      'POST',
+      this.rootUrl + `/customer/${encodeURIComponent(String(params.customerId))}/loyalty/merge`,
+      __body,
+      {
+        headers: __headers,
+        params: __params,
+        responseType: 'json'
+      });
+
+    return this.http.request<any>(req).pipe(
+      __filter(_r => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfAccountDetailsDTO>;
+      })
+    );
+  }
+  /**
+   * Kundenkarte hinzufügen
+   * @param params The `CustomerService.CustomerMergeLoyaltyAccountsParams` containing the following parameters:
+   *
+   * - `loyaltyCardValues`:
+   *
+   * - `customerId`:
+   *
+   * - `locale`:
+   */
+  CustomerMergeLoyaltyAccounts(params: CustomerService.CustomerMergeLoyaltyAccountsParams): __Observable<ResponseArgsOfAccountDetailsDTO> {
+    return this.CustomerMergeLoyaltyAccountsResponse(params).pipe(
+      __map(_r => _r.body as ResponseArgsOfAccountDetailsDTO)
+    );
+  }
+
+  /**
+   * Kundenkarte hinzufügen
+   * @param params The `CustomerService.CustomerAddLoyaltyCardParams` containing the following parameters:
+   *
+   * - `loyaltyCardValues`:
+   *
+   * - `customerId`:
+   *
+   * - `locale`:
+   */
+  CustomerAddLoyaltyCardResponse(params: CustomerService.CustomerAddLoyaltyCardParams): __Observable<__StrictHttpResponse<ResponseArgsOfAccountDetailsDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    __body = params.loyaltyCardValues;
+
+    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
+    let req = new HttpRequest<any>(
+      'POST',
+      this.rootUrl + `/customer/${encodeURIComponent(String(params.customerId))}/loyalty/add-card`,
+      __body,
+      {
+        headers: __headers,
+        params: __params,
+        responseType: 'json'
+      });
+
+    return this.http.request<any>(req).pipe(
+      __filter(_r => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfAccountDetailsDTO>;
+      })
+    );
+  }
+  /**
+   * Kundenkarte hinzufügen
+   * @param params The `CustomerService.CustomerAddLoyaltyCardParams` containing the following parameters:
+   *
+   * - `loyaltyCardValues`:
+   *
+   * - `customerId`:
+   *
+   * - `locale`:
+   */
+  CustomerAddLoyaltyCard(params: CustomerService.CustomerAddLoyaltyCardParams): __Observable<ResponseArgsOfAccountDetailsDTO> {
+    return this.CustomerAddLoyaltyCardResponse(params).pipe(
+      __map(_r => _r.body as ResponseArgsOfAccountDetailsDTO)
+    );
+  }
+
   /**
    * Anlage eines neuen Kunden
    * @param payload Kundendaten
@@ -861,6 +965,24 @@ module CustomerService {
     deletionComment?: null | string;
   }
 
+  /**
+   * Parameters for CustomerMergeLoyaltyAccounts
+   */
+  export interface CustomerMergeLoyaltyAccountsParams {
+    loyaltyCardValues: AddLoyaltyCardValues;
+    customerId: number;
+    locale?: null | string;
+  }
+
+  /**
+   * Parameters for CustomerAddLoyaltyCard
+   */
+  export interface CustomerAddLoyaltyCardParams {
+    loyaltyCardValues: AddLoyaltyCardValues;
+    customerId: number;
+    locale?: null | string;
+  }
+
   /**
    * Parameters for CustomerAddPayerReference
    */

generated/swagger/crm-api/src/services/loyalty-card.service.ts

@@ -10,10 +10,11 @@ import { map as __map, filter as __filter } from 'rxjs/operators';
 import { ResponseArgsOfIQueryResultOfLoyaltyBookingInfoDTO } from '../models/response-args-of-iquery-result-of-loyalty-booking-info-dto';
 import { ResponseArgsOfLoyaltyBookingInfoDTO } from '../models/response-args-of-loyalty-booking-info-dto';
 import { LoyaltyBookingValues } from '../models/loyalty-booking-values';
-import { ResponseArgsOfIEnumerableOfString } from '../models/response-args-of-ienumerable-of-string';
+import { ResponseArgsOfIEnumerableOfKeyValueDTOOfStringAndInteger } from '../models/response-args-of-ienumerable-of-key-value-dtoof-string-and-integer';
 import { ResponseArgsOfKeyValueDTOOfStringAndString } from '../models/response-args-of-key-value-dtoof-string-and-string';
-import { ResponseArgsOfBoolean } from '../models/response-args-of-boolean';
+import { ResponseArgsOfLoyaltyBonResponse } from '../models/response-args-of-loyalty-bon-response';
 import { LoyaltyBonValues } from '../models/loyalty-bon-values';
+import { ResponseArgsOfBoolean } from '../models/response-args-of-boolean';
 import { ResponseArgsOfNullableBoolean } from '../models/response-args-of-nullable-boolean';
 @Injectable({
   providedIn: 'root',
@@ -21,12 +22,13 @@ import { ResponseArgsOfNullableBoolean } from '../models/response-args-of-nullab
 class LoyaltyCardService extends __BaseService {
   static readonly LoyaltyCardListBookingsPath = '/loyalty/{cardCode}/booking';
   static readonly LoyaltyCardAddBookingPath = '/loyalty/{cardCode}/booking';
+  static readonly LoyaltyCardListCustomerBookingsPath = '/customer/{customerId}/loyalty/booking';
   static readonly LoyaltyCardBookingReasonPath = '/loyalty/booking/reason';
   static readonly LoyaltyCardCurrentBookingPartnerStorePath = '/loyalty/booking/partner/store/current';
   static readonly LoyaltyCardLoyaltyBonCheckPath = '/loyalty/{cardCode}/bon/check';
   static readonly LoyaltyCardLoyaltyBonAddPath = '/loyalty/{cardCode}/bon/add';
   static readonly LoyaltyCardLockCardPath = '/loyalty/{cardCode}/lock';
-  static readonly LoyaltyCardUnlockCardPath = '/loyalty/{cardCode}/unlock';
+  static readonly LoyaltyCardUnlockCardPath = '/customer/{customerId}/loyalty/{cardCode}/unlock';
 
   constructor(
     config: __Configuration,
@@ -130,10 +132,55 @@ class LoyaltyCardService extends __BaseService {
     );
   }
 
+  /**
+   * Bookings / Buchungen
+   * @param params The `LoyaltyCardService.LoyaltyCardListCustomerBookingsParams` containing the following parameters:
+   *
+   * - `customerId`:
+   *
+   * - `locale`:
+   */
+  LoyaltyCardListCustomerBookingsResponse(params: LoyaltyCardService.LoyaltyCardListCustomerBookingsParams): __Observable<__StrictHttpResponse<ResponseArgsOfIQueryResultOfLoyaltyBookingInfoDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
+    let req = new HttpRequest<any>(
+      'GET',
+      this.rootUrl + `/customer/${encodeURIComponent(String(params.customerId))}/loyalty/booking`,
+      __body,
+      {
+        headers: __headers,
+        params: __params,
+        responseType: 'json'
+      });
+
+    return this.http.request<any>(req).pipe(
+      __filter(_r => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfIQueryResultOfLoyaltyBookingInfoDTO>;
+      })
+    );
+  }
+  /**
+   * Bookings / Buchungen
+   * @param params The `LoyaltyCardService.LoyaltyCardListCustomerBookingsParams` containing the following parameters:
+   *
+   * - `customerId`:
+   *
+   * - `locale`:
+   */
+  LoyaltyCardListCustomerBookings(params: LoyaltyCardService.LoyaltyCardListCustomerBookingsParams): __Observable<ResponseArgsOfIQueryResultOfLoyaltyBookingInfoDTO> {
+    return this.LoyaltyCardListCustomerBookingsResponse(params).pipe(
+      __map(_r => _r.body as ResponseArgsOfIQueryResultOfLoyaltyBookingInfoDTO)
+    );
+  }
+
   /**
    * Booking reason / Buchungsgründe
    */
-  LoyaltyCardBookingReasonResponse(): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfString>> {
+  LoyaltyCardBookingReasonResponse(): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfKeyValueDTOOfStringAndInteger>> {
     let __params = this.newParams();
     let __headers = new HttpHeaders();
     let __body: any = null;
@@ -150,16 +197,16 @@ class LoyaltyCardService extends __BaseService {
     return this.http.request<any>(req).pipe(
       __filter(_r => _r instanceof HttpResponse),
       __map((_r) => {
-        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfString>;
+        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfKeyValueDTOOfStringAndInteger>;
       })
     );
   }
   /**
    * Booking reason / Buchungsgründe
    */
-  LoyaltyCardBookingReason(): __Observable<ResponseArgsOfIEnumerableOfString> {
+  LoyaltyCardBookingReason(): __Observable<ResponseArgsOfIEnumerableOfKeyValueDTOOfStringAndInteger> {
     return this.LoyaltyCardBookingReasonResponse().pipe(
-      __map(_r => _r.body as ResponseArgsOfIEnumerableOfString)
+      __map(_r => _r.body as ResponseArgsOfIEnumerableOfKeyValueDTOOfStringAndInteger)
     );
   }
 
@@ -206,7 +253,7 @@ class LoyaltyCardService extends __BaseService {
    *
    * - `locale`:
    */
-  LoyaltyCardLoyaltyBonCheckResponse(params: LoyaltyCardService.LoyaltyCardLoyaltyBonCheckParams): __Observable<__StrictHttpResponse<ResponseArgsOfBoolean>> {
+  LoyaltyCardLoyaltyBonCheckResponse(params: LoyaltyCardService.LoyaltyCardLoyaltyBonCheckParams): __Observable<__StrictHttpResponse<ResponseArgsOfLoyaltyBonResponse>> {
     let __params = this.newParams();
     let __headers = new HttpHeaders();
     let __body: any = null;
@@ -226,7 +273,7 @@ class LoyaltyCardService extends __BaseService {
     return this.http.request<any>(req).pipe(
       __filter(_r => _r instanceof HttpResponse),
       __map((_r) => {
-        return _r as __StrictHttpResponse<ResponseArgsOfBoolean>;
+        return _r as __StrictHttpResponse<ResponseArgsOfLoyaltyBonResponse>;
       })
     );
   }
@@ -240,9 +287,9 @@ class LoyaltyCardService extends __BaseService {
    *
    * - `locale`:
    */
-  LoyaltyCardLoyaltyBonCheck(params: LoyaltyCardService.LoyaltyCardLoyaltyBonCheckParams): __Observable<ResponseArgsOfBoolean> {
+  LoyaltyCardLoyaltyBonCheck(params: LoyaltyCardService.LoyaltyCardLoyaltyBonCheckParams): __Observable<ResponseArgsOfLoyaltyBonResponse> {
     return this.LoyaltyCardLoyaltyBonCheckResponse(params).pipe(
-      __map(_r => _r.body as ResponseArgsOfBoolean)
+      __map(_r => _r.body as ResponseArgsOfLoyaltyBonResponse)
     );
   }
 
@@ -345,6 +392,8 @@ class LoyaltyCardService extends __BaseService {
    * Unlock card
    * @param params The `LoyaltyCardService.LoyaltyCardUnlockCardParams` containing the following parameters:
    *
+   * - `customerId`:
+   *
    * - `cardCode`:
    *
    * - `locale`:
@@ -354,10 +403,11 @@ class LoyaltyCardService extends __BaseService {
     let __headers = new HttpHeaders();
     let __body: any = null;
 
+
     if (params.locale != null) __params = __params.set('locale', params.locale.toString());
     let req = new HttpRequest<any>(
       'POST',
-      this.rootUrl + `/loyalty/${encodeURIComponent(String(params.cardCode))}/unlock`,
+      this.rootUrl + `/customer/${encodeURIComponent(String(params.customerId))}/loyalty/${encodeURIComponent(String(params.cardCode))}/unlock`,
       __body,
       {
         headers: __headers,
@@ -376,6 +426,8 @@ class LoyaltyCardService extends __BaseService {
    * Unlock card
    * @param params The `LoyaltyCardService.LoyaltyCardUnlockCardParams` containing the following parameters:
    *
+   * - `customerId`:
+   *
    * - `cardCode`:
    *
    * - `locale`:
@@ -406,6 +458,14 @@ module LoyaltyCardService {
     locale?: null | string;
   }
 
+  /**
+   * Parameters for LoyaltyCardListCustomerBookings
+   */
+  export interface LoyaltyCardListCustomerBookingsParams {
+    customerId: number;
+    locale?: null | string;
+  }
+
   /**
    * Parameters for LoyaltyCardLoyaltyBonCheck
    */
@@ -436,6 +496,7 @@ module LoyaltyCardService {
    * Parameters for LoyaltyCardUnlockCard
    */
   export interface LoyaltyCardUnlockCardParams {
+    customerId: number;
     cardCode: string;
     locale?: null | string;
   }

libs/availability/data-access/project.json

@@ -1,28 +1,28 @@
-{
-  "name": "availability-data-access",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/availability/data-access/src",
-  "prefix": "availability",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "test": {
-      "executor": "@nx/vite:test",
-      "outputs": ["{options.reportsDirectory}"],
-      "options": {
-        "reportsDirectory": "../../../coverage/libs/availability/data-access"
-      },
-      "configurations": {
-        "ci": {
-          "mode": "run",
-          "coverage": {
-            "enabled": true
-          }
-        }
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    }
-  }
-}
+{
+  "name": "availability-data-access",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/availability/data-access/src",
+  "prefix": "availability",
+  "projectType": "library",
+  "tags": ["skip:ci"],
+  "targets": {
+    "test": {
+      "executor": "@nx/vite:test",
+      "outputs": ["{options.reportsDirectory}"],
+      "options": {
+        "reportsDirectory": "../../../coverage/libs/availability/data-access"
+      },
+      "configurations": {
+        "ci": {
+          "mode": "run",
+          "coverage": {
+            "enabled": true
+          }
+        }
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    }
+  }
+}

libs/checkout/data-access/project.json

@@ -1,30 +1,28 @@
-{
-  "name": "checkout-data-access",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/checkout/data-access/src",
-  "prefix": "lib",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "test": {
-      "executor": "@nx/vite:test",
-      "outputs": [
-        "{options.reportsDirectory}"
-      ],
-      "options": {
-        "reportsDirectory": "../../../coverage/libs/checkout/data-access"
-      },
-      "configurations": {
-        "ci": {
-          "mode": "run",
-          "coverage": {
-            "enabled": true
-          }
-        }
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    }
-  }
-}
+{
+  "name": "checkout-data-access",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/checkout/data-access/src",
+  "prefix": "lib",
+  "projectType": "library",
+  "tags": ["skip:ci"],
+  "targets": {
+    "test": {
+      "executor": "@nx/vite:test",
+      "outputs": ["{options.reportsDirectory}"],
+      "options": {
+        "reportsDirectory": "../../../coverage/libs/checkout/data-access"
+      },
+      "configurations": {
+        "ci": {
+          "mode": "run",
+          "coverage": {
+            "enabled": true
+          }
+        }
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    }
+  }
+}

libs/checkout/feature/reward-catalog/src/lib/reward-action/reward-action.component.ts

@@ -88,7 +88,7 @@ export class RewardActionComponent {
         items,
         useRedemptionPoints: true,
         preSelectOption: { option: 'in-store' },
-        disabledPurchaseOptions: ['delivery', 'dig-delivery', 'b2b-delivery'],
+        disabledPurchaseOptions: ['b2b-delivery'],
         hideDisabledPurchaseOptions: true,
       });
 

libs/checkout/feature/reward-catalog/src/lib/reward-header/reward-customer-card/reward-customer-card.component.html

@@ -12,7 +12,7 @@
       type="button"
       color="subtle"
       size="small"
-      (click)="resetCustomerAndCart()"
+      (click)="resetCustomerAndRewardCart()"
     >
       Zurücksetzen
     </ui-text-button>

libs/checkout/feature/reward-catalog/src/lib/reward-header/reward-customer-card/reward-customer-card.component.ts

@@ -16,8 +16,9 @@ import {
   SelectedRewardShoppingCartResource,
 } from '@isa/checkout/data-access';
 import { RouterLink } from '@angular/router';
-import { injectTabId } from '@isa/core/tabs';
+import { TabService, getNextTabNameHelper } from '@isa/core/tabs';
 import { formatName } from '@isa/utils/format-name';
+import { DomainCheckoutService } from '@domain/checkout';
 
 @Component({
   selector: 'reward-customer-card',
@@ -34,7 +35,8 @@ import { formatName } from '@isa/utils/format-name';
 export class RewardCustomerCardComponent {
   #crmTabMetadataService = inject(CrmTabMetadataService);
   #checkoutMetadataService = inject(CheckoutMetadataService);
-  tabId = injectTabId();
+  #domainCheckoutService = inject(DomainCheckoutService);
+  #tabService = inject(TabService);
   #customerResource = inject(SelectedCustomerResource).resource;
   #shoppingCartResource = inject(SelectedRewardShoppingCartResource).resource;
   #primaryCustomerCardResource = inject(PrimaryCustomerCardResource);
@@ -65,11 +67,71 @@ export class RewardCustomerCardComponent {
     });
   });
 
-  resetCustomerAndCart() {
-    this.#crmTabMetadataService.setSelectedCustomerId(this.tabId()!, undefined);
-    this.#checkoutMetadataService.setRewardShoppingCartId(
-      this.tabId()!,
-      undefined,
-    );
+  resetCustomerAndRewardCart() {
+    const tabId = this.#tabService.activatedTabId()!;
+
+    // Clear all customer-related checkout data
+    this.#clearCheckoutData(tabId);
+
+    // Clear all customer-related metadata
+    this.#clearCustomerMetadata(tabId);
+
+    // Clear reward shopping cart ID from metadata
+    this.#checkoutMetadataService.setRewardShoppingCartId(tabId, undefined);
+
+    // Rename tab to "Vorgang X"
+    const tabName = getNextTabNameHelper(this.#tabService.entityMap());
+    this.#tabService.patchTab(tabId, { name: tabName });
+  }
+
+  /**
+   * Clears all checkout data set by the continue() flow (customer, buyer, payer, shipping address, notification channels).
+   * This is the reverse operation of what happens in details-main-view.component.ts continue().
+   */
+  #clearCheckoutData(tabId: number): void {
+    // Reset customer (reverse of _setCustomer)
+    this.#domainCheckoutService.setCustomer({
+      processId: tabId,
+      customerDto: null as any,
+    });
+
+    // Reset buyer (reverse of _setBuyer)
+    this.#domainCheckoutService.setBuyer({
+      processId: tabId,
+      buyer: null as any,
+    });
+
+    // Reset payer (reverse of _setPayer)
+    this.#domainCheckoutService.setPayer({
+      processId: tabId,
+      payer: null as any,
+    });
+
+    // Reset shipping address (reverse of _setShippingAddress)
+    this.#domainCheckoutService.setShippingAddress({
+      processId: tabId,
+      shippingAddress: null as any,
+    });
+
+    // Reset notification channels (reverse of _updateNotifcationChannelsAsync)
+    this.#domainCheckoutService.setNotificationChannels({
+      processId: tabId,
+      notificationChannels: 0,
+    });
+  }
+
+  /**
+   * Clears all customer-related metadata from the tab (customer ID, payer ID, shipping address ID).
+   * This is the reverse operation of what happens in details-main-view.component.ts continue().
+   */
+  #clearCustomerMetadata(tabId: number): void {
+    // Clear customer ID from metadata (reverse of _setSelectedCustomerIdInTab)
+    this.#crmTabMetadataService.setSelectedCustomerId(tabId, undefined);
+
+    // Clear payer ID from metadata
+    this.#crmTabMetadataService.setSelectedPayerId(tabId, undefined);
+
+    // Clear shipping address ID from metadata
+    this.#crmTabMetadataService.setSelectedShippingAddressId(tabId, undefined);
   }
 }

libs/checkout/feature/reward-order-confirmation/project.json

@@ -1,20 +1,20 @@
-{
-  "name": "checkout-feature-reward-order-confirmation",
-  "$schema": "../../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/checkout/feature/reward-order-confirmation/src",
-  "prefix": "checkout",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "test": {
-      "executor": "@nx/vite:test",
-      "outputs": ["{options.reportsDirectory}"],
-      "options": {
-        "reportsDirectory": "../../../../coverage/libs/checkout/feature/reward-order-confirmation"
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    }
-  }
-}
+{
+  "name": "checkout-feature-reward-order-confirmation",
+  "$schema": "../../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/checkout/feature/reward-order-confirmation/src",
+  "prefix": "checkout",
+  "projectType": "library",
+  "tags": ["skip:ci"],
+  "targets": {
+    "test": {
+      "executor": "@nx/vite:test",
+      "outputs": ["{options.reportsDirectory}"],
+      "options": {
+        "reportsDirectory": "../../../../coverage/libs/checkout/feature/reward-order-confirmation"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    }
+  }
+}

libs/checkout/feature/reward-order-confirmation/src/lib/order-confirmation-item-list/order-confirmation-item-list-item/order-confirmation-item-list-item.component.ts

@@ -10,8 +10,7 @@ import {
   DisplayOrderDestinationInfoComponent,
 } from '@isa/checkout/shared/product-info';
 import { DisplayOrderItemDTO } from '@generated/swagger/oms-api';
-import { Product } from '@isa/common/data-access';
-import { type OrderItemGroup } from '@isa/checkout/data-access';
+import { type OrderItemGroup, type Product } from '@isa/checkout/data-access';
 
 @Component({
   selector: 'checkout-order-confirmation-item-list-item',

libs/checkout/feature/reward-order-confirmation/src/lib/routes.ts

@@ -1,6 +1,7 @@
 import { Routes } from '@angular/router';
 import { CoreCommandModule } from '@core/command';
 import { OMS_ACTION_HANDLERS } from '@isa/oms/data-access';
+import { canDeactivateTabCleanup } from '@isa/core/tabs';
 
 export const routes: Routes = [
   {
@@ -12,5 +13,6 @@ export const routes: Routes = [
       import('./reward-order-confirmation.component').then(
         (m) => m.RewardOrderConfirmationComponent,
       ),
+    canDeactivate: [canDeactivateTabCleanup],
   },
 ];

libs/checkout/feature/reward-shopping-cart/src/lib/reward-shopping-cart-item/reward-shopping-cart-item.component.ts

@@ -88,7 +88,7 @@ export class RewardShoppingCartItemComponent {
         tabId: this.#tabId() as unknown as number,
         type: 'update',
         useRedemptionPoints: true,
-        disabledPurchaseOptions: ['delivery', 'dig-delivery', 'b2b-delivery'],
+        disabledPurchaseOptions: ['b2b-delivery'],
         hideDisabledPurchaseOptions: true,
       });
 

libs/checkout/shared/product-info/project.json

@@ -1,30 +1,28 @@
-{
-  "name": "checkout-shared-product-info",
-  "$schema": "../../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/checkout/shared/product-info/src",
-  "prefix": "checkout",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "test": {
-      "executor": "@nx/vite:test",
-      "outputs": [
-        "{options.reportsDirectory}"
-      ],
-      "options": {
-        "reportsDirectory": "../../../../coverage/libs/checkout/shared/product-info"
-      },
-      "configurations": {
-        "ci": {
-          "mode": "run",
-          "coverage": {
-            "enabled": true
-          }
-        }
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    }
-  }
-}
+{
+  "name": "checkout-shared-product-info",
+  "$schema": "../../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/checkout/shared/product-info/src",
+  "prefix": "checkout",
+  "projectType": "library",
+  "tags": ["skip:ci"],
+  "targets": {
+    "test": {
+      "executor": "@nx/vite:test",
+      "outputs": ["{options.reportsDirectory}"],
+      "options": {
+        "reportsDirectory": "../../../../coverage/libs/checkout/shared/product-info"
+      },
+      "configurations": {
+        "ci": {
+          "mode": "run",
+          "coverage": {
+            "enabled": true
+          }
+        }
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    }
+  }
+}

libs/checkout/shared/product-info/src/lib/product-info/product-info.component.ts

@@ -4,11 +4,14 @@ import {
   computed,
   input,
 } from '@angular/core';
-import { Product } from '@isa/common/data-access';
 import { ProductImageDirective } from '@isa/shared/product-image';
 import { ProductRouterLinkDirective } from '@isa/shared/product-router-link';
 
-export type ProductInfoItem = Pick<Product, 'ean' | 'name' | 'contributors'>;
+export type ProductInfoItem = {
+  ean?: string;
+  name?: string;
+  contributors?: string;
+};
 
 export type ProductNameSize = 'small' | 'medium' | 'large';
 

libs/common/data-access/src/lib/helpers/is-response-args.helper.ts

@@ -1,11 +1,13 @@
+import z from 'zod';
 import { ResponseArgs } from '../models';
 
+const ResponseArgsSchema = z.object({
+  error: z.boolean(),
+  message: z.string().optional(),
+  invalidProperties: z.record(z.string()).optional(),
+  result: z.any().optional(),
+});
+
 export function isResponseArgs<T>(args: any): args is ResponseArgs<T> {
-  return (
-    args &&
-    typeof args === 'object' &&
-    'error' in args &&
-    'invalidProperties' in args &&
-    'message' in args
-  );
+  return ResponseArgsSchema.safeParse(args).success;
 }

libs/common/data-access/src/lib/models/index.ts

@@ -9,7 +9,6 @@ export * from './order-type-feature';
 export * from './payer-type';
 export * from './price-value';
 export * from './price';
-export * from './product';
 export * from './response-args';
 export * from './return-value';
 export * from './vat-type';

libs/common/data-access/src/lib/models/product.ts

@@ -1,5 +0,0 @@
-import { ProductDTO as CatProductDTO } from '@generated/swagger/cat-search-api';
-import { ProductDTO as CheckoutProductDTO } from '@generated/swagger/checkout-api';
-import { ProductDTO as OmsProductDTO } from '@generated/swagger/oms-api';
-
-export type Product = CatProductDTO | CheckoutProductDTO | OmsProductDTO;

libs/common/data-access/src/lib/operators/catch-response-args-error.ts

@@ -1,43 +1,43 @@
-import { catchError } from 'rxjs/operators';
-import { OperatorFunction, throwError } from 'rxjs';
-import { ResponseArgsError } from '../errors';
-import { HttpErrorResponse } from '@angular/common/http';
-import { ResponseArgs } from '../models';
-
-/**
- *
- * Operator that catches errors from an observable stream and transforms them into
- *
- * `ResponseArgsError` instances when applicable.
- * This operator is useful for handling HTTP errors that return a structured
- * response conforming to the `ResponseArgs` interface.
- *
- * If the error is already a `ResponseArgsError`, it is re-thrown as is.
- * If the error is an `HttpErrorResponse` with a valid `ResponseArgs` payload,
- * it creates and throws a new `ResponseArgsError`.
- * For all other error types, it re-throws the original error.
- *
- */
-export const catchResponseArgsErrorPipe = <T>(): OperatorFunction<T, T> =>
-  catchError((err: unknown) => {
-    if (err instanceof ResponseArgsError) {
-      return throwError(() => err);
-    }
-
-    if (err instanceof HttpErrorResponse && err.error) {
-      const payload = err.error as Partial<ResponseArgs<unknown>>;
-
-      if (payload.error === true) {
-        return throwError(
-          () =>
-            new ResponseArgsError({
-              error: true,
-              message: payload.message,
-              invalidProperties: payload.invalidProperties ?? {},
-            }),
-        );
-      }
-    }
-
-    return throwError(() => err);
-  });
+import { catchError, mergeMap } from 'rxjs/operators';
+import { OperatorFunction, throwError, pipe } from 'rxjs';
+import { ResponseArgsError } from '../errors';
+import { HttpErrorResponse } from '@angular/common/http';
+import { isResponseArgs } from '../helpers';
+
+/**
+ *
+ * Operator that catches errors from an observable stream and transforms them into
+ *
+ * `ResponseArgsError` instances when applicable.
+ * This operator is useful for handling HTTP errors that return a structured
+ * response conforming to the `ResponseArgs` interface.
+ *
+ * If the error is already a `ResponseArgsError`, it is re-thrown as is.
+ * If the error is an `HttpErrorResponse` with a valid `ResponseArgs` payload,
+ * it creates and throws a new `ResponseArgsError`.
+ * For all other error types, it re-throws the original error.
+ *
+ */
+export const catchResponseArgsErrorPipe = <T>(): OperatorFunction<T, T> =>
+  pipe(
+    catchError((err: unknown) => {
+      if (err instanceof ResponseArgsError) {
+        return throwError(() => err);
+      }
+
+      if (err instanceof HttpErrorResponse) {
+        const payload = err.error;
+        if (isResponseArgs(payload)) {
+          return throwError(() => new ResponseArgsError(payload));
+        }
+      }
+      return throwError(() => err);
+    }),
+    mergeMap((response) => {
+      if (isResponseArgs(response) && response.error === true) {
+        return throwError(() => new ResponseArgsError(response));
+      }
+
+      return [response];
+    }),
+  );

libs/common/print/src/lib/components/print-button/print-button.component.spec.ts

@@ -5,6 +5,10 @@ import { PrinterType, Printer } from '../../models';
 import { InfoButtonComponent } from '@isa/ui/buttons';
 import { NgIcon } from '@ng-icons/core';
 
+// Mock Scandit modules to avoid loading external dependencies
+jest.mock('scandit-web-datacapture-core', () => ({}));
+jest.mock('scandit-web-datacapture-barcode', () => ({}));
+
 describe('PrintButtonComponent', () => {
   let spectator: Spectator<PrintButtonComponent>;
   let printServiceMock: jest.Mocked<PrintService>;

libs/core/navigation/README.md

@@ -146,6 +146,68 @@ navState.preserveContext(
 
 ---
 
+#### `patchContext<T>(partialState, customScope?)`
+
+Partially update preserved context without replacing the entire context.
+
+This method merges partial state with the existing context, preserving properties you don't specify. Properties explicitly set to `undefined` will be removed from the context.
+
+```typescript
+// Existing context: { returnUrl: '/cart', autoTriggerContinueFn: true, customerId: 123 }
+
+// Clear one property while preserving others
+await navState.patchContext(
+  { autoTriggerContinueFn: undefined },
+  'select-customer'
+);
+// Result: { returnUrl: '/cart', customerId: 123 }
+
+// Update one property while preserving others
+await navState.patchContext(
+  { customerId: 456 },
+  'select-customer'
+);
+// Result: { returnUrl: '/cart', customerId: 456 }
+
+// Add new property to existing context
+await navState.patchContext(
+  { selectedTab: 'details' },
+  'select-customer'
+);
+// Result: { returnUrl: '/cart', customerId: 456, selectedTab: 'details' }
+```
+
+**Parameters:**
+- `partialState`: Partial state object to merge (set properties to `undefined` to remove them)
+- `customScope` (optional): Custom scope within the tab
+
+**Use Cases:**
+- Clear trigger flags while preserving flow data
+- Update specific properties without affecting others
+- Remove properties from context
+- Add properties to existing context
+
+**Comparison with `preserveContext`:**
+- `preserveContext`: Replaces entire context (overwrites all properties)
+- `patchContext`: Merges with existing context (updates only specified properties)
+
+```typescript
+// ❌ preserveContext - must manually preserve existing properties
+const context = await navState.restoreContext();
+await navState.preserveContext({
+  returnUrl: context?.returnUrl, // Must specify
+  customerId: context?.customerId, // Must specify
+  autoTriggerContinueFn: undefined, // Clear this
+});
+
+// ✅ patchContext - automatically preserves unspecified properties
+await navState.patchContext({
+  autoTriggerContinueFn: undefined, // Only specify what changes
+});
+```
+
+---
+
 #### `restoreContext<T>(customScope?)`
 
 Retrieve preserved context **without** removing it.
@@ -710,6 +772,7 @@ export const NAVIGATION_CONTEXT_METADATA_KEY = 'navigation-contexts';
 | Method | Parameters | Returns | Purpose |
 |--------|-----------|---------|---------|
 | `preserveContext(state, customScope?)` | state: T, customScope?: string | void | Save context |
+| `patchContext(partialState, customScope?)` | partialState: Partial<T>, customScope?: string | void | Merge partial updates |
 | `restoreContext(customScope?)` | customScope?: string | T \| null | Get context (keep) |
 | `restoreAndClearContext(customScope?)` | customScope?: string | T \| null | Get + remove |
 | `clearPreservedContext(customScope?)` | customScope?: string | boolean | Remove context |

libs/core/navigation/project.json

@@ -1,20 +1,20 @@
-{
-  "name": "core-navigation",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/core/navigation/src",
-  "prefix": "core",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "test": {
-      "executor": "@nx/vite:test",
-      "outputs": ["{options.reportsDirectory}"],
-      "options": {
-        "reportsDirectory": "../../../coverage/libs/core/navigation"
-      }
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    }
-  }
-}
+{
+  "name": "core-navigation",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/core/navigation/src",
+  "prefix": "core",
+  "projectType": "library",
+  "tags": ["skip:ci"],
+  "targets": {
+    "test": {
+      "executor": "@nx/vite:test",
+      "outputs": ["{options.reportsDirectory}"],
+      "options": {
+        "reportsDirectory": "../../../coverage/libs/core/navigation"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    }
+  }
+}

libs/core/navigation/src/lib/navigation-context.service.ts

@@ -143,6 +143,75 @@ export class NavigationContextService {
     }));
   }
 
+  /**
+   * Patch a context in the active tab's metadata.
+   *
+   * Merges partial data with the existing context, preserving unspecified properties.
+   * Properties explicitly set to `undefined` will be removed from the context.
+   * If the context doesn't exist, creates a new one (behaves like setContext).
+   *
+   * @template T The type of data being patched
+   * @param partialData The partial navigation data to merge
+   * @param customScope Optional custom scope (defaults to 'default')
+   *
+   * @example
+   * ```typescript
+   * // Clear one property while preserving others
+   * contextService.patchContext({ autoTriggerContinueFn: undefined }, 'select-customer');
+   *
+   * // Update one property while preserving others
+   * contextService.patchContext({ selectedTab: 'details' }, 'customer-flow');
+   * ```
+   */
+  async patchContext<T extends NavigationContextData>(
+    partialData: Partial<T>,
+    customScope?: string,
+  ): Promise<void> {
+    const tabId = this.#tabService.activatedTabId();
+    if (tabId === null) {
+      throw new Error('No active tab - cannot patch navigation context');
+    }
+
+    const scopeKey = customScope || 'default';
+    const existingContext = await this.getContext<T>(customScope);
+
+    const mergedData = {
+      ...(existingContext ?? {}),
+      ...partialData,
+    };
+
+    // Remove properties explicitly set to undefined
+    const removedKeys: string[] = [];
+    Object.keys(mergedData).forEach((key) => {
+      if (mergedData[key] === undefined) {
+        removedKeys.push(key);
+        delete mergedData[key];
+      }
+    });
+
+    const contextsMap = this.#getContextsMap(tabId);
+    const context: NavigationContext = {
+      data: mergedData,
+      createdAt:
+        existingContext && contextsMap[scopeKey]
+          ? contextsMap[scopeKey].createdAt
+          : Date.now(),
+    };
+
+    contextsMap[scopeKey] = context;
+    this.#saveContextsMap(tabId, contextsMap);
+
+    this.#log.debug('Context patched in tab metadata', () => ({
+      tabId,
+      scopeKey,
+      patchedKeys: Object.keys(partialData),
+      removedKeys,
+      totalDataKeys: Object.keys(mergedData),
+      wasUpdate: existingContext !== null,
+      totalContexts: Object.keys(contextsMap).length,
+    }));
+  }
+
   /**
    * Get a context from the active tab's metadata without removing it.
    *

libs/core/navigation/src/lib/navigation-state.service.ts

@@ -112,6 +112,50 @@ export class NavigationStateService {
     await this.#contextService.setContext(state, customScope);
   }
 
+  /**
+   * Patch preserved navigation state.
+   *
+   * Merges partial state with existing preserved context, keeping unspecified properties intact.
+   * This is useful when you need to update or clear specific properties without replacing
+   * the entire context. Properties set to `undefined` will be removed.
+   *
+   * Use cases:
+   * - Clear a trigger flag while preserving return URL
+   * - Update one property in a multi-property context
+   * - Remove specific properties from context
+   *
+   * @template T The type of state data being patched
+   * @param partialState The partial state to merge (properties set to undefined will be removed)
+   * @param customScope Optional custom scope within the tab
+   *
+   * @example
+   * ```typescript
+   * // Clear the autoTriggerContinueFn flag while preserving returnUrl
+   * await navigationStateService.patchContext(
+   *   { autoTriggerContinueFn: undefined },
+   *   'select-customer'
+   * );
+   *
+   * // Update selectedTab while keeping other properties
+   * await navigationStateService.patchContext(
+   *   { selectedTab: 'rewards' },
+   *   'customer-flow'
+   * );
+   *
+   * // Add a new property to existing context
+   * await navigationStateService.patchContext(
+   *   { shippingAddressId: 123 },
+   *   'checkout-flow'
+   * );
+   * ```
+   */
+  async patchContext<T extends NavigationContextData>(
+    partialState: Partial<T>,
+    customScope?: string,
+  ): Promise<void> {
+    await this.#contextService.patchContext(partialState, customScope);
+  }
+
   /**
    * Restore preserved navigation state.
    *

libs/core/tabs/src/index.ts

@@ -8,3 +8,4 @@ export * from './lib/tab-navigation.constants';
 export * from './lib/tab-config';
 export * from './lib/helpers';
 export * from './lib/has-tab-id.guard';
+export * from './lib/tab-cleanup.guard';

libs/core/tabs/src/lib/helpers.spec.ts

@@ -0,0 +1,71 @@
+import { getNextTabNameHelper } from './helpers';
+import { Tab } from './schemas';
+import { EntityMap } from '@ngrx/signals/entities';
+
+describe('getNextTabNameHelper', () => {
+  const createTab = (id: number, name: string): Tab => ({
+    id,
+    name,
+    createdAt: Date.now(),
+    activatedAt: Date.now(),
+    tags: [],
+    metadata: {},
+    location: { current: -1, locations: [] },
+  });
+
+  it('should return "Vorgang 1" when no tabs exist', () => {
+    const entities: EntityMap<Tab> = {};
+    const result = getNextTabNameHelper(entities);
+    expect(result).toBe('Vorgang 1');
+  });
+
+  it('should return "Vorgang 1" when no Vorgang tabs exist', () => {
+    const entities: EntityMap<Tab> = {
+      1: createTab(1, 'Bestellbestätigung'),
+      2: createTab(2, 'Artikelsuche'),
+    };
+    const result = getNextTabNameHelper(entities);
+    expect(result).toBe('Vorgang 1');
+  });
+
+  it('should return "Vorgang 2" when one Vorgang tab exists', () => {
+    const entities: EntityMap<Tab> = {
+      1: createTab(1, 'Vorgang 1'),
+    };
+    const result = getNextTabNameHelper(entities);
+    expect(result).toBe('Vorgang 2');
+  });
+
+  it('should return "Vorgang 4" when three Vorgang tabs exist', () => {
+    const entities: EntityMap<Tab> = {
+      1: createTab(1, 'Vorgang 1'),
+      2: createTab(2, 'Vorgang 3'),
+      3: createTab(3, 'Vorgang 2'),
+    };
+    const result = getNextTabNameHelper(entities);
+    expect(result).toBe('Vorgang 4');
+  });
+
+  it('should count only Vorgang tabs, ignore other tabs', () => {
+    const entities: EntityMap<Tab> = {
+      1: createTab(1, 'Vorgang 1'),
+      2: createTab(2, 'Bestellbestätigung'),
+      3: createTab(3, 'Vorgang 2'),
+      4: createTab(4, 'Artikelsuche'),
+      5: createTab(5, 'Max Mustermann - Bestellbestätigung'),
+    };
+    const result = getNextTabNameHelper(entities);
+    expect(result).toBe('Vorgang 3');
+  });
+
+  it('should handle gaps in numbering by counting tabs', () => {
+    const entities: EntityMap<Tab> = {
+      1: createTab(1, 'Vorgang 1'),
+      2: createTab(2, 'Vorgang 5'),
+      3: createTab(3, 'Vorgang 10'),
+    };
+    // Count is 3, so next should be Vorgang 4
+    const result = getNextTabNameHelper(entities);
+    expect(result).toBe('Vorgang 4');
+  });
+});

libs/core/tabs/src/lib/helpers.ts

@@ -27,3 +27,75 @@ export function getMetadataHelper<T extends z.ZodTypeAny>(
   }
   return undefined;
 }
+
+/**
+ * Gets the next tab name for a Vorgang (process).
+ *
+ * @param entities - All tab entities
+ * @returns Tab name in format "Vorgang X" where X is the count of existing Vorgang tabs + 1
+ *
+ * Behavior:
+ * - Counts all tabs matching pattern "Vorgang \\d+"
+ * - Returns "Vorgang {count + 1}"
+ * - Example: If 2 Vorgang tabs exist -> returns "Vorgang 3"
+ */
+export function getNextTabNameHelper(entities: EntityMap<Tab>): string {
+  const REGEX_PROCESS_NAME = /^Vorgang \d+$/;
+  const allTabs = Object.values(entities);
+
+  // Count tabs with "Vorgang X" pattern
+  const vorgangTabCount = allTabs.filter((tab) =>
+    REGEX_PROCESS_NAME.test(tab.name),
+  ).length;
+
+  return `Vorgang ${vorgangTabCount + 1}`;
+}
+
+// TODO: #5484 Move Logic to other location
+/**
+ * Formats the customer name for tab display.
+ *
+ * For B2B accounts (have 'b2b' feature and not 'staff' feature), shows organization name.
+ * For regular customers, shows first and last name.
+ * Falls back to organization name if personal names are missing.
+ *
+ * @param customer - The customer data
+ * @returns Formatted customer name for display, or empty string if no name available
+ */
+export const formatCustomerTabNameHelper = (customer: {
+  firstName?: string | null;
+  lastName?: string | null;
+  organisation?: { name?: string | null } | null;
+  features?: Array<{ key?: string }> | null;
+}): string => {
+  // Format tab name with customer info (same logic as details-main-view)
+  let name = `${customer.firstName ?? ''} ${customer.lastName ?? ''}`.trim();
+
+  // Check if this is a B2B account (has 'b2b' feature and not 'staff' feature)
+  const isBusinessKonto =
+    !!customer.features?.some((f) => f.key === 'b2b') &&
+    !customer.features?.some((f) => f.key === 'staff');
+
+  // For B2B accounts or when names are missing, use organization name
+  if (
+    (isBusinessKonto && customer.organisation?.name) ||
+    (!customer.firstName && !customer.lastName)
+  ) {
+    name = customer.organisation?.name ?? '';
+  }
+
+  return name;
+};
+
+// TODO: #5484 Move Logic to other location
+/**
+ * Helper function to check if a shopping cart has items.
+ *
+ * @param cart - The shopping cart object or null/undefined
+ * @returns True if cart has items, false otherwise
+ */
+export const checkCartHasItemsHelper = (
+  cart: { items?: unknown[] | null } | null | undefined,
+): boolean => {
+  return (cart?.items?.length ?? 0) > 0;
+};

libs/core/tabs/src/lib/tab-cleanup.guard.ts

@@ -0,0 +1,195 @@
+import { inject } from '@angular/core';
+import { CanDeactivateFn, Router } from '@angular/router';
+import { TabService } from './tab';
+import { logger } from '@isa/core/logging';
+import {
+  CheckoutMetadataService,
+  ShoppingCartService,
+} from '@isa/checkout/data-access';
+import {
+  getNextTabNameHelper,
+  formatCustomerTabNameHelper,
+  checkCartHasItemsHelper,
+} from './helpers';
+import { DomainCheckoutService } from '@domain/checkout';
+import { CrmTabMetadataService } from '@isa/crm/data-access';
+import { firstValueFrom } from 'rxjs';
+
+// TODO: #5484 Move Guard to other location + Use resources for fetching cart data
+/**
+ * CanDeactivate Guard that manages tab context based on shopping cart state.
+ *
+ * This guard checks both the regular shopping cart and reward shopping cart:
+ * - If BOTH carts are empty (or don't exist), the tab context is cleared and renamed to "Vorgang X"
+ * - If EITHER cart still has items:
+ *   - Customer context is preserved
+ *   - Tab name is updated to show customer name (or organization name for B2B)
+ *   - process_type is set to 'cart-checkout' to show cart icon
+ *
+ * Usage: Apply to checkout-summary routes to automatically manage tab state after order completion.
+ */
+export const canDeactivateTabCleanup: CanDeactivateFn<unknown> = async () => {
+  const tabService = inject(TabService);
+  const checkoutMetadataService = inject(CheckoutMetadataService);
+  const crmTabMetadataService = inject(CrmTabMetadataService);
+  const shoppingCartService = inject(ShoppingCartService);
+  const domainCheckoutService = inject(DomainCheckoutService);
+  const router = inject(Router);
+  const log = logger(() => ({ guard: 'TabCleanup' }));
+
+  const tabId = tabService.activatedTabId();
+  if (!tabId) {
+    log.warn('No active tab found');
+    return true;
+  }
+
+  // Check if the target URL contains a tab ID and if it matches the current tab
+  // Routes without tab ID (e.g., /filiale/package-inspection, /kunde/dashboard) are global areas
+  // Routes with different tab ID (e.g., creating new process) should not affect current tab
+  const nextUrl = router.getCurrentNavigation()?.finalUrl?.toString() ?? '';
+  const tabIdMatch = nextUrl.match(/\/(\d{10,})\//);
+  const targetTabId = tabIdMatch ? parseInt(tabIdMatch[1], 10) : null;
+
+  // Skip cleanup if navigating to global area or different tab
+  if (!targetTabId || targetTabId !== tabId) {
+    log.debug(
+      targetTabId
+        ? 'Navigating to different tab, keeping current tab unchanged'
+        : 'Navigating to global area (no tab ID), keeping tab unchanged',
+      () => ({
+        currentTabId: tabId,
+        targetTabId,
+        nextUrl,
+      }),
+    );
+    return true;
+  }
+
+  try {
+    // Get shopping cart IDs from tab metadata
+    const shoppingCartId = checkoutMetadataService.getShoppingCartId(tabId);
+    const rewardShoppingCartId =
+      checkoutMetadataService.getRewardShoppingCartId(tabId);
+
+    // Load carts and check if they have items
+    let regularCart = null;
+    if (shoppingCartId) {
+      try {
+        regularCart = await shoppingCartService.getShoppingCart(shoppingCartId);
+      } catch (error) {
+        log.debug('Could not load regular shopping cart', () => ({
+          shoppingCartId,
+          error: (error as Error).message,
+        }));
+      }
+    }
+
+    let rewardCart = null;
+    if (rewardShoppingCartId) {
+      try {
+        rewardCart =
+          await shoppingCartService.getShoppingCart(rewardShoppingCartId);
+      } catch (error) {
+        log.debug('Could not load reward shopping cart', () => ({
+          rewardShoppingCartId,
+          error: (error as Error).message,
+        }));
+      }
+    }
+
+    const hasRegularItems = checkCartHasItemsHelper(regularCart);
+    const hasRewardItems = checkCartHasItemsHelper(rewardCart);
+
+    log.debug('Cart status check', () => ({
+      tabId,
+      shoppingCartId,
+      rewardShoppingCartId,
+      hasRegularItems,
+      hasRewardItems,
+    }));
+
+    // If either cart has items, preserve context and update tab name with customer info
+    if (hasRegularItems || hasRewardItems) {
+      log.info(
+        'Preserving checkout context - cart(s) still have items',
+        () => ({
+          tabId,
+          hasRegularItems,
+          hasRewardItems,
+        }),
+      );
+
+      try {
+        // Get customer from checkout service
+        const customer = await firstValueFrom(
+          domainCheckoutService.getCustomer({ processId: tabId }),
+        );
+
+        if (customer) {
+          const name = formatCustomerTabNameHelper(customer);
+
+          if (name) {
+            // Update tab name with customer info
+            tabService.patchTab(tabId, { name });
+
+            // Ensure process_type is 'cart' for proper cart icon display
+            tabService.patchTabMetadata(tabId, {
+              process_type: 'cart',
+            });
+
+            log.info('Updated tab name with customer info', () => ({
+              tabId,
+              customerName: name,
+            }));
+          }
+        }
+      } catch (error) {
+        // If customer data can't be loaded, just log and continue
+        log.warn('Could not load customer for tab name update', () => ({
+          tabId,
+          error: (error as Error).message,
+        }));
+      }
+
+      return true;
+    }
+
+    // Both carts are empty - clean up context
+    log.info('Cleaning up checkout context - both carts empty', () => ({
+      tabId,
+    }));
+
+    // Remove checkout state from store (customer, buyer, payer, etc.)
+    domainCheckoutService.removeProcess({ processId: tabId });
+
+    // Clear customer-related metadata (prevents old customer data from being reused)
+    crmTabMetadataService.setSelectedCustomerId(tabId, undefined);
+    crmTabMetadataService.setSelectedPayerId(tabId, undefined);
+    crmTabMetadataService.setSelectedShippingAddressId(tabId, undefined);
+
+    // Create new shopping cart and update Store (this automatically dispatches setShoppingCart action)
+    await firstValueFrom(
+      domainCheckoutService.createShoppingCart({ processId: tabId }),
+    );
+
+    // Clear tab metadata and location history, but keep process_type for cart icon
+    tabService.patchTabMetadata(tabId, { process_type: 'cart' });
+    tabService.clearLocationHistory(tabId);
+
+    // Rename tab to next "Vorgang X" based on count of existing Vorgang tabs
+    const tabName = getNextTabNameHelper(tabService.entityMap());
+    tabService.patchTab(tabId, { name: tabName });
+
+    log.info('Tab reset to clean state', () => ({
+      tabId,
+      name: tabName,
+    }));
+
+    return true;
+  } catch (error) {
+    log.error('Error in checkout cleanup guard', error as Error, () => ({
+      tabId,
+    }));
+    return true; // Allow navigation even if cleanup fails
+  }
+};

libs/core/tabs/src/lib/tab.resolver-fn.ts

@@ -3,6 +3,7 @@ import { TabService } from './tab';
 import { Tab } from './schemas';
 import { inject } from '@angular/core';
 import { logger } from '@isa/core/logging';
+import { getNextTabNameHelper } from './helpers';
 
 export const tabResolverFn: ResolveFn<Tab> = (route) => {
   const log = logger(() => ({
@@ -22,9 +23,10 @@ export const tabResolverFn: ResolveFn<Tab> = (route) => {
   let tab = tabService.entityMap()[tabId];
 
   if (!tab) {
+    const tabName = getNextTabNameHelper(tabService.entityMap());
     tab = tabService.addTab({
       id: tabId,
-      name: 'Neuer Vorgang',
+      name: tabName,
       metadata: {
         process_type: 'cart',
       },