agents-united 0.5.0

package/registry/skills/churn-prevention-playbook/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: churn-prevention-playbook
+description: Production-grade Churn Prevention Playbook for customer health
+  scoring, early warning detection, automated retention workflows, and exit
+  survey salvage offers.
+metadata:
+  author: agents-united
+  version: 2.0.0
+  icon: 🛡️
+disable-slash-command: true
+---
+
+# Customer Churn Prevention Playbook & Retention Automation
+
+## Overview & Purpose
+The Churn Prevention Playbook provides an enterprise framework for detecting at-risk customer accounts, executing automated retention interventions, and mitigating voluntary and involuntary subscription churn in SaaS businesses.
+
+Following this skill models multi-factor customer health scores (login frequency, feature depth, support ticket sentiment, billing status), orchestrates proactive automated interventions, structures cancellation exit flows with tailored salvage offers, and automates smart dunning for failed recurring payments.
+
+## Execution Triggers & Prerequisites
+### Execution Triggers
+- Monthly customer or revenue churn rate exceeding target threshold (> 2.0% monthly MRR churn).
+- Customer health score declining into the "At Risk" tier (< 50/100).
+- User initiating subscription cancellation flow in billing settings.
+- Payment gateway returning invoice charge failures (`invoice.payment_failed`).
+
+### Prerequisites
+- Billing gateway integration (Stripe, Chargebee, Paddle).
+- User product analytics tracking login timestamps and key feature usage events.
+- In-app notification and email outreach communication channels.
+- Clean git working directory.
+
+## Input & Output Requirements
+### Inputs
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `health_score_weights` | Object | Yes | Weights for usage, logins, tickets, seat utilization |
+| `at_risk_threshold` | Number | Optional | Score cutoff for at-risk classification (default: 50) |
+| `salvage_discount_rules`| Array<Object> | Yes | Exit flow offer policies (e.g. 50% off 2 months, pause plan) |
+| `dunning_retry_schedule`| Array<Number> | Optional | Retry delays in days: `[1, 3, 5, 7]` |
+| `cancellation_reasons` | Array<String> | Yes | Categorized exit survey reasons |
+
+### Outputs
+| Artifact | Path / Format | Description |
+|---|---|---|
+| Retention Strategy Spec | `docs/churn-prevention-playbook/retention-spec.md` | Health scoring models, salvage offers, dunning rules |
+| Health Score Engine | `src/services/retention/HealthScoreCalculator.ts` | Multi-factor health score calculation algorithm |
+| Stripe Webhook Handler | `src/api/webhooks/stripe-retention-handler.ts` | Dunning and cancellation event processor |
+| Cohort Churn Report | `reports/churn-prevention-playbook/churn-analysis.json` | Gross vs Net MRR churn and salvage conversion rate |
+
+## Step-by-Step Execution Runbook
+
+### Phase 1: Customer Health Score Algorithm & Early Warning Telemetry
+1. Formulate composite Customer Health Score formula ($0 - 100$):
+   $$\text{Health Score} = 0.35 \times \text{Usage Velocity} + 0.25 \times \text{Login Frequency} + 0.20 \times \text{Seat Utilization} + 0.20 \times \text{Support Sentiment}$$
+2. Classify customer accounts into 3 tiers:
+   - Green (Healthy): Score 75 - 100 (prime candidates for expansion/upsell).
+   - Yellow (Neutral / Stagnant): Score 50 - 74 (needs proactive engagement).
+   - Red (At-Risk): Score < 50 (immediate retention trigger).
+3. Schedule daily cron job calculating health score across all active accounts.
+
+### Phase 2: Proactive Automated Intervention & Re-Engagement Triggers
+1. Trigger automated re-engagement playbook when an account drops into Red (< 50):
+   - Trigger 1: Send personalized "How can we help?" email from Customer Success Lead.
+   - Trigger 2: Display in-app banner offering 1-on-1 workflow optimization call.
+   - Trigger 3: Alert dedicated account executive in Slack/CRM if account ARR > $5,000.
+2. Provide curated feature recommendation guides matching the account's unutilized modules.
+
+### Phase 3: Cancellation Exit Flow & Salvage Offer Deflection Architecture
+1. Design multi-step cancellation flow in account billing settings:
+   - Step 1: Categorized exit survey (Cost, Missing Feature, Buggy/Hard to Use, Not Using Enough, Switching).
+   - Step 2: Dynamic salvage deflection offer matched to selected reason:
+     - Reason "Too Expensive" -> Offer 50% discount for next 3 billing cycles.
+     - Reason "Not using enough right now" -> Offer 1-click 60-day Subscription Pause.
+     - Reason "Missing Feature" -> Connect directly to Product Roadmap & Beta access.
+   - Step 3: Final confirmation with loss aversion reminder (e.g. "You will lose access to 14 active agent workflows").
+
+### Phase 4: Involuntary Churn & Smart Dunning Payment Retry Engine
+1. Listen for Stripe `invoice.payment_failed` webhook events.
+2. Trigger automated dunning sequence:
+   - Day 0: Soft decline email prompting credit card update + in-app billing grace period banner.
+   - Day 3: Smart retry attempt 1 via payment gateway.
+   - Day 5: Urgent payment failed notice + SMS / push notification.
+   - Day 7: Final retry attempt before account downgrade to free tier.
+3. Keep user workspace read-only during 14-day grace period to prevent data loss and encourage reactivation.
+
+### Phase 5: Post-Churn Exit Survey Analysis & Win-Back Cadence
+1. Log all completed cancellations with full survey metadata into analytics warehouse.
+2. Enroll cancelled accounts into automated 60-day win-back nurture sequence:
+   - Day 30: Product update newsletter featuring major newly shipped features.
+   - Day 60: Exclusive reactivation incentive offer ($100 credit on restart).
+3. Generate monthly churn cohort report at `reports/churn-prevention-playbook/churn-analysis.json`.
+4. Commit churn prevention engine to repository.
+   ```bash
+   git add src/services/retention/ docs/churn-prevention-playbook/
+   git commit -m "feat(churn-prevention-playbook): implement customer health score and retention automation"
+   ```
+
+## Code & Configuration Exemplars
+
+### Exemplar 1: TypeScript Customer Health Score & Risk Classifier
+```typescript
+export interface AccountTelemetry {
+  accountId: string;
+  daysSinceLastLogin: number;
+  monthlyWorkflowRuns: number;
+  seatsUsed: number;
+  seatsPurchased: number;
+  openNegativeTickets: number;
+}
+
+export function calculateCustomerHealthScore(telemetry: AccountTelemetry): { score: number; tier: 'green' | 'yellow' | 'red' } {
+  // Login factor (0-100)
+  const loginScore = Math.max(0, 100 - (telemetry.daysSinceLastLogin * 10));
+  // Usage factor (0-100)
+  const usageScore = Math.min(100, telemetry.monthlyWorkflowRuns * 5);
+  // Seat utilization factor (0-100)
+  const seatScore = telemetry.seatsPurchased > 0 ? (telemetry.seatsUsed / telemetry.seatsPurchased) * 100 : 50;
+  // Support sentiment penalty
+  const supportPenalty = telemetry.openNegativeTickets * 20;
+
+  const rawScore = (0.35 * usageScore) + (0.25 * loginScore) + (0.20 * seatScore) + 20 - supportPenalty;
+  const score = Math.max(0, Math.min(100, Math.round(rawScore)));
+
+  let tier: 'green' | 'yellow' | 'red' = 'green';
+  if (score < 50) tier = 'red';
+  else if (score < 75) tier = 'yellow';
+
+  return { score, tier };
+}
+```
+
+### Exemplar 2: Stripe Billing Webhook & Dunning Handler
+```typescript
+export interface StripeInvoiceEvent {
+  id: string;
+  customer: string;
+  attempt_count: number;
+  amount_due: number;
+}
+
+export async function handleInvoicePaymentFailed(event: StripeInvoiceEvent): Promise<string> {
+  const { customer, attempt_count, amount_due } = event;
+  console.log(`[Dunning] Payment failed for customer ${customer}, attempt #${attempt_count}, amount: $${amount_due / 100}`);
+
+  if (attempt_count === 1) {
+    // Dispatch immediate soft dunning notification
+    return 'dunning_soft_notification_sent';
+  } else if (attempt_count >= 4) {
+    // Final failure: transition account to grace period / read-only
+    return 'account_restricted_grace_period';
+  }
+  return 'retry_scheduled';
+}
+```
+
+## Edge Cases & Error Recovery Procedures
+
+### Scenario A: Repeated Dunning Retries Triggering Customer Bank Card Blocks
+1. **Diagnosis**: Firing payment retries too rapidly (e.g. multiple times in 24 hours) triggers bank fraud flags.
+2. **Recovery Protocol**:
+   - Step 1: Enforce exponential backoff retry schedule (Days 1, 3, 5, 8).
+   - Step 2: Check card decline codes (`insufficient_funds` vs `stolen_card` vs `expired_card`); do not retry stolen cards.
+   - Step 3: Prompt user for alternative payment method (PayPal, secondary card, ACH).
+
+### Scenario B: Cancellation Deflection Discount Exploited by Active Customers
+1. **Diagnosis**: Paying customers discover that visiting cancellation page awards automatic 50% discount.
+2. **Recovery Protocol**:
+   - Step 1: Limit discount salvage offers to accounts that have never received a discount in the prior 12 months.
+   - Step 2: Require a minimum 3-month account age before discount offers are unlocked in the cancellation modal.
+   - Step 3: Implement admin logging and threshold alerts if salvage claim rate exceeds 15% of cancellation attempts.
+
+## Verification & Validation Checklist
+- [ ] Frontmatter conforms strictly to `author: "agents-united"` and `version: "2.0.0"`.
+- [ ] All 7 mandatory sections present with explicit headers.
+- [ ] Step-by-Step Execution Runbook body contains >= 50 lines.
+- [ ] Customer Health Score formula and Red/Yellow/Green tier cutoffs defined.
+- [ ] Exit flow salvage deflection logic and smart dunning retry engine detailed.
+- [ ] Code exemplars provided with valid syntax fencing.
+- [ ] Zero dummy placeholder strings or unpopulated template markers present.
+- [ ] Project build, test suite, and doctor check pass 100% cleanly.

package/registry/skills/ci-cd-pipeline-automation/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: ci-cd-pipeline-automation
+description: Automates CI/CD delivery pipelines, GitHub Actions workflows,
+  container builds, and staging preview deployments.
+metadata:
+  author: Agents United Core Team
+  version: 1.0.0
+  source: https://github.com/NeoAnthropocene/agents-united
+  icon: 🚀
+disable-slash-command: true
+---
+
+# CI/CD Pipeline Automation Playbook
+
+## Overview & Purpose
+`ci-cd-pipeline-automation` guides AI agents in crafting, optimizing, and maintaining Continuous Integration and Continuous Delivery (CI/CD) pipelines across GitHub Actions, GitLab CI, and Docker container workflows.
+
+## Rules & Constraints
+1. **Never hardcode secrets** in workflow files; always use secrets management (`${{ secrets.GITHUB_TOKEN }}`).
+2. **Always pin container base images** to specific tags or SHA hashes rather than `latest`.
+3. **Use dependency caching** (`actions/setup-node` cache, Docker layer caching) to optimize build times.
+4. **Implement automated status checks** as pull request merge gates.
+
+## Step-by-Step Execution Runbook
+
+### Phase 1 — Workflow Scaffolding
+- Create `.github/workflows/ci.yml` for pull request linting, testing, and building.
+- Set up multi-runner job matrices for parallel execution.
+
+### Phase 2 — Container Build Optimization
+- Create multi-stage `Dockerfile` to separate build dependencies from minimal runtime images.
+- Validate build cache arguments.
+
+### Phase 3 — Staging & Release Verification
+- Configure deployment steps with rollback handling on non-zero exit codes.
+
+## Verification Checklist
+- [ ] Workflow YAML validated for correct syntax.
+- [ ] Secrets appropriately referenced.
+- [ ] Build & test status gates configured.

package/registry/skills/clickable-prototype-spec/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: clickable-prototype-spec
+description: Production-grade Clickable Prototype Spec playbook for design
+  operations, UX systems, and growth strategy.
+metadata:
+  author: agents-united
+  version: 2.0.0
+  icon: 🖱️
+disable-slash-command: true
+---
+
+# Clickable Prototype Spec
+
+## Overview & Purpose
+The Clickable Prototype Spec skill provides a deterministic framework for executing clickable prototype spec processes in modern software products.
+
+Following this skill ensures high usability, visual consistency, rapid iteration, and complete cross-functional team alignment.
+
+## Execution Triggers & Prerequisites
+### Execution Triggers
+- Direct request to execute Clickable Prototype Spec tasks.
+- Auditing existing product assets or workflows.
+- Standardizing clickable-prototype-spec procedures across team projects.
+- Preparing design handoffs or growth campaign launches.
+
+### Prerequisites
+- Project workspace configured with design system tokens or component libraries.
+- Target UI design specification or growth experiment hypothesis.
+- Testing and linting tools operational.
+- Clean git working directory.
+
+## Input & Output Requirements
+### Inputs
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `target_scope` | String | Yes | Target UI component, page, or campaign scope |
+| `config` | Object | Optional | Specific parameters and threshold configurations |
+| `output_dir` | Directory Path | Optional | Destination directory for generated artifacts |
+| `strict_mode` | Boolean | Optional | Enforce strict zero-warning validation |
+
+### Outputs
+| Artifact | Path / Format | Description |
+|---|---|---|
+| Specification Document | `docs/clickable-prototype-spec/spec.md` | Full specification and guidelines document |
+| Component / Asset Files | `src/clickable-prototype-spec/*` | Implemented design tokens, components, or campaign assets |
+| Audit Report | `reports/clickable-prototype-spec/summary.json` | Health check and audit metric results |
+
+## Step-by-Step Execution Runbook
+
+### Phase 1: Pre-Execution Discovery & Workspace Analysis
+1. Inspect workspace repository to locate relevant UI components, tokens, or campaign assets.
+   ```bash
+   find src/ docs/ -maxdepth 3 -type f
+   ```
+2. Analyze domain requirements and classify core UI elements, interaction flows, or growth metrics.
+3. Establish baseline quality metrics and target benchmarks.
+4. Verify working tree status to ensure clean git workspace.
+   ```bash
+   git status --short
+   ```
+5. Formulate initial execution plan.
+
+### Phase 2: Input Contract Validation & Strategy Selection
+1. Validate input parameters against technical feasibility and design system guidelines.
+2. Select implementation pattern matching component or campaign architecture.
+3. Establish verification rules and accessibility / conversion thresholds.
+4. Formulate atomic step-by-step execution sequence.
+5. Create temporary working directory if needed.
+
+### Phase 3: Core Step-by-Step Implementation Execution
+1. Author primary specification document at `docs/clickable-prototype-spec/spec.md`.
+2. Generate code, token, or layout implementation files.
+   ```bash
+   npm run typecheck
+   ```
+3. Apply automated formatting and linting tools.
+4. Execute unit or visual regression tests.
+   ```bash
+   npm test
+   ```
+5. Refactor asset structure for optimal performance and maintainability.
+
+### Phase 4: Verification, Testing & Quality Gate Checking
+1. Run full project verification suite.
+   ```bash
+   npm run typecheck && npm test && npm run build
+   ```
+2. Verify zero lint errors, type warnings, or broken references.
+3. Execute CLI health doctor check.
+   ```bash
+   node dist/cli.js doctor
+   ```
+4. Assert all acceptance criteria are satisfied.
+
+### Phase 5: Post-Execution Cleanup & Artifact Generation
+1. Generate execution summary report at `reports/clickable-prototype-spec/summary.md`.
+2. Clean up temporary build artifacts and scratch files.
+3. Commit generated files to git repository.
+   ```bash
+   git add docs/clickable-prototype-spec/ reports/clickable-prototype-spec/
+   git commit -m "feat(clickable-prototype-spec): implement Clickable Prototype Spec playbook artifacts"
+   ```
+4. Publish documentation for team review.
+
+## Code & Configuration Exemplars
+
+### Exemplar 1: Clickable Prototype Spec Configuration Specification
+```yaml
+version: "2.0.0"
+metadata:
+  skill: "clickable-prototype-spec"
+  author: "agents-united"
+rules:
+  strictValidation: true
+  reporting:
+    format: "json"
+    output: "reports/clickable-prototype-spec/summary.json"
+```
+
+### Exemplar 2: Clickable Prototype Spec Helper Module
+```typescript
+export function runClickablePrototypeSpec(scope: string): boolean {
+  console.log('Running Clickable Prototype Spec on:', scope);
+  return true;
+}
+```
+
+## Edge Cases & Error Recovery Procedures
+
+### Scenario A: Validation Failure in Clickable Prototype Spec
+1. **Diagnosis**: Specification or code asset fails validation rules in clickable-prototype-spec.
+2. **Recovery Protocol**:
+   - Step 1: Inspect error log at reports directory.
+   - Step 2: Correct non-compliant syntax or structure.
+   - Step 3: Re-run verification pipeline.
+
+### Scenario B: Missing Resource for Clickable Prototype Spec
+1. **Diagnosis**: Target design token or configuration asset missing from workspace.
+2. **Recovery Protocol**:
+   - Step 1: Generate baseline resource file from standard template.
+   - Step 2: Update configuration references.
+   - Step 3: Resume runbook execution.
+
+## Verification & Validation Checklist
+- [ ] Frontmatter conforms strictly to `author: "agents-united"` and `version: "2.0.0"`.
+- [ ] All 7 mandatory sections present with explicit headers.
+- [ ] Step-by-Step Execution Runbook body contains >= 50 lines.
+- [ ] Code exemplars provided with valid syntax fencing.
+- [ ] Zero dummy placeholder strings or unpopulated template markers present.
+- [ ] Project build, test suite, and doctor check pass 100% cleanly.

package/registry/skills/code-refactoring/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: code-refactoring
+description: Production-grade Code Refactoring playbook for safely modernizing
+  legacy codebases with zero regressions.
+metadata:
+  author: agents-united
+  version: 2.0.0
+  icon: ♻️
+disable-slash-command: true
+---
+
+# Systematic Code Refactoring & Tech Debt Remediation
+
+## Overview & Purpose
+The Systematic Code Refactoring & Tech Debt Remediation skill provides a deterministic, battle-tested framework for executing code-refactoring processes across the Agents United multi-agent ecosystem.
+
+Following this skill ensures high quality, zero-regression execution, rigorous testing gates, and seamless cross-functional team alignment.
+
+## Execution Triggers & Prerequisites
+### Execution Triggers
+- Direct request or workflow step invoking code-refactoring.
+- Auditing, implementing, or standardizing code-refactoring procedures.
+- Addressing technical debt, architectural reviews, or production readiness gates.
+- Preparing pull requests or automated release validations.
+
+### Prerequisites
+- Active project repository workspace with version control configured.
+- Operational testing, typechecking, and build toolchains.
+- Domain requirements, architectural constraints, or user stories defined.
+- Clean git working tree before beginning execution.
+
+## Input & Output Requirements
+### Inputs
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `target_scope` | String | Yes | Target module, service, component, or file path |
+| `config` | Object | Optional | Specific domain configurations, thresholds, and options |
+| `output_dir` | Directory Path | Optional | Destination directory for generated artifacts and reports |
+| `strict_mode` | Boolean | Optional | Enforce strict zero-warning validation and high test coverage |
+
+### Outputs
+| Artifact | Path / Format | Description |
+|---|---|---|
+| Specification Document | `docs/code-refactoring/spec.md` | Full technical specification and architectural plan |
+| Implementation Files | `src/code-refactoring/*` | Production-ready source code, tests, and configurations |
+| Execution Report | `reports/code-refactoring/summary.json` | Verification metrics, test results, and audit summary |
+
+## Step-by-Step Execution Runbook
+
+### Phase 1: Code Smell Detection & Dependency Mapping
+1. Identify refactoring targets using static analysis: Cyclomatic complexity > 15, file length > 500 lines.
+2. Classify code smells: God objects, shotgun surgery, deep nesting, duplicate logic, primitive obsession.
+3. Map caller graph and downstream consumer dependencies using AST analysis / grep.
+4. Verify existing automated test suite coverage on the target module before touching code.
+5. If coverage is < 80%, author characterization tests to capture current behavior first.
+
+### Phase 2: Refactoring Strategy & Safety Boundary Formulation
+1. Select appropriate Martin Fowler refactoring patterns: Extract Method, Replace Conditional with Polymorphism, Introduce Parameter Object.
+2. Establish the Strangler Fig pattern for large-scale module replacements.
+3. Define clear interface boundaries to encapsulate internal structural changes.
+4. Ensure all operations maintain immutability and eliminate global mutable state.
+5. Create dedicated refactoring branch in git.
+
+### Phase 3: Incremental Micro-Refactoring Execution
+1. Perform micro-transformations in tiny, atomic commits (one refactoring step per commit).
+2. Extract nested helper functions and replace magic strings/numbers with typed enums/constants.
+3. Migrate imperative loops to declarative, strongly-typed pipeline operations.
+4. Inject dependencies explicitly to eliminate hidden hardcoded singleton coupling.
+5. Run unit test suite immediately after each micro-refactor.
+
+### Phase 4: Regression Testing & Performance Benchmark Validation
+1. Run complete test suite (npm test) and typechecker (npm run typecheck).
+2. Run regression benchmark to verify memory allocation and CPU cycles have not degraded.
+3. Perform static linting to ensure no dead code or unreferenced imports remain.
+4. Inspect git diff to confirm only structural refactorings occurred with zero accidental logic shifts.
+5. Verify 100% test pass rate.
+
+### Phase 5: Code Review & Documentation Sync
+1. Document architectural improvements in pull request summary.
+2. Update internal JSDoc comments and module architecture diagrams.
+3. Squash intermediate commits into logical, readable conventional commits.
+4. Merge refactored branch to main.
+5. Monitor application telemetry for regression anomalies.
+
+## Code & Configuration Exemplars
+
+### Exemplar 1: Systematic Code Refactoring & Tech Debt Remediation Configuration & Specification
+```yaml
+// Before: Nested callback anti-pattern with mutation
+// After: Pure pipeline with immutable transformations
+export function processTransactions(txs: readonly Transaction[]): TransactionReport {
+  return txs
+    .filter(isValidTransaction)
+    .map(normalizeCurrency)
+    .reduce(aggregateTotals, initialReport);
+}
+```
+
+### Exemplar 2: Systematic Code Refactoring & Tech Debt Remediation TypeScript Type Contract
+```typescript
+export interface RefactorPlan {
+  targetModule: string;
+  codeSmell: 'long-method' | 'god-class' | 'feature-envy' | 'duplicate-logic' | 'primitive-obsession';
+  testCoverageBefore: number;
+  safetyChecklist: {
+    unitTestsPassing: boolean;
+    typesEnforced: boolean;
+    behaviorPreserved: boolean;
+  };
+}
+```
+
+## Edge Cases & Error Recovery Procedures
+
+### Scenario A: Validation Failure in Systematic Code Refactoring & Tech Debt Remediation
+1. **Diagnosis**: Static analysis, typechecking, or unit tests fail validation rules during execution.
+2. **Recovery Protocol**:
+   - Step 1: Inspect detailed error log output in test/build terminal.
+   - Step 2: Formulate targeted hypothesis and isolate failing line or assertion.
+   - Step 3: Implement surgical code fix and re-run verification suite.
+
+### Scenario B: Missing or Incompatible Dependency
+1. **Diagnosis**: Required toolchain binary or library dependency is missing from the environment.
+2. **Recovery Protocol**:
+   - Step 1: Verify `package.json` engine requirements and local environment versions.
+   - Step 2: Install required peer dependencies cleanly with lockfile sync.
+   - Step 3: Resume runbook from Phase 1.
+
+## Verification & Validation Checklist
+- [ ] Frontmatter conforms strictly to `author: "agents-united"` and `version: "2.0.0"`.
+- [ ] All 7 mandatory sections present with explicit headers.
+- [ ] Step-by-Step Execution Runbook body contains >= 50 lines.
+- [ ] Code exemplars provided with valid syntax fencing.
+- [ ] Zero dummy placeholder strings or unpopulated template markers present.
+- [ ] Project build, test suite, and doctor check pass 100% cleanly.

package/registry/skills/component-library-management/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: component-library-management
+description: Production-grade Component Library Management playbook for design
+  operations, UX systems, and growth strategy.
+metadata:
+  author: agents-united
+  version: 2.0.0
+  icon: 📚
+disable-slash-command: true
+---
+
+# Component Library Management
+
+## Overview & Purpose
+The Component Library Management skill provides a deterministic framework for executing component library management processes in modern software products.
+
+Following this skill ensures high usability, visual consistency, rapid iteration, and complete cross-functional team alignment.
+
+## Execution Triggers & Prerequisites
+### Execution Triggers
+- Direct request to execute Component Library Management tasks.
+- Auditing existing product assets or workflows.
+- Standardizing component-library-management procedures across team projects.
+- Preparing design handoffs or growth campaign launches.
+
+### Prerequisites
+- Project workspace configured with design system tokens or component libraries.
+- Target UI design specification or growth experiment hypothesis.
+- Testing and linting tools operational.
+- Clean git working directory.
+
+## Input & Output Requirements
+### Inputs
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `target_scope` | String | Yes | Target UI component, page, or campaign scope |
+| `config` | Object | Optional | Specific parameters and threshold configurations |
+| `output_dir` | Directory Path | Optional | Destination directory for generated artifacts |
+| `strict_mode` | Boolean | Optional | Enforce strict zero-warning validation |
+
+### Outputs
+| Artifact | Path / Format | Description |
+|---|---|---|
+| Specification Document | `docs/component-library-management/spec.md` | Full specification and guidelines document |
+| Component / Asset Files | `src/component-library-management/*` | Implemented design tokens, components, or campaign assets |
+| Audit Report | `reports/component-library-management/summary.json` | Health check and audit metric results |
+
+## Step-by-Step Execution Runbook
+
+### Phase 1: Pre-Execution Discovery & Workspace Analysis
+1. Inspect workspace repository to locate relevant UI components, tokens, or campaign assets.
+   ```bash
+   find src/ docs/ -maxdepth 3 -type f
+   ```
+2. Analyze domain requirements and classify core UI elements, interaction flows, or growth metrics.
+3. Establish baseline quality metrics and target benchmarks.
+4. Verify working tree status to ensure clean git workspace.
+   ```bash
+   git status --short
+   ```
+5. Formulate initial execution plan.
+
+### Phase 2: Input Contract Validation & Strategy Selection
+1. Validate input parameters against technical feasibility and design system guidelines.
+2. Select implementation pattern matching component or campaign architecture.
+3. Establish verification rules and accessibility / conversion thresholds.
+4. Formulate atomic step-by-step execution sequence.
+5. Create temporary working directory if needed.
+
+### Phase 3: Core Step-by-Step Implementation Execution
+1. Author primary specification document at `docs/component-library-management/spec.md`.
+2. Generate code, token, or layout implementation files.
+   ```bash
+   npm run typecheck
+   ```
+3. Apply automated formatting and linting tools.
+4. Execute unit or visual regression tests.
+   ```bash
+   npm test
+   ```
+5. Refactor asset structure for optimal performance and maintainability.
+
+### Phase 4: Verification, Testing & Quality Gate Checking
+1. Run full project verification suite.
+   ```bash
+   npm run typecheck && npm test && npm run build
+   ```
+2. Verify zero lint errors, type warnings, or broken references.
+3. Execute CLI health doctor check.
+   ```bash
+   node dist/cli.js doctor
+   ```
+4. Assert all acceptance criteria are satisfied.
+
+### Phase 5: Post-Execution Cleanup & Artifact Generation
+1. Generate execution summary report at `reports/component-library-management/summary.md`.
+2. Clean up temporary build artifacts and scratch files.
+3. Commit generated files to git repository.
+   ```bash
+   git add docs/component-library-management/ reports/component-library-management/
+   git commit -m "feat(component-library-management): implement Component Library Management playbook artifacts"
+   ```
+4. Publish documentation for team review.
+
+## Code & Configuration Exemplars
+
+### Exemplar 1: Component Library Management Configuration Specification
+```yaml
+version: "2.0.0"
+metadata:
+  skill: "component-library-management"
+  author: "agents-united"
+rules:
+  strictValidation: true
+  reporting:
+    format: "json"
+    output: "reports/component-library-management/summary.json"
+```
+
+### Exemplar 2: Component Library Management Helper Module
+```typescript
+export function runComponentLibraryManagement(scope: string): boolean {
+  console.log('Running Component Library Management on:', scope);
+  return true;
+}
+```
+
+## Edge Cases & Error Recovery Procedures
+
+### Scenario A: Validation Failure in Component Library Management
+1. **Diagnosis**: Specification or code asset fails validation rules in component-library-management.
+2. **Recovery Protocol**:
+   - Step 1: Inspect error log at reports directory.
+   - Step 2: Correct non-compliant syntax or structure.
+   - Step 3: Re-run verification pipeline.
+
+### Scenario B: Missing Resource for Component Library Management
+1. **Diagnosis**: Target design token or configuration asset missing from workspace.
+2. **Recovery Protocol**:
+   - Step 1: Generate baseline resource file from standard template.
+   - Step 2: Update configuration references.
+   - Step 3: Resume runbook execution.
+
+## Verification & Validation Checklist
+- [ ] Frontmatter conforms strictly to `author: "agents-united"` and `version: "2.0.0"`.
+- [ ] All 7 mandatory sections present with explicit headers.
+- [ ] Step-by-Step Execution Runbook body contains >= 50 lines.
+- [ ] Code exemplars provided with valid syntax fencing.
+- [ ] Zero dummy placeholder strings or unpopulated template markers present.
+- [ ] Project build, test suite, and doctor check pass 100% cleanly.