bigpowers 2.76.3 → 2.77.1

package/scripts/sync-status-from-epics.sh

@@ -12,6 +12,32 @@ $PYTHON - "$EPICS" "$OUT" <<'PY'
 import re
 import sys
 from pathlib import Path
+import yaml
+
+
+def _yaml_str(s: str) -> str:
+    """Return a YAML-safe quoted string, using single quotes when needed."""
+    if not s:
+        return "''"
+    if any(c in s for c in ":{}[]&*?|>-;!%@`,\"\n\t#'"):
+        escaped = s.replace("'", "''")
+        return f"'{escaped}'"
+    if s.startswith(" ") or s.endswith(" ") or s[0] in "0123456789":
+        escaped = s.replace("'", "''")
+        return f"'{escaped}'"
+    return s
+
+
+def _yaml_val(v) -> str:
+    """Return a YAML-safe scalar representation."""
+    if v is None:
+        return "null"
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, (int, float)):
+        return str(v)
+    return _yaml_str(str(v))
+
 
 epics_dir = Path(sys.argv[1])
 out = Path(sys.argv[2])
@@ -23,34 +49,231 @@ if existing_path.exists():
     for m in re.finditer(r"^  ([a-z0-9._-]+):\s*(\S+)", existing, re.M):
         keys[m.group(1)] = m.group(2)
 
-for epic_file in sorted(epics_dir.glob("e*.yaml")):
-    text = epic_file.read_text(encoding="utf-8")
-    em = re.search(r"^id:\s*(e\d+)", text, re.M)
-    if em:
-        eid = em.group(1)
-        keys.setdefault(eid, "backlog")
-    for sm in re.finditer(r"^\s+- id:\s*(e\d+s\d+)", text, re.M):
-        keys.setdefault(sm.group(1), "backlog")
-
-for folder in sorted(epics_dir.glob("e*/")):
-    epic_yaml = folder / "epic.yaml"
-    if epic_yaml.exists():
-        text = epic_yaml.read_text(encoding="utf-8")
-        em = re.search(r"^id:\s*(e\d+)", text, re.M)
-        if em:
-            keys.setdefault(em.group(1), "backlog")
-        # Parse inline story IDs from capsule epic.yaml (same pattern as flat files)
-        for sm in re.finditer(r"^\s+- id:\s*(e\d+s\d+)", text, re.M):
-            keys.setdefault(sm.group(1), "backlog")
-    for story in (folder / "stories").glob("e*s*.md"):
-        m = re.match(r"(e\d+s\d+)", story.name)
-        if m:
-            keys.setdefault(m.group(1), "backlog")
+# --- Parse release-plan.yaml for wsjf/tier per epic ---
+rp_epics: dict[str, dict[str, object]] = {}
+rp_path = epics_dir.parent / "release-plan.yaml"
+if rp_path.exists():
+    try:
+        rp = yaml.safe_load(rp_path.read_text(encoding="utf-8"))
+        for ep in (rp.get("epics") or []):
+            eid = ep.get("id")
+            if not eid:
+                continue
+            entry: dict[str, object] = {}
+            if "wsjf" in ep:
+                entry["wsjf"] = ep["wsjf"]
+            if "tier" in ep:
+                entry["tier"] = ep["tier"]
+            rp_epics[eid] = entry
+    except Exception:
+        pass
+
+# --- Collect all epic sources (capsule dirs + flat YAML) ---
+epic_sources: list[tuple[str, Path]] = []
+seen_eids: set[str] = set()
+
+# Search roots: epics_dir itself, plus immediate subdirectories (e.g., archive/)
+search_roots = [epics_dir] if epics_dir.is_dir() else []
+for sub in sorted(epics_dir.iterdir()) if epics_dir.is_dir() else []:
+    if sub.is_dir():
+        search_roots.append(sub)
+
+for root in search_roots:
+    for capsule in sorted(root.glob("e*/")):
+        ey = capsule / "epic.yaml"
+        if ey.exists():
+            try:
+                ed = yaml.safe_load(ey.read_text(encoding="utf-8"))
+                eid = ed.get("id")
+                if eid and eid not in seen_eids:
+                    epic_sources.append((eid, ey))
+                    seen_eids.add(eid)
+            except Exception:
+                pass
+
+    for epic_file in sorted(root.glob("e*.yaml")):
+        if re.search(r"e\d+s\d+", epic_file.stem):
+            continue
+        try:
+            ed = yaml.safe_load(epic_file.read_text(encoding="utf-8"))
+            eid = ed.get("id")
+            if eid and eid not in seen_eids:
+                epic_sources.append((eid, epic_file))
+                seen_eids.add(eid)
+        except Exception:
+            pass
+
+# --- Build enriched epic + story data ---
+epics_output: dict[str, dict[str, object]] = {}
+stories_output: dict[str, dict[str, object]] = {}
+
+risk_rank = {"P0": 4, "P1": 3, "P2": 2, "P3": 1}
+sec_rank = {"high": 4, "medium": 3, "low": 2, "none": 1}
+
+for eid, epic_path in sorted(epic_sources):
+    try:
+        ed = yaml.safe_load(epic_path.read_text(encoding="utf-8"))
+    except Exception:
+        continue
+    keys.setdefault(eid, "backlog")
+
+    title = ed.get("title", "")
+    total_bcps = ed.get("total_bcps") or ed.get("bcps")
+
+    epics_output[eid] = {
+        "status": keys[eid],
+        "title": title,
+        "wsjf": rp_epics.get(eid, {}).get("wsjf"),
+        "total_bcps": total_bcps,
+    }
+    if "tier" in rp_epics.get(eid, {}):
+        epics_output[eid]["tier"] = rp_epics[eid]["tier"]
+
+    capsule_dir = epic_path.parent
+    stories = ed.get("stories") or []
 
+    for story in stories:
+        if not isinstance(story, dict):
+            continue
+        sid = story.get("id")
+        if not sid or not re.match(r"^e\d+s\d+$", str(sid)):
+            continue
+        keys.setdefault(sid, "backlog")
+
+        story_bcps = story.get("bcp") or story.get("bcps")
+        stories_output[sid] = {
+            "status": keys[sid],
+            "title": story.get("title", ""),
+            "bcps": story_bcps,
+            "epic": eid,
+            "tasks_total": 0,
+            "tasks_passing": 0,
+            "tasks_failing": 0,
+            "risk_max": None,
+            "security_max": None,
+        }
+
+        # Look for -tasks.yaml at capsule root
+        tasks_file = None
+        for pattern in [f"{sid}-tasks.yaml", f"{sid}*.yaml"]:
+            for tf in sorted(capsule_dir.glob(pattern)):
+                try:
+                    tf_data = yaml.safe_load(tf.read_text(encoding="utf-8"))
+                    if isinstance(tf_data, dict) and "tasks" in tf_data:
+                        tasks_file = tf
+                        break
+                except Exception:
+                    pass
+            if tasks_file:
+                break
+
+        if tasks_file:
+            try:
+                tf_data = yaml.safe_load(tasks_file.read_text(encoding="utf-8"))
+                tasks = tf_data.get("tasks") or []
+
+                stories_output[sid]["tasks_total"] = len(tasks)
+                passing = sum(
+                    1 for t in tasks
+                    if isinstance(t, dict) and t.get("status") in ("done", "passing")
+                )
+                failing = sum(
+                    1 for t in tasks
+                    if isinstance(t, dict) and t.get("status") == "failing"
+                )
+                stories_output[sid]["tasks_passing"] = passing
+                stories_output[sid]["tasks_failing"] = failing
+
+                # Risk max: check individual tasks + story-level
+                max_risk_val = None
+                max_risk_rank = 0
+                for t in tasks:
+                    tr = t.get("risk") if isinstance(t, dict) else None
+                    if tr in risk_rank and risk_rank[tr] > max_risk_rank:
+                        max_risk_rank = risk_rank[tr]
+                        max_risk_val = tr
+                sr = tf_data.get("risk")
+                if sr in risk_rank and risk_rank[sr] > max_risk_rank:
+                    max_risk_val = sr
+                stories_output[sid]["risk_max"] = max_risk_val
+
+                # Security max: check individual tasks + story-level
+                max_sec_val = None
+                max_sec_rank = 0
+                for t in tasks:
+                    ts = t.get("security") if isinstance(t, dict) else None
+                    if ts in sec_rank and sec_rank[ts] > max_sec_rank:
+                        max_sec_rank = sec_rank[ts]
+                        max_sec_val = ts
+                ss = tf_data.get("security")
+                if ss in sec_rank and sec_rank[ss] > max_sec_rank:
+                    max_sec_val = ss
+                stories_output[sid]["security_max"] = max_sec_val
+
+            except Exception:
+                pass
+
+    # Stories/ subdirectory (future-proofing)
+    stories_dir = capsule_dir / "stories"
+    if stories_dir.is_dir():
+        for story_file in sorted(stories_dir.glob("e*s*.md")):
+            m = re.match(r"(e\d+s\d+)", story_file.stem)
+            if m:
+                sid = m.group(1)
+                keys.setdefault(sid, "backlog")
+                if sid not in stories_output:
+                    stories_output[sid] = {
+                        "status": keys[sid],
+                        "title": "",
+                        "bcps": None,
+                        "epic": eid,
+                        "tasks_total": 0,
+                        "tasks_passing": 0,
+                        "tasks_failing": 0,
+                        "risk_max": None,
+                        "security_max": None,
+                    }
+
+# --- Build output ---
 lines = ["development_status:"]
 for k in sorted(keys.keys()):
     lines.append(f"  {k}: {keys[k]}")
 lines.append("")
+
+# --- Epics section ---
+lines.append("epics:")
+for eid in sorted(epics_output.keys()):
+    lines.append(f"  {eid}:")
+    ep = epics_output[eid]
+    lines.append(f"    status: {_yaml_val(ep['status'])}")
+    lines.append(f"    title: {_yaml_str(ep.get('title', ''))}")
+    if ep.get("wsjf") is not None:
+        lines.append(f"    wsjf: {ep['wsjf']}")
+    if ep.get("tier") is not None:
+        lines.append(f"    tier: {ep['tier']}")
+    if ep.get("total_bcps") is not None:
+        lines.append(f"    total_bcps: {ep['total_bcps']}")
+lines.append("")
+
+# --- Stories section ---
+lines.append("stories:")
+for sid in sorted(stories_output.keys()):
+    lines.append(f"  {sid}:")
+    st = stories_output[sid]
+    lines.append(f"    status: {_yaml_val(st['status'])}")
+    lines.append(f"    title: {_yaml_str(st.get('title', ''))}")
+    if st.get("bcps") is not None:
+        lines.append(f"    bcps: {st['bcps']}")
+    lines.append(f"    epic: {_yaml_val(st['epic'])}")
+    lines.append(f"    tasks_total: {st['tasks_total']}")
+    lines.append(f"    tasks_passing: {st['tasks_passing']}")
+    lines.append(f"    tasks_failing: {st['tasks_failing']}")
+    if st.get("risk_max") is not None:
+        lines.append(f"    risk_max: {_yaml_val(st['risk_max'])}")
+    if st.get("security_max") is not None:
+        lines.append(f"    security_max: {_yaml_val(st['security_max'])}")
+lines.append("")
+
 out.write_text("\n".join(lines), encoding="utf-8")
-print(f"sync-status-from-epics: wrote {out} ({len(keys)} keys)")
+print(f"sync-status-from-epics: wrote {out} ({len(keys)} development keys, {len(epics_output)} epics, {len(stories_output)} stories)")
 PY

package/scripts/validate-skill-catalog.sh

@@ -18,7 +18,7 @@ VIOLATIONS=0
 WARNINGS=0
 
 # Documented naming exceptions (craft-skill REFERENCE.md)
-VERB_NOUN_EXCEPTIONS="grill-me grill-with-docs context7-mcp using-bigpowers deploy"
+VERB_NOUN_EXCEPTIONS="grill-me grill-with-docs context7-mcp using-bigpowers deploy generate-allure-report"
 
 catalog_usage() {
   echo "Usage: bash scripts/validate-skill-catalog.sh [--archive] [--strict] [--skill <name>]"

package/skills/audit-code/SKILL.md

@@ -31,7 +31,7 @@ Apply the full checklist to churn-ranked files in descending order. Files with z
 - Default: full checklist
 - --quick: Run only Supply Chain and Test Coverage. Use for changes under 50 LOC.
 - --gate: Non-interactive mode for automated CI gating (used by build-epic step 6). Exit with non-zero status code (`exit 1`) on ANY checklist failure; `exit 0` only if ALL items pass. Produces a compact pass/fail summary to stderr. On failure, list every ✗ item with reason.
-- --parallel: Run checklist sections in **isolated git worktrees** (e45s18) so concurrent checks cannot corrupt each other's working tree. See [REFERENCE.md](REFERENCE.md) or:
+- --parallel: Run checklist sections in **isolated git worktrees** (e45s18) so concurrent checks cannot corrupt each other's working tree:
 
 ```bash
 bash scripts/lib/parallel-review-worktrees.sh audit-code

package/skills/build-epic/SKILL.md

@@ -35,6 +35,7 @@ Orchestrates the **build** flow for a single epic: survey → plan tasks → kic
 ## Process
 
 1. Read `specs/state.yaml`, `specs/execution-status.yaml`, `specs/release-plan.yaml`, active `specs/epics/eNN-slug/epic.yaml`.
+   - **On story start (step 1):** Write `started_at` ISO 8601 timestamp to `execution-status.yaml` under the story's key in the `stories:` section. The `bp-timing.sh` script already tracks skill-level timings — this is story-level.
 2. **Step 0 — Threat Model:** Run `security-review` against the epic's scope (read from the epic capsule). Output `specs/security/epics/<epic-id>/THREAT_MODEL.md` with surface area, vulnerability categories, risk level, and mitigation guidance.
 3. **Assess Impact (Step 2):** Before writing tasks, run `assess-impact --lightweight` on the proposed change. If the risk score exceeds 7, gate — require a `grill-me` session. Write the impact report to `specs/IMPACT-<epic>-<story>.md`. For net-new code with no existing dependents, skip.
 4. **BCP Tracking (Step 2):** After `plan-work` completes, read the `bcps:` count (Business Complexity Points story size) from the epic capsule and carry it into `state.yaml` as `epic_cycle.story_bcps = N`.
@@ -43,6 +44,15 @@ Orchestrates the **build** flow for a single epic: survey → plan tasks → kic
 6. Run **only the current step** (resume mode) unless user asked for full auto-run.
 7. After step verify passes, increment `epic_cycle.step` in `state.yaml` (or `bash scripts/bp-yaml-set.sh` if available).
 8. On story complete, set `execution-status.yaml` story key to `done`; run `bash scripts/sync-status-from-epics.sh`.
+   - **On story complete (step 8):** Write `completed_at` ISO 8601 timestamp to `execution-status.yaml` under the same story key. Format:
+
+     ```yaml
+     stories:
+       e01s01:
+         status: done
+         started_at: "2026-07-12T16:00:00-03:00"
+         completed_at: "2026-07-12T18:45:00-03:00"
+     ```
 9. **Traceability refresh:** Before step 8 (release-branch), run `bash scripts/trace-stories.sh` to regenerate `specs/traceability-matrix.json`, `specs/TRACEABILITY_LATEST.md`, and the `specs/codebase-wiki/` OKF bundle. Surface dark/orphan/stale findings for the just-built epic in your verify summary. If `scripts/trace-stories.sh` is missing or fails, note "trace skipped" and continue — trace failure must be visible, not silent (blocking is gate-trace's job, e38s06).
 
 9b. **OKF wiki refresh (e39s08):** Before step 8, run maintain-wiki INGEST to refresh the OKF wiki bundle:

package/skills/craft-skill/SKILL.md

@@ -33,7 +33,7 @@ Move process detail into the SKILL.md body or REFERENCE.md — never into `descr
    - Any reference materials to include?
    - What specs/ output does it produce (if any)?
 
-2. **Verify Principles** — Ensure the skill aligns with [PRINCIPLES.md](../docs/PRINCIPLES.md):
+2. **Verify Principles** — Ensure the skill aligns with [PRINCIPLES.md](https://github.com/danielvm-git/bigpowers/blob/main/docs/PRINCIPLES.md):
    - Is it atomic (verb-noun)?
    - Is it "deep" (simple interface, complex internal logic)?
    - Does it include Hard Gates?
@@ -46,7 +46,7 @@ Move process detail into the SKILL.md body or REFERENCE.md — never into `descr
 
    **Auto-skill from library README:** When user provides a library README or API docs URL, extract: triggers, HARD GATEs, verify commands, specs/ output — draft SKILL.md without inventing APIs not in the source.
 
-4. Add `model:` frontmatter (`haiku` | `sonnet` | `opus`) per [model-profiles.md](../docs/references/model-profiles.md).
+4. Add `model:` frontmatter (`haiku` | `sonnet` | `opus`) per [model-profiles.md](https://github.com/danielvm-git/bigpowers/blob/main/docs/references/model-profiles.md).
 
 > **STREAM CONTINUITY** — When writing file content, output in continuous chunks of ~200 lines. Do not pause. Continue immediately until complete. If you need time, emit a placeholder comment rather than going silent.
 

package/skills/elaborate-spec/SKILL.md

@@ -65,7 +65,7 @@ Once the user has answered the main questions, probe for assumptions:
 
 ### 4. Synthesize and confirm
 
-Summarize your understanding in 3–5 bullet points aligned with [countable-story-format.md](file:///Users/danielvm/Developer/bigpowers/countable-story-format.md):
+Summarize your understanding in 3–5 bullet points aligned with [countable-story-format.md](https://github.com/danielvm-git/bigpowers/blob/main/docs/countable-story-format.md):
 - The problem (feeds into §1 Business narrative)
 - The solution and main flow (feeds into §5)
 - The key constraints and alternative flows (feeds into §6)

package/skills/evolve-skill/REFERENCE.md

@@ -9,4 +9,4 @@
 **Evidence:** path/to/benchmark-report.md
 ```
 
-Benchmark repo: `/Users/danielvm/Developer/bigpowers-benchmark/`
+Benchmark repo: `bigpowers-benchmark` — resolve the local clone on this machine (e.g. `gh repo clone danielvm-git/bigpowers-benchmark` if absent); never assume a hard-coded absolute path.

package/skills/generate-allure-report/REFERENCE.md

@@ -0,0 +1,243 @@
+# generate-allure-report — Reference
+
+## Data Sources
+
+The script reads five YAML sources from the project:
+
+| Source | Path | Fields Used |
+|--------|------|-------------|
+| Execution status | `specs/execution-status.yaml` | `epics`, `stories`, `development_status` |
+| Release plan | `specs/release-plan.yaml` | `release.version`, `release.status`, `bugs` summary |
+| Epic capsules | `specs/epics/**/epic.yaml` + `-tasks.yaml` | Epic metadata, task pass/fail counts |
+| Cycle times | `specs/metrics/cycle-times.yaml` | Story-level `cycle_minutes`, `bcp_per_hour`, `source` |
+| Bug registry | `specs/bugs/registry.yaml` | Bug counts by status and severity |
+
+## Script Body
+
+`scripts/generate-allure-report.sh`:
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+source "$(dirname "${BASH_SOURCE[0]}")/lib/python-env.sh"
+ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" || ROOT="$(dirname "${BASH_SOURCE[0]}")/.."
+
+mkdir -p "$ROOT/allure-results"
+
+$PYTHON - "$ROOT" <<'PY'
+import json
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+root = Path(sys.argv[1])
+out = root / "allure-results"
+
+# 1. Read execution-status.yaml
+exec_status_file = root / "specs" / "execution-status.yaml"
+release_plan_file = root / "specs" / "release-plan.yaml"
+cycle_times_file = root / "specs" / "metrics" / "cycle-times.yaml"
+bugs_registry_file = root / "specs" / "bugs" / "registry.yaml"
+
+sys.path.insert(0, str(root / "scripts" / "lib"))
+from simple_yaml import parse_simple_yaml
+
+exec_status = parse_simple_yaml(exec_status_file.read_text()) if exec_status_file.exists() else {}
+release_plan = parse_simple_yaml(release_plan_file.read_text()) if release_plan_file.exists() else {}
+cycle_times = parse_simple_yaml(cycle_times_file.read_text()) if cycle_times_file.exists() else {"stories": []}
+bugs_registry = parse_simple_yaml(bugs_registry_file.read_text()) if bugs_registry_file.exists() else {"bugs": []}
+
+# Build cycle-times lookup
+ct_lookup = {}
+for ct in cycle_times.get("stories", []):
+    if isinstance(ct, dict):
+        ct_lookup[ct.get("id", "")] = ct
+
+# 2. Build JUnit XML
+stories = exec_status.get("stories", {})
+
+# Counts for testsuite attributes
+total_stories = len(stories)
+incomplete = sum(1 for s in stories.values() if isinstance(s, dict) and s.get("status") != "done")
+
+testsuite = ET.Element("testsuite", {
+    "name": "bigpowers-epic-progress",
+    "tests": str(total_stories),
+    "failures": str(incomplete),
+    "errors": "0",
+    "skipped": "0",
+})
+
+for story_id in sorted(stories.keys()):
+    story = stories[story_id]
+    if not isinstance(story, dict):
+        continue
+
+    epic_id = story.get("epic", "unknown")
+    title = story.get("title", story_id)
+    bcps = story.get("bcps", 0)
+    status = story.get("status", "backlog")
+    risk_max = story.get("risk_max", "none")
+    security_max = story.get("security_max", "none")
+
+    # Enrich with cycle-times data
+    ct_data = ct_lookup.get(story_id, {})
+    cycle_minutes = ct_data.get("cycle_minutes", 0)
+    bcp_per_hour = ct_data.get("bcp_per_hour", 0)
+
+    # Time: cycle_minutes * 60 for seconds in Allure display
+    time_seconds = cycle_minutes * 60.0 if cycle_minutes else 0.0
+
+    testcase = ET.SubElement(testsuite, "testcase", {
+        "classname": epic_id,
+        "name": f"{story_id}: {title}",
+        "time": str(round(time_seconds, 3)),
+    })
+
+    props = ET.SubElement(testcase, "properties")
+    ET.SubElement(props, "property", {"name": "risk", "value": risk_max})
+    ET.SubElement(props, "property", {"name": "security", "value": security_max})
+    ET.SubElement(props, "property", {"name": "bcps", "value": str(bcps)})
+    ET.SubElement(props, "property", {"name": "status", "value": status})
+    ET.SubElement(props, "property", {"name": "bcp_per_hour", "value": str(bcp_per_hour)})
+    ET.SubElement(props, "property", {"name": "lead_time_minutes", "value": str(cycle_minutes)})
+
+    if status != "done":
+        ET.SubElement(testcase, "failure", {
+            "message": f"Story {story_id} is {status} [risk={risk_max}, security={security_max}]",
+            "type": "StoryIncomplete"
+        })
+
+tree = ET.ElementTree(testsuite)
+ET.indent(tree, space="  ")
+tree.write(str(out / "junit-results.xml"), encoding="utf-8", xml_declaration=True)
+
+# 3. Build categories.json
+epics = exec_status.get("epics", {})
+categories = []
+
+for epic_id in sorted(epics.keys()):
+    epic = epics[epic_id]
+    if isinstance(epic, dict) and epic.get("status") != "done":
+        categories.append({
+            "name": f"Epic: {epic.get('title', epic_id)}",
+            "matchedStatuses": ["failed"],
+            "messageRegex": f".*{epic_id}:.*"
+        })
+
+categories.append({
+    "name": "P0 Risk",
+    "matchedStatuses": ["failed"],
+    "messageRegex": ".*risk.*P0.*"
+})
+categories.append({
+    "name": "Security Review",
+    "matchedStatuses": ["failed"],
+    "messageRegex": ".*security.*(?:medium|high).*"
+})
+
+# Add bug-based categories
+bug_list = bugs_registry.get("bugs", [])
+bug_count = len(bug_list) if isinstance(bug_list, list) else 0
+open_bugs = sum(1 for b in bug_list if isinstance(b, dict) and b.get("status") not in ("fixed", "closed", None))
+if open_bugs > 0:
+    categories.append({
+        "name": "Open Bugs",
+        "matchedStatuses": ["failed"],
+        "messageRegex": ".*Bug.*"
+    })
+
+(out / "categories.json").write_text(json.dumps(categories, indent=2))
+
+# 4. Build executor.json
+rl = release_plan.get("release", {}) if isinstance(release_plan.get("release"), dict) else {}
+executor = {
+    "name": "bigpowers",
+    "type": "bigpowers",
+    "buildName": rl.get("version", "unknown") if isinstance(rl, dict) else "unknown",
+    "buildOrder": len(exec_status.get("development_status", {})),
+}
+(out / "executor.json").write_text(json.dumps(executor, indent=2))
+
+# Summary
+epic_count = len([e for e in epics.values() if isinstance(e, dict) and e.get("status") == "done"])
+total_epics = len(epics)
+print(f"generate-allure-report: {total_stories} stories, {epic_count}/{total_epics} epics done, {bug_count} bugs")
+print(f"  -> {out}/junit-results.xml")
+print(f"  -> {out}/categories.json")
+print(f"  -> {out}/executor.json")
+PY
+```
+
+## JUnit XML Schema
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<testsuite name="bigpowers-epic-progress" tests="N" failures="F" errors="0" skipped="0">
+  <testcase classname="e01" name="e01s01: Security slopcheck tags" time="0.75">
+    <properties>
+      <property name="risk" value="none"/>
+      <property name="security" value="none"/>
+      <property name="bcps" value="1"/>
+      <property name="status" value="done"/>
+      <property name="bcp_per_hour" value="1.3"/>
+      <property name="lead_time_minutes" value="45"/>
+    </properties>
+  </testcase>
+  <testcase classname="e01" name="e01s99: Some incomplete story" time="0.0">
+    <properties>...</properties>
+    <failure message="Story e01s99 is backlog [risk=P0, security=high]" type="StoryIncomplete"/>
+  </testcase>
+</testsuite>
+```
+
+## Categories JSON Schema
+
+```json
+[
+  {
+    "name": "Epic: Quality Core - Skill Hardening",
+    "matchedStatuses": ["failed"],
+    "messageRegex": ".*e45:.*"
+  },
+  {
+    "name": "P0 Risk",
+    "matchedStatuses": ["failed"],
+    "messageRegex": ".*risk.*P0.*"
+  },
+  {
+    "name": "Security Review",
+    "matchedStatuses": ["failed"],
+    "messageRegex": ".*security.*(?:medium|high).*"
+  }
+]
+```
+
+## Executor JSON Schema
+
+```json
+{
+  "name": "bigpowers",
+  "type": "bigpowers",
+  "buildName": "2.76.2",
+  "buildOrder": 400
+}
+```
+
+## Example Usage
+
+```bash
+# Generate reports
+bash scripts/generate-allure-report.sh
+
+# Verify output
+test -f allure-results/junit-results.xml && echo "JUnit OK"
+test -f allure-results/categories.json && echo "Categories OK"
+test -f allure-results/executor.json && echo "Executor OK"
+
+# Serve with Allure
+allure serve allure-results/
+
+# Or open the Allure TestOps UI
+allure open allure-results/
+```

package/skills/generate-allure-report/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: generate-allure-report
+model: sonnet
+effort: standard
+description: "Generate Allure-ready reports from bigpowers YAML metadata. Reads execution-status.yaml, release-plan.yaml, epic capsules, task YAMLs, cycle-times.yaml, and bug registry to produce allure-results/junit-results.xml, categories.json, and executor.json. Use when preparing progress dashboards, integrating with Allure TestOps, or generating CI reports."
+---
+
+# Generate Allure Report
+
+Generate Allure TestOps-compatible reports from bigpowers project metadata. Produces JUnit XML for story-level test results, custom categories for filtering, and executor metadata — all in the `allure-results/` directory.
+
+## Quick Start
+
+```bash
+bash scripts/generate-allure-report.sh
+```
+
+## What It Produces
+
+Three files in `allure-results/`:
+
+| File | Description |
+|------|-------------|
+| `junit-results.xml` | One `<testcase>` per story with `<properties>` for risk, security, WSJF, tier, wave, and status. Incomplete stories get a `<failure>` element. |
+| `categories.json` | Custom Allure categories for filtering by epic, risk level (P0), and security reviews. |
+| `executor.json` | Build metadata — name, type, version from release-plan.yaml, build order. |
+
+## Data Sources
+
+See [REFERENCE.md](REFERENCE.md)
+
+## Verify
+
+```bash
+test -f allure-results/junit-results.xml && test -f allure-results/categories.json && test -f allure-results/executor.json
+```
+
+## Handoff
+
+- next_skill: null (terminal skill — no downstream workflow step)

package/skills/grill-me/REFERENCE.md

@@ -43,7 +43,7 @@ Ask one question at a time. For each challenge, cite the specific URL and sectio
 
 When an assumption doesn't match the docs:
 
-> "Your plan uses `library.doThing(a, b)` but the [docs](URL) show the signature is `doThing(config: {a, b})` with a config object. This will fail at runtime."
+> "Your plan uses `library.doThing(a, b)` but the [docs](https://example.com/api-reference) show the signature is `doThing(config: {a, b})` with a config object. This will fail at runtime."
 
 Document each discrepancy clearly.