xtrm-tools 0.5.0

package/skills/creating-service-skills/scripts/scaffolder.py

@@ -0,0 +1,482 @@
+#!/usr/bin/env python3
+"""
+Scaffolder for creating-service-skills.
+
+Phase 1 of the two-phase workflow: generates a structural skeleton for a new
+service skill by parsing docker-compose.yml, Dockerfiles, and dependency files.
+The skeleton contains [PENDING RESEARCH] markers for the agent to fill in Phase 2.
+
+Output location: .claude/skills/<service-id>/
+"""
+
+import sys
+from pathlib import Path
+
+# Resolve bootstrap from this script's directory
+script_dir = Path(__file__).parent
+sys.path.insert(0, str(script_dir))
+
+from bootstrap import RootResolutionError, get_project_root, register_service  # noqa: E402
+
+# ---------------------------------------------------------------------------
+# Official documentation map — populated from detected technologies
+# ---------------------------------------------------------------------------
+OFFICIAL_DOCS: dict[str, tuple[str, str]] = {
+    # Docker images / databases
+    "postgres": ("PostgreSQL", "https://www.postgresql.org/docs/"),
+    "timescale": ("TimescaleDB", "https://docs.timescale.com/"),
+    "timescaledb": ("TimescaleDB", "https://docs.timescale.com/"),
+    "redis": ("Redis", "https://redis.io/docs/"),
+    "mysql": ("MySQL", "https://dev.mysql.com/doc/"),
+    "mongodb": ("MongoDB", "https://www.mongodb.com/docs/"),
+    "mongo": ("MongoDB", "https://www.mongodb.com/docs/"),
+    "elasticsearch": ("Elasticsearch", "https://www.elastic.co/guide/"),
+    "rabbitmq": ("RabbitMQ", "https://www.rabbitmq.com/documentation.html"),
+    "kafka": ("Apache Kafka", "https://kafka.apache.org/documentation/"),
+    "clickhouse": ("ClickHouse", "https://clickhouse.com/docs/"),
+    # Python packages
+    "fastapi": ("FastAPI", "https://fastapi.tiangolo.com/"),
+    "flask": ("Flask", "https://flask.palletsprojects.com/"),
+    "django": ("Django", "https://docs.djangoproject.com/"),
+    "sqlalchemy": ("SQLAlchemy", "https://docs.sqlalchemy.org/"),
+    "alembic": ("Alembic", "https://alembic.sqlalchemy.org/en/latest/"),
+    "prisma": ("Prisma", "https://www.prisma.io/docs/"),
+    "celery": ("Celery", "https://docs.celeryq.dev/"),
+    "pydantic": ("Pydantic", "https://docs.pydantic.dev/"),
+    "asyncpg": ("asyncpg", "https://magicstack.github.io/asyncpg/"),
+    "psycopg2": ("psycopg2", "https://www.psycopg.org/docs/"),
+    "psycopg": ("psycopg3", "https://www.psycopg.org/psycopg3/docs/"),
+    "aiohttp": ("aiohttp", "https://docs.aiohttp.org/"),
+    "httpx": ("HTTPX", "https://www.python-httpx.org/"),
+}
+
+
+def scaffold_service_skill(service_id: str, compose_data: dict) -> Path:
+    """
+    Main entry point for Phase 1 scaffolding.
+    """
+    try:
+        project_root = get_project_root()
+    except RootResolutionError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    skill_dir = Path(project_root) / ".claude" / "skills" / service_id
+    if skill_dir.exists():
+        print(f"Skill directory already exists: {skill_dir}")
+        print("Aborting to prevent overwriting. Delete it manually if you want to re-scaffold.")
+        sys.exit(1)
+
+    print(f"Scaffolding new service skill: {service_id}")
+    print(f"Target directory: {skill_dir}")
+
+    skill_dir.mkdir(parents=True)
+    (skill_dir / "scripts").mkdir()
+    (skill_dir / "references").mkdir()
+    (skill_dir / "assets").mkdir()
+
+    # Detect service details from compose
+    service_config = compose_data.get("services", {}).get(service_id, {})
+
+    # 1. Generate SKILL.md
+    write_skill_md(service_id, service_config, skill_dir)
+
+    # 2. Generate script stubs
+    write_script_stubs(service_id, skill_dir)
+
+    # 3. Generate reference stubs
+    write_reference_stubs(service_id, skill_dir)
+
+    # 4. Register service in bootstrap state
+    # [TODO] Fill in territory and name properly
+    register_service(
+        service_id, service_id, [], str((skill_dir / "SKILL.md").relative_to(project_root))
+    )
+
+    print(f"\n✅ Phase 1 Complete for {service_id}")
+    print("Next step: Run Phase 2 deep dive for this service.")
+    return skill_dir
+
+
+def write_skill_md(service_id: str, config: dict, skill_dir: Path) -> None:
+    """Generate the root SKILL.md file."""
+    name = service_id.replace("-", " ").replace("_", " ").title()
+    persona = f"{name} Expert"
+
+    # Detect docs to link
+    docs_section = ""
+    # [PENDING] Implement documentation auto-detection logic here
+
+    content = f"""---
+name: {service_id}
+description: >-
+  [PENDING RESEARCH] Specialized knowledge for the {name} service.
+  Use when debugging, analyzing performance, or understanding this service.
+allowed-tools: Bash(python3 *), Read, Grep, Glob
+---
+
+# {name}
+
+## Service Overview
+
+[PENDING RESEARCH] Describe what this service does, its role in the system,
+and whether it runs continuously, as a one-shot job, or on a schedule.
+
+**Persona**: {persona}
+
+## Architecture
+
+[PENDING RESEARCH]
+
+**Entry Point**: [Verify in Dockerfile CMD and docker-compose `command:` field]
+**Container Name**: {service_id}
+**Restart Policy**: [PENDING RESEARCH]
+
+**Primary Modules**:
+- [PENDING RESEARCH] List key modules after reading the source tree
+
+**Dependencies**: [PENDING RESEARCH] PostgreSQL? Redis? External APIs?
+
+## ⚠️ CRITICAL REQUIREMENTS
+
+[PENDING RESEARCH] Add any mandatory patterns, initialization calls, or
+invariants that must not be violated when modifying this service.
+
+## Data Flows
+
+[PENDING RESEARCH] Trace the primary data paths through the service.
+
+## Database Interactions
+
+[PENDING RESEARCH]
+
+| Table | Operation | Timestamp Column | Stale Threshold |
+|-------|-----------|-----------------|-----------------|
+| [table] | INSERT/SELECT | [col] | [N min] |
+
+## Common Operations
+
+### Service Management
+
+```bash
+# Start the service
+docker compose up -d {service_id}
+
+# Check logs
+docker logs {service_id} --tail 50
+
+# Restart
+docker compose restart {service_id}
+```
+
+### Data Inspection
+
+- **Health check**: `python3 .claude/skills/{service_id}/scripts/health_probe.py`
+- **Log analysis**: `python3 .claude/skills/{service_id}/scripts/log_hunter.py`
+- **Data explorer**: `python3 .claude/skills/{service_id}/scripts/data_explorer.py`
+
+## Troubleshooting Guide
+
+[PENDING RESEARCH] Fill from exception handlers and code comments.
+
+| Symptom | Likely Cause | Resolution |
+|---------|-------------|------------|
+| [what you see] | [root cause] | [exact command to fix] |
+
+Minimum 5 rows required.
+
+<!-- SEMANTIC_START -->
+## Semantic Deep Dive (Human/Agent Refined)
+
+[PENDING RESEARCH] Add deep operational knowledge after Phase 2 deep dive.
+
+<!-- SEMANTIC_END -->
+
+## Scripts
+
+- `scripts/health_probe.py` — Container status + table freshness check
+- `scripts/log_hunter.py` — Service-specific log pattern analysis
+- `scripts/data_explorer.py` — Safe database inspection (read-only)
+
+## References
+{docs_section}
+- `references/deep_dive.md` — Detailed Phase 2 research notes
+- `references/architecture_ssot.md` — Architecture SSOT (link from project SSOT if available)
+
+---
+
+*Generated by creating-service-skills Phase 1. Run Phase 2 to fill [PENDING RESEARCH] markers.*
+"""  # nosec B608
+    (skill_dir / "SKILL.md").write_text(content, encoding="utf-8")
+
+
+def write_script_stubs(service_id: str, skill_dir: Path) -> None:
+    """
+    Write Phase 1 script stubs into the skill's scripts/ directory.
+    """
+    scripts_dir = skill_dir / "scripts"
+    scripts_dir.mkdir(parents=True, exist_ok=True)
+
+    # health_probe.py stub (using replace to avoid f-string escaping hell)
+    health_probe_tpl = '''#!/usr/bin/env python3
+"""Health probe for {{SERVICE_ID}}.
+
+[PENDING RESEARCH] Replace all [FILL] markers during Phase 2 deep dive.
+"""
+import json
+import subprocess
+import sys
+
+CONTAINER = "{{SERVICE_ID}}"
+# [PENDING RESEARCH] Set the actual external-mapped DB port (e.g. 5433 for host, 5432 for container)
+DB_PORT = 5433
+# [PENDING RESEARCH] Set the actual output table(s) and stale thresholds in minutes
+STALE_CHECKS: list[dict] = [
+    # {"table": "table_name", "ts_col": "created_at", "stale_minutes": 10},
+]
+
+
+def check_container() -> bool:
+    result = subprocess.run(
+        ["docker", "inspect", "-f", "{{.State.Running}}", CONTAINER],
+        capture_output=True, text=True
+    )
+    running = result.stdout.strip() == "true"
+    print(f"Container {CONTAINER}: {'RUNNING' if running else 'STOPPED'}")
+    return running
+
+
+def check_table_freshness() -> bool:
+    """[PENDING RESEARCH] Query actual output tables with correct stale thresholds."""
+    if not STALE_CHECKS:
+        print("Table freshness: NOT CONFIGURED (Phase 2 required)")
+        return True
+    # [PENDING RESEARCH] Implement actual DB checks here
+    return True
+
+
+def main(as_json: bool = False) -> None:
+    ok = check_container()
+    ok &= check_table_freshness()
+    if as_json:
+        print(json.dumps({"healthy": ok, "service": CONTAINER}))
+    else:
+        print(f"\\nOverall: {'HEALTHY' if ok else 'UNHEALTHY'}")
+    sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    import argparse
+    p = argparse.ArgumentParser()
+    p.add_argument("--json", action="store_true")
+    args = p.parse_args()
+    main(as_json=args.json)
+'''
+    (scripts_dir / "health_probe.py").write_text(
+        health_probe_tpl.replace("{{SERVICE_ID}}", service_id), encoding="utf-8"
+    )
+
+    # log_hunter.py stub
+    log_hunter_tpl = '''#!/usr/bin/env python3
+"""Log hunter for {{SERVICE_ID}}.
+
+[PENDING RESEARCH] Replace generic patterns with actual error strings
+found in the codebase exception handlers during Phase 2 deep dive.
+"""
+import json
+import re
+import subprocess
+import sys
+from collections import defaultdict
+
+CONTAINER = "{{SERVICE_ID}}"
+
+# [PENDING RESEARCH] Replace with patterns sourced from the actual codebase.
+# Find them with: search_for_pattern("logger.error|raise|panic!")
+PATTERNS: list[tuple[str, str, str]] = [
+    ("ConnectionError", "ERROR", "Database or Redis connectivity issue"),
+    ("TimeoutError", "WARNING", "External service latency detected"),
+]
+
+
+def hunt_logs(tail: int = 200) -> dict:
+    """Tails logs and matches against patterns."""
+    result = subprocess.run(
+        ["docker", "logs", "--tail", str(tail), CONTAINER],
+        capture_output=True, text=True
+    )
+    logs = result.stdout + result.stderr
+    matches = defaultdict(int)
+
+    for line in logs.splitlines():
+        for pattern, level, desc in PATTERNS:
+            if pattern in line:
+                matches[pattern] += 1
+
+    return dict(matches)
+
+
+def main() -> None:
+    results = hunt_logs()
+    print(f"Log anomalies for {CONTAINER}:")
+    if not results:
+        print("  ✓ No known error patterns detected in recent logs.")
+    else:
+        for p, count in results.items():
+            print(f"  - {p}: {count} occurrences")
+
+
+if __name__ == "__main__":
+    main()
+'''
+    (scripts_dir / "log_hunter.py").write_text(
+        log_hunter_tpl.replace("{{SERVICE_ID}}", service_id), encoding="utf-8"
+    )
+
+    # data_explorer.py stub
+    data_explorer_tpl = '''#!/usr/bin/env python3
+"""Data explorer for {{SERVICE_ID}} — read-only DB inspection.
+
+[PENDING RESEARCH] Fill in actual table names, columns, and host port
+during Phase 2 deep dive. All queries must use parameterized %s placeholders.
+"""
+import json
+import sys
+
+# [PENDING RESEARCH] Set the actual table and connection settings
+TABLE = "[PENDING RESEARCH]"
+DB_HOST = "localhost"
+DB_PORT = 5433  # [PENDING RESEARCH] external mapped port, not container-internal
+DB_NAME = "[PENDING RESEARCH]"
+DB_USER = "postgres"
+
+
+def recent_rows(limit: int = 20, as_json: bool = False) -> None:
+    """[PENDING RESEARCH] Query most recent rows from the output table."""
+    print(f"[PENDING RESEARCH] Implement: SELECT * FROM {TABLE} ORDER BY created_at DESC LIMIT %s")
+    print("Use parameterized queries only — no f-strings in SQL.")
+
+
+def main() -> None:
+    import argparse
+    p = argparse.ArgumentParser()
+    p.add_argument("--limit", type=int, default=20)
+    p.add_argument("--json", action="store_true")
+    args = p.parse_args()
+    recent_rows(args.limit, args.json)
+
+
+if __name__ == "__main__":
+    main()
+'''
+    (scripts_dir / "data_explorer.py").write_text(
+        data_explorer_tpl.replace("{{SERVICE_ID}}", service_id), encoding="utf-8"
+    )
+
+    # Makefile — standard diagnostic runner for every skill
+    makefile_tpl = """# Skill diagnostic scripts for {{SERVICE_ID}}
+# Usage: make <target>   (from this directory)
+# Override python: make health PYTHON=/path/to/python3
+
+# Auto-detect: prefer project venv (4 levels up), fall back to system python3
+_VENV := $(wildcard ../../../../venv/bin/python3)
+PYTHON ?= $(if $(_VENV),../../../../venv/bin/python3,python3)
+
+.PHONY: health health-json data data-json logs errors db help
+
+help:
+\t@echo "Available targets:"
+\t@echo "  health      - Run health probe (human readable)"
+\t@echo "  health-json - Run health probe (JSON output)"
+\t@echo "  data        - Show latest DB records"
+\t@echo "  data-json   - Show latest DB records (JSON, limit 5)"
+\t@echo "  logs        - Tail and analyze recent logs"
+\t@echo "  errors      - Show errors/criticals only"
+\t@echo "  db          - Run DB helper example queries"
+\t@echo ""
+\t@echo "Python: $(PYTHON)"
+
+health:
+\t$(PYTHON) health_probe.py
+
+health-json:
+\t$(PYTHON) health_probe.py --json
+
+data:
+\t$(PYTHON) data_explorer.py
+
+data-json:
+\t$(PYTHON) data_explorer.py --json --limit 5
+
+logs:
+\t$(PYTHON) log_hunter.py --tail 50
+
+errors:
+\t$(PYTHON) log_hunter.py --errors-only --tail 50
+
+db:
+\t$(PYTHON) db_helper.py
+"""
+    (scripts_dir / "Makefile").write_text(
+        makefile_tpl.replace("{{SERVICE_ID}}", service_id), encoding="utf-8"
+    )
+
+
+def write_reference_stubs(service_id: str, skill_dir: Path) -> None:
+    """Generate reference markdown files."""
+    name = service_id.replace("-", " ").replace("_", " ").title()
+
+    # deep_dive.md
+    (skill_dir / "references" / "deep_dive.md").write_text(
+        f"""# Phase 2 Research: {name}
+
+## Source Analysis
+- **Entry Point**: [FILL]
+- **Main Loop**: [FILL]
+- **Error Handlers**: [FILL]
+
+## Logic Trace
+1. [Step 1]
+2. [Step 2]
+
+## Invariants
+- [Must always X]
+- [Must never Y]
+""",
+        encoding="utf-8",
+    )
+
+    # architecture_ssot.md (stub)
+    (skill_dir / "references" / "architecture_ssot.md").write_text(
+        f"""# {name} Architecture
+
+[PENDING RESEARCH] Replace with link to project-level SSOT if exists,
+otherwise document high-level components here.
+""",
+        encoding="utf-8",
+    )
+
+
+if __name__ == "__main__":
+    import yaml
+
+    if len(sys.argv) < 2:
+        print("Usage: scaffolder.py <docker-compose-path> [service-id]")
+        sys.exit(1)
+
+    compose_path = Path(sys.argv[1])
+    if not compose_path.exists():
+        print(f"Compose file not found: {compose_path}")
+        sys.exit(1)
+
+    with open(compose_path) as f:
+        data = yaml.safe_load(f)
+
+    if len(sys.argv) > 2:
+        # Scaffold specific service
+        sid = sys.argv[2]
+        scaffold_service_skill(sid, data)
+    else:
+        # Scaffold all services in compose
+        for sid in data.get("services", {}).keys():
+            scaffold_service_skill(sid, data)

package/skills/delegating/SKILL.md

@@ -0,0 +1,196 @@
+---
+name: delegating
+description: >-
+  Proactively delegates tasks to cost-optimized agents before working in main session.
+  MUST suggest for: tests, typos, formatting, docs, refactors, code reviews, feature
+  implementation, debugging, commit validation. Skips main session token usage by routing
+  to GLM (simple/deterministic), Gemini (reasoning/analysis), Qwen (quality/patterns),
+  or multi-agent orchestration (review, feature dev, bug hunt). Never suggest for:
+  architecture decisions, security-critical code, unknown-cause bugs, performance optimization.
+allowed-tools: Bash
+---
+
+# Delegating Tasks
+
+Delegate tasks to cost-optimized models (CCS) or multi-agent orchestration workflows (Gemini/Qwen).
+
+## When to Suggest
+
+**Task Pattern → Backend Mapping** (auto-selection logic):
+
+| Task Pattern                  | Backend     | Cost   | Reason                         |
+|-------------------------------|-------------|--------|--------------------------------|
+| `typo\|test\|doc\|format`     | CCS (GLM)   | LOW    | Simple deterministic           |
+| `think\|analyze\|reason`      | CCS (Gemini)| MEDIUM | Requires reasoning             |
+| `review.*(code\|security)`    | Orchestration| HIGH   | Multi-agent code review        |
+| `implement.*feature`          | Orchestration| HIGH   | Full development workflow      |
+| `validate.*commit`            | Orchestration| MEDIUM | Security+Quality validation    |
+| `debug\|bug.*unknown`         | Orchestration| HIGH   | Root cause investigation       |
+
+**Never Suggest For:**
+- Architecture decisions requiring human judgment
+- Security-critical without review
+- Performance optimization (needs profiling first)
+
+---
+
+## Interactive Menu
+
+### Step 1: Delegation Choice
+
+Use AskUserQuestion with:
+- question: "This task can be delegated. How would you like to proceed?"
+- header: "Execution"
+- options:
+  - "Delegate (Recommended)" — Execute via optimal backend. Saves main session tokens and uses cost-efficient models.
+  - "Work in main session" — Execute in current Claude session. Better for tasks requiring discussion or complex context.
+
+**If user selects "Delegate"** → Continue to Step 2
+**If user selects "Work in main session"** → Execute task normally (don't delegate)
+
+### Step 2: Backend Selection
+
+Use AskUserQuestion with:
+- question: "Which backend should handle this task?"
+- header: "Backend"
+- options:
+  - "Auto-select (Recommended)" — Analyzes task keywords and selects optimal backend/profile automatically.
+  - "GLM - Cost-optimized" — Fast model for tests, typos, formatting [LOW COST]
+  - "Gemini - Reasoning" — Analysis, thinking, architecture tasks [MEDIUM COST]
+  - "Qwen - Quality" — Code quality, pattern detection [MEDIUM COST]
+  - "Multi-Agent Orchestration" — Direct Gemini/Qwen collaboration for complex tasks (review, feature dev, debugging) [HIGH COST]
+
+---
+
+## Auto-Selection Logic
+
+**Configuration-Driven:** All pattern matching is defined in [config.yaml](config.yaml), not hardcoded.
+
+### Configuration Structure
+
+The skill reads `config.yaml` to determine:
+1. **Available backends** (CCS profiles + Orchestration workflows)
+2. **Pattern mappings** (task keywords → backend selection)
+3. **Priority order** (Orchestration workflows checked before CCS)
+4. **Default fallback** (when no pattern matches)
+
+---
+
+## Orchestration Workflow Selection (Autonomous)
+
+When `backend: 'orchestration'` is selected, **Claude autonomously** chooses the appropriate workflow and orchestrates between `gemini` and `qwen` CLI tools.
+
+### Selection Process
+
+1. **Load config** - Read workflow definitions from `config.yaml`
+2. **Match patterns** - Determine which orchestration pattern (collaborative, handshake, troubleshoot) applies.
+3. **Execute turn protocol** - Use CLI commands sequentially:
+   - `gemini -p "..."`
+   - `qwen "..."`
+   - `gemini -r latest -p "..."` (to refine)
+
+### Turn Protocols
+
+| Workflow | Protocol |
+| :--- | :--- |
+| **handshake** | 1 turn: Agent A (Gemini) proposes -> Agent B (Qwen) validates. |
+| **collaborative** | 3 turns: Gemini designs -> Qwen critiques -> Gemini refines. |
+| **troubleshoot** | 4 turns: Gemini hypothesis -> Qwen verification -> Gemini root cause -> Final synthesis. |
+
+---
+
+## Execution Flow
+
+### For Direct Invocation (`/delegation [task]` or `/delegate [task]`)
+
+1. **Parse override flag** (if present: `--glm`, `--gemini`, `--orchestrate`, etc.)
+2. **Auto-select backend** using keyword-based logic.
+3. **Route to appropriate backend** (see sections below).
+4. **Report results**: Backend, Workflow (if Orchestration), Cost indicator, Duration.
+
+---
+
+### CCS / GLM Execution
+
+CCS wraps the `claude` CLI and **only works with GLM**. It requires a PTY for output and is blocked by the `CLAUDECODE` nested-session guard — always run via tmux:
+
+```bash
+tmux new-session -d -s ccs_task "env -u CLAUDECODE ccs glm -p '{task}' > /tmp/ccs_out.txt 2>&1"
+sleep 30  # or poll until session exits
+cat /tmp/ccs_out.txt
+```
+
+**If the task requires file modifications**, add `--dangerously-skip-permissions`:
+
+```bash
+tmux new-session -d -s ccs_task "env -u CLAUDECODE ccs glm --dangerously-skip-permissions -p '{task}' > /tmp/ccs_out.txt 2>&1"
+```
+
+---
+
+### Gemini CLI Execution
+
+Gemini is a **direct CLI** — no tmux workaround needed:
+
+```bash
+gemini -p "task description"
+```
+
+**If the task requires file modifications**, add `-y` to auto-approve all tool calls:
+
+```bash
+gemini -y -p "task description"
+```
+
+---
+
+### Qwen CLI Execution
+
+Qwen is a **direct CLI** — no tmux workaround needed:
+
+```bash
+qwen "task description"
+```
+
+**If the task requires file modifications**, add `-y` to auto-approve all tool calls:
+
+```bash
+qwen -y "task description"
+```
+
+---
+
+### Orchestration Execution
+
+Multi-turn sequences use Gemini and Qwen **direct CLIs**. Add `-y` to all turns when modifications are expected:
+
+```bash
+gemini -y -p "..."            # Turn 1
+qwen -y "..."                 # Turn 2
+gemini -y -r latest -p "..."  # Turn 3 (refine)
+```
+
+---
+
+## Examples
+
+### Auto-Selection Examples
+
+**CCS Simple:**
+- `/delegate add unit tests for UserService` → CCS (GLM)
+- `/delegate think about the best database schema` → CCS (Gemini)
+
+**Orchestration Workflows:**
+- `/delegate review this code for security issues` → Orchestration (parallel-review)
+- `/delegate implement OAuth authentication feature` → Orchestration (feature-design)
+- `/delegate debug crash on startup` → Orchestration (bug-hunt)
+
+---
+
+## Notes
+
+### Version 7.0.0 - Direct Orchestration
+- **Independent of unitAI**: Now uses direct `gemini` and `qwen` CLI calls.
+- **Unified backends**: CCS (cost-optimized) + Direct Orchestration.
+- **Config-driven**: All behavior defined in `config.yaml`.
+- **Reference**: Uses patterns from [orchestrating-agents](../orchestrating-agents/SKILL.md).