agents-united 0.5.0

package/registry/skills/handoff/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: handoff
+description: Capture session progress, active context, decision logs, and
+  remaining tasks to pass context seamlessly between subagents or future
+  sessions.
+metadata:
+  author: Matt Pocock (mattpocock/skills)
+  version: 1.0.0
+  source: https://github.com/mattpocock/skills
+  icon: 🤝
+---
+
+# Session Handoff & Context Persistence
+
+## Overview & Purpose
+`handoff` creates structured context handoff notes at the end of an agent session or before delegating tasks to subagents. This preserves context momentum and prevents redundant discovery work.
+
+## Input & Output Requirements
+### Inputs
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `summary` | String | Yes | Brief description of completed work and current state |
+
+### Outputs
+| Artifact | Path / Format | Description |
+|---|---|---|
+| Handoff Document | `docs/handoff/HANDOFF-<date>.md` | Persistent session summary and open task list |
+
+## Step-by-Step Execution Runbook
+
+### Phase 1 — State Capture
+1. Summarize key achievements and completed PRs/commits in this session.
+2. List modified files and current git branch.
+
+### Phase 2 — Remaining Work & Blockers
+1. Highlight open tasks, failing tests, or unmerged branches.
+2. Document explicit next steps for the incoming agent.
+
+### Phase 3 — Persistence
+1. Save handoff notes to `docs/handoff/` or output directly in session response.
+
+## Verification & Validation Checklist
+- [ ] Frontmatter contains author attribution to Matt Pocock.
+- [ ] Handoff summary includes completed items, open items, and next steps.

package/registry/skills/hf-model-evaluation/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: hf-model-evaluation
+description: Automated evaluation, benchmarking, dataset curation, and
+  leaderboard metric verification using the Hugging Face ecosystem (Evaluate,
+  Datasets, Transformers).
+metadata:
+  author: Hugging Face / agents-united
+  version: 2.0.0
+  license: MIT
+  icon: 🤗
+disable-slash-command: true
+---
+
+# Hugging Face Model Evaluation Playbook
+
+## Overview & Purpose
+`hf-model-evaluation` provides standardized benchmarking workflows for assessing LLM and embedding model performance on standardized evaluation benchmarks using Hugging Face datasets and evaluation harnesses.
+
+## When to Trigger
+Trigger this skill whenever:
+- Running deterministic evaluation benchmarks (MMLU, GSM8k, HumanEval, ARC, Hellaswag).
+- Measuring LLM answer faithfulness, context recall, and toxicity scoring with automated harnesses.
+- Curating golden evaluation splits and synthetic test datasets with Hugging Face Datasets.
+- Generating comprehensive model cards and leaderboard performance summaries.
+
+## Input & Output Requirements
+- **Inputs**: Target model weights/repo ID, evaluation dataset split names, benchmark task configuration YAML, and random seeds.
+- **Outputs**: Automated metric reports (accuracy, exact match, F1, ROUGE, BERTScore), latency benchmarks, and Hugging Face model cards.
+
+## Step-by-Step Execution Runbook
+
+### Phase 1 — Benchmark Task & Dataset Configuration
+- Load standardized benchmark datasets via `datasets.load_dataset()`.
+- Define few-shot prompt formatting templates and deterministic parameters (temperature=0, top_p=1.0).
+
+### Phase 2 — Evaluation Harness Execution
+- Run batch evaluation using `lm-evaluation-harness` or `ragas` library.
+- Log token generation latency, GPU memory footprint, and exact match outputs.
+
+### Phase 3 — Metric Aggregation & Error Analysis
+- Aggregate scores across dataset domains and identify failure clusters.
+- Compute confidence intervals and statistical significance deltas against baseline models.
+
+### Phase 4 — Model Card Publishing
+- Document evaluation methodology, carbon footprint, model limitations, and benchmark results in a README model card.
+
+## Edge Cases & Boundary Conditions
+- **Data Contamination**: Audit evaluation test splits against training datasets to ensure no memorization or test set leakage.
+- **Non-Deterministic Outputs**: Fix random seeds in PyTorch, CUDA, and Hugging Face pipelines (`transformers.set_seed(42)`).
+- **Prompt Sensitivity Variations**: Evaluate across 3 distinct prompt variations to measure prompt robustness.
+
+## Error Recovery & Fallbacks
+- If GPU VRAM is exceeded during evaluation, reduce batch size or enable 8-bit model loading (`load_in_8bit=True`).
+- If dataset download fails from Hugging Face Hub, use cached local disk splits.
+
+## Code Exemplars & Patterns
+
+```python
+import evaluate
+from datasets import load_dataset
+from transformers import pipeline, set_seed
+
+set_seed(42)
+
+# 1. Load evaluation metric and dataset
+exact_match_metric = evaluate.load("exact_match")
+eval_dataset = load_dataset("trivia_qa", "rc.nocontext", split="validation[:100]")
+
+# 2. Initialize generation pipeline
+generator = pipeline("text-generation", model="meta-llama/Llama-3.1-8B-Instruct", device_map="auto")
+
+predictions = []
+references = []
+
+for item in eval_dataset:
+    prompt = f"Answer concisely: {item['question']}\nAnswer:"
+    res = generator(prompt, max_new_tokens=32, temperature=0.0)
+    pred_text = res[0]['generated_text'].replace(prompt, '').strip()
+    predictions.append(pred_text)
+    references.append(item['answer']['value'])
+
+results = exact_match_metric.compute(predictions=predictions, references=references)
+print(f"Exact Match Accuracy: {results['exact_match']:.2%}")
+```

package/registry/skills/interaction-pattern-library/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: interaction-pattern-library
+description: Production-grade Interaction Pattern Library playbook for design
+  operations, UX systems, and growth strategy.
+metadata:
+  author: agents-united
+  version: 2.0.0
+  icon: ✨
+disable-slash-command: true
+---
+
+# Interaction Pattern Library
+
+## Overview & Purpose
+The Interaction Pattern Library skill provides a deterministic framework for executing interaction pattern library 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 Interaction Pattern Library tasks.
+- Auditing existing product assets or workflows.
+- Standardizing interaction-pattern-library 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/interaction-pattern-library/spec.md` | Full specification and guidelines document |
+| Component / Asset Files | `src/interaction-pattern-library/*` | Implemented design tokens, components, or campaign assets |
+| Audit Report | `reports/interaction-pattern-library/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/interaction-pattern-library/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/interaction-pattern-library/summary.md`.
+2. Clean up temporary build artifacts and scratch files.
+3. Commit generated files to git repository.
+   ```bash
+   git add docs/interaction-pattern-library/ reports/interaction-pattern-library/
+   git commit -m "feat(interaction-pattern-library): implement Interaction Pattern Library playbook artifacts"
+   ```
+4. Publish documentation for team review.
+
+## Code & Configuration Exemplars
+
+### Exemplar 1: Interaction Pattern Library Configuration Specification
+```yaml
+version: "2.0.0"
+metadata:
+  skill: "interaction-pattern-library"
+  author: "agents-united"
+rules:
+  strictValidation: true
+  reporting:
+    format: "json"
+    output: "reports/interaction-pattern-library/summary.json"
+```
+
+### Exemplar 2: Interaction Pattern Library Helper Module
+```typescript
+export function runInteractionPatternLibrary(scope: string): boolean {
+  console.log('Running Interaction Pattern Library on:', scope);
+  return true;
+}
+```
+
+## Edge Cases & Error Recovery Procedures
+
+### Scenario A: Validation Failure in Interaction Pattern Library
+1. **Diagnosis**: Specification or code asset fails validation rules in interaction-pattern-library.
+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 Interaction Pattern Library
+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/interactive-prototype-builder/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: interactive-prototype-builder
+description: Production-grade Interactive Prototype Builder playbook with live
+  URL preview cards, Storybook/Vite sandboxes, and visual side-by-side diffing.
+metadata:
+  author: agents-united
+  version: 2.0.0
+  icon: 🛠️
+disable-slash-command: true
+---
+
+# Interactive Prototype Builder
+
+## Overview & Purpose
+The Interactive Prototype Builder skill provides a deterministic framework for constructing, previewing, and verifying high-fidelity interactive UI prototypes with live browser preview cards, state-driven interaction models, and visual side-by-side diffing.
+
+Following this skill ensures high usability, visual consistency, rapid iteration, and complete cross-functional team alignment.
+
+## Execution Triggers & Prerequisites
+### Execution Triggers
+- Direct request to build or refine interactive UI prototypes.
+- Creating clickable mockups or Storybook sandboxes for stakeholder review.
+- Standardizing interactive prototype workflows across design and engineering teams.
+- Preparing design handoffs with live in-app preview cards.
+
+### Prerequisites
+- Project workspace configured with design system tokens or component libraries.
+- Target UI design specification or wireframe spec.
+- Testing, linting, and bundler/dev server tools operational.
+- Clean git working directory.
+
+## Input & Output Requirements
+### Inputs
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `target_scope` | String | Yes | Target UI component, page, or interaction 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/interactive-prototype-builder/spec.md` | Full specification and guidelines document |
+| Component / Asset Files | `src/components/*` | Implemented design tokens, components, or interactive assets |
+| Live Preview URL Card | Markdown Block | In-app live preview link (`http://localhost:6006` or `http://localhost:5173`) |
+| Visual Diff Report | `reports/interactive-prototype-builder/visual-diff.md` | Side-by-side visual diffs and region selection analysis |
+
+## 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, and reactive state transitions.
+3. Establish baseline quality metrics, accessibility standards (WCAG 2.2 AA), and responsiveness targets.
+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 architecture (e.g. Radix UI primitives, Tailwind styling, Framer Motion transitions).
+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 Implementation & Live Preview Execution
+1. Author primary specification document at `docs/interactive-prototype-builder/spec.md`.
+2. Generate code, token, SVG, or interactive React/HTML component files.
+3. Launch local development or Storybook server in background task (`manage_task`):
+   ```bash
+   npm run storybook -- --ci --port 6006
+   ```
+4. Emit Live Preview URL Card for Desktop preview pane:
+   ```markdown
+   > [!TIP]
+   > **Interactive Component Preview**: [Open Storybook Live Canvas](http://localhost:6006)
+   ```
+5. Apply automated formatting and linting tools.
+6. Execute visual regression tests and capture side-by-side SVG/image diffs.
+
+### Phase 4: Verification, Visual Diffing & Quality Gate Checking
+1. Perform side-by-side visual diff comparisons between baseline and generated component states.
+2. Ingest region-selection feedback (bounding box coordinates and cropped image previews) to iteratively refine UI layout.
+3. Run full project verification suite:
+   ```bash
+   npm run typecheck && npm test && npm run build
+   ```
+4. Verify zero accessibility violations (WCAG 2.2 AA) and zero broken layout references.
+5. Execute CLI health doctor check.
+   ```bash
+   node dist/cli.js doctor
+   ```
+
+### Phase 5: Post-Execution Cleanup & Artifact Generation
+1. Generate execution summary report at `reports/interactive-prototype-builder/summary.md`.
+2. Clean up temporary build artifacts and scratch files.
+3. Commit generated files to git repository.
+   ```bash
+   git add docs/interactive-prototype-builder/ reports/interactive-prototype-builder/
+   git commit -m "feat(interactive-prototype-builder): implement Interactive Prototype Builder playbook artifacts"
+   ```
+4. Publish documentation for team review.
+
+## Code & Configuration Exemplars
+
+### Exemplar 1: Interactive Prototype Builder Configuration Specification
+```yaml
+version: "2.0.0"
+metadata:
+  skill: "interactive-prototype-builder"
+  author: "agents-united"
+rules:
+  strictValidation: true
+  livePreview:
+    port: 6006
+    urlPattern: "http://localhost:6006"
+  reporting:
+    format: "json"
+    output: "reports/interactive-prototype-builder/summary.json"
+```
+
+### Exemplar 2: Interactive Prototype Builder Helper Module
+```typescript
+export function runInteractivePrototypeBuilder(scope: string): boolean {
+  console.log('Running Interactive Prototype Builder on:', scope);
+  return true;
+}
+```
+
+## Edge Cases & Error Recovery Procedures
+
+### Scenario A: Port Collision on Live Preview Server
+1. **Diagnosis**: Storybook/Vite server fails to bind to target port (e.g. 6006 already in use).
+2. **Recovery Protocol**:
+   - Step 1: Detect collision and allocate next ephemeral port (`6007`+).
+   - Step 2: Update Live Preview URL Card link in the orchestration report.
+   - Step 3: Verify preview health endpoint responds with HTTP 200.
+
+### Scenario B: Visual Regression Diff Exceeds Threshold
+1. **Diagnosis**: Generated component rendering differs from baseline beyond allowable pixel delta (>0.5%).
+2. **Recovery Protocol**:
+   - Step 1: Inspect region-selection bounding box coordinates in the visual diff artifact.
+   - Step 2: Adjust CSS layout tokens, typography, or padding to match design spec.
+   - Step 3: Re-capture snapshot and assert zero visual regression.
+
+## 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.
+- [ ] Live preview URL card format and visual diffing steps documented.
+- [ ] Project build, test suite, and doctor check pass 100% cleanly.

package/registry/skills/local-llm-inference/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: local-llm-inference
+description: Local and on-premise LLM inference with Ollama, vLLM, GGUF
+  quantizations, PagedAttention, and OpenAI-compatible API servers.
+metadata:
+  author: Ollama & vLLM Community / agents-united
+  version: 2.0.0
+  license: MIT
+  icon: 🦙
+disable-slash-command: true
+---
+
+# Local LLM Inference Playbook
+
+## Overview & Purpose
+`local-llm-inference` provides configuration and optimization guidelines for running open-source LLMs locally (Ollama) or in high-concurrency production environments (vLLM).
+
+## When to Trigger
+Trigger this skill whenever:
+- Setting up local development workflows with privacy-preserving offline LLMs.
+- Configuring Ollama CLI, custom Modelfile templates, and parameters.
+- Deploying high-throughput vLLM inference servers with PagedAttention and continuous batching.
+- Selecting model quantizations (GGUF, AWQ, GPTQ) for hardware memory limits.
+
+## Input & Output Requirements
+- **Inputs**: Model name or GGUF file path, hardware specifications (CPU, Apple Silicon RAM, NVIDIA VRAM), and inference API port.
+- **Outputs**: Running local inference daemon, OpenAI-compatible REST endpoints (`/v1/chat/completions`), and benchmark metrics.
+
+## Step-by-Step Execution Runbook
+
+### Phase 1 — Environment Reconnaissance & Model Selection
+- Assess available RAM/VRAM to choose appropriate quantization (4-bit vs 8-bit).
+- Pull model weights via Ollama CLI or download Hugging Face safetensors for vLLM.
+
+### Phase 2 — Server Launch & Optimization
+- Launch Ollama server or start vLLM daemon with tuned `--gpu-memory-utilization` and `--max-model-len`.
+- Verify GPU offloading layers and memory allocation.
+
+### Phase 3 — Verification & Client Connection
+- Test local endpoint with curl or OpenAI SDK pointing to `http://localhost:11434/v1` or `http://localhost:8000/v1`.
+- Measure Time-to-First-Token (TTFT) and sustained generation throughput.
+
+## Edge Cases & Boundary Conditions
+- **System Memory Pressure**: If total model weights exceed VRAM, configure Ollama partial CPU offloading or reduce context length.
+- **High Concurrency Latency Spikes**: Enable continuous batching and tensor parallelism across multiple GPUs in vLLM.
+- **Prompt Format Mismatches**: Ensure chat templates match exact model tokenizers (e.g. ChatML, Llama-3 headers).
+
+## Error Recovery & Fallbacks
+- If vLLM crashes with CUDA OOM, restart daemon with lower `--gpu-memory-utilization 0.80` and `--max-num-seqs 64`.
+- If Ollama service fails to respond, restart daemon and verify model file integrity with `ollama list`.
+
+## Code Exemplars & Patterns
+
+```bash
+# Start vLLM OpenAI-compatible server with PagedAttention and AWQ quantization
+python3 -m vllm.entrypoints.openai.api_server \
+  --model casperhansen/llama-3-8b-instruct-awq \
+  --quantization awq \
+  --dtype float16 \
+  --gpu-memory-utilization 0.90 \
+  --max-model-len 8192 \
+  --port 8000
+```
+
+```python
+from openai import OpenAI
+
+# Connect standard OpenAI client to local vLLM / Ollama instance
+client = OpenAI(base_url="http://localhost:8000/v1", api_key="local-token")
+
+response = client.chat.completions.create(
+    model="casperhansen/llama-3-8b-instruct-awq",
+    messages=[{"role": "user", "content": "Explain vector indexing in 2 sentences."}],
+    temperature=0.7,
+)
+print(response.choices[0].message.content)
+```

package/registry/skills/maestro-mobile-testing/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: maestro-mobile-testing
+description: Declarative mobile UI testing with Maestro, automated mobile
+  regression flows, deep linking, and cross-platform verification.
+metadata:
+  author: tovimx (tovimx/maestro-mobile-testing-skill)
+  version: 1.0.0
+  source: https://skills.sh/tovimx/maestro-mobile-testing-skill/maestro-mobile-testing
+  icon: 🧪
+disable-slash-command: true
+---
+
+# Maestro Mobile E2E Testing Playbook
+
+## Overview & Purpose
+`maestro-mobile-testing` provides instructions and patterns for authoring declarative, readable mobile UI test flows for iOS and Android using Maestro.
+
+## Rules & Constraints
+1. **Use Text and Accessibility Identifiers** — Prefer `tapOn: "Button Text"` or `tapOn: { id: "button_id" }` over brittle coordinates.
+2. **Avoid Hardcoded Sleeps** — Rely on Maestro's built-in auto-waiting for elements to render.
+3. **Isolate Test Flows** — Use `launchApp: { clearState: true }` to guarantee independent test preconditions.
+4. **Assert Visible Text and State** — Verify expected screen content with `assertVisible: "Welcome Screen"`.
+
+## Step-by-Step Execution Runbook
+
+### Phase 1 — Test Flow Definition
+- Create `.maestro/` directory containing YAML test flow files (e.g. `auth_flow.yaml`, `checkout_flow.yaml`).
+- Define appId and target environment configurations.
+
+### Phase 2 — Flow Execution & Actions
+- Author steps: `tapOn`, `inputText`, `scroll`, `back`, `assertVisible`.
+- Add conditional checks (`runFlow: { when: { visible: "Modal" } }`).
+
+### Phase 3 — Verification
+- Run tests on iOS Simulator and Android Emulator via `maestro test .maestro/`.
+
+## Verification Checklist
+- [ ] Test flows execute deterministically on both iOS and Android.
+- [ ] No brittle coordinate-based taps.
+- [ ] Clear error logs and screenshots captured on assertion failure.