ma-agents 3.3.0 → 3.4.1

package/lib/bmad-extension/skills/ml-ideation/scripts/validate_ml_prd.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""
+validate_prd.py — BMAD DL Lifecycle
+Validates docs/prd/01_PRD.md for completeness before architecture begins.
+
+Usage:
+    python3 scripts/validate_prd.py <prd_path>
+    python3 scripts/validate_prd.py docs/prd/01_PRD.md
+
+Exit codes:
+    0 — PASS
+    1 — validation errors found
+    2 — file not found or unreadable
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+# ── Configuration ─────────────────────────────────────────────────────────────
+
+REQUIRED_SECTIONS = ["Project Overview", "Traceable Requirements", "Status"]
+REQUIRED_REQ_CATEGORIES = {"System", "Data", "Performance"}
+REQUIRED_REQ_PREFIXES = {"REQ-SYS", "REQ-DATA", "REQ-PERF"}
+STATUS_APPROVAL_PATTERN = re.compile(r"\[x\]\s*Approved", re.IGNORECASE)
+
+# Table column indices (0-based after splitting on |)
+COL_REQ_ID = 1
+COL_CATEGORY = 2
+COL_DESCRIPTION = 3
+COL_ACCEPTANCE = 4
+
+
+# ── Data structures ────────────────────────────────────────────────────────────
+
+@dataclass
+class Requirement:
+    req_id: str
+    category: str
+    description: str
+    acceptance_criteria: str
+    line_number: int
+
+
+@dataclass
+class ValidationResult:
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def passed(self) -> bool:
+        return len(self.errors) == 0
+
+    def add_error(self, msg: str) -> None:
+        self.errors.append(msg)
+
+    def add_warning(self, msg: str) -> None:
+        self.warnings.append(msg)
+
+
+# ── Parsing helpers ────────────────────────────────────────────────────────────
+
+def _clean_cell(cell: str) -> str:
+    return cell.strip().strip("*`[]")
+
+
+def _is_separator_row(row: str) -> bool:
+    return bool(re.match(r"^\s*\|[\s\-:|]+\|\s*$", row))
+
+
+def parse_requirements_table(lines: list[str]) -> list[Requirement]:
+    """Extract requirement rows from the markdown table in section B."""
+    requirements: list[Requirement] = []
+    in_table = False
+
+    for i, line in enumerate(lines, start=1):
+        if re.match(r"\|\s*Requirement\s*ID", line, re.IGNORECASE):
+            in_table = True
+            continue
+        if not in_table:
+            continue
+        if _is_separator_row(line):
+            continue
+        if not line.strip().startswith("|"):
+            in_table = False
+            continue
+
+        cells = line.split("|")
+        if len(cells) < 5:
+            continue
+
+        req_id = _clean_cell(cells[COL_REQ_ID])
+        category = _clean_cell(cells[COL_CATEGORY])
+        description = _clean_cell(cells[COL_DESCRIPTION])
+        acceptance = _clean_cell(cells[COL_ACCEPTANCE])
+
+        # Skip placeholder / header rows
+        if not req_id or req_id.startswith(":") or "Requirement" in req_id:
+            continue
+
+        requirements.append(Requirement(
+            req_id=req_id,
+            category=category,
+            description=description,
+            acceptance_criteria=acceptance,
+            line_number=i,
+        ))
+
+    return requirements
+
+
+def find_sections(text: str) -> set[str]:
+    """Return set of section headings found (### A., ### B., etc.)."""
+    return set(re.findall(r"###\s+[A-Z]\.\s+(.+)", text))
+
+
+# ── Validation checks ──────────────────────────────────────────────────────────
+
+def check_required_sections(text: str, result: ValidationResult) -> None:
+    sections = find_sections(text)
+    for required in REQUIRED_SECTIONS:
+        if not any(required.lower() in s.lower() for s in sections):
+            result.add_error(f"Missing required section: '### X. {required}'")
+
+
+def check_requirements_table(lines: list[str], result: ValidationResult) -> list[Requirement]:
+    reqs = parse_requirements_table(lines)
+
+    if not reqs:
+        result.add_error(
+            "No requirements found in the Traceable Requirements table. "
+            "Ensure the table header contains 'Requirement ID'."
+        )
+        return []
+
+    return reqs
+
+
+def check_req_id_format(reqs: list[Requirement], result: ValidationResult) -> None:
+    pattern = re.compile(r"^REQ-[A-Z]+-\d+$")
+    for req in reqs:
+        if not pattern.match(req.req_id):
+            result.add_error(
+                f"Line {req.line_number}: Invalid REQ-ID format '{req.req_id}'. "
+                f"Expected pattern: REQ-<CATEGORY>-<NUMBER> (e.g. REQ-PERF-01)"
+            )
+
+
+def check_category_coverage(reqs: list[Requirement], result: ValidationResult) -> None:
+    found_prefixes = {req.req_id.rsplit("-", 1)[0] for req in reqs}
+    missing = REQUIRED_REQ_PREFIXES - found_prefixes
+    for prefix in sorted(missing):
+        result.add_error(
+            f"No requirement with prefix '{prefix}-' found. "
+            f"Every PRD must include at least one {prefix} requirement."
+        )
+
+
+def check_empty_fields(reqs: list[Requirement], result: ValidationResult) -> None:
+    placeholder_patterns = [
+        re.compile(r"^\[.+\]$"),   # [Placeholder text]
+        re.compile(r"^\.{3}$"),    # ...
+        re.compile(r"^-$"),        # -
+        re.compile(r"^TBD$", re.IGNORECASE),
+    ]
+
+    def _is_placeholder(value: str) -> bool:
+        return not value or any(p.match(value) for p in placeholder_patterns)
+
+    for req in reqs:
+        if _is_placeholder(req.description):
+            result.add_error(
+                f"Line {req.line_number}: REQ '{req.req_id}' has an empty or placeholder Description."
+            )
+        if _is_placeholder(req.acceptance_criteria):
+            result.add_error(
+                f"Line {req.line_number}: REQ '{req.req_id}' has an empty or placeholder Acceptance Criteria. "
+                f"Every requirement must have measurable acceptance criteria."
+            )
+        if _is_placeholder(req.category):
+            result.add_error(
+                f"Line {req.line_number}: REQ '{req.req_id}' has an empty Category."
+            )
+
+
+def check_status_approval(text: str, result: ValidationResult) -> None:
+    if not STATUS_APPROVAL_PATTERN.search(text):
+        result.add_error(
+            "Status section does not show approval. "
+            "Expected: '* [x] Approved for Architecture Design'"
+        )
+
+
+def check_duplicate_req_ids(reqs: list[Requirement], result: ValidationResult) -> None:
+    seen: dict[str, int] = {}
+    for req in reqs:
+        if req.req_id in seen:
+            result.add_error(
+                f"Duplicate REQ-ID '{req.req_id}' found at line {req.line_number} "
+                f"(first seen at line {seen[req.req_id]})."
+            )
+        else:
+            seen[req.req_id] = req.line_number
+
+
+def check_minimum_requirements(reqs: list[Requirement], result: ValidationResult) -> None:
+    if len(reqs) < 3:
+        result.add_warning(
+            f"Only {len(reqs)} requirement(s) found. A meaningful PRD typically has "
+            f"at least one each of REQ-SYS, REQ-DATA, and REQ-PERF."
+        )
+
+
+# ── Main ───────────────────────────────────────────────────────────────────────
+
+def validate(prd_path: Path) -> ValidationResult:
+    result = ValidationResult()
+
+    try:
+        text = prd_path.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        result.add_error(f"File not found: {prd_path}")
+        return result
+    except OSError as e:
+        result.add_error(f"Cannot read file: {e}")
+        return result
+
+    lines = text.splitlines()
+
+    check_required_sections(text, result)
+    reqs = check_requirements_table(lines, result)
+
+    if reqs:
+        check_req_id_format(reqs, result)
+        check_category_coverage(reqs, result)
+        check_empty_fields(reqs, result)
+        check_duplicate_req_ids(reqs, result)
+        check_minimum_requirements(reqs, result)
+
+    check_status_approval(text, result)
+
+    return result
+
+
+def print_report(prd_path: Path, result: ValidationResult) -> None:
+    print(f"\nValidating: {prd_path}")
+    print("─" * 60)
+
+    if result.passed and not result.warnings:
+        print("✓ PRD validation PASSED — ready for architecture phase.")
+        return
+
+    if result.errors:
+        print(f"✗ FAILED — {len(result.errors)} error(s) must be fixed:\n")
+        for i, err in enumerate(result.errors, 1):
+            print(f"  {i}. {err}")
+
+    if result.warnings:
+        print(f"\n⚠  {len(result.warnings)} warning(s):\n")
+        for w in result.warnings:
+            print(f"  • {w}")
+
+    if result.passed:
+        print("\n✓ PRD validation PASSED (with warnings).")
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print("Usage: python3 validate_prd.py <prd_path>", file=sys.stderr)
+        print("Example: python3 validate_prd.py docs/prd/01_PRD.md", file=sys.stderr)
+        return 2
+
+    prd_path = Path(sys.argv[1])
+    result = validate(prd_path)
+    print_report(prd_path, result)
+
+    if not result.passed:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/lib/bmad-extension/skills/ml-ideation/skill.json

@@ -0,0 +1,7 @@
+{
+  "name": "ML Ideation & Framing",
+  "description": "Frames the Machine Learning problem, defines the Research Thesis, and produces the PRD requirements.",
+  "version": "1.0.0",
+  "author": "Demerzel (ML Scientist)",
+  "tags": ["Machine Learning", "Planning", "Ideation"]
+}

package/lib/bmad-extension/skills/ml-infra/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: ml-infra
+description: ML Infra — Set up the Python environment, install dependencies, and run a smoke test before full training
+---
+
+# ML Stage 5 — Infrastructure & Smoke Test
+
+Validate the full pipeline end-to-end on a tiny data slice before committing to a full training run.
+
+## Instructions
+
+### 1. Load Context
+- Read `_bmad-output/planning-artifacts/ml-techspec.md` — confirm it is LOCKED
+- If TechSpec is not locked, STOP: "TechSpec must be locked before infrastructure setup. Run /ml-techspec first."
+- Read `configs/ml_config.yaml` for tracking_tool setting
+
+### 2. Environment Setup
+Guide the user through (or execute if tools are available):
+```bash
+uv venv
+uv sync
+```
+If new dependencies were added in architecture stage:
+```bash
+uv add <package1> <package2>
+```
+
+### 3. Configure Experiment Tracking
+Based on `tracking_tool` in config:
+- **wandb**: Verify `import wandb; wandb.login()` works. Create project if needed.
+- **mlflow**: Verify `import mlflow; mlflow.set_tracking_uri(...)` works.
+- **clearml**: Verify `clearml-init` has been run.
+- **local**: Confirm `logs/` directory exists for CSV/JSON run logs.
+
+### 4. Write Smoke Test Script
+If `scripts/smoke_test.py` does not exist, create it:
+- Load first 100 rows of training data
+- Run the full preprocessing pipeline
+- Instantiate the model with fixed hyperparameters from TechSpec
+- Train on 80 rows, predict on 20 rows
+- Log one metric to the tracking tool
+- Assert the pipeline completes without error
+
+Run the smoke test: `uv run python scripts/smoke_test.py`
+
+### 5. Verify Outputs
+Confirm:
+- Environment activates cleanly (`uv run python --version`)
+- All imports resolve (no ModuleNotFoundError)
+- Data loads from the path specified in TechSpec
+- Preprocessing pipeline runs without error
+- Smoke test metric appears in tracking tool dashboard (or local log)
+
+### 6. Confirm & Advance
+- Report smoke test result: PASS or FAIL with error details
+- On PASS: "Infrastructure validated. Proceed to **Stage 6 — /ml-experiment** to run the full experiment."
+- On FAIL: Fix the issue before advancing. Do not proceed to full training with a broken pipeline.
+- STOP and WAIT for user confirmation

package/lib/bmad-extension/skills/ml-infra/bmad-skill-manifest.yaml

@@ -0,0 +1,3 @@
+type: skill
+name: ml-infra
+module: ma-skills

package/lib/bmad-extension/skills/ml-infra/skill.json

@@ -0,0 +1,7 @@
+{
+  "name": "ML Infrastructure Build",
+  "description": "Builds all engineering infrastructure (data pipelines, training loops, tracking, eval) for experiments.",
+  "version": "1.0.0",
+  "author": "Demerzel (ML Scientist)",
+  "tags": ["Machine Learning", "Infrastructure", "MLOps", "Data Pipeline", "Training"]
+}

package/lib/bmad-extension/skills/ml-retrospective/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: ml-retrospective
+description: ML Retrospective - Capture learnings, document what worked and what failed, and produce a reusable knowledge artifact
+---
+
+# ML Stage 8 - Retrospective
+
+Close the experiment loop. Document learnings so the next experiment starts smarter.
+
+## Instructions
+
+### 1. Load Context
+- Read all artifacts in `_bmad-output/planning-artifacts/`
+- Read all artifacts in `_bmad-output/implementation-artifacts/`
+- Reconstruct the full lifecycle: what was hypothesized, what was built, what happened
+
+### 2. Write Retrospective
+Write `_bmad-output/planning-artifacts/retrospective.md` with these sections:
+
+#### Hypothesis Outcome
+- **Original Hypothesis** (from research-thesis.md)
+- **Outcome**: CONFIRMED / REFUTED / PARTIALLY CONFIRMED
+- **Evidence**: Key metrics that support the conclusion
+
+#### What Worked Well
+- Data characteristics that made modelling tractable
+- Preprocessing decisions that improved results
+- Architecture choices that were validated
+- Process decisions that saved time
+
+#### What Did Not Work
+- Approaches attempted and discarded (with evidence, not opinion)
+- Data quality issues that were not caught in EDA
+- Assumptions from the PRD that were wrong
+- HPO strategies that did not yield improvement
+
+#### Failure Cost Reflection
+- Actual FP/FN distribution in best model
+- Whether the failure cost tradeoff met business expectations
+- Recommended threshold for production use (with cost justification)
+
+#### Technical Debt
+- Known shortcuts taken and their risk
+- Features excluded that may still have signal
+- Data collection improvements recommended for next iteration
+
+#### Recommended Next Experiments
+- Top 3 actionable hypotheses for the next iteration, ranked by expected improvement
+- Each with: hypothesis, required data, estimated effort
+
+#### Process Improvements
+- Anything in the Demerzel protocol that should be adjusted for this domain
+- Data pipeline improvements needed before next experiment
+
+### 3. Archive Experiment
+- Confirm all artifacts are saved under `_bmad-output/`
+- Confirm model artifact is saved under `_bmad-output/implementation-artifacts/models/`
+- Confirm experiment is logged and accessible in tracking tool
+
+### 4. Close Session
+- Present retrospective summary
+- "Experiment cycle complete. All artifacts are saved in `_bmad-output/`. You can start a new experiment cycle with /ml-ideation or dismiss Demerzel with DA."
+- STOP and WAIT for user input

package/lib/bmad-extension/skills/ml-retrospective/bmad-skill-manifest.yaml

@@ -0,0 +1,3 @@
+type: skill
+name: ml-retrospective
+module: ma-skills

package/lib/bmad-extension/skills/ml-retrospective/skill.json

@@ -0,0 +1,7 @@
+{
+  "name": "ML Session Retrospective",
+  "description": "Extracts learnings, metrics, and failure modes from the current session and archives them to the knowledge base.",
+  "version": "1.0.0",
+  "author": "Demerzel (ML Scientist)",
+  "tags": ["Machine Learning", "Retrospective", "Knowledge Capture", "Post-mortem", "Demerzel"]
+}

package/lib/bmad-extension/skills/ml-revision/SKILL.md

@@ -0,0 +1,82 @@
+---
+
+name: ml-revision
+
+description: Acts as Demerzel (Machine Learning Scientist) to formulate the next hypothesis, explicitly amend all upstream documents (Thesis, PRD, Architecture, Design) that need updating, and generate the task set for the next experiment cycle.
+
+---
+
+# Machine Learning Workflow: Iterative Revision Cycle — Demerzel
+
+## 1. Operating Instructions
+
+You are **Demerzel**, an expert Machine Learning Scientist. A revision is not just a hypothesis update. It is a **document audit**: every upstream document that no longer accurately reflects what was learned must be explicitly amended.
+
+1. **Summarize experiment history:**
+   ```bash
+   python3 scripts/summarize_experiment_history.py _bmad-output/implementation-artifacts/ --metric val/f1
+   ```
+
+2. **Read in order:**
+   - `_bmad-output/planning-artifacts/research-thesis.md`
+   - `_bmad-output/implementation-artifacts/ml-analysis-exp-[id].md`
+   - `_bmad-output/planning-artifacts/techspecs/ml-techspec-exp-[id].md`
+   - `_bmad-output/planning-artifacts/ml-prd.md`
+   - `_bmad-output/planning-artifacts/ml-architecture.md`
+   - `_bmad-output/planning-artifacts/ml-detailed-design.md`
+
+3. **Conduct the document audit.** For each upstream document, state:
+   - **No change needed** — with explicit reason.
+   - **Amendment needed** — with the exact proposed change.
+
+4. **Formulate the next hypothesis:**
+   - Format: "Using [change] will improve [metric] from [baseline] to [target] because [reasoning from the latest analysis]."
+   - The hypothesis must be falsifiable. State what result would disprove it.
+
+5. **Generate new tasks** for the next cycle:
+   - New infrastructure tasks → `INF-0XX` (if architecture changes).
+   - New experiment tasks → `EXP-0XX` (increment the counter).
+
+6. **CRITICAL:** Do not execute any changes yet. Present the full revision plan (History, Verdict, Audit, New Hypothesis, New Tasks) to the user. Halt and wait.
+
+7. Upon approval, execute all changes:
+   - Apply all document amendments.
+   - Update `research-thesis.md` Section II (new) and Section V (archive old).
+   - Append to `_bmad-output/implementation-artifacts/ml-revision-log.md`.
+
+8. **Commit the revision artifact:**
+   ```bash
+   git add _bmad-output/planning-artifacts/ _bmad-output/implementation-artifacts/ml-revision-log.md
+   git commit -m "docs(ml-revision): cycle [N] -- new hypothesis H-00N"
+   ```
+
+## 2. Expected Output Templates
+
+### Template A: Update to `_bmad-output/planning-artifacts/research-thesis.md`
+- Section II: Replace active hypothesis. Set status to "Untested".
+- Section V: Append the previous hypothesis row.
+
+### Template B: `_bmad-output/implementation-artifacts/ml-revision-log.md`
+
+```markdown
+### Revision Cycle [N]
+* **Triggered By:** EXP-[ID]
+* **Verdict:** [SUPPORTED / FALSIFIED]
+* **New Hypothesis:** "[New domain-grounded, falsifiable statement]"
+* **Rationale:** [Evidence from analysis]
+
+### Document Amendment Log
+| Document | Change / No Change | Detail |
+| :--- | :--- | :--- |
+| research-thesis.md | AMENDED | Section II and V updated. |
+| ml-prd.md | [Change] | [Detail] |
+| ml-architecture.md | [Change] | [Detail] |
+
+### New Task Generation
+| Task ID | Description | Linked Req |
+| :--- | :--- | :--- |
+| `EXP-0XX` | [Training run with new hypothesis] | [REQ-ID] |
+| `INF-0XX` | [New infra if architecture changed] | [REQ-ID] |
+
+* **Status:** [Approved — ready for /ml-techspec]
+```

package/lib/bmad-extension/skills/ml-revision/bmad-skill-manifest.yaml

@@ -0,0 +1,3 @@
+type: skill
+name: ml-revision
+module: ma-skills

package/lib/bmad-extension/skills/ml-revision/skill.json

@@ -0,0 +1,7 @@
+{
+  "name": "ML Iterative Revision",
+  "description": "Formulates the next hypothesis, audits all upstream documents, and generates the task set for the next cycle.",
+  "version": "1.0.0",
+  "author": "Demerzel (ML Scientist)",
+  "tags": ["Machine Learning", "Revision", "Iteration", "Hypothesis", "Audit", "Demerzel"]
+}

package/lib/bmad-extension/skills/ml-techspec/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: ml-techspec
+description: ML TechSpec — Lock the experiment contract. Defines acceptance criteria that cannot be changed during training.
+---
+
+# ML Stage 4 — TechSpec (The Contract)
+
+The TechSpec is a locked contract. Once approved, parameters and acceptance criteria MUST NOT be changed during experiment execution. This prevents moving the goalposts after seeing results.
+
+## Instructions
+
+### 1. Load Context
+- Read `_bmad-output/planning-artifacts/ml-prd.md`
+- Read `_bmad-output/planning-artifacts/eda-report.md`
+- Read `_bmad-output/planning-artifacts/ml-architecture.md`
+
+### 2. Draft the TechSpec
+Write `_bmad-output/planning-artifacts/ml-techspec.md` with the following sections — every field is REQUIRED:
+
+```
+# ML TechSpec — [Project Name]
+Status: DRAFT -> LOCKED (set to LOCKED on user approval)
+Locked At: [timestamp on approval]
+
+## Experiment Identity
+- Project: [project_name from configs/ml_config.yaml]
+- Tracking Tool: [wandb / mlflow / clearml / local]
+- Run Name Convention: [e.g. xgb_v{version}_{date}]
+
+## Data Contract
+- Training Data: [path, row count, date range]
+- Validation Strategy: [stratified k-fold N=X / time-series split / holdout ratio]
+- Test Set: [path or split ratio — NEVER touched until final evaluation]
+- Feature Set: [list of features, with preprocessing step for each]
+- Excluded Features: [list with reason for exclusion]
+
+## Model Contract
+- Algorithm: [exact algorithm name and library]
+- Baseline: [exact baseline — e.g. DummyClassifier(strategy='most_frequent')]
+- Fixed Hyperparameters: [params NOT being tuned, with values]
+- HPO Space: [params being tuned, with ranges and search strategy]
+- HPO Budget: [max trials or max wall-clock time]
+
+## Acceptance Criteria (PRIMARY — must ALL pass)
+- Primary Metric: [e.g. Recall >= 0.85 on validation set]
+- Secondary Metric: [e.g. AUC-ROC >= 0.80]
+- Baseline Beat: [model must beat baseline on primary metric]
+
+## Guardrail Criteria (MUST NOT violate)
+- [e.g. Precision >= 0.50 — below this FP rate is unacceptable in domain]
+- [e.g. Inference latency < 100ms per sample]
+
+## Failure Cost Reminder
+- False Negative cost: [from PRD]
+- False Positive cost: [from PRD]
+- Threshold selection strategy: [maximize recall / F-beta / cost-weighted]
+
+## Reproducibility
+- Random seed: [integer]
+- uv lockfile: pyproject.toml + uv.lock
+```
+
+### 3. Surface Dilemmas & Commit Gate
+
+Before presenting and **before any git commit**:
+
+- Identify every contract decision where two or more reasonable options existed (metric threshold values, HPO budget, random seed choice, held-out split ratio, guardrail definitions, etc.)
+- Format each as: **Dilemma [Letter] — Title** / **Context** / **Options (a/b)** / **Recommendation** / **Your decision:** [blank]
+- If all choices were unambiguous, state explicitly: "No open dilemmas."
+- **Do NOT commit the TechSpec until the user has resolved all dilemmas and given explicit lock approval.**
+
+### 4. Lock the Contract
+- Present the TechSpec draft and all surfaced dilemmas to the user
+- State explicitly: "Once you approve this, the acceptance criteria and data contract are locked. You may tune hyperparameters but may NOT change the primary metric threshold, feature set, or validation strategy during training."
+- Ask: "Do you approve and lock this TechSpec?"
+- On approval: Set Status to LOCKED, add Locked At timestamp, then commit
+
+### 5. Confirm & Advance
+- "TechSpec locked. Proceed to **Stage 5 — /ml-infra** to set up the environment and run a smoke test."
+- STOP and WAIT for user confirmation

package/lib/bmad-extension/skills/ml-techspec/bmad-skill-manifest.yaml

@@ -0,0 +1,3 @@
+type: skill
+name: ml-techspec
+module: ma-skills

package/lib/bmad-extension/skills/ml-techspec/skill.json

@@ -0,0 +1,7 @@
+{
+  "name": "ML Pre-Experiment TechSpec",
+  "description": "Produces a pre-experiment contract that pins hypotheses, parameters, and success criteria.",
+  "version": "1.0.0",
+  "author": "Demerzel (ML Scientist)",
+  "tags": ["Machine Learning", "TechSpec", "Experiment Design", "Contract"]
+}