bigpowers 2.76.3 → 2.77.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.76.3",
+  "version": "2.77.0",
   "description": "73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "main": "index.js",
   "scripts": {

package/scripts/generate-allure-report.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+# story: e76
+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"
+
+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
+
+# Build JUnit XML
+stories = exec_status.get("stories", {})
+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")
+
+    ct_data = ct_lookup.get(story_id, {})
+    cycle_minutes = ct_data.get("cycle_minutes", 0) if isinstance(ct_data, dict) else 0
+    bcp_per_hour = ct_data.get("bcp_per_hour", 0) if isinstance(ct_data, dict) else 0
+
+    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)
+
+# 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).*"
+})
+
+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))
+
+# Executor JSON
+rl = release_plan.get("release", {})
+if not isinstance(rl, dict):
+    rl = {}
+executor = {
+    "name": "bigpowers",
+    "type": "bigpowers",
+    "buildName": rl.get("version", "unknown"),
+    "buildOrder": len(exec_status.get("development_status", {})),
+}
+(out / "executor.json").write_text(json.dumps(executor, indent=2))
+
+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

package/scripts/record-cycle-time.sh

@@ -50,6 +50,7 @@ STORY_KEY="Story"
 # git-hours engine — partition + whole_range_hours (additivity oracle)
 true && source "$(dirname "${BASH_SOURCE[0]}")/lib/git-hours.sh"
 true && source "$(dirname "${BASH_SOURCE[0]}")/lib/record-cycle-time-lib.sh"
+true && source "$(dirname "${BASH_SOURCE[0]}")/lib/python-env.sh"
 
 die() { record_cycle_die "$@"; }
 usage_cycle() { record_cycle_usage; }
@@ -256,6 +257,33 @@ cmd_append() {
   } >> "$file"
 
   echo "record-cycle-time: OKF bundle written for $story → $file (effort=$eff h, lead=$lead_min min, commits=$count)"
+
+  # Also update execution-status.yaml with cycle-time data
+  local exec_yaml="$ROOT/specs/execution-status.yaml"
+  if [ -f "$exec_yaml" ]; then
+    # Compute bcp_per_hour: bcps / effort_hours, handle zero effort
+    local bph
+    bph="$(awk -v b="$bcps" -v e="$eff" 'BEGIN{if(e>0)printf "%.1f", b/e; else print "0.0"}')"
+
+    $PYTHON -c "
+import sys
+sys.path.insert(0, '$ROOT/scripts/lib')
+import yaml
+try:
+    with open('$exec_yaml') as f:
+        data = yaml.safe_load(f) or {}
+except: data = {}
+
+stories = data.setdefault('stories', {})
+entry = stories.setdefault('$story', {})
+entry['effort_hours'] = float('$eff')
+entry['lead_time_minutes'] = int('$lead_min')
+entry['bcp_per_hour'] = float('$bph')
+
+with open('$exec_yaml', 'w') as f:
+    yaml.dump(data, f, default_flow_style=False, sort_keys=False, allow_unicode=True)
+" 2>/dev/null || echo "WARN: could not update execution-status.yaml with cycle-time data" >&2
+  fi
 }
 
 [ $# -ge 1 ] || { usage_cycle; }

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/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: