From 76bc45c42a87a600e14a49085a7092df5ca69575 Mon Sep 17 00:00:00 2001 From: PhucMN Date: Fri, 16 Oct 2026 13:52:44 +0700 Subject: [PATCH 1/8] =?UTF-8?q?=E2=9C=A8=20[feat]=20forge:=20gitea=20adapt?= =?UTF-8?q?er=20core=20=E2=80=94=20resolution,=20reads,=20tea=20stub?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - super-board-forge.py/.sh: one source of truth for github|gitea (env → config → remote → default github), read/write dispatch, shared halt discipline - super-board-gitea-read.py: bounded read-only Gitea evidence via tea; same CLI, kinds, exit codes (79/64) and halt file as github-read; composite reads normalize to the github shapes (items/fields/quota/approval…) - super-board-gitea-api.sh: low-level tea api writes with SB_GITEA_TIMEOUT-bounded spawns and label create/attach - evals/_stubs/bin/tea: stateful offline tea stub (fixtures + tea-state.json, calls/writes logs, rate-limit headers) - config-schema: forge/forge_host/forge_login keys; setup.py BIN + parse_remote; install.sh copies the new scripts - tests: test_forge.py, test-forge.sh, test_gitea_reads.py, test-gitea-api.sh (all offline) Co-Authored-By: Claude Code --- evals/_stubs/bin/tea | 283 +++++++++ install.sh | 2 +- scripts/super-board-forge.py | 168 +++++ scripts/super-board-forge.sh | 110 ++++ scripts/super-board-gitea-api.sh | 86 +++ scripts/super-board-gitea-read.py | 573 ++++++++++++++++++ scripts/super-board-setup.py | 21 +- .../super-board/references/config-schema.json | 16 + tests/test-forge.sh | 162 +++++ tests/test-gitea-api.sh | 79 +++ tests/test_forge.py | 160 +++++ tests/test_gitea_reads.py | 265 ++++++++ 12 files changed, 1921 insertions(+), 4 deletions(-) create mode 100755 evals/_stubs/bin/tea create mode 100755 scripts/super-board-forge.py create mode 100755 scripts/super-board-forge.sh create mode 100755 scripts/super-board-gitea-api.sh create mode 100755 scripts/super-board-gitea-read.py create mode 100755 tests/test-forge.sh create mode 100755 tests/test-gitea-api.sh create mode 100644 tests/test_forge.py create mode 100644 tests/test_gitea_reads.py diff --git a/evals/_stubs/bin/tea b/evals/_stubs/bin/tea new file mode 100755 index 00000000..466e0864 --- /dev/null +++ b/evals/_stubs/bin/tea @@ -0,0 +1,283 @@ +#!/usr/bin/env bash +# Offline `tea` stand-in for evals and tests. Stateful: reads/writes +# /.git/tea-state.json (seeded from /.git/tea-fixture/ on first +# call), logs every call to /.git/tea-calls.log and every write to +# /.git/tea-writes.log, and never touches the network. +# +# Only the surface the gitea adapter uses is implemented: +# tea --version · tea login ls +# tea api [-X M] [-d json] [-i] [--login L] +# Endpoints may carry literal {owner}/{repo} placeholders; they are expanded +# from $GITEA_REPO like the real `tea api` does. +# +# State shape (.git/tea-state.json): +# {issues:[gitea issue objects + stub-only _column], pulls:[…], labels:[…], +# projects:[{id,title}], columns:[{id,title,color}], comments:{"":[…]}} +# Fixture seeds (all optional): issues.json pulls.json labels.json projects.json +# columns.json board.json ([{column:, numbers:[…]}] → sets _column) +# pull--files.json pull-.diff version.json user.json repo.json +# no-ratelimit (existence → -i prints no X-RateLimit-* headers) +set -uo pipefail +ROOT="$PWD" +while [ "$ROOT" != / ] && [ ! -d "$ROOT/.git" ]; do ROOT="$(dirname "$ROOT")"; done +[ -d "$ROOT/.git" ] || ROOT="$PWD" +FX="$ROOT/.git/tea-fixture" +STATE="$ROOT/.git/tea-state.json" +printf '%s\n' "tea $*" >>"$ROOT/.git/tea-calls.log" + +# ── args: drop global flags, find the subcommand ───────────────────────────── +args=(); skip=0 +for a in "$@"; do + if [ "$skip" = 1 ]; then skip=0; continue; fi + case "$a" in + --login|--config) skip=1 ;; + *) args+=("$a") ;; + esac +done +CMD="${args[0]:-}" + +case "$CMD" in + --version|-v) echo "tea version 0.16.0 (eval stub)"; exit 0 ;; + version) echo "0.16.0 (eval stub)"; exit 0 ;; +esac +if [ "$CMD" = login ]; then echo "eval-stub (https://gitea.example.com) "; exit 0; fi +[ "$CMD" = api ] || { echo "ok (eval stub)"; exit 0; } + +# ── parse `api` ─────────────────────────────────────────────────────────────── +METHOD="GET"; BODY=""; HEADERS=0; ENDPOINT="" +rest=("${args[@]:1}"); i=0 +while [ $i -lt ${#rest[@]} ]; do + a="${rest[$i]}" + case "$a" in + -X|--method) METHOD="${rest[$((i+1))]}"; i=$((i+2)); continue ;; + -d|--data) BODY="${rest[$((i+1))]}"; i=$((i+2)); continue ;; + -i) HEADERS=1; i=$((i+1)); continue ;; + -f|-F) i=$((i+2)); continue ;; + -*) i=$((i+1)); continue ;; + *) ENDPOINT="$a"; i=$((i+1)) ;; + esac +done +[ -n "$ENDPOINT" ] || { echo "tea stub: api without endpoint" >&2; exit 64; } +# placeholder expansion, like real tea with a repo context +if [ -n "${GITEA_REPO:-}" ]; then + ENDPOINT="${ENDPOINT//\{owner\}/${GITEA_REPO%%/*}}" + ENDPOINT="${ENDPOINT//\{repo\}/${GITEA_REPO##*/}}" +fi +PATHPART="${ENDPOINT%%\?*}"; QUERY="" +[ "$PATHPART" = "$ENDPOINT" ] || QUERY="${ENDPOINT#*\?}" +PATHPART="${PATHPART#/}" # accept a leading slash +q() { # q → query param value + local kv + local -a _qs=() + IFS='&' read -ra _qs <<<"$QUERY" + for kv in ${_qs+"${_qs[@]}"}; do case "$kv" in "$1="*) echo "${kv#*=}"; return ;; esac; done + echo "" +} +segs() { local s=${PATHPART//[^\/]/}; echo $(( ${#s} + 1 )); } +seg() { # seg <1-based index> + local IFS='/'; local -a p=($PATHPART); echo "${p[$(( $1 - 1 ))]:-}"; +} + +# ── state ───────────────────────────────────────────────────────────────────── +fx() { [ -f "$FX/$1" ] && cat "$FX/$1"; } +seed_state() { + local issues pulls labels projects columns board + issues=$(fx issues.json); pulls=$(fx pulls.json); labels=$(fx labels.json) + projects=$(fx projects.json); columns=$(fx columns.json); board=$(fx board.json) + jq -cn \ + --argjson issues "${issues:-[]}" --argjson pulls "${pulls:-[]}" \ + --argjson labels "${labels:-[]}" --argjson projects "${projects:-[]}" \ + --argjson columns "${columns:-[]}" --argjson board "${board:-[]}" '{ + issues: [ $issues[] | . as $it + | ($board | map(select(.numbers | index($it.number))) | (.[0].column // null)) as $c + | if $c then ._column = $c else . end ], + pulls: $pulls, labels: $labels, projects: $projects, columns: $columns, + comments: {}, writes: 0 }' +} +[ -s "$STATE" ] || seed_state > "$STATE" +state() { jq "$@" "$STATE"; } +put_state() { local tmp; tmp=$(mktemp "$STATE.XXXXXX") && jq "$@" "$STATE" > "$tmp" && mv "$tmp" "$STATE"; } +log_write() { printf '%s %s %s\n' "$METHOD" "$PATHPART" "$BODY" >> "$ROOT/.git/tea-writes.log"; } +fail_http() { echo "ServerError: $1 $2 (eval stub)" >&2; exit 1; } + +emit_headers() { + [ "$HEADERS" = 1 ] || return 0 + { echo "HTTP/1.1 200 OK" + if [ ! -e "$FX/no-ratelimit" ]; then + echo "X-RateLimit-Limit: 3600" + echo "X-RateLimit-Remaining: 3597" + echo "X-RateLimit-Reset: $(( $(date +%s) + 3600 ))" + fi + } >&2 +} + +strip() { jq -c 'walk(if type == "object" then del(._column) else . end)'; } +page_slice() { # page_slice → the requested page + local p l; p=$(q page); l=$(q limit); p=${p:-1}; l=${l:-30} + jq -c --argjson s "$(( (p - 1) * l ))" --argjson l "$l" '.[$s:$s+$l]' +} + +# ── GET routes (specific first; `*` spans slashes in case globs) ───────────── +if [ "$METHOD" = GET ]; then + case "$PATHPART" in + version) emit_headers; fx version.json || echo '{"version":"1.25.0 (eval stub)"}'; exit 0 ;; + user) emit_headers; fx user.json || echo '{"login":"eval-bot"}'; exit 0 ;; + esac + case "$PATHPART" in + repos/*/*/projects/*/columns/*/issues) + emit_headers; cid=$(seg 7) + state -c --argjson c "$cid" '[ .issues[] | select((._column // null) == $c) ]' | strip | page_slice; exit 0 ;; + repos/*/*/projects/*/columns) + emit_headers; state -c '.columns'; exit 0 ;; + repos/*/*/projects/*) + emit_headers; pid=$(seg 5) + out=$(state -c --argjson p "$pid" '.projects[] | select(.id == $p)') + [ -n "$out" ] && echo "$out" || fail_http 404 "project $pid"; exit 0 ;; + repos/*/*/projects) + emit_headers; state -c '.projects'; exit 0 ;; + repos/*/*/issues/*/comments) + emit_headers; n=$(seg 5) + state -c --arg n "$n" '.comments[$n] // []' | page_slice; exit 0 ;; + repos/*/*/issues/*) + emit_headers; n=$(seg 5) + case "$n" in ''|*[!0-9]*) echo '{}'; exit 0 ;; esac + out=$(state -c --argjson n "$n" '[ .issues[] | select(.number == $n) ] | .[0] // empty' | strip) + [ -n "$out" ] && echo "$out" || fail_http 404 "issue $n"; exit 0 ;; + repos/*/*/issues) + emit_headers; st=$(q state); ty=$(q type) + state -c --arg st "${st:-open}" --arg ty "$ty" ' + [ .issues[] + | select(($st == "all") or ((.state // "open") == $st)) + | select(($ty != "issues") or ((.pull_request // null) == null)) ]' | strip | page_slice; exit 0 ;; + repos/*/*/pulls/*.diff) + n=$(seg 5); n=${n%%.*} + fx "pull-$n.diff" || echo ""; exit 0 ;; + repos/*/*/pulls/*/files) + emit_headers; n=$(seg 5) + fx "pull-$n-files.json" || echo '[]'; exit 0 ;; + repos/*/*/pulls/*/merge) echo '{}' ; exit 0 ;; + repos/*/*/pulls/*) + emit_headers; n=$(seg 5) + out=$(state -c --argjson n "$n" '.pulls[] | select(.number == $n)') + [ -n "$out" ] && echo "$out" || fail_http 404 "pull $n"; exit 0 ;; + repos/*/*/pulls) + emit_headers; st=$(q state) + state -c --arg st "${st:-open}" '[ .pulls[] | select(($st == "all") or ((.state // "open") == $st)) ]' | page_slice; exit 0 ;; + repos/*/*/labels) + emit_headers; state -c '.labels'; exit 0 ;; + esac + if [ "$(segs)" = 3 ]; then # bare repo read: repos// + emit_headers + fx repo.json || echo '{"full_name":"'"${GITEA_REPO:-example/shop}"'","default_branch":"main","permissions":{"admin":true,"push":true,"pull":true}}' + exit 0 + fi + emit_headers; echo '{}'; exit 0 +fi + +# ── writes ──────────────────────────────────────────────────────────────────── +log_write +[ -n "$BODY" ] || BODY='{}' +case "$PATHPART" in + repos/*/*/issues) # POST create + [ "$METHOD" = POST ] || { echo '{}'; exit 0; } + put_state --argjson b "$BODY" ' + (1 + ([ .issues[].number ] + [0] | max)) as $n | (1 + ([ .issues[].id ] + [0] | max)) as $id | + .issues += [{ id: $id, number: $n, title: ($b.title // ""), body: ($b.body // ""), + state: "open", labels: [], html_url: ("https://gitea.example/issues/" + ($n|tostring)), + created_at: "2026-01-01T00:00:00Z", updated_at: "2026-01-01T00:00:00Z" }] | + .writes += 1' + state -c '.issues[-1]' | strip ;; + repos/*/*/projects/*/columns/*/issues/*) # POST add issue to column + gid=$(seg 9); cid=$(seg 7) + put_state --argjson g "$gid" --argjson c "$cid" ' + .issues = [ .issues[] | if .id == $g then ._column = $c else . end ] | .writes += 1' + echo '{}' ;; + repos/*/*/projects/*/issues/*/move) # POST move between columns + gid=$(seg 7); cid=$(jq -r '.column_id // empty' <<<"$BODY") + state -e --argjson g "$gid" 'any(.issues[]; .id == $g)' >/dev/null || fail_http 404 "issue $gid not found" + [ -n "$cid" ] || fail_http 422 "column_id required" + put_state --argjson g "$gid" --argjson c "$cid" ' + .issues = [ .issues[] | if .id == $g then ._column = $c else . end ] | .writes += 1' + echo "" ;; # 204 + repos/*/*/projects/*/columns) # POST create column + put_state --argjson b "$BODY" ' + (1 + ([ .columns[].id ] + [0] | max)) as $id | + .columns += [{ id: $id, title: ($b.title // ""), color: ($b.color // "") }] | .writes += 1' + state -c '.columns[-1]' ;; + repos/*/*/projects) # POST create project + put_state --argjson b "$BODY" ' + (1 + ([ .projects[].id ] + [0] | max)) as $id | + .projects += [{ id: $id, title: ($b.title // "") }] | .writes += 1' + state -c '.projects[-1]' ;; + repos/*/*/issues/*/comments) # POST comment + n=$(seg 5) + put_state --arg n "$n" --argjson b "$BODY" ' + (1 + ([ .comments[][]?.id ] + [0] | max)) as $id | + .comments[$n] = ((.comments[$n] // []) + [{ id: $id, body: ($b.body // ""), + user: { login: "eval-bot" }, created_at: "2026-01-01T00:00:00Z", updated_at: "2026-01-01T00:00:00Z" }]) | + .writes += 1' + state -c --arg n "$n" '.comments[$n][-1]' ;; + repos/*/*/issues/*/labels*) # POST attach / DELETE remove label ids + n=$(seg 5) + if [ "$METHOD" = DELETE ]; then + lid=${PATHPART##*/labels/} + put_state --argjson n "$n" --argjson l "${lid:-0}" ' + .issues = [ .issues[] | if .number == $n then + .labels = [ (.labels // [])[] | select(.id != $l) ] else . end ] | .writes += 1' + else + put_state --argjson n "$n" --argjson b "$BODY" ' + ($b.labels // []) as $ids | + ([ .labels[] | select(.id as $i | $ids | index($i)) ]) as $add | + .issues = [ .issues[] | if .number == $n then + .labels = (((.labels // []) + $add) | unique_by(.id)) else . end ] | .writes += 1' + fi + state -c --argjson n "$n" '[ .issues[] | select(.number == $n) | .labels // [] ] | .[0] // []' ;; + repos/*/*/issues/*/assignees) # POST add / DELETE remove assignees + n=$(seg 5) + if [ "$METHOD" = DELETE ]; then + put_state --argjson n "$n" --argjson b "$BODY" ' + ($b.assignees // []) as $l | + .issues = [ .issues[] | if .number == $n then + .assignees = [ (.assignees // [])[] | select(.login as $x | $l | index($x) | not) ] else . end ] | .writes += 1' + else + put_state --argjson n "$n" --argjson b "$BODY" ' + ($b.assignees // []) as $l | + .issues = [ .issues[] | if .number == $n then + .assignees = (((.assignees // []) + [ $l[] | { login: . } ]) | unique_by(.login)) else . end ] | .writes += 1' + fi + state -c --argjson n "$n" '[ .issues[] | select(.number == $n) | .assignees // [] ] | .[0] // []' ;; + repos/*/*/labels) # POST create label (after the deeper issues/*/labels route: + # case globs span slashes, so this bare pattern would swallow it) + [ "$METHOD" = POST ] || { echo '{}'; exit 0; } + name=$(jq -r '.name // ""' <<<"$BODY") + state -e --arg n "$name" 'any(.labels[]; .name == $n) | not' >/dev/null || fail_http 422 "label already exists" + put_state --argjson b "$BODY" ' + (1 + ([ .labels[].id ] + [0] | max)) as $id | + .labels += [{ id: $id, name: ($b.name // ""), color: ($b.color // "#ededed") }] | .writes += 1' + state -c '.labels[-1]' ;; + repos/*/*/pulls/*/merge) # POST merge + n=$(seg 5) + want=$(jq -r '.head_commit_id // empty' <<<"$BODY") + head=$(state -r --argjson n "$n" '[ .pulls[] | select(.number == $n) | .head.sha // empty ] | .[0] // empty') + if [ -n "$want" ] && [ -n "$head" ] && [ "$want" != "$head" ]; then + fail_http 409 "head_commit_id mismatch"; fi + sha="merge$(printf '%036d' "$n")" + put_state --argjson n "$n" --arg s "$sha" ' + .pulls = [ .pulls[] | if .number == $n then + .merged = true | .state = "closed" | .merge_commit_sha = $s else . end ] | .writes += 1' + echo '{}' ;; + repos/*/*/pulls/*) # PATCH pull (body etc.) + [ "$METHOD" = PATCH ] || { echo '{}'; exit 0; } + n=$(seg 5) + put_state --argjson n "$n" --argjson b "$BODY" ' + .pulls = [ .pulls[] | if .number == $n then . * $b else . end ] | .writes += 1' + state -c --argjson n "$n" '.pulls[] | select(.number == $n)' ;; + repos/*/*/issues/*) # PATCH issue + [ "$METHOD" = PATCH ] || { echo '{}'; exit 0; } + n=$(seg 5) + put_state --argjson n "$n" --argjson b "$BODY" ' + .issues = [ .issues[] | if .number == $n then . * $b else . end ] | .writes += 1' + state -c --argjson n "$n" '.issues[] | select(.number == $n)' | strip ;; + *) echo '{}' ;; +esac +exit 0 diff --git a/install.sh b/install.sh index 009fbe83..7be9c296 100755 --- a/install.sh +++ b/install.sh @@ -145,7 +145,7 @@ copy_file() { fi } -for script in super-board-project-verifier.py super-board-skills-ready.py super-board-calibration.py super-board-verification-ready.py super-board-github-read.py super-board-collect-state.py super-board-run.sh super-board-gh-guard.sh super-board-card.sh super-board-status.py super-board-wave-plan.sh super-board-codex-lane.sh super-board-codex-wave.sh super-board-deps.sh super-board-preflight.sh super-board-merge-gate.sh super-board-merge-policy.py super-board-approval.py super-board-env-check.sh super-board-agents-md.py super-board-settings.py super-board-setup.py super-board-usage.sh super-board-throttle.sh super-board-host.sh super-board-pr-body.sh super-review-file-refactor.sh super-qa-file-bug.sh super-board-stop.sh; do +for script in super-board-project-verifier.py super-board-skills-ready.py super-board-calibration.py super-board-verification-ready.py super-board-github-read.py super-board-forge.py super-board-forge.sh super-board-gitea-api.sh super-board-gitea-read.py super-board-collect-state.py super-board-run.sh super-board-gh-guard.sh super-board-card.sh super-board-status.py super-board-wave-plan.sh super-board-codex-lane.sh super-board-codex-wave.sh super-board-deps.sh super-board-preflight.sh super-board-merge-gate.sh super-board-merge-policy.py super-board-approval.py super-board-env-check.sh super-board-agents-md.py super-board-settings.py super-board-setup.py super-board-usage.sh super-board-throttle.sh super-board-host.sh super-board-pr-body.sh super-review-file-refactor.sh super-qa-file-bug.sh super-board-stop.sh; do if [ -f "$REPO_ROOT/scripts/$script" ]; then copy_file "$REPO_ROOT/scripts/$script" "$TARGET/.claude/bin/$script" chmod +x "$TARGET/.claude/bin/$script" diff --git a/scripts/super-board-forge.py b/scripts/super-board-forge.py new file mode 100755 index 00000000..addb17bd --- /dev/null +++ b/scripts/super-board-forge.py @@ -0,0 +1,168 @@ +#!/usr/bin/env python3 +"""Forge resolution: which host the board talks to, and where. + +One source of truth for `github` vs `gitea`. Precedence, highest first: +environment (SB_FORGE / SB_FORGE_HOST / SB_FORGE_LOGIN) → config keys +(forge / forge_host / forge_login) → the git remote's host (advisory: it +fills owner/repo and a gitea host, but never flips the forge kind on its +own) → default `github`. + +`project.owner` stays the account that owns the board; owner/repo fall back +to parsing `repo.remote` (any host, https/http/ssh/scp forms) and then to +`git remote get-url origin`. A gitea config without a resolvable host exits +66 — scripts must never guess which server to write to. + +Usage: + super-board-forge.py get [--config PATH] [--root DIR] [--json|--shell] + super-board-forge.py forge|host|owner|repo [--config PATH] [--root DIR] + +Exit codes: 0 ok · 64 usage/unknown forge · 66 config missing required value. +""" +from __future__ import annotations + +import argparse +import json +import os +import re +import shlex +import subprocess +import sys + +FORGES = ("github", "gitea") +GITHUB_HOST = "https://github.com" + +# https://host[:port]/owner/repo(.git) · http://… · ssh://git@host[:port]/owner/repo +_URL_RE = re.compile(r'^(https?)://(?:[^@/]+@)?([^/:]+)(?::(\d+))?/(.+?)(?:\.git)?/?$') +_SSH_RE = re.compile(r'^ssh://(?:[^@/]+@)?([^/:]+)(?::(\d+))?/(.+?)(?:\.git)?/?$') +# scp form: git@host:owner/repo(.git) +_SCP_RE = re.compile(r'^(?:[^@/\s]+@)?([^/:@\s]+):(.+?)(?:\.git)?/?$') + + +def parse_remote(url): + """Remote URL → {host, owner, repo} for any forge, or None when unparseable. + + `host` keeps the URL's own scheme and port (a local Gitea is often plain + http on :3000); scp-form remotes are assumed https. + """ + url = (url or "").strip() + if not url: + return None + scheme, netloc, path = None, None, None + m = _URL_RE.match(url) + if m: + scheme, netloc, path = m.group(1), m.group(2), m.group(4) + if m.group(3): + netloc = f"{netloc}:{m.group(3)}" + else: + m = _SSH_RE.match(url) + if m: + scheme, netloc, path = "https", m.group(1), m.group(3) + if m.group(2): + netloc = f"{netloc}:{m.group(2)}" + else: + m = _SCP_RE.match(url) + if m and "/" in m.group(2): + scheme, netloc, path = "https", m.group(1), m.group(2) + if not (scheme and netloc and path): + return None + parts = [p for p in path.strip("/").split("/") if p] + if len(parts) < 2: + return None + owner, repo = parts[-2], parts[-1] + if not re.match(r'^[\w.\-]+$', owner) or not re.match(r'^[\w.\-]+$', repo): + return None + return {"host": f"{scheme}://{netloc}", "owner": owner, "repo": repo} + + +def _git_remote_url(root): + try: + r = subprocess.run(["git", "remote", "get-url", "origin"], cwd=root, + capture_output=True, text=True, timeout=5) + except (OSError, subprocess.TimeoutExpired): + return None + return r.stdout.strip() if r.returncode == 0 else None + + +def resolve(config_path=None, root=None): + """Precedence env → config → remote → default. Returns the forge dict.""" + root = root or os.environ.get("SB_REPO_PATH") or os.getcwd() + cfg = {} + if config_path: + try: + with open(config_path) as f: + cfg = json.load(f) + except (OSError, ValueError): + cfg = {} + if not isinstance(cfg, dict): + cfg = {} + + forge = (os.environ.get("SB_FORGE") or cfg.get("forge") or "").strip().lower() + remote = parse_remote((cfg.get("repo") or {}).get("remote")) or parse_remote(_git_remote_url(root)) + + if not forge: + # The remote's host never flips the kind by itself: an unrecognized + # host stays "github" (today's behavior) until the config says otherwise. + forge = "github" + if forge not in FORGES: + raise ValueError(f"unknown forge \"{forge}\" (expected one of: {', '.join(FORGES)})") + + host = os.environ.get("SB_FORGE_HOST") or cfg.get("forge_host") or "" + if not host: + if forge == "gitea" and remote and "github.com" not in remote["host"]: + host = remote["host"] + elif forge == "github": + host = GITHUB_HOST + host = host.rstrip("/") + + owner = (cfg.get("project") or {}).get("owner") or (remote or {}).get("owner") or "" + repo = (remote or {}).get("repo") or "" + login = os.environ.get("SB_FORGE_LOGIN") or cfg.get("forge_login") or "" + + return {"forge": forge, "host": host, "login": login, "owner": owner, "repo": repo, + "config": os.path.abspath(config_path) if config_path else None} + + +def check(res): + """Post-conditions callers rely on; raises with exit-66 wording.""" + if res["forge"] == "gitea" and not res["host"]: + raise LookupError("forge is gitea but no host resolved — set forge_host in the config, " + "SB_FORGE_HOST, or a git remote pointing at the instance") + + +def main(argv): + ap = argparse.ArgumentParser(add_help=True, description=__doc__.splitlines()[0]) + ap.add_argument("cmd", choices=("get", "forge", "host", "owner", "repo")) + ap.add_argument("--config") + ap.add_argument("--root") + ap.add_argument("--json", action="store_true") + ap.add_argument("--shell", action="store_true", + help="print SB_FORGE_* assignments safe for eval (get only)") + a = ap.parse_args(argv) + + try: + res = resolve(a.config, a.root) + except ValueError as e: # unknown forge → usage + print(str(e), file=sys.stderr) + return 64 + try: + check(res) + except LookupError as e: + print(str(e), file=sys.stderr) + return 66 + + if a.cmd != "get": + print(res[a.cmd]) + return 0 + if a.shell: + print(f"SB_FORGE_KIND={shlex.quote(res['forge'])}") + print(f"SB_FORGE_HOST={shlex.quote(res['host'])}") + print(f"SB_FORGE_LOGIN={shlex.quote(res['login'])}") + print(f"SB_FORGE_OWNER={shlex.quote(res['owner'])}") + print(f"SB_FORGE_REPO={shlex.quote(res['repo'])}") + return 0 + print(json.dumps(res if a.json else {k: v for k, v in res.items() if k != "config"}, indent=1)) + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/scripts/super-board-forge.sh b/scripts/super-board-forge.sh new file mode 100755 index 00000000..3c227c47 --- /dev/null +++ b/scripts/super-board-forge.sh @@ -0,0 +1,110 @@ +#!/usr/bin/env bash +# super-board-forge.sh — forge dispatch for board scripts. +# +# Sourced, never executed. One place decides whether the board talks to GitHub +# (gh + super-board-github-read.py) or Gitea (tea + super-board-gitea-read.py); +# callers keep using the same verbs and the same exit codes (79 halt · 73 +# budget · 69 board · 67 CLI fail). Resolution lives in super-board-forge.py: +# env SB_FORGE/SB_FORGE_HOST/SB_FORGE_LOGIN → config forge/forge_host/ +# forge_login → the git remote → default github. +# +# Usage from a board script: +# source "$(dirname "$0")/super-board-forge.sh" +# sb_forge_resolve "$CONFIG_PATH" # sets+exports SB_FORGE_* (exit 64/66 propagates) +# sb_forge_checkpoint # halt-file check, both forges +# sb_forge_read json -- # bounded read via the forge's wrapper +# sb_forge_write_once issue edit 3 --add-label qa # github gh write +# sb_forge_tea_write POST repos/o/r/issues "labels" '[1]' # gitea REST write +# sb_forge_label_add 12 bug # add a label on either forge +# +# On gitea, GITEA_REPO=/ is exported so `tea api` expands +# {owner}/{repo} placeholders inside worktrees the same way GH_REPO does for +# `gh api` on GitHub. + +# This file's own path: BASH_SOURCE under bash, the %x prompt escape under zsh. +if [ -n "${BASH_SOURCE[0]:-}" ]; then _sb_forge_src="${BASH_SOURCE[0]}"; else eval '_sb_forge_src="${(%):-%x}"'; fi +SB_FORGE_BIN="$(cd "$(dirname "$_sb_forge_src")" && pwd)"; unset _sb_forge_src +SB_FORGE_PY="$SB_FORGE_BIN/super-board-forge.py" +SB_GITHUB_READ="$SB_FORGE_BIN/super-board-github-read.py" +SB_GITEA_READ="$SB_FORGE_BIN/super-board-gitea-read.py" +SB_GITEA_API="$SB_FORGE_BIN/super-board-gitea-api.sh" + +SB_FORGE_KIND="${SB_FORGE_KIND:-github}" +SB_FORGE_HOST="${SB_FORGE_HOST:-}" +SB_FORGE_LOGIN="${SB_FORGE_LOGIN:-}" +SB_FORGE_OWNER="${SB_FORGE_OWNER:-}" +SB_FORGE_REPO="${SB_FORGE_REPO:-}" + +sb_forge_resolve() { + # $1 = config path (optional). Fills SB_FORGE_* from super-board-forge.py. + local assignments rc=0 + assignments=$(python3 "$SB_FORGE_PY" get --shell ${1:+--config "$1"}) || rc=$? + [ "$rc" -eq 0 ] || return "$rc" + eval "$assignments" + export SB_FORGE_KIND SB_FORGE_HOST SB_FORGE_LOGIN SB_FORGE_OWNER SB_FORGE_REPO + if [ "$SB_FORGE_KIND" = "gitea" ] && [ -n "$SB_FORGE_OWNER" ] && [ -n "$SB_FORGE_REPO" ]; then + export GITEA_REPO="$SB_FORGE_OWNER/$SB_FORGE_REPO" + fi + return 0 +} + +sb_forge_read_wrapper() { + if [ "$SB_FORGE_KIND" = "gitea" ]; then + [ -f "$SB_GITEA_READ" ] || { echo "[forge] gitea read wrapper missing: $SB_GITEA_READ" >&2; return 67; } + echo "$SB_GITEA_READ" + else + echo "$SB_GITHUB_READ" + fi +} + +sb_forge_checkpoint() { python3 "$(sb_forge_read_wrapper)" --check; } + +sb_forge_read() { + # Callers pass ` [--] `; the wrappers take `--kind K -- args`. + local kind="$1"; shift + [ "${1:-}" = "--" ] && shift + local wrapper; wrapper=$(sb_forge_read_wrapper) || return $? + python3 "$wrapper" --kind "$kind" -- "$@" +} + +sb_forge_halt() { + # Record an ambiguous write outcome (never retried) on either forge. + local wrapper; wrapper=$(sb_forge_read_wrapper) || return 0 + python3 "$wrapper" --halt "$1" >&2 || true +} + +sb_forge_write_once() { + # GitHub write with halt-on-unknown-outcome. Mirrors run.sh's gh_write_once: + # a FAILED write may or may not have landed, so the run stops (79) and a + # human reconciles instead of a retry doubling it. + sb_forge_checkpoint || return $? + gh "$@" || { + sb_forge_halt "GitHub $1 ${2:-} response failed; reconcile the write before restarting" + return 79 + } +} + +sb_forge_tea_write() { + # Gitea write with the same discipline: [json-body]. + sb_forge_checkpoint || return $? + [ -f "$SB_GITEA_API" ] || { echo "[forge] gitea api helper missing: $SB_GITEA_API" >&2; return 67; } + # shellcheck source=super-board-gitea-api.sh + . "$SB_GITEA_API" + sb_gitea_api "$@" || { + sb_forge_halt "Gitea $1 $2 response failed; reconcile the write before restarting" + return 79 + } +} + +sb_forge_label_add() { + # $1 = issue number, $2 = label name. Creates the label on gitea only when + # missing (no --force there); github's `gh label create --force` idiom stays + # with callers that already use it. + local issue="$1" label="$2" + if [ "$SB_FORGE_KIND" = "gitea" ]; then + . "$SB_GITEA_API" + sb_gitea_label_add "$issue" "$label" + else + sb_forge_write_once issue edit "$issue" --add-label "$label" >/dev/null + fi +} diff --git a/scripts/super-board-gitea-api.sh b/scripts/super-board-gitea-api.sh new file mode 100755 index 00000000..686b0804 --- /dev/null +++ b/scripts/super-board-gitea-api.sh @@ -0,0 +1,86 @@ +#!/usr/bin/env bash +# super-board-gitea-api.sh — low-level Gitea REST calls through `tea api`. +# +# Sourced by super-board-forge.sh and the gitea-side scripts; never executed. +# Every call goes through the tea CLI (v0.16.x pinned semantics): `tea api` +# prefixes /api/v1/, expands {owner}/{repo} from the repo context (GITEA_REPO +# env, exported by forge.sh, or --repo), and `-i` prints response headers to +# STDERR so stdout stays clean JSON. +# +# sb_gitea_api GET repos/{owner}/{repo}/issues +# sb_gitea_api POST repos/{owner}/{repo}/issues '{"title":"…"}' +# sb_gitea_api_headers GET version 2>headers.txt # body stdout, headers stderr +# sb_gitea_label_add 12 bug # resolve/create id, attach +# +# All tea spawns are timeout-bounded (SB_GITEA_TIMEOUT, default 30s) because a +# broken tea binary on Windows hangs instead of failing — a hung board call +# must still surface as exit 67, not a dead worker. + +SB_GITEA_TIMEOUT="${SB_GITEA_TIMEOUT:-30}" + +# Label colors shared with setup.py's LABELS map (github strips the leading #). +SB_GITEA_LABEL_COLORS_qa="0e8a16" +SB_GITEA_LABEL_COLORS_bug="d73a4a" +SB_GITEA_LABEL_COLORS_feature="1d76db" +SB_GITEA_LABEL_DEFAULT_COLOR="ededed" + +sb_gitea_tea() { + # Run tea with a bounded lifetime; prefer coreutils timeout when present. + # SB_GITEA_TEA overrides the executable (tests point it at the offline stub). + local login_flag=() tea_cmd + [ -n "${SB_FORGE_LOGIN:-}" ] && login_flag=(--login "$SB_FORGE_LOGIN") + read -r -a tea_cmd <<< "${SB_GITEA_TEA:-tea}" + if command -v timeout >/dev/null 2>&1; then + timeout "$SB_GITEA_TIMEOUT" "${tea_cmd[@]}" "${login_flag[@]}" "$@" + else + "${tea_cmd[@]}" "${login_flag[@]}" "$@" + fi +} + +sb_gitea_api() { + # [json-body]. JSON on stdout. Non-zero on HTTP/tea failure. + local method="$1" endpoint="$2" body="${3:-}" + if [ -n "$body" ]; then + sb_gitea_tea api -X "$method" -d "$body" "$endpoint" + else + sb_gitea_tea api -X "$method" "$endpoint" + fi +} + +sb_gitea_api_headers() { + # Same as sb_gitea_api plus `-i`: response headers land on stderr (the guard + # reads X-RateLimit-* from there), the body stays clean JSON on stdout. + local method="$1" endpoint="$2" body="${3:-}" + if [ -n "$body" ]; then + sb_gitea_tea api -i -X "$method" -d "$body" "$endpoint" + else + sb_gitea_tea api -i -X "$method" "$endpoint" + fi +} + +sb_gitea_label_id() { + # $1 = label name → prints its id, or nothing when the repo lacks it. + sb_gitea_api GET 'repos/{owner}/{repo}/labels' 2>/dev/null \ + | jq -r --arg n "$1" '.[] | select(.name == $n) | .id' | head -1 +} + +sb_gitea_label_add() { + # $1 = issue number, $2 = label name. Creates the label when missing + # (Gitea's create has no --force; the pre-check is the idempotence). + local issue="$1" label="$2" id color + id=$(sb_gitea_label_id "$label") + if [ -z "$id" ]; then + # Bash indirect lookup, guarded: only plain names can have a color preset. + color="$SB_GITEA_LABEL_DEFAULT_COLOR" + case "$label" in + *[!A-Za-z0-9_-]* | '') : ;; + *) local varname="SB_GITEA_LABEL_COLORS_${label}" + [ -n "${!varname:-}" ] && color="${!varname}" ;; + esac + id=$(sb_gitea_api POST 'repos/{owner}/{repo}/labels' \ + "$(jq -cn --arg n "$label" --arg c "#$color" '{name:$n,color:$c}')" | jq -r '.id') + [ -n "$id" ] && [ "$id" != "null" ] || return 67 + fi + sb_gitea_api POST "repos/{owner}/{repo}/issues/${issue}/labels" \ + "$(jq -cn --argjson id "$id" '{labels:[$id]}')" >/dev/null +} diff --git a/scripts/super-board-gitea-read.py b/scripts/super-board-gitea-read.py new file mode 100755 index 00000000..85e8bb86 --- /dev/null +++ b/scripts/super-board-gitea-read.py @@ -0,0 +1,573 @@ +#!/usr/bin/env python3 +"""Bounded, read-only Gitea evidence through the tea CLI. Exit 79 stops the run. + +The gitea twin of super-board-github-read.py: same CLI surface, same retry +discipline (three attempts, permanent errors stop on the first), same halt +file (.claude/super-board/github-halt.json — one halt per repo, name kept for +compatibility), same exit codes (79 halted, 64 caller's malformed shape). +It reuses github-read's halt machinery and diff validator by importing it. + +Two call styles: + +1. Passthrough — validate whatever a read-only tea command printed: + super-board-gitea-read.py --kind json -- api repos/{owner}/{repo}/issues + read_only_tea() rejects any method but GET and any body/field flag. + +2. Composite — the wrapper performs the (paginated, multi-endpoint) read and + prints the SAME normalized shape the github path produces, so card.sh, + wave-plan, merge-policy and friends stay shape-stable across forges: + --issue N kinds: issue · state · comments + --pr N kinds: head · body · merge-state · metadata · diff (--meta) · approval + --items O/R/PROJECT kind items (project = the Gitea project's API id) + --fields O/R/PROJECT kind fields (Status field synthesized from columns) + --project O/R/P · --projects O/R · --permission O/R + --issue-history O/R · --prs-open O/R · --prs-merged O/R · --issues-closed O/R + --quota (header probe; rate_limits_disabled:true when the + instance sends no X-RateLimit-* — resources then carry + sentinel 5000s so old readers never sleep forever) + +Gitea degradations, documented in references/gitea.md: approval's +closingIssuesReferences becomes a `Closes #N` body parse (fail-closed: no +trailer, no link); stateReason does not exist (closed issues validate as +COMPLETED); DraftIssue cards do not exist. + +Env: SB_FORGE_LOGIN (tea --login), GITEA_REPO or SB_FORGE_OWNER/SB_FORGE_REPO +(tea api placeholder context), SB_GITEA_TIMEOUT (default 30s per spawn — a +broken tea binary hangs instead of failing), SB_GITEA_RETRY_DELAY, +SB_GITEA_READ_STRICT, SB_GITHUB_HALT_FILE, SB_REPO_PATH. +""" +from __future__ import annotations + +import argparse +import importlib.util +import json +import os +from pathlib import Path +import re +import shlex +import subprocess +import sys +import time + +# ── shared machinery from the github twin ───────────────────────────────────── +_spec = importlib.util.spec_from_file_location( + 'super_board_github_read', Path(__file__).resolve().with_name('super-board-github-read.py')) +ghread = importlib.util.module_from_spec(_spec) +_spec.loader.exec_module(ghread) + +HALTED = ghread.HALTED # 79 +ReadHalted = ghread.ReadHalted +halt_path = ghread.halt_path +check_halt = ghread.check_halt +halt = ghread.halt +require = ghread.require + +PAGE_LIMIT = 50 # per-request page size for Gitea list endpoints +MAX_PAGES = 40 # truncation guard: 2000 issues/PRs per list +TEA_TIMEOUT = int(os.environ.get('SB_GITEA_TIMEOUT', '30')) + +# Agent-facing kinds whose payload is the caller's responsibility (passthrough). +FORMS = { + 'json': 'api (JSON output)', + 'scalar': 'api printing one value', + 'object': 'api (JSON object)', + 'array': 'api (JSON array)', + 'issue-number': 'api printing an issue number or nothing', +} + +class GiteaErrors(ValueError): + """The server's own error payload: an outage, never the caller's shape.""" + + +def read_only_tea(args): + """Only GETs may be retried. Mirrors github-read's read_only gate.""" + if not args: + return False + if args[0] == 'version': + return True + if args[0] == 'login': + return args[1:2] in (['ls'], ['list']) + if args[0] != 'api': + return False + rest = args[1:] + for i, a in enumerate(rest): + if a in ('-X', '--method'): + if i + 1 >= len(rest) or rest[i + 1].upper() != 'GET': + return False + elif a.startswith('--method='): + if a.split('=', 1)[1].upper() != 'GET': + return False + elif a.startswith('-X'): + if a[2:].upper() != 'GET': + return False + elif a in ('-d', '--data', '-f', '-F', '--input') or a.startswith(('-d', '-f', '-F', '--input=', '--data=')): + return False + return True + + +def permanent_error(text): + if re.search(r'rate limit|too many requests|\b429\b', text, re.I): + return False + return re.search(r'HTTP 40[134]|\b40[134]\b|\b422\b|invalid token|token (?:is )?required|' + r'unauthorized|forbidden|user does not exist|not found', text, re.I) is not None + + +def _tea_env(): + env = dict(os.environ) + if not env.get('GITEA_REPO'): + owner, repo = env.get('SB_FORGE_OWNER', ''), env.get('SB_FORGE_REPO', '') + if owner and repo: + env['GITEA_REPO'] = f'{owner}/{repo}' + return env + + +def tea_cmd(): + """The tea executable, overridable like cleanup-wt.py's CLEANUP_WT_GH — + tests point it at `bash evals/_stubs/bin/tea`. Quote paths with spaces; + on Windows use forward slashes (posix shlex rules, which Git bash accepts).""" + return shlex.split(os.environ.get('SB_GITEA_TEA', 'tea')) + + +def _tea(args): + """One bounded tea spawn. Returns (stdout, stderr, returncode).""" + cmd = tea_cmd() + login = os.environ.get('SB_FORGE_LOGIN') + if login: + cmd += ['--login', login] + cmd += args + r = subprocess.run(cmd, capture_output=True, text=True, timeout=TEA_TIMEOUT, env=_tea_env()) + return r.stdout, r.stderr, r.returncode + + +def tea_get(endpoint): + """GET one endpoint through `tea api`; returns parsed JSON. Raises on failure.""" + out, err, rc = _tea(['api', '-X', 'GET', endpoint]) + if rc: + raise GiteaErrors(f'tea api GET {endpoint} failed: {(err or out).strip()[:300]}') + try: + return json.loads(out) + except ValueError: + raise GiteaErrors(f'tea api GET {endpoint} printed non-JSON: {out.strip()[:200]}') + + +def tea_get_paged(endpoint): + """Paginate a Gitea list endpoint. Raises when the cap truncates a full page.""" + sep = '&' if '?' in endpoint else '?' + pages = [] + for page in range(1, MAX_PAGES + 1): + batch = tea_get(f'{endpoint}{sep}page={page}&limit={PAGE_LIMIT}') + require(isinstance(batch, list), f'{endpoint} page {page} is not a list') + pages.append(batch) + if len(batch) < PAGE_LIMIT: + return pages + raise GiteaErrors(f'{endpoint} still full after {MAX_PAGES} pages — evidence would be truncated') + + +def _or_path(spec): + """'owner/repo' → (owner, repo); anything else is a usage error.""" + require(spec and re.fullmatch(r'[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+', spec) is not None, + 'expected owner/repo') + return spec.split('/', 1) + + +def _or_project(spec): + """'owner/repo/project' → (owner, repo, project id).""" + parts = (spec or '').split('/') + require(len(parts) == 3 and all(parts) and parts[2].isdigit(), 'expected owner/repo/project') + return parts[0], parts[1], parts[2] + + +# ── normalization: Gitea REST → the shapes the github path prints ───────────── + +def _labels(entry): + return [{'name': l.get('name', '')} for l in (entry.get('labels') or [])] + + +def map_issue(i): + return {'id': i.get('id'), 'number': i.get('number'), 'title': i.get('title', ''), + 'body': i.get('body') or '', 'state': (i.get('state') or '').upper(), + 'url': i.get('html_url', ''), 'labels': _labels(i), + 'assignees': [{'login': a.get('login', '')} for a in (i.get('assignees') or [])]} + + +def map_pull(owner, repo, p, with_files=False): + head = p.get('head') or {} + state = 'MERGED' if p.get('merged') else (p.get('state') or '').upper() + out = {'number': p.get('number'), 'title': p.get('title', ''), 'body': p.get('body') or '', + 'state': state, 'url': p.get('html_url', ''), 'labels': _labels(p), + 'headRefName': head.get('ref', ''), 'headRefOid': head.get('sha', '')} + if state == 'MERGED': + out['mergeCommit'] = {'oid': p.get('merge_commit_sha') or head.get('sha', '')} + if with_files: + files = tea_get(f'repos/{owner}/{repo}/pulls/{p["number"]}/files') + require(isinstance(files, list), 'PR file list is not a list') + out['files'] = [{'path': f.get('filename', ''), 'additions': f.get('additions', 0), + 'deletions': f.get('deletions', 0)} for f in files] + out['additions'] = sum(f['additions'] for f in out['files']) + out['deletions'] = sum(f['deletions'] for f in out['files']) + out['changedFiles'] = len(out['files']) + return out + + +CLOSES_RE = re.compile(r'\b(?:close[sd]?|fixe[sd]?|resolve[sd]?)\s*:?\s+#(\d+)', re.I) + + +def op_issue(owner, repo, n, kind): + i = tea_get(f'repos/{owner}/{repo}/issues/{n}') + require(isinstance(i, dict) and i.get('number') == int(n), f'issue {n} unreadable') + if kind == 'state': + state = (i.get('state') or '').upper() + require(state in ('OPEN', 'CLOSED'), 'missing issue state') + return state + '\n', None + if kind == 'comments': + pages = tea_get_paged(f'repos/{owner}/{repo}/issues/{n}/comments') + norm = [[{'id': c.get('id'), 'body': c.get('body') or '', 'user': c.get('user') or {}, + 'created_at': c.get('created_at'), 'updated_at': c.get('updated_at')} + for c in page] for page in pages] + require(bool(norm), 'comment pages missing') + for page in norm: + for c in page: + require(type(c['id']) is int and isinstance(c['body'], str) and isinstance(c['user'], dict) + and c['created_at'] and c['updated_at'], 'comment fields missing') + return json.dumps(norm), norm + return json.dumps(map_issue(i)), None + + +def op_pr(owner, repo, n, kind, meta): + p = tea_get(f'repos/{owner}/{repo}/pulls/{n}') + require(isinstance(p, dict) and p.get('number') == int(n), f'PR {n} unreadable') + m = map_pull(owner, repo, p, with_files=(kind in ('metadata', 'diff'))) + if kind == 'head': + require(m['headRefName'] and re.fullmatch(r'[0-9a-f]{40}', m['headRefOid']), + 'missing PR branch or full head') + return f"{m['headRefName']} {m['headRefOid']}\n", None + if kind == 'body': + return json.dumps({'body': m['body'], 'headRefOid': m['headRefOid']}), None + if kind == 'merge-state': + return json.dumps({'state': m['state'], 'headRefOid': m['headRefOid'], + 'mergeCommit': m.get('mergeCommit')}), None + if kind == 'metadata': + return json.dumps(m), None + if kind == 'diff': + require(isinstance(meta, dict), 'diff metadata missing') + out, err, rc = _tea(['api', '-X', 'GET', f'repos/{owner}/{repo}/pulls/{n}.diff']) + require(rc == 0, f'PR diff unreadable: {err.strip()[:200]}') + ghread.validate(out, 'diff', meta) # same hunk-counting validator as github + return out, None + if kind == 'approval': + # Gitea has no closingIssuesReferences; the writing standard's `Closes #N` + # trailer is the contract. Fail-closed: no trailer means no linked issues, + # and approval.py refuses to merge without them. + numbers = sorted({int(x) for x in CLOSES_RE.findall(m['body'])}) + require(re.fullmatch(r'[0-9a-f]{40}', m['headRefOid']) and m['state'] in ('OPEN', 'CLOSED', 'MERGED'), + 'PR identity missing') + return json.dumps({'headRefOid': m['headRefOid'], 'state': m['state'], + 'closingIssues': [{'number': n} for n in numbers]}), None + raise ValueError(f'--pr does not serve kind "{kind}"') + + +def op_items(owner, repo, project): + columns = tea_get(f'repos/{owner}/{repo}/projects/{project}/columns') + require(isinstance(columns, list) and bool(columns), 'project has no columns') + items, seen = [], set() + for col in columns: + cid, title = col.get('id'), col.get('title', '') + require(cid is not None and title, 'column identity missing') + for page in tea_get_paged(f'repos/{owner}/{repo}/projects/{project}/columns/{cid}/issues'): + for entry in page: + gid = entry.get('id') + require(gid is not None and gid not in seen, 'board item duplicated or id-less') + seen.add(gid) + is_pr = entry.get('pull_request') is not None + item = {'id': f'gitea:{gid}', 'status': title, 'title': entry.get('title', ''), + 'content': {'type': 'PullRequest' if is_pr else 'Issue', + 'number': entry.get('number'), 'title': entry.get('title', ''), + 'url': entry.get('html_url', ''), 'repository': f'{owner}/{repo}'}} + names = [l.get('name') for l in (entry.get('labels') or []) if l.get('name')] + if names: + item['labels'] = names + items.append(item) + payload = {'items': items, 'totalCount': len(items)} + ghread.validate(json.dumps(payload), 'items') # same board validator as github + return json.dumps(payload), payload + + +def op_fields(owner, repo, project): + columns = tea_get(f'repos/{owner}/{repo}/projects/{project}/columns') + require(isinstance(columns, list) and bool(columns), 'project has no columns') + options = [{'id': str(c['id']), 'name': c.get('title', '')} for c in columns] + require(all(c.get('id') is not None and c.get('title') for c in columns), 'column identity missing') + payload = {'fields': [{'name': 'Status', 'id': f'gitea:status:{project}', 'options': options}]} + ghread.validate(json.dumps(payload), 'fields') + return json.dumps(payload), payload + + +def op_project(owner, repo, project): + p = tea_get(f'repos/{owner}/{repo}/projects/{project}') + require(isinstance(p, dict) and p.get('id') is not None, 'project unreadable') + payload = {'id': str(p['id']), 'title': p.get('title', '')} + ghread.validate(json.dumps(payload), 'project') + return json.dumps(payload), payload + + +def op_projects(owner, repo): + projects = [] + for page in tea_get_paged(f'repos/{owner}/{repo}/projects'): + projects += [{'id': p.get('id'), 'title': p.get('title', ''), 'description': p.get('description', '')} + for p in page] + payload = {'projects': projects} + ghread.validate(json.dumps(payload), 'projects') + return json.dumps(payload), payload + + +def op_permission(owner, repo): + r = tea_get(f'repos/{owner}/{repo}') + perms = (r or {}).get('permissions') or {} + level = 'admin' if perms.get('admin') else 'write' if perms.get('push') else 'read' if perms.get('pull') else 'none' + payload = {'permission': level} + ghread.validate(json.dumps(payload), 'permission') + return json.dumps(payload), payload + + +def op_issue_history(owner, repo): + out = [] + for state in ('open', 'closed'): + for page in tea_get_paged(f'repos/{owner}/{repo}/issues?state={state}&type=issues'): + for i in page: + require(type(i.get('number')) is int and i['number'] > 0 and isinstance(i.get('body') or '', str), + 'issue history fields missing') + out.append({'number': i['number'], 'state': (i.get('state') or '').upper(), 'body': i.get('body') or ''}) + numbers = [i['number'] for i in out] + require(len(numbers) == len(set(numbers)), 'issue history duplicated a number') + return json.dumps(out), out + + +def op_prs(owner, repo, kind): + state = 'open' if kind == 'prs-open' else 'closed' + out = [] + for page in tea_get_paged(f'repos/{owner}/{repo}/pulls?state={state}&sort=oldest'): + for p in page: + if kind == 'prs-merged' and not p.get('merged'): + continue + m = map_pull(owner, repo, p, with_files=(kind == 'prs-open')) + entry = {'number': m['number'], 'title': m['title'], 'body': m['body'], 'url': m['url']} + if kind == 'prs-open': + entry['headRefName'] = m['headRefName'] + entry['files'] = [{'path': f['path']} for f in m['files']] + out.append(entry) + require(isinstance(out, list), 'PR list missing') + for e in out: + require(type(e.get('number')) is int and e['number'] > 0 and isinstance(e.get('title'), str) + and isinstance(e.get('body'), str) and isinstance(e.get('url'), str), 'PR identity missing') + if kind == 'prs-open': + require(isinstance(e.get('headRefName'), str) and e['headRefName'] and isinstance(e['files'], list) + and all(isinstance(f, dict) and f.get('path') for f in e['files']), 'open PR branch/files missing') + return json.dumps(out), out + + +def op_issues_closed(owner, repo): + out = [] + for page in tea_get_paged(f'repos/{owner}/{repo}/issues?state=closed&type=issues'): + for i in page: + require(type(i.get('number')) is int and i['number'] > 0 and isinstance(i.get('body') or '', str), + 'closed issue fields missing') + # Gitea has no stateReason; a closed issue validates as COMPLETED. + out.append({'number': i['number'], 'title': i.get('title', ''), 'body': i.get('body') or '', + 'stateReason': 'COMPLETED'}) + return json.dumps(out), out + + +def op_quota(): + # `-i` prints response headers to stderr; stdout stays clean JSON. + out, err, rc = _tea(['api', '-i', '-X', 'GET', 'version']) + require(rc == 0, f'quota probe failed: {err.strip()[:200]}') + headers = {k.lower(): v.strip() for k, _, v in (line.partition(':') for line in err.splitlines())} + now = int(time.time()) + disabled = 'x-ratelimit-limit' not in headers + + def bucket(prefix): + if disabled: + return {'limit': 5000, 'remaining': 5000, 'used': 0, 'reset': now + 3600} + limit = int(headers.get(f'x-ratelimit-{prefix}', '0') or 0) + remaining = int(headers.get(f'x-ratelimit-remaining', '0') or 0) + reset = int(headers.get(f'x-ratelimit-reset', '0') or 0) + return {'limit': limit, 'remaining': remaining, 'used': max(0, limit - remaining), + 'reset': reset if reset > 0 else now + 3600} + + core = bucket('limit') + payload = {'resources': {'core': core, 'graphql': dict(core)}, 'rate_limits_disabled': disabled} + ghread.validate(json.dumps(payload), 'quota') + return json.dumps(payload), payload + + +# ── bounded retry over a whole logical read ─────────────────────────────────── + +def read_logical(fn, kind, operation, recovering=False): + """Three attempts over the whole composite read; same halt discipline.""" + if not recovering: + check_halt() + last = 'Gitea read failed' + shape_only = True + delay = float(os.environ.get('SB_GITEA_RETRY_DELAY', os.environ.get('SB_GITHUB_RETRY_DELAY', '1'))) + for attempt in range(1, 4): + if not recovering: + check_halt() + try: + output, _ = fn() + if not recovering: + check_halt() + return output + except GiteaErrors as error: + shape_only = False + last = f'Gitea required read failed: {error}' + if permanent_error(str(error)): + halt('Gitea rejected a required read (authentication, permission, or missing resource); ' + 'fix it before restarting', attempt, operation) + except (ValueError, KeyError, TypeError, AttributeError, IndexError) as error: + last = f'Gitea required read returned incomplete evidence: {error}' + except (OSError, subprocess.SubprocessError): + shape_only = False + last = 'Gitea required read timed out or could not start (is tea installed and logged in?)' + if attempt < 3: + print(f'[gitea-read] {last}; retry {attempt + 1}/3', file=sys.stderr) + time.sleep(max(0, delay) * attempt) + if shape_only and kind in FORMS and not os.environ.get('SB_GITEA_READ_STRICT'): + raise ValueError(f'{last}; this call failed, the run continues. Valid form: --kind {kind} -- {FORMS[kind]}') + halt(f'{last}; stopped after 3 failed attempts', 3, operation) + + +def repo_context(): + """owner/repo from GITEA_REPO / SB_FORGE_* so composite ops work in worktrees.""" + spec = os.environ.get('GITEA_REPO') + if not spec: + owner, repo = os.environ.get('SB_FORGE_OWNER', ''), os.environ.get('SB_FORGE_REPO', '') + spec = f'{owner}/{repo}' if owner and repo else '' + require(spec, 'repo context missing: set GITEA_REPO (forge.sh exports it) or pass owner/repo flags') + return _or_path(spec) + + +def serve(argv, recovering=False): + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument('--kind', default='json') + parser.add_argument('--meta') + parser.add_argument('--check', action='store_true') + parser.add_argument('--halt', help='record an unresolved mutation outcome and stop; never retry it') + parser.add_argument('--resume', action='store_true') + parser.add_argument('--issue', help='issue/PR number in the resolved repo') + parser.add_argument('--pr', help='PR number in the resolved repo') + parser.add_argument('--items', help='owner/repo/project — whole board (kind items)') + parser.add_argument('--fields', help='owner/repo/project — Status field from columns (kind fields)') + parser.add_argument('--project', help='owner/repo/project — one project (kind project)') + parser.add_argument('--projects', help='owner/repo — project list (kind projects)') + parser.add_argument('--permission', help='owner/repo — collaborator level (kind permission)') + parser.add_argument('--issue-history', help='owner/repo — complete all-state issue history') + parser.add_argument('--prs-open', help='owner/repo') + parser.add_argument('--prs-merged', help='owner/repo') + parser.add_argument('--issues-closed', help='owner/repo') + parser.add_argument('--quota', action='store_true', help='rate-limit probe (kind quota)') + parser.add_argument('command', nargs=argparse.REMAINDER) + args = parser.parse_args(argv) + command = args.command[1:] if args.command[:1] == ['--'] else args.command + kind = args.kind + composite = any([args.issue, args.pr, args.items, args.fields, args.project, args.projects, + args.permission, args.issue_history, args.prs_open, args.prs_merged, + args.issues_closed, args.quota]) + + try: + if args.halt: + halt(args.halt, 1) + if args.check: + check_halt() + return 0 + if args.resume: + path = halt_path() + if path.exists(): + record = json.loads(path.read_text()) + operation = record.get('operation') + if not isinstance(operation, dict) or not operation.get('gitea'): + raise ReadHalted('saved failure needs manual outcome reconciliation before restart') + if command or composite: + if kind != operation.get('kind'): + raise ValueError('replacement recovery read must validate the same evidence kind') + replay = [a for a in argv if a != '--resume'] + else: + replay = operation.get('argv') or [] + rc = serve(replay, recovering=True) + if rc == 0: + read_logical(op_quota, 'quota', {'gitea': True, 'argv': ['--quota'], 'kind': 'quota'}, + recovering=True) + path.replace(path.with_name(f'github-halt-{time.time_ns()}.json')) + return rc + meta = json.loads(Path(args.meta).read_text()) if args.meta else None + operation = {'gitea': True, 'argv': list(argv), 'kind': kind} + + # Passthrough: validate a read-only tea command's own output. + if command and not composite: + require(read_only_tea(command), 'retry helper accepts read-only tea commands only') + require(kind in FORMS, f'kind "{kind}" needs its composite flag; passthrough serves ' + + ', '.join(sorted(FORMS))) + + def _passthrough(): + out, err, rc = _tea(command) + if rc: + raise GiteaErrors((err or out).strip()[:300]) + ghread.validate(out, kind) + return out, None + + sys.stdout.write(read_logical(_passthrough, kind, operation, recovering)) + return 0 + + # Composites: the wrapper performs and normalizes the read. + def run_op(): + if args.quota: + require(kind == 'quota', '--quota serves kind quota') + return op_quota() + if args.items: + require(kind == 'items', '--items serves kind items') + return op_items(*_or_project(args.items)) + if args.fields: + require(kind == 'fields', '--fields serves kind fields') + return op_fields(*_or_project(args.fields)) + if args.project: + require(kind == 'project', '--project serves kind project') + return op_project(*_or_project(args.project)) + if args.projects: + require(kind == 'projects', '--projects serves kind projects') + return op_projects(*_or_path(args.projects)) + if args.permission: + require(kind == 'permission', '--permission serves kind permission') + return op_permission(*_or_path(args.permission)) + if args.issue_history: + return op_issue_history(*_or_path(args.issue_history)) + if args.prs_open: + require(kind == 'prs-open', '--prs-open serves kind prs-open') + return op_prs(*_or_path(args.prs_open), 'prs-open') + if args.prs_merged: + require(kind == 'prs-merged', '--prs-merged serves kind prs-merged') + return op_prs(*_or_path(args.prs_merged), 'prs-merged') + if args.issues_closed: + require(kind == 'issues-closed', '--issues-closed serves kind issues-closed') + return op_issues_closed(*_or_path(args.issues_closed)) + if args.pr: + require(kind in ('head', 'body', 'merge-state', 'metadata', 'diff', 'approval'), + f'--pr does not serve kind "{kind}"') + owner, repo = repo_context() + return op_pr(owner, repo, args.pr, kind, meta) + if args.issue: + require(kind in ('issue', 'state', 'comments'), f'--issue does not serve kind "{kind}"') + owner, repo = repo_context() + return op_issue(owner, repo, args.issue, kind) + raise ValueError('nothing to read: pass a composite flag or -- ') + + sys.stdout.write(read_logical(run_op, kind, operation, recovering)) + return 0 + except ReadHalted as error: + print(f'[gitea-read] HALT: {error}. Saved at {halt_path()}', file=sys.stderr) + return HALTED + except (ValueError, OSError) as error: + print(f'[gitea-read] {error}', file=sys.stderr) + return 64 + + +if __name__ == '__main__': + sys.exit(serve(sys.argv[1:])) diff --git a/scripts/super-board-setup.py b/scripts/super-board-setup.py index acfab70f..2be53e49 100755 --- a/scripts/super-board-setup.py +++ b/scripts/super-board-setup.py @@ -49,6 +49,7 @@ import hashlib import datetime as dt import glob +import importlib.util import json import os import platform @@ -71,7 +72,7 @@ } SKILLS = ["super-board", "super-build", "super-qa", "super-review", "super-collect", "visual", "git-sync", "ui-refine-loop"] OLD_SKILL_DIRS = ["super-refine", "cleanup-wt", "arch-loop"] -BIN = ["super-board-project-verifier.py", "super-board-skills-ready.py", "super-board-host.sh", "super-board-codex-wave.sh", "super-board-codex-lane.sh", "super-board-calibration.py", "super-board-verification-ready.py", "super-board-github-read.py", "super-board-collect-state.py", "super-board-run.sh", "super-board-gh-guard.sh", "super-board-card.sh", "super-board-status.py", "super-board-wave-plan.sh", +BIN = ["super-board-project-verifier.py", "super-board-skills-ready.py", "super-board-host.sh", "super-board-codex-wave.sh", "super-board-codex-lane.sh", "super-board-calibration.py", "super-board-verification-ready.py", "super-board-github-read.py", "super-board-forge.py", "super-board-forge.sh", "super-board-gitea-api.sh", "super-board-gitea-read.py", "super-board-collect-state.py", "super-board-run.sh", "super-board-gh-guard.sh", "super-board-card.sh", "super-board-status.py", "super-board-wave-plan.sh", "super-board-deps.sh", "super-board-preflight.sh", "super-board-merge-gate.sh", "super-board-merge-policy.py", "super-board-approval.py", "super-board-env-check.sh", "super-board-agents-md.py", "super-board-settings.py", "super-board-setup.py", "super-board-usage.sh", "super-board-pr-body.sh", @@ -155,6 +156,20 @@ def write_json(path, data): os.replace(tmp, path) +_FORGE_MOD = None + + +def forge_mod(): + """super-board-forge.py loaded as a module (dashes rule out `import`).""" + global _FORGE_MOD + if _FORGE_MOD is None: + path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "super-board-forge.py") + spec = importlib.util.spec_from_file_location("super_board_forge", path) + _FORGE_MOD = importlib.util.module_from_spec(spec) + spec.loader.exec_module(_FORGE_MOD) + return _FORGE_MOD + + def find_pack(explicit=None): """The pack checkout whose install.sh can (re)install pieces. None when not found.""" cands = [explicit, os.environ.get("SUPER_BOARD_PACK"), @@ -1000,10 +1015,10 @@ def main(argv): cfg = load_json(cfg_path) if cfg_path else {} cfg = cfg if isinstance(cfg, dict) else {} proj = cfg.get("project") or {} - m = re.search(r"github\.com[:/]([^/]+/[^/.]+)", ((cfg.get("repo") or {}).get("remote") or "")) + remote = forge_mod().parse_remote((cfg.get("repo") or {}).get("remote") or "") owner = flag(rest, "--owner") or proj.get("owner") number = flag(rest, "--number") or proj.get("number") - repo = flag(rest, "--repo") or (m.group(1) if m else None) + repo = flag(rest, "--repo") or (f"{remote['owner']}/{remote['repo']}" if remote else None) if not (owner and number and repo): return 64 qa_all = "--qa-all" in rest or bool(cfg.get("_qa_all")) diff --git a/skills/super-board/references/config-schema.json b/skills/super-board/references/config-schema.json index c9d3be07..2c762eea 100644 --- a/skills/super-board/references/config-schema.json +++ b/skills/super-board/references/config-schema.json @@ -13,10 +13,26 @@ // E.g. "staging QA" or "admin build pipeline". "description": "", + // Which forge hosts the board, issues and PRs (v3.2.0). "github" (default, + // absent means github) or "gitea". Resolution order for every script: + // env SB_FORGE / SB_FORGE_HOST / SB_FORGE_LOGIN → these keys → the git + // remote (advisory: fills owner/repo and a gitea host, never flips the + // kind). See references/gitea.md for the full mapping and degradations. + "forge": "github", + // Instance base URL, REQUIRED when forge is "gitea" (e.g. + // "https://gitea.example.com" or "http://localhost:3000"). A gitea config + // with no resolvable host exits 66 — scripts never guess the server. + "forge_host": null, + // Optional tea login name (`tea login ls`) for machines with several + // Gitea accounts; absent lets tea use its default login, or the + // GITEA_TOKEN + TEA_HOST env pair in CI. + "forge_login": null, + "project": { "owner": "", "title": "", // Required; `gh project` CLI takes number, not title (titles aren't unique). + // On Gitea this is the project's API id (onboard records id + UI URL). "number": 0 }, diff --git a/tests/test-forge.sh b/tests/test-forge.sh new file mode 100755 index 00000000..dd6492f0 --- /dev/null +++ b/tests/test-forge.sh @@ -0,0 +1,162 @@ +#!/usr/bin/env bash +# Tests super-board-forge.sh + super-board-gitea-api.sh against fake wrappers, +# a fake gh and a fake tea. No network. +# +# The forge layer's promise: callers keep one verb set while the wrapper, +# the env (GITEA_REPO) and the halt discipline switch with SB_FORGE_KIND. +set -euo pipefail +cd "$(dirname "$0")" +SRC="$PWD/../scripts" +TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT +fail() { echo "FAIL: $1" >&2; exit 1; } +pass=0; ok() { pass=$((pass + 1)); echo " ✅ $1"; } + +mkdir -p "$TMP/bin" +cp "$SRC/super-board-forge.py" "$SRC/super-board-forge.sh" "$SRC/super-board-gitea-api.sh" "$TMP/bin/" + +# Fake read wrappers: answer --check/--halt, otherwise print name + args. +for w in github gitea; do + cat > "$TMP/bin/super-board-${w}-read.py" < "$TMP/bin/gh" <<'EOF' +#!/usr/bin/env bash +{ printf 'gh %s\n' "$*"; } >> "$FAKE_LOG" +case "$1 $2" in + "issue edit") exit "${GH_FAIL:-0}" ;; +esac +exit 0 +EOF +cat > "$TMP/bin/tea" <<'EOF' +#!/usr/bin/env bash +{ printf 'tea %s\n' "$*"; } >> "$FAKE_LOG" +args="$*" +case "$args" in + *"-X GET"*labels*) cat "$TEA_LABELS" ;; + *"-X POST"*labels*) + case "$args" in + *issues/*) echo '{}' ;; + *) echo '{"id":7,"name":"created"}' ;; + esac ;; + *) echo '{}' ;; +esac +exit 0 +EOF +chmod +x "$TMP/bin/gh" "$TMP/bin/tea" + +export PATH="$TMP/bin:$PATH" FAKE_LOG="$TMP/log" HALT_FILE="$TMP/halt.json" \ + SB_GITHUB_HALT_FILE="$TMP/halt.json" TEA_LABELS="$TMP/labels.json" +: > "$FAKE_LOG" + +load() { # fresh shell state per scenario, sourcing the copied forge.sh + unset SB_FORGE_KIND SB_FORGE_HOST SB_FORGE_LOGIN SB_FORGE_OWNER SB_FORGE_REPO GITEA_REPO 2>/dev/null || true + SB_FORGE_KIND=github SB_FORGE_HOST= SB_FORGE_LOGIN= SB_FORGE_OWNER= SB_FORGE_REPO= + # shellcheck source=/dev/null + source "$TMP/bin/super-board-forge.sh" +} + +cat > "$TMP/github.json" <<'EOF' +{"forge":"github","project":{"owner":"acme"},"repo":{"remote":"https://github.com/acme/app.git"}} +EOF +cat > "$TMP/gitea.json" <<'EOF' +{"forge":"gitea","forge_host":"http://localhost:3000","project":{"owner":"acme"}, + "repo":{"remote":"http://localhost:3000/acme/app.git"}} +EOF + +# 1 — github config resolves and reads through the github wrapper. +load +sb_forge_resolve "$TMP/github.json" || fail "resolve github" +[ "$SB_FORGE_KIND" = github ] || fail "kind: $SB_FORGE_KIND" +OUT=$(sb_forge_read json -- api rate_limit) || fail "github read" +[ "$OUT" = "github-read --kind json -- api rate_limit" ] || fail "dispatch: $OUT" +[ -z "${GITEA_REPO:-}" ] || fail "GITEA_REPO leaked into github mode" +ok "github config → github wrapper, no GITEA_REPO" + +# 2 — gitea config resolves, exports GITEA_REPO and reads through the gitea wrapper. +load +sb_forge_resolve "$TMP/gitea.json" || fail "resolve gitea" +[ "$SB_FORGE_KIND" = gitea ] || fail "kind: $SB_FORGE_KIND" +[ "$SB_FORGE_HOST" = "http://localhost:3000" ] || fail "host: $SB_FORGE_HOST" +[ "$GITEA_REPO" = "acme/app" ] || fail "GITEA_REPO: ${GITEA_REPO:-unset}" +OUT=$(sb_forge_read json -- api GET repos/{owner}/{repo}) || fail "gitea read" +[ "$OUT" = "gitea-read --kind json -- api GET repos/{owner}/{repo}" ] || fail "dispatch: $OUT" +ok "gitea config → gitea wrapper + GITEA_REPO exported" + +# 3 — a gitea config with no host anywhere exits 66 through resolve. +load +cat > "$TMP/nohost.json" <<'EOF' +{"forge":"gitea"} +EOF +RC=0; sb_forge_resolve "$TMP/nohost.json" 2>/dev/null || RC=$? +[ "$RC" = 66 ] || fail "hostless gitea should exit 66, got $RC" +ok "gitea without host → exit 66" + +# 4 — write_once: success passes through to gh; failure halts and returns 79. +load +sb_forge_resolve "$TMP/github.json" +: > "$FAKE_LOG" +sb_forge_write_once issue edit 12 --add-label qa >/dev/null || fail "write_once success" +grep -q '^gh issue edit 12 --add-label qa' "$FAKE_LOG" || fail "gh not called: $(cat "$FAKE_LOG")" +rm -f "$HALT_FILE" +export GH_FAIL=1 +RC=0; sb_forge_write_once issue edit 12 --add-label qa >/dev/null 2>&1 || RC=$? +unset GH_FAIL +[ "$RC" = 79 ] || fail "failed write should return 79, got $RC" +[ -f "$HALT_FILE" ] || fail "failed write must record a halt" +ok "write_once: gh passthrough, failure → halt + 79" + +# 5 — label_add on github is one gh issue edit. +load +sb_forge_resolve "$TMP/github.json" +: > "$FAKE_LOG"; rm -f "$HALT_FILE" +sb_forge_label_add 12 bug >/dev/null || fail "github label_add" +grep -q '^gh issue edit 12 --add-label bug' "$FAKE_LOG" || fail "$(cat "$FAKE_LOG")" +ok "github label_add → gh issue edit --add-label" + +# 6 — label_add on gitea: existing label → resolve id, POST issue labels. +load +sb_forge_resolve "$TMP/gitea.json" +echo '[{"id":5,"name":"bug"},{"id":6,"name":"qa"}]' > "$TEA_LABELS" +: > "$FAKE_LOG" +sb_forge_label_add 12 bug >/dev/null || fail "gitea label_add" +grep -q 'repos/{owner}/{repo}/issues/12/labels' "$FAKE_LOG" || fail "no attach: $(cat "$FAKE_LOG")" +grep -q '"labels":\[5\]' "$FAKE_LOG" || fail "wrong id: $(cat "$FAKE_LOG")" +ok "gitea label_add → id lookup + POST issue labels" + +# 7 — label_add on gitea: missing label → create with the shared color, then attach. +load +sb_forge_resolve "$TMP/gitea.json" +echo '[]' > "$TEA_LABELS" +: > "$FAKE_LOG" +sb_forge_label_add 12 feature >/dev/null || fail "gitea label create" +grep -q '"name":"feature"' "$FAKE_LOG" || fail "no create: $(cat "$FAKE_LOG")" +grep -q '"color":"#1d76db"' "$FAKE_LOG" || fail "wrong color: $(cat "$FAKE_LOG")" +grep -q '"labels":\[7\]' "$FAKE_LOG" || fail "attach used wrong id: $(cat "$FAKE_LOG")" +ok "gitea label_add → create with shared color, then attach" + +# 8 — tea_write halts + returns 79 when tea fails. +load +sb_forge_resolve "$TMP/gitea.json" +cat > "$TMP/bin/tea" <<'EOF' +#!/usr/bin/env bash +exit 1 +EOF +chmod +x "$TMP/bin/tea" +rm -f "$HALT_FILE" +RC=0; sb_forge_tea_write POST repos/{owner}/{repo}/issues '{"title":"x"}' >/dev/null 2>&1 || RC=$? +[ "$RC" = 79 ] || fail "failed tea write should return 79, got $RC" +[ -f "$HALT_FILE" ] || fail "failed tea write must record a halt" +ok "tea_write: failure → halt + 79" + +echo "test-forge: $pass passed" diff --git a/tests/test-gitea-api.sh b/tests/test-gitea-api.sh new file mode 100755 index 00000000..fd8945ed --- /dev/null +++ b/tests/test-gitea-api.sh @@ -0,0 +1,79 @@ +#!/usr/bin/env bash +# Tests super-board-gitea-api.sh against the offline tea stub (evals/_stubs/bin/tea). +# No network. The helper's promises: JSON body building, {owner}/{repo} expansion +# via GITEA_REPO, -i headers on stderr only, and a bounded lifetime for a hung tea. +set -euo pipefail +cd "$(dirname "$0")" +SRC="$PWD/../scripts" +STUB="$PWD/../evals/_stubs/bin/tea" +TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT +fail() { echo "FAIL: $1" >&2; exit 1; } +pass=0; ok() { pass=$((pass + 1)); echo " ✅ $1"; } + +mkdir -p "$TMP/.git" +cd "$TMP" +export GITEA_REPO="example/shop" SB_GITEA_TEA="bash $STUB" +cat > .git/tea-state.json <<'EOF' +{"issues":[{"id":101,"number":1,"title":"Cart bug","body":"x","state":"open","labels":[]}], + "pulls":[], + "labels":[{"id":3,"name":"bug","color":"#d73a4a"}], + "projects":[{"id":4,"title":"Board"}], + "columns":[{"id":10,"title":"Ready"},{"id":11,"title":"Done"}], + "comments":{},"writes":0} +EOF +# shellcheck source=/dev/null +source "$SRC/super-board-gitea-api.sh" + +# 1 — POST with a JSON body creates and echoes the issue. +OUT=$(sb_gitea_api POST 'repos/{owner}/{repo}/issues' '{"title":"New bug","body":"b"}') || fail "create issue" +[ "$(jq -r .title <<<"$OUT")" = "New bug" ] || fail "echo: $OUT" +[ "$(jq -r .number <<<"$OUT")" = 2 ] || fail "number: $OUT" +jq -e '.issues | length == 2' .git/tea-state.json >/dev/null || fail "state not written" +ok "POST issues → created, state updated" + +# 2 — label helpers: attach existing, create missing with the shared color. +sb_gitea_label_add 1 bug >/dev/null || fail "attach existing label" +jq -e '(.issues[] | select(.number==1) | .labels | map(.name)) == ["bug"]' .git/tea-state.json >/dev/null \ + || fail "label not attached: $(jq -c '.issues[0].labels' .git/tea-state.json)" +sb_gitea_label_add 1 feature >/dev/null || fail "create+attach missing label" +jq -e 'any(.labels[]; .name=="feature" and .color=="#1d76db")' .git/tea-state.json >/dev/null \ + || fail "feature label missing/wrong color: $(jq -c .labels .git/tea-state.json)" +ok "label_add attaches existing, creates missing with shared color" + +# 3 — creating an existing label is refused by the server, and the pre-check +# makes label_add idempotent instead. +sb_gitea_label_add 1 bug >/dev/null || fail "idempotent re-attach" +jq -e '(.issues[] | select(.number==1) | .labels | length) == 2' .git/tea-state.json >/dev/null \ + || fail "re-attach duplicated: $(jq -c '.issues[0].labels' .git/tea-state.json)" +ok "label_add is idempotent" + +# 4 — headers go to stderr, body stays clean JSON on stdout. +ERR=$(sb_gitea_api_headers GET version 2>&1 >/dev/null) || fail "header probe" +OUT=$(sb_gitea_api_headers GET version 2>/dev/null) || fail "header probe body" +grep -q 'X-RateLimit-Remaining: 3597' <<<"$ERR" || fail "no rate headers: $ERR" +jq -e .version <<<"$OUT" >/dev/null || fail "body not clean JSON: $OUT" +ok "tea api -i → headers stderr, JSON stdout" + +# 5 — the move endpoint (card.sh's gitea mutation). +sb_gitea_api POST 'repos/{owner}/{repo}/projects/4/issues/101/move' '{"column_id":11}' >/dev/null \ + || fail "move" +jq -e '(.issues[] | select(.id==101) | ._column) == 11' .git/tea-state.json >/dev/null || fail "not moved" +ok "POST move → column changed" + +# 6 — a hung tea is killed by the timeout, not the worker. +cat > "$TMP/hang-tea" <<'EOF' +#!/usr/bin/env bash +sleep 30 +EOF +export SB_GITEA_TEA="bash $TMP/hang-tea" SB_GITEA_TIMEOUT=1 +RC=0; sb_gitea_api GET version >/dev/null 2>&1 || RC=$? +[ "$RC" != 0 ] || fail "hung tea should fail, not block" +unset SB_GITEA_TEA SB_GITEA_TIMEOUT +export SB_GITEA_TEA="bash $STUB" +ok "hung tea → bounded failure (rc=$RC)" + +# 7 — every write was logged for auditability. +[ "$(grep -c '^POST' .git/tea-writes.log)" -ge 4 ] || fail "write log: $(cat .git/tea-writes.log)" +ok "writes logged to tea-writes.log" + +echo "test-gitea-api: $pass passed" diff --git a/tests/test_forge.py b/tests/test_forge.py new file mode 100644 index 00000000..288a8085 --- /dev/null +++ b/tests/test_forge.py @@ -0,0 +1,160 @@ +#!/usr/bin/env python3 +"""Offline contract for super-board-forge.py: remote parsing, precedence, CLI exits.""" +import json +import os +from pathlib import Path +import subprocess +import sys +import tempfile +import unittest + +ROOT = Path(__file__).resolve().parents[1] +HELPER = ROOT / 'scripts/super-board-forge.py' + +import importlib.util +_spec = importlib.util.spec_from_file_location('super_board_forge', HELPER) +forge = importlib.util.module_from_spec(_spec) +_spec.loader.exec_module(forge) + + +class ParseRemoteTests(unittest.TestCase): + def test_https_github(self): + self.assertEqual(forge.parse_remote('https://github.com/acme/app.git'), + {'host': 'https://github.com', 'owner': 'acme', 'repo': 'app'}) + + def test_https_no_suffix(self): + self.assertEqual(forge.parse_remote('https://github.com/acme/app'), + {'host': 'https://github.com', 'owner': 'acme', 'repo': 'app'}) + + def test_http_gitea_with_port_keeps_scheme_and_port(self): + self.assertEqual(forge.parse_remote('http://localhost:3000/acme/app.git'), + {'host': 'http://localhost:3000', 'owner': 'acme', 'repo': 'app'}) + + def test_scp_form(self): + self.assertEqual(forge.parse_remote('git@gitea.example.com:acme/app.git'), + {'host': 'https://gitea.example.com', 'owner': 'acme', 'repo': 'app'}) + + def test_ssh_url_with_port(self): + self.assertEqual(forge.parse_remote('ssh://git@gitea.example.com:2222/acme/app.git'), + {'host': 'https://gitea.example.com:2222', 'owner': 'acme', 'repo': 'app'}) + + def test_unparseable(self): + for url in ('', None, 'not-a-url', 'https://github.com/onlyowner', '/local/path', + 'https://github.com/a b/c d'): + with self.subTest(url=url): + self.assertIsNone(forge.parse_remote(url)) + + +class ResolveTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.root = Path(self.temp.name) # not a git repo: remote fallback stays empty + self.env_saved = {k: os.environ.get(k) for k in ('SB_FORGE', 'SB_FORGE_HOST', 'SB_FORGE_LOGIN')} + for k in self.env_saved: + os.environ.pop(k, None) + + def tearDown(self): + for k, v in self.env_saved.items(): + if v is None: + os.environ.pop(k, None) + else: + os.environ[k] = v + self.temp.cleanup() + + def write_config(self, cfg): + path = self.root / 'cfg.json' + path.write_text(json.dumps(cfg)) + return str(path) + + def test_absent_config_defaults_to_github(self): + res = forge.resolve(root=str(self.root)) + self.assertEqual(res['forge'], 'github') + self.assertEqual(res['host'], 'https://github.com') + + def test_config_keys_win_over_remote_but_env_wins_over_all(self): + cfg = self.write_config({'forge': 'gitea', 'forge_host': 'https://gitea.example.com', + 'forge_login': 'bot', 'project': {'owner': 'acme'}, + 'repo': {'remote': 'https://gitea.example.com/acme/app.git'}}) + res = forge.resolve(cfg, root=str(self.root)) + self.assertEqual((res['forge'], res['host'], res['login'], res['owner'], res['repo']), + ('gitea', 'https://gitea.example.com', 'bot', 'acme', 'app')) + os.environ['SB_FORGE_HOST'] = 'http://localhost:3000' + res = forge.resolve(cfg, root=str(self.root)) + self.assertEqual(res['host'], 'http://localhost:3000') + + def test_gitea_host_falls_back_to_a_non_github_remote(self): + cfg = self.write_config({'forge': 'gitea', + 'repo': {'remote': 'http://localhost:3000/acme/app.git'}}) + res = forge.resolve(cfg, root=str(self.root)) + self.assertEqual(res['host'], 'http://localhost:3000') + self.assertEqual(res['owner'], 'acme') + forge.check(res) # must not raise + + def test_gitea_without_host_fails_check(self): + cfg = self.write_config({'forge': 'gitea'}) + res = forge.resolve(cfg, root=str(self.root)) + with self.assertRaises(LookupError): + forge.check(res) + + def test_unknown_forge_raises(self): + os.environ['SB_FORGE'] = 'gitlab' + with self.assertRaises(ValueError): + forge.resolve(root=str(self.root)) + + +class CliTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.root = Path(self.temp.name) + self.env = {k: v for k, v in os.environ.items() + if k not in ('SB_FORGE', 'SB_FORGE_HOST', 'SB_FORGE_LOGIN')} + + def tearDown(self): + self.temp.cleanup() + + def run_cli(self, *args, env=None): + return subprocess.run([sys.executable, str(HELPER), *args], cwd=self.root, + env=env or self.env, text=True, capture_output=True) + + def write_config(self, cfg): + path = self.root / 'cfg.json' + path.write_text(json.dumps(cfg)) + return str(path) + + def test_get_shell_is_eval_safe(self): + cfg = self.write_config({'forge': 'gitea', 'forge_host': "https://gitea.example.com", + 'repo': {'remote': 'https://gitea.example.com/acme/app.git'}}) + r = self.run_cli('get', '--config', cfg, '--shell') + self.assertEqual(r.returncode, 0, r.stderr) + # shlex.quote leaves bare words unquoted; the empty login shows quoting works. + self.assertIn('SB_FORGE_KIND=gitea', r.stdout) + self.assertIn("SB_FORGE_LOGIN=''", r.stdout) + self.assertIn('SB_FORGE_REPO=app', r.stdout) + + def test_single_value_subcommands(self): + cfg = self.write_config({'forge': 'gitea', 'forge_host': 'https://gitea.example.com', + 'project': {'owner': 'acme'}, + 'repo': {'remote': 'https://gitea.example.com/acme/app.git'}}) + for cmd, want in (('forge', 'gitea'), ('host', 'https://gitea.example.com'), + ('owner', 'acme'), ('repo', 'app')): + r = self.run_cli(cmd, '--config', cfg) + self.assertEqual(r.stdout.strip(), want, f'{cmd}: {r.stderr}') + + def test_unknown_forge_exits_64(self): + cfg = self.write_config({'forge': 'bitbucket'}) + self.assertEqual(self.run_cli('get', '--config', cfg).returncode, 64) + + def test_gitea_without_host_exits_66(self): + cfg = self.write_config({'forge': 'gitea'}) + self.assertEqual(self.run_cli('get', '--config', cfg).returncode, 66) + + def test_get_json_shape(self): + r = self.run_cli('get', '--json') + self.assertEqual(r.returncode, 0, r.stderr) + data = json.loads(r.stdout) + self.assertEqual(data['forge'], 'github') + self.assertIn('config', data) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_gitea_reads.py b/tests/test_gitea_reads.py new file mode 100644 index 00000000..903e35e3 --- /dev/null +++ b/tests/test_gitea_reads.py @@ -0,0 +1,265 @@ +#!/usr/bin/env python3 +"""Offline CLI contract for the gitea twin: bounded reads, normalized shapes, shared halt.""" +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +ROOT = Path(__file__).resolve().parents[1] +HELPER = ROOT / 'scripts/super-board-gitea-read.py' +TEA_STUB = ROOT / 'evals/_stubs/bin/tea' +SHA = 'a' * 40 + +DIFF = '''diff --git a/a.ts b/a.ts +index 1234567..89abcde 100644 +--- a/a.ts ++++ b/a.ts +@@ -1,3 +1,4 @@ + line1 +-line2 ++line2x ++line2y + line3 +''' + +PULL = {'number': 7, 'title': 'Fix cart', 'body': 'Closes #1\nmore', 'state': 'open', + 'merged': False, 'head': {'ref': 'fix-cart', 'sha': SHA}, + 'html_url': 'https://gitea.example/example/shop/pulls/7', 'labels': []} + +ISSUES = [ + {'id': 101, 'number': 1, 'title': 'Cart bug', 'body': 'broken', 'state': 'open', + 'labels': [{'id': 3, 'name': 'bug'}], 'html_url': 'u1', + 'created_at': '2026-01-01T00:00:00Z', 'updated_at': '2026-01-01T00:00:00Z'}, + {'id': 102, 'number': 2, 'title': 'Done thing', 'body': 'ok', 'state': 'closed', + 'labels': [], 'html_url': 'u2', + 'created_at': '2026-01-01T00:00:00Z', 'updated_at': '2026-01-01T00:00:00Z'}, + {'id': 103, 'number': 3, 'title': 'PR entry', 'body': '', 'state': 'open', + 'labels': [], 'html_url': 'u3', 'pull_request': {}, + 'created_at': '2026-01-01T00:00:00Z', 'updated_at': '2026-01-01T00:00:00Z'}, +] + +COLUMNS = [{'id': 10, 'title': 'Ready', 'color': '#2563eb'}, + {'id': 11, 'title': 'Done', 'color': '#16a34a'}] + + +def base_state(): + issues = json.loads(json.dumps(ISSUES)) + issues[0]['_column'] = 10 + issues[1]['_column'] = 11 + return {'issues': issues, 'pulls': [json.loads(json.dumps(PULL))], + 'labels': [{'id': 3, 'name': 'bug', 'color': '#d73a4a'}], + 'projects': [{'id': 4, 'title': 'Shop Board'}], + 'columns': COLUMNS, + 'comments': {'1': [{'id': 9, 'body': 'looked into it', 'user': {'login': 'eval-bot'}, + 'created_at': '2026-01-02T00:00:00Z', 'updated_at': '2026-01-02T00:00:00Z'}]}, + 'writes': 0} + + +class GiteaReadTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.root = Path(self.temp.name) + (self.root / '.git').mkdir() + (self.root / '.git/tea-fixture').mkdir() + (self.root / '.git/tea-fixture/pull-7.diff').write_text(DIFF) + (self.root / '.git/tea-fixture/pull-7-files.json').write_text( + json.dumps([{'filename': 'a.ts', 'additions': 2, 'deletions': 1}])) + (self.root / '.git/tea-state.json').write_text(json.dumps(base_state())) + self.bin = self.root / 'bin' + self.bin.mkdir() + self.stub = self.bin / 'tea' + shutil.copy(TEA_STUB, self.stub) + self.stub.chmod(0o755) + self.halt = self.root / 'halt.json' + # SB_GITEA_TEA names the executable (like CLEANUP_WT_GH): on Windows a + # PATH stub can't be spawned by CreateProcess and a real tea.exe would + # shadow it, so the stub is invoked through bash explicitly. + if os.name == 'nt': + git_bash = Path(r'C:\Program Files\Git\usr\bin\bash.exe') + bash = str(git_bash) if git_bash.exists() else 'bash' + else: + bash = 'bash' + # forward slashes: SB_GITEA_TEA is split with posix shlex rules and Git + # bash accepts C:/… paths, so one spelling works on every platform. + tea = f'"{bash.replace(chr(92), "/")}" "{str(self.stub).replace(chr(92), "/")}"' + self.env = dict(os.environ, PATH=f'{self.bin}:{os.environ["PATH"]}', + SB_GITEA_TEA=tea, + GITEA_REPO='example/shop', SB_GITHUB_HALT_FILE=str(self.halt), + SB_GITEA_RETRY_DELAY='0', SB_GITHUB_RETRY_DELAY='0') + + def tearDown(self): + self.temp.cleanup() + + def read(self, *args, expect=0): + r = subprocess.run([sys.executable, str(HELPER), *args], env=self.env, + text=True, capture_output=True, cwd=self.root) + self.assertEqual(r.returncode, expect, f'{" ".join(args)}: {r.stderr}') + return r + + def state(self): + return json.loads((self.root / '.git/tea-state.json').read_text()) + + def failing_tea(self, message, rc=1): + script = self.bin / 'tea' + script.write_text('#!/usr/bin/env bash\n' + f'echo "tea $*" >> "$PWD/.git/tea-calls.log"\n' + f'echo "{message}" >&2\nexit {rc}\n') + script.chmod(0o755) + + # ── halt discipline ────────────────────────────────────────────────────── + + def test_three_failed_attempts_halt(self): + self.failing_tea('ServerError: 500 boom') + r = self.read('--kind', 'json', '--', 'api', 'repos/{owner}/{repo}/projects', expect=79) + self.assertEqual(r.stdout, '') + self.assertEqual(json.loads(self.halt.read_text())['attempts'], 3) + self.assertIn('retry 2/3', r.stderr) + # a halted run must not read again + shutil.copy(TEA_STUB, self.bin / 'tea'); (self.bin / 'tea').chmod(0o755) + self.read('--kind', 'json', '--', 'api', 'repos/{owner}/{repo}/projects', expect=79) + calls = (self.root / '.git/tea-calls.log').read_text() + self.assertEqual(calls.count('tea api'), 3) + + def test_permanent_404_halts_on_first_attempt(self): + self.failing_tea('ServerError: 404 not found') + self.read('--kind', 'json', '--', 'api', 'repos/{owner}/{repo}/projects', expect=79) + self.assertEqual(json.loads(self.halt.read_text())['attempts'], 1) + + def test_check_and_resume_roundtrip(self): + self.failing_tea('ServerError: 500 boom') + self.read('--issue-history', 'example/shop', expect=79) + self.read('--check', expect=79) + shutil.copy(TEA_STUB, self.bin / 'tea'); (self.bin / 'tea').chmod(0o755) + r = self.read('--resume') + self.assertFalse(self.halt.exists()) + self.assertTrue(list(self.halt.parent.glob('github-halt-*.json')), 'halt not archived') + numbers = sorted(i['number'] for i in json.loads(r.stdout)) + self.assertEqual(numbers, [1, 2]) # PR-shaped entries stay out of issue history + + def test_halt_flag_records_ambiguous_write(self): + self.read('--halt', 'Gitea POST merge response failed', expect=79) + self.assertEqual(json.loads(self.halt.read_text())['attempts'], 1) + + # ── passthrough ────────────────────────────────────────────────────────── + + def test_passthrough_json(self): + r = self.read('--kind', 'json', '--', 'api', 'repos/{owner}/{repo}/projects') + self.assertEqual(json.loads(r.stdout), [{'id': 4, 'title': 'Shop Board'}]) + + def test_passthrough_rejects_writes(self): + r = self.read('--kind', 'json', '--', 'api', '-X', 'POST', + 'repos/{owner}/{repo}/issues', '-d', '{}', expect=64) + self.assertIn('read-only', r.stderr) + + def test_passthrough_rejects_non_get_method_flag(self): + self.read('--kind', 'json', '--', 'api', '-X', 'PATCH', 'repos/o/r/pulls/1', expect=64) + + # ── issue composites ───────────────────────────────────────────────────── + + def test_issue_state_and_comments(self): + r = self.read('--kind', 'state', '--issue', '1') + self.assertEqual(r.stdout.strip(), 'OPEN') + r = self.read('--kind', 'issue', '--issue', '1') + i = json.loads(r.stdout) + self.assertEqual((i['id'], i['number'], i['state']), (101, 1, 'OPEN')) + self.assertNotIn('_column', json.dumps(i)) + r = self.read('--kind', 'comments', '--issue', '1') + pages = json.loads(r.stdout) + self.assertEqual(pages[0][0]['body'], 'looked into it') + + # ── PR composites ──────────────────────────────────────────────────────── + + def test_pr_head_body_merge_state(self): + r = self.read('--kind', 'head', '--pr', '7') + self.assertEqual(r.stdout.strip(), f'fix-cart {SHA}') + body = json.loads(self.read('--kind', 'body', '--pr', '7').stdout) + self.assertEqual(body['headRefOid'], SHA) + ms = json.loads(self.read('--kind', 'merge-state', '--pr', '7').stdout) + self.assertEqual((ms['state'], ms['headRefOid']), ('OPEN', SHA)) + + def test_pr_metadata_and_diff(self): + meta = json.loads(self.read('--kind', 'metadata', '--pr', '7').stdout) + self.assertEqual((meta['additions'], meta['deletions'], meta['changedFiles']), (2, 1, 1)) + self.assertEqual(meta['files'][0]['path'], 'a.ts') + meta_path = self.root / 'meta.json' + meta_path.write_text(json.dumps(meta)) + r = self.read('--kind', 'diff', '--pr', '7', '--meta', str(meta_path)) + self.assertIn('diff --git a/a.ts', r.stdout) + + def test_pr_approval_parses_closes_trailer(self): + a = json.loads(self.read('--kind', 'approval', '--pr', '7').stdout) + self.assertEqual(a['closingIssues'], [{'number': 1}]) + self.assertEqual(a['headRefOid'], SHA) + + # ── board composites ───────────────────────────────────────────────────── + + def test_items_shape_matches_github_validator(self): + r = self.read('--kind', 'items', '--items', 'example/shop/4') + board = json.loads(r.stdout) + self.assertEqual(board['totalCount'], 2) # issue 3 has no column + ready = [i for i in board['items'] if i['status'] == 'Ready'][0] + self.assertEqual(ready['id'], 'gitea:101') + self.assertEqual(ready['content']['number'], 1) + self.assertEqual(ready['content']['repository'], 'example/shop') + self.assertEqual(ready['labels'], ['bug']) + + def test_fields_synthesizes_status_field(self): + f = json.loads(self.read('--kind', 'fields', '--fields', 'example/shop/4').stdout) + status = f['fields'][0] + self.assertEqual(status['name'], 'Status') + self.assertEqual({o['name']: o['id'] for o in status['options']}, {'Ready': '10', 'Done': '11'}) + + def test_project_and_projects_and_permission(self): + p = json.loads(self.read('--kind', 'project', '--project', 'example/shop/4').stdout) + self.assertEqual(p['id'], '4') + ps = json.loads(self.read('--kind', 'projects', '--projects', 'example/shop').stdout) + self.assertEqual(ps['projects'][0]['title'], 'Shop Board') + perm = json.loads(self.read('--kind', 'permission', '--permission', 'example/shop').stdout) + self.assertEqual(perm['permission'], 'admin') + + # ── lists ──────────────────────────────────────────────────────────────── + + def test_issue_history_covers_both_states(self): + r = self.read('--issue-history', 'example/shop') + states = {i['number']: i['state'] for i in json.loads(r.stdout)} + # type=issues excludes the PR-shaped entry (#3), like GraphQL repository.issues + self.assertEqual(states, {1: 'OPEN', 2: 'CLOSED'}) + + def test_prs_open_prs_merged_issues_closed(self): + opens = json.loads(self.read('--kind', 'prs-open', '--prs-open', 'example/shop').stdout) + self.assertEqual(opens[0]['headRefName'], 'fix-cart') + self.assertEqual(opens[0]['files'], [{'path': 'a.ts'}]) + self.assertEqual(json.loads(self.read('--kind', 'prs-merged', + '--prs-merged', 'example/shop').stdout), []) + closed = json.loads(self.read('--kind', 'issues-closed', '--issues-closed', 'example/shop').stdout) + self.assertEqual(closed[0]['stateReason'], 'COMPLETED') + + # ── quota ──────────────────────────────────────────────────────────────── + + def test_quota_reads_headers(self): + q = json.loads(self.read('--kind', 'quota', '--quota').stdout) + self.assertEqual(q['rate_limits_disabled'], False) + self.assertEqual(q['resources']['core']['remaining'], 3597) + self.assertEqual(q['resources']['graphql']['remaining'], 3597) + + def test_quota_disabled_instances_get_sentinels(self): + (self.root / '.git/tea-fixture/no-ratelimit').write_text('') + q = json.loads(self.read('--kind', 'quota', '--quota').stdout) + self.assertEqual(q['rate_limits_disabled'], True) + self.assertEqual(q['resources']['core']['remaining'], 5000) + + # ── usage ──────────────────────────────────────────────────────────────── + + def test_composite_flag_kind_mismatch_is_usage(self): + self.read('--kind', 'json', '--items', 'example/shop/4', expect=64) + + def test_bad_owner_repo_spec_is_usage(self): + self.read('--issue-history', 'bad spec', expect=64) + + +if __name__ == '__main__': + unittest.main() From 5702f5b368c02100f7c5de8549a1f980f6bedb77 Mon Sep 17 00:00:00 2001 From: PhucMN Date: Fri, 16 Oct 2026 15:22:53 +0700 Subject: [PATCH 2/8] =?UTF-8?q?=E2=9C=A8=20[feat]=20forge:=20gitea=20board?= =?UTF-8?q?=20adapter=20=E2=80=94=20card,=20status,=20setup?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - card.sh: forge-resolved dispatch; gitea branch reads columns/items through gitea-read and moves cards via the projects move endpoint; same cache shape, verbs and exit codes (3/64/66/69/79) - status.py: gitea branch renders the same snapshot from one normalized board read + comments for Blocked reason tags; 79 propagates from the halt file - setup.py: tea in TOOLS (brew/winget/dl.gitea.com), tea_probe (a hung binary counts as missing), forge-aware check() tool requirements, board-rank --forge gitea, board-migrate gitea (additive columns/labels, Skipped→Done, old-label mapping, --prune-empty, idempotent re-runs, snapshot under migrations/) - setup.py Windows hardening surfaced by the new paths: bash resolved via shutil.which (System32 WSL no longer shadows Git bash), UTF-8 for stdout, child-process capture and file reads - gitea-read: UTF-8 decode of tea output (emoji reason tags survived cp1252 before); gitea-api: SB_GITEA_TEA splits quoted paths - tea stub: per-project columns (_project), DELETE column route, write-route ordering fix (case globs span slashes) - tests: test-card-gitea.sh (7), test-status-gitea.sh (4), test-setup-gitea.sh (4) — all offline Co-Authored-By: Claude Code --- evals/_stubs/bin/tea | 14 +- scripts/super-board-card.sh | 110 ++++++++++--- scripts/super-board-gitea-api.sh | 6 +- scripts/super-board-gitea-read.py | 5 +- scripts/super-board-setup.py | 257 ++++++++++++++++++++++++++++-- scripts/super-board-status.py | 145 ++++++++++++----- tests/test-card-gitea.sh | 104 ++++++++++++ tests/test-setup-gitea.sh | 85 ++++++++++ tests/test-status-gitea.sh | 66 ++++++++ 9 files changed, 711 insertions(+), 81 deletions(-) create mode 100644 tests/test-card-gitea.sh create mode 100644 tests/test-setup-gitea.sh create mode 100644 tests/test-status-gitea.sh diff --git a/evals/_stubs/bin/tea b/evals/_stubs/bin/tea index 466e0864..1126f04b 100755 --- a/evals/_stubs/bin/tea +++ b/evals/_stubs/bin/tea @@ -128,7 +128,9 @@ if [ "$METHOD" = GET ]; then emit_headers; cid=$(seg 7) state -c --argjson c "$cid" '[ .issues[] | select((._column // null) == $c) ]' | strip | page_slice; exit 0 ;; repos/*/*/projects/*/columns) - emit_headers; state -c '.columns'; exit 0 ;; + # columns with no _project belong to every project (single-board fixtures) + emit_headers; pid=$(seg 5) + state -c --argjson p "$pid" '[ .columns[] | select((._project // null) == null or ._project == $p) ]'; exit 0 ;; repos/*/*/projects/*) emit_headers; pid=$(seg 5) out=$(state -c --argjson p "$pid" '.projects[] | select(.id == $p)') @@ -200,10 +202,16 @@ case "$PATHPART" in .issues = [ .issues[] | if .id == $g then ._column = $c else . end ] | .writes += 1' echo "" ;; # 204 repos/*/*/projects/*/columns) # POST create column - put_state --argjson b "$BODY" ' + pid=$(seg 5) + put_state --argjson b "$BODY" --argjson p "$pid" ' (1 + ([ .columns[].id ] + [0] | max)) as $id | - .columns += [{ id: $id, title: ($b.title // ""), color: ($b.color // "") }] | .writes += 1' + .columns += [{ id: $id, title: ($b.title // ""), color: ($b.color // ""), _project: $p }] | .writes += 1' state -c '.columns[-1]' ;; + repos/*/*/projects/*/columns/*) # DELETE one column + [ "$METHOD" = DELETE ] || { echo '{}'; exit 0; } + cid=$(seg 7) + put_state --argjson c "$cid" '.columns = [ .columns[] | select(.id != $c) ] | .writes += 1' + echo "" ;; repos/*/*/projects) # POST create project put_state --argjson b "$BODY" ' (1 + ([ .projects[].id ] + [0] | max)) as $id | diff --git a/scripts/super-board-card.sh b/scripts/super-board-card.sh index f11ea170..346856cc 100755 --- a/scripts/super-board-card.sh +++ b/scripts/super-board-card.sh @@ -37,8 +37,8 @@ # 79 reads halted (super-board-github-read.py) · 3 issue not on this board / # Status option missing. set -euo pipefail -# Fixed read commands: a malformed payload is GitHub's, so it halts (#32). -export SB_GITHUB_READ_STRICT=1 +# Fixed read commands: a malformed payload is the forge's, so it halts (#32). +export SB_GITHUB_READ_STRICT=1 SB_GITEA_READ_STRICT=1 HERE=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) CONFIG="${SB_CONFIG:-}"; OWNER="${BUILD_LOOP_OWNER:-}"; NUMBER="${BUILD_LOOP_PROJECT:-}"; REPO="" @@ -64,8 +64,24 @@ if [ -n "$CONFIG" ]; then [ -n "$NUMBER" ] || NUMBER=$(echo "$CJ" | jq -r '.project.number // ""') [ -n "$REPO" ] || REPO=$(echo "$CJ" | jq -r '.repo.remote // ""') fi -[ -n "$REPO" ] || REPO=$(git remote get-url origin 2>/dev/null || true) -REPO=$(echo "$REPO" | sed -E 's#^(https?://github\.com/|git@github\.com:)##; s#\.git$##') + +# Forge resolution (github default): on gitea, NUMBER is the project's API id +# and REPO comes from the resolver instead of the github.com strip below. +FORGE_KIND=github +if [ -f "$HERE/super-board-forge.sh" ]; then + # shellcheck source=super-board-forge.sh + . "$HERE/super-board-forge.sh" + sb_forge_resolve ${CONFIG:+"$CONFIG"} || exit $? + FORGE_KIND="$SB_FORGE_KIND" +fi + +if [ "$FORGE_KIND" = gitea ] && [ -n "$SB_FORGE_OWNER" ] && [ -n "$SB_FORGE_REPO" ]; then + [ -n "$OWNER" ] || OWNER="$SB_FORGE_OWNER" + REPO="$SB_FORGE_OWNER/$SB_FORGE_REPO" +else + [ -n "$REPO" ] || REPO=$(git remote get-url origin 2>/dev/null || true) + REPO=$(echo "$REPO" | sed -E 's#^(https?://github\.com/|git@github\.com:)##; s#\.git$##') +fi [ -n "$OWNER" ] && [ -n "$NUMBER" ] || { echo "project owner/number unknown: pass --config or --owner/--number" >&2; exit 66; } # Reads go through the kit's bounded retry helper when it is installed, so a @@ -102,6 +118,46 @@ cache_put() { # $1 = jq filter applied to the current cache, with --arg/--argjs cache_drop() { rm -f "$CACHE"; } # ── reads ─────────────────────────────────────────────────────────────── +if [ "$FORGE_KIND" = gitea ]; then + GITEA_READ="$HERE/super-board-gitea-read.py" + [ -f "$GITEA_READ" ] || { echo "gitea read wrapper missing: $GITEA_READ" >&2; exit 67; } + + load_ids() { # columns → the github-shaped {projectId, fieldId, options} triple + PROJECT_ID=$(cache_get .projectId); FIELD_ID=$(cache_get .fieldId) + OPTIONS_JSON=$(cache_get '.options // empty | tojson') + [ -n "$PROJECT_ID" ] && [ -n "$FIELD_ID" ] && [ -n "$OPTIONS_JSON" ] && return 0 + local out + out=$(python3 "$GITEA_READ" --kind fields --fields "$REPO/$NUMBER") || return $? + PROJECT_ID=$(echo "$out" | jq -r '.fields[0].id // empty') + FIELD_ID=$(echo "$out" | jq -r '.fields[0].id // empty') + OPTIONS_JSON=$(echo "$out" | jq -c '[.fields[0].options[]? | {(.name): .id}] | add // {}') + [ -n "$PROJECT_ID" ] && [ -n "$FIELD_ID" ] || { echo "project $OWNER/$NUMBER or its columns not found" >&2; return 69; } + cache_put '.projectId = $p | .fieldId = $f | .options = $o' --arg p "$PROJECT_ID" --arg f "$FIELD_ID" --argjson o "$OPTIONS_JSON" + } + + read_card() { # $1 = issue; whole-board read (Gitea has no targeted card query) + [ -n "$REPO" ] || { echo "repo unknown: pass --repo or a config with repo.remote" >&2; return 66; } + local board node + board=$(python3 "$GITEA_READ" --kind items --items "$REPO/$NUMBER") || return $? + node=$(echo "$board" | jq -c --argjson n "$1" '[.items[] | select(.content.number == $n)][0] // empty') + [ -n "$node" ] || { echo "#$1 is not on project $OWNER/$NUMBER" >&2; return 3; } + ITEM_ID=$(echo "$node" | jq -r .id) # "gitea:" + STATUS_NAME=$(echo "$node" | jq -r '.status // ""') + cache_put '.items[$k] = $v' --arg k "$1" --arg v "$ITEM_ID" + } + + set_status() { # $1 = gitea:, $2 = column id — one move, no halt on failure + local gid="${1#gitea:}" out rc=0 + . "$HERE/super-board-gitea-api.sh" + out=$(sb_gitea_api POST "repos/$REPO/projects/$NUMBER/issues/$gid/move" \ + "$(jq -cn --argjson c "$2" '{column_id:$c}')" 2>&1) || rc=$? + [ "$rc" -eq 0 ] || { echo "$out" >&2; return 69; } + } + + items() { # whole board, gh item-list shape (normalized by gitea-read) + python3 "$GITEA_READ" --kind items --items "$REPO/$NUMBER" || return $? + } +else load_ids() { # fills PROJECT_ID FIELD_ID OPTIONS_JSON — 0 points when cached, else 1 PROJECT_ID=$(cache_get .projectId); FIELD_ID=$(cache_get .fieldId) OPTIONS_JSON=$(cache_get '.options // empty | tojson') @@ -141,11 +197,6 @@ read_card() { # $1 = issue; sets ITEM_ID STATUS_NAME cache_put '.items[$k] = $v' --arg k "$1" --arg v "$ITEM_ID" } -item_id() { # $1 = issue - ITEM_ID=$(cache_get ".items[\"$1\"]") - [ -n "$ITEM_ID" ] || read_card "$1" -} - set_status() { # $1 = item id, $2 = option id — one mutation local out out=$(gh api graphql -f query='mutation($p:ID!,$i:ID!,$f:ID!,$o:String!){ @@ -154,22 +205,6 @@ set_status() { # $1 = item id, $2 = option id — one mutation echo "$out" | no_errors || { echo "$out" >&2; return 69; } } -move() { # $1 = issue, $2 = Status name - local issue="$1" name="$2" opt attempt - for attempt in 1 2; do - load_ids || return $? - opt=$(echo "$OPTIONS_JSON" | jq -r --arg n "$name" '.[$n] // empty') - if [ -z "$opt" ]; then - [ "$attempt" = 1 ] && { cache_drop; continue; } - echo "Status option '$name' is not on project $OWNER/$NUMBER" >&2; return 3 - fi - item_id "$issue" || return $? - if set_status "$ITEM_ID" "$opt"; then echo "moved #$issue → $name"; return 0; fi - [ "$attempt" = 1 ] && { echo "move failed; re-reading board ids once" >&2; cache_drop; } - done - return 69 -} - items() { # whole board, gh item-list shape, ~1 point per 100 cards local pages pages=$(gh_read api graphql --paginate --slurp -f query='query($owner:String!,$number:Int!,$endCursor:String){ @@ -200,6 +235,31 @@ items() { # whole board, gh item-list shape, ~1 point per 100 cards else error("board read incomplete: \([ $p[].nodes[] ] | length) of \($total) items") end' \ || { echo "board read incomplete" >&2; return 69; } } +fi + +# ── shared across forges ───────────────────────────────────────────────── +item_id() { # $1 = issue + ITEM_ID=$(cache_get ".items[\"$1\"]") + [ -n "$ITEM_ID" ] || read_card "$1" +} + +move() { # $1 = issue, $2 = Status name + local issue="$1" name="$2" opt attempt rc + for attempt in 1 2; do + load_ids || return $? + opt=$(echo "$OPTIONS_JSON" | jq -r --arg n "$name" '.[$n] // empty') + if [ -z "$opt" ]; then + [ "$attempt" = 1 ] && { cache_drop; continue; } + echo "Status option '$name' is not on project $OWNER/$NUMBER" >&2; return 3 + fi + item_id "$issue" || return $? + rc=0; set_status "$ITEM_ID" "$opt" || rc=$? + [ "$rc" -eq 0 ] && { echo "moved #$issue → $name"; return 0; } + [ "$rc" -eq 79 ] && return 79 + [ "$attempt" = 1 ] && { echo "move failed; re-reading board ids once" >&2; cache_drop; } + done + return 69 +} case "$VERB" in move) [ $# -eq 2 ] || { echo "usage: move " >&2; exit 64; }; move "$1" "$2" ;; diff --git a/scripts/super-board-gitea-api.sh b/scripts/super-board-gitea-api.sh index 686b0804..6f3df44c 100755 --- a/scripts/super-board-gitea-api.sh +++ b/scripts/super-board-gitea-api.sh @@ -26,10 +26,12 @@ SB_GITEA_LABEL_DEFAULT_COLOR="ededed" sb_gitea_tea() { # Run tea with a bounded lifetime; prefer coreutils timeout when present. - # SB_GITEA_TEA overrides the executable (tests point it at the offline stub). + # SB_GITEA_TEA overrides the executable (tests point it at the offline stub); + # it is split with eval so quoted paths with spaces survive — the same value + # is shlex-split by super-board-gitea-read.py. local login_flag=() tea_cmd [ -n "${SB_FORGE_LOGIN:-}" ] && login_flag=(--login "$SB_FORGE_LOGIN") - read -r -a tea_cmd <<< "${SB_GITEA_TEA:-tea}" + eval "tea_cmd=(${SB_GITEA_TEA:-tea})" if command -v timeout >/dev/null 2>&1; then timeout "$SB_GITEA_TIMEOUT" "${tea_cmd[@]}" "${login_flag[@]}" "$@" else diff --git a/scripts/super-board-gitea-read.py b/scripts/super-board-gitea-read.py index 85e8bb86..3add9e55 100755 --- a/scripts/super-board-gitea-read.py +++ b/scripts/super-board-gitea-read.py @@ -135,7 +135,10 @@ def _tea(args): if login: cmd += ['--login', login] cmd += args - r = subprocess.run(cmd, capture_output=True, text=True, timeout=TEA_TIMEOUT, env=_tea_env()) + # encoding: tea prints UTF-8 JSON; on Windows text=True would otherwise + # decode with the console codepage and mangle every emoji (reason tags!). + r = subprocess.run(cmd, capture_output=True, text=True, encoding='utf-8', + errors='replace', timeout=TEA_TIMEOUT, env=_tea_env()) return r.stdout, r.stderr, r.returncode diff --git a/scripts/super-board-setup.py b/scripts/super-board-setup.py index 2be53e49..4d343a3f 100755 --- a/scripts/super-board-setup.py +++ b/scripts/super-board-setup.py @@ -54,10 +54,19 @@ import os import platform import re +import shlex import shutil import subprocess import sys +# Windows consoles default to cp1252: the ✓ lists and install.sh's emoji output +# would crash every onboard step. status.py already reconfigures the same way. +for _stream in (sys.stdout, sys.stderr): + try: + _stream.reconfigure(encoding="utf-8", errors="replace") # type: ignore[attr-defined] + except Exception: + pass + COLUMNS = ["Backlog", "Ready", "Building", "QA", "Review", "Blocked", "Done"] LABELS = { "qa": ("0e8a16", "Test what exists; skips Building (super-board)"), @@ -86,6 +95,10 @@ "dnf": "sudo dnf install -y git", "win": "winget install --id Git.Git -e"}), "gh": ("reads and moves cards on GitHub", {"mac": "brew install gh", "apt": "sudo apt-get install -y gh", "dnf": "sudo dnf install -y gh", "win": "winget install --id GitHub.cli -e"}), + "tea": ("reads and moves cards on Gitea", {"mac": "brew install tea", + "apt": "curl -fsSL https://dl.gitea.com/tea/0.16.0/tea-0.16.0-linux-amd64 -o /usr/local/bin/tea && sudo chmod +x /usr/local/bin/tea", + "dnf": "curl -fsSL https://dl.gitea.com/tea/0.16.0/tea-0.16.0-linux-amd64 -o /usr/local/bin/tea && sudo chmod +x /usr/local/bin/tea", + "win": "winget install --id Gitea.tea -e"}), "jq": ("the board scripts read JSON with it", {"mac": "brew install jq", "apt": "sudo apt-get install -y jq", "dnf": "sudo dnf install -y jq", "win": "winget install --id jqlang.jq -e"}), "node": ("the helper installer; actual skill files are checked separately", @@ -101,8 +114,11 @@ def out(obj, code=0): return code -def run(cmd, cwd=None, check=False, input=None): - r = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, input=input) +def run(cmd, cwd=None, check=False, input=None, timeout=None): + # encoding: child scripts print UTF-8 (emoji, ✓); Windows would otherwise + # decode them with the console codepage and die mid-onboard. + r = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True, input=input, + timeout=timeout, encoding="utf-8", errors="replace") if check and r.returncode != 0: raise RuntimeError(f"{' '.join(cmd[:3])} failed: {(r.stderr or r.stdout).strip()[:300]}") return r @@ -134,7 +150,7 @@ def vtuple(v): def read(path, default=""): try: - with open(path) as f: + with open(path, encoding="utf-8", errors="replace") as f: return f.read().strip() except OSError: return default @@ -142,7 +158,7 @@ def read(path, default=""): def load_json(path): try: - with open(path) as f: + with open(path, encoding="utf-8") as f: return json.load(f) except (OSError, ValueError): return None @@ -150,7 +166,7 @@ def load_json(path): def write_json(path, data): tmp = path + ".tmp" - with open(tmp, "w") as f: + with open(tmp, "w", encoding="utf-8") as f: json.dump(data, f, indent=2) f.write("\n") os.replace(tmp, path) @@ -310,6 +326,10 @@ def check(root, pack, host="claude", home=None, catalog=None): old_dirs = [d for d in OLD_SKILL_DIRS if os.path.isdir(os.path.join(claude, "skills", d))] configs = {} verification = {} + forges = set() + env_forge = (os.environ.get("SB_FORGE") or "").strip().lower() + if env_forge: + forges.add(env_forge) for p in sorted(glob.glob(os.path.join(claude, "super-board", "configs", "*.json"))): cfg = load_json(p) ready = subprocess.run([sys.executable, os.path.join(os.path.dirname(__file__), @@ -318,6 +338,7 @@ def check(root, pack, host="claude", home=None, catalog=None): if ready.returncode: verification[os.path.relpath(p, root)] = ready.stderr.strip() if isinstance(cfg, dict): + forges.add((cfg.get("forge") or "github").strip().lower()) _, ch = migrate_config(cfg) if ch: configs[os.path.relpath(p, root)] = ch @@ -328,13 +349,26 @@ def check(root, pack, host="claude", home=None, catalog=None): from_v = upgrade_rec.get("from") or (have_v if have_v and pack_version and vtuple(have_v) < vtuple(pack_version) else None) fam = os_family() needs = [] - for t in ("git", "gh", "jq", "node"): + # Forge-aware tool requirements: gh for github boards (and while no config + # exists yet — github stays the default), tea for gitea boards. + tools = ["git", "jq", "node"] + if not forges or "github" in forges: + tools.insert(1, "gh") + if "gitea" in forges: + tools.append("tea") + for t in tools: if not have(t if t != "node" else "npx"): why, cmds = TOOLS[t] cmd = cmds[fam] if t == "node": cmd += " && " + HELPERS_CMD needs.append({"kind": "tool", "name": t, "why": why, "command": cmd}) + elif t == "tea" and not tea_probe(): + # A tea binary that hangs (seen on Windows builds) is worse than a + # missing one: every board call would block until its timeout. + needs.append({"kind": "tool", "name": "tea", + "why": "tea is installed but did not answer `tea --version` within 5s — reinstall it", + "command": TOOLS["tea"][1][fam]}) readiness = helper_readiness(root, host, home, catalog) helpers = readiness["ready"] git = is_git_repo(root) @@ -357,6 +391,14 @@ def check(root, pack, host="claude", home=None, catalog=None): } +def bash_exe(): + """Full path to a usable bash. On Windows a bare "bash" resolves through + System32 before PATH, so a broken WSL relay shadows Git's bash and every + install.sh run dies with execvpe(/bin/bash); shutil.which respects PATH + order, so the first working bash the user installed is the one we run.""" + return shutil.which("bash") or "bash" + + def backup(root, paths, stamp): dest = os.path.join(root, ".claude", "super-board", "backup", stamp) for p in paths: @@ -384,7 +426,7 @@ def fix(root, pack, helpers=True, dry=False, host="claude", home=None, catalog=N if not pack: return {**before, "fixed": [], "error": "pack-not-found"} if not dry: - r = run(["bash", os.path.join(pack, "install.sh"), root], + r = run([bash_exe(), os.path.join(pack, "install.sh"), root], input="", cwd=root) if r.returncode != 0: return {**before, "fixed": fixed, "error": "install.sh failed: " + (r.stderr or r.stdout)[-300:]} @@ -428,7 +470,7 @@ def fix(root, pack, helpers=True, dry=False, host="claude", home=None, catalog=N if helpers and not before["helper_skills"] and have("npx"): if not dry: - r = run(["bash", "-c", HELPERS_CMD], cwd=root, input="") + r = run([bash_exe(), "-c", HELPERS_CMD], cwd=root, input="") confirmed = helper_readiness(root, host, home, catalog) if confirmed["ready"]: fixed.append("worker skills re-resolved after helper installation") @@ -566,6 +608,193 @@ def board_rank(owner): return {"owner": owner, "boards": ranked, "recommend": best and best["number"]} +# ── Gitea board: rank and migrate (via tea api) ─────────────────────────────── + +GITEA_COLUMN_COLORS = {"Backlog": "#6b7280", "Ready": "#2563eb", "Building": "#d97706", + "QA": "#ea580c", "Review": "#7c3aed", "Blocked": "#dc2626", "Done": "#16a34a"} +GITEA_LABEL_COLORS = {"qa": "#0e8a16", "bug": "#d73a4a", "feature": "#1d76db"} +LABEL_DESCRIPTIONS = {"qa": "Test what exists; skips Building (super-board)", + "bug": "Something is broken; built, tested, reviewed (super-board)", + "feature": "New behaviour; built, tested, reviewed (super-board)"} + + +def tea_cmd(): + """The tea executable; SB_GITEA_TEA overrides it (tests use the offline stub).""" + cmd = shlex.split(os.environ.get("SB_GITEA_TEA", "tea")) + login = os.environ.get("SB_FORGE_LOGIN") + if login: + cmd += ["--login", login] + return cmd + + +def tea_probe(): + """True when tea answers --version within 5s. A hung binary counts as absent.""" + try: + r = run(tea_cmd() + ["--version"], timeout=5) + return r.returncode == 0 + except (OSError, subprocess.TimeoutExpired): + return False + + +def tea_json(*args, input=None, timeout=30): + """One `tea api` call → parsed JSON. Raises RuntimeError like gh_json. + `input` becomes the request body via -d (tea also accepts -d @-, but a + direct argument keeps the offline stub and the real CLI on one path).""" + a = list(args) + if input is not None: + a += ["-d", input] + r = run(tea_cmd() + ["api", *a], timeout=timeout) + if r.returncode != 0: + raise RuntimeError(f"tea {' '.join(args[:3])}: {(r.stderr or r.stdout).strip()[:300]}") + try: + return json.loads(r.stdout.strip() or "null") # 204s answer with an empty body + except ValueError: + raise RuntimeError(f"tea {' '.join(args[:3])} printed non-JSON: {r.stdout.strip()[:200]}") + + +def board_rank_gitea(owner, repo): + """The repo's Gitea projects, best column match first — same output shape + as board_rank so onboard step 3 renders either forge identically. + `repo` is already "owner/name" (the board-migrate convention).""" + base = f"repos/{repo}" + projects = tea_json("-X", "GET", f"{base}/projects") or [] + ranked = [] + for p in projects: + if not isinstance(p, dict) or not p.get("id"): + continue + if p.get("state") == "closed" or p.get("is_closed"): + continue + cols = tea_json("-X", "GET", f"{base}/projects/{p['id']}/columns") or [] + have = [c.get("title", "") for c in cols if isinstance(c, dict)] + cards = 0 + for c in cols: + issues = tea_json("-X", "GET", f"{base}/projects/{p['id']}/columns/{c['id']}/issues?page=1&limit=50") or [] + cards += len(issues) + low = {h.lower() for h in have} + match = [c for c in COLUMNS if c.lower() in low] + ranked.append({"number": p["id"], "title": p.get("title"), "url": p.get("html_url"), + "cards": cards, "matches": len(match), + "missing": [c for c in COLUMNS if c not in match], + "extra": [h for h in have if h.lower() not in {c.lower() for c in COLUMNS}]}) + ranked.sort(key=lambda r: (-r["matches"], -r["cards"], -r["number"])) + best = ranked[0] if ranked and ranked[0]["matches"] >= 4 else None + return {"owner": owner, "boards": ranked, "recommend": best and best["number"]} + + +def board_migrate_gitea(owner, number, repo, qa_all=False, dry=False, prune_empty=False, root=None, config_path=None): + """Gitea board half: additive only. Creates the seven columns and three + labels when missing, maps old type labels, moves Skipped cards to Done and + removes the Skipped column, and (with --prune-empty) deletes empty + non-canonical columns. Gitea has no destructive field rewrite, so there is + no option-remap recovery record — but the pre-write snapshot is still saved + under .claude/super-board/migrations/ and every step is idempotent: re-run + the same command after a failure to finish the upgrade. + `repo` is already "owner/name" (the board-migrate convention).""" + base = f"repos/{repo}" + proj = tea_json("-X", "GET", f"{base}/projects/{number}") + if not isinstance(proj, dict) or not proj.get("id"): + raise RuntimeError("Gitea omitted the project identity") + cols = tea_json("-X", "GET", f"{base}/projects/{number}/columns") or [] + snapshot = {"project": proj, "columns": cols, + "issues": {str(c["id"]): tea_json("-X", "GET", f"{base}/projects/{number}/columns/{c['id']}/issues?page=1&limit=50") or [] + for c in cols if isinstance(c, dict) and c.get("id")}} + path = os.path.join(root or os.getcwd(), ".claude", "super-board", "migrations", + f"gitea-board-{number}.json") + result = {"forge": "gitea", "url": proj.get("html_url"), "added_columns": [], + "labels_created": [], "labels_mapped": 0, "qa_labelled": 0, + "skipped_moved": 0, "skipped_removed": False, "pruned": [], + "snapshot": None, "dry": dry} + by_title = {c.get("title"): c for c in cols if isinstance(c, dict)} + result["added_columns"] = [c for c in COLUMNS if c not in by_title] + labels = tea_json("-X", "GET", f"{base}/labels") or [] + label_by_name = {l.get("name", "").lower(): l for l in labels if isinstance(l, dict)} + result["labels_created"] = [n for n in GITEA_LABEL_COLORS if n not in label_by_name] + if dry: + skipped = by_title.get("Skipped") + if skipped: + result["skipped_moved"] = len(snapshot["issues"].get(str(skipped["id"]), [])) + result["skipped_removed"] = True + return result + + os.makedirs(os.path.dirname(path), exist_ok=True) + write_json(path, snapshot) + result["snapshot"] = os.path.relpath(path, root or os.getcwd()) + + for title in COLUMNS: + if title in by_title: + continue + created = tea_json("-X", "POST", f"{base}/projects/{number}/columns", + input=json.dumps({"title": title, "color": GITEA_COLUMN_COLORS[title]})) + if not isinstance(created, dict) or not created.get("id"): + raise RuntimeError(f"Could not verify creation of column {title}") + by_title[title] = created + for name, color in GITEA_LABEL_COLORS.items(): + if name in label_by_name: + continue + created = tea_json("-X", "POST", f"{base}/labels", + input=json.dumps({"name": name, "color": color, + "description": LABEL_DESCRIPTIONS[name]})) + if not isinstance(created, dict) or not created.get("id"): + raise RuntimeError(f"Could not verify creation of label {name}") + label_by_name[name] = created + + # Walk every column once: old type labels → the three v3 labels, qa_all on + # active cards, and Skipped → Done. Gitea's POST issue-labels is ADDITIVE + # (removals go through DELETE …/labels/{id}). No compare-and-swap exists; + # every step is idempotent, so re-running after a failure finishes the job. + skipped = by_title.get("Skipped") + done = by_title.get("Done") + for title, col in by_title.items(): + issues = tea_json("-X", "GET", f"{base}/projects/{number}/columns/{col['id']}/issues?page=1&limit=50") or [] + for it in issues: + if not isinstance(it, dict) or not it.get("id"): + continue + current = {l.get("name", "").lower(): l.get("id") for l in (it.get("labels") or []) if isinstance(l, dict)} + add, drop = set(), [] + for old, new in OLD_LABELS.items(): + if old in current: + drop.append(current[old]) + add.add(new) + if title == "Skipped": + if done: + tea_json("-X", "POST", f"{base}/projects/{number}/issues/{it['id']}/move", + input=json.dumps({"column_id": done["id"]})) + result["skipped_moved"] += 1 + elif qa_all and title != "Done" and not (set(current) & set(GITEA_LABEL_COLORS)): + add.add("qa") + for lid in drop: + tea_json("-X", "DELETE", f"{base}/issues/{it['number']}/labels/{lid}") + if drop: + result["labels_mapped"] += len(drop) + add_ids = [label_by_name[n]["id"] for n in sorted(add) if n in label_by_name] + if add_ids: + if "qa" in add: + result["qa_labelled"] += 1 + tea_json("-X", "POST", f"{base}/issues/{it['number']}/labels", + input=json.dumps({"labels": add_ids})) + if skipped: + left = tea_json("-X", "GET", f"{base}/projects/{number}/columns/{skipped['id']}/issues?page=1&limit=50") or [] + if not left: + tea_json("-X", "DELETE", f"{base}/projects/{number}/columns/{skipped['id']}") + result["skipped_removed"] = True + else: + raise RuntimeError(f"Skipped column still holds {len(left)} cards; move them and re-run") + if prune_empty: + for c in cols: + title = c.get("title") + if not isinstance(c, dict) or title in COLUMNS or title == "Skipped": + continue + issues = tea_json("-X", "GET", f"{base}/projects/{number}/columns/{c['id']}/issues?page=1&limit=50") or [] + if not issues: + tea_json("-X", "DELETE", f"{base}/projects/{number}/columns/{c['id']}") + result["pruned"].append(title) + if config_path: + current = load_json(config_path) + if isinstance(current, dict) and current.pop("_qa_all", None) is not None: + durable_json(os.path.abspath(config_path), current) + return result + + OPTIONS_Q = "query($id:ID!){node(id:$id){... on ProjectV2SingleSelectField{options{id name color description}}}}" UPDATE_M = ("mutation($id:ID!,$opts:[ProjectV2SingleSelectFieldOptionInput!]!){updateProjectV2Field(input:" "{fieldId:$id,singleSelectOptions:$opts}){projectV2Field{... on ProjectV2SingleSelectField{options{id name}}}}}") @@ -1003,6 +1232,11 @@ def main(argv): owner = flag(rest, "--owner") if not owner: return 64 + if (flag(rest, "--forge") or "github").lower() == "gitea": + repo = flag(rest, "--repo") + if not repo: + return 64 + return out(board_rank_gitea(owner, repo)) return out(board_rank(owner)) if cmd == "board-migrate": # --config fills owner / number / repo and the qa-all flag an upgraded @@ -1022,7 +1256,12 @@ def main(argv): if not (owner and number and repo): return 64 qa_all = "--qa-all" in rest or bool(cfg.get("_qa_all")) - res = board_migrate(owner, int(number), repo, qa_all, dry, "--prune-empty" in rest, root, cfg_path) + forge_name = (flag(rest, "--forge") or cfg.get("forge") or os.environ.get("SB_FORGE") or "github").lower() + if forge_name == "gitea": + res = board_migrate_gitea(owner, int(number), repo, qa_all, dry, + "--prune-empty" in rest, root, cfg_path) + else: + res = board_migrate(owner, int(number), repo, qa_all, dry, "--prune-empty" in rest, root, cfg_path) return out(res) except (RuntimeError, OSError, ValueError, KeyError, TypeError) as e: return out({"error": str(e)}, 2) diff --git a/scripts/super-board-status.py b/scripts/super-board-status.py index b9530a10..5a12198b 100755 --- a/scripts/super-board-status.py +++ b/scripts/super-board-status.py @@ -39,7 +39,9 @@ from __future__ import annotations import datetime +import importlib.util import json +import os import re import subprocess import sys @@ -368,6 +370,40 @@ def gh(*args: str, check: bool = True) -> str: return proc.stdout +# ───────────────────────────── gitea ───────────────────────────── +# Same read-only contract through the gitea twin of github-read: the wrapper +# normalizes Gitea REST into the shapes this renderer already consumes. + +def forge_resolve(config_path: Path) -> dict[str, Any]: + """super-board-forge.py resolve() as a module (dashes rule out import).""" + path = Path(__file__).resolve().with_name("super-board-forge.py") + spec = importlib.util.spec_from_file_location("super_board_forge", path) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + res = mod.resolve(str(config_path)) + mod.check(res) + return res + + +def gitea_read(*args: str, check: bool = True, env: dict[str, str] | None = None) -> str: + """Run super-board-gitea-read.py; 79 (halt) propagates, others exit 67.""" + helper = Path(__file__).resolve().with_name("super-board-gitea-read.py") + try: + proc = subprocess.run([sys.executable, str(helper), *args], capture_output=True, + text=True, encoding="utf-8", check=False, env=env) + except OSError as e: + print(f"gitea read could not start: {e}", file=sys.stderr) + sys.exit(67) + if proc.returncode != 0: + if check: + print(f"gitea read failed ({' '.join(args[:4])}…)", file=sys.stderr) + if proc.stderr.strip(): + print(proc.stderr.strip()[:800], file=sys.stderr) + sys.exit(79 if proc.returncode == 79 else 67) + return "" + return proc.stdout + + # ───────────────────────────── GraphQL ───────────────────────────── # Targeted query — number, title, labels, Status only. ~3 KB vs. 100+ KB for # `gh project item-list --format json` (which slurps every issue body). @@ -515,27 +551,68 @@ def main() -> int: run_date = datetime.date.today().isoformat() manifest_path = Path(runs_dir) / f"{run_date}-{config_slug}.md" - # ── fetch project items (paginated) ── - def fetch_page(after: str | None) -> dict[str, Any]: - args = [ - "api", "graphql", - "-f", f"query={ITEMS_QUERY}", - "-F", f"owner={project_owner}", - "-F", f"number={project_number}", - ] - if after: - # First page leaves `$after` unset → GraphQL defaults to null. - args += ["-F", f"after={after}"] - out = gh(*args) - payload: dict[str, Any] = json.loads(out) - if payload.get("errors"): - print("graphql returned errors:", file=sys.stderr) - for err in payload["errors"]: - print(f" - {err.get('message')}", file=sys.stderr) - sys.exit(67) - return payload + forge = (os.environ.get("SB_FORGE") or cfg.get("forge") or "github").strip().lower() + genv: dict[str, str] | None = None + items: list[dict[str, Any]] = [] + hit_cap = False + + if forge == "gitea": + # ── gitea: one normalized board read (columns + per-column issues) ── + try: + res = forge_resolve(config_path) + except (ValueError, LookupError) as e: + print(f"forge config: {e}", file=sys.stderr) + return 66 + genv = dict(os.environ, GITEA_REPO=f"{res['owner']}/{res['repo']}") + board = json.loads(gitea_read("--kind", "items", "--items", + f"{res['owner']}/{res['repo']}/{project_number}", env=genv)) + for it in board.get("items") or []: + c = it.get("content") or {} + if not c.get("number"): + continue + items.append({ + "number": c["number"], + "title": sanitize_title(it.get("title") or c.get("title") or ""), + "labels": it.get("labels") or [], + "status": it.get("status") or "", + }) + else: + # ── github: fetch project items (paginated GraphQL) ── + def fetch_page(after: str | None) -> dict[str, Any]: + args = [ + "api", "graphql", + "-f", f"query={ITEMS_QUERY}", + "-F", f"owner={project_owner}", + "-F", f"number={project_number}", + ] + if after: + # First page leaves `$after` unset → GraphQL defaults to null. + args += ["-F", f"after={after}"] + out = gh(*args) + payload: dict[str, Any] = json.loads(out) + if payload.get("errors"): + print("graphql returned errors:", file=sys.stderr) + for err in payload["errors"]: + print(f" - {err.get('message')}", file=sys.stderr) + sys.exit(67) + return payload + + items_raw, hit_cap = paginate_items(fetch_page) + for n in items_raw: + c = n.get("content") or {} + if not c.get("number"): + continue + items.append({ + "number": c["number"], + "title": sanitize_title(c.get("title") or ""), + "labels": [ + l["name"] + for l in (c.get("labels", {}).get("nodes") or []) + if l.get("name") + ], + "status": field_status(n), + }) - items_raw, hit_cap = paginate_items(fetch_page) if hit_cap: print( f"warning: stopped after {MAX_ITEM_PAGES * 100} items — " @@ -543,22 +620,6 @@ def fetch_page(after: str | None) -> dict[str, Any]: file=sys.stderr, ) - items: list[dict[str, Any]] = [] - for n in items_raw: - c = n.get("content") or {} - if not c.get("number"): - continue - items.append({ - "number": c["number"], - "title": sanitize_title(c.get("title") or ""), - "labels": [ - l["name"] - for l in (c.get("labels", {}).get("nodes") or []) - if l.get("name") - ], - "status": field_status(n), - }) - by_status: dict[str, list[dict[str, Any]]] = { s: sorted([i for i in items if i["status"] == s], key=lambda x: -x["number"]) for s in BOARD_ORDER @@ -571,14 +632,16 @@ def fetch_page(after: str | None) -> dict[str, Any]: reasons: dict[int, str] = {} for it in by_status["Blocked"]: n = it["number"] - out = gh("issue", "view", str(n), "--json", "comments", check=False) - if not out: - continue try: - comments = json.loads(out).get("comments") or [] + if forge == "gitea": + out = gitea_read("--kind", "comments", "--issue", str(n), check=False, env=genv) + comments = [c for page in json.loads(out) for c in page] if out else [] + else: + out = gh("issue", "view", str(n), "--json", "comments", check=False) + comments = json.loads(out).get("comments") or [] if out else [] except json.JSONDecodeError: continue - comments.sort(key=lambda c: c.get("createdAt", "")) + comments.sort(key=lambda c: c.get("createdAt") or c.get("created_at") or "") body = (comments[-1].get("body") if comments else "") or "" reasons[n] = body[:4000] diff --git a/tests/test-card-gitea.sh b/tests/test-card-gitea.sh new file mode 100644 index 00000000..8ef27667 --- /dev/null +++ b/tests/test-card-gitea.sh @@ -0,0 +1,104 @@ +#!/usr/bin/env bash +# Tests super-board-card.sh's gitea branch against the offline tea stub. +# No network. Pins the same promises as test-card.sh: a warm move is ONE +# write, a cold one is two reads plus the write, an unknown column re-reads +# once then exits 3, and a rejected read halts (79) instead of retrying forever. +set -euo pipefail +cd "$(dirname "$0")" +CARD="$PWD/../scripts/super-board-card.sh" +STUB="$PWD/../evals/_stubs/bin/tea" +TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT +fail() { echo "FAIL: $1" >&2; exit 1; } +pass=0; ok() { pass=$((pass + 1)); echo " ✅ $1"; } + +mkdir -p "$TMP/.git" +cat > "$TMP/.git/tea-state.json" <<'EOF' +{"issues":[ + {"id":101,"number":1,"title":"Cart bug","body":"x","state":"open","labels":[{"id":3,"name":"bug"}],"_column":10}, + {"id":102,"number":2,"title":"Ship it","body":"y","state":"open","labels":[],"_column":11}], + "pulls":[], + "labels":[{"id":3,"name":"bug","color":"#d73a4a"}], + "projects":[{"id":4,"title":"Board"}], + "columns":[{"id":10,"title":"Ready"},{"id":11,"title":"Done"}], + "comments":{},"writes":0} +EOF +cat > "$TMP/cfg.json" <<'EOF' +{"forge":"gitea","forge_host":"http://localhost:3000", + "project":{"owner":"example","title":"Board","number":4}, + "repo":{"path":".","remote":"http://localhost:3000/example/shop.git"}} +EOF +cat > "$TMP/hang-tea" <<'EOF' +#!/usr/bin/env bash +echo "tea $*" >> "$PWD/.git/tea-calls.log" +echo "ServerError: 404 not found" >&2 +exit 1 +EOF + +# SB_GITEA_TEA names the tea executable; on Windows an extensionless PATH stub +# loses to the real tea.exe in CreateProcess, so run the stub through Git bash +# by absolute path (forward slashes; both shlex and bash word-splitting agree). +if [ -x "/c/Program Files/Git/usr/bin/bash.exe" ]; then + BASH_EXE="C:/Program Files/Git/usr/bin/bash.exe" +else + BASH_EXE="bash" +fi +export SB_GITEA_TEA="\"$BASH_EXE\" $(cygpath -m "$STUB" 2>/dev/null || echo "$STUB")" \ + SB_CARD_CACHE_DIR="$TMP/cache" \ + SB_GITHUB_HALT_FILE="$TMP/halt.json" SB_GITEA_RETRY_DELAY=0 +card() { (cd "$TMP" && "$CARD" --config "$TMP/cfg.json" "$@"); } +calls() { grep -c "$1" "$TMP/.git/tea-calls.log" 2>/dev/null || true; } +writes() { grep -c "$1" "$TMP/.git/tea-writes.log" 2>/dev/null || true; } +reset_logs() { : > "$TMP/.git/tea-calls.log"; : > "$TMP/.git/tea-writes.log"; } + +# 1 — cold move: fields read + items read + ONE move write, right column. +reset_logs +OUT=$(card move 1 Done) || fail "cold move" +[ "$OUT" = "moved #1 → Done" ] || fail "cold move output: $OUT" +[ "$(writes move)" = 1 ] || fail "cold move writes: $(cat "$TMP/.git/tea-writes.log")" +grep move "$TMP/.git/tea-writes.log" | grep -q '"column_id":11' || fail "wrong column: $(cat "$TMP/.git/tea-writes.log")" +jq -e '(.issues[] | select(.id==101) | ._column) == 11' "$TMP/.git/tea-state.json" >/dev/null || fail "state not moved" +ok "cold move = 2 reads + 1 move, right column" + +# 2 — warm move: ids and the item id are cached from test 1, so it is ONE write. +reset_logs +card move 1 Ready >/dev/null || fail "warm move" +[ "$(calls 'tea api')" = 1 ] && [ "$(writes move)" = 1 ] || fail "warm move calls: $(cat "$TMP/.git/tea-calls.log")" +ok "warm move = 1 write" + +# 3 — cache shape matches the github one (board--.json). +[ -f "$TMP/cache/board-example-4.json" ] || fail "cache file missing" +jq -e '.items["1"] == "gitea:101" and .options.Done == "11"' "$TMP/cache/board-example-4.json" >/dev/null \ + || fail "cache content: $(cat "$TMP/cache/board-example-4.json")" +ok "cache holds gitea ids in the github cache shape" + +# 4 — a column the board does not have: re-read once, exit 3, no write. +reset_logs +RC=0; card move 1 Shipping >/dev/null 2>&1 || RC=$? +[ "$RC" = 3 ] || fail "unknown column should exit 3, got $RC" +[ "$(writes POST)" = 0 ] || fail "unknown column must not write" +ok "unknown column → re-read, exit 3, no write" + +# 5 — an issue that is not on the board: exit 3. +reset_logs +RC=0; card move 999 Ready >/dev/null 2>&1 || RC=$? +[ "$RC" = 3 ] || fail "off-board issue should exit 3, got $RC" +ok "off-board issue → exit 3" + +# 6 — status and items verbs serve the normalized shapes. +[ "$(card status 2)" = "Done" ] || fail "status: $(card status 2)" +card items | jq -e '.totalCount == 2 and (.items[0].content.repository == "example/shop")' >/dev/null \ + || fail "items shape: $(card items)" +card ids | jq -e '.options.Ready == "10"' >/dev/null || fail "ids: $(card ids)" +ok "status / items / ids verbs" + +# 7 — a rejected read (permanent 404) halts on the first attempt: exit 79. +rm -f "$TMP/halt.json" "$TMP/cache/board-example-4.json" +reset_logs +export SB_GITEA_TEA="\"$BASH_EXE\" $(cygpath -m "$TMP/hang-tea" 2>/dev/null || echo "$TMP/hang-tea")" +RC=0; card items >/dev/null 2>&1 || RC=$? +[ "$RC" = 79 ] || fail "permanent error should halt 79, got $RC" +[ -f "$TMP/halt.json" ] || fail "halt file missing" +[ "$(calls 'tea api')" = 1 ] || fail "permanent error retried: $(cat "$TMP/.git/tea-calls.log")" +ok "permanent read error → halt (79), no retry" + +echo "test-card-gitea: $pass passed" diff --git a/tests/test-setup-gitea.sh b/tests/test-setup-gitea.sh new file mode 100644 index 00000000..d7fc07df --- /dev/null +++ b/tests/test-setup-gitea.sh @@ -0,0 +1,85 @@ +#!/usr/bin/env bash +# Tests super-board-setup.py's gitea board commands (board-rank, board-migrate) +# against the offline tea stub. No network. The github halves stay covered by +# test-setup.sh; this suite pins the gitea output shapes onboard consumes. +set -euo pipefail +cd "$(dirname "$0")" +SETUP="$PWD/../scripts/super-board-setup.py" +STUB="$PWD/../evals/_stubs/bin/tea" +TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT +fail() { echo "FAIL: $1" >&2; exit 1; } +pass=0; ok() { pass=$((pass + 1)); echo " ✅ $1"; } + +mkdir -p "$TMP/.git" +if [ -x "/c/Program Files/Git/usr/bin/bash.exe" ]; then + BASH_EXE="C:/Program Files/Git/usr/bin/bash.exe" +else + BASH_EXE="bash" +fi +export SB_GITEA_TEA="\"$BASH_EXE\" $(cygpath -m "$STUB" 2>/dev/null || echo "$STUB")" + +seed() { cat > "$TMP/.git/tea-state.json"; } + +# ── board-rank ─────────────────────────────────────────────────────────────── +seed <<'EOF' +{"issues":[{"id":101,"number":1,"title":"a","body":"","state":"open","labels":[],"_column":2}], + "pulls":[],"labels":[], + "projects":[{"id":4,"title":"Shop Board","html_url":"u4"},{"id":5,"title":"Empty","html_url":"u5"}], + "columns":[{"id":1,"title":"Backlog","_project":4},{"id":2,"title":"Ready","_project":4}, + {"id":9,"title":"Todo","_project":5}], + "comments":{},"writes":0} +EOF +OUT=$(cd "$TMP" && python3 "$SETUP" board-rank --owner example --repo example/shop --forge gitea) || fail "board-rank exit" +echo "$OUT" | jq -e '.boards | length == 2' >/dev/null || fail "boards: $OUT" +echo "$OUT" | jq -e '.boards[0].number == 4 and .boards[0].matches == 2' >/dev/null || fail "rank order: $OUT" +echo "$OUT" | jq -e '.boards[0].missing | index("Done")' >/dev/null || fail "missing columns: $OUT" +echo "$OUT" | jq -e '.recommend == null' >/dev/null || fail "recommend with 2 matches should be null: $OUT" +ok "board-rank gitea ranks repo projects by column match" + +# ── board-migrate: adds columns + labels, moves Skipped → Done, removes it ─── +seed <<'EOF' +{"issues":[ + {"id":101,"number":1,"title":"old bug","body":"","state":"open","labels":[{"id":8,"name":"bugfix"}],"_column":3}, + {"id":102,"number":2,"title":"ready thing","body":"","state":"open","labels":[],"_column":2}], + "pulls":[], + "labels":[{"id":8,"name":"bugfix","color":"#ff0000"}], + "projects":[{"id":4,"title":"Shop Board","html_url":"u4"}], + "columns":[{"id":2,"title":"Ready"},{"id":3,"title":"Skipped"},{"id":4,"title":"Done"}], + "comments":{},"writes":0} +EOF +OUT=$(cd "$TMP" && python3 "$SETUP" board-migrate --owner example --number 4 --repo example/shop \ + --forge gitea --root "$TMP") || fail "board-migrate exit: $OUT" +echo "$OUT" | jq -e '.added_columns == ["Backlog","Building","QA","Review","Blocked"]' >/dev/null || fail "added_columns: $OUT" +echo "$OUT" | jq -e '(.labels_created | sort) == ["bug","feature","qa"]' >/dev/null || fail "labels_created: $OUT" +echo "$OUT" | jq -e '.skipped_moved == 1 and .skipped_removed == true' >/dev/null || fail "skipped handling: $OUT" +echo "$OUT" | jq -e '.labels_mapped == 1' >/dev/null || fail "old label mapping: $OUT" +jq -e '[.columns[].title] | (index("Backlog") != null) and (index("Skipped") == null)' \ + "$TMP/.git/tea-state.json" >/dev/null || fail "columns after migrate: $(jq -c '[.columns[].title]' "$TMP/.git/tea-state.json")" +jq -e '(.issues[] | select(.id==101) | ._column) == 4' "$TMP/.git/tea-state.json" >/dev/null \ + || fail "skipped card not moved to Done" +jq -e '(.issues[] | select(.id==101) | .labels | map(.name)) | (index("bug") != null) and (index("bugfix") == null)' \ + "$TMP/.git/tea-state.json" >/dev/null || fail "label conversion: $(jq -c '.issues[0].labels' "$TMP/.git/tea-state.json")" +[ -f "$TMP/.claude/super-board/migrations/gitea-board-4.json" ] || fail "snapshot missing" +ok "board-migrate gitea: columns, labels, Skipped→Done, snapshot" + +# ── board-migrate is idempotent: re-running changes nothing ────────────────── +OUT2=$(cd "$TMP" && python3 "$SETUP" board-migrate --owner example --number 4 --repo example/shop \ + --forge gitea --root "$TMP") || fail "re-run exit: $OUT2" +echo "$OUT2" | jq -e '.added_columns == [] and .labels_created == [] and .skipped_moved == 0 and .labels_mapped == 0' >/dev/null \ + || fail "re-run not a no-op: $OUT2" +ok "board-migrate gitea re-run is a no-op" + +# ── dry run writes nothing ─────────────────────────────────────────────────── +seed <<'EOF' +{"issues":[],"pulls":[],"labels":[], + "projects":[{"id":6,"title":"Fresh","html_url":"u6"}], + "columns":[{"id":1,"title":"Todo"}], + "comments":{},"writes":0} +EOF +OUT=$(cd "$TMP" && python3 "$SETUP" board-migrate --owner example --number 6 --repo example/shop \ + --forge gitea --root "$TMP" --dry-run --prune-empty) || fail "dry exit: $OUT" +echo "$OUT" | jq -e '.dry == true and (.added_columns | length == 7)' >/dev/null || fail "dry plan: $OUT" +jq -e '[.columns[].title] == ["Todo"]' "$TMP/.git/tea-state.json" >/dev/null || fail "dry run mutated state" +ok "dry-run plans all seven columns, mutates nothing" + +echo "test-setup-gitea: $pass passed" diff --git a/tests/test-status-gitea.sh b/tests/test-status-gitea.sh new file mode 100644 index 00000000..8a3fb14c --- /dev/null +++ b/tests/test-status-gitea.sh @@ -0,0 +1,66 @@ +#!/usr/bin/env bash +# Tests super-board-status.py's gitea branch end-to-end against the offline tea +# stub: one normalized board read, Blocked reason-tags from comments, exit 0. +# No network. The github branch stays covered by test_status_parse.py + CI. +set -euo pipefail +cd "$(dirname "$0")" +STATUS="$PWD/../scripts/super-board-status.py" +STUB="$PWD/../evals/_stubs/bin/tea" +TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT +fail() { echo "FAIL: $1" >&2; exit 1; } +pass=0; ok() { pass=$((pass + 1)); echo " ✅ $1"; } + +mkdir -p "$TMP/.git" "$TMP/.claude/super-board/configs" +cat > "$TMP/.claude/super-board/configs/shop.json" <<'EOF' +{"forge":"gitea","forge_host":"http://localhost:3000", + "project":{"owner":"example","title":"Board","number":4}, + "repo":{"path":".","remote":"http://localhost:3000/example/shop.git"}, + "base_branch":"main"} +EOF +echo shop > "$TMP/.claude/super-board/active" +cat > "$TMP/.git/tea-state.json" <<'EOF' +{"issues":[ + {"id":101,"number":1,"title":"Cart discount","body":"x","state":"open","labels":[{"id":3,"name":"feature"}],"_column":2}, + {"id":103,"number":3,"title":"Flaky checkout","body":"y","state":"open","labels":[{"id":4,"name":"bug"}],"_column":6}, + {"id":104,"number":4,"title":"Shipped thing","body":"z","state":"closed","labels":[],"_column":7}], + "pulls":[], + "labels":[{"id":3,"name":"feature"},{"id":4,"name":"bug"}], + "projects":[{"id":4,"title":"Board"}], + "columns":[{"id":1,"title":"Backlog"},{"id":2,"title":"Ready"},{"id":3,"title":"Building"}, + {"id":4,"title":"QA"},{"id":5,"title":"Review"},{"id":6,"title":"Blocked"},{"id":7,"title":"Done"}], + "comments":{"3":[{"id":1,"body":"⚙ upstream API down — waiting on #9","user":{"login":"bot"}, + "created_at":"2026-01-02T00:00:00Z","updated_at":"2026-01-02T00:00:00Z"}]}, + "writes":0} +EOF + +if [ -x "/c/Program Files/Git/usr/bin/bash.exe" ]; then + BASH_EXE="C:/Program Files/Git/usr/bin/bash.exe" +else + BASH_EXE="bash" +fi +export SB_GITEA_TEA="\"$BASH_EXE\" $(cygpath -m "$STUB" 2>/dev/null || echo "$STUB")" \ + SB_GITHUB_HALT_FILE="$TMP/halt.json" SB_GITEA_RETRY_DELAY=0 + +OUT=$(cd "$TMP" && python3 "$STATUS" 2>"$TMP/err.txt") || fail "status exit: $(cat "$TMP/err.txt")" + +grep -q 'super-board · Board' <<<"$OUT" || fail "header missing: $(head -5 <<<"$OUT")" +ok "renders the snapshot header" + +# Blocked lane shows #3 and its reason-tag body. +grep -q '#3' <<<"$OUT" || fail "blocked card missing" +grep -q 'infra / tooling' <<<"$OUT" || fail "reason tag missing: $(grep -A3 -i block <<<"$OUT")" +ok "Blocked lane + reason tag from gitea comments" + +# Ready and Done lanes carry their cards. +grep -q '#1' <<<"$OUT" || fail "ready card missing" +grep -q '#4' <<<"$OUT" || fail "done card missing" +ok "cards render in their columns" + +# A halted forge read must surface as 79, not a fabricated snapshot. +echo '{"reason":"test halt","attempts":3,"at":0,"operation":null}' > "$TMP/halt.json" +RC=0; (cd "$TMP" && python3 "$STATUS") >/dev/null 2>&1 || RC=$? +[ "$RC" = 79 ] || fail "halted read should exit 79, got $RC" +rm -f "$TMP/halt.json" +ok "halt file propagates as exit 79" + +echo "test-status-gitea: $pass passed" From c115bc3df8751a5bf8879aac0178668f2f4e8bd6 Mon Sep 17 00:00:00 2001 From: PhucMN Date: Fri, 16 Oct 2026 15:38:24 +0700 Subject: [PATCH 3/8] =?UTF-8?q?=E2=9C=A8=20[feat]=20forge:=20guard=20+=20t?= =?UTF-8?q?hrottle=20gitea=20mode?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - gh-guard: sb_gh_guard_kind/sb_gh_guard_quota dispatch; gitea guard_check reads the api bucket through gitea-read and never sleeps when the instance has rate limits disabled (the local budget stays the protection); summary appends rate_limits=off - throttle: gitea steps max_workers down on the core bucket (graphql mirror on github unchanged); disabled limits only trip on real lane-result evidence; 429/too-many-requests added to the failure grep - tea stub: X-RateLimit-Remaining overridable via fixture - tests: test-gh-guard-gitea.sh (4), gitea cases in test-throttle.sh; all 7 github sections still pass Co-Authored-By: Claude Code --- evals/_stubs/bin/tea | 4 ++- scripts/super-board-gh-guard.sh | 48 +++++++++++++++++++++++---- scripts/super-board-throttle.sh | 25 +++++++++++---- tests/test-gh-guard-gitea.sh | 57 +++++++++++++++++++++++++++++++++ tests/test-throttle.sh | 23 ++++++++++++- 5 files changed, 142 insertions(+), 15 deletions(-) create mode 100644 tests/test-gh-guard-gitea.sh diff --git a/evals/_stubs/bin/tea b/evals/_stubs/bin/tea index 1126f04b..4bb9eb38 100755 --- a/evals/_stubs/bin/tea +++ b/evals/_stubs/bin/tea @@ -102,10 +102,12 @@ fail_http() { echo "ServerError: $1 $2 (eval stub)" >&2; exit 1; } emit_headers() { [ "$HEADERS" = 1 ] || return 0 + local rem=3597 + [ -f "$FX/ratelimit-remaining" ] && rem=$(cat "$FX/ratelimit-remaining") { echo "HTTP/1.1 200 OK" if [ ! -e "$FX/no-ratelimit" ]; then echo "X-RateLimit-Limit: 3600" - echo "X-RateLimit-Remaining: 3597" + echo "X-RateLimit-Remaining: $rem" echo "X-RateLimit-Reset: $(( $(date +%s) + 3600 ))" fi } >&2 diff --git a/scripts/super-board-gh-guard.sh b/scripts/super-board-gh-guard.sh index 931a7d0a..b33f8665 100755 --- a/scripts/super-board-gh-guard.sh +++ b/scripts/super-board-gh-guard.sh @@ -24,10 +24,36 @@ SB_GH_GUARD_STATE_FILE="${SB_GH_GUARD_STATE_FILE:-${TMPDIR:-/tmp}/super-board-gh # This file's own path: BASH_SOURCE under bash, the %x prompt escape under zsh. if [ -n "${BASH_SOURCE[0]:-}" ]; then _sb_guard_src="${BASH_SOURCE[0]}"; else eval '_sb_guard_src="${(%):-%x}"'; fi -SB_GITHUB_READ="$(cd "$(dirname "$_sb_guard_src")" && pwd)/super-board-github-read.py"; unset _sb_guard_src +SB_GUARD_BIN="$(cd "$(dirname "$_sb_guard_src")" && pwd)"; unset _sb_guard_src +SB_GITHUB_READ="$SB_GUARD_BIN/super-board-github-read.py" +SB_GITEA_READ="$SB_GUARD_BIN/super-board-gitea-read.py" sb_gh_required_read() { local kind="$1"; shift; python3 "$SB_GITHUB_READ" --kind "$kind" -- "$@"; } sb_gh_halt_check() { python3 "$SB_GITHUB_READ" --check; } +sb_gh_guard_kind() { + # Which forge this worker talks to. SB_FORGE_KIND wins (forge.sh exports it); + # otherwise resolve from SB_CONFIG/the environment, defaulting to github. + if [ -z "${SB_FORGE_KIND:-}" ] && [ -f "$SB_GUARD_BIN/super-board-forge.sh" ]; then + # shellcheck source=super-board-forge.sh + . "$SB_GUARD_BIN/super-board-forge.sh" + sb_forge_resolve ${SB_CONFIG:+"$SB_CONFIG"} >/dev/null 2>&1 || true + fi + echo "${SB_FORGE_KIND:-github}" +} + +sb_gh_guard_quota() { + # The forge's quota payload, in the github rate_limit shape, read WITHOUT the + # bounded helper: a failed quota probe must never halt a worker (throttle and + # the summary tolerate '{}'). Gitea instances without rate limiting answer + # {"rate_limits_disabled":true} with sentinel 5000s: callers must not sleep + # on those, the local budget is the guard. + if [ "$(sb_gh_guard_kind)" = gitea ]; then + python3 "$SB_GITEA_READ" --kind quota --quota 2>/dev/null || echo '{}' + else + sb_gh_quota_merge "$(gh api rate_limit 2>/dev/null || echo '{}')" + fi +} + # `gh api rate_limit` (REST) misreports the GraphQL bucket. Measured 2026-10-04, # back to back on one token: REST said graphql used=2 remaining=4998 while # GraphQL's own rateLimit said used=930 — and an hour earlier REST said 4999 @@ -46,12 +72,22 @@ sb_gh_quota_merge() { } sb_gh_guard_check() { - # Sleep until GraphQL quota recovers. Also checks REST. + # Sleep until the forge's quota recovers. GitHub keeps the bounded required + # read (its halt discipline protects the shared bucket) and checks the + # GraphQL bucket first, then REST; Gitea checks the single API bucket — and + # only when the instance actually rate-limits. # Arg 1: optional minimum-remaining threshold (default 200). local min="${1:-$SB_GH_GUARD_MIN_REMAINING_DEFAULT}" local payload graphql_remaining graphql_reset rest_remaining now wait - payload=$(sb_gh_required_read quota api rate_limit) || return $? - payload=$(sb_gh_quota_merge "$payload") + if [ "$(sb_gh_guard_kind)" = gitea ]; then + payload=$(python3 "$SB_GITEA_READ" --kind quota --quota) || return $? + if [ "$(echo "$payload" | jq -r '.rate_limits_disabled // false')" = "true" ]; then + return 0 # nothing to wait for; sb_gh_budget_spend is the protection + fi + else + payload=$(sb_gh_required_read quota api rate_limit) || return $? + payload=$(sb_gh_quota_merge "$payload") + fi graphql_remaining=$(echo "$payload" | jq -r '.resources.graphql.remaining // 5000') rest_remaining=$(echo "$payload" | jq -r '.resources.core.remaining // 5000') @@ -75,8 +111,8 @@ sb_gh_guard_check() { sb_gh_guard_summary() { # One-line snapshot. Use in worker exit messages for trend tracking. local payload - payload=$(sb_gh_quota_merge "$(gh api rate_limit 2>/dev/null || echo '{}')") - echo "[gh-guard] $(echo "$payload" | jq -r '"graphql=\(.resources.graphql.remaining // "?")/\(.resources.graphql.limit // "?") rest=\(.resources.core.remaining // "?")/\(.resources.core.limit // "?")"')" + payload=$(sb_gh_guard_quota 2>/dev/null || echo '{}') + echo "[gh-guard] $(echo "$payload" | jq -r '"graphql=\(.resources.graphql.remaining // "?")/\(.resources.graphql.limit // "?") rest=\(.resources.core.remaining // "?")/\(.resources.core.limit // "?")" + (if (.rate_limits_disabled // false) then " rate_limits=off" else "" end)')" } sb_gh_budget_init() { diff --git a/scripts/super-board-throttle.sh b/scripts/super-board-throttle.sh index e1893c59..e5047a74 100755 --- a/scripts/super-board-throttle.sh +++ b/scripts/super-board-throttle.sh @@ -36,20 +36,31 @@ while [ $# -gt 0 ]; do done [ -n "$CONFIG" ] && [ -f "$CONFIG" ] || { echo "config not found: ${CONFIG:-}" >&2; exit 66; } +HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +# shellcheck source=super-board-gh-guard.sh +. "$HERE/super-board-gh-guard.sh" +SB_CONFIG="$CONFIG" +FORGE_KIND=$(sb_gh_guard_kind) if [ -n "$RATE" ]; then PAYLOAD=$(cat "$RATE") else - # shellcheck source=super-board-gh-guard.sh - . "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/super-board-gh-guard.sh" - PAYLOAD=$(sb_gh_quota_merge "$(gh api rate_limit 2>/dev/null || echo '{}')") + PAYLOAD=$(sb_gh_guard_quota 2>/dev/null || echo '{}') fi -REMAINING=$(printf '%s' "$PAYLOAD" | jq -r '.resources.graphql.remaining // "unknown"' 2>/dev/null || echo unknown) +# Gitea has one API bucket (the graphql slot mirrors it); instances without +# rate limiting report the sentinel 5000 and never trip the remaining check — +# there, only real evidence (a lane result reporting 429s) narrows the wave. +BUCKET=graphql +[ "$FORGE_KIND" = gitea ] && BUCKET=core +REMAINING=$(printf '%s' "$PAYLOAD" | jq -r ".resources.${BUCKET}.remaining // \"unknown\"" 2>/dev/null || echo unknown) +DISABLED=$(printf '%s' "$PAYLOAD" | jq -r '.rate_limits_disabled // false' 2>/dev/null || echo false) WHY="" -[ "$REMAINING" = "0" ] && WHY="graphql remaining 0" +if [ "$REMAINING" = "0" ] && [ "$DISABLED" != "true" ]; then + WHY="${BUCKET} remaining 0" +fi if [ -z "$WHY" ] && [ -n "$RESULTS" ] && [ -f "$RESULTS" ] \ - && grep -Eqi 'rate.?limit(ed)? (exceeded|hit|reached)|api rate limit|secondary rate limit|graphql.{0,40}(quota|rate.?limit)|was submitted too quickly' "$RESULTS"; then - WHY="a lane result reports a GitHub rate-limit failure" + && grep -Eqi 'rate.?limit(ed)? (exceeded|hit|reached)|api rate limit|secondary rate limit|graphql.{0,40}(quota|rate.?limit)|was submitted too quickly|too many requests|\b429\b' "$RESULTS"; then + WHY="a lane result reports a forge rate-limit failure" fi FROM=$(jq -r '.max_workers // 0' "$CONFIG") diff --git a/tests/test-gh-guard-gitea.sh b/tests/test-gh-guard-gitea.sh new file mode 100644 index 00000000..d14f2856 --- /dev/null +++ b/tests/test-gh-guard-gitea.sh @@ -0,0 +1,57 @@ +#!/usr/bin/env bash +# Tests super-board-gh-guard.sh's gitea mode against the offline tea stub: +# a disabled-limit instance never sleeps (the local budget is the guard), +# the summary reports the api bucket, and the budget exits 73 when spent. +# No network. GitHub-side guard behavior stays covered by test-throttle.sh. +set -euo pipefail +cd "$(dirname "$0")" +KIT="$PWD/.." +GUARD="$KIT/scripts/super-board-gh-guard.sh" +STUB="$KIT/evals/_stubs/bin/tea" +TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT +fail() { echo "FAIL: $1" >&2; exit 1; } +pass=0; ok() { pass=$((pass + 1)); echo " ✅ $1"; } + +mkdir -p "$TMP/.git" +if [ -x "/c/Program Files/Git/usr/bin/bash.exe" ]; then + BASH_EXE="C:/Program Files/Git/usr/bin/bash.exe" +else + BASH_EXE="bash" +fi +export SB_GITEA_TEA="\"$BASH_EXE\" $(cygpath -m "$STUB" 2>/dev/null || echo "$STUB")" \ + SB_FORGE_KIND=gitea SB_GH_GUARD_STATE_FILE="$TMP/budget" \ + SB_GITHUB_HALT_FILE="$TMP/halt.json" SB_GITEA_RETRY_DELAY=0 +# shellcheck source=/dev/null +source "$GUARD" +cd "$TMP" + +# 1 — healthy headers: guard check passes without sleeping. +T0=$(date +%s) +sb_gh_guard_check 200 || fail "healthy guard check" +[ $(( $(date +%s) - T0 )) -lt 10 ] || fail "healthy check slept" +ok "healthy api bucket → no sleep" + +# 2 — summary reports the api bucket in the shared one-line format. +SUM=$(sb_gh_guard_summary) +grep -q 'rest=3597/3600' <<<"$SUM" || fail "summary: $SUM" +ok "summary: $SUM" + +# 3 — a disabled-limit instance: check returns instantly, summary says off. +mkdir -p .git/tea-fixture +touch .git/tea-fixture/no-ratelimit +T0=$(date +%s) +sb_gh_guard_check 200 || fail "disabled guard check" +[ $(( $(date +%s) - T0 )) -lt 10 ] || fail "disabled check slept" +SUM=$(sb_gh_guard_summary) +grep -q 'rate_limits=off' <<<"$SUM" || fail "disabled summary: $SUM" +rm -f .git/tea-fixture/no-ratelimit +ok "rate limits off → no sleep, summary says rate_limits=off" + +# 4 — the local budget is forge-neutral and still exits 73 when spent. +sb_gh_budget_init 2 +sb_gh_budget_spend 1 || fail "first spend" +RC=0; sb_gh_budget_spend 1 >/dev/null 2>&1 || RC=$? +[ "$RC" = 73 ] || fail "spending the last unit should exit 73, got $RC" +ok "budget 2 → first spend ok, second exits 73" + +echo "test-gh-guard-gitea: $pass passed" diff --git a/tests/test-throttle.sh b/tests/test-throttle.sh index 4ccf14e2..a338ef0e 100644 --- a/tests/test-throttle.sh +++ b/tests/test-throttle.sh @@ -73,4 +73,25 @@ RC=0; bash "$S" --config "$T/missing.json" >/dev/null 2>&1 || RC=$? RC=0; run --bogus >/dev/null 2>&1 || RC=$? [ "$RC" -eq 64 ] || fail "unknown arg should exit 64, got $RC" -echo 'PASS: test-throttle.sh (graphql reading, ladder, floor, lane failures, dry-run)' +# 8 — gitea: the single API bucket decides, disabled limits never hit, and a +# 429 in the lane results is still trusted over any reading. +cfg '{"max_workers":3,"forge":"gitea","forge_host":"http://localhost:3000","repo":{"remote":"http://localhost:3000/example/shop.git"}}' +echo '{"resources":{"core":{"remaining":0,"limit":3600},"graphql":{"remaining":0,"limit":3600}},"rate_limits_disabled":false}' > "$T/rate.json" +OUT=$(run --rate "$T/rate.json" --dry-run) +echo "$OUT" | jq -e '.hit and .why == "core remaining 0" and .from == 3 and .to == 2' >/dev/null || fail "gitea core 0: $OUT" +echo '{"resources":{"core":{"remaining":0,"limit":3600},"graphql":{"remaining":0,"limit":3600}},"rate_limits_disabled":true}' > "$T/rate.json" +OUT=$(run --rate "$T/rate.json" --dry-run) +echo "$OUT" | jq -e '.hit == false' >/dev/null || fail "disabled limits must not hit: $OUT" +echo '{"resources":{"core":{"remaining":3597,"limit":3600},"graphql":{"remaining":3597,"limit":3600}}}' > "$T/rate.json" +echo '[{"number":7,"detail":"tea: ServerError 429 Too Many Requests"}]' > "$T/results.json" +OUT=$(run --rate "$T/rate.json" --results "$T/results.json" --dry-run) +echo "$OUT" | jq -e '.hit and (.why | test("lane result"))' >/dev/null || fail "gitea 429 text: $OUT" + +# 9 — gitea live probe through the offline tea stub: healthy headers → no hit. +mkdir -p "$T/.git" +STUB="$KIT/evals/_stubs/bin/tea" +if [ -x "/c/Program Files/Git/usr/bin/bash.exe" ]; then BASH_EXE="C:/Program Files/Git/usr/bin/bash.exe"; else BASH_EXE="bash"; fi +OUT=$(cd "$T" && SB_GITEA_TEA="\"$BASH_EXE\" $(cygpath -m "$STUB" 2>/dev/null || echo "$STUB")" bash "$S" --config "$T/cfg.json" --dry-run) +echo "$OUT" | jq -e '.hit == false' >/dev/null || fail "gitea live probe: $OUT" + +echo 'PASS: test-throttle.sh (graphql reading, ladder, floor, lane failures, dry-run, gitea bucket)' From c31da2ed03de24d4d0639c4b5e0b113abc55a73f Mon Sep 17 00:00:00 2001 From: PhucMN Date: Fri, 16 Oct 2026 16:51:54 +0700 Subject: [PATCH 4/8] =?UTF-8?q?=E2=9C=A8=20[feat]=20forge:=20gitea=20write?= =?UTF-8?q?=20ops=20across=20the=20lane=20scripts?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - merge-gate: gitea squash-merge via POST pulls/{i}/merge pinned with head_commit_id (the --match-head-commit analog); lost-response path unchanged (MERGED→0, head moved→6, else halt→79); approval calls carry --forge - approval.py: Gitea class — head/state + Closes-trailer links through gitea-read, owner/collaborator trust with fail-closed permission reads - pr-body: gitea PATCH pulls/{i} through tea api, GITEA_REPO twin of GH_REPO, same block splice + head pin (exit 6) - run.sh (legacy dispatcher): forge_resolved checkpoints, forge_assign/forge_comment with the same halt-on-unknown-outcome discipline, gitea card moves via card.sh, quota guard reads the gitea bucket - stop.sh: PR lookup via prs-open, comments via the shared issues endpoint (a Gitea PR is an issue), assignee/label release through tea api — still best-effort - file-bug / file-refactor / collect-file: resolve-or-create label ids, POST issues with label ids, one-step column placement, dedupe via issue-history, SB_FORGE/SB_CONFIG passed to child filers - wave.js: input.forge switches READ_SHAPES/READ_FAILURE/BOARD_IO wording and the classify label one-liner (sb_forge_label_add on gitea) - gitea-api: SB_GITEA_TIMEOUT defaults safely under set -u - tests: test-pr-body-gitea.sh (5), merge head-pin cases in test-gitea-api.sh (8) Co-Authored-By: Claude Code --- scripts/super-board-approval.py | 80 ++++++++++- scripts/super-board-gitea-api.sh | 2 +- scripts/super-board-merge-gate.sh | 104 ++++++++++---- scripts/super-board-pr-body.sh | 46 +++++-- scripts/super-board-run.sh | 120 +++++++++++++--- scripts/super-board-stop.sh | 46 ++++++- scripts/super-qa-file-bug.sh | 122 ++++++++++++++--- scripts/super-review-file-refactor.sh | 129 ++++++++++++++---- .../scripts/super-collect-file.sh | 96 +++++++++++-- tests/test-gitea-api.sh | 16 ++- tests/test-pr-body-gitea.sh | 74 ++++++++++ workflows/super-board-wave.js | 36 ++++- 12 files changed, 745 insertions(+), 126 deletions(-) create mode 100644 tests/test-pr-body-gitea.sh diff --git a/scripts/super-board-approval.py b/scripts/super-board-approval.py index 2f161e96..ddfd13d7 100644 --- a/scripts/super-board-approval.py +++ b/scripts/super-board-approval.py @@ -12,6 +12,7 @@ from datetime import datetime import hashlib import json +import os import re import subprocess import sys @@ -203,6 +204,79 @@ def check(self, number, head=None, scope=None, issue=None): return validate(comments, expected, self.permission) +class Gitea(GitHub): + """Same trust model on Gitea, through super-board-gitea-read.py as a + subprocess (its halt/retry discipline stays in one place). Degradations, + documented in references/gitea.md: + - closingIssuesReferences does not exist: the PR body's `Closes #N` + trailer (guaranteed by the writing standard) is the link, parsed by + gitea-read; no trailer → no linked issues → fail closed. + - per-user collaborator permission does not exist: the repo owner is + admin, a listed collaborator counts as write (Gitea's default grant), + everyone else is untrusted.""" + + def _cli(self, *cli_args): + helper = Path(__file__).with_name("super-board-gitea-read.py") + env = dict(os.environ, GITEA_REPO=self.repo) + proc = subprocess.run([sys.executable, str(helper), *cli_args], + capture_output=True, text=True, encoding="utf-8", env=env) + if proc.returncode == github_read.HALTED: + raise github_read.ReadHalted(proc.stderr.strip() or "gitea reads are halted") + if proc.returncode != 0: + raise ValueError(proc.stderr.strip()[:300] or f"gitea read failed ({proc.returncode})") + return proc.stdout + + def permission(self, login): + if not re.fullmatch(r"[A-Za-z0-9_-]+(?:\[bot\])?", login): + return None + owner = self.repo.split("/")[0] + if login.lower() == owner.lower(): + return "admin" + if login not in self.permissions: + perm = None + try: + value = json.loads(self._cli("--kind", "json", "--", "api", + f"repos/{self.repo}/collaborators")) + for c in value if isinstance(value, list) else []: + if isinstance(c, dict) and (c.get("login") or "").lower() == login.lower(): + p = c.get("permissions") or {} + if isinstance(c.get("permission"), str): + perm = c["permission"] + elif p: + perm = ("admin" if p.get("admin") else "write" if p.get("push") + else "read" if p.get("pull") else None) + else: + perm = "write" # a listed collaborator holds Gitea's default grant + break + except (ValueError, KeyError, TypeError, OSError, subprocess.SubprocessError): + perm = None # unreadable collaborator list → fail closed + self.permissions[login] = perm + return self.permissions[login] + + def comments(self, number): + pages = json.loads(self._cli("--kind", "comments", "--issue", str(number))) + if not isinstance(pages, list) or not pages or any(not isinstance(p, list) for p in pages): + raise ValueError("unreadable comments") + if any(not isinstance(c, dict) for page in pages for c in page): + raise ValueError("unreadable comment") + return [dict(comment, source=number) for page in pages for comment in page] + + def pr(self, number): + value = json.loads(self._cli("--kind", "approval", "--pr", str(number))) + if value.get("state") != "OPEN": + raise ValueError("PR is not open") + head = value.get("headRefOid") or "" + if not SHA.fullmatch(head): + raise ValueError("unreadable PR head") + issues = {i["number"] for i in value.get("closingIssues") or [] + if isinstance(i, dict) and isinstance(i.get("number"), int)} + return head, issues + + +def forge_class(name): + return Gitea if (name or "github").strip().lower() == "gitea" else GitHub + + def main(): ap = argparse.ArgumentParser(description=__doc__) ap.add_argument("--repo", required=True) @@ -211,7 +285,9 @@ def main(): ap.add_argument("--plan", help="JSON plan from merge-policy") ap.add_argument("--request", action="store_true", help="print a pinned request; no network or writes") ap.add_argument("--deps", action="store_true", help="enrich the dependency graph on stdin") + ap.add_argument("--forge", help="github (default) or gitea; SB_FORGE overrides nothing here — the caller passes it") args = ap.parse_args() + forge = forge_class(args.forge or os.environ.get("SB_FORGE")) if args.request: if not args.pr or not args.head or not SHA.fullmatch(args.head) or not args.plan: ap.error("request requires --pr, full --head and --plan") @@ -219,7 +295,7 @@ def main(): return if args.deps: graph = json.load(sys.stdin) - github = GitHub(args.repo) if args.repo else None + github = forge(args.repo) if args.repo else None for entry in graph.values(): entry["needsYouDone"] = False entry["approvalRefresh"] = False @@ -243,7 +319,7 @@ def main(): if not args.pr or not args.head or not args.plan: ap.error("check requires --pr, --head and --plan") try: - result = GitHub(args.repo).check(args.pr, args.head, scope_for(json.loads(args.plan))) + result = forge(args.repo).check(args.pr, args.head, scope_for(json.loads(args.plan))) except (ValueError, KeyError, TypeError, OSError, subprocess.SubprocessError): result = {"approved": False, "why": "approval evidence could not be verified"} print(json.dumps(result)) diff --git a/scripts/super-board-gitea-api.sh b/scripts/super-board-gitea-api.sh index 6f3df44c..42f2108a 100755 --- a/scripts/super-board-gitea-api.sh +++ b/scripts/super-board-gitea-api.sh @@ -33,7 +33,7 @@ sb_gitea_tea() { [ -n "${SB_FORGE_LOGIN:-}" ] && login_flag=(--login "$SB_FORGE_LOGIN") eval "tea_cmd=(${SB_GITEA_TEA:-tea})" if command -v timeout >/dev/null 2>&1; then - timeout "$SB_GITEA_TIMEOUT" "${tea_cmd[@]}" "${login_flag[@]}" "$@" + timeout "${SB_GITEA_TIMEOUT:-30}" "${tea_cmd[@]}" "${login_flag[@]}" "$@" else "${tea_cmd[@]}" "${login_flag[@]}" "$@" fi diff --git a/scripts/super-board-merge-gate.sh b/scripts/super-board-merge-gate.sh index 21c6dfeb..4cd0f752 100755 --- a/scripts/super-board-merge-gate.sh +++ b/scripts/super-board-merge-gate.sh @@ -108,10 +108,11 @@ # and migrations run after verification, inside the lock, right before the # merge. `--dry-run` reports both and runs neither. set -euo pipefail -# Fixed read commands: a malformed payload is GitHub's, so it halts (#32). -export SB_GITHUB_READ_STRICT=1 +# Fixed read commands: a malformed payload is the forge's, so it halts (#32). +export SB_GITHUB_READ_STRICT=1 SB_GITEA_READ_STRICT=1 HERE=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) GITHUB_READ="$HERE/super-board-github-read.py" +GITEA_READ="$HERE/super-board-gitea-read.py" CONFIG=""; PR=""; LOCK_TIMEOUT=1800; STALE_AFTER=""; DRY=0; EXPECT_HEAD=""; SUBJECT=""; MSG_FILE="" while [ $# -gt 0 ]; do @@ -145,7 +146,26 @@ fi CONFIG_JSON=$(cat "$CONFIG") printf '%s\n' "$CONFIG_JSON" | python3 "$HERE/super-board-verification-ready.py" --config - BASE=$(echo "$CONFIG_JSON" | jq -r '.base_branch // "main"') -REPO=$(echo "$CONFIG_JSON" | jq -r '.repo.remote // ""' | sed -E 's#^https?://github\.com/##; s#\.git$##') + +# Forge resolution: github (default) reads through github-read + gh; gitea +# through gitea-read + tea api. Same verbs, same exit codes, one halt file. +FORGE_KIND=github +if [ -f "$HERE/super-board-forge.sh" ]; then + # shellcheck source=super-board-forge.sh + . "$HERE/super-board-forge.sh" + sb_forge_resolve "$CONFIG" || exit $? + FORGE_KIND="$SB_FORGE_KIND" +fi +if [ "$FORGE_KIND" = gitea ]; then + READ_PY="$GITEA_READ" + REPO="$SB_FORGE_OWNER/$SB_FORGE_REPO" +else + READ_PY="$GITHUB_READ" + REPO=$(echo "$CONFIG_JSON" | jq -r '.repo.remote // ""' | sed -E 's#^https?://github\.com/##; s#\.git$##') +fi +gate_check() { python3 "$READ_PY" --check; } +gate_halt() { python3 "$READ_PY" --halt "$1"; } + REPO_PATH=$(echo "$CONFIG_JSON" | jq -r '.repo.path // "."') export SB_REPO_PATH="$REPO_PATH" # Read with a while-loop rather than `mapfile`: macOS ships bash 3.2 and every @@ -160,7 +180,7 @@ if [ "${#VERIFY[@]}" -eq 0 ]; then echo "verification-readiness: verify_commands yielded no usable shell commands; repair the project config and restart the board." >&2 exit 9 fi -python3 "$GITHUB_READ" --check +gate_check LOCK_DIR="${REPO_PATH}/.claude/super-board/inflight/merge.lock" mkdir -p "$(dirname "$LOCK_DIR")" @@ -206,12 +226,20 @@ trap cleanup EXIT # ---- the head guard -------------------------------------------------------- # Review evidence belongs to one commit. If the branch moved after the Reviewer # passed it, the tests it reran and the diff it read describe something else. -pr_head() { python3 "$GITHUB_READ" --kind head -- pr view "$PR" ${REPO:+--repo "$REPO"} --json headRefName,headRefOid \ - -q '.headRefName + " " + .headRefOid'; } +if [ "$FORGE_KIND" = gitea ]; then + pr_head() { python3 "$GITEA_READ" --kind head --pr "$PR"; } +else + pr_head() { python3 "$GITHUB_READ" --kind head -- pr view "$PR" ${REPO:+--repo "$REPO"} --json headRefName,headRefOid \ + -q '.headRefName + " " + .headRefOid'; } +fi HEAD=$(pr_head) || exit $? read -r HEAD_REF HEAD_SHA <<<"$HEAD" -[ -n "${HEAD_SHA:-}" ] || { say "could not read the PR head from GitHub"; exit 1; } -pr_state() { python3 "$GITHUB_READ" --kind merge-state -- pr view "$PR" ${REPO:+--repo "$REPO"} --json state,mergeCommit,headRefOid; } +[ -n "${HEAD_SHA:-}" ] || { say "could not read the PR head from the forge"; exit 1; } +if [ "$FORGE_KIND" = gitea ]; then + pr_state() { python3 "$GITEA_READ" --kind merge-state --pr "$PR"; } +else + pr_state() { python3 "$GITHUB_READ" --kind merge-state -- pr view "$PR" ${REPO:+--repo "$REPO"} --json state,mergeCommit,headRefOid; } +fi STATE=$(pr_state) || exit $? if [ "$(echo "$STATE" | jq -r .state)" = MERGED ]; then say "already merged; no verification, migration, or merge is repeated" @@ -236,8 +264,19 @@ fi HERE=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) # Outside $SCRATCH: `git worktree add` below needs that directory empty. META=$(mktemp); DIFF=$(mktemp) -python3 "$GITHUB_READ" --kind metadata -- pr view "$PR" ${REPO:+--repo "$REPO"} --json labels,files,additions,deletions,changedFiles,body > "$META" -python3 "$GITHUB_READ" --kind diff --meta "$META" -- pr diff "$PR" ${REPO:+--repo "$REPO"} > "$DIFF" +read_meta() { + if [ "$FORGE_KIND" = gitea ]; then + python3 "$GITEA_READ" --kind metadata --pr "$PR" > "$META" + else + python3 "$GITHUB_READ" --kind metadata -- pr view "$PR" ${REPO:+--repo "$REPO"} --json labels,files,additions,deletions,changedFiles,body > "$META" + fi +} +read_meta +if [ "$FORGE_KIND" = gitea ]; then + python3 "$GITEA_READ" --kind diff --pr "$PR" --meta "$META" > "$DIFF" +else + python3 "$GITHUB_READ" --kind diff --meta "$META" -- pr diff "$PR" ${REPO:+--repo "$REPO"} > "$DIFF" +fi PLAN=$(python3 "$HERE/super-board-merge-policy.py" --config "$CONFIG" --meta "$META" --diff "$DIFF") || { echo "human-gate: policy — could not classify the PR (unreadable metadata)" say "merge policy could not be evaluated — a human merges this one"; exit 7; } @@ -246,13 +285,13 @@ PLAN=$(python3 "$HERE/super-board-merge-policy.py" --config "$CONFIG" --meta "$M # and policy/commands. Re-read trusted approval evidence; never mint it here. APPROVED=false approval_check() { - APPROVAL=$(python3 "$HERE/super-board-approval.py" --repo "$REPO" --pr "$PR" \ + APPROVAL=$(python3 "$HERE/super-board-approval.py" --forge "$FORGE_KIND" --repo "$REPO" --pr "$PR" \ --head "$HEAD_SHA" --plan "$PLAN") || APPROVAL='{"approved":false}' - python3 "$GITHUB_READ" --check || exit $? + gate_check || exit $? APPROVED=$(echo "$APPROVAL" | jq -r '.approved // false') } approval_request() { - python3 "$HERE/super-board-approval.py" --request --repo "$REPO" --pr "$PR" \ + python3 "$HERE/super-board-approval.py" --forge "$FORGE_KIND" --request --repo "$REPO" --pr "$PR" \ --head "$HEAD_SHA" --plan "$PLAN" } HUMAN=$(echo "$PLAN" | jq -r '.human[] | "human-gate: \(.category) — \(.why)"') @@ -289,7 +328,7 @@ for cmd in "${VERIFY[@]}"; do done say "verified green against ${BASE} (${#VERIFY[@]} command(s))" -python3 "$GITHUB_READ" --check +gate_check # ---- migrations (inside the lock, after the build proof) ------------------- # Run the configured migrate command for every allowed env, from the verified @@ -303,7 +342,7 @@ if [ "$(echo "$PLAN" | jq '.migrations | length')" -gt 0 ]; then [ -n "$env" ] || continue if [ "$DRY" -eq 1 ]; then say "dry run: would migrate ${env}: ${cmd}"; continue; fi say "migrate ${env}: ${cmd}" - python3 "$GITHUB_READ" --check + gate_check if ! ( cd "$SCRATCH" && eval "$cmd" ) >"$SCRATCH/.migrate.log" 2>&1; then say "FAILED: migrate ${env}"; tail -20 "$SCRATCH/.migrate.log" >&2 NEEDS+=("${cmd} # ${env}: failed in the merge gate — fix, run it, then mark done") @@ -326,7 +365,7 @@ fi if [ "$APPROVED" = true ]; then # Code remains pinned; body-declared human steps and config can change without # a commit. Reclassify them too instead of reusing the old approval scope. - python3 "$GITHUB_READ" --kind metadata -- pr view "$PR" ${REPO:+--repo "$REPO"} --json labels,files,additions,deletions,changedFiles,body > "$META" + read_meta PLAN=$(python3 "$HERE/super-board-merge-policy.py" --config "$CONFIG" --meta "$META" --diff "$DIFF") || { say "human approval scope could not be refreshed"; exit 7; } approval_check @@ -343,12 +382,29 @@ if [ "$DRY" -eq 1 ]; then exit 0 fi -# --match-head-commit makes GitHub refuse if anything was pushed after HEAD_SHA, -# including during the verification run above. -python3 "$GITHUB_READ" --check -if gh pr merge "$PR" ${REPO:+--repo "$REPO"} --squash --delete-branch \ - ${SUBJECT:+--subject "$SUBJECT"} ${MSG_FILE:+--body-file "$MSG_FILE"} \ - --match-head-commit "$HEAD_SHA" 2>&1 | tail -3 >&2; then +# The forge pins the code itself: GitHub via --match-head-commit, Gitea via the +# merge API's head_commit_id (a server old enough to ignore that field is a +# documented gitea degradation — the pr_state read below bounds the damage). +gate_check +do_merge() { + if [ "$FORGE_KIND" = gitea ]; then + # shellcheck source=super-board-gitea-api.sh + . "$HERE/super-board-gitea-api.sh" + local body + body=$(jq -cn --arg sha "$HEAD_SHA" --arg title "$SUBJECT" \ + '{do:"squash", head_commit_id:$sha, delete_branch_after_merge:true, merge_when_checks_succeed:false} + + (if $title != "" then {merge_title_field:$title} else {} end)') + if [ -n "$MSG_FILE" ]; then + body=$(jq -c --rawfile m "$MSG_FILE" '. + {merge_message_field:$m}' <<<"$body") + fi + sb_gitea_api POST "repos/$REPO/pulls/$PR/merge" "$body" + else + gh pr merge "$PR" ${REPO:+--repo "$REPO"} --squash --delete-branch \ + ${SUBJECT:+--subject "$SUBJECT"} ${MSG_FILE:+--body-file "$MSG_FILE"} \ + --match-head-commit "$HEAD_SHA" + fi +} +if do_merge 2>&1 | tail -3 >&2; then say "merged ${HEAD_SHA}" # Post-merge tidy-up: drop worktrees and local branches the merge just made # redundant. Optional (only when the cleanup-wt hook is installed), local-only, and it @@ -360,7 +416,7 @@ if gh pr merge "$PR" ${REPO:+--repo "$REPO"} --squash --delete-branch \ fi STATE=$(pr_state) || exit $? if [ "$(echo "$STATE" | jq -r .state)" = MERGED ]; then - say "merge response was lost; GitHub confirms the merge commit" + say "merge response was lost; the forge confirms the merge commit" exit 0 fi NOW_SHA=$(echo "$STATE" | jq -r .headRefOid) @@ -369,4 +425,4 @@ if [ "$NOW_SHA" != "$HEAD_SHA" ]; then say "the review evidence is void — send the card back to Review" exit 6 fi -python3 "$GITHUB_READ" --halt "Merge response failed and GitHub has not confirmed a merge; reconcile PR #${PR} before restarting. No merge was retried." +gate_halt "Merge response failed and the forge has not confirmed a merge; reconcile PR #${PR} before restarting. No merge was retried." diff --git a/scripts/super-board-pr-body.sh b/scripts/super-board-pr-body.sh index 34b5a5e2..8db70303 100755 --- a/scripts/super-board-pr-body.sh +++ b/scripts/super-board-pr-body.sh @@ -70,12 +70,33 @@ SRC="${BODY_FILE:-$APPEND_FILE}" [ -r "$SRC" ] || die "cannot read $SRC" 66 [ "$DRY" -eq 1 ] || [ -n "$HEAD" ] || die "--expect-head is required (the PR head your edit is based on)" 64 -GITHUB_READ="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/super-board-github-read.py" -# REST, not `gh pr view`/`gh pr edit`: this script runs ~3 times per lane per -# card, and the REST core bucket is separate from the GraphQL one the board -# lives on. GH_REPO fills {owner}/{repo}; unset, gh uses the current checkout. -export GH_REPO="${REPO:-${GH_REPO:-}}"; [ -n "$GH_REPO" ] || unset GH_REPO -META=$(python3 "$GITHUB_READ" --kind body -- api "repos/{owner}/{repo}/pulls/$PR" --jq '{headRefOid: .head.sha, body: (.body // "")}' ) || exit $? +HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +GITHUB_READ="$HERE/super-board-github-read.py" +GITEA_READ="$HERE/super-board-gitea-read.py" + +# Forge resolution: github (default) reads/PATCHes through gh; gitea through +# tea api. Same markers, same head-pin, same exits. +FORGE_KIND=github +if [ -f "$HERE/super-board-forge.sh" ]; then + # shellcheck source=super-board-forge.sh + . "$HERE/super-board-forge.sh" + sb_forge_resolve ${CONFIG:+"$CONFIG"} || exit $? + FORGE_KIND="$SB_FORGE_KIND" +fi + +if [ "$FORGE_KIND" = gitea ]; then + READ_PY="$GITEA_READ" + # GITEA_REPO fills tea's {owner}/{repo} placeholders in every worktree. + if [ -n "$REPO" ]; then export GITEA_REPO="$REPO"; fi + META=$(python3 "$GITEA_READ" --kind body --pr "$PR") || exit $? +else + READ_PY="$GITHUB_READ" + # REST, not `gh pr view`/`gh pr edit`: this script runs ~3 times per lane per + # card, and the REST core bucket is separate from the GraphQL one the board + # lives on. GH_REPO fills {owner}/{repo}; unset, gh uses the current checkout. + export GH_REPO="${REPO:-${GH_REPO:-}}"; [ -n "$GH_REPO" ] || unset GH_REPO + META=$(python3 "$GITHUB_READ" --kind body -- api "repos/{owner}/{repo}/pulls/$PR" --jq '{headRefOid: .head.sha, body: (.body // "")}' ) || exit $? +fi NOW=$(printf '%s' "$META" | jq -r '.headRefOid // empty') if [ -n "$HEAD" ]; then # Short or full sha both work: the PR head must start with what you passed. @@ -147,8 +168,15 @@ sys.stdout.write(out) PY if [ "$DRY" -eq 1 ]; then cat "$NEW_TMP"; exit 0; fi -# $(…) drops trailing newlines, which GitHub does not keep either. +# $(…) drops trailing newlines, which neither forge keeps. if [ "$(cat "$OLD_TMP")" = "$(cat "$NEW_TMP")" ]; then echo unchanged; exit 0; fi -python3 "$GITHUB_READ" --check || exit $? -jq -n --rawfile b "$NEW_TMP" '{body: $b}' | gh api -X PATCH "repos/{owner}/{repo}/pulls/$PR" --input - >/dev/null 2>&1 || { python3 "$GITHUB_READ" --halt "PR body update outcome unknown for #$PR; read the body before retrying"; exit 79; } +python3 "$READ_PY" --check || exit $? +if [ "$FORGE_KIND" = gitea ]; then + # shellcheck source=super-board-gitea-api.sh + . "$HERE/super-board-gitea-api.sh" + sb_gitea_api PATCH "repos/{owner}/{repo}/pulls/$PR" "$(jq -n --rawfile b "$NEW_TMP" '{body: $b}')" >/dev/null 2>&1 \ + || { python3 "$READ_PY" --halt "PR body update outcome unknown for #$PR; read the body before retrying"; exit 79; } +else + jq -n --rawfile b "$NEW_TMP" '{body: $b}' | gh api -X PATCH "repos/{owner}/{repo}/pulls/$PR" --input - >/dev/null 2>&1 || { python3 "$READ_PY" --halt "PR body update outcome unknown for #$PR; read the body before retrying"; exit 79; } +fi echo updated diff --git a/scripts/super-board-run.sh b/scripts/super-board-run.sh index b8beab5b..040df482 100755 --- a/scripts/super-board-run.sh +++ b/scripts/super-board-run.sh @@ -31,14 +31,57 @@ # (no subshell, no `exec` of a native PE), so `$!` names the worker itself rather than a bash stub. set -euo pipefail -SB_GITHUB_READ="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/super-board-github-read.py" -gh_checkpoint() { python3 "$SB_GITHUB_READ" --check || exit $?; } +SB_BIN_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +SB_GITHUB_READ="$SB_BIN_DIR/super-board-github-read.py" +SB_GITEA_READ="$SB_BIN_DIR/super-board-gitea-read.py" +# READ_PY/FORGE_KIND are set by the forge resolution after the config read; the +# defaults keep lib-only sourcing (SB_LIB_ONLY=1) on the github path. +FORGE_KIND="${SB_FORGE_KIND:-github}" +if [ "$FORGE_KIND" = gitea ]; then READ_PY="$SB_GITEA_READ"; else READ_PY="$SB_GITHUB_READ"; fi +gh_checkpoint() { python3 "$READ_PY" --check || exit $?; } +forge_halt_exit() { + python3 "$READ_PY" --halt "$1" >&2 || true + exit 79 +} gh_write_once() { gh_checkpoint - gh "$@" || { - python3 "$SB_GITHUB_READ" --halt "GitHub $1 $2 response failed; reconcile the write before restarting" >&2 || true - exit 79 - } + gh "$@" || forge_halt_exit "GitHub $1 $2 response failed; reconcile the write before restarting" +} +forge_assign() { + # forge_assign add|remove — the claim mutex on either forge. + # Gitea has no compare-and-swap: the local inflight lock stays the primary + # claim, this mirrors it for humans (documented gitea degradation). + local op="$1" issue="$2" login="$3" + gh_checkpoint + if [ "$FORGE_KIND" = gitea ]; then + # shellcheck source=super-board-gitea-api.sh + . "$SB_BIN_DIR/super-board-gitea-api.sh" + local method=POST + [ "$op" = remove ] && method=DELETE + sb_gitea_api "$method" "repos/{owner}/{repo}/issues/${issue}/assignees" \ + "$(jq -cn --arg l "$login" '{assignees:[$l]}')" >/dev/null 2>&1 \ + || forge_halt_exit "Gitea assignee ${op} on #${issue} response failed; reconcile the write before restarting" + else + local flag="--add-assignee" + [ "$op" = remove ] && flag="--remove-assignee" + gh issue edit "$issue" "$flag" "$login" >/dev/null 2>&1 \ + || forge_halt_exit "GitHub issue edit ${flag} #${issue} response failed; reconcile the write before restarting" + fi +} +forge_comment() { + # forge_comment + local issue="$1" body="$2" + gh_checkpoint + if [ "$FORGE_KIND" = gitea ]; then + # shellcheck source=super-board-gitea-api.sh + . "$SB_BIN_DIR/super-board-gitea-api.sh" + sb_gitea_api POST "repos/{owner}/{repo}/issues/${issue}/comments" \ + "$(jq -cn --arg b "$body" '{body:$b}')" >/dev/null 2>&1 \ + || forge_halt_exit "Gitea comment on #${issue} response failed; reconcile the write before restarting" + else + gh issue comment "$issue" --body "$body" >/dev/null 2>&1 \ + || forge_halt_exit "GitHub issue comment #${issue} response failed; reconcile the write before restarting" + fi } # ───────────────────────────── args + paths ───────────────────────────── @@ -108,6 +151,20 @@ INFLIGHT_DIR=".claude/super-board/inflight" mkdir -p "docs/super-board/runs" "$WORKER_LOG_DIR" .claude/worktrees "$INFLIGHT_DIR" fi # end non-lib-only setup +# Forge resolution (github default): a lib-only source keeps whatever the +# caller set; a real run resolves from its config, env and remote. +if [ -f "$SB_BIN_DIR/super-board-forge.sh" ]; then + # shellcheck source=super-board-forge.sh + . "$SB_BIN_DIR/super-board-forge.sh" + if [ "${SB_LIB_ONLY:-0}" != "1" ]; then + sb_forge_resolve "$CONFIG_PATH" || exit $? + else + sb_forge_resolve || true + fi + FORGE_KIND="$SB_FORGE_KIND" + if [ "$FORGE_KIND" = gitea ]; then READ_PY="$SB_GITEA_READ"; else READ_PY="$SB_GITHUB_READ"; fi +fi + # Defaults so the helpers below are safe to source under `set -u` in lib-only mode. : "${RUN_MANIFEST:=/dev/null}" : "${WORKER_LOG_DIR:=/dev/null}" @@ -157,8 +214,14 @@ status_option_id() { } set_card_status() { - # $1 = project item id, $2 = target status name. Returns non-zero if unresolvable. - local item_id="$1" name="$2" opt_id + # $1 = project item id, $2 = target status name, $3 = issue number (gitea). + # Returns non-zero if unresolvable. Gitea moves through card.sh, which owns + # the column cache and the move endpoint; github keeps the direct mutation. + local item_id="$1" name="$2" issue="${3:-}" opt_id + if [ "$FORGE_KIND" = gitea ]; then + "$SB_BIN_DIR/super-board-card.sh" --config "$CONFIG_PATH" move "$issue" "$name" >/dev/null || return 1 + return 0 + fi resolve_status_field || { gh_checkpoint; log "⚠ could not resolve Status field — skipping reconcile"; return 1; } opt_id=$(status_option_id "$name") || { log "⚠ Status option '${name}' not present on the board — skipping reconcile"; return 1; } @@ -183,7 +246,11 @@ issue_is_open() { # $1 = issue number. Returns 0 when OPEN, 1 when CLOSED. # Unreadable is distinct from both OPEN and CLOSED: exit 79 halts the run. local state - state=$(python3 "$SB_GITHUB_READ" --kind state -- issue view "$1" --json state -q '.state') || return 79 + if [ "$FORGE_KIND" = gitea ]; then + state=$(python3 "$SB_GITEA_READ" --kind state --issue "$1") || return 79 + else + state=$(python3 "$SB_GITHUB_READ" --kind state -- issue view "$1" --json state -q '.state') || return 79 + fi [ "$state" != "CLOSED" ] } @@ -218,9 +285,9 @@ top_card_in_column() { [ "$issue_rc" -le 1 ] || exit "$issue_rc" if [ "$issue_rc" -ne 0 ]; then log "reconciled closed #${issue} -> Done (was '${col}') — dispatching 0 workers for it" - set_card_status "$item_id" "Done" || { gh_checkpoint; log " ↳ reconcile of #${issue} could not be written to the board"; return 1; } + set_card_status "$item_id" "Done" "$issue" || { gh_checkpoint; log " ↳ reconcile of #${issue} could not be written to the board"; return 1; } gh_checkpoint - [ -n "$BOT_LOGIN" ] && gh_write_once issue edit "$issue" --remove-assignee "$BOT_LOGIN" >/dev/null 2>&1 || true + [ -n "$BOT_LOGIN" ] && forge_assign remove "$issue" "$BOT_LOGIN" || true rm -f "$INFLIGHT_DIR/$issue" continue fi @@ -271,8 +338,23 @@ lane_idle() { } gh_rate_guard() { - # Sleep until rate limit resets if GraphQL remaining < 200. + # Sleep until rate limit resets if the forge's bucket is nearly empty. local payload remaining reset now wait + if [ "$FORGE_KIND" = gitea ]; then + payload=$(python3 "$SB_GITEA_READ" --kind quota --quota) || return $? + # An instance without rate limiting has nothing to wait for. + [ "$(echo "$payload" | jq -r '.rate_limits_disabled // false')" = "true" ] && return 0 + remaining=$(echo "$payload" | jq -r '.resources.core.remaining // 5000') + if [ "$remaining" -lt 200 ]; then + reset=$(echo "$payload" | jq -r '.resources.core.reset // 0') + now=$(date +%s) + wait=$((reset - now + 10)) + [ "$wait" -lt 60 ] && wait=60 + log "⚠ Gitea API rate limit low (${remaining} left) — sleeping ${wait}s until reset" + sleep "$wait" + fi + return 0 + fi payload=$(python3 "$SB_GITHUB_READ" --kind quota -- api rate_limit) || return $? # REST misreports the GraphQL bucket; super-board-gh-guard.sh → sb_gh_quota_merge. payload=$(. "$(dirname "$SB_GITHUB_READ")/super-board-gh-guard.sh" && sb_gh_quota_merge "$payload") @@ -297,7 +379,7 @@ try_claim_assignee() { local issue="$1" [ -z "$BOT_LOGIN" ] && return 0 gh_checkpoint - gh_write_once issue edit "$issue" --add-assignee "$BOT_LOGIN" >/dev/null 2>&1 || { + forge_assign add "$issue" "$BOT_LOGIN" || { log "claim failed on #${issue} (race or gh api error) — skipping this tick" return 1 } @@ -400,7 +482,7 @@ check_lane_zombie() { sleep 1 kill -9 "$pid" 2>/dev/null || true gh_checkpoint - [ -n "$BOT_LOGIN" ] && gh_write_once issue edit "$issue" --remove-assignee "$BOT_LOGIN" >/dev/null 2>&1 || true + [ -n "$BOT_LOGIN" ] && forge_assign remove "$issue" "$BOT_LOGIN" || true gh_checkpoint rm -f "$INFLIGHT_DIR/$issue" case "$lane" in @@ -479,7 +561,7 @@ reap_finished_locks() { gh_checkpoint if [ -n "$BOT_LOGIN" ]; then gh_checkpoint - gh_write_once issue edit "$issue" --remove-assignee "$BOT_LOGIN" >/dev/null 2>&1 || true + forge_assign remove "$issue" "$BOT_LOGIN" || true log "reaped stale lock + swept assignee on #${issue} (pid=${PID:-empty})" else log "reaped stale lock for #${issue} (pid=${PID:-empty})" @@ -544,18 +626,18 @@ reclaim_stranded_building() { continue fi fi - if ! set_card_status "$item_id" "Ready"; then + if ! set_card_status "$item_id" "Ready" "$issue"; then gh_checkpoint log "⚠ stranded #${issue} in Building — could not move it to Ready; drag it by hand" continue fi - [ -n "$BOT_LOGIN" ] && gh_write_once issue edit "$issue" --remove-assignee "$BOT_LOGIN" >/dev/null 2>&1 || true + [ -n "$BOT_LOGIN" ] && forge_assign remove "$issue" "$BOT_LOGIN" || true # Comment format: writing-standard.md § 4. gh_checkpoint - gh_write_once issue comment "$issue" --body "[orchestrator] [report] ↩️ back to Ready · stranded in Building + forge_comment "$issue" "[orchestrator] [report] ↩️ back to Ready · stranded in Building Did: found no live worker; the last run stopped mid-build ✅ Done: card moved to Ready · branch ${branch:-none found}${branch:+ kept} -Next: builder (next tick${branch:+, continues on the branch})" >/dev/null 2>&1 || true +Next: builder (next tick${branch:+, continues on the branch})" || true log "↩ stranded #${issue}: Building → Ready (branch ${branch:-none})" done </dev/null \ + | jq -r --arg p "issue-${issue}-" '[.[] | select(.headRefName | startswith($p)) | .number][0] // empty' + return 0 + fi gh pr list --state open --json number,headRefName \ --jq ".[] | select(.headRefName | startswith(\"issue-${issue}-\")) | .number" 2>/dev/null | head -1 } @@ -106,6 +123,20 @@ Did: \`super-board stop\` ended worker PID ${pid:-unknown} at ${TS} ❌ Not done: interrupted work may be uncommitted; inspect the preserved worktree Next: preserve edits before \`super-board run ${CONFIG_SLUG}\`; dirty or legacy worktrees need inspection" + if [ "$FORGE_KIND" = gitea ]; then + # On Gitea a PR IS an issue: one comments endpoint serves both. + # shellcheck source=super-board-gitea-api.sh + . "$HERE/super-board-gitea-api.sh" + sb_gitea_api POST "repos/{owner}/{repo}/issues/${issue}/comments" "$(jq -cn --arg b "$body" '{body:$b}')" >/dev/null 2>&1 \ + && log " 💬 issue comment posted on #${issue}" \ + || log " ⚠ failed to comment on issue #${issue} (continuing)" + if [ -n "$pr" ]; then + sb_gitea_api POST "repos/{owner}/{repo}/issues/${pr}/comments" "$(jq -cn --arg b "$body" '{body:$b}')" >/dev/null 2>&1 \ + && log " 💬 PR comment posted on #${pr}" \ + || log " ⚠ failed to comment on PR #${pr} (continuing)" + fi + return 0 + fi gh issue comment "$issue" --body "$body" >/dev/null 2>&1 \ && log " 💬 issue comment posted on #${issue}" \ || log " ⚠ failed to comment on issue #${issue} (continuing)" @@ -120,6 +151,19 @@ Next: preserve edits before \`super-board run ${CONFIG_SLUG}\`; dirty or legacy release_claim() { local issue="$1" [ -z "$BOT_LOGIN" ] && return 0 + if [ "$FORGE_KIND" = gitea ]; then + # shellcheck source=super-board-gitea-api.sh + . "$HERE/super-board-gitea-api.sh" + sb_gitea_api DELETE "repos/{owner}/{repo}/issues/${issue}/assignees" \ + "$(jq -cn --arg l "$BOT_LOGIN" '{assignees:[$l]}')" >/dev/null 2>&1 || true + for label in loop:in-build loop:in-qa loop:in-review; do + local lid + lid=$(sb_gitea_label_id "$label" 2>/dev/null || true) + [ -n "$lid" ] && sb_gitea_api DELETE "repos/{owner}/{repo}/issues/${issue}/labels/${lid}" >/dev/null 2>&1 || true + done + log " 🔓 released assignee + lane labels on #${issue}" + return 0 + fi gh issue edit "$issue" --remove-assignee "$BOT_LOGIN" >/dev/null 2>&1 || true for label in loop:in-build loop:in-qa loop:in-review; do gh issue edit "$issue" --remove-label "$label" >/dev/null 2>&1 || true diff --git a/scripts/super-qa-file-bug.sh b/scripts/super-qa-file-bug.sh index f34a4e13..36b7cfbd 100755 --- a/scripts/super-qa-file-bug.sh +++ b/scripts/super-qa-file-bug.sh @@ -144,39 +144,76 @@ if [ -z "$FINGERPRINT" ]; then | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g; s/^-|-$//g')" fi -GITHUB_READ="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/super-board-github-read.py" -python3 "$GITHUB_READ" --check || exit $? +HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +GITHUB_READ="$HERE/super-board-github-read.py" +GITEA_READ="$HERE/super-board-gitea-read.py" +# Forge resolution: env SB_FORGE (or an SB_CONFIG config) picks gitea; the +# default stays github. Lane workers on a gitea board export both. +FORGE_KIND=github +if [ -f "$HERE/super-board-forge.sh" ]; then + # shellcheck source=super-board-forge.sh + . "$HERE/super-board-forge.sh" + sb_forge_resolve ${SB_CONFIG:+"$SB_CONFIG"} || exit $? + FORGE_KIND="$SB_FORGE_KIND" +fi +if [ "$FORGE_KIND" = gitea ]; then READ_PY="$GITEA_READ"; else READ_PY="$GITHUB_READ"; fi +if [ "$FORGE_KIND" = gitea ]; then + # shellcheck source=super-board-gitea-api.sh + . "$HERE/super-board-gitea-api.sh" +fi +python3 "$READ_PY" --check || exit $? # --- project resolution ----------------------------------------------------- -OWNER="${SUPER_QA_PROJECT_OWNER:-}" -if [ -z "$OWNER" ]; then - OWNER=$(python3 "$GITHUB_READ" --kind scalar -- repo view --json owner -q .owner.login) || exit $? +if [ "$FORGE_KIND" = gitea ]; then + REPO_NAME="${SUPER_QA_REPO:-$SB_FORGE_OWNER/$SB_FORGE_REPO}" + OWNER="${SUPER_QA_PROJECT_OWNER:-$SB_FORGE_OWNER}" +else + OWNER="${SUPER_QA_PROJECT_OWNER:-}" + if [ -z "$OWNER" ]; then + OWNER=$(python3 "$GITHUB_READ" --kind scalar -- repo view --json owner -q .owner.login) || exit $? + fi fi PROJECT_TITLE="${SUPER_QA_PROJECT_TITLE:-Super Ultimate QA}" TARGET_COLUMN="${SUPER_QA_TARGET_OPTION_NAME:-Bug}" -PROJECT_LIST=$(python3 "$GITHUB_READ" --kind projects -- project list --owner "$OWNER" --format json) || exit $? +if [ "$FORGE_KIND" = gitea ]; then + PROJECT_LIST=$(python3 "$GITEA_READ" --kind projects --projects "$REPO_NAME") || exit $? +else + PROJECT_LIST=$(python3 "$GITHUB_READ" --kind projects -- project list --owner "$OWNER" --format json) || exit $? +fi NUMBER=$(echo "$PROJECT_LIST" | jq -r --arg t "$PROJECT_TITLE" \ - '[.projects[] | select((.title // "" | ascii_downcase) == ($t | ascii_downcase))] | first | .number // empty') + '[.projects[] | select((.title // "" | ascii_downcase) == ($t | ascii_downcase))] | first | (.number // .id) // empty') # Do NOT silently fall back to the repo's primary project — its columns mean # different things, and QA cards would enter a lane that never expects them. [ -n "$NUMBER" ] || die "no project titled '${PROJECT_TITLE}' under ${OWNER} — create one, or set SUPER_QA_PROJECT_TITLE" 70 # --- dedupe ----------------------------------------------------------------- -REPO_NAME="${SUPER_QA_REPO:-}" -if [ -z "$REPO_NAME" ]; then - REPO_NAME=$(python3 "$GITHUB_READ" --kind scalar -- repo view --json nameWithOwner --jq .nameWithOwner) || exit $? +if [ "$FORGE_KIND" = gitea ]; then + : "${REPO_NAME:=$SB_FORGE_OWNER/$SB_FORGE_REPO}" +else + REPO_NAME="${SUPER_QA_REPO:-}" + if [ -z "$REPO_NAME" ]; then + REPO_NAME=$(python3 "$GITHUB_READ" --kind scalar -- repo view --json nameWithOwner --jq .nameWithOwner) || exit $? + fi fi REPO_FLAG=(-R "$REPO_NAME") -ISSUES_JSON=$(python3 "$GITHUB_READ" --issue-history "$REPO_NAME") || exit $? +ISSUES_JSON=$(python3 "$READ_PY" --issue-history "$REPO_NAME") || exit $? EXISTING=$(printf '%s' "$ISSUES_JSON" | jq -r --arg fingerprint "$FINGERPRINT" '[.[] | select(.state == "OPEN" and any(.body | splits("\\s+"); . == $fingerprint)) | .number] | first // empty') if [ -n "$EXISTING" ]; then - python3 "$GITHUB_READ" --check || exit $? - gh issue comment "$EXISTING" "${REPO_FLAG[@]}" --body "Seen again${ITER:+ on iteration ${ITER}}. + python3 "$READ_PY" --check || exit $? + SEEN_BODY="Seen again${ITER:+ on iteration ${ITER}}. -${BODY_RAW}" >/dev/null 2>&1 || { python3 "$GITHUB_READ" --halt "Comment outcome unknown for #${EXISTING}; inspect before retrying"; exit 79; } +${BODY_RAW}" + if [ "$FORGE_KIND" = gitea ]; then + sb_gitea_api POST "repos/$REPO_NAME/issues/${EXISTING}/comments" \ + "$(jq -cn --arg b "$SEEN_BODY" '{body:$b}')" >/dev/null 2>&1 \ + || { python3 "$READ_PY" --halt "Comment outcome unknown for #${EXISTING}; inspect before retrying"; exit 79; } + else + gh issue comment "$EXISTING" "${REPO_FLAG[@]}" --body "$SEEN_BODY" >/dev/null 2>&1 \ + || { python3 "$READ_PY" --halt "Comment outcome unknown for #${EXISTING}; inspect before retrying"; exit 79; } + fi echo "$EXISTING" exit 0 fi @@ -238,24 +275,67 @@ if [ -n "$CATEGORY" ]; then LABELS+=("qa:${CATEGORY}"); fi if [ -n "$SUGGESTED_SKILL" ]; then LABELS+=("skill:${SUGGESTED_SKILL}"); fi # `gh issue create` hard-fails on an unknown label, which would lose the finding -# entirely. Create them best-effort first. +# entirely. Create them best-effort first. On Gitea, POST issues takes label IDs, +# so resolve-or-create each one and pass the ids in the create payload. +GITEA_LABEL_IDS="[]" for l in "${LABELS[@]}"; do - python3 "$GITHUB_READ" --check || exit $? - gh label create "$l" "${REPO_FLAG[@]}" --color D93F0B --force >/dev/null 2>&1 || true + python3 "$READ_PY" --check || exit $? + if [ "$FORGE_KIND" = gitea ]; then + lid=$(sb_gitea_api GET "repos/$REPO_NAME/labels" 2>/dev/null | jq -r --arg n "$l" '[.[] | select(.name == $n) | .id][0] // empty') + if [ -z "$lid" ]; then + lid=$(sb_gitea_api POST "repos/$REPO_NAME/labels" \ + "$(jq -cn --arg n "$l" '{name:$n,color:"#d93f0b"}')" 2>/dev/null | jq -r '.id // empty') || lid="" + fi + [ -n "$lid" ] && GITEA_LABEL_IDS=$(jq -cn --argjson a "$GITEA_LABEL_IDS" --argjson i "$lid" '$a + [$i]') + else + gh label create "$l" "${REPO_FLAG[@]}" --color D93F0B --force >/dev/null 2>&1 || true + fi done LABEL_ARGS=() for l in "${LABELS[@]}"; do LABEL_ARGS+=(--label "$l"); done -python3 "$GITHUB_READ" --check || exit $? -ISSUE_URL=$(gh issue create "${REPO_FLAG[@]}" --title "$FULL_TITLE" --body-file "$BODY_TMP" "${LABEL_ARGS[@]}") \ - || { python3 "$GITHUB_READ" --halt "Issue creation response failed; reconcile fingerprint ${FINGERPRINT} before retrying"; exit 79; } -ISSUE_N=$(basename "$ISSUE_URL") +python3 "$READ_PY" --check || exit $? +if [ "$FORGE_KIND" = gitea ]; then + CREATED=$(sb_gitea_api POST "repos/$REPO_NAME/issues" \ + "$(jq -cn --arg t "$FULL_TITLE" --rawfile b "$BODY_TMP" --argjson l "$GITEA_LABEL_IDS" \ + '{title:$t, body:$b, labels:$l}')") \ + || { python3 "$READ_PY" --halt "Issue creation response failed; reconcile fingerprint ${FINGERPRINT} before retrying"; exit 79; } + ISSUE_N=$(echo "$CREATED" | jq -r .number) + ISSUE_URL=$(echo "$CREATED" | jq -r '.html_url // empty') + [ -n "$ISSUE_URL" ] || ISSUE_URL="http://gitea/$REPO_NAME/issues/$ISSUE_N" + GITEA_ISSUE_GID=$(echo "$CREATED" | jq -r .id) +else + ISSUE_URL=$(gh issue create "${REPO_FLAG[@]}" --title "$FULL_TITLE" --body-file "$BODY_TMP" "${LABEL_ARGS[@]}") \ + || { python3 "$READ_PY" --halt "Issue creation response failed; reconcile fingerprint ${FINGERPRINT} before retrying"; exit 79; } + ISSUE_N=$(basename "$ISSUE_URL") +fi # --- promote onto the board ------------------------------------------------- # Past this point the issue exists, so the number goes to stdout no matter what: # exit 71 tells the caller "filed, needs a manual move" rather than losing it. promote() { local item_id project_id field_json field_id option_id + if [ "$FORGE_KIND" = gitea ]; then + # One step on Gitea: adding the issue straight into the target column. + local column_id candidate + python3 "$READ_PY" --check || return $? + field_json=$(python3 "$GITEA_READ" --kind fields --fields "$REPO_NAME/$NUMBER") || return $? + column_id="" + for candidate in "$TARGET_COLUMN" Bug Ready Todo Backlog Triage; do + column_id=$(echo "$field_json" | jq -r --arg c "$candidate" \ + '[.fields[0].options[]? | select(.name==$c) | .id][0] // empty') + if [ -n "$column_id" ]; then + [ "$candidate" = "$TARGET_COLUMN" ] || \ + echo "note: no '${TARGET_COLUMN}' column on this board — filed the bug into '${candidate}'" >&2 + break + fi + done + [ -n "$column_id" ] || { echo "warn: no '${TARGET_COLUMN}' column and no alias (Bug, Ready, Todo, Backlog, Triage) on the board" >&2; return 1; } + python3 "$READ_PY" --check || return $? + sb_gitea_api POST "repos/$REPO_NAME/projects/$NUMBER/columns/$column_id/issues/$GITEA_ISSUE_GID" >/dev/null \ + || { python3 "$READ_PY" --halt "Project column add outcome unknown for issue #${ISSUE_N}; reconcile before retrying"; return 79; } + return 0 + fi python3 "$GITHUB_READ" --check || return $? item_id=$(gh project item-add "$NUMBER" --owner "$OWNER" --url "$ISSUE_URL" --format json --jq '.id') || { python3 "$GITHUB_READ" --halt "Project item add outcome unknown for issue #${ISSUE_N}; reconcile before retrying"; return 79; } project_id=$(python3 "$GITHUB_READ" --kind scalar -- project view "$NUMBER" --owner "$OWNER" --format json --jq '.id') || return $? diff --git a/scripts/super-review-file-refactor.sh b/scripts/super-review-file-refactor.sh index 13d97c9c..8e19d504 100755 --- a/scripts/super-review-file-refactor.sh +++ b/scripts/super-review-file-refactor.sh @@ -66,37 +66,66 @@ OWNER=$(echo "$CONFIG_JSON" | jq -r '.project.owner') NUMBER=$(echo "$CONFIG_JSON" | jq -r '.project.number') REPO=$(echo "$CONFIG_JSON" | jq -r '.repo.remote // empty') +HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +GITHUB_READ="$HERE/super-board-github-read.py" +GITEA_READ="$HERE/super-board-gitea-read.py" +# Forge resolution from the config the reviewer already passes. +FORGE_KIND=github +if [ -f "$HERE/super-board-forge.sh" ]; then + # shellcheck source=super-board-forge.sh + . "$HERE/super-board-forge.sh" + sb_forge_resolve "$CONFIG" || exit $? + FORGE_KIND="$SB_FORGE_KIND" +fi +if [ "$FORGE_KIND" = gitea ]; then + READ_PY="$GITEA_READ" + # shellcheck source=super-board-gitea-api.sh + . "$HERE/super-board-gitea-api.sh" +else + READ_PY="$GITHUB_READ" +fi + # `gh issue` needs an -R when the CWD is a worktree of a different remote; the # reviewer always runs from one, so resolve it rather than trusting the CWD. -if [ -n "$REPO" ]; then +if [ "$FORGE_KIND" = gitea ]; then + REPO_FLAG=() + REPO_NAME="$SB_FORGE_OWNER/$SB_FORGE_REPO" +elif [ -n "$REPO" ]; then REPO_FLAG=(-R "$(echo "$REPO" | sed -E 's#(git@github\.com:|https://github\.com/)##; s#\.git$##')") else REPO_FLAG=() fi -GITHUB_READ="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/super-board-github-read.py" -python3 "$GITHUB_READ" --check || exit $? +python3 "$READ_PY" --check || exit $? # --- dedupe ----------------------------------------------------------------- # The fingerprint is stamped into the body as an HTML comment so it survives # edits to the prose and stays invisible on the rendered issue. STAMP="" -REPO_NAME="${REPO_FLAG[1]:-}" -if [ -z "$REPO_NAME" ]; then - REPO_NAME=$(python3 "$GITHUB_READ" --kind scalar -- repo view --json nameWithOwner --jq .nameWithOwner) || exit $? +if [ "$FORGE_KIND" != gitea ]; then + REPO_NAME="${REPO_FLAG[1]:-}" + if [ -z "$REPO_NAME" ]; then + REPO_NAME=$(python3 "$GITHUB_READ" --kind scalar -- repo view --json nameWithOwner --jq .nameWithOwner) || exit $? + fi fi -ISSUES_JSON=$(python3 "$GITHUB_READ" --issue-history "$REPO_NAME") || exit $? +ISSUES_JSON=$(python3 "$READ_PY" --issue-history "$REPO_NAME") || exit $? EXISTING=$(printf '%s' "$ISSUES_JSON" | jq -r --arg fingerprint "$FINGERPRINT" '[.[] | select(.state == "OPEN" and any(.body | splits("\\s+"); . == $fingerprint)) | .number] | first // empty') if [ -n "$EXISTING" ]; then # Same shape problem, seen again on a later PR. Add the sighting, don't stack cards. - python3 "$GITHUB_READ" --check || exit $? - gh issue comment "$EXISTING" "${REPO_FLAG[@]}" \ - --body "Seen again during review${PR:+ of #${PR}}. + python3 "$READ_PY" --check || exit $? + SEEN_BODY="Seen again during review${PR:+ of #${PR}}. -$(cat "$BODY_FILE")" >/dev/null 2>&1 \ - || { python3 "$GITHUB_READ" --halt "Comment outcome unknown for #${EXISTING}; inspect before retrying"; exit 79; } +$(cat "$BODY_FILE")" + if [ "$FORGE_KIND" = gitea ]; then + sb_gitea_api POST "repos/$REPO_NAME/issues/${EXISTING}/comments" \ + "$(jq -cn --arg b "$SEEN_BODY" '{body:$b}')" >/dev/null 2>&1 \ + || { python3 "$READ_PY" --halt "Comment outcome unknown for #${EXISTING}; inspect before retrying"; exit 79; } + else + gh issue comment "$EXISTING" "${REPO_FLAG[@]}" --body "$SEEN_BODY" >/dev/null 2>&1 \ + || { python3 "$READ_PY" --halt "Comment outcome unknown for #${EXISTING}; inspect before retrying"; exit 79; } + fi echo "$EXISTING" exit 0 fi @@ -172,9 +201,20 @@ if [ -n "$AREA" ]; then LABELS+=("area:${AREA}"); fi # Labels may not exist yet on a fresh repo. Create them best-effort; `gh issue # create` hard-fails on an unknown label, which would lose the finding entirely. +# On Gitea, POST issues takes label IDs: resolve-or-create each one. +GITEA_LABEL_IDS="[]" for l in "${LABELS[@]}"; do - python3 "$GITHUB_READ" --check || exit $? - gh label create "$l" "${REPO_FLAG[@]}" --color BFD4F2 --force >/dev/null 2>&1 || true + python3 "$READ_PY" --check || exit $? + if [ "$FORGE_KIND" = gitea ]; then + lid=$(sb_gitea_api GET "repos/$REPO_NAME/labels" 2>/dev/null | jq -r --arg n "$l" '[.[] | select(.name == $n) | .id][0] // empty') + if [ -z "$lid" ]; then + lid=$(sb_gitea_api POST "repos/$REPO_NAME/labels" \ + "$(jq -cn --arg n "$l" '{name:$n,color:"#bfd4f2"}')" 2>/dev/null | jq -r '.id // empty') || lid="" + fi + [ -n "$lid" ] && GITEA_LABEL_IDS=$(jq -cn --argjson a "$GITEA_LABEL_IDS" --argjson i "$lid" '$a + [$i]') + else + gh label create "$l" "${REPO_FLAG[@]}" --color BFD4F2 --force >/dev/null 2>&1 || true + fi done LABEL_ARGS=() @@ -183,13 +223,22 @@ for l in "${LABELS[@]}"; do LABEL_ARGS+=(--label "$l"); done # Title: `♻️ [refactor] : `; scope = --area, else the fingerprint's module. SCOPE="${AREA:-${FINGERPRINT%%|*}}" SCOPE=$(echo "${SCOPE:-code}" | tr '[:upper:]' '[:lower:]' | sed -E 's#[^a-z0-9._/-]+#-#g; s#^-+|-+$##g') -python3 "$GITHUB_READ" --check || exit $? -ISSUE_URL=$(gh issue create "${REPO_FLAG[@]}" \ - --title "♻️ [refactor] ${SCOPE:-code}: ${TITLE}" \ - --body-file "$BODY_TMP" \ - "${LABEL_ARGS[@]}") || { python3 "$GITHUB_READ" --halt "Issue creation response failed; reconcile fingerprint ${FINGERPRINT} before retrying"; exit 79; } - -ISSUE_N=$(basename "$ISSUE_URL") +python3 "$READ_PY" --check || exit $? +if [ "$FORGE_KIND" = gitea ]; then + CREATED=$(sb_gitea_api POST "repos/$REPO_NAME/issues" \ + "$(jq -cn --arg t "♻️ [refactor] ${SCOPE:-code}: ${TITLE}" --rawfile b "$BODY_TMP" --argjson l "$GITEA_LABEL_IDS" \ + '{title:$t, body:$b, labels:$l}')") \ + || { python3 "$READ_PY" --halt "Issue creation response failed; reconcile fingerprint ${FINGERPRINT} before retrying"; exit 79; } + ISSUE_URL=$(echo "$CREATED" | jq -r '.html_url // empty') + ISSUE_N=$(echo "$CREATED" | jq -r .number) + GITEA_ISSUE_GID=$(echo "$CREATED" | jq -r .id) +else + ISSUE_URL=$(gh issue create "${REPO_FLAG[@]}" \ + --title "♻️ [refactor] ${SCOPE:-code}: ${TITLE}" \ + --body-file "$BODY_TMP" \ + "${LABEL_ARGS[@]}") || { python3 "$READ_PY" --halt "Issue creation response failed; reconcile fingerprint ${FINGERPRINT} before retrying"; exit 79; } + ISSUE_N=$(basename "$ISSUE_URL") +fi # --- place on the board ----------------------------------------------------- # The holding column is deliberately NOT in the config's managed `columns` list, @@ -206,11 +255,6 @@ ISSUE_N=$(basename "$ISSUE_URL") place_card() { local item_id project_id field_json field_id option_id candidate local -a candidates - python3 "$GITHUB_READ" --check || return $? - item_id=$(gh project item-add "$NUMBER" --owner "$OWNER" --url "$ISSUE_URL" --format json --jq '.id') || { python3 "$GITHUB_READ" --halt "Project item add outcome unknown for issue #${ISSUE_N}; reconcile before retrying"; return 79; } - project_id=$(python3 "$GITHUB_READ" --kind scalar -- project view "$NUMBER" --owner "$OWNER" --format json --jq '.id') || return $? - field_json=$(python3 "$GITHUB_READ" --kind fields -- project field-list "$NUMBER" --owner "$OWNER" --format json) || return $? - field_id=$(echo "$field_json" | jq -r '.fields[] | select(.name=="Status") | .id') # The requested name first, then the conventional aliases for "not started". # Ordered by intent: a holding column beats Ready, because a card filed by a # reviewer has no acceptance criteria and Ready feeds the build lane directly. @@ -225,6 +269,37 @@ place_card() { else candidates=("$COLUMN" "Backlog" "Todo" "To do" "Triage" "Inbox") fi + if [ "$FORGE_KIND" = gitea ]; then + # Gitea places the card by adding it straight into the chosen column. + python3 "$READ_PY" --check || return $? + field_json=$(python3 "$GITEA_READ" --kind fields --fields "$REPO_NAME/$NUMBER") || return $? + option_id="" + for candidate in "${candidates[@]}"; do + option_id=$(echo "$field_json" | jq -r --arg c "$candidate" \ + '[.fields[0].options[]? | select(.name==$c) | .id][0] // empty') + if [ -n "$option_id" ]; then + [ "$candidate" = "$COLUMN" ] || \ + echo "note: no '${COLUMN}' column on this board — filed #${ISSUE_N} into '${candidate}'" >&2 + break + fi + done + if [ -n "$option_id" ]; then + python3 "$READ_PY" --check || return $? + sb_gitea_api POST "repos/$REPO_NAME/projects/$NUMBER/columns/$option_id/issues/$GITEA_ISSUE_GID" >/dev/null \ + || { python3 "$READ_PY" --halt "Project column add outcome unknown for issue #${ISSUE_N}; reconcile before retrying"; return 79; } + else + echo "warn: this board has no '${COLUMN}' column and none of the usual aliases" >&2 + echo "warn: (Backlog, Todo, To do, Triage, Inbox) — #${ISSUE_N} exists but is NOT on the board;" >&2 + echo "warn: add a holding column or pass --column, then move it by hand." >&2 + return 1 + fi + return 0 + fi + python3 "$GITHUB_READ" --check || return $? + item_id=$(gh project item-add "$NUMBER" --owner "$OWNER" --url "$ISSUE_URL" --format json --jq '.id') || { python3 "$GITHUB_READ" --halt "Project item add outcome unknown for issue #${ISSUE_N}; reconcile before retrying"; return 79; } + project_id=$(python3 "$GITHUB_READ" --kind scalar -- project view "$NUMBER" --owner "$OWNER" --format json --jq '.id') || return $? + field_json=$(python3 "$GITHUB_READ" --kind fields -- project field-list "$NUMBER" --owner "$OWNER" --format json) || return $? + field_id=$(echo "$field_json" | jq -r '.fields[] | select(.name=="Status") | .id') for candidate in "${candidates[@]}"; do option_id=$(echo "$field_json" | jq -r --arg c "$candidate" \ '.fields[] | select(.name=="Status") | .options[]? | select(.name==$c) | .id') @@ -248,7 +323,7 @@ place_card() { if ! place_card; then echo "$ISSUE_N" - python3 "$GITHUB_READ" --check || exit 79 + python3 "$READ_PY" --check || exit 79 echo "warn: filed #${ISSUE_N} but could not place it on project ${OWNER}/${NUMBER}; inspect before retrying" >&2 exit 71 fi diff --git a/skills/super-collect/scripts/super-collect-file.sh b/skills/super-collect/scripts/super-collect-file.sh index 8c8faf41..35ed39b8 100755 --- a/skills/super-collect/scripts/super-collect-file.sh +++ b/skills/super-collect/scripts/super-collect-file.sh @@ -97,10 +97,29 @@ fi # Router-owned duplicate/adopt writes share the same halt as the child filers. GITHUB_READ="$BIN/super-board-github-read.py" -python3 "$GITHUB_READ" --check || exit $? -REPO_NAME="${REPO_FLAG[1]:-}" -if [ -z "$REPO_NAME" ]; then - REPO_NAME=$(python3 "$GITHUB_READ" --kind scalar -- repo view --json nameWithOwner --jq .nameWithOwner) || exit $? +GITEA_READ="$BIN/super-board-gitea-read.py" +FORGE_KIND=github +if [ -f "$BIN/super-board-forge.sh" ]; then + # shellcheck source=/dev/null + . "$BIN/super-board-forge.sh" + sb_forge_resolve "$CONFIG" || exit $? + FORGE_KIND="$SB_FORGE_KIND" +fi +if [ "$FORGE_KIND" = gitea ]; then + READ_PY="$GITEA_READ" + # shellcheck source=/dev/null + . "$BIN/super-board-gitea-api.sh" +else + READ_PY="$GITHUB_READ" +fi +python3 "$READ_PY" --check || exit $? +if [ "$FORGE_KIND" = gitea ]; then + REPO_NAME="$SB_FORGE_OWNER/$SB_FORGE_REPO" +else + REPO_NAME="${REPO_FLAG[1]:-}" + if [ -z "$REPO_NAME" ]; then + REPO_NAME=$(python3 "$GITHUB_READ" --kind scalar -- repo view --json nameWithOwner --jq .nameWithOwner) || exit $? + fi fi case "$REPO_NAME" in */*) ;; *) die "cannot resolve owner/name for collector" 70;; esac STATE="$BIN/super-board-collect-state.py" @@ -141,7 +160,11 @@ if [ -z "$ADOPT" ]; then fi # --- holding column --------------------------------------------------------- -FIELDS=$(python3 "$GITHUB_READ" --kind fields -- project field-list "$NUMBER" --owner "$OWNER" --format json) || exit $? +if [ "$FORGE_KIND" = gitea ]; then + FIELDS=$(python3 "$GITEA_READ" --kind fields --fields "$REPO_NAME/$NUMBER") || exit $? +else + FIELDS=$(python3 "$GITHUB_READ" --kind fields -- project field-list "$NUMBER" --owner "$OWNER" --format json) || exit $? +fi HOLD="" for c in Backlog Todo "To do" Triage Inbox; do hit=$(echo "$FIELDS" | jq -r --arg c "$c" '.fields[] | select(.name=="Status") | .options[]? | select(.name==$c) | .name' | head -1) @@ -149,7 +172,7 @@ for c in Backlog Todo "To do" Triage Inbox; do done [ -n "$HOLD" ] || die "project ${OWNER}/${NUMBER} has no holding column (Backlog, Todo, To do, Triage, Inbox) — refusing: the filers would fall back to Ready" 65 -place() { # $1 = issue url +place() { # $1 = issue url (github) — gitea uses place_gitea with the global id local item_id project_id field_id option_id python3 "$GITHUB_READ" --check || return $? item_id=$(gh project item-add "$NUMBER" --owner "$OWNER" --url "$1" --format json --jq '.id') || return 1 @@ -162,8 +185,30 @@ place() { # $1 = issue url --field-id "$field_id" --single-select-option-id "$option_id" >/dev/null } +place_gitea() { # $1 = issue global id — one add-to-column call places the card + local option_id + python3 "$READ_PY" --check || return $? + option_id=$(echo "$FIELDS" | jq -r --arg c "$HOLD" '.fields[] | select(.name=="Status") | .options[] | select(.name==$c) | .id') + [ -n "$option_id" ] && [ "$option_id" != "null" ] || return 1 + sb_gitea_api POST "repos/$REPO_NAME/projects/$NUMBER/columns/$option_id/issues/$1" >/dev/null +} + tag() { # $1 = issue number, rest = labels; best-effort local n="$1"; shift + if [ "$FORGE_KIND" = gitea ]; then + local l lid + for l in "$@"; do + python3 "$READ_PY" --check || return $? + lid=$(sb_gitea_api GET "repos/$REPO_NAME/labels" 2>/dev/null | jq -r --arg n "$l" '[.[] | select(.name == $n) | .id][0] // empty') + [ -n "$lid" ] || sb_gitea_api POST "repos/$REPO_NAME/labels" \ + "$(jq -cn --arg n "$l" '{name:$n,color:"#5319e7"}')" >/dev/null 2>&1 || true + done + for l in "$@"; do + python3 "$READ_PY" --check || return $? + sb_gitea_label_add "$n" "$l" >/dev/null 2>&1 || echo "warn: could not label #${n} ${l}" >&2 + done + return 0 + fi for l in "$@"; do python3 "$GITHUB_READ" --check || return $? gh label create "$l" ${REPO_FLAG[@]+"${REPO_FLAG[@]}"} --color 5319E7 --force >/dev/null 2>&1 || true @@ -178,13 +223,21 @@ tag() { # $1 = issue number, rest = labels; best-effort # --- adopt ------------------------------------------------------------------ if [ -n "$ADOPT" ]; then if [ "$YES" -ne 1 ]; then echo "would-adopt|#${ADOPT}|${TYPE}|${HOLD}"; exit 0; fi - URL=$(python3 "$GITHUB_READ" --kind scalar -- issue view "$ADOPT" ${REPO_FLAG[@]+"${REPO_FLAG[@]}"} --json url --jq .url) || exit $? - BOARD=$(python3 "$GITHUB_READ" --kind items -- project item-list "$NUMBER" --owner "$OWNER" --format json --limit 500) || exit $? + GITEA_GID="" + if [ "$FORGE_KIND" = gitea ]; then + ADOPT_JSON=$(python3 "$READ_PY" --kind issue --issue "$ADOPT") || exit $? + URL=$(echo "$ADOPT_JSON" | jq -r .url) + GITEA_GID=$(echo "$ADOPT_JSON" | jq -r .id) + BOARD=$(python3 "$READ_PY" --kind items --items "$REPO_NAME/$NUMBER") || exit $? + else + URL=$(python3 "$GITHUB_READ" --kind scalar -- issue view "$ADOPT" ${REPO_FLAG[@]+"${REPO_FLAG[@]}"} --json url --jq .url) || exit $? + BOARD=$(python3 "$GITHUB_READ" --kind items -- project item-list "$NUMBER" --owner "$OWNER" --format json --limit 500) || exit $? + fi # A matching issue number without its repository URL cannot prove whether # this is already our card. Preserve potentially live work until reconciled. AMBIGUOUS=$(printf '%s' "$BOARD" | jq -r --argjson n "$ADOPT" '[.items[] | select(.content.type == "Issue" and .content.number == $n and ((.content.url // "") == ""))] | length') || exit 70 if [ "$AMBIGUOUS" != 0 ]; then - python3 "$GITHUB_READ" --halt "Board identity is incomplete for issue #${ADOPT}; reconcile before adoption" + python3 "$READ_PY" --halt "Board identity is incomplete for issue #${ADOPT}; reconcile before adoption" exit 79 fi # Never reset a card already on the board to Backlog, especially live work. @@ -192,7 +245,11 @@ if [ -n "$ADOPT" ]; then if [ "$ON_BOARD" != 0 ]; then echo "$ADOPT"; exit 0; fi state begin "$ADOPT" || exit $? tag "$ADOPT" "$TYPE" "source:collect" ${EXTRA_LABELS[@]+"${EXTRA_LABELS[@]}"} || { RC=$?; echo "$ADOPT"; exit "$RC"; } - place "$URL" || { RC=$?; echo "$ADOPT"; [ "$RC" -eq 79 ] && exit 79; echo "warn: #${ADOPT} not placed in '${HOLD}'" >&2; exit 71; } + if [ "$FORGE_KIND" = gitea ]; then + place_gitea "$GITEA_GID" || { RC=$?; echo "$ADOPT"; [ "$RC" -eq 79 ] && exit 79; echo "warn: #${ADOPT} not placed in '${HOLD}'" >&2; exit 71; } + else + place "$URL" || { RC=$?; echo "$ADOPT"; [ "$RC" -eq 79 ] && exit 79; echo "warn: #${ADOPT} not placed in '${HOLD}'" >&2; exit 71; } + fi state success "$ADOPT" || exit $? echo "$ADOPT"; exit 0 fi @@ -201,7 +258,7 @@ fi # Repo-wide, any label, any state. An open hit is a duplicate; a closed-only hit # is a recurrence — file again, but name the issue that claimed the fix. # Exact match on a whitespace-delimited token: `err|sentry|441` must not hit `err|sentry|4411`. -ISSUES_JSON=$(python3 "$GITHUB_READ" --issue-history "$REPO_NAME") || exit $? +ISSUES_JSON=$(python3 "$READ_PY" --issue-history "$REPO_NAME") || exit $? HITS=$(printf '%s' "$ISSUES_JSON" | jq -r --arg fp "$FP" '[.[] | select(any(.body | splits("\\s+"); . == $fp))] | sort_by(.state != "OPEN") | map("\(.number) \(.state)") | .[]') || exit 70 OPEN_HIT=$(echo "$HITS" | awk '$2=="OPEN"{print $1; exit}') @@ -209,13 +266,21 @@ CLOSED_HIT=$(echo "$HITS" | awk '$2!="OPEN" && $1!=""{print $1; exit}') if [ -n "$OPEN_HIT" ]; then if [ "$YES" -ne 1 ]; then echo "duplicate|#${OPEN_HIT}|${TYPE}|${TITLE}"; exit 0; fi - python3 "$GITHUB_READ" --check || { RC=$?; echo "$OPEN_HIT"; exit "$RC"; } + python3 "$READ_PY" --check || { RC=$?; echo "$OPEN_HIT"; exit "$RC"; } SEEN=$(state seen "$OPEN_HIT") || exit $? if [ "$SEEN" = unchanged ]; then echo "$OPEN_HIT"; exit 0; fi state begin "$OPEN_HIT" || exit $? - gh issue comment "$OPEN_HIT" ${REPO_FLAG[@]+"${REPO_FLAG[@]}"} --body "Seen again by super-collect (${SOURCE}). + SEEN_BODY="Seen again by super-collect (${SOURCE}). -$(cat "$BODY_FILE")" >/dev/null 2>&1 || { python3 "$GITHUB_READ" --halt "Collector comment outcome unknown for #${OPEN_HIT}; reconcile before retrying"; echo "$OPEN_HIT"; exit 79; } +$(cat "$BODY_FILE")" + if [ "$FORGE_KIND" = gitea ]; then + sb_gitea_api POST "repos/$REPO_NAME/issues/${OPEN_HIT}/comments" \ + "$(jq -cn --arg b "$SEEN_BODY" '{body:$b}')" >/dev/null 2>&1 \ + || { python3 "$READ_PY" --halt "Collector comment outcome unknown for #${OPEN_HIT}; reconcile before retrying"; echo "$OPEN_HIT"; exit 79; } + else + gh issue comment "$OPEN_HIT" ${REPO_FLAG[@]+"${REPO_FLAG[@]}"} --body "$SEEN_BODY" >/dev/null 2>&1 \ + || { python3 "$READ_PY" --halt "Collector comment outcome unknown for #${OPEN_HIT}; reconcile before retrying"; echo "$OPEN_HIT"; exit 79; } + fi state success "$OPEN_HIT" || exit $? echo "$OPEN_HIT"; exit 0 fi @@ -252,6 +317,7 @@ case "$TYPE" in case "$TYPE" in bug) KIND=bug; WEAK=0 ;; feature) KIND=feature; WEAK=1 ;; fix) KIND=tech-debt; WEAK=1 ;; esac OUT=$(SUPER_QA_PROJECT_OWNER="$OWNER" SUPER_QA_PROJECT_TITLE="$PTITLE" \ SUPER_QA_TARGET_OPTION_NAME="$HOLD" SUPER_QA_ALLOW_WEAK_BODY="$WEAK" SUPER_QA_REPO="$REPO_NAME" \ + SB_FORGE="$FORGE_KIND" SB_CONFIG="$CONFIG" \ "$BIN/super-qa-file-bug.sh" --title "$TITLE" --body-file "$BODY_TMP" --kind "$KIND" \ --priority "$PRIORITY" --fingerprint "$FP" ${AREA:+--area "$AREA"} 2>"$ERR"); RC=$? ;; esac @@ -263,7 +329,7 @@ if [ "$RC" -eq 79 ]; then [ -z "$N" ] || echo "$N"; exit 79; fi if [ "$RC" -eq 64 ] || [ "$RC" -eq 66 ]; then state known-failure || true; fi case "$N" in ''|*[!0-9]*) die "filer failed (exit ${RC})" "$([ "$RC" -ne 0 ] && echo "$RC" || echo 70)" ;; esac if [ "$RC" -ne 0 ]; then - python3 "$GITHUB_READ" --halt "Collector filing/placement incomplete for #${N}; reconcile before retrying" + python3 "$READ_PY" --halt "Collector filing/placement incomplete for #${N}; reconcile before retrying" echo "$N"; exit 79 fi tag "$N" "source:collect" "collect:${SOURCE}" ${EXTRA_LABELS[@]+"${EXTRA_LABELS[@]}"} || { RC=$?; echo "$N"; exit "$RC"; } diff --git a/tests/test-gitea-api.sh b/tests/test-gitea-api.sh index fd8945ed..dcc633ec 100755 --- a/tests/test-gitea-api.sh +++ b/tests/test-gitea-api.sh @@ -72,7 +72,21 @@ unset SB_GITEA_TEA SB_GITEA_TIMEOUT export SB_GITEA_TEA="bash $STUB" ok "hung tea → bounded failure (rc=$RC)" -# 7 — every write was logged for auditability. +# 7 — the merge endpoint pins the head: a stale head_commit_id is refused (409), +# the current one merges and records the merge commit. +jq '.pulls = [{"number":7,"title":"Fix","state":"open","merged":false, + "head":{"ref":"fix","sha":"abc123"}}]' .git/tea-state.json > "$TMP/s2" && mv "$TMP/s2" .git/tea-state.json +RC=0; sb_gitea_api POST 'repos/{owner}/{repo}/pulls/7/merge' \ + '{"do":"squash","head_commit_id":"stale000"}' >/dev/null 2>&1 || RC=$? +[ "$RC" != 0 ] || fail "stale head_commit_id must be refused" +jq -e '.pulls[0].merged == false' .git/tea-state.json >/dev/null || fail "refused merge mutated state" +sb_gitea_api POST 'repos/{owner}/{repo}/pulls/7/merge' \ + '{"do":"squash","head_commit_id":"abc123","delete_branch_after_merge":true}' >/dev/null || fail "pinned merge" +jq -e '.pulls[0].merged == true and .pulls[0].state == "closed"' .git/tea-state.json >/dev/null \ + || fail "merge not recorded: $(jq -c .pulls .git/tea-state.json)" +ok "merge pins head_commit_id: stale refused, current merges" + +# 8 — every write was logged for auditability. [ "$(grep -c '^POST' .git/tea-writes.log)" -ge 4 ] || fail "write log: $(cat .git/tea-writes.log)" ok "writes logged to tea-writes.log" diff --git a/tests/test-pr-body-gitea.sh b/tests/test-pr-body-gitea.sh new file mode 100644 index 00000000..cd44715b --- /dev/null +++ b/tests/test-pr-body-gitea.sh @@ -0,0 +1,74 @@ +#!/usr/bin/env bash +# Tests super-board-pr-body.sh's gitea branch against the offline tea stub: +# one marker block rewritten, head pin enforced (exit 6), idempotent no-op, +# dry-run touches nothing. No network. The github branch stays in test-pr-body.sh. +set -euo pipefail +cd "$(dirname "$0")" +KIT="$PWD/.." +PRBODY="$KIT/scripts/super-board-pr-body.sh" +STUB="$KIT/evals/_stubs/bin/tea" +TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT +fail() { echo "FAIL: $1" >&2; exit 1; } +pass=0; ok() { pass=$((pass + 1)); echo " ✅ $1"; } + +SHA=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +mkdir -p "$TMP/.git" +cat > "$TMP/.git/tea-state.json" <<EOF +{"issues":[], + "pulls":[{"number":7,"title":"Fix","state":"open","merged":false, + "head":{"ref":"fix","sha":"$SHA"}, + "body":"<!-- sb:status -->\nold status\n<!-- /sb:status -->\n\n<!-- sb:problem -->\nkeep me\n<!-- /sb:problem -->"}], + "labels":[],"projects":[],"columns":[],"comments":{},"writes":0} +EOF +if [ -x "/c/Program Files/Git/usr/bin/bash.exe" ]; then + BASH_EXE="C:/Program Files/Git/usr/bin/bash.exe" +else + BASH_EXE="bash" +fi +export SB_GITEA_TEA="\"$BASH_EXE\" $(cygpath -m "$STUB" 2>/dev/null || echo "$STUB")" \ + SB_FORGE=gitea SB_FORGE_HOST="http://localhost:3000" \ + SB_GITHUB_HALT_FILE="$TMP/halt.json" SB_GITEA_RETRY_DELAY=0 +printf 'building #7\n- did things\n' > "$TMP/block.md" + +run() { (cd "$TMP" && bash "$PRBODY" --repo example/shop "$@"); } +body_now() { jq -r '.pulls[0].body' "$TMP/.git/tea-state.json"; } + +# 1 — replaces only the named block, keeps the others byte-identical. +OUT=$(run --pr 7 --block status --expect-head "$SHA" --body-file "$TMP/block.md") || fail "update run" +[ "$OUT" = updated ] || fail "expected 'updated', got: $OUT" +body_now | grep -q 'building #7' || fail "block not written: $(body_now)" +body_now | grep -q 'keep me' || fail "other block clobbered: $(body_now)" +body_now | grep -q 'old status' && fail "old content survived" +ok "one block rewritten, others untouched" + +# 2 — same content again is a no-op. +OUT=$(run --pr 7 --block status --expect-head "$SHA" --body-file "$TMP/block.md") || fail "rerun" +[ "$OUT" = unchanged ] || fail "expected 'unchanged', got: $OUT" +ok "idempotent re-run reports unchanged" + +# 3 — a moved head refuses the edit (exit 6), body untouched. +BEFORE=$(body_now) +RC=0; run --pr 7 --block status --expect-head bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb \ + --body-file "$TMP/block.md" >/dev/null 2>&1 || RC=$? +[ "$RC" = 6 ] || fail "stale head should exit 6, got $RC" +[ "$(body_now)" = "$BEFORE" ] || fail "stale-head run wrote anyway" +ok "head pin: stale expect-head → exit 6, no write" + +# 4 — dry-run prints the new body and writes nothing. +printf 'dry content\n' > "$TMP/block.md" +W_BEFORE=$(wc -l < "$TMP/.git/tea-writes.log" 2>/dev/null | tr -d ' ' || echo 0) +OUT=$(run --pr 7 --block status --expect-head "$SHA" --body-file "$TMP/block.md" --dry-run) || fail "dry run" +grep -q 'dry content' <<<"$OUT" || fail "dry-run output missing the new block" +[ "$(body_now)" = "$BEFORE" ] || fail "dry-run wrote to the server" +W_AFTER=$(wc -l < "$TMP/.git/tea-writes.log" 2>/dev/null | tr -d ' ' || echo 0) +[ "$W_BEFORE" = "$W_AFTER" ] || fail "dry-run logged a write: $(tail -1 "$TMP/.git/tea-writes.log")" +ok "dry-run prints, never writes" + +# 5 — append mode adds a row inside the block once (history rows). +printf '| row one |\n' > "$TMP/block.md" +run --pr 7 --block history --expect-head "$SHA" --append-file "$TMP/block.md" >/dev/null || fail "append create" +run --pr 7 --block history --expect-head "$SHA" --append-file "$TMP/block.md" >/dev/null || fail "append twice" +[ "$(body_now | grep -c 'row one')" = 1 ] || fail "append duplicated the row: $(body_now)" +ok "append is idempotent per row" + +echo "test-pr-body-gitea: $pass passed" diff --git a/workflows/super-board-wave.js b/workflows/super-board-wave.js index e7047595..11c553a3 100644 --- a/workflows/super-board-wave.js +++ b/workflows/super-board-wave.js @@ -38,10 +38,29 @@ const readyLane = (card) => card.lane || (labelsOf(card).includes('qa') ? 'qa' : if (input.tier && !['low', 'medium', 'high'].includes(input.tier)) { throw new Error(`super-board-wave: unknown tier "${input.tier}" — use low | medium | high`) } +// Forge of this board's config (v3.2.0): the orchestrator passes config.forge. +// Prompts, read shapes and the label one-liner below follow it; the board +// scripts (card.sh, merge-gate, filers) resolve the same key themselves. +const FORGE = input.forge || 'github' +if (!['github', 'gitea'].includes(FORGE)) { + throw new Error(`super-board-wave: unknown forge "${FORGE}" — use github | gitea`) +} +const FORGE_NAME = FORGE === 'gitea' ? 'Gitea' : 'GitHub' +const READ_HELPER = `.claude/bin/super-board-${FORGE}-read.py` let halted = false -// Valid form per --kind, from validate() in scripts/super-board-github-read.py (#32). -const READ_SHAPES = [ +// Valid form per --kind, from validate() in the forge's read wrapper (#32). +const READ_SHAPES = FORGE === 'gitea' ? [ + `Read shapes (helper: ${READ_HELPER}; GITEA_REPO is exported by the lane setup):`, + `- issue title+body: --kind issue --issue <N>`, + `- issue comments: --kind comments --issue <N> (zero comments = [[]])`, + `- other JSON, incl. maybe-empty lists: --kind json -- api repos/{owner}/{repo}/… (GET only)`, + `- PR branch+head: --kind head --pr <N>`, + `- PR body+head: --kind body --pr <N>`, + `- PR metadata: --kind metadata --pr <N>`, + `- issue state: --kind state --issue <N>`, + `A read whose output misses its shape exits 64 for that call only and prints the valid form: fix the read, do not halt.`, +].join('\n') : [ `Read shapes (helper: .claude/bin/super-board-github-read.py --kind <kind> -- <gh args>):`, `- issue title+body: --kind issue -- issue view <N> --json number,title,body`, `- issue comments: --kind comments -- api repos/{owner}/{repo}/issues/<N>/comments --paginate --slurp (zero comments = [[]])`, @@ -52,7 +71,7 @@ const READ_SHAPES = [ `- issue state: --kind state -- issue view <N> --json state --jq .state`, `A read whose output misses its shape exits 64 for that call only and prints the valid form: fix the read, do not halt.`, ].join('\n') -const READ_FAILURE = READ_SHAPES + '\n' + `Verification-readiness exit 9 means missing/unusable config.verify_commands: preserve card/worktree/approval/claims, report status=halted (preflight verdict=halted), stop dispatch, repair project configuration before explicit restart; no Build bounce or automatic retries. ` + `Required GitHub reads use .claude/bin/super-board-github-read.py: three total attempts, exit 79 means run halted. Check --check before any GitHub write, migration, or merge. On exit 79 preserve worktree/card/approval/claims, make no more GitHub calls, and report status=halted (preflight verdict=halted). Never retry a mutation. Config: ${input.configPath}.` +const READ_FAILURE = READ_SHAPES + '\n' + `Verification-readiness exit 9 means missing/unusable config.verify_commands: preserve card/worktree/approval/claims, report status=halted (preflight verdict=halted), stop dispatch, repair project configuration before explicit restart; no Build bounce or automatic retries. ` + `Required ${FORGE_NAME} reads use ${READ_HELPER}: three total attempts, exit 79 means run halted. Check --check before any ${FORGE_NAME} write, migration, or merge. On exit 79 preserve worktree/card/approval/claims, make no more ${FORGE_NAME} calls, and report status=halted (preflight verdict=halted). Never retry a mutation. Config: ${input.configPath}.` const CLASSIFY_SCHEMA = { type: 'object', @@ -132,7 +151,9 @@ const REVIEW_MEMORY = [ // and its Status options with `gh project field-list` (101) before each move. const BOARD_IO = () => `Board moves and reads: .claude/bin/super-board-card.sh --config ${input.configPath} move <issue> <Status> ` + - `(1 GraphQL point) · status <issue> · items. Comments, labels, PR reads: REST per .claude/skills/super-board/references/rate-limit-etiquette.md → "Price list". Read GitHub once per decision, never in a sleep loop.` + (FORGE === 'gitea' + ? `(one move call) · status <issue> · items. Comments, labels, PR reads: tea through ${READ_HELPER} per .claude/skills/super-board/references/gitea.md. Read the forge once per decision, never in a sleep loop.` + : `(1 GraphQL point) · status <issue> · items. Comments, labels, PR reads: REST per .claude/skills/super-board/references/rate-limit-etiquette.md → "Price list". Read GitHub once per decision, never in a sleep loop.`) // The orchestrator resolves every remaining chain before claims. The runtime has // no subprocess API; each worker repeats the deterministic CLI before its writes. @@ -294,12 +315,15 @@ const results = await pipeline( const labels = labelsOf(card) const typed = ['qa', 'bug', 'feature'].find((l) => labels.includes(l)) const cls = await agent( - SKILLS_CHECK([card]) + '\n' + READ_FAILURE + '\n' + `Read GitHub issue #${card.number} ("${card.title}") — body (--kind issue) and all comments (--kind comments) — with the read shapes above. ` + + SKILLS_CHECK([card]) + '\n' + READ_FAILURE + '\n' + `Read ${FORGE_NAME} issue #${card.number} ("${card.title}") — body (--kind issue) and all comments (--kind comments) — with the read shapes above. ` + `Classify it: kind (feature|bug|qa) and complexity (low|medium|high) judged by the scope of change required. ` + (typed ? `Its label says "${typed}": return kind "${typed}" — the label routes the card, you never override it.` : `It has no type label, so it is built (no label = Building). Return feature or bug — never qa, ` + - `which only a person sets. Existing docs/ux/tests/refactor/tech-debt rows keep their label chain: classify complexity without adding feature/bug. For a truly untyped card, re-run skills-ready against a copy of this card with the proposed label before any label write, then add that label: gh issue edit ${card.number} --add-label <kind>.`), + `which only a person sets. Existing docs/ux/tests/refactor/tech-debt rows keep their label chain: classify complexity without adding feature/bug. For a truly untyped card, re-run skills-ready against a copy of this card with the proposed label before any label write, then add that label: ` + + (FORGE === 'gitea' + ? `bash -c '. .claude/bin/super-board-forge.sh && sb_forge_resolve ${input.configPath} && sb_forge_label_add ${card.number} <kind>'.` + : `gh issue edit ${card.number} --add-label <kind>.`)), { label: `classify:#${card.number}`, phase: 'Classify', model: classifyModel, schema: CLASSIFY_SCHEMA } ) if (cls && cls.status === 'halted') halted = true From be847c8a145e6a3885ee2b7f84f87763c257b2bb Mon Sep 17 00:00:00 2001 From: PhucMN <phucmnp@gmail.com> Date: Fri, 16 Oct 2026 17:15:43 +0700 Subject: [PATCH 5/8] =?UTF-8?q?=E2=9C=A8=20[feat]=20forge:=20gitea=20colle?= =?UTF-8?q?ctors,=20hooks,=20deps=20and=20planners?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - gitea-read: --deps composite (open issues + last 8 comments) emitting the GraphQL node shape the deps parser reads - deps.sh: --forge flag (+ SB_FORGE env); approval enrichment carries --forge - preflight.sh: --forge flag; merged/open/closed/target reads through gitea-read with identical normalized shapes - cleanup-wt.py: pull_requests dispatches to tea (CLEANUP_WT_TEA / SB_FORGE / non-github remote); remote-branch safety unchanged — an unavailable forge CLI still keeps branches - collect_prs.py: gitea list via pulls?state=closed&sort=recentupdate with per-PR comments/reviews; documented degradations (no reviewThreads, mergedAt from closed_at) - wave-plan.sh: forge resolved once from the config and exported (SB_FORGE_*), deps repo derivation works for any host - codex-lane/codex-wave: helper + prompts follow the config's forge; merge line forbids bare tea pulls merge too - tests: test-deps-gitea.sh; full gitea suite (11 bash + 2 python) green Co-Authored-By: Claude Code <noreply@anthropic.com> --- hooks/cleanup-wt.py | 78 ++++++++++++++++- scripts/super-board-codex-lane.sh | 11 ++- scripts/super-board-codex-wave.sh | 18 ++-- scripts/super-board-deps.sh | 15 +++- scripts/super-board-forge.py | 5 +- scripts/super-board-gitea-read.py | 26 +++++- scripts/super-board-preflight.sh | 29 +++++-- scripts/super-board-wave-plan.sh | 22 ++++- skills/super-collect/scripts/collect_prs.py | 95 +++++++++++++++++++-- tests/test-deps-gitea.sh | 48 +++++++++++ 10 files changed, 316 insertions(+), 31 deletions(-) create mode 100644 tests/test-deps-gitea.sh diff --git a/hooks/cleanup-wt.py b/hooks/cleanup-wt.py index aab84768..640948d6 100755 --- a/hooks/cleanup-wt.py +++ b/hooks/cleanup-wt.py @@ -169,8 +169,84 @@ def merged_state(cwd, tip, bases, merged_pr_oids=()): return None +def _remote_owner_repo(cwd): + """owner/name from the origin remote (any forge, https/http/ssh/scp), else None.""" + import re + url = (git_out(cwd, "remote", "get-url", "origin") or "").strip() + m = (re.match(r'^(?:https?|ssh|git)://(?:[^@/]+@)?[^/]+/(.+?)(?:\.git)?/?$', url) + or re.match(r'^(?:[^@/\s]+@)?[^/:\s]+:(.+?)(?:\.git)?/?$', url)) + if not m: + return None + parts = [p for p in m.group(1).strip("/").split("/") if p] + return (parts[-2], parts[-1]) if len(parts) >= 2 else None + + +def _gitea_forge(cwd): + """Gitea when told (SB_FORGE/CLEANUP_WT_TEA), else when origin is not GitHub.""" + forge = (os.environ.get("SB_FORGE") or "").strip().lower() + if forge: + return forge == "gitea" + if os.environ.get("CLEANUP_WT_TEA"): + return True + remote = (git_out(cwd, "remote", "get-url", "origin") or "").lower() + return bool(remote) and "github.com" not in remote + + +def pull_requests_gitea(cwd): + """{open: {branch: number}, merged: {branch: [oid]}} via tea api, or None.""" + import shlex + exe = shlex.split(os.environ.get("CLEANUP_WT_TEA", "tea")) + orr = _remote_owner_repo(cwd) + if not orr: + return None + base = f"repos/{orr[0]}/{orr[1]}" + + def tea(endpoint): + try: + r = subprocess.run(exe + ["api", "-X", "GET", endpoint], cwd=cwd, + capture_output=True, text=True, encoding="utf-8", + errors="replace", timeout=15) + return json.loads(r.stdout) if r.returncode == 0 else None + except (OSError, ValueError, subprocess.TimeoutExpired): + return None + + def paged(endpoint, cap): + out = [] + for page in range(1, cap // 50 + 1): + batch = tea(f"{endpoint}&page={page}&limit=50") + if not isinstance(batch, list): + return None if page == 1 else out + out += batch + if len(batch) < 50: + return out + return out + + opened = paged(f"{base}/pulls?state=open", 200) + if not isinstance(opened, list): + return None + closed = paged(f"{base}/pulls?state=closed", 300) or [] + open_by, merged_by = {}, {} + for pr in opened: + head = (pr.get("head") or {}).get("ref") + open_by.setdefault(head, pr.get("number")) + open_by.setdefault(pr.get("base", {}).get("ref") if isinstance(pr.get("base"), dict) else None, + pr.get("number")) + open_by.pop(None, None) + for pr in closed: + if not pr.get("merged"): + continue + head = (pr.get("head") or {}).get("ref") + sha = (pr.get("head") or {}).get("sha") + if head and sha: + merged_by.setdefault(head, []).append(sha) + return {"open": open_by, "merged": merged_by} + + def pull_requests(cwd): - """{open: {branch: number}, merged: {branch: [oid]}}, or None when gh is unavailable.""" + """{open: {branch: number}, merged: {branch: [oid]}}, or None when the forge + CLI is unavailable (callers then keep remote branches — never guess).""" + if _gitea_forge(cwd): + return pull_requests_gitea(cwd) exe = os.environ.get("CLEANUP_WT_GH", "gh") env = dict(os.environ, GH_PROMPT_DISABLED="1", GH_NO_UPDATE_NOTIFIER="1", GH_PAGER="cat") diff --git a/scripts/super-board-codex-lane.sh b/scripts/super-board-codex-lane.sh index 70e0a87a..de36d4ee 100755 --- a/scripts/super-board-codex-lane.sh +++ b/scripts/super-board-codex-lane.sh @@ -96,9 +96,12 @@ try: except subprocess.CalledProcessError: fail('Codex lane must start inside the target git repository') os.chdir(root) -helper = script_path.with_name('super-board-github-read.py') +# Forge-aware helper: the gitea twin shares the --check/--halt contract. +FORGE = (os.environ.get('SB_FORGE') or config.get('forge') or 'github').lower() +FORGE_NAME = 'Gitea' if FORGE == 'gitea' else 'GitHub' +helper = script_path.with_name('super-board-gitea-read.py' if FORGE == 'gitea' else 'super-board-github-read.py') if not helper.exists() or subprocess.run([sys.executable, str(helper), '--check']).returncode: - result('halted', 'required GitHub reads halted or helper missing; preserve claims and worktrees') + result('halted', f'required {FORGE_NAME} reads halted or helper missing; preserve claims and worktrees') sys.exit(79) resolver_path = script_path.with_name('super-board-skills-ready.py') @@ -127,7 +130,7 @@ Resolved skill report: {json.dumps(skills)} Config: {config_path} Card: {json.dumps(card)} Read .claude/skills/{skill}/SKILL.md and .claude/skills/super-board/references/run.md → {section} lifecycle; follow all its board, branch, worktree, comments, test and merge requirements. -Source .claude/bin/super-board-gh-guard.sh and use its quota checks. Required GitHub reads go through .claude/bin/super-board-github-read.py; a read that misses its --kind shape exits 64 for that call only and prints the valid form, so fix the read. Check --check before new writes, migrations and merges; exit 79 means status=halted, no more GitHub calls, preserve claims/worktree/card/approval. Never retry a mutation. +Source .claude/bin/super-board-gh-guard.sh and use its quota checks. Required {FORGE_NAME} reads go through .claude/bin/{helper.name}; a read that misses its --kind shape exits 64 for that call only and prints the valid form, so fix the read. Check --check before new writes, migrations and merges; exit 79 means status=halted, no more {FORGE_NAME} calls, preserve claims/worktree/card/approval. Never retry a mutation. Use .claude/bin/super-board-card.sh for board reads/moves and .claude/bin/super-board-pr-body.sh for owned PR blocks; follow writing-standard.md and pr-author-notes.md. Use your own worktree under .claude/worktrees/; never edit the main checkout. Clean up on ordinary exit, preserve work on halt/interruption. Codex adaptation: do not launch Claude or other sub-agents. Perform preflight, classification, independent review and truth-check duties inline. This changes the execution host, never the evidence requirements, confidence threshold or merge policy. @@ -141,7 +144,7 @@ elif args.lane == 'qa' and card['status'] == 'Ready': elif args.lane == 'review': prompt += '''The owner explicitly chose run --codex: you may review and own the merge. First load the latest <!-- super-review:report -->; grade prior R-ids fixed/not fixed/no longer applies, bounce any not fixed and edit the same report in place. Form hypotheses from the issue AC and diff before reading the Builder narrative. Rerun the Tester's tests. When truth_gate triggers, apply super-review's fixed Adversarial mode brief inline in two distinct passes (code-grounder and historian); collect evidence and aggregate confidence against truth_threshold. Over-engineering is Should fix, never Blocker alone and never lowers confidence. Missing evidence fails closed. -Merge ONLY through the unchanged .claude/bin/super-board-merge-gate.sh, pinning the exact head you reviewed at review pass using --expect-head "$HEAD" --config <config> --pr <N> --subject <title> --body-file <msg.md>. Never run bare gh pr merge or bypass the gate. Follow run.md Merge protocol and route every gate exit exactly: 2/5 rebase pass, 3 Blocked, 4 stay Review, 6 fresh review, 7/8 human gate with pinned approval-request; 9 verification-readiness means halt and preserve card/worktree/approval/claims until config repair and explicit restart, never a Build bounce or rebase retry. Respect human_approves_merge and merge_policy. Confirm MERGED <sha>, fetch base and prove merge-base --is-ancestor <sha> origin/<base> before closing issue or moving Done. +Merge ONLY through the unchanged .claude/bin/super-board-merge-gate.sh, pinning the exact head you reviewed at review pass using --expect-head "$HEAD" --config <config> --pr <N> --subject <title> --body-file <msg.md>. Never run bare gh pr merge / tea pulls merge or bypass the gate. Follow run.md Merge protocol and route every gate exit exactly: 2/5 rebase pass, 3 Blocked, 4 stay Review, 6 fresh review, 7/8 human gate with pinned approval-request; 9 verification-readiness means halt and preserve card/worktree/approval/claims until config repair and explicit restart, never a Build bounce or rebase retry. Respect human_approves_merge and merge_policy. Confirm MERGED <sha>, fetch base and prove merge-base --is-ancestor <sha> origin/<base> before closing issue or moving Done. ''' counts = {key: {'type': 'integer'} for key in ['fixed', 'notFixed', 'noLongerApplies']} diff --git a/scripts/super-board-codex-wave.sh b/scripts/super-board-codex-wave.sh index 9bade29f..f10855af 100755 --- a/scripts/super-board-codex-wave.sh +++ b/scripts/super-board-codex-wave.sh @@ -130,6 +130,7 @@ except FileExistsError: # The router only grades scope; it writes nothing. A Codex-only run grades with # the cheapest Codex model rather than waking Claude. ROUTER_MODEL = 'gpt-6-luna' +FORGE = (os.environ.get('SB_FORGE') or config.get('forge') or 'github').lower() GRADE_SCHEMA = {'type': 'object', 'additionalProperties': False, 'required': ['complexity'], 'properties': {'complexity': {'type': 'string', 'enum': ['low', 'medium', 'high']}}} @@ -139,11 +140,18 @@ def grade(card): return card.get('complexity') if card.get('complexity') in ['low', 'medium', 'high'] else None, False if card.get('complexity') in ['low', 'medium', 'high']: return card['complexity'], False - prompt = (f"Read GitHub issue #{card['number']} (\"{card.get('title', '')}\") - body and all comments - with " - f".claude/bin/super-board-github-read.py --kind issue -- issue view {card['number']} --json number,title,body and " - f"--kind comments -- api repos/{{owner}}/{{repo}}/issues/{card['number']}/comments --paginate --slurp. " - 'Grade complexity (low|medium|high) by the scope of change required. Read only: change no file, ' - 'label, comment or board state. Exit 79 from the read helper means stop and return nothing.\n') + if FORGE == 'gitea': + prompt = (f"Read Gitea issue #{card['number']} (\"{card.get('title', '')}\") - body and all comments - with " + f".claude/bin/super-board-gitea-read.py --kind issue --issue {card['number']} and " + f"--kind comments --issue {card['number']}. " + 'Grade complexity (low|medium|high) by the scope of change required. Read only: change no file, ' + 'label, comment or board state. Exit 79 from the read helper means stop and return nothing.\n') + else: + prompt = (f"Read GitHub issue #{card['number']} (\"{card.get('title', '')}\") - body and all comments - with " + f".claude/bin/super-board-github-read.py --kind issue -- issue view {card['number']} --json number,title,body and " + f"--kind comments -- api repos/{{owner}}/{{repo}}/issues/{card['number']}/comments --paginate --slurp. " + 'Grade complexity (low|medium|high) by the scope of change required. Read only: change no file, ' + 'label, comment or board state. Exit 79 from the read helper means stop and return nothing.\n') with tempfile.TemporaryDirectory(prefix='super-board-codex-grade-') as temporary: schema_path, output = Path(temporary) / 'schema.json', Path(temporary) / 'grade.json' schema_path.write_text(json.dumps(GRADE_SCHEMA)) diff --git a/scripts/super-board-deps.sh b/scripts/super-board-deps.sh index 38d8449d..59588b63 100755 --- a/scripts/super-board-deps.sh +++ b/scripts/super-board-deps.sh @@ -60,21 +60,29 @@ set -euo pipefail HERE=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) -REPO=""; LIMIT="200"; ONLY=""; FROM="" +REPO=""; LIMIT="200"; ONLY=""; FROM=""; FORGE_ARG="" while [ $# -gt 0 ]; do case "$1" in --repo) REPO="$2"; shift 2 ;; --limit) LIMIT="$2"; shift 2 ;; --issues) ONLY="$2"; shift 2 ;; - --from) FROM="$2"; shift 2 ;; # a saved `gh issue list --json …` payload; tests use this + --forge) FORGE_ARG="$2"; shift 2 ;; # github|gitea; default: env SB_FORGE, else github + --from) FROM="$2"; shift 2 ;; # a saved issue-list payload; tests use this *) echo "unknown arg: $1" >&2; exit 64 ;; esac done +FORGE_KIND="${FORGE_ARG:-${SB_FORGE:-github}}" # Open issues carry the graph; closed ones are only needed to answer "is this # blocker still open?", which `openBlockers` derives from the open set itself. if [ -n "$FROM" ]; then ISSUES=$(cat "$FROM") +elif [ "$FORGE_KIND" = gitea ]; then + [ -n "$REPO" ] || { echo "--repo <owner/name> is required" >&2; exit 64; } + # One list read + one comments read per open issue (Gitea has no combined + # query). The node shape matches the GitHub GraphQL page below, so the + # fail-safe parser and the approval enrichment are forge-neutral. + ISSUES=$(GITEA_REPO="$REPO" python3 "$HERE/super-board-gitea-read.py" --deps "$REPO") || exit $? else [ -n "$REPO" ] || { echo "--repo <owner/name> is required" >&2; exit 64; } # GraphQL rather than `gh issue list`, because the lanes' `blocked-by:` line @@ -95,6 +103,7 @@ fi APPROVAL_REPO="$REPO" [ -z "$FROM" ] || APPROVAL_REPO="" +APPROVAL_FORGE=(--forge "$FORGE_KIND") echo "$ISSUES" | jq --arg only "$ONLY" ' # ---- the parser --------------------------------------------------------- # Everything after the LAST "## Blocked by" heading, stopping at the next @@ -192,4 +201,4 @@ echo "$ISSUES" | jq --arg only "$ONLY" ' needsYouDone: false } ] | ( if $filter == null then . else map(select(.number as $n | $filter | index($n))) end ) - | INDEX(.number | tostring)' | python3 "$(dirname "${BASH_SOURCE[0]}")/super-board-approval.py" --deps --repo "$APPROVAL_REPO" + | INDEX(.number | tostring)' | python3 "$(dirname "${BASH_SOURCE[0]}")/super-board-approval.py" --deps --repo "$APPROVAL_REPO" "${APPROVAL_FORGE[@]}" diff --git a/scripts/super-board-forge.py b/scripts/super-board-forge.py index addb17bd..1967e2ac 100755 --- a/scripts/super-board-forge.py +++ b/scripts/super-board-forge.py @@ -114,8 +114,9 @@ def resolve(config_path=None, root=None): host = GITHUB_HOST host = host.rstrip("/") - owner = (cfg.get("project") or {}).get("owner") or (remote or {}).get("owner") or "" - repo = (remote or {}).get("repo") or "" + owner = (os.environ.get("SB_FORGE_OWNER") or (cfg.get("project") or {}).get("owner") + or (remote or {}).get("owner") or "") + repo = os.environ.get("SB_FORGE_REPO") or (remote or {}).get("repo") or "" login = os.environ.get("SB_FORGE_LOGIN") or cfg.get("forge_login") or "" return {"forge": forge, "host": host, "login": login, "owner": owner, "repo": repo, diff --git a/scripts/super-board-gitea-read.py b/scripts/super-board-gitea-read.py index 3add9e55..6af71095 100755 --- a/scripts/super-board-gitea-read.py +++ b/scripts/super-board-gitea-read.py @@ -345,6 +345,27 @@ def op_issue_history(owner, repo): return json.dumps(out), out +def op_deps(owner, repo): + """Open issues with their last 8 comments — in the GraphQL node shape the + deps.sh parser reads (labels.nodes / comments.nodes; its jq `//` fallbacks + cannot catch a plain array, indexing it errors first). + One list read plus one comments read per open issue: Gitea has no single + query for both (documented degradation vs the GitHub GraphQL call).""" + out = [] + for page in tea_get_paged(f'repos/{owner}/{repo}/issues?state=open&type=issues'): + for i in page: + require(type(i.get('number')) is int and i['number'] > 0, 'deps issue number missing') + comments = [] + for cpage in tea_get_paged(f'repos/{owner}/{repo}/issues/{i["number"]}/comments'): + comments += [{'body': c.get('body') or ''} for c in cpage if isinstance(c, dict)] + out.append({'number': i['number'], 'title': i.get('title', ''), + 'body': i.get('body') or '', 'state': 'OPEN', + 'labels': {'nodes': [{'name': l.get('name', '')} for l in (i.get('labels') or []) + if isinstance(l, dict)]}, + 'comments': {'nodes': comments[-8:]}}) + return json.dumps(out), out + + def op_prs(owner, repo, kind): state = 'open' if kind == 'prs-open' else 'closed' out = [] @@ -464,6 +485,7 @@ def serve(argv, recovering=False): parser.add_argument('--projects', help='owner/repo — project list (kind projects)') parser.add_argument('--permission', help='owner/repo — collaborator level (kind permission)') parser.add_argument('--issue-history', help='owner/repo — complete all-state issue history') + parser.add_argument('--deps', help='owner/repo — open issues + last 8 comments (deps.sh node shape)') parser.add_argument('--prs-open', help='owner/repo') parser.add_argument('--prs-merged', help='owner/repo') parser.add_argument('--issues-closed', help='owner/repo') @@ -473,7 +495,7 @@ def serve(argv, recovering=False): command = args.command[1:] if args.command[:1] == ['--'] else args.command kind = args.kind composite = any([args.issue, args.pr, args.items, args.fields, args.project, args.projects, - args.permission, args.issue_history, args.prs_open, args.prs_merged, + args.permission, args.issue_history, args.deps, args.prs_open, args.prs_merged, args.issues_closed, args.quota]) try: @@ -542,6 +564,8 @@ def run_op(): return op_permission(*_or_path(args.permission)) if args.issue_history: return op_issue_history(*_or_path(args.issue_history)) + if args.deps: + return op_deps(*_or_path(args.deps)) if args.prs_open: require(kind == 'prs-open', '--prs-open serves kind prs-open') return op_prs(*_or_path(args.prs_open), 'prs-open') diff --git a/scripts/super-board-preflight.sh b/scripts/super-board-preflight.sh index 6aec11e7..dcdec5e3 100755 --- a/scripts/super-board-preflight.sh +++ b/scripts/super-board-preflight.sh @@ -45,10 +45,10 @@ # Exit 0 ok · 64 usage · 79 required GitHub evidence unavailable (pause the run; # a blind pre-flight never says proceed). set -euo pipefail -# Fixed read commands: a malformed payload is GitHub's, so it halts (#32). -export SB_GITHUB_READ_STRICT=1 +# Fixed read commands: a malformed payload is the forge's, so it halts (#32). +export SB_GITHUB_READ_STRICT=1 SB_GITEA_READ_STRICT=1 -REPO=""; ISSUES=""; INFLIGHT=""; FILES=""; THRESHOLD="0.6" +REPO=""; ISSUES=""; INFLIGHT=""; FILES=""; THRESHOLD="0.6"; FORGE_ARG="" while [ $# -gt 0 ]; do case "$1" in --repo) REPO="$2"; shift 2 ;; @@ -56,11 +56,14 @@ while [ $# -gt 0 ]; do --inflight) INFLIGHT="$2"; shift 2 ;; --files) FILES="$2"; shift 2 ;; --threshold) THRESHOLD="$2"; shift 2 ;; + --forge) FORGE_ARG="$2"; shift 2 ;; # github|gitea; default: env SB_FORGE *) echo "unknown arg: $1" >&2; exit 64 ;; esac done [ -n "$REPO" ] && [ -n "$ISSUES" ] || { echo "usage: --repo <owner/name> --issues <N[,M…]>" >&2; exit 64; } echo "$ISSUES" | grep -Eq '^[0-9]+(,[0-9]+)*$' || { echo "--issues must be numbers: $ISSUES" >&2; exit 64; } +FORGE_KIND="${FORGE_ARG:-${SB_FORGE:-github}}" +export SB_FORGE="$FORGE_KIND" HERE=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) if [ -f "$HERE/super-board-gh-guard.sh" ]; then @@ -69,15 +72,27 @@ if [ -f "$HERE/super-board-gh-guard.sh" ]; then sb_gh_guard_check 200 || exit $? fi -MERGED=$(python3 "$HERE/super-board-github-read.py" --kind prs-merged -- pr list --repo "$REPO" --state merged --limit 100 --json number,title,body,url ) || exit $? -OPEN=$(python3 "$HERE/super-board-github-read.py" --kind prs-open -- pr list --repo "$REPO" --state open --limit 100 --json number,title,body,url,headRefName,files ) || exit $? -CLOSED=$(python3 "$HERE/super-board-github-read.py" --kind issues-closed -- issue list --repo "$REPO" --state closed --limit 100 --json number,title,body,stateReason ) || exit $? +if [ "$FORGE_KIND" = gitea ]; then + GITEA_READ="$HERE/super-board-gitea-read.py" + export GITEA_REPO="$REPO" + MERGED=$(python3 "$GITEA_READ" --kind prs-merged --prs-merged "$REPO") || exit $? + OPEN=$(python3 "$GITEA_READ" --kind prs-open --prs-open "$REPO") || exit $? + CLOSED=$(python3 "$GITEA_READ" --kind issues-closed --issues-closed "$REPO") || exit $? +else + MERGED=$(python3 "$HERE/super-board-github-read.py" --kind prs-merged -- pr list --repo "$REPO" --state merged --limit 100 --json number,title,body,url ) || exit $? + OPEN=$(python3 "$HERE/super-board-github-read.py" --kind prs-open -- pr list --repo "$REPO" --state open --limit 100 --json number,title,body,url,headRefName,files ) || exit $? + CLOSED=$(python3 "$HERE/super-board-github-read.py" --kind issues-closed -- issue list --repo "$REPO" --state closed --limit 100 --json number,title,body,stateReason ) || exit $? +fi CARDS="[]" [ -n "$INFLIGHT" ] && CARDS=$(cat "$INFLIGHT") TARGETS="[]" for n in ${ISSUES//,/ }; do - one=$(python3 "$HERE/super-board-github-read.py" --kind issue -- issue view "$n" --repo "$REPO" --json number,title,body ) || exit $? + if [ "$FORGE_KIND" = gitea ]; then + one=$(python3 "$GITEA_READ" --kind issue --issue "$n") || exit $? + else + one=$(python3 "$HERE/super-board-github-read.py" --kind issue -- issue view "$n" --repo "$REPO" --json number,title,body ) || exit $? + fi TARGETS=$(jq -c --argjson one "$one" '. + [$one]' <<<"$TARGETS") done diff --git a/scripts/super-board-wave-plan.sh b/scripts/super-board-wave-plan.sh index ecb21bdf..ee009f4f 100755 --- a/scripts/super-board-wave-plan.sh +++ b/scripts/super-board-wave-plan.sh @@ -91,7 +91,19 @@ CONFIG_JSON=$(cat "$CONFIG") HERE=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) printf '%s\n' "$CONFIG_JSON" | python3 "$HERE/super-board-verification-ready.py" --config - export SB_REPO_PATH=$(echo "$CONFIG_JSON" | jq -r '.repo.path // "."') -python3 "$HERE/super-board-github-read.py" --check +# Forge resolution from the (already once-read) config, exported so card.sh and +# deps.sh in this process tree resolve the same forge without the config file +# ($CONFIG may be a FIFO that cannot be read twice). +FORGE_CFG=$(mktemp); trap 'rm -f "$FORGE_CFG"' EXIT +printf '%s\n' "$CONFIG_JSON" > "$FORGE_CFG" +eval "$(python3 "$HERE/super-board-forge.py" get --shell --config "$FORGE_CFG")" || exit $? +rm -f "$FORGE_CFG"; trap - EXIT +export SB_FORGE="$SB_FORGE_KIND" SB_FORGE_HOST SB_FORGE_LOGIN SB_FORGE_OWNER SB_FORGE_REPO +if [ "$SB_FORGE_KIND" = gitea ]; then + python3 "$HERE/super-board-gitea-read.py" --check +else + python3 "$HERE/super-board-github-read.py" --check +fi VARIANT=$(echo "$CONFIG_JSON" | jq -r '.variant // ""') # 0 or absent = unlimited. A wave is sized by the dependency graph, not a knob. MAX_WORKERS=$(echo "$CONFIG_JSON" | jq -r '.max_workers // 0') @@ -118,8 +130,12 @@ esac if [ -n "$DEPS_FILE" ]; then DEPS=$(cat "$DEPS_FILE") else - REPO=$(echo "$CONFIG_JSON" | jq -r '.repo.remote // ""' \ - | sed -E 's#^https?://github\.com/##; s#\.git$##') + if [ "$SB_FORGE_KIND" = gitea ] && [ -n "$SB_FORGE_OWNER" ] && [ -n "$SB_FORGE_REPO" ]; then + REPO="$SB_FORGE_OWNER/$SB_FORGE_REPO" + else + REPO=$(echo "$CONFIG_JSON" | jq -r '.repo.remote // ""' \ + | sed -E 's#^https?://github\.com/##; s#\.git$##') + fi [ -n "$REPO" ] || { echo "config.repo.remote is required to derive dependencies" >&2; exit 66; } HERE=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) # A graph we cannot fetch is not a graph of zero blockers. Fail rather than diff --git a/skills/super-collect/scripts/collect_prs.py b/skills/super-collect/scripts/collect_prs.py index 10e2c230..b9498405 100755 --- a/skills/super-collect/scripts/collect_prs.py +++ b/skills/super-collect/scripts/collect_prs.py @@ -52,12 +52,46 @@ def gh_graphql(query, variables, run=subprocess.run): return json.loads(r.stdout) -def repo_slug(cfg, override=None): +# ── gitea (tea api) ──────────────────────────────────────────────────────────── +# Degradations vs the GraphQL search, documented in references/gitea.md: +# no reviewThreads (empty list), no merged_at (closed_at/updated_at is the +# merge-time approximation), author "bot" is a login heuristic, and the window +# filter rides pulls?state=closed&sort=recentupdate. + +def forge_of(cfg): + return (os.environ.get("SB_FORGE") or (cfg or {}).get("forge") or "github").strip().lower() + + +def tea_cmd(): + import shlex + cmd = shlex.split(os.environ.get("SB_GITEA_TEA", "tea")) + login = os.environ.get("SB_FORGE_LOGIN") + if login: + cmd += ["--login", login] + return cmd + + +def tea_get(endpoint, run=subprocess.run): + r = run(tea_cmd() + ["api", "-X", "GET", endpoint], capture_output=True, + text=True, encoding="utf-8") + if r.returncode != 0: + raise RuntimeError(f"tea api GET {endpoint.split('?')[0]} failed: {(r.stderr or r.stdout).strip()[:300]}") + return json.loads(r.stdout.strip() or "null") + + +def repo_slug(cfg, override=None, forge="github"): if override: return override remote = ((cfg or {}).get("repo") or {}).get("remote") or "" - m = re.search(r"github\.com[:/]([^/]+/[^/.]+)", remote) - return m.group(1) if m else None + if forge == "github": + m = re.search(r"github\.com[:/]([^/]+/[^/.]+)", remote) + return m.group(1) if m else None + m = (re.match(r'^(?:https?|ssh|git)://(?:[^@/]+@)?[^/]+/(.+?)(?:\.git)?/?$', remote) + or re.match(r'^(?:[^@/\s]+@)?[^/:\s]+:(.+?)(?:\.git)?/?$', remote)) + if not m: + return None + parts = [p for p in m.group(1).strip("/").split("/") if p] + return f"{parts[-2]}/{parts[-1]}" if len(parts) >= 2 else None def who(a): @@ -95,6 +129,53 @@ def list_prs(repo, since, max_prs=200, run=subprocess.run): return prs[:max_prs], len(prs) >= max_prs +def shape_gitea(pr, repo, run): + n = pr["number"] + comments = [] + for page in range(1, 3): # cap: the newest 100 comments, like the query's first:100 + batch = tea_get(f"repos/{repo}/issues/{n}/comments?page={page}&limit=50", run) or [] + comments += [note({"author": {"login": (c.get("user") or {}).get("login")}, + "body": c.get("body")}) for c in batch if isinstance(c, dict) and c.get("body")] + if len(batch) < 50: + break + reviews = [] + try: + rvs = tea_get(f"repos/{repo}/pulls/{n}/reviews", run) or [] + except RuntimeError: + rvs = [] # an unreadable review list must not lose the PR's comments + for rv in rvs: + if isinstance(rv, dict) and rv.get("body"): + reviews.append(note({"author": {"login": (rv.get("user") or {}).get("login")}, + "body": rv.get("body")}, {"state": rv.get("state")})) + return {"number": n, "title": pr.get("title", ""), "url": pr.get("html_url", ""), + "mergedAt": pr.get("closed_at") or pr.get("updated_at"), + "author": who({"login": (pr.get("user") or {}).get("login")}), + "comments": comments, "reviews": reviews, "threads": []} + + +def list_prs_gitea(repo, since, max_prs=200, run=subprocess.run): + cutoff = since.date().isoformat() + prs = [] + for page in range(1, max_prs // 50 + 3): + batch = tea_get(f"repos/{repo}/pulls?state=closed&sort=recentupdate&page={page}&limit=50", run) + if not isinstance(batch, list) or not batch: + break + stop = False + for p in batch: + if not isinstance(p, dict) or not p.get("merged"): + continue + when = (p.get("closed_at") or p.get("updated_at") or "")[:10] + if when and when < cutoff: + stop = True # recentupdate is newest-first: the window ended + break + prs.append(shape_gitea(p, repo, run)) + if len(prs) >= max_prs: + return prs, True + if stop or len(batch) < 50: + break + return prs[:max_prs], len(prs) >= max_prs + + def main(argv=None): p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) p.add_argument("--config") @@ -105,14 +186,18 @@ def main(argv=None): lp.add_argument("--max", type=int) a = p.parse_args(argv) cfg, _ = cc.active_config(a.config) - repo = repo_slug(cfg, a.repo) + forge = forge_of(cfg) + repo = repo_slug(cfg, a.repo, forge) if not repo: print(json.dumps({"source": "prs", "status": "unavailable", "error": "no repo.remote in config; pass --repo"})) return 2 since = cc.since(a.since, cc.window_days(cfg)) max_prs = a.max or int(cc.collect_block(cfg, "prs").get("max_prs", 200)) try: - prs, truncated = list_prs(repo, since, max_prs) + if forge == "gitea": + prs, truncated = list_prs_gitea(repo, since, max_prs) + else: + prs, truncated = list_prs(repo, since, max_prs) except RuntimeError as e: print(json.dumps({"source": "prs", "status": "unavailable", "error": str(e)})) return 2 diff --git a/tests/test-deps-gitea.sh b/tests/test-deps-gitea.sh new file mode 100644 index 00000000..2a3e5ddb --- /dev/null +++ b/tests/test-deps-gitea.sh @@ -0,0 +1,48 @@ +#!/usr/bin/env bash +# Tests super-board-deps.sh --forge gitea (the --deps composite of +# super-board-gitea-read.py) against the offline tea stub. No network. +# The parser itself stays covered by test-deps.sh; this pins the gitea feed: +# open issues + last-8 comments in the GraphQL node shape. +set -euo pipefail +cd "$(dirname "$0")" +KIT="$PWD/.." +DEPS="$KIT/scripts/super-board-deps.sh" +STUB="$KIT/evals/_stubs/bin/tea" +TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT +fail() { echo "FAIL: $1" >&2; exit 1; } +pass=0; ok() { pass=$((pass + 1)); echo " ✅ $1"; } + +mkdir -p "$TMP/.git" +cat > "$TMP/.git/tea-state.json" <<'EOF' +{"issues":[ + {"id":101,"number":1,"title":"Free card","state":"open","labels":[], + "body":"intro\n\n## Blocked by\n\n- None."}, + {"id":102,"number":2,"title":"Waiting card","state":"open","labels":[], + "body":"intro\n\n## Blocked by\n\n- #1"}, + {"id":103,"number":3,"title":"Parked card","state":"open","labels":[{"id":5,"name":"needs-you"}], + "body":"intro\n\n## Blocked by\n\n- None.", + "_parked":true}, + {"id":104,"number":4,"title":"Done card","state":"closed","labels":[],"body":"x"}], + "pulls":[],"labels":[{"id":5,"name":"needs-you"}],"projects":[],"columns":[], + "comments":{"3":[{"id":1,"body":"[orchestrator] [block] 🙋\nReason tag: 🙋 needs a human\nblocked-by: -","user":{"login":"bot"},"created_at":"2026-01-02T00:00:00Z","updated_at":"2026-01-02T00:00:00Z"}]}, + "writes":0} +EOF +if [ -x "/c/Program Files/Git/usr/bin/bash.exe" ]; then + BASH_EXE="C:/Program Files/Git/usr/bin/bash.exe" +else + BASH_EXE="bash" +fi +export SB_GITEA_TEA="\"$BASH_EXE\" $(cygpath -m "$STUB" 2>/dev/null || echo "$STUB")" \ + SB_GITHUB_HALT_FILE="$TMP/halt.json" SB_GITEA_RETRY_DELAY=0 + +OUT=$(cd "$TMP" && bash "$DEPS" --forge gitea --repo example/shop) || fail "deps exit: $OUT" + +echo "$OUT" | jq -e '."1".runnable == true' >/dev/null || fail "free card not runnable: $OUT" +echo "$OUT" | jq -e '."2".runnable == false and (."2".openBlockers == [1])' >/dev/null \ + || fail "waiting card: $(echo "$OUT" | jq -c '."2"')" +echo "$OUT" | jq -e '."3".needsYou == true and ."3".humanGated == true and ."3".runnable == false' >/dev/null \ + || fail "parked card: $(echo "$OUT" | jq -c '."3"')" +echo "$OUT" | jq -e 'has("4") | not' >/dev/null || fail "closed issue leaked into the graph" +ok "gitea deps: runnable, blocked-by, needs-you comment line, closed excluded" + +echo "test-deps-gitea: $pass passed" From f80cc9cdd613e80ee14854478f098cfae5bc998b Mon Sep 17 00:00:00 2001 From: PhucMN <phucmnp@gmail.com> Date: Fri, 16 Oct 2026 17:26:12 +0700 Subject: [PATCH 6/8] =?UTF-8?q?=E2=9C=A8=20[feat]=20forge:=20onboard=20git?= =?UTF-8?q?ea=20flow?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - onboard.md: step 0 forge hint from the origin remote; step 2 becomes 🔑 FORGE with a full gitea branch (tea probe/reinstall, host, token via tea login add or GITEA_TOKEN+TEA_HOST, /user verify, swagger capability gate on the projects-columns API, bot identity without [bot]); step 3 board-rank/board-migrate/create gain --forge gitea forms (project.number = API id); step 6 swaps the gh permission lines for Bash(tea:*); step 7 pings tea api /user; step 8 writes forge/forge_host/forge_login; self-check and error table cover gitea - answers file: answers.forge block documented for both forges - get.sh: notes why tea is not inventoried there (setup.py needs owns it) Co-Authored-By: Claude Code <noreply@anthropic.com> --- .claude-plugin/marketplace.json | 2 +- .claude-plugin/plugin.json | 4 +- README.md | 6 +-- RELEASE-NOTES.md | 4 +- diagrams/_shared/sitenav.html | 2 +- diagrams/impeccable/index.html | 2 +- diagrams/index.html | 36 ++++++------- diagrams/mattpocock/index.html | 2 +- diagrams/onboarding/index.html | 8 +-- diagrams/pstack/index.html | 2 +- diagrams/sdlc-template/index.html | 2 +- diagrams/visual/index.html | 2 +- diagrams/visual/skill-map.html | 2 +- diagrams/writing-standard/reference.html | 4 +- docs/blocked-column-audit.html | 2 +- get.sh | 11 ++-- skills/super-board/references/onboard.md | 69 ++++++++++++++++++++++-- 17 files changed, 111 insertions(+), 49 deletions(-) diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json index eceb79d3..e11310c1 100644 --- a/.claude-plugin/marketplace.json +++ b/.claude-plugin/marketplace.json @@ -8,7 +8,7 @@ "source": "./", "description": "Autonomous GitHub Project board runner: super-board, super-build, super-qa, super-review, super-collect, visual, git-sync, ui-refine-loop. After install, run /super-board onboard to add the guard hooks, .claude/bin scripts and workflows a plugin cannot ship.", "category": "development", - "homepage": "https://github.com/EricTechPro/super-board" + "homepage": "https://github.com/mnphuc/super-board-gitea" } ] } diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json index 58ddbaa7..a120ab38 100644 --- a/.claude-plugin/plugin.json +++ b/.claude-plugin/plugin.json @@ -5,8 +5,8 @@ "author": { "name": "Eric Tech" }, - "homepage": "https://github.com/EricTechPro/super-board", - "repository": "https://github.com/EricTechPro/super-board", + "homepage": "https://github.com/mnphuc/super-board-gitea", + "repository": "https://github.com/mnphuc/super-board-gitea", "license": "MIT", "keywords": [ "github-projects", diff --git a/README.md b/README.md index 8b57d856..89274d2c 100644 --- a/README.md +++ b/README.md @@ -28,13 +28,13 @@ In your project folder: ```bash -curl -fsSL https://raw.githubusercontent.com/EricTechPro/super-board/main/get.sh | bash +curl -fsSL https://raw.githubusercontent.com/mnphuc/super-board-gitea/main/get.sh | bash ``` Or as a Claude Code plugin: ``` -/plugin marketplace add EricTechPro/super-board +/plugin marketplace add mnphuc/super-board-gitea /plugin install super-board@super-board ``` @@ -51,7 +51,7 @@ canonical skill files; the package bundles no private skill. See ### 1. Install ```bash -curl -fsSL https://raw.githubusercontent.com/EricTechPro/super-board/main/get.sh | bash +curl -fsSL https://raw.githubusercontent.com/mnphuc/super-board-gitea/main/get.sh | bash ``` ### 2. Onboard diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index dde5f349..4091160f 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -122,7 +122,7 @@ Source links that work away from a checkout. runs)" count and the family titles in step. - ✨ **`/visual render --source-base URL [--source-root DIR]`.** Node sources under the source root become links to the hosted file (`:12-20` → `#L12-L20`); others show as text. The skill-map - pages are re-rendered against `https://github.com/EricTechPro/super-board/blob/main/`. + pages are re-rendered against `https://github.com/mnphuc/super-board-gitea/blob/main/`. - 🧪 `test-readme-sync.sh` no longer needs a skills badge, and checks both counts and the family titles after a sync. @@ -214,7 +214,7 @@ per file; failures still name the file. `install.sh` records an older install in > then without `--dry-run`, and check the columns, labels and card statuses before you run > onboard on the real board. -1. Install over the old copy: `curl -fsSL https://raw.githubusercontent.com/EricTechPro/super-board/main/get.sh | bash` +1. Install over the old copy: `curl -fsSL https://raw.githubusercontent.com/mnphuc/super-board-gitea/main/get.sh | bash` (or `./install.sh <project>`). It records the version you came from. 2. Run `/super-board onboard`. Step 1 upgrades with no question and lists it under "Upgraded for you" (backup in `.claude/super-board/backup/<ts>/`): diff --git a/diagrams/_shared/sitenav.html b/diagrams/_shared/sitenav.html index 11e7b176..46a03a2d 100644 --- a/diagrams/_shared/sitenav.html +++ b/diagrams/_shared/sitenav.html @@ -2,6 +2,6 @@ <a class="logo" href="../"><svg viewBox="0 0 96 96" aria-hidden="true"><rect x="4" y="4" width="88" height="88" rx="20" fill="#0d1117" stroke="#3d444d" stroke-width="2"/><rect x="14" y="16" width="20" height="64" rx="5" fill="#fff" fill-opacity=".08"/><rect x="38" y="16" width="20" height="64" rx="5" fill="#fff" fill-opacity=".08"/><rect x="62" y="16" width="20" height="64" rx="5" fill="#fff" fill-opacity=".08"/><rect x="17" y="20" width="14" height="10" rx="2.5" fill="#d97757"/><rect x="17" y="33" width="14" height="10" rx="2.5" fill="#d97757" fill-opacity=".55"/><rect x="41" y="20" width="14" height="10" rx="2.5" fill="#58a6ff"/><rect x="65" y="20" width="14" height="10" rx="2.5" fill="#3fb950"/><rect x="65" y="33" width="14" height="10" rx="2.5" fill="#3fb950"/><rect x="65" y="46" width="14" height="10" rx="2.5" fill="#3fb950"/></svg>super-board</a> <span class="sp"></span> %%MAPNAV%% - <a class="lk" href="https://github.com/EricTechPro/super-board"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="currentColor"><path d="M12 2a10 10 0 0 0-3.16 19.49c.5.09.68-.22.68-.48v-1.7c-2.78.6-3.37-1.34-3.37-1.34-.45-1.15-1.11-1.46-1.11-1.46-.91-.62.07-.61.07-.61 1 .07 1.53 1.03 1.53 1.03.89 1.53 2.34 1.09 2.91.83.09-.65.35-1.09.64-1.34-2.22-.25-4.55-1.11-4.55-4.94 0-1.09.39-1.98 1.03-2.68-.1-.25-.45-1.27.1-2.64 0 0 .84-.27 2.75 1.02a9.5 9.5 0 0 1 5 0c1.91-1.29 2.75-1.02 2.75-1.02.55 1.37.2 2.39.1 2.64.64.7 1.03 1.59 1.03 2.68 0 3.84-2.34 4.69-4.57 4.93.36.31.68.92.68 1.86v2.75c0 .27.18.58.69.48A10 10 0 0 0 12 2z"/></svg><span class="nl">GitHub</span></a> + <a class="lk" href="https://github.com/mnphuc/super-board-gitea"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="currentColor"><path d="M12 2a10 10 0 0 0-3.16 19.49c.5.09.68-.22.68-.48v-1.7c-2.78.6-3.37-1.34-3.37-1.34-.45-1.15-1.11-1.46-1.11-1.46-.91-.62.07-.61.07-.61 1 .07 1.53 1.03 1.53 1.03.89 1.53 2.34 1.09 2.91.83.09-.65.35-1.09.64-1.34-2.22-.25-4.55-1.11-4.55-4.94 0-1.09.39-1.98 1.03-2.68-.1-.25-.45-1.27.1-2.64 0 0 .84-.27 2.75 1.02a9.5 9.5 0 0 1 5 0c1.91-1.29 2.75-1.02 2.75-1.02.55 1.37.2 2.39.1 2.64.64.7 1.03 1.59 1.03 2.68 0 3.84-2.34 4.69-4.57 4.93.36.31.68.92.68 1.86v2.75c0 .27.18.58.69.48A10 10 0 0 0 12 2z"/></svg><span class="nl">GitHub</span></a> <button class="btn" id="sbtt" type="button" aria-label="Toggle light or dark theme"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="4"/><path d="M12 2v2M12 20v2M4.9 4.9l1.4 1.4M17.7 17.7l1.4 1.4M2 12h2M20 12h2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4"/></svg><span class="nl">Theme</span></button> </div></header> diff --git a/diagrams/impeccable/index.html b/diagrams/impeccable/index.html index 345c77ff..077c8cc4 100644 --- a/diagrams/impeccable/index.html +++ b/diagrams/impeccable/index.html @@ -249,7 +249,7 @@ <a class="lk" href="../impeccable/" aria-current="page"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">Impeccable<span class="hide-s"> map</span></span></a> <a class="lk" href="../pstack/"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">pstack<span class="hide-s"> map</span></span></a> <a class="lk" href="../mattpocock/"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">Matt Pocock<span class="hide-s"> map</span></span></a> - <a class="lk" href="https://github.com/EricTechPro/super-board"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="currentColor"><path d="M12 2a10 10 0 0 0-3.16 19.49c.5.09.68-.22.68-.48v-1.7c-2.78.6-3.37-1.34-3.37-1.34-.45-1.15-1.11-1.46-1.11-1.46-.91-.62.07-.61.07-.61 1 .07 1.53 1.03 1.53 1.03.89 1.53 2.34 1.09 2.91.83.09-.65.35-1.09.64-1.34-2.22-.25-4.55-1.11-4.55-4.94 0-1.09.39-1.98 1.03-2.68-.1-.25-.45-1.27.1-2.64 0 0 .84-.27 2.75 1.02a9.5 9.5 0 0 1 5 0c1.91-1.29 2.75-1.02 2.75-1.02.55 1.37.2 2.39.1 2.64.64.7 1.03 1.59 1.03 2.68 0 3.84-2.34 4.69-4.57 4.93.36.31.68.92.68 1.86v2.75c0 .27.18.58.69.48A10 10 0 0 0 12 2z"/></svg><span class="nl">GitHub</span></a> + <a class="lk" href="https://github.com/mnphuc/super-board-gitea"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="currentColor"><path d="M12 2a10 10 0 0 0-3.16 19.49c.5.09.68-.22.68-.48v-1.7c-2.78.6-3.37-1.34-3.37-1.34-.45-1.15-1.11-1.46-1.11-1.46-.91-.62.07-.61.07-.61 1 .07 1.53 1.03 1.53 1.03.89 1.53 2.34 1.09 2.91.83.09-.65.35-1.09.64-1.34-2.22-.25-4.55-1.11-4.55-4.94 0-1.09.39-1.98 1.03-2.68-.1-.25-.45-1.27.1-2.64 0 0 .84-.27 2.75 1.02a9.5 9.5 0 0 1 5 0c1.91-1.29 2.75-1.02 2.75-1.02.55 1.37.2 2.39.1 2.64.64.7 1.03 1.59 1.03 2.68 0 3.84-2.34 4.69-4.57 4.93.36.31.68.92.68 1.86v2.75c0 .27.18.58.69.48A10 10 0 0 0 12 2z"/></svg><span class="nl">GitHub</span></a> <button class="btn" id="sbtt" type="button" aria-label="Toggle light or dark theme"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="4"/><path d="M12 2v2M12 20v2M4.9 4.9l1.4 1.4M17.7 17.7l1.4 1.4M2 12h2M20 12h2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4"/></svg><span class="nl">Theme</span></button> </div></header> diff --git a/diagrams/index.html b/diagrams/index.html index 38c65d7d..ebdbf1b7 100644 --- a/diagrams/index.html +++ b/diagrams/index.html @@ -175,15 +175,15 @@ <nav class="nav" id="nav" aria-label="Main"> <div class="row"> <a class="logo" href="#top" aria-label="super-board home"><svg viewBox="0 0 96 96" aria-hidden="true"><rect x="4" y="4" width="88" height="88" rx="20" fill="#0d1117" stroke="#3d444d" stroke-width="2"/><rect x="14" y="16" width="20" height="64" rx="5" fill="#fff" fill-opacity=".08"/><rect x="38" y="16" width="20" height="64" rx="5" fill="#fff" fill-opacity=".08"/><rect x="62" y="16" width="20" height="64" rx="5" fill="#fff" fill-opacity=".08"/><rect x="17" y="20" width="14" height="10" rx="2.5" fill="#d97757"/><rect x="17" y="33" width="14" height="10" rx="2.5" fill="#d97757" fill-opacity=".55"/><rect x="41" y="20" width="14" height="10" rx="2.5" fill="#58a6ff"/><rect x="65" y="20" width="14" height="10" rx="2.5" fill="#3fb950"/><rect x="65" y="33" width="14" height="10" rx="2.5" fill="#3fb950"/><rect x="65" y="46" width="14" height="10" rx="2.5" fill="#3fb950"/></svg>super-board</a> - <a class="vpill" href="https://github.com/EricTechPro/super-board/releases/tag/v3.0.2">v3.0.2</a> + <a class="vpill" href="https://github.com/mnphuc/super-board-gitea/releases/tag/v3.0.2">v3.0.2</a> <button class="burger" id="burger" type="button" aria-label="Menu" aria-expanded="false" aria-controls="links">☰</button> <div class="lk" id="links"> <a href="#how">How it works</a> <a href="#map">Skill map</a> <a href="#pages">Pages</a> <a href="#install">Install</a> - <a href="https://github.com/EricTechPro/super-board/stargazers" aria-label="GitHub stars"><img alt="GitHub stars" src="https://img.shields.io/github/stars/EricTechPro/super-board?style=social"></a> - <a class="btn" href="https://github.com/EricTechPro/super-board"><i class="gh"></i> GitHub</a> + <a href="https://github.com/mnphuc/super-board-gitea/stargazers" aria-label="GitHub stars"><img alt="GitHub stars" src="https://img.shields.io/github/stars/mnphuc/super-board-gitea?style=social"></a> + <a class="btn" href="https://github.com/mnphuc/super-board-gitea"><i class="gh"></i> GitHub</a> <button class="tbtn" id="tt" type="button" aria-label="Toggle light or dark theme" title="Theme"><svg width="16" height="16" viewBox="0 0 16 16" aria-hidden="true"><path d="M8 1.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM8 13V3a5 5 0 0 1 0 10Z"/></svg></button> </div> </div> @@ -195,10 +195,10 @@ <h1 class="big">super-board</h1> <p class="pitch">Add tasks, walk away, get merged PRs with proof.</p> <p class="sub">An autonomous GitHub Project board for Claude Code. 8 skills (5 you type, 3 the board runs) · 9 commands · 6 guard hooks.</p> - <div class="cmd"><code>curl -fsSL https://raw.githubusercontent.com/EricTechPro/super-board/main/get.sh | bash</code></div> + <div class="cmd"><code>curl -fsSL https://raw.githubusercontent.com/mnphuc/super-board-gitea/main/get.sh | bash</code></div> <div class="ctas" style="justify-content:center"> <a class="btn pri" href="#map">See the skill map</a> - <a class="btn" href="https://github.com/EricTechPro/super-board"><i class="gh"></i> GitHub</a> + <a class="btn" href="https://github.com/mnphuc/super-board-gitea"><i class="gh"></i> GitHub</a> <a class="btn" href="https://youtu.be/nX_bGyIOFM4">▶ Watch the demo</a> </div> </div></section> @@ -250,17 +250,17 @@ <h2>8 skills</h2> <p class="lead">5 you type in Claude Code. 3 the board runs for each card.</p> <div class="grp"><h3>You type</h3><span>5 skills</span></div> <div class="sgrid"> - <a class="scard" href="https://github.com/EricTechPro/super-board/blob/main/skills/super-board/README.md"><span class="nm">/super-board</span><p>Runs the board: Build → QA → Review, merges when green.</p><code>/super-board run my-app</code></a> - <a class="scard" href="https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/README.md"><span class="nm">/super-collect</span><p>Finds problems in Sentry, PostHog, issues and PRs. Files verified cards.</p><code>/super-collect sentry</code></a> - <a class="scard" href="https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/README.md"><span class="nm">/ui-refine-loop</span><p>Critique → refine rounds on one page or component.</p><code>/ui-refine-loop /settings</code></a> - <a class="scard" href="https://github.com/EricTechPro/super-board/blob/main/skills/visual/README.md"><span class="nm">/visual</span><p>One HTML page: branch recap, plan, or codebase map.</p><code>/visual recap</code></a> - <a class="scard" href="https://github.com/EricTechPro/super-board/blob/main/skills/git-sync/README.md"><span class="nm">/git-sync</span><p>Commits per logical change, merge-pulls, pushes without force.</p><code>/git-sync</code></a> + <a class="scard" href="https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/README.md"><span class="nm">/super-board</span><p>Runs the board: Build → QA → Review, merges when green.</p><code>/super-board run my-app</code></a> + <a class="scard" href="https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/README.md"><span class="nm">/super-collect</span><p>Finds problems in Sentry, PostHog, issues and PRs. Files verified cards.</p><code>/super-collect sentry</code></a> + <a class="scard" href="https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/README.md"><span class="nm">/ui-refine-loop</span><p>Critique → refine rounds on one page or component.</p><code>/ui-refine-loop /settings</code></a> + <a class="scard" href="https://github.com/mnphuc/super-board-gitea/blob/main/skills/visual/README.md"><span class="nm">/visual</span><p>One HTML page: branch recap, plan, or codebase map.</p><code>/visual recap</code></a> + <a class="scard" href="https://github.com/mnphuc/super-board-gitea/blob/main/skills/git-sync/README.md"><span class="nm">/git-sync</span><p>Commits per logical change, merge-pulls, pushes without force.</p><code>/git-sync</code></a> </div> <div class="grp"><h3>The board runs</h3><span>3 lanes</span></div> <div class="sgrid three"> - <a class="scard" href="https://github.com/EricTechPro/super-board/blob/main/skills/super-build/README.md"><span class="col">Building</span><span class="nm">super-build</span><p>Own worktree, smallest safe change, tests, draft PR.</p></a> - <a class="scard" href="https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/README.md"><span class="col">QA</span><span class="nm">super-qa</span><p>Evidence, test-gap check, screenshots, or bounce back to Build.</p></a> - <a class="scard" href="https://github.com/EricTechPro/super-board/blob/main/skills/super-review/README.md"><span class="col">Review</span><span class="nm">super-review</span><p>Its own review, remembers prior findings, then the merge gate.</p></a> + <a class="scard" href="https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/README.md"><span class="col">Building</span><span class="nm">super-build</span><p>Own worktree, smallest safe change, tests, draft PR.</p></a> + <a class="scard" href="https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/README.md"><span class="col">QA</span><span class="nm">super-qa</span><p>Evidence, test-gap check, screenshots, or bounce back to Build.</p></a> + <a class="scard" href="https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-review/README.md"><span class="col">Review</span><span class="nm">super-review</span><p>Its own review, remembers prior findings, then the merge gate.</p></a> </div> <p class="uses">Uses: <a href="https://github.com/mattpocock/skills">Matt Pocock skills</a>, ponytail, impeccable, humanizer.</p> </div></section> @@ -273,10 +273,10 @@ <h2>Install</h2> <button type="button" role="tab" id="tab-p" aria-controls="tp-p" aria-selected="false">Claude Code plugin</button> <button type="button" role="tab" id="tab-c" aria-controls="tp-c" aria-selected="false">From a checkout</button> </div> - <div class="tp" role="tabpanel" id="tp-t" aria-labelledby="tab-t"><div class="code"><code>curl -fsSL https://raw.githubusercontent.com/EricTechPro/super-board/main/get.sh | bash</code></div><p class="small" style="margin:0">Needs Claude Code, <code>gh</code>, <code>jq</code>, bash 3.2+ and Python 3. The installer checks.</p></div> - <div class="tp" role="tabpanel" id="tp-p" aria-labelledby="tab-p" hidden><div class="code"><code>/plugin marketplace add EricTechPro/super-board + <div class="tp" role="tabpanel" id="tp-t" aria-labelledby="tab-t"><div class="code"><code>curl -fsSL https://raw.githubusercontent.com/mnphuc/super-board-gitea/main/get.sh | bash</code></div><p class="small" style="margin:0">Needs Claude Code, <code>gh</code>, <code>jq</code>, bash 3.2+ and Python 3. The installer checks.</p></div> + <div class="tp" role="tabpanel" id="tp-p" aria-labelledby="tab-p" hidden><div class="code"><code>/plugin marketplace add mnphuc/super-board-gitea /plugin install super-board@super-board</code></div><p class="note">The plugin ships the skills only. Run <code>/super-board:super-board onboard</code>; its 🔍 Checks step adds the guard hooks, scripts and workflows.</p></div> - <div class="tp" role="tabpanel" id="tp-c" aria-labelledby="tab-c" hidden><div class="code"><code>git clone https://github.com/EricTechPro/super-board.git + <div class="tp" role="tabpanel" id="tp-c" aria-labelledby="tab-c" hidden><div class="code"><code>git clone https://github.com/mnphuc/super-board-gitea.git ./super-board/install.sh [--no-hooks] [--protect-main] /path/to/your-project</code></div></div> <div class="then"><span><b>Then</b> open Claude Code and run <code>/super-board onboard</code></span><span>8 steps · Enter takes the recommended answer · <a href="onboarding/">see it first</a></span></div> </div></section> @@ -284,9 +284,9 @@ <h2>Install</h2> <footer class="foot"><div class="row"> <span>MIT © Eric Tech</span><span class="sp"></span> - <a href="https://github.com/EricTechPro/super-board">GitHub</a> + <a href="https://github.com/mnphuc/super-board-gitea">GitHub</a> <a href="https://youtu.be/nX_bGyIOFM4">YouTube</a> - <a href="https://github.com/EricTechPro/super-board/blob/main/RELEASE-NOTES.md">Release notes</a> + <a href="https://github.com/mnphuc/super-board-gitea/blob/main/RELEASE-NOTES.md">Release notes</a> </div></footer> <script> diff --git a/diagrams/mattpocock/index.html b/diagrams/mattpocock/index.html index 83a489f4..e3ce5b82 100644 --- a/diagrams/mattpocock/index.html +++ b/diagrams/mattpocock/index.html @@ -250,7 +250,7 @@ <a class="lk" href="../impeccable/"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">Impeccable<span class="hide-s"> map</span></span></a> <a class="lk" href="../pstack/"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">pstack<span class="hide-s"> map</span></span></a> <a class="lk" href="../mattpocock/" aria-current="page"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">Matt Pocock<span class="hide-s"> map</span></span></a> - <a class="lk" href="https://github.com/EricTechPro/super-board"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="currentColor"><path d="M12 2a10 10 0 0 0-3.16 19.49c.5.09.68-.22.68-.48v-1.7c-2.78.6-3.37-1.34-3.37-1.34-.45-1.15-1.11-1.46-1.11-1.46-.91-.62.07-.61.07-.61 1 .07 1.53 1.03 1.53 1.03.89 1.53 2.34 1.09 2.91.83.09-.65.35-1.09.64-1.34-2.22-.25-4.55-1.11-4.55-4.94 0-1.09.39-1.98 1.03-2.68-.1-.25-.45-1.27.1-2.64 0 0 .84-.27 2.75 1.02a9.5 9.5 0 0 1 5 0c1.91-1.29 2.75-1.02 2.75-1.02.55 1.37.2 2.39.1 2.64.64.7 1.03 1.59 1.03 2.68 0 3.84-2.34 4.69-4.57 4.93.36.31.68.92.68 1.86v2.75c0 .27.18.58.69.48A10 10 0 0 0 12 2z"/></svg><span class="nl">GitHub</span></a> + <a class="lk" href="https://github.com/mnphuc/super-board-gitea"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="currentColor"><path d="M12 2a10 10 0 0 0-3.16 19.49c.5.09.68-.22.68-.48v-1.7c-2.78.6-3.37-1.34-3.37-1.34-.45-1.15-1.11-1.46-1.11-1.46-.91-.62.07-.61.07-.61 1 .07 1.53 1.03 1.53 1.03.89 1.53 2.34 1.09 2.91.83.09-.65.35-1.09.64-1.34-2.22-.25-4.55-1.11-4.55-4.94 0-1.09.39-1.98 1.03-2.68-.1-.25-.45-1.27.1-2.64 0 0 .84-.27 2.75 1.02a9.5 9.5 0 0 1 5 0c1.91-1.29 2.75-1.02 2.75-1.02.55 1.37.2 2.39.1 2.64.64.7 1.03 1.59 1.03 2.68 0 3.84-2.34 4.69-4.57 4.93.36.31.68.92.68 1.86v2.75c0 .27.18.58.69.48A10 10 0 0 0 12 2z"/></svg><span class="nl">GitHub</span></a> <button class="btn" id="sbtt" type="button" aria-label="Toggle light or dark theme"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="4"/><path d="M12 2v2M12 20v2M4.9 4.9l1.4 1.4M17.7 17.7l1.4 1.4M2 12h2M20 12h2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4"/></svg><span class="nl">Theme</span></button> </div></header> diff --git a/diagrams/onboarding/index.html b/diagrams/onboarding/index.html index ae81a33c..82b2daf8 100644 --- a/diagrams/onboarding/index.html +++ b/diagrams/onboarding/index.html @@ -82,7 +82,7 @@ <span class="vpill">v3.0.2</span> <span class="sp"></span> <a class="lk hide-s" href="../skill-map/">Skill map</a> - <a class="lk" href="https://github.com/EricTechPro/super-board">GitHub</a> + <a class="lk" href="https://github.com/mnphuc/super-board-gitea">GitHub</a> <button class="btn" id="tt" type="button" aria-label="Toggle light or dark theme">Theme</button> </div></header> @@ -100,12 +100,12 @@ <h1>Setup, step by step</h1> <div class="term"> <div class="bar"><span class="dot"></span><span class="dot"></span><span class="dot"></span><span class="tt" id="ttl"></span></div> -<div class="screen" data-id="install" data-n="Install" data-e="📦" data-w="t"><span class="zp">eric@mac <i>my-app</i> %</span> curl -fsSL https://raw.githubusercontent.com/EricTechPro/super-board/main/get.sh | bash +<div class="screen" data-id="install" data-n="Install" data-e="📦" data-w="t"><span class="zp">eric@mac <i>my-app</i> %</span> curl -fsSL https://raw.githubusercontent.com/mnphuc/super-board-gitea/main/get.sh | bash 🧩 super-board installer target: /Users/eric/code/my-app 🔍 checking what you need <span class="ok">✓</span> curl · tar · python3 · gh · jq · node -📦 downloading EricTechPro/super-board@v3.0.2 +📦 downloading mnphuc/super-board-gitea@v3.0.2 🔧 installing <span class="ok">✓</span> skills, scripts and workflows → .claude/ 🛡️ 6 guard hooks → .claude/settings.json <span class="dim">(new file)</span> @@ -173,7 +173,7 @@ <h1>Setup, step by step</h1> 🤖 Then: <span class="info">/super-board run</span>.</span></div></div> </div> - <p class="foot">Example project: <code>~/code/my-app</code>. Your names, counts and answers will differ. <a href="https://github.com/EricTechPro/super-board#install">Install guide</a></p> + <p class="foot">Example project: <code>~/code/my-app</code>. Your names, counts and answers will differ. <a href="https://github.com/mnphuc/super-board-gitea#install">Install guide</a></p> </main> <script> diff --git a/diagrams/pstack/index.html b/diagrams/pstack/index.html index 3e358271..7b22e6cd 100644 --- a/diagrams/pstack/index.html +++ b/diagrams/pstack/index.html @@ -250,7 +250,7 @@ <a class="lk" href="../impeccable/"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">Impeccable<span class="hide-s"> map</span></span></a> <a class="lk" href="../pstack/" aria-current="page"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">pstack<span class="hide-s"> map</span></span></a> <a class="lk" href="../mattpocock/"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">Matt Pocock<span class="hide-s"> map</span></span></a> - <a class="lk" href="https://github.com/EricTechPro/super-board"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="currentColor"><path d="M12 2a10 10 0 0 0-3.16 19.49c.5.09.68-.22.68-.48v-1.7c-2.78.6-3.37-1.34-3.37-1.34-.45-1.15-1.11-1.46-1.11-1.46-.91-.62.07-.61.07-.61 1 .07 1.53 1.03 1.53 1.03.89 1.53 2.34 1.09 2.91.83.09-.65.35-1.09.64-1.34-2.22-.25-4.55-1.11-4.55-4.94 0-1.09.39-1.98 1.03-2.68-.1-.25-.45-1.27.1-2.64 0 0 .84-.27 2.75 1.02a9.5 9.5 0 0 1 5 0c1.91-1.29 2.75-1.02 2.75-1.02.55 1.37.2 2.39.1 2.64.64.7 1.03 1.59 1.03 2.68 0 3.84-2.34 4.69-4.57 4.93.36.31.68.92.68 1.86v2.75c0 .27.18.58.69.48A10 10 0 0 0 12 2z"/></svg><span class="nl">GitHub</span></a> + <a class="lk" href="https://github.com/mnphuc/super-board-gitea"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="currentColor"><path d="M12 2a10 10 0 0 0-3.16 19.49c.5.09.68-.22.68-.48v-1.7c-2.78.6-3.37-1.34-3.37-1.34-.45-1.15-1.11-1.46-1.11-1.46-.91-.62.07-.61.07-.61 1 .07 1.53 1.03 1.53 1.03.89 1.53 2.34 1.09 2.91.83.09-.65.35-1.09.64-1.34-2.22-.25-4.55-1.11-4.55-4.94 0-1.09.39-1.98 1.03-2.68-.1-.25-.45-1.27.1-2.64 0 0 .84-.27 2.75 1.02a9.5 9.5 0 0 1 5 0c1.91-1.29 2.75-1.02 2.75-1.02.55 1.37.2 2.39.1 2.64.64.7 1.03 1.59 1.03 2.68 0 3.84-2.34 4.69-4.57 4.93.36.31.68.92.68 1.86v2.75c0 .27.18.58.69.48A10 10 0 0 0 12 2z"/></svg><span class="nl">GitHub</span></a> <button class="btn" id="sbtt" type="button" aria-label="Toggle light or dark theme"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="4"/><path d="M12 2v2M12 20v2M4.9 4.9l1.4 1.4M17.7 17.7l1.4 1.4M2 12h2M20 12h2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4"/></svg><span class="nl">Theme</span></button> </div></header> diff --git a/diagrams/sdlc-template/index.html b/diagrams/sdlc-template/index.html index c7e84787..2e340b94 100644 --- a/diagrams/sdlc-template/index.html +++ b/diagrams/sdlc-template/index.html @@ -250,7 +250,7 @@ <a class="lk" href="../impeccable/"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">Impeccable<span class="hide-s"> map</span></span></a> <a class="lk" href="../pstack/"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">pstack<span class="hide-s"> map</span></span></a> <a class="lk" href="../mattpocock/"><img class="ni nimg" alt="" src="data:image/png;base64,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"><span class="nl">Matt Pocock<span class="hide-s"> map</span></span></a> - <a class="lk" href="https://github.com/EricTechPro/super-board"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="currentColor"><path d="M12 2a10 10 0 0 0-3.16 19.49c.5.09.68-.22.68-.48v-1.7c-2.78.6-3.37-1.34-3.37-1.34-.45-1.15-1.11-1.46-1.11-1.46-.91-.62.07-.61.07-.61 1 .07 1.53 1.03 1.53 1.03.89 1.53 2.34 1.09 2.91.83.09-.65.35-1.09.64-1.34-2.22-.25-4.55-1.11-4.55-4.94 0-1.09.39-1.98 1.03-2.68-.1-.25-.45-1.27.1-2.64 0 0 .84-.27 2.75 1.02a9.5 9.5 0 0 1 5 0c1.91-1.29 2.75-1.02 2.75-1.02.55 1.37.2 2.39.1 2.64.64.7 1.03 1.59 1.03 2.68 0 3.84-2.34 4.69-4.57 4.93.36.31.68.92.68 1.86v2.75c0 .27.18.58.69.48A10 10 0 0 0 12 2z"/></svg><span class="nl">GitHub</span></a> + <a class="lk" href="https://github.com/mnphuc/super-board-gitea"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="currentColor"><path d="M12 2a10 10 0 0 0-3.16 19.49c.5.09.68-.22.68-.48v-1.7c-2.78.6-3.37-1.34-3.37-1.34-.45-1.15-1.11-1.46-1.11-1.46-.91-.62.07-.61.07-.61 1 .07 1.53 1.03 1.53 1.03.89 1.53 2.34 1.09 2.91.83.09-.65.35-1.09.64-1.34-2.22-.25-4.55-1.11-4.55-4.94 0-1.09.39-1.98 1.03-2.68-.1-.25-.45-1.27.1-2.64 0 0 .84-.27 2.75 1.02a9.5 9.5 0 0 1 5 0c1.91-1.29 2.75-1.02 2.75-1.02.55 1.37.2 2.39.1 2.64.64.7 1.03 1.59 1.03 2.68 0 3.84-2.34 4.69-4.57 4.93.36.31.68.92.68 1.86v2.75c0 .27.18.58.69.48A10 10 0 0 0 12 2z"/></svg><span class="nl">GitHub</span></a> <button class="btn" id="sbtt" type="button" aria-label="Toggle light or dark theme"><svg class="ni" viewBox="0 0 24 24" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="4"/><path d="M12 2v2M12 20v2M4.9 4.9l1.4 1.4M17.7 17.7l1.4 1.4M2 12h2M20 12h2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4"/></svg><span class="nl">Theme</span></button> </div></header> diff --git a/diagrams/visual/index.html b/diagrams/visual/index.html index 051221ce..7db3b500 100644 --- a/diagrams/visual/index.html +++ b/diagrams/visual/index.html @@ -558,7 +558,7 @@ <body> <div class="bar"><div class="wrap"><span class="brand">/visual</span><nav id="nav"></nav><button class="btn" id="theme" type="button" aria-label="Toggle theme">◐</button></div></div> <main class="wrap" id="app"></main> -<script id="visual-data" type="application/json">{"title": "super-board skill map", "pack": "_skills/vendor/super-board", "branch": "feat/sb-cleanup @ b67241e1 (v3.0.0)", "sourcesBase": "", "kinds": {"public": "skill or command a user triggers directly", "lane": "board lane skill: started by /super-board run, also runnable standalone", "external": "skill from outside the pack (origin field says where)", "verb": "an Impeccable command", "script": "shell, python, node script or saved Workflow", "hook": "Claude Code hook or guard", "board": "state: GitHub Project, config, ledgers, repo"}, "nodes": [{"id": "super-board", "label": "/super-board", "kind": "public", "what": "The autonomous GitHub-Project pipeline: five verbs (onboard, lint, status, run, stop) take one board shape (Backlog · Ready · Building · QA · Review · Blocked · Done) from empty to drained, with labels qa · bug · feature routing each card.", "when": "Eric types /super-board <verb>, or says \"drain my GitHub project\" or \"stop super-board\"; with no verb it asks which one.", "how": "The session is an orchestrator only: it routes the verb to its reference file, dispatches lane agents, and never does product work itself. Board state is the only state, so `run` is also resume. Every commit, ticket, PR body and comment follows references/writing-standard.md.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/writing-standard.md"], "verbs": ["onboard", "lint", "status", "run", "stop"], "sublabel": "onboard · lint · status · run · stop", "opensView": "super-board", "author": "EricTechPro"}, {"id": "super-collect", "label": "/super-collect", "kind": "public", "what": "Finds problems in one project and files them as verified tickets into its super-board Backlog: five built-in sources plus any custom source added in onboard. It never builds, edits app code, or moves a card to Ready.", "when": "Eric runs /super-collect (all enabled sources) or /super-collect <source…> with sentry, posthog, github, prs, architecture or a custom source's name; optional --since and --yes.", "how": "Fetches each source for the window (default 14 days), sends every candidate to one fresh verifier sub-agent, then files through super-collect-file.sh. Dry-run by default: it shows a plan table and files on confirm.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"], "verbs": ["sentry", "posthog", "github", "prs", "architecture", "custom"], "sublabel": "sentry · posthog · github · prs · architecture · custom", "opensView": "super-collect", "author": "EricTechPro"}, {"id": "ui-refine-loop", "label": "/ui-refine-loop", "kind": "public", "what": "Unattended Impeccable check-then-fix loop on one page or component that ends in a draft PR with a Before | After table. Standalone: no board lane ever starts it.", "when": "Eric runs /ui-refine-loop <route | component | description> [\"what's wrong\"] [--rounds N], or says \"refine loop\" or \"polish this page with impeccable\".", "how": "Reads the target's code, grills Eric (at most 10 questions) into a taste file, then runs the saved ui-refine-loop workflow: each round fresh checkers rank typed problems and a fresh fixer chains Impeccable verbs, polish last. Default 5 rounds; a finish reviewer grades every fix. Commits are `💄 [ui] <slug>: …` and the PR body uses super-board-pr-body.sh's marker blocks.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js"], "verbs": ["<route|component>", "--rounds N"], "sublabel": "grill · check · fix · draft PR", "opensView": "ui-refine-loop", "author": "EricTechPro"}, {"id": "visual", "label": "/visual", "kind": "public", "what": "Turns the current work into one self-contained HTML page: a branch recap, a plan, or a map of a folder or architecture, with diagrams, a file map and annotated code.", "when": "Eric runs /visual, /visual recap [base], /visual plan [file] or /visual <path>; with no argument visual.py detect picks the mode.", "how": "Writes a data.json from git facts or the plan, then visual.py render injects it into an inline template with no build step. It screenshots the page headless to check it, and offers to publish only on a yes.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/visual/SKILL.md"], "verbs": ["recap", "plan", "explore"], "sublabel": "recap · plan · explore", "opensView": "visual", "author": "EricTechPro", "credits": ["BuilderIO", "tt-a1i"]}, {"id": "sb-onboard", "label": "/super-board onboard", "kind": "public", "what": "An 8-step setup wizard (Checks · GitHub · Board · Branch · AGENTS.md · Policies · Bug sources · Review) that installs or repairs what the board needs and writes the config once.", "when": "Eric runs /super-board onboard (or /super-board:super-board onboard after a plugin install), on a new project, after an upgrade from 2.x, or to check and repair an existing setup.", "how": "One AskUserQuestion per step with the recommended option first; must-haves are fixed without asking by super-board-setup.py. Answers save to onboard-answers.json as they come, so a halt resumes, and repo files change only at step 8 after \"Write everything\". It ends by naming /super-board lint.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"], "author": "EricTechPro", "opensView": "sb-onboard"}, {"id": "sb-lint", "label": "/super-board lint", "kind": "public", "what": "Pre-flight readiness check that walks Ready, Building, QA and Review, flags issues that fail any of 18 criteria, proposes a qa/bug/feature label, and dispatches a helper skill per flagged issue.", "when": "Eric runs /super-board lint before a run, typically after /super-collect filed new Backlog cards.", "how": "Criteria 13–18 cover what the loop needs: a parseable `## Blocked by` line, a fake with no follow-up card, too big (over ~400 changed lines or many areas), the ticket sections, a checklist AC, and lettered Context steps. Phase 4 routes each flagged pattern to one skill sub-agent while Eric keeps the pace.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/lint.md"], "opensView": "sb-lint", "author": "EricTechPro"}, {"id": "sb-status", "label": "/super-board status", "kind": "public", "what": "Read-only snapshot of the active config, every column in board order (Backlog included), and in-flight workers.", "when": "Eric runs /super-board status to see where a run stands.", "how": "super-board-status.py reads the board and local in-flight state and prints the columns in the board's own order; it changes nothing.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/status.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-status.py"], "author": "EricTechPro"}, {"id": "sb-run", "label": "/super-board run", "kind": "public", "what": "The autonomous loop: repeated waves of the super-board-wave workflow from this session until the board drains or a halt gate fires. Also the resume command.", "when": "Eric runs /super-board run [--low|--high] [<slug>]; the default worker_backend \"workflow\" stays in-session, \"claude-p\" opts into the legacy headless runner.", "how": "Each wave: rate and usage guard, plan with super-board-wave-plan.sh (which refuses an old `variant: qa-only` config with exit 65), act on sweep/flag/stranded/resume, claim cards by assignee, launch the workflow, reconcile, report. Halts after 3 zero-progress waves, a high block rate, or a stop.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run-workflow.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "verbs": ["--low", "--high"], "opensView": "super-board-run", "author": "EricTechPro"}, {"id": "sb-stop", "label": "/super-board stop", "kind": "public", "what": "Graceful shutdown: stops the wave, posts \"stopped mid-flight\" comments, releases assignee claims, and removes the wave lock so the next run resumes.", "when": "Eric runs /super-board stop or says \"stop the run\" / \"pause the loop\".", "how": "Stops the workflow (or kills the legacy dispatcher via super-board-stop.sh), comments on every in-flight issue and PR, and strips bot_identity assignees. Resume is just `run` again.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/stop.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-stop.sh"], "author": "EricTechPro"}, {"id": "super-build", "label": "super-build", "kind": "lane", "what": "Builder lane: takes a pre-flighted Ready card into its own worktree, makes the smallest safe change test-first under the 400-line PR cap, opens a draft PR and moves the card to QA. It never merges.", "when": "Started by the board: the super-board-wave workflow runs it for Ready cards labelled feature or bug (or unlabelled) once pre-flight says proceed. Also runnable standalone as /super-build (legacy headless claude -p dispatch).", "how": "Follows run.md's Builder lifecycle. An explicit `Skills:` line wins, else the type label picks the chain, always plus ponytail first, verification-before-completion and a code-review of its own diff. Past the size cap mid-build it stops and proposes a /to-tickets split. Commits and PR blocks follow the writing standard via super-board-pr-body.sh.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-build/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-build/references/decision-policy.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-build/references/worker-preamble.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "opensView": "super-build", "author": "EricTechPro"}, {"id": "super-qa", "label": "super-qa", "kind": "lane", "what": "Tester lane: builds an issue-scoped test plan, runs a test-gap check on the Builder's diff, captures evidence and screenshots, then passes the card to Review or bounces it to Build.", "when": "Started by the board for cards in QA, and straight from Ready for cards labelled qa (they skip Building). Also runnable standalone as /super-qa, a BFS route-crawling bug-bash, or /super-qa <url> for a live site with no repo.", "how": "One observable test per AC plus the test-gap ledger, High gaps written red-first. On a qa card it creates the issue branch itself and files real defects as bug cards. It ticks the PR's ac block, writes visual and history rows with super-board-pr-body.sh, and posts `[qa] [report]` comments with screenshots pinned to a sha.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/references/iteration-preamble.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "opensView": "super-qa", "author": "EricTechPro"}, {"id": "super-review", "label": "super-review", "kind": "lane", "what": "Reviewer lane and standalone PR review: forms its own hypotheses first, remembers prior findings, classes every finding, and merges only through the merge gate.", "when": "Started by the board for cards in Review (always on the session model). Also runnable standalone when Eric says \"review this branch\" or \"is this merge-ready\".", "how": "Thread scan, prior-report round 1, own pass with code-review, codebase-design and ponytail-review, a rerun of the Tester's exact test command, then an adversarial truth-check on non-trivial diffs. One report comment is edited in place every round. A clean review merges through the gate pinned to the reviewed head SHA; exit 7 or 8 parks the card in Blocked with 🙋. Visual problems become a UI ticket, never a ui-refine-loop run. The truth-check sub-agents get a fixed verbatim brief, and Over-engineering is never a Blocker from any of them.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-review/SKILL.md"], "opensView": "super-review", "author": "EricTechPro"}, {"id": "gh-board", "label": "GitHub Project board", "kind": "board", "what": "The configured GitHub Project with seven columns (Backlog, Ready, Building, QA, Review, Blocked, Done) and three routing labels (qa, bug, feature); the only loop state. There is no Skipped column.", "when": "Read and written on every wave, by every lane move, and by /super-collect filing into Backlog.", "how": "Cards move by `gh project item-edit`; assignees act as claim mutexes; PR threads start with their owner lane [builder] / [qa] / [reviewer] plus a label. A card dropped on purpose is closed as not planned and moved to Done with a 🤷 comment.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run-workflow.md"]}, {"id": "sb-config", "label": "super-board config", "kind": "board", "what": "Per-project JSON config: board, base branch, timezone, the seven columns, labels, merge_policy, migrations, worker backend, model tier, truth gate, plus `collect` (sources and custom[]) and `refine` blocks. No `variant` key.", "when": "Written once by onboard at step 8 (and migrated to v3 keys by super-board-setup.py fix); read at the start of every run, collect and ui-refine-loop setup.", "how": "Lives at `.claude/super-board/configs/<slug>.json` with `.claude/super-board/active` pointing at it, validated against config-schema.json.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/config-schema.json"]}, {"id": "base-branch", "label": "repo · base branch", "kind": "board", "what": "The project's git repo and configured base branch (never assumed to be main); a card is Done only when its merge commit is an ancestor of it.", "when": "Changed only by a merge-gate squash-merge; read by /visual and branched from by every worktree.", "how": "Lanes and ui-refine-loop work on their own branches under .worktrees/ or .claude/worktrees/; the opt-in protected-push guard can block direct pushes to it.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-review/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"]}, {"id": "run-manifest", "label": "run manifest", "kind": "board", "what": "Per-run ledger at `docs/super-board/runs/<date>-<slug>.md`, one line per card per wave.", "when": "Appended during each wave's reconcile step.", "how": "Each line records card, lanes run, final status, column and detail: `| #N | <lanesRun> | <finalStatus> | <column> | <detail> |`.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run-workflow.md"]}, {"id": "qa-board", "label": "Super Ultimate QA board", "kind": "board", "what": "Separate GitHub Project (Queue, Testing, Done, Bug, Flaky, Skip) used by standalone /super-qa as its loop state.", "when": "Written when a standalone super-qa iteration finds a red spec; /super-collect bugs and qa-card defects also go through the same filer.", "how": "super-qa-file-bug.sh creates a `source:qa` issue with the evidence body and sets its Status to Bug (Flaky and Skip for the other outcomes).", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/SKILL.md"]}, {"id": "taste-file", "label": "taste + direction file", "kind": "board", "what": "Per-project design taste file (default `docs/design/taste.md`) holding the grill's goal, direction, keep and avoid answers plus taste rules and slop tells.", "when": "Written after the grill and committed as the refine branch's first commit; read first by every checker, fixer and finish reviewer.", "how": "Starts from the neutral references/taste.md when absent; each target gets a `### <target>` block under Direction, with \"you pick\" answers marked (picked).", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/grill.md", "https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/taste.md"]}, {"id": "refine-ledger", "label": "refine ledger", "kind": "board", "what": "The only memory carried between refine rounds: one line per check with score /40, before-vs-now, and problem ids.", "when": "Appended by the workflow after every check; written to `<run>/ledger.md` at finish.", "how": "Checkers reuse ledger ids so a problem that survives three checks is called out; stop rules read it (two clean checks, two reverts in a row).", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/ledger.md"]}, {"id": "draft-pr", "label": "refine draft PR", "kind": "board", "what": "The draft PR from `refine/<slug>` against the recorded base branch, with a Before | After table, score line and finish grades.", "when": "Opened once at the end of a ui-refine-loop run; never merged by the loop.", "how": "pr-shots.sh commits round-0 and final shots to `docs/ui-refine/<slug>/` and prints a Before | After table pinned to both shas; the body uses the writing standard's marker blocks (status, problem, solution, ac, history, visual, risk) and is humanized before `gh pr create --draft`.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/scripts/pr-shots.sh"]}, {"id": "gh-issues", "label": "open GitHub issues", "kind": "board", "what": "The repo's open issues that are not yet on the board and carry no `source:*` label.", "when": "Read by the /super-collect github source.", "how": "Fetched with `gh issue list --state open`; real work is adopted onto the board (`--adopt <n>`), never copied into a new issue.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"]}, {"id": "claude-settings", "label": ".claude/settings.json", "kind": "board", "what": "The target project's Claude Code settings, where install.sh merges the guard hook block from settings-snippet.json.", "when": "Written by install.sh (backed up first, never adding a command twice); read by Claude Code at every session.", "how": "Wires PreToolUse, PostToolUse and SessionStart commands to the scripts copied into `.claude/hooks/`; `--protect-main` adds settings-protect-main.json.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/settings-snippet.json", "https://github.com/EricTechPro/super-board/blob/main/hooks/settings-protect-main.json", "https://github.com/EricTechPro/super-board/blob/main/install.sh"]}, {"id": "hooks", "label": "guard hooks", "kind": "hook", "what": "The pack's Claude Code hooks: four default guards, an opt-in push guard, post-merge worktree cleanup, and two dev-only hooks for the pack itself.", "when": "Installed by install.sh unless --no-hooks; each fires on its Claude Code event and matcher.", "how": "Python 3 stdlib scripts that read hook JSON on stdin, print a decision only when they block, and exit 0 on their own errors so a broken guard never stops work.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/README.md"], "opensView": "hooks"}, {"id": "guard-worktree-path", "label": "guard-worktree-path", "kind": "hook", "what": "Denies `git worktree add|move` whose target resolves outside `<repo>/.claude/worktrees/`.", "when": "PreToolUse, matcher Bash, on every shell command.", "how": "Parses the command, honouring `cd X &&` and `git -C X`, resolves the target path, and blocks when it escapes the worktrees folder.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/guard-worktree-path.py"]}, {"id": "guard-secrets", "label": "guard-secrets", "kind": "hook", "what": "Denies reading or piping dotenv files, SSH keys, .npmrc, credentials(.json), service-account JSON and .pem files; .env.example stays readable.", "when": "PreToolUse, matcher Bash|Read|Grep.", "how": "Matches file paths in Read/Grep input and in shell commands against secret-file patterns and blocks the call. One plain call to super-board-env-check.sh (no pipe, chain or redirect) is allowed, since it prints only present / empty / missing.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/guard-secrets.py"]}, {"id": "guard-key-literals", "label": "guard-key-literals", "kind": "hook", "what": "Stops a live-looking API key from being written into a file, and flags one already on disk.", "when": "PreToolUse on Edit|MultiEdit|Write|NotebookEdit|Bash, and PostToolUse on Edit|MultiEdit|Write|NotebookEdit.", "how": "Scans the content being written for key-shaped literals and reports line numbers only, never the value.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/guard-key-literals.py"]}, {"id": "guard-delete-outside", "label": "guard-delete-outside", "kind": "hook", "what": "Denies rm, rmdir, unlink, find -delete / -exec rm and git clean whose target resolves outside $CLAUDE_PROJECT_DIR, and always `/` or `~` itself.", "when": "PreToolUse, matcher Bash.", "how": "Resolves each target (honouring cd, git -C, ~ and $HOME); temp dirs stay allowed, and a path known only at run time is allowed.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/guard-delete-outside.py"]}, {"id": "guard-protected-push", "label": "guard-protected-push", "kind": "hook", "what": "Opt-in guard that denies a git push that would update or delete main, master, any configured base_branch, or a name in SB_PROTECTED_BRANCHES.", "when": "PreToolUse, matcher Bash, only after onboard's Policies yes (step 6) or `./install.sh --protect-main`.", "how": "Catches force pushes, explicit refspecs, --delete, --all/--mirror and a bare push while the base is checked out; feature-branch force pushes stay allowed. SB_ALLOW_PROTECTED_PUSH=1 turns it off for a session.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/guard-protected-push.py", "https://github.com/EricTechPro/super-board/blob/main/hooks/settings-protect-main.json"]}, {"id": "cleanup-wt", "label": "cleanup-wt", "kind": "hook", "what": "Removes worktrees and local branches already merged into a base branch; never deletes unmerged work.", "when": "SessionStart with `--auto --fetch` when a base tip moved since the last session, and after every merge when the merge gate calls it with `--post-merge`.", "how": "Wip-commits a dirty worktree on a merged branch and keeps its branch, never touches bases or its own worktree, and writes a recovery TSV under `<git-common-dir>/cleanup-wt/` before acting.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/cleanup-wt.py", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-gate.sh"]}, {"id": "gate-skill-evals", "label": "gate-skill-evals (dev)", "kind": "hook", "what": "Dev-only Stop hook that blocks ending a session when a skill changed and no `claude plugin eval` result is newer than the change.", "when": "Stop event in the pack's own `.claude/settings.json` (and EricOS if added by hand); never installed into target projects.", "how": "A changed SKILL.md always counts; a changed reference, script or workflow counts when the skill has an eval case. SKILL_EVAL_GATE=off, a running eval or `.claude/eval-gate-ignore` globs stand it down.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/dev/gate-skill-evals.py", "https://github.com/EricTechPro/super-board/blob/main/.claude/settings.json"]}, {"id": "readme-sync", "label": "readme-sync (dev)", "kind": "hook", "what": "Dev-only hooks that keep README.md's skill tables in step with skills/*/SKILL.md and families.json.", "when": "PostToolUse on Edit|Write|MultiEdit in the pack repo, and as a git pre-commit hook when it is symlinked in.", "how": "Runs super-board-readme-sync.py; the pre-commit version stops the commit when README.md had to change so it can be staged.", "source": ["https://github.com/EricTechPro/super-board/blob/main/.claude/settings.json", "https://github.com/EricTechPro/super-board/blob/main/hooks/pre-commit-readme.sh", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-readme-sync.py"]}, {"id": "wave-plan", "label": "super-board-wave-plan.sh", "kind": "script", "what": "Read-only planner that computes the next wave from board state: cards (each with its lane and labels) plus the sweep, flag, stranded and resume lists.", "when": "Run by the orchestrator at the start of every wave, after the rate and usage guards pass.", "how": "Reads the board and `## Blocked by` dependencies (via super-board-deps.sh); a Ready card labelled qa gets lane qa, every other Ready card lane build. `resume` lists 🙋 cards a human approved with `done`. A `variant: qa-only` config is refused with exit 65.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-wave-plan.sh", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-deps.sh"]}, {"id": "wave-js", "label": "super-board-wave.js", "kind": "script", "what": "Saved Workflow that drains one wave: a Pre-flight phase for cards about to be built, a haiku classify router, then Build, QA and Review lane agents per card.", "when": "Launched by /super-board run with {configPath, cards (with lane and labels), humanApprovesMerge, tier}; a stale `variant` other than full is refused.", "how": "Pre-flights Ready build cards in batches of 5 and never builds a card without a proceed verdict. The classifier keeps a card's qa/bug/feature label and adds feature or bug to unlabelled ones, never qa. A qa card goes Ready → QA. Model ladder by tier and complexity; Review always on the session model.", "source": ["https://github.com/EricTechPro/super-board/blob/main/workflows/super-board-wave.js"]}, {"id": "merge-gate", "label": "super-board-merge-gate.sh", "kind": "script", "what": "The only path to the base branch: takes an atomic mkdir lock, applies merge_policy, re-proves the branch against the current base inside the lock, runs allowed DB migrations, then squash-merges.", "when": "Called by the Reviewer once a review passes (and human_approves_merge is not set).", "how": "super-board-merge-policy.py decides who merges: money, auth, destructive schema or a diff over auto_max_lines (400 changed lines, lockfiles/generated/snapshots/migration SQL excluded) exits 7; a migration it may not run or a declared human step exits 8. Otherwise it merges with `--match-head-commit` (exit 6 when the head moved) and runs cleanup-wt --post-merge.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-policy.py"]}, {"id": "file-bug", "label": "super-qa-file-bug.sh", "kind": "script", "what": "Files one finding as a GitHub issue with a validated body onto the Super Ultimate QA board.", "when": "Called by standalone super-qa on a red spec, and by super-collect-file.sh for bug, feature and fix tickets.", "how": "Rejects bodies missing the ticket-format sections (Problem · Context · Fix · Acceptance Criteria · Risk, bugs with the folded Evidence table) or holding placeholders; adds type, source, priority and area labels and sets the project Status, falling back through Bug, Ready, Todo, Backlog, Triage.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-qa-file-bug.sh"]}, {"id": "file-refactor", "label": "review-file-refactor.sh", "kind": "script", "what": "Files a deepening opportunity as a `refactor` card, deduped by fingerprint.", "when": "Called by super-review for shape findings that must not block a merge, and by super-collect-file.sh for architecture tickets.", "how": "A body with an `## Acceptance criteria` section goes straight to Ready; otherwise it lands in the holding column for lint. It appends `## Blocked by` when missing.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-review-file-refactor.sh"]}, {"id": "collect-file", "label": "super-collect-file.sh", "kind": "script", "what": "Single filing entry point for /super-collect that routes each verified ticket to the pack's filers.", "when": "Called once per candidate the verifier marked file or needs-triage (dry-run without --yes, real filing with it), or with --adopt <n>.", "how": "bug/feature/fix go to super-qa-file-bug.sh, refactor to super-review-file-refactor.sh, every body in the writing-standard ticket format. It enforces per-source fingerprints (custom `custom|<name>|<key>`), exact-fingerprint dedupe and the board's holding column.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/super-collect-file.sh"]}, {"id": "collect-sentry", "label": "sentry fetcher", "kind": "script", "what": "The sentry source: lists unresolved Sentry issues in the window and pulls event and tag evidence.", "when": "Run when /super-collect includes sentry and the config has a sentry block.", "how": "`collect_sentry.py list --since <w>` calls the Sentry REST API with SENTRY_AUTH_TOKEN from .env; `check <id>` answers still-happening for the verifier. One issue becomes one bug, fp `err|sentry|<id>`.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/collect_sentry.py"]}, {"id": "collect-posthog", "label": "posthog fetcher", "kind": "script", "what": "The posthog source: exceptions, configured failure events, rage and dead clicks, web vitals, surveys, plus tracking gaps.", "when": "Run when /super-collect includes posthog.", "how": "`collect_posthog.py list|events|funnel|check` runs HogQL queries with POSTHOG_PERSONAL_API_KEY; signal groups over the thresholds become bugs, and missing workflow events become `analytics` feature tickets.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/collect_posthog.py"]}, {"id": "collect-prs", "label": "prs fetcher", "kind": "script", "what": "The prs source: merged PRs in the window with their comments, reviews, review threads and flagged super-review reports.", "when": "Run when /super-collect includes prs.", "how": "`collect_prs.py list` runs one paginated GraphQL search; Claude then clusters recurring root causes at a shared boundary into fix, refactor or feature tickets (fp `prs|<boundary>|<cause>`).", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/collect_prs.py"]}, {"id": "shoot", "label": "shoot.mjs", "kind": "script", "what": "Playwright screenshot script for the refine loop: light and dark at 1440 and 390, section crops, and before | after sheets.", "when": "Run for round-0 shots at setup and for AFTER shots at the end of every fix round.", "how": "Writes `<label>-<state>-<desktop|mobile>-<light|dark>.png` grown to the scroll height; `--compare round-0` adds cmp sheets the next checker judges.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/scripts/shoot.mjs"]}, {"id": "imp-detect", "label": "impeccable detect", "kind": "script", "what": "Impeccable's mechanical anti-pattern detector, run over every scope path holding markup or styles.", "when": "Run by the isolated detector sub-agent in every check, alongside the audit.", "how": "Invoked as `scripts/impeccable detect --json` (v4.4+) or `node scripts/detect.mjs --json` (v4.0.x), as found by refine-setup.sh detect; exit 2 means findings, which are checked in source for false positives.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/checker-brief.md", "https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/scripts/refine-setup.sh"]}, {"id": "install-sh", "label": "install.sh", "kind": "script", "what": "Installs the pack into a target project: skills, .claude/bin scripts, workflows and the guard hooks, with grouped emoji output.", "when": "Run by get.sh, by super-board-setup.py fix during onboard, or by hand: `./install.sh [--no-hooks] [--protect-main] [target]`.", "how": "Copies hooks/*.py to `.claude/hooks/` (never hooks/dev/) and merges the hook block through super-board-settings.py; `--no-hooks --protect-main` installs only the push guard. It records an older install in `.claude/super-board/upgrade.json` and ends with one next step: /super-board onboard.", "source": ["https://github.com/EricTechPro/super-board/blob/main/install.sh"], "opensView": "install"}, {"id": "visual-py", "label": "visual.py", "kind": "script", "what": "The /visual helper: detect picks the mode, facts collects git data, render injects data.json into the inline template.", "when": "Run by /visual at every step: detect with no argument, facts in recap mode, render after data.json is written.", "how": "render prints `{out, missingHunks}`; grounded hunks come from git via `hunks[].file + contains`, and output lands in a gitignored `_tmp/<date>-visual/` or `.visual/`.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/visual/scripts/visual.py"]}, {"id": "grilling", "label": "grilling", "kind": "external", "what": "Interview pattern that walks a design tree in rounds: numbered questions, each with a recommended answer, until the frontier is empty.", "when": "Reached by /ui-refine-loop's grill step and by /super-board lint for vague or multi-reading tickets; forbidden inside unattended workers.", "how": "Asks the whole frontier per round and waits; facts come from sub-agents, decisions from the user. ui-refine-loop caps it at 10 questions in waves of 3, then 4.", "source": [".agents/skills/grilling/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "tdd", "label": "tdd", "kind": "external", "what": "Test-driven development discipline: tests at agreed seams through public interfaces, red before green, one vertical slice at a time.", "when": "Reached by super-build for every non-docs ticket, by super-qa when writing High test gaps, and by implement.", "how": "Defines good tests, the anti-patterns (implementation-coupled, tautological, horizontal slicing) and the loop rules; refactoring belongs to the code-review stage.", "source": [".agents/skills/tdd/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "tdd", "author": "mattpocock"}, {"id": "tdd-v2", "label": "tdd-v2", "kind": "external", "what": "The EricOS testing ladder: which rung a test belongs at (unit, isolated render, e2e) and the gate for climbing to the next.", "when": "Reached by super-qa's test-gap check \"where the repo has it\", and by implement as its preferred test skill.", "how": "Building climbs bottom-up; chasing a defect walks down to the first rung that still reproduces. It owns the layer and defers red-green discipline to tdd.", "source": [".agents/skills/tdd-v2/SKILL.md"], "external": true, "origin": "EricOS local skill", "opensView": "tdd-v2", "author": "EricTechPro"}, {"id": "implement", "label": "implement", "kind": "external", "what": "Implements a piece of work from a spec or tickets, test-first, then reviews and commits it.", "when": "Reached by super-build when the issue's type label is feature or ux (implement → tdd → codebase-design).", "how": "Uses tdd-v2 at pre-agreed seams with tdd underneath, runs typecheck and single tests often and the full suite once, then runs code-review before committing.", "source": [".agents/skills/implement/SKILL.md"], "external": true, "origin": "mattpocock-skills (EricOS local override)", "opensView": "implement", "author": "mattpocock"}, {"id": "code-review", "label": "code-review", "kind": "external", "what": "Two-axis review of the diff since a fixed point: Standards (repo rules plus a Fowler smell baseline) and Spec (does it match the issue).", "when": "Reached by super-build once against its own diff before the final commit, by super-review on every card, and by implement and tdd.", "how": "Pins the fixed point (the lanes pass the merge-base so it never asks), runs a Standards and a Spec sub-agent in parallel, and reports them side by side without reranking.", "source": [".agents/skills/code-review/SKILL.md"], "external": true, "origin": "mattpocock-skills (EricOS local override)", "opensView": "code-review", "author": "mattpocock"}, {"id": "diagnosing-bugs", "label": "diagnosing-bugs", "kind": "external", "what": "Diagnosis loop for hard bugs and perf regressions: build a tight red feedback loop, reproduce, hypothesise, instrument, fix with a regression test.", "when": "Reached by super-build for `bug`-labelled tickets, by super-qa as a required dependency, and by lint for bug tickets with no repro.", "how": "Six phases; refuses to theorise before one command goes red on this bug. Its post-mortem hands off to improve-codebase-architecture when no good seam exists.", "source": [".agents/skills/diagnosing-bugs/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "diagnosing-bugs", "author": "mattpocock"}, {"id": "codebase-design", "label": "codebase-design", "kind": "external", "what": "Shared deep-module vocabulary: module, interface, depth, seam, adapter, leverage, locality, and the deletion test.", "when": "Reached by super-build for feature and refactor tickets, by super-review in step 2 and for every deepening opportunity, and by super-collect's architecture finder as a fallback.", "how": "A reference to consult, not a session: no report, no prompts. Its design-it-twice pattern runs parallel sub-agents when an interface needs alternatives.", "source": [".agents/skills/codebase-design/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "ask-matt", "label": "ask-matt", "kind": "external", "what": "Router over the Matt Pocock skills: which flow fits the situation, from idea to ship.", "when": "Reached by super-build and super-qa workers when the right flow is unclear.", "how": "Main flow: grill-with-docs, optional prototype via handoff, to-spec and to-tickets for multi-session work, then implement (driving tdd) and code-review. On-ramps: triage, diagnosing-bugs, wayfinder.", "source": [".agents/skills/ask-matt/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "ask-matt", "author": "mattpocock"}, {"id": "humanizer", "label": "humanizer", "kind": "external", "what": "Strips AI writing tells from a finished draft so it reads like a person wrote it, with Eric Tech plain-words overrides.", "when": "Reached whenever a lane or ui-refine-loop writes prose: the writing standard says ALWAYS run commits, tickets, PR bodies and comments through it when installed.", "how": "Applies the vendored blader/humanizer rule set (32 patterns) as a silent pass; without it the writing standard's plain-words rules apply (short sentences, plain words, no hype).", "source": [".agents/skills/humanizer/SKILL.md", "erictech-skills/skills/humanizer/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/writing-standard.md"], "external": true, "origin": "erictech-skills (vendored blader/humanizer)", "author": "blader"}, {"id": "verification", "label": "verification-before-compl.", "kind": "external", "what": "Evidence before assertions: run the verification command and read its output before claiming work is done, fixed or passing.", "when": "Reached by super-build before its final commit and by super-qa as a required dependency.", "how": "A gate function: identify the proving command, run it fresh, read the full output, and only then state the result.", "source": [".agents/skills/verification-before-completion/SKILL.md"], "external": true, "origin": "EricOS .agents/skills (origin not recorded)", "author": "obra"}, {"id": "context7", "label": "context7 (docs)", "kind": "external", "what": "MCP docs lookup used to read current official documentation for a library or API version.", "when": "Reached by super-build when a ticket touches a third-party API, an upgrade, or auth/billing.", "how": "Builder reads the exact surface and installed major's docs (context7 when available, else vendor docs by web search) and cites them as `Docs:` bullets in the PR's Solution block.", "source": ["~/.claude/plugins/marketplaces/claude-plugins-official/external_plugins/context7/README.md"], "external": true, "origin": "claude-plugins-official (MCP plugin)", "author": "upstash"}, {"id": "resolving-merge-conflicts", "label": "resolving-merge-conflicts", "kind": "external", "what": "Resolves an in-progress merge or rebase conflict by reading each side's intent, then runs the project's checks.", "when": "Reached by super-build on a live conflict, e.g. when the merge gate exits 2 or 5 and the card returns to the Builder, and by /git-sync when its pull conflicts.", "how": "Finds primary sources per hunk, preserves both intents where possible, never aborts; the Builder's finish line is green verification, not an empty conflict list.", "source": [".agents/skills/resolving-merge-conflicts/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "improve-codebase-architecture", "label": "improve-codebase-arch.", "kind": "external", "what": "Scans a codebase for deepening opportunities, presents them as an HTML report, then grills through the one picked.", "when": "Reached by /super-collect's architecture finder (findings only, no report or grilling) and by diagnosing-bugs' post-mortem; never loaded inside the Review lane.", "how": "Explores hot spots from git history with codebase-design vocabulary and CONTEXT.md/ADRs, writes the report, then runs grilling and domain-modeling on the chosen candidate.", "source": [".agents/skills/improve-codebase-architecture/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "improve-codebase-architecture", "author": "mattpocock"}, {"id": "domain-modeling", "label": "domain-modeling", "kind": "external", "what": "Sharpens a project's domain language in CONTEXT.md and records hard-to-reverse decisions as ADRs.", "when": "Reached from improve-codebase-architecture, grill-with-docs, triage and wayfinder sessions, and listed in super-build's skill map for terminology and ADRs.", "how": "Challenges fuzzy or overloaded terms and updates CONTEXT.md inline; offers an ADR only when a future reader would need the reason.", "source": [".agents/skills/domain-modeling/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "ponytail", "label": "ponytail", "kind": "external", "what": "Forces the simplest solution that works via a ladder: needed at all, already in the codebase, stdlib, native, installed dep, one line, then minimal code.", "when": "Reached by super-build on every ticket, before the first line of code (full intensity).", "how": "Runs after understanding the problem; bug fixes go to the root cause in the shared function. Inline ladder fallback when the plugin is absent.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "ponytail-review", "label": "ponytail-review", "kind": "external", "what": "Diff review that hunts only over-engineering, one line per finding tagged delete, stdlib, native, yagni or shrink.", "when": "Reached by super-review on the merge-base diff in step 3.", "how": "Ends with `net: -N lines possible`; findings are Over-engineering, always Should fix and never a merge blocker alone. It applies nothing.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail-review/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "ponytail-audit", "label": "ponytail-audit", "kind": "external", "what": "Whole-repo version of ponytail-review: a ranked list of what to delete, simplify or replace with stdlib or native features.", "when": "Reached by /super-collect's architecture finder for over-engineering findings.", "how": "Same tags as ponytail-review, biggest cut first, ending `net: -N lines, -M deps possible`; one-shot and read-only.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail-audit/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "impeccable", "label": "impeccable", "kind": "external", "what": "Frontend design skill whose commands critique, audit and refine UI: build, evaluate, refine, enhance, fix and iterate categories.", "when": "Reached by /ui-refine-loop at setup (detect and context), by every checker and fixer, and by lint for shape and clarify.", "how": "Each command has a playbook under reference/<command>.md plus craft-floor.md; refine-setup.sh finds v4.0.x node scripts or the v4.4+ launcher in this or any parent dir, warning loudly when missing.", "source": [".agents/skills/impeccable/SKILL.md"], "external": true, "origin": "pbakaus/impeccable", "opensView": "impeccable", "author": "pbakaus"}, {"id": "testing-strategy", "label": "testing-strategy", "kind": "external", "what": "Coverage judgment per component type: what is worth testing and what to skip.", "when": "Listed by super-build's skill map and super-qa's dependencies for deciding which kind of test a change needs.", "how": "Informs coverage only; the localisation ladder, not this skill, picks the test layer. Not installed in EricOS.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-build/references/decision-policy.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "vitest", "label": "vitest", "kind": "external", "what": "Mechanics for unit and integration tests in a TS/JS repo.", "when": "Listed by super-qa and super-build when the localisation ladder stops at unit or integration in a TS/JS repo.", "how": "Its references (core-expect, features-mocking, features-coverage, core-hooks, advanced-vi) guide test code. Not installed in EricOS.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/SKILL.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "playwright-bp", "label": "playwright-best-practices", "kind": "external", "what": "Mechanics for browser e2e specs: locators, fixtures, test data factories, page objects.", "when": "Listed by super-qa when writing or refactoring a Playwright spec.", "how": "data-testid first with getByRole fallback, custom fixtures for auth and seeding, POM for reusable interactions. Not installed in EricOS.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/SKILL.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "qa-test-planner", "label": "qa-test-planner", "kind": "external", "what": "Test-plan helper lint dispatches for QA tickets with a vague test surface.", "when": "Reached by /super-board lint Phase 4 for QA tickets whose test surface is vague.", "how": "One sub-agent per flagged issue drafts a concrete test plan. Not installed in EricOS.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/lint.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "setup-matt-pocock-skills", "label": "setup-matt-pocock-skills", "kind": "external", "what": "One-time repo setup for the engineering skills: issue tracker, triage label vocabulary, domain doc layout.", "when": "Reached when code-review, to-spec, to-tickets, triage or wayfinder find `docs/agents/issue-tracker.md` missing.", "how": "Asks a few sections with recommended answers and records them under docs/agents/ so the other skills know whether to call gh or write markdown files.", "source": [".agents/skills/setup-matt-pocock-skills/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "grill-with-docs", "label": "grill-with-docs", "kind": "external", "what": "Stateful grilling that builds CONTEXT.md and ADRs and checkpoints every answer to a capture file.", "when": "Reached from ask-matt as step 1 of the main flow whenever there is a working directory.", "how": "Runs the grilling primitive and drives domain-modeling to keep the glossary clean; user-invoked only.", "source": [".agents/skills/grill-with-docs/SKILL.md", "erictech-skills/skills/grill-with-docs/SKILL.md"], "external": true, "origin": "erictech-skills (override of mattpocock grill-with-docs)", "opensView": "grill-with-docs", "author": "EricTechPro"}, {"id": "prototype", "label": "prototype", "kind": "external", "what": "Throwaway prototype that answers one design question: a logic demo or a UI to look at.", "when": "Reached from ask-matt when a question needs a runnable answer, and from wayfinder prototype tickets.", "how": "Throwaway from day one, trivial to run, no persistence, no polish; the learning is handed back via handoff.", "source": [".agents/skills/prototype/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "handoff", "label": "handoff", "kind": "external", "what": "Compacts the conversation into a handoff document for a fresh agent.", "when": "Reached from ask-matt to bridge a prototype detour or a phase boundary.", "how": "Writes the summary to the OS temp directory, not the workspace, so another session can pick it up.", "source": [".agents/skills/handoff/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "to-spec", "label": "to-spec", "kind": "external", "what": "Turns the current conversation into a spec and publishes it to the issue tracker, no interview.", "when": "Reached from ask-matt for multi-session builds; listed in super-build's skill map.", "how": "Writes the spec from a template and applies the `ready-for-agent` label; needs the tracker config from setup-matt-pocock-skills.", "source": [".agents/skills/to-spec/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "to-spec", "author": "mattpocock"}, {"id": "to-tickets", "label": "to-tickets", "kind": "external", "what": "Breaks a plan or spec into tracer-bullet tickets, each declaring its blocking edges.", "when": "Reached from ask-matt after to-spec, and from /super-board lint to split a too-big ticket (criterion 15) into vertical slices; its `## Blocked by` template is why lint criterion 13 exists.", "how": "Publishes blockers first so edges reference real ids, as files locally or native blocking links on a real tracker.", "source": [".agents/skills/to-tickets/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "to-tickets", "author": "mattpocock"}, {"id": "triage", "label": "triage", "kind": "external", "what": "Moves raw issues and external PRs through a state machine of triage roles into agent-ready briefs.", "when": "Reached from ask-matt when bugs and requests pile up that you did not create.", "how": "Categorise, verify, grill if needed, write the brief; every comment carries an AI disclaimer and labels come from setup-matt-pocock-skills.", "source": [".agents/skills/triage/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "triage", "author": "mattpocock"}, {"id": "wayfinder", "label": "wayfinder", "kind": "external", "what": "Charts a shared map of decision tickets for a huge, foggy effort and resolves them one at a time.", "when": "Reached from ask-matt for greenfield projects or builds too big for one session.", "how": "Tickets are research, prototype, grilling or task, HITL or AFK; it hands off to to-spec when the map clears instead of building.", "source": [".agents/skills/wayfinder/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "wayfinder", "author": "mattpocock"}, {"id": "verbs-group", "label": "impeccable fix verbs", "kind": "verb", "what": "The 15 Impeccable commands the ui-refine-loop fixer may chain, one per problem type, with polish always last.", "when": "Each fix round, after the checker returns ranked, typed P0–P3 problems.", "how": "The workflow attaches routing.md's default command per type and suggests a chain (severity order, structural before surface, additive verbs only when the direction asks); the fixer reads each playbook and craft-floor, then makes the final call.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/routing.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js", "https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/fixer-brief.md"], "opensView": "impeccable-verbs", "author": "pbakaus"}, {"id": "late-verbs", "label": "motion + perf verbs", "kind": "verb", "what": "The last tier of the chain before polish: animate, delight and optimize.", "when": "When a problem is typed needs-motion, personality or performance.", "how": "routing.md runs these after the structural, surface and fix tiers; animate and delight are additive, so they run only when the brief or taste direction asks for more.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/routing.md"], "opensView": "late-verbs", "author": "pbakaus"}, {"id": "v-critique", "label": "critique", "kind": "verb", "what": "UX design review with scoring; the loop uses Assessment A only, scored /20 across specificity, hierarchy, typography, color and composition.", "when": "Every check, run by the isolated design reviewer sub-agent in parallel with the detector.", "how": "Reads critique.md (Assessment A) and craft-floor.md, every shot and crop in both themes and widths, then the scope files; returns up to 8 typed problems. No Nielsen heuristics.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/critique.md"], "author": "pbakaus"}, {"id": "v-audit", "label": "audit", "kind": "verb", "what": "Technical quality check scored /20 across accessibility, performance, responsive, theming and implementation integrity.", "when": "Every check, run by the isolated detector sub-agent after impeccable detect.", "how": "Reads audit.md, scores five dimensions 0–4, and turns each verified detector cluster or audit gap into a typed problem; it never sees the screenshots or the design review.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/audit.md"], "author": "pbakaus"}, {"id": "v-polish", "label": "polish", "kind": "verb", "what": "Final quality pass over everything the round touched: small misalignments and inconsistencies, no structural change.", "when": "Always the last command of every fix round, even when no problem was typed polish.", "how": "Runs once over all touched files after the routed chain; then checks must be green before the round's single commit.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/polish.md"], "author": "pbakaus"}, {"id": "v-distill", "label": "distill", "kind": "verb", "what": "Strips a surface to its essence, removing duplicate actions and competing chrome.", "when": "Routed for problems typed `cluttered`.", "how": "Structural tier, so it runs first in the chain alongside extract; follows reference/distill.md as a refinement of the existing design.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/distill.md"], "author": "pbakaus"}, {"id": "v-bolder", "label": "bolder", "kind": "verb", "what": "Amplifies a safe, bland design so it has more presence.", "when": "Routed for `bland`, only when the brief or taste direction asks for more.", "how": "Additive surface-tier verb; skipped with a reason like \"direction says calmer\", and dropped when it pulls against quieter on the same element.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/bolder.md"], "author": "pbakaus"}, {"id": "v-quieter", "label": "quieter", "kind": "verb", "what": "Tones down an aggressive design: fewer colors, weights, borders, shadows or badges.", "when": "Routed for problems typed `too-loud`.", "how": "Surface tier after layout/adapt; when it conflicts with bolder on one element the higher-severity problem wins.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/quieter.md"], "author": "pbakaus"}, {"id": "v-colorize", "label": "colorize", "kind": "verb", "what": "Adds strategic color where gray or flat UI should carry meaning.", "when": "Routed for `dull-color`, only when the direction asks for more.", "how": "Additive surface-tier verb; changes must hold in light and dark and use tokens, not raw values.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/colorize.md"], "author": "pbakaus"}, {"id": "v-layout", "label": "layout", "kind": "verb", "what": "Fixes spacing, rhythm, grouping, alignment and visual hierarchy.", "when": "Routed for problems typed `spacing-hierarchy`.", "how": "Second tier, after distill/extract; a cramped look caused by a copied card is rerouted to extract by the fixer.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/layout.md"], "author": "pbakaus"}, {"id": "v-typeset", "label": "typeset", "kind": "verb", "what": "Improves typography: fonts, type scale, weights, line length and figures.", "when": "Routed for problems typed `typography`.", "how": "Surface tier with colorize, quieter and bolder; follows reference/typeset.md within the taste file's type rules.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/typeset.md"], "author": "pbakaus"}, {"id": "v-adapt", "label": "adapt", "kind": "verb", "what": "Adapts the surface to other screen sizes: breakpoints, touch targets, no sideways scroll at 390.", "when": "Routed for problems typed `responsive`.", "how": "Second tier with layout; the after shots at 390 in both themes prove it.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/adapt.md"], "author": "pbakaus"}, {"id": "v-optimize", "label": "optimize", "kind": "verb", "what": "Diagnoses and fixes UI performance: jank, layout shift, heavy images or bundles.", "when": "Routed for problems typed `performance`.", "how": "Last tier with animate and delight, before polish; follows reference/optimize.md.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/optimize.md"], "author": "pbakaus"}, {"id": "v-onboard", "label": "onboard", "kind": "verb", "what": "Designs first-run flows and empty states that point to the next action.", "when": "Routed for problems typed `first-run-empty`.", "how": "Fix tier with clarify and harden; no dense fixture means no dense shots, never fabricated data.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/onboard.md"], "author": "pbakaus"}, {"id": "v-clarify", "label": "clarify", "kind": "verb", "what": "Improves UX copy: labels, errors, status words and instructions.", "when": "Routed for `confusing-copy` in the refine loop; also dispatched by /super-board lint for copy or error-message ACs.", "how": "Fix tier; refinement keeps the meaning of factual copy and never adds claims.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/clarify.md"], "author": "pbakaus"}, {"id": "v-harden", "label": "harden", "kind": "verb", "what": "Production-readiness: long content, errors, loading, i18n, overflow, and accessibility (contrast, focus, names, keyboard).", "when": "Routed for problems typed `edge-cases` or `accessibility`.", "how": "Fix tier; the only verb two problem types share in routing.md.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/harden.md"], "author": "pbakaus"}, {"id": "v-animate", "label": "animate", "kind": "verb", "what": "Adds purposeful motion and state-change feedback.", "when": "Routed for `needs-motion`, only when the brief or direction asks for motion.", "how": "Additive last-tier verb; delight may call it.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/animate.md"], "author": "pbakaus"}, {"id": "v-delight", "label": "delight", "kind": "verb", "what": "Adds personality and memorable touches to a correct but lifeless surface.", "when": "Routed for `personality`, only when the brief asks for character.", "how": "Additive last-tier verb that calls animate for motion; followed by polish.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/delight.md"], "author": "pbakaus"}, {"id": "v-extract", "label": "extract", "kind": "verb", "what": "Pulls repeated UI into shared tokens and components.", "when": "Routed for `drift`: the same pattern copied 3+ times, raw values next to tokens, one-off components.", "how": "Structural tier, first in the chain; shared components change only behind a new prop that defaults to today's behaviour.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/extract.md"], "author": "pbakaus"}, {"id": "v-shape", "label": "shape", "kind": "verb", "what": "Plans UX/UI for a feature before code is written.", "when": "Dispatched by /super-board lint for feature tickets with undefined UX; never typed as a refine-loop problem.", "how": "Requires init's PRODUCT.md; a redesign need found in the loop goes to openQuestions instead.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/shape.md"], "author": "pbakaus"}, {"id": "v-init", "label": "init", "kind": "verb", "what": "Captures durable product context in PRODUCT.md.", "when": "Suggested by /impeccable when PRODUCT.md is missing; not run by the refine loop.", "how": "Shape and document require it; its context feeds live mode.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/init.md"], "author": "pbakaus"}, {"id": "v-document", "label": "document", "kind": "verb", "what": "Generates DESIGN.md from existing project code.", "when": "When DESIGN.md is missing; the refine loop reads DESIGN.md if present but never runs this.", "how": "Requires init; doctor feeds it when files go stale.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/document.md"], "author": "pbakaus"}, {"id": "v-live", "label": "live", "kind": "verb", "what": "Visual variant mode: pick elements in the browser and generate alternatives.", "when": "Interactive iteration only; the refine loop forbids it as a problem type.", "how": "Fed by init's context and calls polish on the chosen variant.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/live.md"], "author": "pbakaus"}, {"id": "v-overdrive", "label": "overdrive", "kind": "verb", "what": "Pushes a design past conventional limits for a wow factor.", "when": "Interactive only; the refine loop never types a problem as overdrive.", "how": "A redesign-scale command, so the checker sends such needs to openQuestions.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/overdrive.md"], "author": "pbakaus"}, {"id": "preflight", "label": "super-board-preflight.sh", "kind": "script", "what": "Builder pre-flight check: is a Ready card already done, already in progress, overlapping an open PR's files, or unclear?", "when": "Run once per batch of up to 5 Ready build cards by the wave's Pre-flight agent (or by the Builder as step 0 on the legacy backend), before any worktree.", "how": "Prints mechanical verdicts and near-miss candidates; the agent adds 'too big' and semantic matches, then returns proceed, hold, sequence or skipped. Hold and sequence move the card to Blocked with the block template; skipped leaves it in Ready.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-preflight.sh", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"]}, {"id": "pr-body", "label": "super-board-pr-body.sh", "kind": "script", "what": "Rewrites one marker block of a PR body (redcheck, status, problem, solution, ac, history, visual, risk) without clobbering other lanes' blocks.", "when": "Called by every lane when it updates its part of the PR, and with --skeleton by ui-refine-loop for a fresh body.", "how": "`--pr N --block <name> --expect-head <sha>` with --body-file or --append-file (history rows); `--time` prints local time in the config's timezone.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-pr-body.sh", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/writing-standard.md"]}, {"id": "needs-you", "label": "Blocked · 🙋 needs you", "kind": "board", "what": "A card parked in Blocked with the 🙋 template and the `needs-you` label: a step only a human may take. There is no separate column.", "when": "The merge gate exits 7 (merge_policy: money, auth, destructive schema, over 400 lines) or 8 (a migration the robot may not run, or a declared human step).", "how": "The comment opens \"🙋 Your turn on #N\" with the exact commands as checkboxes; a human merges it, or comments `done` / labels `needs-you:done` so the planner's resume list sends it back to Review.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/block-template.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"]}, {"id": "setup-py", "label": "super-board-setup.py", "kind": "script", "what": "The deterministic half of onboard: finds what is missing or old and fixes the must-haves, and handles boards and branches.", "when": "Run by onboard step 1 (check / fix), step 3 (board-rank, board-migrate, names) and step 4 (branch).", "how": "`fix` installs or refreshes skills, scripts, workflows, guard hooks and settings (via install.sh), removes super-refine / cleanup-wt / arch-loop folders, migrates config keys to v3, runs git init and adds Matt Pocock's skills, all backed up first. `board-migrate` adds missing columns and the three labels and moves Skipped cards to Done.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"]}, {"id": "agents-md-py", "label": "super-board-agents-md.py", "kind": "script", "what": "The deterministic half of the AGENTS.md step: detect, backup, the managed super-board block, the CLAUDE.md pointer, coverage and size checks.", "when": "Run by onboard step 5 to stage the merge and at step 8 to write it; install.sh refreshes the managed block on re-install.", "how": "The agent merges rules semantically (duplicates once, conflicts asked one by one); the script proves every rule unit maps to a line (`coverage`), keeps AGENTS.md ≤ 200 lines with one marker pair, and writes atomically.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-agents-md.py", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/agents-md-block.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md"]}, {"id": "agents-file", "label": "AGENTS.md + CLAUDE.md", "kind": "board", "what": "The project's instruction files: AGENTS.md as the single source of truth with a managed super-board block, and CLAUDE.md as `@AGENTS.md` plus Claude-only rules.", "when": "Written at onboard step 8 when Eric chose to move his rules (or only add the section); the block is rewritten on re-install.", "how": "The block sits between `<!-- super-board:begin -->` and `<!-- super-board:end -->`, rendered from agents-md-block.md with a Writing table that links the writing standard; nothing outside the markers is touched.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/agents-md-block.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md"]}, {"id": "settings-py", "label": "super-board-settings.py", "kind": "script", "what": "Merges hook blocks and permission allow rules into .claude/settings.json without losing anything.", "when": "Run by install.sh for the guard hooks, and by onboard step 6/8 for the permission lines and the protect-main hook.", "how": "`hooks <settings> <snippet>` and `allow <settings> <rules…>` keep every existing key, back the file up, write atomically, and leave an invalid settings.json untouched; `--dry-run` prints the diff onboard shows as \"N lines\".", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-settings.py"]}, {"id": "env-check", "label": "super-board-env-check.sh", "kind": "script", "what": "Says which env keys exist (present, empty or missing) without ever printing a value.", "when": "Run by onboard to detect SENTRY_AUTH_TOKEN, POSTHOG_PERSONAL_API_KEY or migration DB URLs, and allowed in permissions for runs.", "how": "Reads .env.local or .env itself and prints one word per key; guard-secrets lets a plain call through while still blocking cat, grep or source on dotenv files.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-env-check.sh", "https://github.com/EricTechPro/super-board/blob/main/hooks/guard-secrets.py"]}, {"id": "collect-custom", "label": "custom source fetcher", "kind": "script", "what": "The custom source: extra sources a project added in onboard (an http API, a CLI command, or an MCP server), stored in collect.custom[].", "when": "Run by onboard step 7 (classify, ping, add) and by /super-collect for every custom source (list, normalize).", "how": "`collect_custom.py` classifies the typed text, pings read-only before saving, refuses commands that look like they change something, and turns output into candidates with fp `custom|<name>|<key>`. MCP reads go through the agent and `normalize`.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/collect_custom.py"]}, {"id": "get-sh", "label": "get.sh", "kind": "script", "what": "One-line installer: `curl -fsSL …/get.sh | bash` fetches the latest super-board release and runs install.sh.", "when": "Eric (or a user) runs it in a project folder to install or upgrade; options --target, --ref, --no-helper-skills, and --no-hooks / --protect-main passed through.", "how": "Downloads the release tarball, runs install.sh, adds Matt Pocock's skills via `npx skills@latest add mattpocock/skills` unless told not to, and prints the next step once.", "source": ["https://github.com/EricTechPro/super-board/blob/main/get.sh"]}, {"id": "plugin-mkt", "label": "plugin marketplace install", "kind": "board", "what": "The Claude Code plugin form of the pack (marketplace.json + plugin.json): ships the seven skills only.", "when": "A user adds the marketplace and installs the plugin instead of running get.sh.", "how": "Skills carry the plugin prefix (/super-board:super-board onboard); onboard step 1 then installs the guard hooks, .claude/bin scripts and workflows a plugin cannot ship from the plugin's own copy.", "source": ["https://github.com/EricTechPro/super-board/blob/main/.claude-plugin/marketplace.json", "https://github.com/EricTechPro/super-board/blob/main/.claude-plugin/plugin.json"]}, {"id": "onboard-answers", "label": "onboard answers file", "kind": "board", "what": "`.claude/super-board/onboard-answers.json`: every onboard answer, saved the moment it is given (gitignored).", "when": "Written after each answer; read when onboard re-runs or resumes after a halt.", "how": "Atomic writes; `last_step` drives the \"Continue where you left off?\" screen, and a finished setup's values fill the step-8 table on re-run.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md"]}, {"id": "upgrade-json", "label": "upgrade record", "kind": "board", "what": "`.claude/super-board/upgrade.json`: the version an install replaced, so onboard knows to upgrade a 2.x setup.", "when": "Written by install.sh (or get.sh) when it finds an older install.", "how": "super-board-setup.py fix reads it and reports \"Upgraded for you\": old folders removed, config keys migrated, labels mapped, Skipped cards moved to Done.", "source": ["https://github.com/EricTechPro/super-board/blob/main/install.sh", "https://github.com/EricTechPro/super-board/blob/main/RELEASE-NOTES.md"]}, {"id": "git-sync", "label": "/git-sync", "kind": "public", "what": "Commits the working tree as one commit per logical change, merge-pulls, pushes the current branch without force, and reports what it did.", "when": "Eric runs /git-sync or says \"sync\", \"commit and push\" or \"pull and push\", usually at the end of a piece of work.", "how": "Stages each group by path (never `git add -A`), refuses secrets, writes the host's commit format or the writing standard, gates `supabase/` changes on a migration file and advisors, then `git pull --no-rebase` and `git push`. The default or a protected branch needs a yes.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/git-sync/SKILL.md"], "sublabel": "commit · pull · push", "opensView": "git-sync", "author": "EricTechPro"}], "edges": [{"id": "r-board-build", "from": "super-board", "to": "super-build", "label": "starts Build lane", "when": "a planned Ready card labelled feature or bug (or unlabelled) passes pre-flight"}, {"id": "r-board-qa", "from": "super-board", "to": "super-qa", "label": "starts QA lane", "when": "a card is in QA, or in Ready with the qa label (skips Building)"}, {"id": "r-board-review", "from": "super-board", "to": "super-review", "label": "starts Review lane", "when": "a card is in Review"}, {"id": "r-board-gh", "from": "super-board", "to": "gh-board", "label": "drains", "when": "every wave until drained or halted"}, {"id": "r-board-config", "from": "super-board", "to": "sb-config", "label": "reads config", "when": "onboard writes it; every run reads it"}, {"id": "r-collect-gh", "from": "super-collect", "to": "gh-board", "label": "files to Backlog", "when": "the verifier says file or needs-triage and the run is confirmed"}, {"id": "r-collect-config", "from": "super-collect", "to": "sb-config", "label": "reads collect block", "when": "every run, to resolve sources, window and board"}, {"id": "r-build-qa", "from": "super-build", "to": "super-qa", "label": "hands off", "when": "the draft PR is open and the card moved to QA"}, {"id": "r-qa-review", "from": "super-qa", "to": "super-review", "label": "hands off", "when": "every AC passes and evidence is committed; a fail sends the card back to Ready"}, {"id": "r-review-build", "from": "super-review", "to": "super-build", "label": "bounces [builder]", "when": "a code-side finding or an unfixed prior finding"}, {"id": "r-review-base", "from": "super-review", "to": "base-branch", "label": "merges via gate", "when": "review is clean, tests rerun green, and merge_policy lets the robot merge"}, {"id": "r-review-hooks", "from": "super-review", "to": "hooks", "label": "triggers cleanup-wt", "when": "the merge gate merged a PR and cleanup-wt is installed"}, {"id": "r-refine-base", "from": "ui-refine-loop", "to": "base-branch", "label": "opens draft PR", "when": "the loop stops; it pushes refine/<slug> only and never merges"}, {"id": "r-visual-base", "from": "visual", "to": "base-branch", "label": "reads git facts", "when": "recap mode, or any mode reading the repo"}, {"id": "r-refine-config", "from": "ui-refine-loop", "to": "sb-config", "label": "reads refine block", "when": "setup, when a super-board config exists"}, {"id": "run-claim", "from": "sb-run", "to": "gh-board", "label": "claims + drains", "when": "each wave: claims cards by bot_identity assignee after sweep/flag/stranded, until drained or halted"}, {"id": "sb-v-onboard", "from": "super-board", "to": "sb-onboard", "label": "routes onboard", "when": "Eric runs /super-board onboard"}, {"id": "sb-v-lint", "from": "super-board", "to": "sb-lint", "label": "routes lint", "when": "Eric runs /super-board lint"}, {"id": "sb-v-status", "from": "super-board", "to": "sb-status", "label": "routes status", "when": "Eric runs /super-board status"}, {"id": "sb-v-run", "from": "super-board", "to": "sb-run", "label": "routes run", "when": "Eric runs /super-board run, or asks to resume"}, {"id": "sb-v-stop", "from": "super-board", "to": "sb-stop", "label": "routes stop", "when": "Eric runs /super-board stop or says pause"}, {"id": "sb-onb-config", "from": "sb-onboard", "to": "sb-config", "label": "8 · writes config", "when": "step 8, after \"Write everything\", with the active pointer"}, {"id": "sb-onb-gh", "from": "sb-onboard", "to": "gh-board", "label": "3 · picks board", "when": "step 3: reuse the best-ranked board (missing columns and labels added) or create one"}, {"id": "sb-lint-gh", "from": "sb-lint", "to": "gh-board", "label": "flags, labels cards", "when": "an active issue fails a criterion; proposed labels and AC fixes apply on approve"}, {"id": "sb-status-gh", "from": "sb-status", "to": "gh-board", "label": "reads counts", "when": "every status call; read-only"}, {"id": "sb-stop-gh", "from": "sb-stop", "to": "gh-board", "label": "releases claims", "when": "posts stopped-mid-flight comments and strips assignees"}, {"id": "lint-grill", "from": "sb-lint", "to": "grilling", "label": "grills Eric", "when": "an issue needs a rethink (criteria 10, 11) or has several readings (12)"}, {"id": "lint-diag", "from": "sb-lint", "to": "diagnosing-bugs", "label": "drafts repro", "when": "a bug ticket has no repro steps"}, {"id": "lint-shape", "from": "sb-lint", "to": "v-shape", "label": "shapes UX", "when": "a feature ticket has undefined UX"}, {"id": "lint-clarify", "from": "sb-lint", "to": "v-clarify", "label": "fixes copy ACs", "when": "an AC is about copy, microcopy or an error message"}, {"id": "lint-qatp", "from": "sb-lint", "to": "qa-test-planner", "label": "plans tests", "when": "a QA ticket has a vague test surface"}, {"id": "run-plan", "from": "sb-run", "to": "wave-plan", "label": "plans wave", "when": "after the rate guard and the usage guard pass; resume list included"}, {"id": "run-launch", "from": "sb-run", "to": "wave-js", "label": "launches workflow", "when": "one or more cards were claimed"}, {"id": "wave-build", "from": "wave-js", "to": "super-build", "label": "runs Build lane", "when": "card enters at Ready (feature, bug or no label) and pre-flight said proceed"}, {"id": "wave-qa", "from": "wave-js", "to": "super-qa", "label": "runs QA lane", "when": "card enters at QA, or Ready with the qa label"}, {"id": "wave-review", "from": "wave-js", "to": "super-review", "label": "runs Review lane", "when": "card enters at Review; always on the session model"}, {"id": "review-gate", "from": "super-review", "to": "merge-gate", "label": "calls merge gate", "when": "clean review, threads resolved, truth score over threshold, tests green"}, {"id": "gate-cleanup", "from": "merge-gate", "to": "cleanup-wt", "label": "runs post-merge", "when": "the merge landed and .claude/hooks/cleanup-wt.py exists"}, {"id": "gate-base", "from": "merge-gate", "to": "base-branch", "label": "squash-merges", "when": "policy allows the robot, the branch still passes against the current base inside the lock, allowed migrations ran"}, {"id": "run-manifest-e", "from": "sb-run", "to": "run-manifest", "label": "appends manifest", "when": "reconcile, once the wave returns; claims are released too"}, {"id": "b-pony", "from": "super-build", "to": "ponytail", "label": "climbs ladder first", "when": "every ticket, before the first line of code"}, {"id": "b-impl", "from": "super-build", "to": "implement", "label": "routes feature", "when": "type label feature or ux (then tdd, codebase-design)"}, {"id": "b-diag", "from": "super-build", "to": "diagnosing-bugs", "label": "routes bug", "when": "type label bug (then tdd)"}, {"id": "b-design", "from": "super-build", "to": "codebase-design", "label": "routes refactor", "when": "type label refactor or tech-debt, or feature"}, {"id": "b-tdd", "from": "super-build", "to": "tdd", "label": "builds test-first", "when": "every ticket except docs"}, {"id": "b-docs", "from": "super-build", "to": "context7", "label": "reads current docs", "when": "the ticket touches a third-party surface, an upgrade, or auth/billing"}, {"id": "b-verify", "from": "super-build", "to": "verification", "label": "proves before commit", "when": "before the final commit"}, {"id": "b-review", "from": "super-build", "to": "code-review", "label": "reviews own diff", "when": "once, against the merge-base, before the final commit"}, {"id": "b-conflict", "from": "super-build", "to": "resolving-merge-conflicts", "label": "resolves conflict", "when": "a live conflict, e.g. after merge-gate exit 2 or 5"}, {"id": "b-askmatt", "from": "super-build", "to": "ask-matt", "label": "asks the router", "when": "the right flow is unclear"}, {"id": "b-gh", "from": "super-build", "to": "gh-board", "label": "moves card to QA", "when": "draft PR opened and comments posted"}, {"id": "q-tdd", "from": "super-qa", "to": "tdd", "label": "writes gaps red-first", "when": "the test-gap check finds a High gap"}, {"id": "q-tddv2", "from": "super-qa", "to": "tdd-v2", "label": "picks the rung", "when": "the repo has tdd-v2 (used instead of plain tdd)"}, {"id": "q-diag", "from": "super-qa", "to": "diagnosing-bugs", "label": "diagnoses failures", "when": "a spec goes red and the cause is unclear"}, {"id": "q-verify", "from": "super-qa", "to": "verification", "label": "proves the pass", "when": "before a pass handoff"}, {"id": "q-askmatt", "from": "super-qa", "to": "ask-matt", "label": "asks the router", "when": "the right flow is unclear"}, {"id": "q-strat", "from": "super-qa", "to": "testing-strategy", "label": "judges coverage", "when": "deciding what is worth testing per component type"}, {"id": "q-vitest", "from": "super-qa", "to": "vitest", "label": "writes unit tests", "when": "the ladder stops at unit or integration in TS/JS"}, {"id": "q-pw", "from": "super-qa", "to": "playwright-bp", "label": "writes e2e specs", "when": "the browser is the thing that broke, or standalone crawl specs"}, {"id": "q-gh", "from": "super-qa", "to": "gh-board", "label": "moves card", "when": "pass: QA to Review; fail: QA to Ready (loop:rebuild-N); a qa card first moves itself Ready to QA"}, {"id": "q-filebug", "from": "super-qa", "to": "file-bug", "label": "files red spec", "when": "a standalone crawl finds a failing spec, or a qa card finds a defect tests alone cannot fix"}, {"id": "filebug-qaboard", "from": "file-bug", "to": "qa-board", "label": "sets Status Bug", "when": "the body passes validation"}, {"id": "v-cr", "from": "super-review", "to": "code-review", "label": "runs two-axis review", "when": "every card, with the merge-base as the fixed point"}, {"id": "v-design", "from": "super-review", "to": "codebase-design", "label": "reads diff shape", "when": "step 2, and when writing every deepening opportunity"}, {"id": "v-pony", "from": "super-review", "to": "ponytail-review", "label": "hunts over-engineering", "when": "step 3, on the merge-base diff; inline ladder if absent"}, {"id": "v-refactor", "from": "super-review", "to": "file-refactor", "label": "files deepening card", "when": "the diff is correct but leaves a shallow module or misplaced seam"}, {"id": "v-gh", "from": "super-review", "to": "gh-board", "label": "bounces or closes", "when": "unresolved [builder]/[qa] threads bounce; a confirmed merge moves the card to Done"}, {"id": "c-sentry", "from": "super-collect", "to": "collect-sentry", "label": "fetches sentry", "when": "sentry is requested or enabled in collect.sources"}, {"id": "c-posthog", "from": "super-collect", "to": "collect-posthog", "label": "fetches posthog", "when": "posthog is requested or enabled"}, {"id": "c-github", "from": "super-collect", "to": "gh-issues", "label": "reads github", "when": "github is requested or enabled"}, {"id": "c-prs", "from": "super-collect", "to": "collect-prs", "label": "fetches merged PRs", "when": "prs is requested or enabled"}, {"id": "c-ica", "from": "super-collect", "to": "improve-codebase-architecture", "label": "finds refactors", "when": "architecture source; read-only finder, findings only"}, {"id": "c-design", "from": "super-collect", "to": "codebase-design", "label": "finds refactors", "when": "architecture source when improve-codebase-architecture is not installed"}, {"id": "c-audit", "from": "super-collect", "to": "ponytail-audit", "label": "finds bloat", "when": "architecture source, always alongside the finder"}, {"id": "c-file", "from": "super-collect", "to": "collect-file", "label": "files if verified", "when": "one fresh verifier per candidate says file or needs-triage (duplicate gets a comment)"}, {"id": "file-gh", "from": "collect-file", "to": "gh-board", "label": "files to Backlog", "when": "--yes or confirmed dry-run; dedupe by exact fingerprint"}, {"id": "u-grill", "from": "ui-refine-loop", "to": "grilling", "label": "grills Eric", "when": "after reading the target's code; at most 10 questions in waves"}, {"id": "u-taste", "from": "ui-refine-loop", "to": "taste-file", "label": "commits taste", "when": "answers in hand; first commit on refine/<slug>"}, {"id": "u-imp", "from": "ui-refine-loop", "to": "impeccable", "label": "detects + loads", "when": "setup (detect, context) and the finish reviewer's craft-floor verdict pass"}, {"id": "u-shoot", "from": "ui-refine-loop", "to": "shoot", "label": "takes shots", "when": "round 0 at setup, then AFTER shots each fix round"}, {"id": "u-critique", "from": "ui-refine-loop", "to": "v-critique", "label": "design reviewer runs", "when": "every check, isolated from the detector"}, {"id": "u-detect", "from": "ui-refine-loop", "to": "imp-detect", "label": "detector runs", "when": "every check, in parallel with the design reviewer"}, {"id": "u-detect-audit", "from": "imp-detect", "to": "v-audit", "label": "feeds audit", "when": "same detector sub-agent; verified hits become problems"}, {"id": "u-crit-verbs", "from": "v-critique", "to": "verbs-group", "label": "checker ranks, routes", "when": "checker merges A and B into at most 8 typed problems"}, {"id": "u-audit-verbs", "from": "v-audit", "to": "verbs-group", "label": "checker ranks, routes", "when": "same merge; the fixer chains the routed verbs"}, {"id": "u-verbs-polish", "from": "verbs-group", "to": "v-polish", "label": "then polish last", "when": "every fix round, once, over all touched files"}, {"id": "u-ledger", "from": "ui-refine-loop", "to": "refine-ledger", "label": "appends ledger", "when": "after every check; stop rules read it"}, {"id": "u-human", "from": "ui-refine-loop", "to": "humanizer", "label": "humanizes PR", "when": "finish, after the finish reviewer graded every fix"}, {"id": "u-pr", "from": "ui-refine-loop", "to": "draft-pr", "label": "opens draft PR", "when": "finish; pushes refine/<slug> only"}, {"id": "iv-v-distill", "from": "verbs-group", "to": "v-distill", "label": "routes cluttered", "when": "a problem is typed cluttered"}, {"id": "iv-v-extract", "from": "verbs-group", "to": "v-extract", "label": "routes drift", "when": "a problem is typed drift"}, {"id": "iv-v-layout", "from": "verbs-group", "to": "v-layout", "label": "routes spacing", "when": "a problem is typed spacing-hierarchy"}, {"id": "iv-v-adapt", "from": "verbs-group", "to": "v-adapt", "label": "routes responsive", "when": "a problem is typed responsive"}, {"id": "iv-v-typeset", "from": "verbs-group", "to": "v-typeset", "label": "routes typography", "when": "a problem is typed typography"}, {"id": "iv-v-colorize", "from": "verbs-group", "to": "v-colorize", "label": "routes dull color", "when": "typed dull-color and the direction asks for more"}, {"id": "iv-v-quieter", "from": "verbs-group", "to": "v-quieter", "label": "routes too-loud", "when": "a problem is typed too-loud"}, {"id": "iv-v-bolder", "from": "verbs-group", "to": "v-bolder", "label": "routes bland", "when": "typed bland and the direction asks for more"}, {"id": "iv-v-clarify", "from": "verbs-group", "to": "v-clarify", "label": "routes confusing copy", "when": "a problem is typed confusing-copy"}, {"id": "iv-v-harden", "from": "verbs-group", "to": "v-harden", "label": "routes edge cases, a11y", "when": "a problem is typed edge-cases or accessibility"}, {"id": "iv-v-onboard", "from": "verbs-group", "to": "v-onboard", "label": "routes first-run", "when": "a problem is typed first-run-empty"}, {"id": "iv-late-verbs", "from": "verbs-group", "to": "late-verbs", "label": "routes motion, perf", "when": "a problem is typed needs-motion, personality or performance"}, {"id": "lv-animate", "from": "late-verbs", "to": "v-animate", "label": "routes needs-motion", "when": "typed needs-motion and the brief asks for motion"}, {"id": "lv-delight", "from": "late-verbs", "to": "v-delight", "label": "routes personality", "when": "typed personality and the brief asks for character"}, {"id": "lv-optimize", "from": "late-verbs", "to": "v-optimize", "label": "routes performance", "when": "a problem is typed performance"}, {"id": "lv-del-anim", "from": "v-delight", "to": "v-animate", "label": "calls", "when": "delight needs motion for its touches"}, {"id": "lv-polish", "from": "late-verbs", "to": "v-polish", "label": "then polish last", "when": "always, after the last tier"}, {"id": "im-init", "from": "impeccable", "to": "v-init", "label": "suggests init", "when": "PRODUCT.md is missing"}, {"id": "im-critique", "from": "impeccable", "to": "v-critique", "label": "suggests critique", "when": "an existing UI needs a review"}, {"id": "im-audit", "from": "impeccable", "to": "v-audit", "label": "offers audit", "when": "technical quality needs checking"}, {"id": "im-shape", "from": "impeccable", "to": "v-shape", "label": "offers shape", "when": "planning UX before code"}, {"id": "im-live", "from": "impeccable", "to": "v-live", "label": "offers live", "when": "interactive browser iteration"}, {"id": "im-overdrive", "from": "impeccable", "to": "v-overdrive", "label": "offers overdrive", "when": "an ambitious, unconventional effect is wanted"}, {"id": "im-verbs", "from": "impeccable", "to": "verbs-group", "label": "offers refine verbs", "when": "fix, refine and enhance work on an existing UI"}, {"id": "im-shape-init", "from": "v-shape", "to": "v-init", "label": "requires", "when": "always; shape needs PRODUCT.md"}, {"id": "im-doc-init", "from": "v-document", "to": "v-init", "label": "requires", "when": "always; document needs PRODUCT.md"}, {"id": "im-audit-harden", "from": "v-audit", "to": "v-harden", "label": "suggests", "when": "audit found edge-case or accessibility gaps"}, {"id": "im-audit-opt", "from": "v-audit", "to": "v-optimize", "label": "suggests", "when": "audit found performance gaps"}, {"id": "im-crit-polish", "from": "v-critique", "to": "v-polish", "label": "feeds", "when": "critique findings feed the final pass"}, {"id": "im-live-polish", "from": "v-live", "to": "v-polish", "label": "calls", "when": "a variant was chosen"}, {"id": "vi-py", "from": "visual", "to": "visual-py", "label": "detects, renders", "when": "every run: detect with no argument, facts in recap, render after data.json"}, {"id": "vi-py-base", "from": "visual-py", "to": "base-branch", "label": "reads git diff", "when": "recap mode collects files, +/- and hunks from git"}, {"id": "h-wt", "from": "claude-settings", "to": "guard-worktree-path", "label": "PreToolUse Bash", "when": "every shell command"}, {"id": "h-del", "from": "claude-settings", "to": "guard-delete-outside", "label": "PreToolUse Bash", "when": "every shell command"}, {"id": "h-sec", "from": "claude-settings", "to": "guard-secrets", "label": "Pre Bash|Read|Grep", "when": "every read, grep or shell command"}, {"id": "h-key", "from": "claude-settings", "to": "guard-key-literals", "label": "Pre/PostToolUse writes", "when": "Edit/MultiEdit/Write/NotebookEdit (and Bash before)"}, {"id": "h-session", "from": "claude-settings", "to": "cleanup-wt", "label": "SessionStart --auto", "when": "a base branch tip moved since the last session"}, {"id": "h-push", "from": "install-sh", "to": "guard-protected-push", "label": "--protect-main wires", "when": "install with --protect-main, or onboard's yes"}, {"id": "h-gate", "from": "hooks", "to": "gate-skill-evals", "label": "dev-only Stop", "when": "only in the pack repo or EricOS; a skill changed without a newer eval"}, {"id": "h-readme", "from": "hooks", "to": "readme-sync", "label": "dev-only sync", "when": "edits or commits under skills/ in the pack repo"}, {"id": "tdd-design", "from": "tdd", "to": "codebase-design", "label": "borrows vocabulary", "when": "the interface or seam shape is itself in question"}, {"id": "tdd-cr", "from": "tdd", "to": "code-review", "label": "defers refactor to", "when": "refactoring belongs to review, not the red-green loop"}, {"id": "tddv2-tdd", "from": "tdd-v2", "to": "tdd", "label": "defers discipline to", "when": "always; tdd owns seams and red-before-green"}, {"id": "impl-tddv2", "from": "implement", "to": "tdd-v2", "label": "builds at the rung", "when": "where possible, at pre-agreed seams"}, {"id": "impl-tdd", "from": "implement", "to": "tdd", "label": "red-green under it", "when": "every slice"}, {"id": "impl-cr", "from": "implement", "to": "code-review", "label": "reviews when done", "when": "once the work is done, before committing"}, {"id": "cr-setup", "from": "code-review", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "docs/agents/issue-tracker.md is missing"}, {"id": "db-ica", "from": "diagnosing-bugs", "to": "improve-codebase-architecture", "label": "hands off post-mortem", "when": "the fix is in and the real finding is a missing seam"}, {"id": "ica-design", "from": "improve-codebase-architecture", "to": "codebase-design", "label": "uses vocabulary", "when": "every suggestion, and design-it-twice for alternatives"}, {"id": "ica-grill", "from": "improve-codebase-architecture", "to": "grilling", "label": "grills the pick", "when": "the user picks a candidate (skipped by super-collect)"}, {"id": "ica-dm", "from": "improve-codebase-architecture", "to": "domain-modeling", "label": "updates CONTEXT.md", "when": "a new term or a rejected candidate worth an ADR"}, {"id": "am-grill-with-docs", "from": "ask-matt", "to": "grill-with-docs", "label": "1 · sharpens idea", "when": "start of the main flow, in a working directory"}, {"id": "am-handoff", "from": "ask-matt", "to": "handoff", "label": "bridges detours", "when": "a question needs a prototype, or a phase boundary"}, {"id": "am-prototype", "from": "ask-matt", "to": "prototype", "label": "answers by code", "when": "a question needs a runnable answer"}, {"id": "am-to-spec", "from": "ask-matt", "to": "to-spec", "label": "multi-session: spec", "when": "the build spans several sessions"}, {"id": "am-to-tickets", "from": "ask-matt", "to": "to-tickets", "label": "splits into tickets", "when": "after to-spec, with blocking edges"}, {"id": "am-implement", "from": "ask-matt", "to": "implement", "label": "builds each ticket", "when": "every ticket, or in place for a small build"}, {"id": "am-tdd", "from": "ask-matt", "to": "tdd", "label": "test-first alone", "when": "a concrete behaviour without a full spec"}, {"id": "am-code-review", "from": "ask-matt", "to": "code-review", "label": "reviews a branch", "when": "reviewing against a fixed point"}, {"id": "am-triage", "from": "ask-matt", "to": "triage", "label": "on-ramp: triage", "when": "raw bugs and requests pile up"}, {"id": "am-diagnosing-bugs", "from": "ask-matt", "to": "diagnosing-bugs", "label": "on-ramp: broken", "when": "something is broken and resists a first look"}, {"id": "am-wayfinder", "from": "ask-matt", "to": "wayfinder", "label": "on-ramp: foggy", "when": "a huge effort too big for one session"}, {"id": "am-improve-codebase-architecture", "from": "ask-matt", "to": "improve-codebase-architecture", "label": "codebase health", "when": "a spare moment for upkeep"}, {"id": "am-domain-modeling", "from": "ask-matt", "to": "domain-modeling", "label": "vocabulary", "when": "the words, not the process, are the problem"}, {"id": "gwd-grill", "from": "grill-with-docs", "to": "grilling", "label": "runs grilling", "when": "every session"}, {"id": "gwd-dm", "from": "grill-with-docs", "to": "domain-modeling", "label": "keeps glossary", "when": "a term is fuzzy or a decision is hard to reverse"}, {"id": "ts-setup", "from": "to-spec", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker and triage labels are not configured"}, {"id": "tt-setup", "from": "to-tickets", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker and triage labels are not configured"}, {"id": "tr-grill", "from": "triage", "to": "grilling", "label": "grills if needed", "when": "an issue is too unclear to brief"}, {"id": "tr-dm", "from": "triage", "to": "domain-modeling", "label": "checks vocabulary", "when": "writing the agent-ready brief"}, {"id": "tr-setup", "from": "triage", "to": "setup-matt-pocock-skills", "label": "needs label map", "when": "the triage label mapping is missing"}, {"id": "wf-grill", "from": "wayfinder", "to": "grilling", "label": "names destination", "when": "first step, and every grilling ticket"}, {"id": "wf-dm", "from": "wayfinder", "to": "domain-modeling", "label": "pins terms", "when": "alongside every grilling session"}, {"id": "wf-proto", "from": "wayfinder", "to": "prototype", "label": "raises fidelity", "when": "a prototype ticket needs UI or logic code"}, {"id": "wf-setup", "from": "wayfinder", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker is not configured"}, {"id": "r-install-hooks", "from": "install-sh", "to": "hooks", "label": "copies guards", "when": "install without --no-hooks (--protect-main adds the push guard)"}, {"id": "onb-answers", "from": "sb-onboard", "to": "onboard-answers", "label": "saves each answer", "when": "the moment each answer is given; resume reads it"}, {"id": "onb-setup", "from": "sb-onboard", "to": "setup-py", "label": "1 · Checks: fix", "when": "every run, first; asks only for system tools or sign-ins"}, {"id": "setup-install", "from": "setup-py", "to": "install-sh", "label": "fix re-runs install", "when": "skills, scripts, workflows, guards or settings entries are missing or old"}, {"id": "setup-gh", "from": "setup-py", "to": "gh-board", "label": "board-rank, migrate", "when": "step 3 (or step 1 on an upgrade): ranks boards, adds columns and labels"}, {"id": "onb-branch", "from": "sb-onboard", "to": "base-branch", "label": "4 · picks base", "when": "step 4; no staging → offers `git push origin main:staging`"}, {"id": "onb-agents", "from": "sb-onboard", "to": "agents-md-py", "label": "5 · AGENTS.md", "when": "step 5: move CLAUDE.md rules, or only add the section"}, {"id": "agents-write", "from": "agents-md-py", "to": "agents-file", "label": "writes block, pointer", "when": "step 8 write, after backup and coverage pass"}, {"id": "onb-settings", "from": "sb-onboard", "to": "settings-py", "label": "6 · Policies", "when": "step 6 answers: safe defaults and N permission lines"}, {"id": "settings-write", "from": "settings-py", "to": "claude-settings", "label": "merges entries", "when": "install (hooks) or onboard step 8 (allow lines)"}, {"id": "settings-push", "from": "settings-py", "to": "guard-protected-push", "label": "wires push guard", "when": "Policies said block pushes to main and the script is installed"}, {"id": "onb-env", "from": "sb-onboard", "to": "env-check", "label": "checks key names", "when": "silent detect and step 7, for Sentry, PostHog and DB keys"}, {"id": "onb-custom", "from": "sb-onboard", "to": "collect-custom", "label": "7 · adds a source", "when": "\"➕ Add another source\": classify, ping read-only, add on ✅"}, {"id": "custom-config", "from": "collect-custom", "to": "sb-config", "label": "saves custom[]", "when": "the ping succeeded; staged until step 8"}, {"id": "lint-tickets", "from": "sb-lint", "to": "to-tickets", "label": "splits too-big", "when": "criterion 15: likely over ~400 changed lines or many areas"}, {"id": "wave-preflight", "from": "wave-js", "to": "preflight", "label": "pre-flights batches", "when": "Ready cards the Builder would take, up to 5 per agent"}, {"id": "preflight-gh", "from": "preflight", "to": "gh-board", "label": "holds to Blocked", "when": "already done, in progress, overlapping, unclear or too big"}, {"id": "gate-needsyou", "from": "merge-gate", "to": "needs-you", "label": "parks (exit 7/8)", "when": "merge_policy says a human merges, or a migration/human step is needed"}, {"id": "needsyou-plan", "from": "needs-you", "to": "wave-plan", "label": "resumes on done", "when": "a human comments done or labels needs-you:done"}, {"id": "super-build-prbody", "from": "super-build", "to": "pr-body", "label": "writes PR blocks", "when": "opening the draft PR and on every rebuild"}, {"id": "super-build-human", "from": "super-build", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "super-qa-prbody", "from": "super-qa", "to": "pr-body", "label": "ticks ac, visual", "when": "every pass or fail handoff"}, {"id": "super-qa-human", "from": "super-qa", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "super-review-prbody", "from": "super-review", "to": "pr-body", "label": "updates status", "when": "after a merge (✅ Merged) or a block"}, {"id": "super-review-human", "from": "super-review", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "review-needsyou", "from": "super-review", "to": "needs-you", "label": "posts 🙋 checklist", "when": "the merge gate exits 7 or 8"}, {"id": "c-custom", "from": "super-collect", "to": "collect-custom", "label": "runs custom sources", "when": "a custom source is requested by name or enabled in collect.sources"}, {"id": "u-prbody", "from": "ui-refine-loop", "to": "pr-body", "label": "builds PR body", "when": "finish: --skeleton marker blocks for the draft PR"}, {"id": "install-settings", "from": "install-sh", "to": "settings-py", "label": "merges hook block", "when": "install without --no-hooks"}, {"id": "secrets-envcheck", "from": "guard-secrets", "to": "env-check", "label": "allows plain call", "when": "a single env-check call with no pipe, chain or redirect"}, {"id": "get-install", "from": "get-sh", "to": "install-sh", "label": "runs install", "when": "after downloading the release tarball"}, {"id": "plugin-onboard", "from": "plugin-mkt", "to": "sb-onboard", "label": "needs onboard", "when": "a plugin ships skills only; onboard step 1 adds the rest"}, {"id": "install-upgrade", "from": "install-sh", "to": "upgrade-json", "label": "records old version", "when": "an older super-board install was found"}, {"id": "upgrade-setup", "from": "upgrade-json", "to": "setup-py", "label": "triggers upgrade", "when": "onboard step 1 runs fix and finds the record"}, {"id": "r-gitsync-base", "from": "git-sync", "to": "base-branch", "label": "pulls, pushes", "when": "every run; a push to the default or a protected branch waits for a yes"}, {"id": "gs-base", "from": "git-sync", "to": "base-branch", "label": "merge-pulls, pushes", "when": "`git pull --no-rebase`, then `git push`; never force"}, {"id": "gs-conflict", "from": "git-sync", "to": "resolving-merge-conflicts", "label": "resolves conflict", "when": "the pull conflicts and the skill is installed; otherwise hunk by hunk"}, {"id": "gs-push", "from": "git-sync", "to": "guard-protected-push", "label": "push checked by", "when": "the opt-in push guard is installed"}], "views": [{"id": "root", "parent": null, "title": "super-board pack", "caption": "Collect verified tickets into the board; the board contains Build → QA → Review. UI refinement, visuals and Git sync are standalone skills. Open a family or step for its tools and policies.", "nodeIds": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "ui-refine-loop", "visual", "git-sync"], "edges": [{"from": "super-collect", "to": "super-board", "label": "Backlog → lint"}, {"from": "super-board", "to": "super-build", "label": "Ready cards"}, "r-build-qa", "r-qa-review", {"from": "super-review", "to": "super-collect", "label": "review done → collect the next tickets", "kind": "feeds", "when": "the board drains; /super-collect files the next verified tickets into Backlog"}], "lanes": false, "layout": {"super-collect": [0, 0], "super-board": [1, 0], "super-build": [2, 0], "super-qa": [3, 0], "super-review": [4, 0], "ui-refine-loop": [5, 0], "visual": [5, 1], "git-sync": [5, 2]}, "nodeOverrides": {"super-collect": {"verbs": [], "sublabel": "Find verified tickets", "emphasis": true}, "super-board": {"verbs": [], "sublabel": "Run the board", "emphasis": true}, "ui-refine-loop": {"verbs": [], "sublabel": "Refine a page", "emphasis": true}, "visual": {"verbs": [], "sublabel": "Draw one visual", "emphasis": true}, "super-build": {"emphasis": true}, "super-qa": {"emphasis": true}, "super-review": {"emphasis": true}, "git-sync": {"verbs": [], "sublabel": "Commit · pull · push", "emphasis": true}}, "containers": [{"id": "collect-family", "label": "/super-collect · intake feeds the board", "nodeIds": ["super-collect"]}, {"id": "board-family", "parent": "collect-family", "label": "/super-board · Build → QA → Review", "nodeIds": ["super-board", "super-build", "super-qa", "super-review"]}], "browserOrder": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "ui-refine-loop", "visual", "git-sync", "hooks", "install"], "intake": [{"label": "Sentry", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMzNjJENTkiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+U2VudHJ5PC90aXRsZT48cGF0aCBkPSJNMTMuOTEgMi41MDVjLS44NzMtMS40NDgtMi45NzItMS40NDgtMy44NDQgMEw2LjkwNCA3LjkyYTE1LjQ3OCAxNS40NzggMCAwIDEgOC41MyAxMi44MTFoLTIuMjIxQTEzLjMwMSAxMy4zMDEgMCAwIDAgNS43ODQgOS44MTRsLTIuOTI2IDUuMDZhNy42NSA3LjY1IDAgMCAxIDQuNDM1IDUuODQ4SDIuMTk0YS4zNjUuMzY1IDAgMCAxLS4yOTgtLjUzNGwxLjQxMy0yLjQwMmE1LjE2IDUuMTYgMCAwIDAtMS42MTQtLjkxM0wuMjk2IDE5LjI3NWEyLjE4MiAyLjE4MiAwIDAgMCAuODEyIDIuOTk5IDIuMjQgMi4yNCAwIDAgMCAxLjA4Ni4yODhoNi45ODNhOS4zMjIgOS4zMjIgMCAwIDAtMy44NDUtOC4zMThsMS4xMS0xLjkyMmExMS40NyAxMS40NyAwIDAgMSA0Ljk1IDEwLjI0aDUuOTE1YTE3LjI0MiAxNy4yNDIgMCAwIDAtNy44ODUtMTUuMjhsMi4yNDQtMy44NDVhLjM3LjM3IDAgMCAxIC41MDQtLjEzYy4yNTUuMTQgOS43NSAxNi43MDggOS45MjggMTYuOWEuMzY1LjM2NSAwIDAgMS0uMzI3LjU0M2gtMi4yODdjLjAyOS42MTIuMDI5IDEuMjIzIDAgMS44MzFoMi4yOTdhMi4yMDYgMi4yMDYgMCAwIDAgMS45MjItMy4zMXoiLz48L3N2Zz4=", "to": "super-collect"}, {"label": "PostHog", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMwMDAwMDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+UG9zdEhvZzwvdGl0bGU+PHBhdGggZD0iTTkuODU0IDE0LjUgNSA5LjY0Ny44NTQgNS41QS41LjUgMCAwIDAgMCA1Ljg1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ni4zNTNMNSAxMy42NDdsLjE0Ny4xNDZMOS44NTQgMTguNWwuMTQ2LjE0N3YtLjA0OWMuMDY1LjAzLjEzNC4wNDkuMjA3LjA0OWgyLjU4NmEuNS41IDAgMCAwIC4zNTMtLjg1NEw5Ljg1NCAxNC41em0wLTUtNC00YS40ODcuNDg3IDAgMCAwLS40MDktLjE0NC41MTUuNTE1IDAgMCAwLS4zNTYuMjEuNDkzLjQ5MyAwIDAgMC0uMDg5LjI4OFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsOSA5YS41LjUgMCAwIDAgLjg1My0uMzU0di0yLjU4NWEuNS41IDAgMCAwLS4xNDYtLjM1NGwtNS01em0xLTRhLjUuNSAwIDAgMC0uODU0LjM1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsNCA0YS41LjUgMCAwIDAgLjg1My0uMzU0VjkuODU0YS41LjUgMCAwIDAtLjE0Ni0uMzU0bC00LTR6bTEyLjY0NyAxMS41MTVhMy44NjMgMy44NjMgMCAwIDEtMi4yMzItMS4xbC00LjcwOC00LjcwN2EuNS41IDAgMCAwLS44NTQuMzU0djYuNTg1YS41LjUgMCAwIDAgLjUuNUgyMy41YS41LjUgMCAwIDAgLjUtLjV2LS42YzAtLjI3Ni0uMjI1LS40OTctLjQ5OS0uNTMyem0tNS4zOTQuMDMyYS44LjggMCAxIDEgMC0xLjYuOC44IDAgMCAxIDAgMS42ek0uODU0IDE1LjVhLjUuNSAwIDAgMC0uODU0LjM1NHYyLjI5M2EuNS41IDAgMCAwIC41LjVoMi4yOTNjLjIyMiAwIC4zOS0uMTM1LjQ2Mi0uMzA5YS40OTMuNDkzIDAgMCAwLS4xMDktLjU0NUwuODU0IDE1LjUwMXpNNSAxNC42NDcuODU0IDEwLjVhLjUuNSAwIDAgMC0uODU0LjM1M3YyLjU4NmEuNS41IDAgMCAwIC4xNDYuMzUzTDQuODU0IDE4LjVsLjE0Ni4xNDdoMi43OTNhLjUuNSAwIDAgMCAuMzUzLS44NTRMNSAxNC42NDd6Ii8+PC9zdmc+", "to": "super-collect"}, {"label": "GitHub", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "super-collect"}], "tour": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "super-collect"]}, {"id": "super-board", "parent": "root", "title": "/super-board · five verbs", "caption": "Onboard sets up; lint makes cards ready; run delegates the lanes. Status inspects a run; stop halts it.", "nodeIds": ["super-board", "sb-onboard", "sb-lint", "sb-status", "sb-run", "sb-stop"], "edges": ["sb-v-onboard", "sb-v-lint", "sb-v-status", "sb-v-run", "sb-v-stop"], "lanes": [{"title": "Prepare", "nodeIds": ["sb-onboard", "sb-lint"]}, {"title": "Run", "nodeIds": ["sb-run"]}, {"title": "Control", "nodeIds": ["sb-status", "sb-stop"]}], "nodeOverrides": {"super-board": {"label": "/super-board", "verbs": [], "sublabel": "Five verbs", "emphasis": true}, "sb-onboard": {"label": "onboard", "verbs": [], "sublabel": "Set up the project", "emphasis": true}, "sb-lint": {"label": "lint", "verbs": [], "sublabel": "Check ticket readiness", "emphasis": true}, "sb-run": {"label": "run", "verbs": [], "sublabel": "Delegate build · QA · review", "emphasis": true}, "sb-status": {"label": "status", "verbs": [], "sublabel": "Inspect the run", "emphasis": true}, "sb-stop": {"label": "stop", "verbs": [], "sublabel": "Halt the run", "emphasis": true}}, "browserOrder": ["super-build", "super-qa", "super-review", "sb-onboard", "sb-lint", "super-board-run", "sb-status", "sb-stop"]}, {"id": "sb-lint", "parent": "super-board", "title": "/super-board lint · Phase 4 routing", "caption": "Interactive-only skills live here, never inside an unattended worker. Ticket-format fixes (criteria 16–18) and catch-alls get an inline draft.", "nodeIds": ["sb-lint", "grilling", "diagnosing-bugs", "v-shape", "v-clarify", "qa-test-planner", "gh-board", "to-tickets"], "edges": ["lint-grill", "lint-diag", "lint-shape", "lint-clarify", "lint-qatp", "sb-lint-gh", "lint-tickets"]}, {"id": "super-board-run", "parent": "super-board", "title": "/super-board run · main steps", "caption": "One wave: classify → pre-flight → delegate → merge → done. Up to min(16, CPUs − 2) cards run at once; the runtime queues the rest. Pre-flight checks batches of 5. Open a step for scripts and policies.", "nodeIds": ["sb-run", "run-classify", "run-preflight", "run-delegate", "run-merge", "run-done"], "edges": [{"from": "sb-run", "to": "run-classify", "label": ""}, {"from": "run-classify", "to": "run-preflight", "label": ""}, {"from": "run-preflight", "to": "run-delegate", "label": ""}, {"from": "run-delegate", "to": "run-merge", "label": ""}, {"from": "run-merge", "to": "run-done", "label": ""}], "render": "process", "nodes": [{"id": "run-classify", "label": "Classify cards", "kind": "step", "what": "Route qa, bug and feature cards by label. Classify unlabelled cards as bug or feature.", "when": "Each Ready card enters the classifier. Existing type labels take priority.", "how": "Read the issue body and comments. Judge complexity as low, medium or high; choose the worker model tier.", "source": ["https://github.com/EricTechPro/super-board/blob/main/workflows/super-board-wave.js"], "opensView": "run-classify", "sublabel": "qa / bug / feature"}, {"id": "run-preflight", "label": "Pre-flight check", "kind": "step", "what": "Check whether a Ready build card is already done or in progress. Flag overlap, unclear scope and excessive size.", "when": "Before any worktree or Builder starts. Check build cards in batches of up to five.", "how": "Combine mechanical checks with semantic matches. Return proceed, hold, sequence or skipped.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-preflight.sh", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "opensView": "run-preflight", "sublabel": "Done? overlap? too big?"}, {"id": "run-delegate", "label": "Delegate to lanes", "kind": "step", "what": "Run the Build, QA and Review lane agents. QA-labelled cards skip Building.", "when": "After pre-flight allows a build card to proceed. QA and Review cards enter their current lane.", "how": "Build advances to QA, then Review. A non-advanced exit stops that card’s chain; Review uses the session model. The runtime caps concurrent agents at min(16, CPUs − 2), and queues the rest.", "source": ["https://github.com/EricTechPro/super-board/blob/main/workflows/super-board-wave.js"], "opensView": "run-lanes", "sublabel": "Build → QA → Review"}, {"id": "run-merge", "label": "Merge gate", "kind": "step", "what": "Re-prove the branch under an atomic merge lock. Apply merge policy before squash-merging.", "when": "Once Review passes. Human-only steps park the card in Blocked.", "how": "Check the current base and permitted migrations. Match the PR head before merge; clean the worktree afterwards.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-policy.py"], "opensView": "merge-gate", "sublabel": "Prove + apply policy"}, {"id": "run-done", "label": "Done", "kind": "step", "what": "Squash-merge the approved PR and clean its worktree. Reconcile the returned card result.", "when": "After Review and the merge gate pass. Report the wave before selecting the next one.", "how": "Record merged, bounced, blocked or failed outcomes. Repeat waves until the board drains or a halt gate fires.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/cleanup-wt.py", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-gate.sh"], "opensView": "run-done", "sublabel": "Merge · clean · reconcile"}], "mainSteps": true, "lanes": false, "layout": {"sb-run": [0, 0], "run-classify": [1, 0], "run-preflight": [2, 0], "run-delegate": [3, 0], "run-merge": [4, 0], "run-done": [5, 0]}, "nodeOverrides": {"sb-run": {"label": "Run a wave", "verbs": [], "sublabel": "Claim ready cards", "opensView": "run-start"}}}, {"id": "super-build", "parent": "super-board", "title": "super-build · skills by ticket type", "caption": "An explicit `Skills:` line wins; otherwise the type label picks the chain. Each PR stays under 400 changed lines. grilling is forbidden here and lives in lint.", "nodeIds": ["super-build", "ponytail", "implement", "diagnosing-bugs", "codebase-design", "tdd", "context7", "verification", "code-review", "resolving-merge-conflicts", "ask-matt", "gh-board", "pr-body", "humanizer"], "edges": ["b-pony", "b-impl", "b-diag", "b-design", "b-tdd", "b-docs", "b-verify", "b-review", "b-conflict", "b-askmatt", "b-gh", "super-build-prbody", "super-build-human"], "nodeOverrides": {"verification": {"label": "verification"}, "resolving-merge-conflicts": {"label": "resolve conflicts"}}}, {"id": "super-qa", "parent": "super-board", "title": "super-qa · test plan, gap check, evidence", "caption": "Issue-scoped inside a run (qa-labelled cards skip Building); standalone it crawls routes and files onto the Super Ultimate QA board.", "nodeIds": ["super-qa", "tdd", "tdd-v2", "diagnosing-bugs", "verification", "ask-matt", "testing-strategy", "vitest", "playwright-bp", "gh-board", "file-bug", "qa-board", "pr-body", "humanizer"], "edges": ["q-tdd", "q-tddv2", "q-diag", "q-verify", "q-askmatt", "q-strat", "q-vitest", "q-pw", "q-gh", "q-filebug", "filebug-qaboard", "super-qa-prbody", "super-qa-human"], "nodeOverrides": {"verification": {"label": "verification"}, "playwright-bp": {"label": "Playwright practices"}}}, {"id": "super-review", "parent": "super-board", "title": "super-review · own pass, memory, merge gate", "caption": "Fresh review, adversarial grounding and refactor findings. Passing review enters the merge gate; human-only steps open their own view.", "nodeIds": ["super-review", "code-review", "codebase-design", "ponytail-review", "file-refactor", "merge-gate", "gh-board", "pr-body", "humanizer", "needs-you"], "edges": ["v-cr", "v-design", "v-pony", "v-refactor", "review-gate", "v-gh", "super-review-prbody", "super-review-human", "review-needsyou"], "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "super-collect", "parent": "root", "title": "/super-collect · fetch, verify, file", "caption": "Fetch sources → verify → confirm → file to Backlog. Five built-in sources plus custom ones; collecting never moves a card to Ready.", "nodeIds": ["collect-fetch", "collect-verify", "collect-confirm", "collect-submit"], "edges": [{"from": "collect-fetch", "to": "collect-verify", "label": "candidates"}, {"from": "collect-verify", "to": "collect-confirm", "label": "real ones"}, {"from": "collect-confirm", "to": "collect-submit", "label": "on yes"}], "nodes": [{"id": "collect-fetch", "label": "Fetch sources", "kind": "step", "what": "Fetch the enabled built-in sources. Include any custom sources added in onboard.", "when": "When /super-collect runs for the project. Use the requested window or the default 14 days.", "how": "Read the selected adapters and findings. Send each candidate to a fresh verifier.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-sources", "sublabel": "Last 14 days by default"}, {"id": "collect-verify", "label": "Verify", "kind": "step", "what": "Check whether each candidate is real and still happening. Reject fixed or duplicate problems.", "when": "After source adapters return candidates. Use one fresh verifier for each candidate.", "how": "Verify against the project evidence. Mark unclear candidates needs-triage before filing.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-verify", "sublabel": "One fresh check each"}, {"id": "collect-confirm", "label": "Confirm", "kind": "step", "what": "Show the proposed filing plan. Keep collection dry-run by default.", "when": "After verification produces the candidate results. Before writing tickets to the board.", "how": "Present the plan table for confirmation. Use --yes when filing is already authorized.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-confirm", "sublabel": "Dry run until you say yes"}, {"id": "collect-submit", "label": "File to Backlog", "kind": "step", "what": "File verified problems into Backlog. Apply fingerprints and duplicate checks.", "when": "After confirmation or an authorized --yes run. File candidates marked file or needs-triage.", "how": "Use one filing entry point for all sources. Route bugs, features and fixes separately from refactors.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/super-collect-file.sh"], "opensView": "collect-submit", "sublabel": "Then lint"}], "mainSteps": true, "render": "process", "lanes": false, "layout": {"collect-fetch": [0, 0], "collect-verify": [1, 0], "collect-confirm": [2, 0], "collect-submit": [3, 0]}, "intake": [{"label": "Sentry", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMzNjJENTkiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+U2VudHJ5PC90aXRsZT48cGF0aCBkPSJNMTMuOTEgMi41MDVjLS44NzMtMS40NDgtMi45NzItMS40NDgtMy44NDQgMEw2LjkwNCA3LjkyYTE1LjQ3OCAxNS40NzggMCAwIDEgOC41MyAxMi44MTFoLTIuMjIxQTEzLjMwMSAxMy4zMDEgMCAwIDAgNS43ODQgOS44MTRsLTIuOTI2IDUuMDZhNy42NSA3LjY1IDAgMCAxIDQuNDM1IDUuODQ4SDIuMTk0YS4zNjUuMzY1IDAgMCAxLS4yOTgtLjUzNGwxLjQxMy0yLjQwMmE1LjE2IDUuMTYgMCAwIDAtMS42MTQtLjkxM0wuMjk2IDE5LjI3NWEyLjE4MiAyLjE4MiAwIDAgMCAuODEyIDIuOTk5IDIuMjQgMi4yNCAwIDAgMCAxLjA4Ni4yODhoNi45ODNhOS4zMjIgOS4zMjIgMCAwIDAtMy44NDUtOC4zMThsMS4xMS0xLjkyMmExMS40NyAxMS40NyAwIDAgMSA0Ljk1IDEwLjI0aDUuOTE1YTE3LjI0MiAxNy4yNDIgMCAwIDAtNy44ODUtMTUuMjhsMi4yNDQtMy44NDVhLjM3LjM3IDAgMCAxIC41MDQtLjEzYy4yNTUuMTQgOS43NSAxNi43MDggOS45MjggMTYuOWEuMzY1LjM2NSAwIDAgMS0uMzI3LjU0M2gtMi4yODdjLjAyOS42MTIuMDI5IDEuMjIzIDAgMS44MzFoMi4yOTdhMi4yMDYgMi4yMDYgMCAwIDAgMS45MjItMy4zMXoiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "PostHog", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMwMDAwMDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+UG9zdEhvZzwvdGl0bGU+PHBhdGggZD0iTTkuODU0IDE0LjUgNSA5LjY0Ny44NTQgNS41QS41LjUgMCAwIDAgMCA1Ljg1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ni4zNTNMNSAxMy42NDdsLjE0Ny4xNDZMOS44NTQgMTguNWwuMTQ2LjE0N3YtLjA0OWMuMDY1LjAzLjEzNC4wNDkuMjA3LjA0OWgyLjU4NmEuNS41IDAgMCAwIC4zNTMtLjg1NEw5Ljg1NCAxNC41em0wLTUtNC00YS40ODcuNDg3IDAgMCAwLS40MDktLjE0NC41MTUuNTE1IDAgMCAwLS4zNTYuMjEuNDkzLjQ5MyAwIDAgMC0uMDg5LjI4OFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsOSA5YS41LjUgMCAwIDAgLjg1My0uMzU0di0yLjU4NWEuNS41IDAgMCAwLS4xNDYtLjM1NGwtNS01em0xLTRhLjUuNSAwIDAgMC0uODU0LjM1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsNCA0YS41LjUgMCAwIDAgLjg1My0uMzU0VjkuODU0YS41LjUgMCAwIDAtLjE0Ni0uMzU0bC00LTR6bTEyLjY0NyAxMS41MTVhMy44NjMgMy44NjMgMCAwIDEtMi4yMzItMS4xbC00LjcwOC00LjcwN2EuNS41IDAgMCAwLS44NTQuMzU0djYuNTg1YS41LjUgMCAwIDAgLjUuNUgyMy41YS41LjUgMCAwIDAgLjUtLjV2LS42YzAtLjI3Ni0uMjI1LS40OTctLjQ5OS0uNTMyem0tNS4zOTQuMDMyYS44LjggMCAxIDEgMC0xLjYuOC44IDAgMCAxIDAgMS42ek0uODU0IDE1LjVhLjUuNSAwIDAgMC0uODU0LjM1NHYyLjI5M2EuNS41IDAgMCAwIC41LjVoMi4yOTNjLjIyMiAwIC4zOS0uMTM1LjQ2Mi0uMzA5YS40OTMuNDkzIDAgMCAwLS4xMDktLjU0NUwuODU0IDE1LjUwMXpNNSAxNC42NDcuODU0IDEwLjVhLjUuNSAwIDAgMC0uODU0LjM1M3YyLjU4NmEuNS41IDAgMCAwIC4xNDYuMzUzTDQuODU0IDE4LjVsLjE0Ni4xNDdoMi43OTNhLjUuNSAwIDAgMCAuMzUzLS44NTRMNSAxNC42NDd6Ii8+PC9zdmc+", "to": "collect-fetch"}, {"label": "GitHub issues", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "Merged PRs", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "Architecture", "mark": "◇", "to": "collect-fetch"}, {"label": "custom", "mark": "+", "dashed": true, "to": "collect-fetch"}]}, {"id": "ui-refine-loop", "parent": "root", "title": "/ui-refine-loop · main steps", "caption": "Standalone: direction → check → fix → review → draft PR. Default 5 rounds; stop after two clean P0/P1 checks, two reverted rounds or a dead agent.", "nodeIds": ["ui-refine-loop", "refine-brief", "refine-check", "refine-fix", "refine-review", "refine-pr", "grilling", "impeccable", "verbs-group", "humanizer"], "edges": [{"from": "ui-refine-loop", "to": "refine-brief", "label": ""}, {"from": "refine-brief", "to": "refine-check", "label": ""}, {"from": "refine-check", "to": "refine-fix", "label": ""}, {"from": "refine-fix", "to": "refine-review", "label": ""}, {"from": "refine-review", "to": "refine-pr", "label": ""}], "render": "process", "nodes": [{"id": "refine-brief", "label": "Grill + save direction", "kind": "step", "what": "Read the target code and clarify the intended UI. Save taste and direction for the loop.", "when": "At the start of a standalone refine task. Before unattended checking and fixing begins.", "how": "Ask at most ten questions. Write the agreed direction into the taste file.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-brief", "sublabel": "Agree what good means"}, {"id": "refine-check", "label": "Check the UI", "kind": "step", "what": "Use fresh checkers to identify UI problems. Rank typed findings before a fix.", "when": "At the start of each refinement round. Check the chosen page or component.", "how": "Capture screenshots and run critique or audit. Route typed findings to the appropriate fix verbs.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-check", "sublabel": "Rank typed problems"}, {"id": "refine-fix", "label": "Fix by routed verbs", "kind": "step", "what": "Apply the Impeccable verbs matched to the findings. Run polish last.", "when": "After checkers have ranked the problems. Use a fresh fixer for the round.", "how": "Chain the verbs in their prescribed order. Keep additive motion within the brief’s permission.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-fix", "sublabel": "Polish comes last"}, {"id": "refine-review", "label": "Review each fix", "kind": "step", "what": "Grade every fix with a finish reviewer. Record or revert each round.", "when": "After the round’s fixer completes. Run five rounds by default unless a stop condition fires.", "how": "Write the outcome to the refine ledger. Stop after two clean checks, two reverted rounds or a dead agent.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-review", "sublabel": "Default: 5 rounds"}, {"id": "refine-pr", "label": "Draft the PR", "kind": "step", "what": "Create the final draft PR. Include a Before | After evidence table.", "when": "When the standalone refinement loop finishes. After fixes have received their finish review.", "how": "Use the PR body marker blocks. Follow the writing standard with humanizer.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/scripts/pr-shots.sh"], "opensView": "refine-pr", "sublabel": "Before | After evidence"}], "mainSteps": true, "lanes": false, "layout": {"ui-refine-loop": [0, 0], "refine-brief": [1, 0], "refine-check": [2, 0], "refine-fix": [3, 0], "refine-review": [4, 0], "refine-pr": [5, 0], "grilling": [1, 1], "impeccable": [2, 1], "verbs-group": [3, 1], "humanizer": [4, 1]}, "nodeOverrides": {"ui-refine-loop": {"label": "Refine a UI", "verbs": [], "sublabel": "Page or component", "opensView": "refine-brief"}, "grilling": {"verbs": []}, "impeccable": {"verbs": []}, "verbs-group": {"verbs": []}, "humanizer": {"verbs": []}}, "stepIds": ["ui-refine-loop", "refine-brief", "refine-check", "refine-fix", "refine-review", "refine-pr"], "containers": [{"id": "refine-family", "label": "/ui-refine-loop · standalone refinement", "nodeIds": ["ui-refine-loop", "refine-pr"]}, {"id": "refine-brief-family", "parent": "refine-family", "label": "Direction · tools", "nodeIds": ["refine-brief", "grilling"]}, {"id": "refine-check-family", "parent": "refine-family", "label": "Check · tools", "nodeIds": ["refine-check", "impeccable"]}, {"id": "refine-fix-family", "parent": "refine-family", "label": "Fix · tools", "nodeIds": ["refine-fix", "verbs-group"]}, {"id": "refine-review-family", "parent": "refine-family", "label": "Review · tools", "nodeIds": ["refine-review", "humanizer"]}]}, {"id": "impeccable-verbs", "parent": "ui-refine-loop", "title": "impeccable fix verbs · routing", "caption": "Chain order: distill/extract, then layout/adapt, then typeset/colorize/quieter/bolder, then clarify/harden/onboard, then animate/delight/optimize, and polish last.", "nodeIds": ["verbs-group", "v-distill", "v-extract", "v-layout", "v-adapt", "v-typeset", "v-colorize", "v-quieter", "v-bolder", "v-clarify", "v-harden", "v-onboard", "late-verbs", "v-polish"], "edges": ["iv-v-distill", "iv-v-extract", "iv-v-layout", "iv-v-adapt", "iv-v-typeset", "iv-v-colorize", "iv-v-quieter", "iv-v-bolder", "iv-v-clarify", "iv-v-harden", "iv-v-onboard", "iv-late-verbs", "u-verbs-polish"]}, {"id": "late-verbs", "parent": "impeccable-verbs", "title": "motion + perf verbs", "caption": "The last tier before polish; animate and delight are additive and need the brief's go-ahead.", "nodeIds": ["late-verbs", "v-animate", "v-delight", "v-optimize", "v-polish"], "edges": ["lv-animate", "lv-delight", "lv-optimize", "lv-del-anim", "lv-polish"]}, {"id": "impeccable", "parent": "ui-refine-loop", "title": "impeccable · how its commands connect", "caption": "From the Impeccable command table and diagrams/impeccable/commands.json; the loop never runs shape, live or overdrive.", "nodeIds": ["impeccable", "v-init", "v-document", "v-shape", "v-critique", "v-audit", "v-harden", "v-optimize", "v-polish", "v-live", "v-overdrive", "verbs-group"], "edges": ["im-init", "im-critique", "im-audit", "im-shape", "im-live", "im-overdrive", "im-verbs"]}, {"id": "visual", "parent": "root", "title": "/visual · one page", "caption": "Triggers no other skill; one helper script does detection, git facts and rendering.", "nodeIds": ["visual", "visual-py", "base-branch"], "edges": ["vi-py", "vi-py-base"], "layout": {"visual": [0, 0], "visual-py": [1, 0], "base-branch": [2, 2]}}, {"id": "hooks", "parent": "root", "title": "guard hooks · events and matchers", "caption": "Four guards and cleanup-wt are on by default; the push guard is opt-in; the eval gate and readme sync are dev-only.", "nodeIds": ["hooks", "guard-worktree-path", "guard-delete-outside", "guard-secrets", "guard-key-literals", "guard-protected-push", "cleanup-wt", "gate-skill-evals", "readme-sync"], "edges": ["h-wt", "h-del", "h-sec", "h-key", "h-session", "h-push", "h-gate", "h-readme"], "layout": {"hooks": [0, 2], "guard-worktree-path": [0, 7], "guard-delete-outside": [0, 3], "guard-secrets": [0, 0], "guard-key-literals": [0, 4], "guard-protected-push": [0, 5], "cleanup-wt": [0, 6], "gate-skill-evals": [1, 0], "readme-sync": [1, 1]}}, {"id": "tdd", "parent": "super-build", "title": "tdd · discipline", "caption": "tdd consults, it does not run sessions.", "nodeIds": ["tdd", "codebase-design", "code-review"], "edges": ["tdd-design", "tdd-cr"], "layout": {"tdd": [0, 0], "codebase-design": [1, 0], "code-review": [1, 2]}}, {"id": "tdd-v2", "parent": "super-qa", "title": "tdd-v2 · the testing ladder", "caption": "tdd-v2 owns the rung; tdd owns the loop.", "nodeIds": ["tdd-v2", "tdd"], "edges": ["tddv2-tdd"], "layout": {"tdd-v2": [0, 0], "tdd": [1, 0]}}, {"id": "implement", "parent": "super-build", "title": "implement · build then review", "caption": "EricOS local override of the mattpocock skill.", "nodeIds": ["implement", "tdd-v2", "tdd", "code-review"], "edges": ["impl-tddv2", "impl-tdd", "impl-cr"]}, {"id": "code-review", "parent": "super-build", "title": "code-review · two axes", "caption": "Standards and Spec run as parallel sub-agents and are reported side by side.", "nodeIds": ["code-review", "setup-matt-pocock-skills"], "edges": ["cr-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"code-review": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "diagnosing-bugs", "parent": "super-build", "title": "diagnosing-bugs · six phases", "caption": "Feedback loop, reproduce, hypothesise, instrument, fix + regression test, cleanup + post-mortem.", "nodeIds": ["diagnosing-bugs", "improve-codebase-architecture"], "edges": ["db-ica"], "layout": {"diagnosing-bugs": [0, 0], "improve-codebase-architecture": [1, 0]}}, {"id": "improve-codebase-architecture", "parent": "super-collect", "title": "improve-codebase-architecture", "caption": "super-collect's finder uses only the findings: no HTML report, no grilling.", "nodeIds": ["improve-codebase-architecture", "codebase-design", "grilling", "domain-modeling"], "edges": ["ica-design", "ica-grill", "ica-dm"]}, {"id": "ask-matt", "parent": "super-build", "title": "ask-matt · idea to ship", "caption": "The router's main flow and on-ramps; codebase-design is the other vocabulary underneath.", "nodeIds": ["ask-matt", "grill-with-docs", "handoff", "prototype", "to-spec", "to-tickets", "implement", "tdd", "code-review", "triage", "diagnosing-bugs", "wayfinder", "improve-codebase-architecture", "domain-modeling"], "edges": ["am-grill-with-docs", "am-handoff", "am-prototype", "am-to-spec", "am-to-tickets", "am-implement", "am-tdd", "am-code-review", "am-triage", "am-diagnosing-bugs", "am-wayfinder", "am-improve-codebase-architecture", "am-domain-modeling"]}, {"id": "grill-with-docs", "parent": "ask-matt", "title": "grill-with-docs", "caption": "The grilling primitive plus a paper trail.", "nodeIds": ["grill-with-docs", "grilling", "domain-modeling"], "edges": ["gwd-grill", "gwd-dm"], "layout": {"grill-with-docs": [0, 0], "grilling": [1, 0], "domain-modeling": [1, 2]}}, {"id": "to-spec", "parent": "ask-matt", "title": "to-spec", "caption": "Synthesis only, no interview.", "nodeIds": ["to-spec", "setup-matt-pocock-skills"], "edges": ["ts-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"to-spec": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "to-tickets", "parent": "ask-matt", "title": "to-tickets", "caption": "Tracer-bullet tickets with blocking edges.", "nodeIds": ["to-tickets", "setup-matt-pocock-skills"], "edges": ["tt-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"to-tickets": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "triage", "parent": "ask-matt", "title": "triage · role state machine", "caption": "Only for issues you did not create.", "nodeIds": ["triage", "grilling", "domain-modeling", "setup-matt-pocock-skills"], "edges": ["tr-grill", "tr-dm", "tr-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}}, {"id": "wayfinder", "parent": "ask-matt", "title": "wayfinder · decision map", "caption": "Produces decisions, not deliverables; hands off to to-spec.", "nodeIds": ["wayfinder", "grilling", "domain-modeling", "prototype", "setup-matt-pocock-skills"], "edges": ["wf-grill", "wf-dm", "wf-proto", "wf-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}}, {"id": "sb-onboard", "parent": "super-board", "title": "/super-board onboard · setup", "caption": "Eight questions, grouped into five phases. Answers save as you go; files change once at the final “Write everything” step.", "nodeIds": ["sb-onboard", "onboard-checks", "onboard-project", "onboard-policies", "onboard-sources", "onboard-write"], "edges": [{"from": "sb-onboard", "to": "onboard-checks", "label": ""}, {"from": "onboard-checks", "to": "onboard-project", "label": ""}, {"from": "onboard-project", "to": "onboard-policies", "label": ""}, {"from": "onboard-policies", "to": "onboard-sources", "label": ""}, {"from": "onboard-sources", "to": "onboard-write", "label": ""}], "render": "process", "nodes": [{"id": "onboard-checks", "label": "Check prerequisites", "kind": "step", "what": "Check required tools and GitHub access. Repair missing installation prerequisites.", "when": "At the first Checks and GitHub setup questions. Re-run onboard to repair an existing setup.", "how": "Run the setup helper for must-haves. Save answers as each question completes.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-checks", "sublabel": "Checks · GitHub"}, {"id": "onboard-project", "label": "Choose board + branch", "kind": "step", "what": "Choose the GitHub Project board. Choose the repository’s base branch.", "when": "During the Board and Branch questions. After required tools and GitHub access are ready.", "how": "Record the board and branch in the saved answers. Write the config only after the final review.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-project", "sublabel": "Board · Branch"}, {"id": "onboard-policies", "label": "Set standards + policy", "kind": "step", "what": "Set AGENTS.md standards and merge policies. Choose whether to protect base-branch pushes.", "when": "During the AGENTS.md and Policies questions. Before the final write of repository files.", "how": "Generate the standards and hook settings. Enable the protected-push guard only when chosen.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-policies", "sublabel": "AGENTS.md · Policies"}, {"id": "onboard-sources", "label": "Choose bug sources", "kind": "step", "what": "Enable built-in collection sources. Add any custom source fetchers.", "when": "During the Bug sources setup question. After standards and policies are selected.", "how": "Save source choices in the collect config. Review all answers before writing files.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"], "opensView": "onboard-sources", "sublabel": "Bug sources"}, {"id": "onboard-write", "label": "Review + write once", "kind": "step", "what": "Review all saved setup answers. Write repository files once at step eight.", "when": "When the owner chooses “Write everything”. After all setup questions are complete.", "how": "Apply the setup and config writes together. End by naming /super-board lint as the next command.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-write", "sublabel": "Review · then lint"}], "mainSteps": true, "lanes": false, "layout": {"sb-onboard": [0, 0], "onboard-checks": [1, 0], "onboard-project": [2, 0], "onboard-policies": [3, 0], "onboard-sources": [4, 0], "onboard-write": [5, 0]}, "nodeOverrides": {"sb-onboard": {"label": "Onboard", "sublabel": "New or existing project", "opensView": "onboard-checks"}}}, {"id": "install", "parent": "root", "title": "install · get.sh, plugin, install.sh", "caption": "Three ways in: the one-line get.sh, the plugin marketplace, or ./install.sh from a checkout. Onboard repairs whatever is missing.", "nodeIds": ["get-sh", "plugin-mkt", "install-sh", "upgrade-json", "setup-py", "sb-onboard", "settings-py", "claude-settings", "hooks"], "edges": ["get-install", "plugin-onboard", "install-upgrade", "upgrade-setup", "onb-setup", "setup-install", "install-settings", "settings-write", "r-install-hooks"], "nodeOverrides": {"plugin-mkt": {"label": "plugin marketplace install"}}, "layout": {"get-sh": [0, 1], "plugin-mkt": [0, 0], "install-sh": [1, 1], "sb-onboard": [1, 0], "upgrade-json": [2, 2], "settings-py": [2, 5], "hooks": [2, 0], "setup-py": [3, 1], "claude-settings": [3, 3]}}, {"id": "run-start", "parent": "super-board-run", "title": "Run trigger · planner and guards", "caption": "", "nodeIds": ["sb-run", "wave-plan", "run-manifest", "policy-usage-pause"], "edges": [{"from": "sb-run", "to": "wave-plan", "label": "plan"}, {"from": "sb-run", "to": "run-manifest", "label": "record"}, {"from": "sb-run", "to": "policy-usage-pause", "label": "guard"}], "node": "sb-run", "nodes": [{"id": "policy-usage-pause", "label": "Usage pause", "kind": "step", "what": "Pause when the rate or usage guard requires it. Report the reset time and remaining cards.", "when": "Before the planner at the start of a wave. Resume with /super-board run.", "how": "Check the rate guard and usage window. Halt on repeated zero progress, a high block rate or an explicit stop.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run-workflow.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "opensView": "usage-pause"}], "nodeOverrides": {"wave-plan": {"label": "wave planner"}}}, {"id": "usage-pause", "parent": "run-start", "title": "Usage pause · halt and resume", "caption": "", "nodeIds": ["policy-usage-pause", "sb-run", "sb-stop"], "edges": [{"from": "policy-usage-pause", "to": "sb-stop", "label": "halt"}, {"from": "policy-usage-pause", "to": "sb-run", "label": "resume"}], "node": "policy-usage-pause", "layout": {"policy-usage-pause": [0, 0], "sb-stop": [1, 0], "sb-run": [1, 2]}}, {"id": "run-classify", "parent": "super-board-run", "title": "Classifier · labels, planner and state", "caption": "", "nodeIds": ["run-classify", "wave-js", "wave-plan", "gh-board", "sb-config"], "edges": [{"from": "run-classify", "to": "wave-js", "label": "label routing"}, {"from": "run-classify", "to": "wave-plan", "label": "eligible cards"}, {"from": "run-classify", "to": "gh-board", "label": "board state"}, {"from": "run-classify", "to": "sb-config", "label": "worker tier"}], "node": "run-classify", "nodeOverrides": {"wave-plan": {"label": "wave planner"}}}, {"id": "run-preflight", "parent": "super-board-run", "title": "Pre-flight · readiness and size", "caption": "", "nodeIds": ["run-preflight", "preflight", "sb-lint", "policy-size-cap"], "edges": [{"from": "run-preflight", "to": "preflight", "label": "mechanical checks"}, {"from": "run-preflight", "to": "sb-lint", "label": "readiness"}, {"from": "run-preflight", "to": "policy-size-cap", "label": "size check"}], "node": "run-preflight", "nodes": [{"id": "policy-size-cap", "label": "400-line cap", "kind": "step", "what": "Keep each PR below 400 changed lines. Split a card that is too large.", "when": "During lint and pre-flight readiness checks. Recheck during Build and at the merge gate.", "how": "The Builder stops and proposes a /to-tickets split. Merge policy escalates a diff over auto_max_lines.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-build/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-build/references/decision-policy.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-build/references/worker-preamble.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "opensView": "size-cap"}], "nodeOverrides": {"preflight": {"label": "pre-flight script"}}}, {"id": "size-cap", "parent": "run-preflight", "title": "400-line cap · split before building", "caption": "", "nodeIds": ["policy-size-cap", "super-build", "to-tickets", "merge-gate"], "edges": [{"from": "policy-size-cap", "to": "super-build", "label": "stop if too big"}, {"from": "policy-size-cap", "to": "to-tickets", "label": "split the card"}, {"from": "policy-size-cap", "to": "merge-gate", "label": "recheck diff"}], "node": "policy-size-cap", "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "run-lanes", "parent": "super-board-run", "title": "Delegate · Build → QA → Review", "caption": "Each card enters the lane selected by its label. Review gets a fresh context.", "nodeIds": ["run-delegate", "super-build", "super-qa", "super-review"], "edges": [{"from": "run-delegate", "to": "super-build", "label": "bug / feature"}, {"from": "run-delegate", "to": "super-qa", "label": "qa skips Build"}, "r-build-qa", "r-qa-review"], "node": "run-delegate", "lanes": [{"title": "Build", "nodeIds": ["super-build"]}, {"title": "QA", "nodeIds": ["super-qa"]}, {"title": "Review", "nodeIds": ["super-review"]}], "layout": {"run-delegate": [0, 0], "super-build": [1, 2], "super-qa": [2, 0], "super-review": [3, 0]}}, {"id": "merge-gate", "parent": "super-board-run", "title": "Merge gate · proof, policy and human handoff", "caption": "", "nodeIds": ["merge-gate", "policy-merge", "needs-you", "cleanup-wt", "base-branch", "guard-protected-push"], "edges": [{"from": "merge-gate", "to": "policy-merge", "label": "who may merge?"}, "gate-needsyou", "gate-cleanup", "gate-base", {"from": "merge-gate", "to": "guard-protected-push", "label": "protect base"}], "node": "merge-gate", "nodes": [{"id": "policy-merge", "label": "Merge policy", "kind": "step", "what": "Decide whether the robot can merge. Route sensitive changes and human steps to needs-you.", "when": "After Review passes. Decide inside the atomic merge lock.", "how": "Exit 7 for money, auth, destructive schema or excessive size. Exit 8 for a disallowed migration or declared human step.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-policy.py"], "opensView": "merge-policy"}], "lanes": [{"title": "Policy", "nodeIds": ["policy-merge", "needs-you", "guard-protected-push"]}, {"title": "Finish", "nodeIds": ["cleanup-wt", "base-branch"]}], "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "merge-policy", "parent": "merge-gate", "title": "Merge policy · automatic or human", "caption": "", "nodeIds": ["policy-merge", "policy-size-cap", "needs-you"], "edges": [{"from": "policy-merge", "to": "policy-size-cap", "label": "diff limit"}, {"from": "policy-merge", "to": "needs-you", "label": "human-only step"}], "node": "policy-merge", "layout": {"policy-merge": [0, 1], "policy-size-cap": [1, 0], "needs-you": [1, 1]}}, {"id": "needs-you", "parent": "merge-gate", "title": "Needs you · human handoff and resume", "caption": "", "nodeIds": ["needs-you", "wave-plan", "super-review"], "edges": ["needsyou-plan", {"from": "needs-you", "to": "super-review", "label": "done → re-review"}], "node": "needs-you", "nodeOverrides": {"wave-plan": {"label": "wave planner"}}, "layout": {"needs-you": [0, 0], "wave-plan": [1, 0], "super-review": [1, 2]}}, {"id": "guard-protected-push", "parent": "merge-gate", "title": "Protected push · opt-in base guard", "caption": "", "nodeIds": ["guard-protected-push", "sb-onboard", "install-sh", "claude-settings"], "edges": [{"from": "guard-protected-push", "to": "sb-onboard", "label": "Policies yes"}, {"from": "guard-protected-push", "to": "install-sh", "label": "--protect-main"}, {"from": "guard-protected-push", "to": "claude-settings", "label": "PreToolUse Bash"}], "node": "guard-protected-push"}, {"id": "run-done", "parent": "super-board-run", "title": "Done · cleanup and reconciliation", "caption": "", "nodeIds": ["run-done", "cleanup-wt", "base-branch", "run-manifest", "gh-board"], "edges": [{"from": "run-done", "to": "cleanup-wt", "label": "remove worktree"}, {"from": "run-done", "to": "base-branch", "label": "merged head"}, {"from": "run-done", "to": "run-manifest", "label": "reconcile"}, {"from": "run-done", "to": "gh-board", "label": "update cards"}], "node": "run-done"}, {"id": "onboard-checks", "parent": "sb-onboard", "title": "Prerequisites · repair and install", "caption": "", "nodeIds": ["onboard-checks", "setup-py", "install-sh", "env-check", "onboard-answers"], "edges": [{"from": "onboard-checks", "to": "setup-py", "label": "repair"}, {"from": "onboard-checks", "to": "install-sh", "label": "install"}, {"from": "onboard-checks", "to": "env-check", "label": "tools + auth"}, {"from": "onboard-checks", "to": "onboard-answers", "label": "save answers"}], "node": "onboard-checks", "nodeOverrides": {"env-check": {"label": "environment check"}}}, {"id": "onboard-project", "parent": "sb-onboard", "title": "Project · board, branch and config", "caption": "", "nodeIds": ["onboard-project", "gh-board", "base-branch", "sb-config"], "edges": [{"from": "onboard-project", "to": "gh-board", "label": "choose board"}, {"from": "onboard-project", "to": "base-branch", "label": "choose base"}, {"from": "onboard-project", "to": "sb-config", "label": "save config"}], "node": "onboard-project"}, {"id": "onboard-policies", "parent": "sb-onboard", "title": "Standards + policies · files and guards", "caption": "", "nodeIds": ["onboard-policies", "agents-md-py", "agents-file", "settings-py", "claude-settings", "guard-protected-push", "policy-merge"], "edges": [{"from": "onboard-policies", "to": "agents-md-py", "label": "generate standards"}, {"from": "onboard-policies", "to": "agents-file", "label": "repo standards"}, {"from": "onboard-policies", "to": "settings-py", "label": "write settings"}, {"from": "onboard-policies", "to": "claude-settings", "label": "hook settings"}, {"from": "onboard-policies", "to": "guard-protected-push", "label": "opt-in guard"}, {"from": "onboard-policies", "to": "policy-merge", "label": "merge rules"}], "node": "onboard-policies", "nodeOverrides": {"agents-md-py": {"label": "standards writer"}}}, {"id": "onboard-sources", "parent": "sb-onboard", "title": "Sources · built-in and custom", "caption": "", "nodeIds": ["onboard-sources", "super-collect", "collect-custom", "sb-config"], "edges": [{"from": "onboard-sources", "to": "super-collect", "label": "five built-ins"}, {"from": "onboard-sources", "to": "collect-custom", "label": "custom fetcher"}, {"from": "onboard-sources", "to": "sb-config", "label": "enabled sources"}], "node": "onboard-sources"}, {"id": "onboard-write", "parent": "sb-onboard", "title": "Review · saved answers and final write", "caption": "", "nodeIds": ["onboard-write", "onboard-answers", "setup-py", "sb-config", "sb-lint"], "edges": [{"from": "onboard-write", "to": "onboard-answers", "label": "review answers"}, {"from": "onboard-write", "to": "setup-py", "label": "write everything"}, {"from": "onboard-write", "to": "sb-config", "label": "save once"}, {"from": "onboard-write", "to": "sb-lint", "label": "next command"}], "node": "onboard-write"}, {"id": "collect-sources", "parent": "super-collect", "title": "Fetch · source adapters", "caption": "", "nodeIds": ["collect-fetch", "collect-sentry", "collect-posthog", "gh-issues", "collect-prs", "improve-codebase-architecture", "collect-custom"], "edges": [{"from": "collect-fetch", "to": "collect-sentry", "label": "sentry"}, {"from": "collect-fetch", "to": "collect-posthog", "label": "posthog"}, {"from": "collect-fetch", "to": "gh-issues", "label": "github"}, {"from": "collect-fetch", "to": "collect-prs", "label": "prs"}, {"from": "collect-fetch", "to": "improve-codebase-architecture", "label": "architecture"}, {"from": "collect-fetch", "to": "collect-custom", "label": "custom"}], "node": "collect-fetch"}, {"id": "collect-verify", "parent": "super-collect", "title": "Verify · a fresh pass for every candidate", "caption": "", "nodeIds": ["collect-verify", "codebase-design", "ponytail-audit", "collect-file"], "edges": [{"from": "collect-verify", "to": "codebase-design", "label": "architecture vocabulary"}, {"from": "collect-verify", "to": "ponytail-audit", "label": "audit findings"}, {"from": "collect-verify", "to": "collect-file", "label": "file / needs-triage"}], "node": "collect-verify"}, {"id": "collect-confirm", "parent": "super-collect", "title": "Confirm · dry-run and enabled sources", "caption": "", "nodeIds": ["collect-confirm", "sb-config", "collect-file"], "edges": [{"from": "collect-confirm", "to": "sb-config", "label": "enabled sources"}, {"from": "collect-confirm", "to": "collect-file", "label": "confirm → --yes"}], "node": "collect-confirm", "layout": {"collect-confirm": [0, 0], "collect-file": [1, 0], "sb-config": [1, 2]}}, {"id": "collect-submit", "parent": "super-collect", "title": "File · one entry point and dedupe", "caption": "", "nodeIds": ["collect-submit", "collect-file", "file-bug", "file-refactor", "gh-board"], "edges": [{"from": "collect-submit", "to": "collect-file", "label": "single entry point"}, {"from": "collect-submit", "to": "file-bug", "label": "bug / feature / fix"}, {"from": "collect-submit", "to": "file-refactor", "label": "refactor"}, {"from": "collect-submit", "to": "gh-board", "label": "Backlog"}], "node": "collect-submit"}, {"id": "refine-brief", "parent": "ui-refine-loop", "title": "Direction · brief and taste", "caption": "", "nodeIds": ["refine-brief", "grilling", "taste-file", "sb-config"], "edges": [{"from": "refine-brief", "to": "grilling", "label": "at most 10 questions"}, {"from": "refine-brief", "to": "taste-file", "label": "save direction"}, {"from": "refine-brief", "to": "sb-config", "label": "refine settings"}], "node": "refine-brief"}, {"id": "refine-check", "parent": "ui-refine-loop", "title": "Check · screenshot, critique and audit", "caption": "", "nodeIds": ["refine-check", "shoot", "v-critique", "imp-detect", "v-audit", "impeccable"], "edges": [{"from": "refine-check", "to": "shoot", "label": "screenshots"}, {"from": "refine-check", "to": "v-critique", "label": "design problems"}, {"from": "refine-check", "to": "imp-detect", "label": "typed checker"}, {"from": "refine-check", "to": "v-audit", "label": "functional audit"}, {"from": "refine-check", "to": "impeccable", "label": "command reference"}], "node": "refine-check"}, {"id": "refine-fix", "parent": "ui-refine-loop", "title": "Fix · routed verbs, polish last", "caption": "", "nodeIds": ["refine-fix", "verbs-group", "v-polish"], "edges": [{"from": "refine-fix", "to": "verbs-group", "label": "route by problem"}, {"from": "verbs-group", "to": "v-polish", "label": "last"}], "node": "refine-fix", "layout": {"refine-fix": [0, 0], "verbs-group": [1, 0], "v-polish": [2, 0]}}, {"id": "refine-review", "parent": "ui-refine-loop", "title": "Review · ledger and finish standard", "caption": "", "nodeIds": ["refine-review", "refine-ledger", "humanizer"], "edges": [{"from": "refine-review", "to": "refine-ledger", "label": "grade / record / revert"}, {"from": "refine-review", "to": "humanizer", "label": "writing standard"}], "node": "refine-review", "layout": {"refine-review": [0, 0], "humanizer": [1, 0], "refine-ledger": [1, 2]}}, {"id": "refine-pr", "parent": "ui-refine-loop", "title": "Draft PR · evidence and marker blocks", "caption": "", "nodeIds": ["refine-pr", "draft-pr", "pr-body", "base-branch"], "edges": [{"from": "refine-pr", "to": "draft-pr", "label": "Before | After"}, {"from": "refine-pr", "to": "pr-body", "label": "marker blocks"}, {"from": "refine-pr", "to": "base-branch", "label": "standalone branch"}], "node": "refine-pr"}, {"id": "hook-settings", "parent": "hooks", "title": "Hook installation · settings and environment", "caption": "Install writes hook settings; onboard repairs installation. Merge policy has its own drill-down.", "nodeIds": ["install-sh", "settings-py", "claude-settings", "env-check", "merge-gate"], "edges": ["install-settings", "settings-write"], "nodeOverrides": {"env-check": {"label": "environment check"}, "merge-gate": {"label": "merge gate script"}}, "layout": {"install-sh": [0, 0], "env-check": [0, 1], "merge-gate": [0, 2], "settings-py": [1, 0], "claude-settings": [2, 3]}}, {"id": "sb-status", "parent": "super-board", "title": "/super-board status", "caption": "Inspect active work, lane outcomes and the dispatcher status without starting a worker.", "nodeIds": ["sb-status"], "edges": [], "layout": {"sb-status": [0, 0]}}, {"id": "sb-stop", "parent": "super-board", "title": "/super-board stop", "caption": "Halt the active dispatcher and report what was stopped.", "nodeIds": ["sb-stop"], "edges": [], "layout": {"sb-stop": [0, 0]}}, {"id": "git-sync", "parent": "root", "title": "/git-sync · commit, pull, push", "caption": "Standalone; no lane runs it. Merges, never rebases, and never force-pushes.", "nodeIds": ["git-sync", "base-branch", "resolving-merge-conflicts", "guard-protected-push"], "edges": ["gs-base", "gs-conflict", "gs-push"]}], "notes": ["Refreshed to super-board v3.0.0 (feat/sb-cleanup @ b67241e1, 28 commits after cd199b2d). Source paths are repo-root-relative.", "Board: seven columns, no Skipped (a dropped card is closed as not planned → Done with 🤷). Labels qa · bug · feature route cards; qa skips Building; the classifier adds feature or bug, never qa. The per-board `variant` is gone and a `qa-only` config is refused with exit 65 until onboard upgrades it.", "Onboarding is an 8-step wizard (Checks · GitHub · Board · Branch · AGENTS.md · Policies · Bug sources · Review) backed by super-board-setup.py (check, fix, migrate-config, names, branch, board-rank, board-migrate). New view sb-onboard; its steps are edge labels, not nodes.", "Merge policy and DB migrations live in the merge gate (super-board-merge-policy.py): money, auth, destructive schema or a diff over auto_max_lines (400 changed lines, lockfiles/generated/snapshots/migration SQL excluded) exits 7; a migration outside allowed_envs, a failed migrate or a declared human step exits 8. Both park the card in Blocked with the 🙋 checklist and the needs-you label, with no extra column; `done` sends it back through the planner's resume list.", "Builder pre-flight (super-board-preflight.sh, a Pre-flight phase in super-board-wave.js, batches of 5) checks already done / in progress / file overlap / unclear / too big before any card is built. Lint has 18 criteria now: 15 = too big (split via /to-tickets), 16–18 = ticket format.", "Writing standard (references/writing-standard.md): commits `<emoji> [type] scope: subject` + bullets, tickets Problem · Context · Fix · AC · Risk · Blocked by, PR bodies in marker blocks rewritten per lane with super-board-pr-body.sh, comments `[role] [label] status`, prose through humanizer when installed. That is why every lane view now shows pr-body and humanizer.", "super-collect gained custom sources (collect_custom.py: http, cli, mcp) added in onboard's \"➕ Add another source\", with fingerprint `custom|<name>|<key>` and the same verifier and filer.", "Install: get.sh one-liner, a plugin marketplace (skills only; onboard adds hooks, scripts and workflows), install.sh with grouped output and an upgrade record, and super-board-settings.py for hook and allow-line merges. There is a new install view under root. env-check (key names only) is allowed through guard-secrets. The AGENTS.md helper is super-board-agents-md.py.", "Added nodes: preflight, pr-body, needs-you, setup-py, agents-md-py, agents-file, settings-py, env-check, collect-custom, get-sh, plugin-mkt, onboard-answers, upgrade-json. Added views: sb-onboard, install. Removed edges: sb-onb-push (now settings-push in sb-onboard), h-install and h-ships (now install-sh → settings-py and install-sh → hooks). Nothing was renamed.", "Also since 88c27812: super-review truth-check sub-agents get a fixed verbatim brief (Over-engineering never blocks), and status lists columns in board order with Backlog. Disagreement: the coordinator listed 'labels qa/bug/feature routing'. That matches, with one addition: no label is also built (treated as feature).", "Kept as-is but stale in the files: the merge protocol and the wave.js `humanApprovesMerge` arg still mention human_approves_merge, which onboard now migrates into merge_policy. super-qa standalone still files onto the separate Super Ultimate QA board.", "The Builder only proposes a /to-tickets split in a PR comment when a build outgrows the cap; it does not run to-tickets, so there is no super-build → to-tickets edge. lint does dispatch it.", "Unchanged from v2: ui-refine-loop is standalone, now stated in super-review and super-qa as 'file a UI ticket; a human can run /ui-refine-loop'. cleanup-wt still runs at SessionStart and post-merge. qa-test-planner, testing-strategy, vitest and playwright-best-practices are still not installed in EricOS."], "authors": {"EricTechPro": {"name": "Eric Tech", "url": "https://github.com/EricTechPro", "avatar": "data:image/jpeg;base64,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"}, "mattpocock": {"name": "Matt Pocock", "url": "https://github.com/mattpocock", "avatar": "data:image/png;base64,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"}, "DietrichGebert": {"name": "Dietrich Gebert", "url": "https://github.com/DietrichGebert", "avatar": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAABgCAIAAABt+uBvAAA/40lEQVR4nGT9SaxtWZImBC+z1ezudLd7rfcR4dFVZP2Vv6hMkipVklBCggFTkJgwQjVAYsIICabMQUKMkFBJMCgokFBVUllkZFQSkRHh0XhGhEfrvb/2tqfb3WrMkK197nVPeP703rv3nLvP3mtZ831mny03/91//4+r0j16eGKtvby87Dx/9OR6O3JIKgRiRaSYmfMfCADyb620xhgT51eUAqUAMLx1dvL1R4s375enJ8sQUz/wzTi8vNxer/1m17eRhqQudv0QkmJChfnHVMqXMRqNNUyUKKXEiRgQVf5YpQ5/E8vN5M8DJX/JzUB+Q2KF8g15JTFV1s6te/u1e3/r7dPjxaIuoTRsUAMiAJKKF5eb55fty4v9882464eiKEihj7Ebxq7rlcJ9N4REidG4olQAbTsgDtfXW+PKwhkIiUJUkG+HId/i4a5U/gJRI3KMEeSmlLNYKvjX3jj+1//W/dKxdu76eoCkRuCqKu1+fPhgYZ1NBL/86Pyzy41x1hhttAGFu/2ekkopIHJVlMR6GEZE0KiJOKSUN0CWkpPCz28D5M7gsFzACmQDCREKq0+P5ibGRW3qsgTFTECkjIOqMvN5pa16dLJYzdZd//F2DKwqTxRCWG82oA0iGu2cTYFGVGxu1tv5rLnZ7BG5cGUi0giKSfZn2idZp7wM033Jv8hqnVcHEVTp7L2mujefv/agrmfWaFlehYZVpEQxxhh8WZZOY0jh3rwYfWmsVQpCJDAYRkyaU1IGsShstkomVta6tu3EZpUCBs43Iasy3VP+S94p5iULJ3dibdNU86aeV+5sUT66fyweQGkcY6FLq3VTFdYahYRWrZr64b0zr1p/vm67/W7fa+Nms3nf98PgFbB1JkU2RHyz3S7ms6bA+/ePuq5nW279Zowj320SHu6Lp68BSZxPiRUpKqwdwthFMJrHMfaURk/dAD6EGAMoWC7mwzicHC073j84ns3rYj+MSkHXD7owM7fYdcPgozEWmIBVYW0k8aq6rjvxyHRw7ds9ymvCSrZR/iL5li5LPWvKCvWytG8+ODk7apyTjbTGgopE0dnKWqtYUVJtu+97n5h3+27XtoP31pm6mQ+Dn/wYlLKoFSYDzFVZGe2stUVhNcJ114aQyqoc9704tRh3vhuxKjUt1XTT8gWrYezB6sdHi7qq2jb0Id7se2VKzSrFxCkcHTUpOqu5Kkul/K7vUwyIunRmNqtPFma3a7ddJNCbdlh3e1YSKTSa0XsihSD/UaDJvQ9+P91H9jSjoKnsqw+PFmWpmU6P6+XCakyFLbSRUGYAC2uyczInaLvh6flms077ru+GQIDZFXAYhrbttLZKkTM2hkQAppk1kWG37/perXctav3i4qYfyacRxYQ0o+wWAGitDkGZAZUisXjWoBUkpfjNB2eo7Xa3i4iJIQy9Bl0W7pWHjUZMRKNPY4gSI1zByoXog/cpSdQw1pUOIqtuGMYQctRDZo8ABEqjTokkHstWfcHXeAqM6Iz5xldeP125EjD64DRSIiyNlTCnNFO2P2Kl/BBSTC8vd89eDiwfAUnRers1xmkjsaquKiJyukTU3ehV8Kaum4vrtVIYklr3vY9xHGPeNsw+NcXAvPj5vylg5sXJWwhi4KfLuqyKaTcQTVPZfhwKV6A2Sd4GNBJIuEgpxfxjTPnXfn0FcYA4cLsd9tfNbmvGvVI6QTGoKtg5lEdUrQBMdu28U3fJQtYOFfPxycIa1MwawacApuAkVmdQGQ3IrJUyGhFVTByTrHak0Pdp3Y7r9QYRUoqAoI1JMUXvj5aL5bxe79t9b8y2G0JMkULTzCHEGCkkMsYgqaRuU7hSEnRUysHosH8AymhVFfBg0XzlwZI49ANpLY9SFq4oXZJfhKBiIqbko1hE8CGGOLabfn0+bs8htqWGFHwce/S+GIdCqRBj1/V69CnFSIzNQ/Po96C5HxnuwmJOIOAKSbr1zMYwIolDOWvC6Gd1WVhtNDiDTqNFrutCa2QmkjQP1undbqBAjeQlNXKCfEkmKg289vDkwenyYr3/4MmF2bd9348kS7BDCWlaXBJMXhGJQEYjEO3HGEBDDokgjszW0d/78sO3H8xtYaK8W1y6sHZmtM6YhImHMCZWiZTkNebkh835p+uLJ77bKIahH7TRCSiOHccRWVljE5ExejazqFsdvJJgufWf/LmuTvD4G2H52mSSOfwxJ7IGh3a8Gcb7s/tGG2XlBusaqxKr0jaVKbSyBq01xCoGHoYwDB4Bj1fz1ZKXq+pXn1zuxyC+7aNmXM7rWQ2F09aYOI4mElvnisKFmABxVjjvRw3KIi9mpUV1b7Wwmn792dV1x+PolYFC61cf1F+5t/jG6/cRYNv1npTkbOAJi0nQM1prTInaYSBWfmzf+Vf/cnP10jmjQfxOUKjccexldYY0DtboCReWzaKu6npsmPx2s+m6VvZo/9LsLqJb6bOv8/JN1kYp5f3YtuJBVGitBb3UtXGI86qY12Y5M85Zp0E8ERSF1Lf+xcvrwLopG2MtoKpn4Xef3ZSWHCpnjNH67GRxulqhUkPXphjMOMZ5UzaNHQeBksBUOmMN3l+ViwKI6XThTldNSuF6258e3V9Udl7pk6O6RC4K5SOhnsxTNU0NgIkpMXGSSGVdUQH85pe/+ld//qdOImHR7rq6xhBC23YCxSU/RUXMEQfvU/Sg+OrmZrVaFWUJAMfHJ2enJ/0wXFxcgtI6bLuP/2IsfqHf+HtQn0j4iImVwkp3XXe8LKtKN87V1hRa16VxhSAkxexHv9n0m73g413XA+JqdaSS2u32V5ubqnDHR4vjxax0unJOLpqSQX748Niw4khxMVsMpt93EsBSTGigdqaw2gePSpUavvHasQ/D6fFy1hgAUmwyfFNpAG1UGjuBdlqXZSGJhiUa5wDOv/zrd9/96U9OTx6CStv1pTFwc33V973WrqiaJASCE0Vt7PFi7seegg+jf/H8eTsMdTVrmmbWlE3l6rK4vr4p6/miWFxenQ8/+9/dw28Wr/0+6kopttZmoGhKqwtnLKJBnbkMo/g6t303+uCDtxooh+p91yGaq5vdrKlKY5FUVRanqzkQ913fSxZWM0H8TjhK7ZwBVRg7dCMZmNUlUkLUhXMIGhScHjVFMTPGgMY7CBKTIk67ttu1XV1XTd0YiykdKAgz/fIXP//1ez9vZst2v/P9HgRPDOOYFLp+HEPioqzLqiJrQaW+HwvrtDHzul4sZ+vN7uL88vnTjTZ2Ma9ffXDv+Oj4w08+XR2dFK58+fQ5bP9qcfPywe/9CVdza/SsqQUnIxtFVWkLp1VmHuJcTHVTNVW9mBXBq8HTxXr/dP2imS/HQJBSN/hFVR8t5oVFTqyqIilVk9KWzbKyr50tTme42aqeTdRDPaus+LNsQjf4q2F9unDMGCNp0AL94TbtJ2o7WR1KNAETAU7iZfLiZx9/8tfvvtsH3l6+BJUWTZFCMLao50dl1QxDP3Td0Heppb7r2r6TK5IvDcxKdEZXpfvSW69/9NHTT59dfvb05tmzzeuvnZ6enD15dl7WtbZu2w2b938Bsf3K3/2HZ6tXmqrQyAbRaqu1No7RatI6wxIsTIGkXGH8kF55cOQHPwyx6/1ms4eklrPl0aqqS3ZGRWEnbA03lTFDMH/wpbOmdkUBEsW20bmSMqjCHLE0QEwpU1dh2gjBoYNbG5J3EknYtdqKbbESVKYB8PzFs3d//OPNpt1049HqpHRW0bhd7/sxdDfns9ns9OSeqzSCSaGNWtVOM2IM0HX7oQvWYByH09Xy/snKaPPycrdZt599+rKalcYWF5dXSttx9CGqF8+e9t/5Xyo1fPnhv6cQtEbUYvKCPw0SZn57C51QaW1pOcOTlRspfHa+ixTu3V/dOzleLZxBpTPUIwSjBRoLVPiv/vN/1AjoNBHs0/ONjxRjOr+8KW0xK4tZaY/mtQZy1hAJDrLWYDaiRAJwuk6wU10VTmig8ANWvNvtv/0v/2w/xM6no5N7qF2iNIiNoIQqg8kP7W479u3Q79LQVoVVFHfr6+3NlWLWrIaujyHtdm30XmdW6iwYrYa+Z07G2X3Xk4JEyVjXD769eXa0XD169TVnhR8iqrLQtjSyl3ewMkMDzQLFjcGmKUrnfKS6LqoCa2ckdvEBjJqMLBG1cdrt293O88UmPL/aoHZWmy7h1X6sDb754GjZWOIUvIA9jTrYpJzOhAiIwTm7XKBzTvhThvSc6Cfv/OD8Zl3Uq+P7j/ohIqh2t765ujldHSk1xDAGP1BkI5sr0FVDWjTVvDy7ucbNtvW919qkxBLuUrJavXpSWl0ljrtuaH3a9P540VzvxlkjbLZuZtvr3U/+8v987a3X4dVXvbC8BWe6qw4lm0waD/xNrEziMsqGLublvo/eS7IQfEcCbrVFa61lEwLp/+I/+0+eXre/eP/Z06t+N9AQ4q7tEymryRnFyc+ampnCOMZIViKTLK2kcwnGwuyN1ZiXGxQqhk8//uSvfvDO8vhBOVslZRTq7Xb37MlnhTWzurKyqTyf1avFXCVvKGnFFHy33WiV7i+ro1o23qo4c/DwePbKcfH6afXavdmj49nZzC1Lya1a5YpdSojY933XdWVZjUPLoX/tS18ritJpcA5slbfgc/ORoCCBLgpq1ajBYP6jSJEnqBIy3HeltdmExJQ27fDp+XoMHD0q0CEMQuySECVtdB+4jbHUbAsjWUGsJn8QSWwST9cHTq+E9Kjddvud734XygXpYvSpH6I2pp7N3nrryxz60O+N4tOjU1n4dlvlKo6wdI3R6IrDaVHW85k6nokLx3G1qOaFAA6jdRK0XnSrZr4d6qK92PUppesuzpuqG2Lf90zulz979+1v/u2/8wd/P4RIUStSCg+2flsFIMWI4oJIijM/w1w0pRxRwRgrLE7J0uXHJONDqp2tHx5dbOPmxTaboZCdeVNToi7SZjeUK1uVtZCHlEiZpDASpwR8m+9zRYRToh//9Kdd0rOTU6XMzeV1iLExDcfgxwHDYCk5UDzsnYHZzNrZMY998iNw0shnS7cqLLDSWiJdirEyqnQS8SglNiTs1AciR4kLZzIN2l/uxpT0EOLgx6v17sd/9Z3f+//9/5vVUd2UmcoeqqHZfia+Swc+mWtuLBzAKxXz/cvXmvU4jsaayVCMNfT2qyfO2vdf7D692A7+gImTwjbiru1Hup5X90ATcHJGo2eAXEBQmc/flrGY+cWLl7/56NMuAXgyGId2rxAun9/MynImbMbMzLxAKi0ARyZfAJumMBgLjYWG0lBlgJizC+eAqpKQZiImJBJWJ4ZQa2vccZAESxyEV6+HlyGM4whKPX/yZHP59CtffmQLo25L14c1mko1U8GSZblZ3I19iIyZ5DCpBDGR0spJ+JAkbc6OZ0KeFLR9vH9S989bH9KuHUbv69L6oa+L6pMLv9tc1qU7PhKQtKjNrLbGWQDIewTAQMTv/eLXY+T1zboo5tdXV1fPnmpnXn30SlO4unCLsjhuqmUOQ+R7lUYgD35EDJiCA3YmGiTJlWmqYzKqpCgEP7Ii8WCxbS4sWmOKiLtZNUQGGJh1G2idyIew3+82V5fG2EO18baIPqESlTsQpFSSeKz6bhzHKLCAJ5tS+UXBTcLXjQ2hM1brqa4zb8qT1eKTFx0AEFE/Ji8sia6G9Pyj8zGE0pXV1f7V+8sHi+o40nIBhbVysWxK293u1x9+cHm5YcD15Yv91c2iKl959ZVHDx/Nm9lquWyqat7M5ZNCy/0V+I7CIHk1BWCvOWimFEfFSTxBvHKfqz2yewQSDkCxUFLZWbGHk2U5CuE1TEM38z5EHzl4v1lfD/3AZAzm1kkmHOpQT+KcWwTWbXZdNwyJDII2WoVMCUPwANCIxTtKcidmu/cC+pXe9DT0wVrM7E8lkrCIADdtK59MFCl1XlmNkJKz86pMeZ01Gk2JP/34s+fPnhb1wqLzY1gt5l9+5dVvfO1rpiiLsiyrZjY/UkYLfOotY8+YoNA89kKXmJAlfHIKqCXLaK1t4VIYBavKvYL3kjimgMdKdr1xuKjs4CnMij6VfQj70RstITcS6ZjGIWiTeaPL4ZjlByPFdhy71veDlywzeapwa0k/1rmJmlCUp3OmMB88X2t0N7v1k+vxpo8KdKLAedPEc1Hn1eHshrKXlKL3Y0h113tQydlGa0wxXJw/T37YhXRy/9Wz5enjs6MvP358dHKSGLSxzXyBGnM0iUwJBQxKCmRXqjSqmFIEzYmTV2IyHMee4yDbDSkFQSnaGJUmDjxVpsFpWNXl6FVi3fr+xmGI4AxM1YTgo8Hcj9FCr0gd2msxpq7zwxhkjQGi2A2lFCXkaW2dy8FIjaMX8ExkrvbCS3atf3rZdzGnKcWU1KHYmj1ZA06B01m3nM+bCoVx1oVk6SnLg+r61mgwRp+sVl/60pcenqwWdYnGIqBxJQvii5Bi8qOlyNFPaEQcXxuKgjDkDSr3S4TeB5Cb4BQDxaAmnIVoQKVs+cIbkJ2G0mnn49G82nYxEIGGixfPYiJtkBJrLVauSBAaKex6v90PPuT2Q45qlFuVOYgLT7ltkaphGFvqE5PZtfhyvet92owhJnn75K453QrKQQFASis0ACe1mdc4n1UaCLWayp8hBFBcV8Klm+Xi/v2T+axoqiJGUlbNmhmgkQgChIqAoooDqBFR9i2njmSMTkorZVWyMQYE0FoH8QDZdIkzRLf9wc+pAwBYo5xBq1Vp1PGi6vwQctQZfABwYqDaTLQ6pNQO/uJyF6eOkiJFUyMrRzeYgngE0iFQkCjDXixXmU/P1+04CE5KkdIEF+SaApYVGZRPEFyJ2mJ6dG8xa8qMDzgXmoklKwMqTMSuKI+OTmazWmgfYNlUpqiMdYkEnIlxp6TiyMMeUuDkWUyGJuwGYBhIaZNDBSvrLDQcPUtGoxgjUQKU7IGgJGgIoGEALgusgiOiRQXzumxH2a0UyUO0RvsQCslosN+351dbn3DK9FP2B4CU3XZqYUF2FJbLC1LO3wSTmFbL5Wa3t1ql6HOPm0trj1fLvtsuZnXlCmuw77qqLBazZhyHdr8tnJs3FssCGDRqbYSLV81ysTopi6pyVWELV1ba5sYGRUCDzkDi6Edt64wrGHHk0LM4ldHaJiY0JWrNESYhgIQOYIQEk88riYyY8z+n6SGhNMqhCsY4E0uHbR/7tk258pIiBZ+S53bo15tNSqh0TmlTv1WiibhYXi/QGqy1k21mHiFZQ2tt5rPaWV2Y2Rj5yfl1IKXBAmC7361WdVkU6+sbBFgtZ86ZQPDs5dWssqB1jKksrLM6g/UUIhfVrJkvF4ujuqiN4AfZEErZP1BpawSlzlfcG5UaNSKPW4GrKlCS7TK2TICcFLHnDKw4dyCS0lDUOV4kBVowkQocD2HXgJpZHAY2yEUBs7oc200KQTkrFtuncfT7vo9ZH5FXB0KMwkVoYk1iKELkywIU5FZF3gkBpuJ/JneHk3PWOr2obO8TihlKtGal1pvtZtvOmjrEUFh9dbMhULNZU1dlWbhM5zgmGkMaQzJlU8xW1mpjIWMxIR+ADDlfKADxy9x2tPJlBToSBQVC9xnl1tHoXHpDYmSlI5uYQoyEKJbKwpASiPHExJTjhsTHprBjjJueNIN1GMf24uVz/cprEcHHmNuzghs4Q2PvSa6YVyL3i1lCSW7TKUmZYlkxyu/JvswweoSSGWMITWErawlx343Hi0W7b7dt71wBgF3Xcwx1KdFIckwYjHZVVaDOuIXIGCvgWltn7OTlk6hFAccYJGoEoow8kWI3DiaRyehf3EnomGS06AfZGgVRmcjUjV3XjiGlmH+zLF6Y16Z2CGg5xvw5AnFKpy2i0RpC0JBuLs6b5bExJpNUpUELKWXlffCSifg21AqRAYYUeaARQBNxzCVjiUG5M2mscSEQYpjNGq1N2/XamOSHs8aGoJlhCH5V20dnC1axKktEmJWucOrsqCmcZtAS6HK5NTMBtlrDAaqovu9ubq7b/As1xiQMCjkB0VFZNsY7HkwaaehN7nfmheD9GNfb3cvLq5dXl1dX1xSDRqoKN59XBslpunc8a5xurJacqPIagSqcKcaEzCl0+/UVsUpEOYFIvks5quQ8nbOixDiTt1HciijKOmrhZSGlkARhYDYts+vH4MNyUSvUfvRiXSl+9UsPa20/u1xLdincN7/y6KuPlh9+9vJoMUNQzum6BIe5c5+hBGWzlLgDB95HxOvd7uWLq/Vmvd9udrvN+fmLzWY99B1Q1AhvPHrwzS+/cX9VzV0wkIahZYqDD/sxfvLsxfsfPX12cXO13SlSVaGrQh0vGpULTsaw90krfO3efFGhomC0RYnlClUqUEAUd+vCOa3zvdBEQznle81KmgwOY0RZRCCekDQqL+RhSgcTpxWQ044+xaS7YbpOSqlA/fC4urhek+ARdFaHELq2PZ1VZ8eVAsrRXrx1u99nMJr8KAtrrHPWZJYJ7ejPL6/3u+3FiydIhL6v2A9ptAYpYgz+5uL8hVDeh3ppGzcDGGgYwrhdX+2uXjzvdut5aVazM2dc4bSxWIvZCkym1CsOVVnu+97pqnROGwMpCGpDqAsDiONn73a/frT45h8CIuWEhwoS39Y9BKznig3xIaNRrgep3CVXt7w/ry72MQWl2jEMYyyrilL6+lurs1VhbKly+i2NoRhX8+bhvWXd2Nmsnqya5HJxHH0I8glNVSo+IKPEtO/7LA7z89o49ib0Nah7s6ZUFLtdCTwvy33X3+xjqE7t6RtmdgKKDfnQbtLQzyuXfP/y+Yv1zVozW6Jus718/nK/3pbGHS+WR01ZlVWQJAACoG6LhlVhlw4fat//8H/b/PQ7GTDnAhnkYnMugzGrjKskUSVKIYQ4iRKm4D0xPnHMXG9MxILfSQ1+bDt0RbFcLQHsT957OkqcQq3glUfHp6sZgyxvmqopE7jKJQIENd5sxq5PClLoBVuT+GlpDAN24/bpR787uv/23/qDv5/Gzfr842effPDZJ092N4DOeqzV8lV3b5mYq/ZSt9cOwIcwDAmiev3xG/OzR0Mazjfbylb3Vqv1zcX56F9/7cQ4XWQRAKiEjBYF96cQnHNnlZtppHHc/uTPVr/3R2CckrSXVFahJQUhR/wY0yTJmNYkG1qmPnhQ/OlcLjXOmKqwFELhDCJst/v1ukWmEayXp8WmWr54dvG1+/OyLnJNwVOMU/LIBFZvX1wNL29OF8cX3Z4E3YJzxaxWXdhu95vnH304W56++rVvff9Xv3v65ANqzxfKr2ZVLmNYAiMMQ9e2OmJTjYkgeaf1oi4aWxerk483/vm+22/2jxbFsNvPLBiNyQesDQJrBJPvwhiotNKKSw3zqiggucZdr/f9xVN9+jiS8iGwrEIODVEYXjrkFk65DDepdJQSg8SD2CczPmdMhsX16clRYYS5tO2w23dGy3sQhWoR2cknd/t9PwwTutJaF8aVzgyXV6aolotVabTROW1kgzaZO589fMOV9fe+83/de/zw06ub77/3weWoHr/55ZOjo8eP33jw6NXC2DB6yiIelahx+GA1O1tUpeYH985Wi6q9vjip7dsPj7/y2oN2dzP2mxS7GHrgWNrcMRCqqJoCmso5i0olhGR1qoyK55+Oo89iQA6RRh+EcUqyjBOIjjkmTJntwEImvpqNSqiGYu677mS5MMgJebVo6qaRfMxRKZXD8756bS5O2lLM0UwDOGuNFvYLoOJ2Wz98+8yW19sLVEkrYGGJQM7ce/w6FnW62f+Dv/3Hs/nx8h/+W+kPv1VrwnFI86P5G19fnD6oHCofVE66iOgwNQVrKsqzxrfXX142X/2jb0Ealw5QjcffektrVZZW87iqS20dpZFTkHBp1LJyWhfOmgKjAqqc8f02JImJcucx19SJk8SaDJfTRFzhtmp80BhOzSuFAKSMD9EZPY5jLJhi9GGMiSyqs8WMuSNWxyt3elRKxBWbhKzEyi1XZI0sGHnsXFGaYua0zakVBLLVGnNd682z+w8DuHJB++3DAtaX63Z7g66sH79dzBaz2ha5W4JoojAlKIw+qulqN+4T+75Lm0unsamKIZBiXxRYl3VZmrIoCmsU6sRZSkisAaui0Gj2N5vj06U4Q4GddsMYaAo0wrBzruc7RsG5STxViybZLEkg54MKLiZlnFYuMwPvg5ZfZr3d3TuazWqsi7qqyqNlOasKo03vh3zFrM1TrLPAzSBiGGUxoi/F6YrkvbaucAUCW2c9ow5jd/HJ+tlnYXvFRX3y5v3F6r5entbHyxqTZczKNUmYSrtCjIJPFlyTA5hTpk6syBS6Lm1d2txTZmdkgzn5iSSklFDr0mIc6dknLxa6OD2pfRpjMU9CGiDlttGtLD3rdm/DzCSI/FzjnJtnaJCBiaM5W1RNU2Yont9MkWKklFZN0VS2qayzMK+LBBN/mKI8ZNyJxmhQXFYF7Hft1cfj1eX9s2MKI6gGmDB6x8pqVy8bWhyd3X/M0ZP3LLfM5dGZy0ocSb+y/0DgCIyz5RhSCbHQLEwLNYPLNEZyCEVvjBZAqoTwpBjUZBkKKOVCSPSLerlZ72ZzjEr1biW5nFMuaefe16GtdZDq52fBSfjLk4PIb574qgI2VQGZnOtcYCGLti7KGFNVWo02q55UCNELaYKpHyMRWkCZrLDwoNOzuL0OF09xu4boyTCmKCg0jDoxap0EwzmlNSGQSjEqLOfVYumHUSlMMWqlVJZOMRqNwqpAGUBli5gokkINpHIpxgrdIjxUPggR01QVzJkIQRdV5e6d9NtLVByrIyrnGSjTQZOPBy1qTiQoV8jK2enFpGSfpkCdK4yyTMa5qdIsXileDXZi83LPMSllS+tyPS/bpHw75ZdlxxJgSqSPz/xHT1W/pXan4qiSIu9t6ViBVpGHjcZOZaWiFnwpn2TMghmRQIkBATJxu49+zGUcIUGUAuSZEOdMogmWSoDA3DzgJOYvtxGEBkwLhBYUcFlVQ9vl2inG4pSz/M2ABp11AzTVShNOaJkRsvqJQa6oKIePTJ8zvpOMbGx+R5LwnqIS/k0se5YoKk59z8tZhblMLfwfeJKVE7GniFmUrqsShNSDcKQQjLPMgSmCtrJXkhECh94pIdPalUVRI7JmP3b7LPwgMUgWO0qyaxLlDeohDCm6qi5zeMCJ8ymVYgpZiIOSM1ISs2d16/dMYez2m9IZZhjLY6VAI1rtcqmHtEEQX85Vp0P9fyoSidUIJpYrcdaBs86rZWa1y+ZhKQPkSf2cNczTSA8Nw1AYwxlv5t4JGhKonruFPFWGJZcr0NZ27TCvyuhH1IU14laKFaYRKJAftVI87K2xMGzH9XkIrlndT5FtaeWh/X4cxzAmJnCuzF3ArqhqVxRZygzRj0pFJf6bAkEWUKQsBLzVJjBvt1fHJ4tF0wx9D6evWWNMrqNm2J81eRPH1iqnZZrU6HkCQkyGsrBncq68PnmBSB3Givzo1e3wU6YQ8vhRDIumICepg3KVHsBIuBB6rZ2GWVPcfwSbrR/k+WLotS4gB5TcGZHcn0jZovTdlocdpa3frrl5VSJStz3fXtj+Mmwu+t2+3/dNYSpjlMKh6za7fmVKQyjESOvoBxIULJk79wKEowPoRClLcvjs9Gxe6rFrdbPAxT35GYSsVjxkqRxtJVgYDblKnibyqtSkRVO51popB+a+X1UgEeXpsGgNhhAmbYOGSdiuouSAoJRwEyCCLNvRn18Riqq4VmTOXnlzfrzuN5S1Bil6nUoCDWjAgkoRBLuydaUKfdxtqN0rd2/9/KNv//N/dv/NNx+elMPF+fri5W9+/TFH9cd/9FUhcuh8UIPn0rIRM8gYTLzd58kyoU+UcxCAnlogABz84KzZVvf1bAk5mchWCzyRpcFJx5TrZ8YIXA4HX8vLJmEuj27k9cw9K+Q4db2AUyBkTcyFUAaVRfLJhwgqN2glxub7INk1CYO5Y0ZK2ZlFXig8s36/vnlCCVQKaewk5GuTBxocqAHCnnxL3Xrc7ZIuGPT1xRMLQ7u52kG9u7oKQ//aK2dDu3757JOjo9Xq6ITR+jFocBKatItjP80wZLQnkTUpASzGVjl7M8URDDAbOnnLWCsrMT1v3lSEQxeaATXkprxSJqPsaUVo8p4DYxWoZQTLkIpETkFENBY5ZzvIvE1cIyatFQmXF7/XSlYQxUyYNHGUDFdUzu9aplLcW2mCwBySz+MnaWSxuygUs73WafDtNhLY09fT0aPj+YMv16cQw/jyN0Pfla6CkqqKlrNyvpjbwhnrgkSaxFFSMqCTpc/l4ikbEwXI7cGYc3lWAemhOMZHXxPzyfogMa8sbTeYtQQH6dlBjOqsYcbbOabDmIx8jXL1zC9jtjgkI8lbVlhgW645QhY9TzVKytAym7YR9KUShEP+x6qAtqOUZ2DQMoUo7FlYkrWFbHFMNOzYhxTHROyOXjHHj3k2R4UPF6vd1adq9/7q3oPZfBbDDsLaGIbCKmvAaGtkd3WO9wya89jaocyOZhp/lKwvT26UsmH1avrqn0A1z6gt5/Es5UTUxugpNx2KHBlc50UzlAfJpmWZwMEE/AQLKzPhv9zMzG1vxWJEPA06SoLFnNzFQTkDTcrGmEIeY82LrhdO7VVuMrowtjFGgyr5VkcvKSAlFb1CTabUJ2f26A1VLKKsYgre8+ZlicGujurlUeyx37UAMYIycjOUn00CJd5C4FySSvm33DlK1mGOId7/5vDg68XpI7BumnqZyoM6/2iuneWUxhxv57p0NjPUGTKSnWB9FMpG0zylsUZTlKSlEQlp6k/DXdn9dgySpxJklmTx4ZfkNX23QkrBjFMbiJMxTgJoDGEYWAwbctkYyRRQHbvFvajKyMlHP/gWU2yMkNQgKbUaogFtwLrAaSTyMRhjCkW5u2YTTcB4Gn0UyMbiP1PhGYvH3yhOX8cDJhJoOk0DM5DEo9yom0DM9AAwFbVykJKMa7RgzxCyp0C2TTSYu7+CgCa0peGO1KnbAgncjqxO7TRJ8gysc1KMnNWOONVRVAV27vy2jzHR6PEAGQwBCpusZlDWO++TCugkfBmlClCFLgiXMF/RMNB675JGKyhn8D0p1kYHjVXuJqFG1rKCh4HMXPljAWQcoJgv7om7TaEo72ZiFXzSAnCiJJRsRJHUvh1SpLpuCky5naGEBHFME9EHzYd9UCbFGOPtikJeDvHCvGF8qzCWGxCAyZS7fDF7ZMb6E1Y4NIazV+vCUeY6EzvI+o0CrU1KCNzm4uN971kXxWxVl8u0Hy4//cy/fMFd66zeX77QKqHhjjZcElYGrHZWV4sZKWc1oQGlSptK74eJDwgIn1o3zbGyVWYSgqyn+k83jCGwQTdGHkNczps8ShjaPq63e7vrF01x2piyrGGC/DGA5GZDSo3D2HLWKmd8o25nHA+a4gm4T2D8IIHIyCD72mRqU+gXKDCJ0nCiITkwTBU6cKWualPNNWhhC8NmOP/02WdPtoNdnLxO3sDG10bZlMb17rrtAMEIwdpux00buuthYEdf/errj5s5AYKQmMiBBW2gyS1vzvnFxBRTda+PlGWBWUWi1K4LF9c9MViMCLCcF0URDR7cMya1ve73XSrMkiEYa6aR/SwrjLuu37V+t++MgKEMm4FYG5xaIZEOJTfIK5K3RE0RW+X4LKQBhW9mNRxMjpR9Pq+q0YIBjBbjNYWyhdLaAPnNYJgXVemqe7a+v3x0f2aKktj6vYkt06hoHNvLsbvphq1n31OAAmyBToPJsw5p9DmNHnozkxtQIs9q71btpnUulmXpnBnH8Xo/3LQ0jmNRWKfVbFYIJslSxMI5bYqRk2/h/Sf702OtAbtu6MdgXGmsa7vOj2MMwUhGlyCqCfNUqYKUS7xTA+du7HoiIIkznubDguXuxm2ViQ4xPdcIrPx0SqCtQB4hhBonl6iaR19+VB6/pexCY6G6nna7GPfDeC5rnzxxF11sZnUZuUpR+DskDRLxrbY0kfhcGMzz/FqAPqSRjbfL2IduTG6Mztpt213sox8jp2StEFYhGTmFUUox0c22/eT8uu+oKtzxegaUcogC4nFWFSrLt4wpzBSDMxnXAg1A6AFky6FJhpcTFE/jxhNVy6sgtjNtJUzepya2L+tTlSyBiUCB0Sqx0BeIQSEUzcIdvYL1MhKHOGgdlPVE6wSbQDFycDWqiD6NCVgZbS2GGDh5DJR0it5jVn0I5SOdGAOiJ/BQklt4CTy0H9M4du0wepoaPXxysqpMVprlckpM6eXLy7YfZmWZ4rDrh3aMAiONLgpttRrToAIB82LVmFwhyYPqU+9xmubII+Ah3KUzvkv12SElrx6KBbn7fVi7W/mVMbo6Ot68fK6yDMfnQQ+dekqs56dqdqTLOo09xT7GbRovWHVRU0hJWxOVsF1EtjYrFDiBpHJKNCqfFFFMMWNZEykNJIgmkErLIzdbxtETQ9fGq33nQ7DGjv0AANdbfzozhYFuGEpb7Pc9Kb06OtJ9iMmModv7UYWojS7ZApNWUFnHpMbrvVG3284T4sqIMRf3MOEhFGUCc4Dh6vMjPKbhB4YJTt8ORUxvqo6Wu/WachvBKpWCF77qGp1zTWIQ1upHcT4LEjk9WuH8Yr7JTmU8niRlwrdVrq6oJME4eCKVFEamMY8LEyNBaVhZo31UfR+HIXhOnqDvIzHsP7kY7s3vHRXzslrH8eJm3Y/UEVztegCzH0LebI4+xBgr5yTMRlnZEJKZuj8HYoKG8UBzMlsHmA6L+MJMEf8NffaE+w8vHVyQVEqEBudn9y4+eQKYAIbMCtm6GZhCSKIrKXjjHAdjaF4gFRa1ysquOAj655FigOSBlTMmphBCoAQphqyjxDHByLlvPvq6qvr11fXT583pvd6HMQTKIXwMkbROMaqorvtAHK7V7uHJScg/e7P325GY/VQigkMkEaBojZ6aiUbzJLSWbBBTCjFmR5V7UDn9H0aYp98K8KDHvs0hcFD7HchvRrRxqk4SF02trOmGcYwppJTrEhDSYQxAmwLAiBPlGkSuMGvWWmJTiLn4g5PoN6UwhnH0vh+8z4fyBFI+8RBS1w9a60Ij7S//2//6v/z2v/jTboiYZ8t9oBBpEgMl5qvN7sV1uwvQK9sGutztd7lJM3EWSYWHJwGtjcttv6o0R4tGcFAeduEJQE+zppPcKusDAQimziweGPAtIcqjM1Mj7JYiTTEMOcuhFfLi5PTFp58ag0krXWpFQVNUuW7qbMHGsZY/aZRLh0yU0bnodzHmdqc2eUwJiVQ/JoHkWrjCENO2j7veI6h5WRZI1vDFdv2//pN//MFvf/UP/v3/CDSSj4myZ6qpzoxjUps+bT56MoxiW4kluUwnARxoPCulwTqLAE1VzhrdFNpk1jDVDikdurCHoojKzcVppjEDgHwMBQsI4EPXRE0M8G5oLX+LM97HjBPLej7f7LdV4ZQiy8kqBG2N0kNMLBCgjKMTo025ngYYYwpZ6J4ob1HwFKkfU2DwMWHilKgf/bYPWttl5WR1hJnI54c4vveLn8yWR2//G/9umk4X4YOHEKtAmIa8PaSn85A4Ixn8PILKY0aVKlfM6rJ2uevPt4dzTIMNWSeNmaDdrsDUgYQDKYWs856MRk+1uVxUEHIPmXHfUhQmUojVbB5SvNnceG+KsSgbHUnpoUcskDn0O+6usW9T30/vpzjGEPM5UuIo0fcU024QhOhjlnelFLzXxi3qoi60RbaoMA9LsVI++I9/8+6jb/xdVa2mIePDZma/UBkHTVz3i8H08wjLMI6x0jY3VSWDmelnJoYOjLfdwdyKycEpfwhl/8oAKWeaL6b/rOhQt50hnpBlPjVLPX9xfrRcLlbHrNTFsyfJD81qtVisaldP1E7TGLp1aq8x9rmrxDGOXb83SJKFKMRxGPphDNz1/RQcgbko3KwuK6OEnU0wRalcNQJiNfTd01+98/jv/Ns4TazetVOZA+d6zmQ+U9+Z7/qIE51UIVA3+L0xgFQZzKezZKlevuGMjg+zZzi1wW7Lb7ninc1lWsIJI0nOUlnFlIdApioM5SrUxcX6n/zTP/1P/9F/vB36qpmfPXj85JMPnnz2SV1fzeqFs8YAc2hju07DzqhJ3xZCDD4KJiDylMI49LkxKClE59ETV7i6LCqLtUUjLEAj4EyPj+duPfaTvO7lh784euXt6t4bdxZ0OEvnblsPBZqcwW45+WE8RWHrfdjEpJrZ0cKEEFgeDGlqth7qBLezaIfjepTVU/vk8ypIyj2pfIhJXlLUeYWnzAaJ1T/7F9/54JNPjTHOua7v58vV4ze+9PzppzdXl/vdTjhjCiq2PHSUxug9qCxCUORD4ER+HEkWhctCG1SFNgaUs6Ypi8rp0qDJBm+MRgCD/Mdvzxjxw6s+21n4+N1vf+3f/A+VKW519bdPwndzdndV1sNy3fkcsFDZvYApNpOMKBc0DgzwVtuQqRMKLdPamvwPnBpCh4SlcmmOFE3dNlJfqAisN9u/+Mvvulyiq6oGskJ0Nl/dfwTWFjcXz/v9tttc++5GxTixpLowMcbRDzH6NE26sCokTeYeG7AzUDisS11ZLIzCrLw0GoX0pXRUwx+9XiLweStZeHv5/OJ3P7339T+club2fCb1//3F8IWpzcMa5CZYSC+vt+agBOGD19DnsQUmY7DamHxoDsU7dUS2lNwJEuKvKA9PwR1gVEr9+Xe+/+z5i4f3j1NIRruqFESVx0YwH1iA60vrrB53JkkYjqXwawVQJKrywJUPIRrNRlHpdGl1gaowUJW6LLQDNjCVKgHVNMxEGmFZ8Jur4rr3uSOoPvnF9+b3X6+OHv6N5fh/rY76ovEcKm3TIERIdNV6kxvwuVV0aEvfRnN157+ohW7RhBGnIYZc+BQvS+ow7wwT1so/5kP47vd+OGSpUaJUOJubfDZPUhvQCjQa59pNtUc7tDeQfJlnOfLRg37sGQt2WSRggUsHpVGVgTz8ZIykLW1R8JfWgnCVCsyjZi6MXVQIymdBvxra/ft/9X9840/+A13Ov0CQJoQ3DfTmae3DqXq3KqHbZBMi+BDMQfaafecgEhZ8OI17Z2Cgp8OwdIJp/jhOhZisZs2ttkNlbTIvVMi/+uVvP/704zyHlSiFOChTFsbYXAwmLuvEapW1Jix2AGG/zkdmMYopMoB2pmBKGriwqnZQanYGjVg1ZTG/BiZnNcWBUsh6hgjAxroo3AjV4eA8tbk8/+t//j8ePXx99fgr89PHWDXqUHM8PN1B8guK75LR4dSNg4GZdJjIUiHFELKkGFWRD4LAQ4Nj6oiaSbsPEptl6SNNMtqpOXUb+hRvNvu/+O6PhfoQN4XReQwDmPC2mmYlprhR22a+lIvFUaUQKJCw0GQwT8/lrp7TXFpVGiitUFmnxWyE03IqjFUcswHAQficJz6u9h1rkxj0bd9r6LbnH//yye9+VpT12etfO33zm7OTRwcZx91BkZPpTKTrLqnl+WsT4pS6KGTGpBSYfKCJzR3/TFKEXikPE7ee5kBipBRldW5xtwC7J09ffPf7P/3w6eXl9Q0TWQ6PT1a5e0kU5Ofx0GvJDWmUFI1AhTVkTG4Dcz5rk5BJK+GohU5aRYtmSvDWOpc7z1ZyB6d0eLYJw2rUIajP1iOx1ZByJQYzlct6Haa2a/1v/vrp+79YnT64/9bXj1/9uirKgzjodqae1Z2FMebBGxPEEQQExUAT5ENlpvrphMUPxig0AFKiPJciKDAeap+QYvrt+x/+39//8U9/8Rs3W7liFnNBtnS2cSqmlEcWD8Q2Tz7JhZ2xKo6L0g2hTq1VxmUabQ1yNjqyhhwqC2gNGESbxVxKPMsajpRCLsJkMKhVTGyt3rWw82oaCpuqoFM2JhL2I7gBExJen3+6vf6see/7J6995eSNbxXL+2oqhE7NszvclNXAhjM+Zc7KpsxOp2WKKaGR8EOTZF8lQQfTHAyDMCZiP4bf/ubD7/3wp+/99v31rq0Xq7qsQz7Fymi3qgunqNvt6+OTXF9LuTYgZH1qR6JS0Y8a1bypR/ZkFKqkgbKajgzS1Ni3yPlMKa1YjMhohng44BURSRliDimixg9e9GGSeOU27F3pIZdfNN11JnKm2sWr7lfrlx++t3z05tkb32ruvaq0vTtJ5/PiH/EUZmI+NTIfejldhigl5HyEbCZGgsLFsiKFpNquf+fHP/2L7/7gat2NfmzbFq2rqtkwekTNnAyooxoLHDY3L8+OV7mDPeFQ4QQUhbcNXVc40w9tYbSpSnAqxdFqZQRbBcXRoLF5OiZXP7QTD1NKReHHWUQ7dZUS88gq6ObD9Yay1iVTSZ2bqGrquKhpwkd9XkEXJ6Toad9/9KvrJx/U86OzL31r9erXTVEfxuwyMTCZbMGEiQ9nJh7GdXLvBGFqc2DuG8UQX7y4+P47P/7eOz9dtx0rCCF6740xpmhSbkVmbzLCCRwWMGzPn7QPX6maWS5xTwd8gdM6op438+CVKvrEwRUFJHlBcQQiYNRoMFsZsHKyNiYLT1NWumiGpNBKbgkp9zzDh+frm46m8zGTfBAcjiPIm6MP8sq7dI8HFpmNg4h8eNmtL56/9/3VwzdP3/q96vghoGEmoXjEtwBGTUqswzUSTdhIJYEW4YP3P/7hj9796c/e2+z2aBwrGL0PuTWciFazWVK39GTSl6Ap0fjden31zBav46Q2y0lNAdel6RKOMcmDWwuQtC4VeWDNJLRLjIhIo67KUueD1DiE/PiHcW6FebiSMaFOtvjV857QwBfqnxMZmvS7cOtu05ThXZKfFms6NHuk5Pf78eNfrV9+vLr32tGrX6vvvWbSNCM9nS8BBw4BU4siR7ih7X/y7s++9/0fffjJZyHGnDt1ymd6hpi0FhssXJF1lDqfiJunz7UhinVhwN/025ebqp6vTkChnaq4ilBRXVqOVYQ0hj73kbLnSGYD4KitMZK/wJosb8kQAZEphSRQzaak5OZBE+LLfvzwatS5hjCp7SY+mjMZ3h2xpG6r759DwoOYCg5n6AD4mGLbh8/e3zz/aHZ0YuBQzbkl7ofeiIohXFxcvvPOuz/6yc9eXl9lSJE1oVPXVDZHWW0nf66aWUhBbiRhHtJQxpj1kKrKmHQD7Xq4PjeART2TYKLyKB8HVNQURVBUgEL2iiJI6AkqRoTEKTCTRbA641ZQxtro+0RBaUfTQGY+sJWM+rOf/GZMEHNeNUYfSsTTgdPT+PcB8SDfOYi6KyBPZa/DqLXKAy8S1FLqXj41kEu2UyTKc7c8dN17v/jVj37086eX5+vtZhyGXI/OUi0hHJANkrTYyF1zEfJRIDS9R3iJ1ruOR7aFGcGv2S/H3RoVYllOp2PnAyoYkLEoGFlFSFFRjCpBVq6SBsiScZzKrDRVGRWjKWPMhxeZcurDv/e7859/uiVOKR8ipvORB7cNmWnuC6eTC/8GC8sRPr8tn2Jz+83JG8U98+smpXCX/G6ubn70o3d/9JOfr/ddyJ1X772+HQ7Kk2aTpeEdyjiMnR2QumJKUx8bUQ+En110v//WmeFOp14lH4dWa9Cly4afYShA1hsLZcvK+YgT8T2cQzFptSXiTse+ALjg88izsDH5tJf78D99++eJMXLUwmDxIPDIN517DllexPH2AFh1t3CfL8pdVfr25WneB/Jgq7jUzdXND37wox+886P1vpf8RWmCP2L709gn5yMJD7MMnAeED1tktQ7e5yVLt+fwKEQHuvjgXAhWqTxQiwKtxuA1AGnrLJok9MZzHKPvKHqhI6xuhe6Yz8JQtiyzfHI6FYX7wYs7aIdCNCiC/Z+//d2rNk2SgXzQXJ6CPhz0rCb0Dqhz8S+P4kuwg9sCsvriWeef/+OOnTKYH/7w3V//5oPf/PaDzX6fpooG3RYM786Xz4lOCP+hhjmRFpjUWuLhMaA2nHueh+wgAbn89Lr77m93/87vP1ChRb8T9j3CmCKUCawTsq5zWks6JuVz1UIWN/8/AXIvWB6WMvTKIxcqZ387VUl7Mv/Dn77zzgdXpDRRUNPpQtP5Qge1PNyeVcIht4m/6GV8+/90YL49Kf92rb5oXPrZy91nz152wygeTlPPnvNhLSlRPEj1DqZzqzWD2z5ztsmiLGOKea8yF8+cO9P+MaT08YvdV159fH9pOYzaFKSymneKoqTM1GhmQlSlsYVzVhvjLOYDIz9Xr9EkOCBGC6hJmc7M/5t/+pc//PWzQMB+jLJD2lhzF56/0GQQbNa1++lcdpjM7MDiP3e3Awq8tay7V9H7IQoNOwyF5FBHmVFENams6K7YSNNxDneFOSGX00FDOYLwNJCV6f7/Q9nV9MZRBNGu6p6ZXa9tDEpARjlwhQMHbpz5eTkhJG7kwCUHDsgSSIRwiRASJBjFkASwRRTZKwJ2PBnvfGR7pj9QV/XMrI0VxGoPq5U/tL3Vr1+/fvXaOcsH2WUrdu4+aXFDCm11gdCiN5a/T0qYktRuqjhmMAZlOSoHBKnYkcRRGx0Vt/O4hPU7+8/2/jgNgGcpLzzUluT1yMfoTSQNPexzyTjmhpV9QM/xSHQsq4tPZDs+U6/+hhHrvRlo9Xgu4MUo5/aRXxB+LyArBjppVxDOIV++Idzj48X8xVSoaeIaZRspDKU0tdY5IAYohSd8FeRZkEqpwJtpBSPEDcQgTC6ZAKp68sZi+71bd3/nAyBnWm8NDiUQXW1IYhMrpWitGZ1h5yVFgLFqLn2gj35YLhYb5phg/YN8k+Jfx0deRP+e5w5q0vT4P1MgIZn5icEByjRVSVbV+sNPv7i3/zQghF0mwvGeio6Foy5D/mHJW3YQSspUkmoYd9eopMpkltnZlc13P/h5fjyfHwXIs8Z7CxhoF8kVSIWDnk0UZM6ngCwDfSTnZar0+c/nVyyaQijHTa0Bnm2Udvo1O14FA9B3CPVRe24F9j3SWbyDvkWcQM+LqKIFYth5kVfdja/2Jlny/jsTdHWG05bXVJDsyGSfBMubSZLxt8uOVgSK809mR/li5/t7i1sPH/7ywLVdWLlZ4GIbIU0rwdMUgTb0ZIsDr/UyAg8MW3xYBeOXPORsuuVjrK+Np2iDpjbU3tiiB6vD7GMurPJxeQ+7bqZaAL5uFs+f52flmXVukiTait1fn3Sde/ut7WmWAFKgAg8r8sm34zri6cn+CNrV4UkjPvr82xtf/nj099nh4bw8zQMfd3YIRQSQSPORndDx/gQ6MhPCVdWZ5LszIBqmhzX+vwdosrbhXOdpgR+v8lkZDoDV63QuVqMQIssy7m+QxNAQwHT65OTPosiN0bQAi9n6BgBoC/vz4rv7B8K77Subm69sUtef4OnsBSkYnC4WXhsvfOPw693H12/efnSYd8Z35BxpdaMkG3ccfWYlMeX8KGosQt7x8wlKVZ117QvGMmA9B/BS3PGcntnDCj9lNlmPIEJwAufJQvxD4zsX2Hok7EQRrNbLulkUxbP89KQN1HH4MZitzTzZaxCxMrC7f/TD3m/XXt9687VXo0AFwxwD6rfxBsRfZfvxZ7dvfrNb6Bgb6ymFryjyVmtETFOFUvWXMSGnUFA1JSgVgZrKT4+pi1H243L56EBUWll6hUFuk1k2EzGsKHKm/zVAxpiqqqqmLKuyrkutG2M6VgQwdkUEtF6bTpmP+9hqBItld//RwdVpcu3qFqfPc1M7cn9Imt55cHD9k52fDp6aaA+IPK1r27qujDXNcqnbpQBMkjSQSoqT548vRPg6qnpRlkXXauqwjbMPIhbgywYovhNe/hMAAP//1qTUQGbX4pUAAAAASUVORK5CYII="}, "pbakaus": {"name": "Paul Bakaus", "url": "https://github.com/pbakaus", "avatar": "data:image/jpeg;base64,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"}, "blader": {"name": "blader", "url": "https://github.com/blader", "avatar": "data:image/jpeg;base64,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"}, "upstash": {"name": "Upstash", "url": "https://github.com/upstash", "avatar": "data:image/png;base64,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"}, "obra": {"name": "Jesse Vincent (obra/superpowers, inferred)", "url": "https://github.com/obra", "avatar": "data:image/jpeg;base64,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"}, "BuilderIO": {"name": "Builder.io", "url": "https://github.com/BuilderIO", "avatar": "data:image/png;base64,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"}, "tt-a1i": {"name": "tt-a1i (archify)", "url": "https://github.com/tt-a1i", "avatar": "data:image/jpeg;base64,/9j/2wCEAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDIBCQkJDAsMGA0NGDIhHCEyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMv/AABEIAGAAYAMBIgACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/AO4tprS9lVGXy3PTK1o67rMWkaOqxRo9xOdigjqAOSfbpn644zmuTv5LjTXWeWHAXkuDkfWsm5v5tUumupmJ42Iv91R/9fNcsI2d09C6UeeVmMnlMsjTTtvkc5ZiOSaYVRRkqPypv35/9mP+Z/8Arfzpx5lX0UZ/H/Oa2O4RtodUCqSeenQVfsNKa+LvhI4I+ZJWHAqkqjezdzx+FdNbx48LxQrwbuURk+zNg/oKAZp6fothaxpIlurOQDvkAJ/+tWiIk/uL+VSzYisPMAzI24j6Af40QQNM6xK2DjqaaJurEAEJkZAqblAJGOgPT+Rp/lp/cX8qrRgNexzAYMkJDj3BGB+G5qsSFozG2PkZipPvj/I/GmK5pacyA7Cq45HT1/8Ar/zqv4hhHkwsqooDEEkAAcVSaeS1mMseTuRgB/tAEj+v5CpvFdyy2UAjAZZMtnr24po5ayszmdb1KNbExB45XkPC9CMHJyPSuWgQpEASST1zVSHUG1O4MsrnznOWUDoo7Z9P8av9qxjDlVjegla5FCN0e4/xtu/Dt+mKeWVQzH+HrTWGyNQOgKj9RUUjbkmUKxOew9hVmz0RPbZlMUR/1jBQfqeK7qK0EFvYQHpHKSc/7rGuD06QnXYdwKp5kIXPchiT+hFeiXrLFEZnICRKzkn1xj+tArk80qxxM0jfIi5PsKmgm8qVJVwccj3rBvbvzV1G3j3vJ8kaBUZuSPYe9Sf2pDFp9i4bAfywd4KnaR15pk3T0ZfRR5uCeVmYj33An+p/KrU7b7VYsfcbfn15B/pUEgXzlb+I4x+Gf8TSzuY7eVx1VCf0oCwySTCtuxmJlc+65yT+Wa4lZHvoraS4keUhdhDOSMqMcD6iur1PfHGsu0Ng+W4zjcjcH8eR+VYEemyW1vbgGNoyxjBVyW3bSeQQOuDyM1cYu1zjxMldR6nB6WzRade3K4DqNqE9jj/64roFAihA5wi459q5WWcxaYlupxvcu+O+CMD9BXT5EjsmflZARjv1z/Ss2dVF6WFJ3xA9OQTntg81UGs6faXbPNdxBVI3dW2kqcZxSxzKqSRykLhs5PQEn+Weapaz4YXUdHdoICL57lTISeWGduPpzTWoVZ8qL1pfQPLA8NzFKFmyuxu20YyOvb0r0PXX36BOyc7kDDH5/wAhXk/hrwhe6dqCR6hYSwzHzDHOsmQQCoChfcknPevZ7LQ7p9Pt0upFwhH7rbyVxggnPoT27UNWdmRCqpRKN05srZ7+JAXkn53dNyMoH6An8KZbarpitFDdXNosW9kdVuEZRuRvlGD74xW1f+GbfVdIXTbuaRoDJ5kqIdomOOjd8ZwePSvBLfwXqllcB9Vt7uXQ41W5mSKbYGYqBgdtwJI6ZwPenGLexlOqo7ns4K+dYxxsCqs+SvAbCkZ/HOfxqXUJhHEI2P8Arv3YwMnJwOB34Jrm9O8GzeFdV03+zrqc291BuuLadgwgI27iD7k4x68811e+UX0KxrgMpVpRjMeWUZGe/OKRup3hcoatcxGziIcFHk7c/dBP8xVWyt/7SneNXePYmVYgrhycKee3Dfn3qTWChnCli26Yszt1ISMRtn/gRqDSrwHXpoi4+eELj3XBH5hj/wB81unakzinaeJV+x5XPZyJclCpyTjGO9XLS/kgdFmBxGu0jHOP84/KtjWtUsrmwY4Tzx91kPNcvKzpHIzcttzyepxWK13KjOUXdHRRGOW5cqVkinjz6jjgj9RW5YSefYoX5cAxuT3I4z+PX8a57R1DWCk9Vc4P6Vv+GzGNfEF04W3nlUgt0DYAwfrgD/8AXUM65LmipHc+HtFKBdQvGeSZh+6DnOxfWtiG6kk1G4tmi2pEqsr/AN7Of8D+VW8YFIWUMASAT0HrTMFpsLVRtNtWl3smRu37Dyu7Oc49c81bpk00VvC808iRxINzO5wFHqTTvYGk9zIvwv8Aah4+ZYV5PXlm/wAKyZrtoNTZYZV84xIgXOdgZiNxGPYAe/Y44swahDq1xPe2+/ysiJCwxuVec4+rGsq2/f6zft1VrmNAfQImcf8AfQP50G8Y+7YdqKgahEg4WGDCjP8AeP8A9gPzrl7JpbTxdbzvIpWeVsANn5SzIAfyz+VbfilPOu9GXcy+Zc+QzIcH5iOM/gaxvFtjZeG/EMEFnvWMIkh3tnb8x/TArXmvDlOOcHGu5+hzkOkNdOkSyKrSHAJHSqGowGG6khcg7CMntwBW3aS3UF5aCW38vcQRuyMj1qhqsJkuJz/fIH54FZK6eoWJtAkZrJd3BJYkemcH+taDkm4C9iBuHqMN/wDWqpoUDPcGAfeZgF/HA/mKuEYu5D0Kxjr9T/hSe530/gR0uheMb3TreGK8zdWwUcsf3iDHY9/ofzrt7LxDpGoQtLb6hAQmd4ZwrJg4OQeRXhV74ksrGERKTcTEfcQ8L7E9q09Ej/tmwjvTGsKs7fLncRz24FBlPlvpueqXvjHTYWMVmxvZ+wh+4Pcv0x7jNcN4i1nUdSv4YLuVRb7TIIoxhAQRjPqfc/gBU0EEdum2MY9T3Nc94jluk8QaHHCWEc8jRyYGQVyuf0JpJ3ZKsndnpGmQLYaTCjEKFTe5PYnk/wAzWH4avDLcSvIMNNIWwf7zAt+m0/nWvrMzW+gXJY/M0flk+7YXP61zumF7e1026Iwsl1hj2GQB/VqZ0FzXLlG1bTLR13N9pWVFDYJZZAMZ7ZVyfwFcd8QrqR9eYyxSRuYUBjkcsV9smtTx0JBrcaqzITFvR1OME8ce4KZ/KuL1ZprtxPO8rzOBvMhJI/GrRx1n75seG4LyZo5bkyspI8ppGJ+UA9Kt6hGEEkrEABlJycelR+GQ1shM9zCYImLDMnK5H8qryWR8T68LGa9S3sk+do1Ybig6ux6L7A/lTZnFOT0Nzw9FH/aWnypIrRlsM6nIY8kY+pJq1r2i51O7j85ooZo1bMY+fktkD07/AJ00/ZIfC63NnsiH2wParnlVUELkewB/GtPU761vI7K9EkflXEJDBmHykEcH/vph+FQtzsm7Q0OZtPCul2ijybBZpD1kujuA/wCA9D+Q+tbltbR2kCwxKqqMnCqAMk5PAqNfKj/1dyFH90sGX/H8jVuzjkvJCoVQg6yhtyj8uc/hSldmEWiWztJb25SCFcsx69gPU10eo6TZwpptsADLFIZNx6kY5/M7fwBqW2u9E0Cx3C8ilkcf8s2DvKfRVHNU57rDm/vXjjkMbSGLeD5SgfKpIPJ+9nGec+tJIuLuzivibr72OmWltbSbZZbhm9cogwQf+BH9K6TTms7iwGmykKB+5wTg+aAGYD3G4fka4X4mWyNZeHE8yM3UqzM+CMqD5Z5/HJ/GtzQbqw1OXVdOurgRPLeG9tnDhWBbkFT6gAfgfrVtFRqXkzR8Z6bJd2tlegZNszLIAOzDGfzA/OuHktRJNll6wucfTIH8q9MvdTsdLtEa9v0dn+Q5IAlOOpA6e+P8BXE6tqGnzX3n2l1bPAyeWFQlTHxjoQMjPcevOKaMq6Sdz//Z"}}, "version": "3.0.0", "kind": "map", "source": "diagrams/skill-map.json", "avatarsEmbedded": 9, "meta": {"generated": "2026-10-03T20:20", "project": "super-board", "sourceBase": "https://github.com/EricTechPro/super-board/blob/main/", "root": ""}}</script> +<script id="visual-data" type="application/json">{"title": "super-board skill map", "pack": "_skills/vendor/super-board", "branch": "feat/sb-cleanup @ b67241e1 (v3.0.0)", "sourcesBase": "", "kinds": {"public": "skill or command a user triggers directly", "lane": "board lane skill: started by /super-board run, also runnable standalone", "external": "skill from outside the pack (origin field says where)", "verb": "an Impeccable command", "script": "shell, python, node script or saved Workflow", "hook": "Claude Code hook or guard", "board": "state: GitHub Project, config, ledgers, repo"}, "nodes": [{"id": "super-board", "label": "/super-board", "kind": "public", "what": "The autonomous GitHub-Project pipeline: five verbs (onboard, lint, status, run, stop) take one board shape (Backlog · Ready · Building · QA · Review · Blocked · Done) from empty to drained, with labels qa · bug · feature routing each card.", "when": "Eric types /super-board <verb>, or says \"drain my GitHub project\" or \"stop super-board\"; with no verb it asks which one.", "how": "The session is an orchestrator only: it routes the verb to its reference file, dispatches lane agents, and never does product work itself. Board state is the only state, so `run` is also resume. Every commit, ticket, PR body and comment follows references/writing-standard.md.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/writing-standard.md"], "verbs": ["onboard", "lint", "status", "run", "stop"], "sublabel": "onboard · lint · status · run · stop", "opensView": "super-board", "author": "EricTechPro"}, {"id": "super-collect", "label": "/super-collect", "kind": "public", "what": "Finds problems in one project and files them as verified tickets into its super-board Backlog: five built-in sources plus any custom source added in onboard. It never builds, edits app code, or moves a card to Ready.", "when": "Eric runs /super-collect (all enabled sources) or /super-collect <source…> with sentry, posthog, github, prs, architecture or a custom source's name; optional --since and --yes.", "how": "Fetches each source for the window (default 14 days), sends every candidate to one fresh verifier sub-agent, then files through super-collect-file.sh. Dry-run by default: it shows a plan table and files on confirm.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"], "verbs": ["sentry", "posthog", "github", "prs", "architecture", "custom"], "sublabel": "sentry · posthog · github · prs · architecture · custom", "opensView": "super-collect", "author": "EricTechPro"}, {"id": "ui-refine-loop", "label": "/ui-refine-loop", "kind": "public", "what": "Unattended Impeccable check-then-fix loop on one page or component that ends in a draft PR with a Before | After table. Standalone: no board lane ever starts it.", "when": "Eric runs /ui-refine-loop <route | component | description> [\"what's wrong\"] [--rounds N], or says \"refine loop\" or \"polish this page with impeccable\".", "how": "Reads the target's code, grills Eric (at most 10 questions) into a taste file, then runs the saved ui-refine-loop workflow: each round fresh checkers rank typed problems and a fresh fixer chains Impeccable verbs, polish last. Default 5 rounds; a finish reviewer grades every fix. Commits are `💄 [ui] <slug>: …` and the PR body uses super-board-pr-body.sh's marker blocks.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js"], "verbs": ["<route|component>", "--rounds N"], "sublabel": "grill · check · fix · draft PR", "opensView": "ui-refine-loop", "author": "EricTechPro"}, {"id": "visual", "label": "/visual", "kind": "public", "what": "Turns the current work into one self-contained HTML page: a branch recap, a plan, or a map of a folder or architecture, with diagrams, a file map and annotated code.", "when": "Eric runs /visual, /visual recap [base], /visual plan [file] or /visual <path>; with no argument visual.py detect picks the mode.", "how": "Writes a data.json from git facts or the plan, then visual.py render injects it into an inline template with no build step. It screenshots the page headless to check it, and offers to publish only on a yes.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/visual/SKILL.md"], "verbs": ["recap", "plan", "explore"], "sublabel": "recap · plan · explore", "opensView": "visual", "author": "EricTechPro", "credits": ["BuilderIO", "tt-a1i"]}, {"id": "sb-onboard", "label": "/super-board onboard", "kind": "public", "what": "An 8-step setup wizard (Checks · GitHub · Board · Branch · AGENTS.md · Policies · Bug sources · Review) that installs or repairs what the board needs and writes the config once.", "when": "Eric runs /super-board onboard (or /super-board:super-board onboard after a plugin install), on a new project, after an upgrade from 2.x, or to check and repair an existing setup.", "how": "One AskUserQuestion per step with the recommended option first; must-haves are fixed without asking by super-board-setup.py. Answers save to onboard-answers.json as they come, so a halt resumes, and repo files change only at step 8 after \"Write everything\". It ends by naming /super-board lint.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"], "author": "EricTechPro", "opensView": "sb-onboard"}, {"id": "sb-lint", "label": "/super-board lint", "kind": "public", "what": "Pre-flight readiness check that walks Ready, Building, QA and Review, flags issues that fail any of 18 criteria, proposes a qa/bug/feature label, and dispatches a helper skill per flagged issue.", "when": "Eric runs /super-board lint before a run, typically after /super-collect filed new Backlog cards.", "how": "Criteria 13–18 cover what the loop needs: a parseable `## Blocked by` line, a fake with no follow-up card, too big (over ~400 changed lines or many areas), the ticket sections, a checklist AC, and lettered Context steps. Phase 4 routes each flagged pattern to one skill sub-agent while Eric keeps the pace.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/lint.md"], "opensView": "sb-lint", "author": "EricTechPro"}, {"id": "sb-status", "label": "/super-board status", "kind": "public", "what": "Read-only snapshot of the active config, every column in board order (Backlog included), and in-flight workers.", "when": "Eric runs /super-board status to see where a run stands.", "how": "super-board-status.py reads the board and local in-flight state and prints the columns in the board's own order; it changes nothing.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/status.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-status.py"], "author": "EricTechPro"}, {"id": "sb-run", "label": "/super-board run", "kind": "public", "what": "The autonomous loop: repeated waves of the super-board-wave workflow from this session until the board drains or a halt gate fires. Also the resume command.", "when": "Eric runs /super-board run [--low|--high] [<slug>]; the default worker_backend \"workflow\" stays in-session, \"claude-p\" opts into the legacy headless runner.", "how": "Each wave: rate and usage guard, plan with super-board-wave-plan.sh (which refuses an old `variant: qa-only` config with exit 65), act on sweep/flag/stranded/resume, claim cards by assignee, launch the workflow, reconcile, report. Halts after 3 zero-progress waves, a high block rate, or a stop.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run-workflow.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "verbs": ["--low", "--high"], "opensView": "super-board-run", "author": "EricTechPro"}, {"id": "sb-stop", "label": "/super-board stop", "kind": "public", "what": "Graceful shutdown: stops the wave, posts \"stopped mid-flight\" comments, releases assignee claims, and removes the wave lock so the next run resumes.", "when": "Eric runs /super-board stop or says \"stop the run\" / \"pause the loop\".", "how": "Stops the workflow (or kills the legacy dispatcher via super-board-stop.sh), comments on every in-flight issue and PR, and strips bot_identity assignees. Resume is just `run` again.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/stop.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-stop.sh"], "author": "EricTechPro"}, {"id": "super-build", "label": "super-build", "kind": "lane", "what": "Builder lane: takes a pre-flighted Ready card into its own worktree, makes the smallest safe change test-first under the 400-line PR cap, opens a draft PR and moves the card to QA. It never merges.", "when": "Started by the board: the super-board-wave workflow runs it for Ready cards labelled feature or bug (or unlabelled) once pre-flight says proceed. Also runnable standalone as /super-build (legacy headless claude -p dispatch).", "how": "Follows run.md's Builder lifecycle. An explicit `Skills:` line wins, else the type label picks the chain, always plus ponytail first, verification-before-completion and a code-review of its own diff. Past the size cap mid-build it stops and proposes a /to-tickets split. Commits and PR blocks follow the writing standard via super-board-pr-body.sh.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/references/decision-policy.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/references/worker-preamble.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "opensView": "super-build", "author": "EricTechPro"}, {"id": "super-qa", "label": "super-qa", "kind": "lane", "what": "Tester lane: builds an issue-scoped test plan, runs a test-gap check on the Builder's diff, captures evidence and screenshots, then passes the card to Review or bounces it to Build.", "when": "Started by the board for cards in QA, and straight from Ready for cards labelled qa (they skip Building). Also runnable standalone as /super-qa, a BFS route-crawling bug-bash, or /super-qa <url> for a live site with no repo.", "how": "One observable test per AC plus the test-gap ledger, High gaps written red-first. On a qa card it creates the issue branch itself and files real defects as bug cards. It ticks the PR's ac block, writes visual and history rows with super-board-pr-body.sh, and posts `[qa] [report]` comments with screenshots pinned to a sha.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/references/iteration-preamble.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "opensView": "super-qa", "author": "EricTechPro"}, {"id": "super-review", "label": "super-review", "kind": "lane", "what": "Reviewer lane and standalone PR review: forms its own hypotheses first, remembers prior findings, classes every finding, and merges only through the merge gate.", "when": "Started by the board for cards in Review (always on the session model). Also runnable standalone when Eric says \"review this branch\" or \"is this merge-ready\".", "how": "Thread scan, prior-report round 1, own pass with code-review, codebase-design and ponytail-review, a rerun of the Tester's exact test command, then an adversarial truth-check on non-trivial diffs. One report comment is edited in place every round. A clean review merges through the gate pinned to the reviewed head SHA; exit 7 or 8 parks the card in Blocked with 🙋. Visual problems become a UI ticket, never a ui-refine-loop run. The truth-check sub-agents get a fixed verbatim brief, and Over-engineering is never a Blocker from any of them.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-review/SKILL.md"], "opensView": "super-review", "author": "EricTechPro"}, {"id": "gh-board", "label": "GitHub Project board", "kind": "board", "what": "The configured GitHub Project with seven columns (Backlog, Ready, Building, QA, Review, Blocked, Done) and three routing labels (qa, bug, feature); the only loop state. There is no Skipped column.", "when": "Read and written on every wave, by every lane move, and by /super-collect filing into Backlog.", "how": "Cards move by `gh project item-edit`; assignees act as claim mutexes; PR threads start with their owner lane [builder] / [qa] / [reviewer] plus a label. A card dropped on purpose is closed as not planned and moved to Done with a 🤷 comment.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run-workflow.md"]}, {"id": "sb-config", "label": "super-board config", "kind": "board", "what": "Per-project JSON config: board, base branch, timezone, the seven columns, labels, merge_policy, migrations, worker backend, model tier, truth gate, plus `collect` (sources and custom[]) and `refine` blocks. No `variant` key.", "when": "Written once by onboard at step 8 (and migrated to v3 keys by super-board-setup.py fix); read at the start of every run, collect and ui-refine-loop setup.", "how": "Lives at `.claude/super-board/configs/<slug>.json` with `.claude/super-board/active` pointing at it, validated against config-schema.json.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/config-schema.json"]}, {"id": "base-branch", "label": "repo · base branch", "kind": "board", "what": "The project's git repo and configured base branch (never assumed to be main); a card is Done only when its merge commit is an ancestor of it.", "when": "Changed only by a merge-gate squash-merge; read by /visual and branched from by every worktree.", "how": "Lanes and ui-refine-loop work on their own branches under .worktrees/ or .claude/worktrees/; the opt-in protected-push guard can block direct pushes to it.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-review/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"]}, {"id": "run-manifest", "label": "run manifest", "kind": "board", "what": "Per-run ledger at `docs/super-board/runs/<date>-<slug>.md`, one line per card per wave.", "when": "Appended during each wave's reconcile step.", "how": "Each line records card, lanes run, final status, column and detail: `| #N | <lanesRun> | <finalStatus> | <column> | <detail> |`.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run-workflow.md"]}, {"id": "qa-board", "label": "Super Ultimate QA board", "kind": "board", "what": "Separate GitHub Project (Queue, Testing, Done, Bug, Flaky, Skip) used by standalone /super-qa as its loop state.", "when": "Written when a standalone super-qa iteration finds a red spec; /super-collect bugs and qa-card defects also go through the same filer.", "how": "super-qa-file-bug.sh creates a `source:qa` issue with the evidence body and sets its Status to Bug (Flaky and Skip for the other outcomes).", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/SKILL.md"]}, {"id": "taste-file", "label": "taste + direction file", "kind": "board", "what": "Per-project design taste file (default `docs/design/taste.md`) holding the grill's goal, direction, keep and avoid answers plus taste rules and slop tells.", "when": "Written after the grill and committed as the refine branch's first commit; read first by every checker, fixer and finish reviewer.", "how": "Starts from the neutral references/taste.md when absent; each target gets a `### <target>` block under Direction, with \"you pick\" answers marked (picked).", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/grill.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/taste.md"]}, {"id": "refine-ledger", "label": "refine ledger", "kind": "board", "what": "The only memory carried between refine rounds: one line per check with score /40, before-vs-now, and problem ids.", "when": "Appended by the workflow after every check; written to `<run>/ledger.md` at finish.", "how": "Checkers reuse ledger ids so a problem that survives three checks is called out; stop rules read it (two clean checks, two reverts in a row).", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/ledger.md"]}, {"id": "draft-pr", "label": "refine draft PR", "kind": "board", "what": "The draft PR from `refine/<slug>` against the recorded base branch, with a Before | After table, score line and finish grades.", "when": "Opened once at the end of a ui-refine-loop run; never merged by the loop.", "how": "pr-shots.sh commits round-0 and final shots to `docs/ui-refine/<slug>/` and prints a Before | After table pinned to both shas; the body uses the writing standard's marker blocks (status, problem, solution, ac, history, visual, risk) and is humanized before `gh pr create --draft`.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/scripts/pr-shots.sh"]}, {"id": "gh-issues", "label": "open GitHub issues", "kind": "board", "what": "The repo's open issues that are not yet on the board and carry no `source:*` label.", "when": "Read by the /super-collect github source.", "how": "Fetched with `gh issue list --state open`; real work is adopted onto the board (`--adopt <n>`), never copied into a new issue.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"]}, {"id": "claude-settings", "label": ".claude/settings.json", "kind": "board", "what": "The target project's Claude Code settings, where install.sh merges the guard hook block from settings-snippet.json.", "when": "Written by install.sh (backed up first, never adding a command twice); read by Claude Code at every session.", "how": "Wires PreToolUse, PostToolUse and SessionStart commands to the scripts copied into `.claude/hooks/`; `--protect-main` adds settings-protect-main.json.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/settings-snippet.json", "https://github.com/mnphuc/super-board-gitea/blob/main/hooks/settings-protect-main.json", "https://github.com/mnphuc/super-board-gitea/blob/main/install.sh"]}, {"id": "hooks", "label": "guard hooks", "kind": "hook", "what": "The pack's Claude Code hooks: four default guards, an opt-in push guard, post-merge worktree cleanup, and two dev-only hooks for the pack itself.", "when": "Installed by install.sh unless --no-hooks; each fires on its Claude Code event and matcher.", "how": "Python 3 stdlib scripts that read hook JSON on stdin, print a decision only when they block, and exit 0 on their own errors so a broken guard never stops work.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/README.md"], "opensView": "hooks"}, {"id": "guard-worktree-path", "label": "guard-worktree-path", "kind": "hook", "what": "Denies `git worktree add|move` whose target resolves outside `<repo>/.claude/worktrees/`.", "when": "PreToolUse, matcher Bash, on every shell command.", "how": "Parses the command, honouring `cd X &&` and `git -C X`, resolves the target path, and blocks when it escapes the worktrees folder.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-worktree-path.py"]}, {"id": "guard-secrets", "label": "guard-secrets", "kind": "hook", "what": "Denies reading or piping dotenv files, SSH keys, .npmrc, credentials(.json), service-account JSON and .pem files; .env.example stays readable.", "when": "PreToolUse, matcher Bash|Read|Grep.", "how": "Matches file paths in Read/Grep input and in shell commands against secret-file patterns and blocks the call. One plain call to super-board-env-check.sh (no pipe, chain or redirect) is allowed, since it prints only present / empty / missing.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-secrets.py"]}, {"id": "guard-key-literals", "label": "guard-key-literals", "kind": "hook", "what": "Stops a live-looking API key from being written into a file, and flags one already on disk.", "when": "PreToolUse on Edit|MultiEdit|Write|NotebookEdit|Bash, and PostToolUse on Edit|MultiEdit|Write|NotebookEdit.", "how": "Scans the content being written for key-shaped literals and reports line numbers only, never the value.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-key-literals.py"]}, {"id": "guard-delete-outside", "label": "guard-delete-outside", "kind": "hook", "what": "Denies rm, rmdir, unlink, find -delete / -exec rm and git clean whose target resolves outside $CLAUDE_PROJECT_DIR, and always `/` or `~` itself.", "when": "PreToolUse, matcher Bash.", "how": "Resolves each target (honouring cd, git -C, ~ and $HOME); temp dirs stay allowed, and a path known only at run time is allowed.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-delete-outside.py"]}, {"id": "guard-protected-push", "label": "guard-protected-push", "kind": "hook", "what": "Opt-in guard that denies a git push that would update or delete main, master, any configured base_branch, or a name in SB_PROTECTED_BRANCHES.", "when": "PreToolUse, matcher Bash, only after onboard's Policies yes (step 6) or `./install.sh --protect-main`.", "how": "Catches force pushes, explicit refspecs, --delete, --all/--mirror and a bare push while the base is checked out; feature-branch force pushes stay allowed. SB_ALLOW_PROTECTED_PUSH=1 turns it off for a session.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-protected-push.py", "https://github.com/mnphuc/super-board-gitea/blob/main/hooks/settings-protect-main.json"]}, {"id": "cleanup-wt", "label": "cleanup-wt", "kind": "hook", "what": "Removes worktrees and local branches already merged into a base branch; never deletes unmerged work.", "when": "SessionStart with `--auto --fetch` when a base tip moved since the last session, and after every merge when the merge gate calls it with `--post-merge`.", "how": "Wip-commits a dirty worktree on a merged branch and keeps its branch, never touches bases or its own worktree, and writes a recovery TSV under `<git-common-dir>/cleanup-wt/` before acting.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/cleanup-wt.py", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-gate.sh"]}, {"id": "gate-skill-evals", "label": "gate-skill-evals (dev)", "kind": "hook", "what": "Dev-only Stop hook that blocks ending a session when a skill changed and no `claude plugin eval` result is newer than the change.", "when": "Stop event in the pack's own `.claude/settings.json` (and EricOS if added by hand); never installed into target projects.", "how": "A changed SKILL.md always counts; a changed reference, script or workflow counts when the skill has an eval case. SKILL_EVAL_GATE=off, a running eval or `.claude/eval-gate-ignore` globs stand it down.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/dev/gate-skill-evals.py", "https://github.com/mnphuc/super-board-gitea/blob/main/.claude/settings.json"]}, {"id": "readme-sync", "label": "readme-sync (dev)", "kind": "hook", "what": "Dev-only hooks that keep README.md's skill tables in step with skills/*/SKILL.md and families.json.", "when": "PostToolUse on Edit|Write|MultiEdit in the pack repo, and as a git pre-commit hook when it is symlinked in.", "how": "Runs super-board-readme-sync.py; the pre-commit version stops the commit when README.md had to change so it can be staged.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/.claude/settings.json", "https://github.com/mnphuc/super-board-gitea/blob/main/hooks/pre-commit-readme.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-readme-sync.py"]}, {"id": "wave-plan", "label": "super-board-wave-plan.sh", "kind": "script", "what": "Read-only planner that computes the next wave from board state: cards (each with its lane and labels) plus the sweep, flag, stranded and resume lists.", "when": "Run by the orchestrator at the start of every wave, after the rate and usage guards pass.", "how": "Reads the board and `## Blocked by` dependencies (via super-board-deps.sh); a Ready card labelled qa gets lane qa, every other Ready card lane build. `resume` lists 🙋 cards a human approved with `done`. A `variant: qa-only` config is refused with exit 65.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-wave-plan.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-deps.sh"]}, {"id": "wave-js", "label": "super-board-wave.js", "kind": "script", "what": "Saved Workflow that drains one wave: a Pre-flight phase for cards about to be built, a haiku classify router, then Build, QA and Review lane agents per card.", "when": "Launched by /super-board run with {configPath, cards (with lane and labels), humanApprovesMerge, tier}; a stale `variant` other than full is refused.", "how": "Pre-flights Ready build cards in batches of 5 and never builds a card without a proceed verdict. The classifier keeps a card's qa/bug/feature label and adds feature or bug to unlabelled ones, never qa. A qa card goes Ready → QA. Model ladder by tier and complexity; Review always on the session model.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/workflows/super-board-wave.js"]}, {"id": "merge-gate", "label": "super-board-merge-gate.sh", "kind": "script", "what": "The only path to the base branch: takes an atomic mkdir lock, applies merge_policy, re-proves the branch against the current base inside the lock, runs allowed DB migrations, then squash-merges.", "when": "Called by the Reviewer once a review passes (and human_approves_merge is not set).", "how": "super-board-merge-policy.py decides who merges: money, auth, destructive schema or a diff over auto_max_lines (400 changed lines, lockfiles/generated/snapshots/migration SQL excluded) exits 7; a migration it may not run or a declared human step exits 8. Otherwise it merges with `--match-head-commit` (exit 6 when the head moved) and runs cleanup-wt --post-merge.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-policy.py"]}, {"id": "file-bug", "label": "super-qa-file-bug.sh", "kind": "script", "what": "Files one finding as a GitHub issue with a validated body onto the Super Ultimate QA board.", "when": "Called by standalone super-qa on a red spec, and by super-collect-file.sh for bug, feature and fix tickets.", "how": "Rejects bodies missing the ticket-format sections (Problem · Context · Fix · Acceptance Criteria · Risk, bugs with the folded Evidence table) or holding placeholders; adds type, source, priority and area labels and sets the project Status, falling back through Bug, Ready, Todo, Backlog, Triage.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-qa-file-bug.sh"]}, {"id": "file-refactor", "label": "review-file-refactor.sh", "kind": "script", "what": "Files a deepening opportunity as a `refactor` card, deduped by fingerprint.", "when": "Called by super-review for shape findings that must not block a merge, and by super-collect-file.sh for architecture tickets.", "how": "A body with an `## Acceptance criteria` section goes straight to Ready; otherwise it lands in the holding column for lint. It appends `## Blocked by` when missing.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-review-file-refactor.sh"]}, {"id": "collect-file", "label": "super-collect-file.sh", "kind": "script", "what": "Single filing entry point for /super-collect that routes each verified ticket to the pack's filers.", "when": "Called once per candidate the verifier marked file or needs-triage (dry-run without --yes, real filing with it), or with --adopt <n>.", "how": "bug/feature/fix go to super-qa-file-bug.sh, refactor to super-review-file-refactor.sh, every body in the writing-standard ticket format. It enforces per-source fingerprints (custom `custom|<name>|<key>`), exact-fingerprint dedupe and the board's holding column.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/super-collect-file.sh"]}, {"id": "collect-sentry", "label": "sentry fetcher", "kind": "script", "what": "The sentry source: lists unresolved Sentry issues in the window and pulls event and tag evidence.", "when": "Run when /super-collect includes sentry and the config has a sentry block.", "how": "`collect_sentry.py list --since <w>` calls the Sentry REST API with SENTRY_AUTH_TOKEN from .env; `check <id>` answers still-happening for the verifier. One issue becomes one bug, fp `err|sentry|<id>`.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/collect_sentry.py"]}, {"id": "collect-posthog", "label": "posthog fetcher", "kind": "script", "what": "The posthog source: exceptions, configured failure events, rage and dead clicks, web vitals, surveys, plus tracking gaps.", "when": "Run when /super-collect includes posthog.", "how": "`collect_posthog.py list|events|funnel|check` runs HogQL queries with POSTHOG_PERSONAL_API_KEY; signal groups over the thresholds become bugs, and missing workflow events become `analytics` feature tickets.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/collect_posthog.py"]}, {"id": "collect-prs", "label": "prs fetcher", "kind": "script", "what": "The prs source: merged PRs in the window with their comments, reviews, review threads and flagged super-review reports.", "when": "Run when /super-collect includes prs.", "how": "`collect_prs.py list` runs one paginated GraphQL search; Claude then clusters recurring root causes at a shared boundary into fix, refactor or feature tickets (fp `prs|<boundary>|<cause>`).", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/collect_prs.py"]}, {"id": "shoot", "label": "shoot.mjs", "kind": "script", "what": "Playwright screenshot script for the refine loop: light and dark at 1440 and 390, section crops, and before | after sheets.", "when": "Run for round-0 shots at setup and for AFTER shots at the end of every fix round.", "how": "Writes `<label>-<state>-<desktop|mobile>-<light|dark>.png` grown to the scroll height; `--compare round-0` adds cmp sheets the next checker judges.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/scripts/shoot.mjs"]}, {"id": "imp-detect", "label": "impeccable detect", "kind": "script", "what": "Impeccable's mechanical anti-pattern detector, run over every scope path holding markup or styles.", "when": "Run by the isolated detector sub-agent in every check, alongside the audit.", "how": "Invoked as `scripts/impeccable detect --json` (v4.4+) or `node scripts/detect.mjs --json` (v4.0.x), as found by refine-setup.sh detect; exit 2 means findings, which are checked in source for false positives.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/checker-brief.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/scripts/refine-setup.sh"]}, {"id": "install-sh", "label": "install.sh", "kind": "script", "what": "Installs the pack into a target project: skills, .claude/bin scripts, workflows and the guard hooks, with grouped emoji output.", "when": "Run by get.sh, by super-board-setup.py fix during onboard, or by hand: `./install.sh [--no-hooks] [--protect-main] [target]`.", "how": "Copies hooks/*.py to `.claude/hooks/` (never hooks/dev/) and merges the hook block through super-board-settings.py; `--no-hooks --protect-main` installs only the push guard. It records an older install in `.claude/super-board/upgrade.json` and ends with one next step: /super-board onboard.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/install.sh"], "opensView": "install"}, {"id": "visual-py", "label": "visual.py", "kind": "script", "what": "The /visual helper: detect picks the mode, facts collects git data, render injects data.json into the inline template.", "when": "Run by /visual at every step: detect with no argument, facts in recap mode, render after data.json is written.", "how": "render prints `{out, missingHunks}`; grounded hunks come from git via `hunks[].file + contains`, and output lands in a gitignored `_tmp/<date>-visual/` or `.visual/`.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/visual/scripts/visual.py"]}, {"id": "grilling", "label": "grilling", "kind": "external", "what": "Interview pattern that walks a design tree in rounds: numbered questions, each with a recommended answer, until the frontier is empty.", "when": "Reached by /ui-refine-loop's grill step and by /super-board lint for vague or multi-reading tickets; forbidden inside unattended workers.", "how": "Asks the whole frontier per round and waits; facts come from sub-agents, decisions from the user. ui-refine-loop caps it at 10 questions in waves of 3, then 4.", "source": [".agents/skills/grilling/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "tdd", "label": "tdd", "kind": "external", "what": "Test-driven development discipline: tests at agreed seams through public interfaces, red before green, one vertical slice at a time.", "when": "Reached by super-build for every non-docs ticket, by super-qa when writing High test gaps, and by implement.", "how": "Defines good tests, the anti-patterns (implementation-coupled, tautological, horizontal slicing) and the loop rules; refactoring belongs to the code-review stage.", "source": [".agents/skills/tdd/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "tdd", "author": "mattpocock"}, {"id": "tdd-v2", "label": "tdd-v2", "kind": "external", "what": "The EricOS testing ladder: which rung a test belongs at (unit, isolated render, e2e) and the gate for climbing to the next.", "when": "Reached by super-qa's test-gap check \"where the repo has it\", and by implement as its preferred test skill.", "how": "Building climbs bottom-up; chasing a defect walks down to the first rung that still reproduces. It owns the layer and defers red-green discipline to tdd.", "source": [".agents/skills/tdd-v2/SKILL.md"], "external": true, "origin": "EricOS local skill", "opensView": "tdd-v2", "author": "EricTechPro"}, {"id": "implement", "label": "implement", "kind": "external", "what": "Implements a piece of work from a spec or tickets, test-first, then reviews and commits it.", "when": "Reached by super-build when the issue's type label is feature or ux (implement → tdd → codebase-design).", "how": "Uses tdd-v2 at pre-agreed seams with tdd underneath, runs typecheck and single tests often and the full suite once, then runs code-review before committing.", "source": [".agents/skills/implement/SKILL.md"], "external": true, "origin": "mattpocock-skills (EricOS local override)", "opensView": "implement", "author": "mattpocock"}, {"id": "code-review", "label": "code-review", "kind": "external", "what": "Two-axis review of the diff since a fixed point: Standards (repo rules plus a Fowler smell baseline) and Spec (does it match the issue).", "when": "Reached by super-build once against its own diff before the final commit, by super-review on every card, and by implement and tdd.", "how": "Pins the fixed point (the lanes pass the merge-base so it never asks), runs a Standards and a Spec sub-agent in parallel, and reports them side by side without reranking.", "source": [".agents/skills/code-review/SKILL.md"], "external": true, "origin": "mattpocock-skills (EricOS local override)", "opensView": "code-review", "author": "mattpocock"}, {"id": "diagnosing-bugs", "label": "diagnosing-bugs", "kind": "external", "what": "Diagnosis loop for hard bugs and perf regressions: build a tight red feedback loop, reproduce, hypothesise, instrument, fix with a regression test.", "when": "Reached by super-build for `bug`-labelled tickets, by super-qa as a required dependency, and by lint for bug tickets with no repro.", "how": "Six phases; refuses to theorise before one command goes red on this bug. Its post-mortem hands off to improve-codebase-architecture when no good seam exists.", "source": [".agents/skills/diagnosing-bugs/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "diagnosing-bugs", "author": "mattpocock"}, {"id": "codebase-design", "label": "codebase-design", "kind": "external", "what": "Shared deep-module vocabulary: module, interface, depth, seam, adapter, leverage, locality, and the deletion test.", "when": "Reached by super-build for feature and refactor tickets, by super-review in step 2 and for every deepening opportunity, and by super-collect's architecture finder as a fallback.", "how": "A reference to consult, not a session: no report, no prompts. Its design-it-twice pattern runs parallel sub-agents when an interface needs alternatives.", "source": [".agents/skills/codebase-design/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "ask-matt", "label": "ask-matt", "kind": "external", "what": "Router over the Matt Pocock skills: which flow fits the situation, from idea to ship.", "when": "Reached by super-build and super-qa workers when the right flow is unclear.", "how": "Main flow: grill-with-docs, optional prototype via handoff, to-spec and to-tickets for multi-session work, then implement (driving tdd) and code-review. On-ramps: triage, diagnosing-bugs, wayfinder.", "source": [".agents/skills/ask-matt/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "ask-matt", "author": "mattpocock"}, {"id": "humanizer", "label": "humanizer", "kind": "external", "what": "Strips AI writing tells from a finished draft so it reads like a person wrote it, with Eric Tech plain-words overrides.", "when": "Reached whenever a lane or ui-refine-loop writes prose: the writing standard says ALWAYS run commits, tickets, PR bodies and comments through it when installed.", "how": "Applies the vendored blader/humanizer rule set (32 patterns) as a silent pass; without it the writing standard's plain-words rules apply (short sentences, plain words, no hype).", "source": [".agents/skills/humanizer/SKILL.md", "erictech-skills/skills/humanizer/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/writing-standard.md"], "external": true, "origin": "erictech-skills (vendored blader/humanizer)", "author": "blader"}, {"id": "verification", "label": "verification-before-compl.", "kind": "external", "what": "Evidence before assertions: run the verification command and read its output before claiming work is done, fixed or passing.", "when": "Reached by super-build before its final commit and by super-qa as a required dependency.", "how": "A gate function: identify the proving command, run it fresh, read the full output, and only then state the result.", "source": [".agents/skills/verification-before-completion/SKILL.md"], "external": true, "origin": "EricOS .agents/skills (origin not recorded)", "author": "obra"}, {"id": "context7", "label": "context7 (docs)", "kind": "external", "what": "MCP docs lookup used to read current official documentation for a library or API version.", "when": "Reached by super-build when a ticket touches a third-party API, an upgrade, or auth/billing.", "how": "Builder reads the exact surface and installed major's docs (context7 when available, else vendor docs by web search) and cites them as `Docs:` bullets in the PR's Solution block.", "source": ["~/.claude/plugins/marketplaces/claude-plugins-official/external_plugins/context7/README.md"], "external": true, "origin": "claude-plugins-official (MCP plugin)", "author": "upstash"}, {"id": "resolving-merge-conflicts", "label": "resolving-merge-conflicts", "kind": "external", "what": "Resolves an in-progress merge or rebase conflict by reading each side's intent, then runs the project's checks.", "when": "Reached by super-build on a live conflict, e.g. when the merge gate exits 2 or 5 and the card returns to the Builder, and by /git-sync when its pull conflicts.", "how": "Finds primary sources per hunk, preserves both intents where possible, never aborts; the Builder's finish line is green verification, not an empty conflict list.", "source": [".agents/skills/resolving-merge-conflicts/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "improve-codebase-architecture", "label": "improve-codebase-arch.", "kind": "external", "what": "Scans a codebase for deepening opportunities, presents them as an HTML report, then grills through the one picked.", "when": "Reached by /super-collect's architecture finder (findings only, no report or grilling) and by diagnosing-bugs' post-mortem; never loaded inside the Review lane.", "how": "Explores hot spots from git history with codebase-design vocabulary and CONTEXT.md/ADRs, writes the report, then runs grilling and domain-modeling on the chosen candidate.", "source": [".agents/skills/improve-codebase-architecture/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "improve-codebase-architecture", "author": "mattpocock"}, {"id": "domain-modeling", "label": "domain-modeling", "kind": "external", "what": "Sharpens a project's domain language in CONTEXT.md and records hard-to-reverse decisions as ADRs.", "when": "Reached from improve-codebase-architecture, grill-with-docs, triage and wayfinder sessions, and listed in super-build's skill map for terminology and ADRs.", "how": "Challenges fuzzy or overloaded terms and updates CONTEXT.md inline; offers an ADR only when a future reader would need the reason.", "source": [".agents/skills/domain-modeling/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "ponytail", "label": "ponytail", "kind": "external", "what": "Forces the simplest solution that works via a ladder: needed at all, already in the codebase, stdlib, native, installed dep, one line, then minimal code.", "when": "Reached by super-build on every ticket, before the first line of code (full intensity).", "how": "Runs after understanding the problem; bug fixes go to the root cause in the shared function. Inline ladder fallback when the plugin is absent.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "ponytail-review", "label": "ponytail-review", "kind": "external", "what": "Diff review that hunts only over-engineering, one line per finding tagged delete, stdlib, native, yagni or shrink.", "when": "Reached by super-review on the merge-base diff in step 3.", "how": "Ends with `net: -N lines possible`; findings are Over-engineering, always Should fix and never a merge blocker alone. It applies nothing.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail-review/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "ponytail-audit", "label": "ponytail-audit", "kind": "external", "what": "Whole-repo version of ponytail-review: a ranked list of what to delete, simplify or replace with stdlib or native features.", "when": "Reached by /super-collect's architecture finder for over-engineering findings.", "how": "Same tags as ponytail-review, biggest cut first, ending `net: -N lines, -M deps possible`; one-shot and read-only.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail-audit/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "impeccable", "label": "impeccable", "kind": "external", "what": "Frontend design skill whose commands critique, audit and refine UI: build, evaluate, refine, enhance, fix and iterate categories.", "when": "Reached by /ui-refine-loop at setup (detect and context), by every checker and fixer, and by lint for shape and clarify.", "how": "Each command has a playbook under reference/<command>.md plus craft-floor.md; refine-setup.sh finds v4.0.x node scripts or the v4.4+ launcher in this or any parent dir, warning loudly when missing.", "source": [".agents/skills/impeccable/SKILL.md"], "external": true, "origin": "pbakaus/impeccable", "opensView": "impeccable", "author": "pbakaus"}, {"id": "testing-strategy", "label": "testing-strategy", "kind": "external", "what": "Coverage judgment per component type: what is worth testing and what to skip.", "when": "Listed by super-build's skill map and super-qa's dependencies for deciding which kind of test a change needs.", "how": "Informs coverage only; the localisation ladder, not this skill, picks the test layer. Not installed in EricOS.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/references/decision-policy.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "vitest", "label": "vitest", "kind": "external", "what": "Mechanics for unit and integration tests in a TS/JS repo.", "when": "Listed by super-qa and super-build when the localisation ladder stops at unit or integration in a TS/JS repo.", "how": "Its references (core-expect, features-mocking, features-coverage, core-hooks, advanced-vi) guide test code. Not installed in EricOS.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/SKILL.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "playwright-bp", "label": "playwright-best-practices", "kind": "external", "what": "Mechanics for browser e2e specs: locators, fixtures, test data factories, page objects.", "when": "Listed by super-qa when writing or refactoring a Playwright spec.", "how": "data-testid first with getByRole fallback, custom fixtures for auth and seeding, POM for reusable interactions. Not installed in EricOS.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/SKILL.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "qa-test-planner", "label": "qa-test-planner", "kind": "external", "what": "Test-plan helper lint dispatches for QA tickets with a vague test surface.", "when": "Reached by /super-board lint Phase 4 for QA tickets whose test surface is vague.", "how": "One sub-agent per flagged issue drafts a concrete test plan. Not installed in EricOS.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/lint.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "setup-matt-pocock-skills", "label": "setup-matt-pocock-skills", "kind": "external", "what": "One-time repo setup for the engineering skills: issue tracker, triage label vocabulary, domain doc layout.", "when": "Reached when code-review, to-spec, to-tickets, triage or wayfinder find `docs/agents/issue-tracker.md` missing.", "how": "Asks a few sections with recommended answers and records them under docs/agents/ so the other skills know whether to call gh or write markdown files.", "source": [".agents/skills/setup-matt-pocock-skills/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "grill-with-docs", "label": "grill-with-docs", "kind": "external", "what": "Stateful grilling that builds CONTEXT.md and ADRs and checkpoints every answer to a capture file.", "when": "Reached from ask-matt as step 1 of the main flow whenever there is a working directory.", "how": "Runs the grilling primitive and drives domain-modeling to keep the glossary clean; user-invoked only.", "source": [".agents/skills/grill-with-docs/SKILL.md", "erictech-skills/skills/grill-with-docs/SKILL.md"], "external": true, "origin": "erictech-skills (override of mattpocock grill-with-docs)", "opensView": "grill-with-docs", "author": "EricTechPro"}, {"id": "prototype", "label": "prototype", "kind": "external", "what": "Throwaway prototype that answers one design question: a logic demo or a UI to look at.", "when": "Reached from ask-matt when a question needs a runnable answer, and from wayfinder prototype tickets.", "how": "Throwaway from day one, trivial to run, no persistence, no polish; the learning is handed back via handoff.", "source": [".agents/skills/prototype/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "handoff", "label": "handoff", "kind": "external", "what": "Compacts the conversation into a handoff document for a fresh agent.", "when": "Reached from ask-matt to bridge a prototype detour or a phase boundary.", "how": "Writes the summary to the OS temp directory, not the workspace, so another session can pick it up.", "source": [".agents/skills/handoff/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "to-spec", "label": "to-spec", "kind": "external", "what": "Turns the current conversation into a spec and publishes it to the issue tracker, no interview.", "when": "Reached from ask-matt for multi-session builds; listed in super-build's skill map.", "how": "Writes the spec from a template and applies the `ready-for-agent` label; needs the tracker config from setup-matt-pocock-skills.", "source": [".agents/skills/to-spec/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "to-spec", "author": "mattpocock"}, {"id": "to-tickets", "label": "to-tickets", "kind": "external", "what": "Breaks a plan or spec into tracer-bullet tickets, each declaring its blocking edges.", "when": "Reached from ask-matt after to-spec, and from /super-board lint to split a too-big ticket (criterion 15) into vertical slices; its `## Blocked by` template is why lint criterion 13 exists.", "how": "Publishes blockers first so edges reference real ids, as files locally or native blocking links on a real tracker.", "source": [".agents/skills/to-tickets/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "to-tickets", "author": "mattpocock"}, {"id": "triage", "label": "triage", "kind": "external", "what": "Moves raw issues and external PRs through a state machine of triage roles into agent-ready briefs.", "when": "Reached from ask-matt when bugs and requests pile up that you did not create.", "how": "Categorise, verify, grill if needed, write the brief; every comment carries an AI disclaimer and labels come from setup-matt-pocock-skills.", "source": [".agents/skills/triage/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "triage", "author": "mattpocock"}, {"id": "wayfinder", "label": "wayfinder", "kind": "external", "what": "Charts a shared map of decision tickets for a huge, foggy effort and resolves them one at a time.", "when": "Reached from ask-matt for greenfield projects or builds too big for one session.", "how": "Tickets are research, prototype, grilling or task, HITL or AFK; it hands off to to-spec when the map clears instead of building.", "source": [".agents/skills/wayfinder/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "wayfinder", "author": "mattpocock"}, {"id": "verbs-group", "label": "impeccable fix verbs", "kind": "verb", "what": "The 15 Impeccable commands the ui-refine-loop fixer may chain, one per problem type, with polish always last.", "when": "Each fix round, after the checker returns ranked, typed P0–P3 problems.", "how": "The workflow attaches routing.md's default command per type and suggests a chain (severity order, structural before surface, additive verbs only when the direction asks); the fixer reads each playbook and craft-floor, then makes the final call.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/routing.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/fixer-brief.md"], "opensView": "impeccable-verbs", "author": "pbakaus"}, {"id": "late-verbs", "label": "motion + perf verbs", "kind": "verb", "what": "The last tier of the chain before polish: animate, delight and optimize.", "when": "When a problem is typed needs-motion, personality or performance.", "how": "routing.md runs these after the structural, surface and fix tiers; animate and delight are additive, so they run only when the brief or taste direction asks for more.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/routing.md"], "opensView": "late-verbs", "author": "pbakaus"}, {"id": "v-critique", "label": "critique", "kind": "verb", "what": "UX design review with scoring; the loop uses Assessment A only, scored /20 across specificity, hierarchy, typography, color and composition.", "when": "Every check, run by the isolated design reviewer sub-agent in parallel with the detector.", "how": "Reads critique.md (Assessment A) and craft-floor.md, every shot and crop in both themes and widths, then the scope files; returns up to 8 typed problems. No Nielsen heuristics.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/critique.md"], "author": "pbakaus"}, {"id": "v-audit", "label": "audit", "kind": "verb", "what": "Technical quality check scored /20 across accessibility, performance, responsive, theming and implementation integrity.", "when": "Every check, run by the isolated detector sub-agent after impeccable detect.", "how": "Reads audit.md, scores five dimensions 0–4, and turns each verified detector cluster or audit gap into a typed problem; it never sees the screenshots or the design review.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/audit.md"], "author": "pbakaus"}, {"id": "v-polish", "label": "polish", "kind": "verb", "what": "Final quality pass over everything the round touched: small misalignments and inconsistencies, no structural change.", "when": "Always the last command of every fix round, even when no problem was typed polish.", "how": "Runs once over all touched files after the routed chain; then checks must be green before the round's single commit.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/polish.md"], "author": "pbakaus"}, {"id": "v-distill", "label": "distill", "kind": "verb", "what": "Strips a surface to its essence, removing duplicate actions and competing chrome.", "when": "Routed for problems typed `cluttered`.", "how": "Structural tier, so it runs first in the chain alongside extract; follows reference/distill.md as a refinement of the existing design.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/distill.md"], "author": "pbakaus"}, {"id": "v-bolder", "label": "bolder", "kind": "verb", "what": "Amplifies a safe, bland design so it has more presence.", "when": "Routed for `bland`, only when the brief or taste direction asks for more.", "how": "Additive surface-tier verb; skipped with a reason like \"direction says calmer\", and dropped when it pulls against quieter on the same element.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/bolder.md"], "author": "pbakaus"}, {"id": "v-quieter", "label": "quieter", "kind": "verb", "what": "Tones down an aggressive design: fewer colors, weights, borders, shadows or badges.", "when": "Routed for problems typed `too-loud`.", "how": "Surface tier after layout/adapt; when it conflicts with bolder on one element the higher-severity problem wins.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/quieter.md"], "author": "pbakaus"}, {"id": "v-colorize", "label": "colorize", "kind": "verb", "what": "Adds strategic color where gray or flat UI should carry meaning.", "when": "Routed for `dull-color`, only when the direction asks for more.", "how": "Additive surface-tier verb; changes must hold in light and dark and use tokens, not raw values.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/colorize.md"], "author": "pbakaus"}, {"id": "v-layout", "label": "layout", "kind": "verb", "what": "Fixes spacing, rhythm, grouping, alignment and visual hierarchy.", "when": "Routed for problems typed `spacing-hierarchy`.", "how": "Second tier, after distill/extract; a cramped look caused by a copied card is rerouted to extract by the fixer.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/layout.md"], "author": "pbakaus"}, {"id": "v-typeset", "label": "typeset", "kind": "verb", "what": "Improves typography: fonts, type scale, weights, line length and figures.", "when": "Routed for problems typed `typography`.", "how": "Surface tier with colorize, quieter and bolder; follows reference/typeset.md within the taste file's type rules.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/typeset.md"], "author": "pbakaus"}, {"id": "v-adapt", "label": "adapt", "kind": "verb", "what": "Adapts the surface to other screen sizes: breakpoints, touch targets, no sideways scroll at 390.", "when": "Routed for problems typed `responsive`.", "how": "Second tier with layout; the after shots at 390 in both themes prove it.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/adapt.md"], "author": "pbakaus"}, {"id": "v-optimize", "label": "optimize", "kind": "verb", "what": "Diagnoses and fixes UI performance: jank, layout shift, heavy images or bundles.", "when": "Routed for problems typed `performance`.", "how": "Last tier with animate and delight, before polish; follows reference/optimize.md.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/optimize.md"], "author": "pbakaus"}, {"id": "v-onboard", "label": "onboard", "kind": "verb", "what": "Designs first-run flows and empty states that point to the next action.", "when": "Routed for problems typed `first-run-empty`.", "how": "Fix tier with clarify and harden; no dense fixture means no dense shots, never fabricated data.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/onboard.md"], "author": "pbakaus"}, {"id": "v-clarify", "label": "clarify", "kind": "verb", "what": "Improves UX copy: labels, errors, status words and instructions.", "when": "Routed for `confusing-copy` in the refine loop; also dispatched by /super-board lint for copy or error-message ACs.", "how": "Fix tier; refinement keeps the meaning of factual copy and never adds claims.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/clarify.md"], "author": "pbakaus"}, {"id": "v-harden", "label": "harden", "kind": "verb", "what": "Production-readiness: long content, errors, loading, i18n, overflow, and accessibility (contrast, focus, names, keyboard).", "when": "Routed for problems typed `edge-cases` or `accessibility`.", "how": "Fix tier; the only verb two problem types share in routing.md.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/harden.md"], "author": "pbakaus"}, {"id": "v-animate", "label": "animate", "kind": "verb", "what": "Adds purposeful motion and state-change feedback.", "when": "Routed for `needs-motion`, only when the brief or direction asks for motion.", "how": "Additive last-tier verb; delight may call it.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/animate.md"], "author": "pbakaus"}, {"id": "v-delight", "label": "delight", "kind": "verb", "what": "Adds personality and memorable touches to a correct but lifeless surface.", "when": "Routed for `personality`, only when the brief asks for character.", "how": "Additive last-tier verb that calls animate for motion; followed by polish.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/delight.md"], "author": "pbakaus"}, {"id": "v-extract", "label": "extract", "kind": "verb", "what": "Pulls repeated UI into shared tokens and components.", "when": "Routed for `drift`: the same pattern copied 3+ times, raw values next to tokens, one-off components.", "how": "Structural tier, first in the chain; shared components change only behind a new prop that defaults to today's behaviour.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/extract.md"], "author": "pbakaus"}, {"id": "v-shape", "label": "shape", "kind": "verb", "what": "Plans UX/UI for a feature before code is written.", "when": "Dispatched by /super-board lint for feature tickets with undefined UX; never typed as a refine-loop problem.", "how": "Requires init's PRODUCT.md; a redesign need found in the loop goes to openQuestions instead.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/shape.md"], "author": "pbakaus"}, {"id": "v-init", "label": "init", "kind": "verb", "what": "Captures durable product context in PRODUCT.md.", "when": "Suggested by /impeccable when PRODUCT.md is missing; not run by the refine loop.", "how": "Shape and document require it; its context feeds live mode.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/init.md"], "author": "pbakaus"}, {"id": "v-document", "label": "document", "kind": "verb", "what": "Generates DESIGN.md from existing project code.", "when": "When DESIGN.md is missing; the refine loop reads DESIGN.md if present but never runs this.", "how": "Requires init; doctor feeds it when files go stale.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/document.md"], "author": "pbakaus"}, {"id": "v-live", "label": "live", "kind": "verb", "what": "Visual variant mode: pick elements in the browser and generate alternatives.", "when": "Interactive iteration only; the refine loop forbids it as a problem type.", "how": "Fed by init's context and calls polish on the chosen variant.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/live.md"], "author": "pbakaus"}, {"id": "v-overdrive", "label": "overdrive", "kind": "verb", "what": "Pushes a design past conventional limits for a wow factor.", "when": "Interactive only; the refine loop never types a problem as overdrive.", "how": "A redesign-scale command, so the checker sends such needs to openQuestions.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/overdrive.md"], "author": "pbakaus"}, {"id": "preflight", "label": "super-board-preflight.sh", "kind": "script", "what": "Builder pre-flight check: is a Ready card already done, already in progress, overlapping an open PR's files, or unclear?", "when": "Run once per batch of up to 5 Ready build cards by the wave's Pre-flight agent (or by the Builder as step 0 on the legacy backend), before any worktree.", "how": "Prints mechanical verdicts and near-miss candidates; the agent adds 'too big' and semantic matches, then returns proceed, hold, sequence or skipped. Hold and sequence move the card to Blocked with the block template; skipped leaves it in Ready.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-preflight.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"]}, {"id": "pr-body", "label": "super-board-pr-body.sh", "kind": "script", "what": "Rewrites one marker block of a PR body (redcheck, status, problem, solution, ac, history, visual, risk) without clobbering other lanes' blocks.", "when": "Called by every lane when it updates its part of the PR, and with --skeleton by ui-refine-loop for a fresh body.", "how": "`--pr N --block <name> --expect-head <sha>` with --body-file or --append-file (history rows); `--time` prints local time in the config's timezone.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-pr-body.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/writing-standard.md"]}, {"id": "needs-you", "label": "Blocked · 🙋 needs you", "kind": "board", "what": "A card parked in Blocked with the 🙋 template and the `needs-you` label: a step only a human may take. There is no separate column.", "when": "The merge gate exits 7 (merge_policy: money, auth, destructive schema, over 400 lines) or 8 (a migration the robot may not run, or a declared human step).", "how": "The comment opens \"🙋 Your turn on #N\" with the exact commands as checkboxes; a human merges it, or comments `done` / labels `needs-you:done` so the planner's resume list sends it back to Review.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/block-template.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"]}, {"id": "setup-py", "label": "super-board-setup.py", "kind": "script", "what": "The deterministic half of onboard: finds what is missing or old and fixes the must-haves, and handles boards and branches.", "when": "Run by onboard step 1 (check / fix), step 3 (board-rank, board-migrate, names) and step 4 (branch).", "how": "`fix` installs or refreshes skills, scripts, workflows, guard hooks and settings (via install.sh), removes super-refine / cleanup-wt / arch-loop folders, migrates config keys to v3, runs git init and adds Matt Pocock's skills, all backed up first. `board-migrate` adds missing columns and the three labels and moves Skipped cards to Done.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"]}, {"id": "agents-md-py", "label": "super-board-agents-md.py", "kind": "script", "what": "The deterministic half of the AGENTS.md step: detect, backup, the managed super-board block, the CLAUDE.md pointer, coverage and size checks.", "when": "Run by onboard step 5 to stage the merge and at step 8 to write it; install.sh refreshes the managed block on re-install.", "how": "The agent merges rules semantically (duplicates once, conflicts asked one by one); the script proves every rule unit maps to a line (`coverage`), keeps AGENTS.md ≤ 200 lines with one marker pair, and writes atomically.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-agents-md.py", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/agents-md-block.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md"]}, {"id": "agents-file", "label": "AGENTS.md + CLAUDE.md", "kind": "board", "what": "The project's instruction files: AGENTS.md as the single source of truth with a managed super-board block, and CLAUDE.md as `@AGENTS.md` plus Claude-only rules.", "when": "Written at onboard step 8 when Eric chose to move his rules (or only add the section); the block is rewritten on re-install.", "how": "The block sits between `<!-- super-board:begin -->` and `<!-- super-board:end -->`, rendered from agents-md-block.md with a Writing table that links the writing standard; nothing outside the markers is touched.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/agents-md-block.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md"]}, {"id": "settings-py", "label": "super-board-settings.py", "kind": "script", "what": "Merges hook blocks and permission allow rules into .claude/settings.json without losing anything.", "when": "Run by install.sh for the guard hooks, and by onboard step 6/8 for the permission lines and the protect-main hook.", "how": "`hooks <settings> <snippet>` and `allow <settings> <rules…>` keep every existing key, back the file up, write atomically, and leave an invalid settings.json untouched; `--dry-run` prints the diff onboard shows as \"N lines\".", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-settings.py"]}, {"id": "env-check", "label": "super-board-env-check.sh", "kind": "script", "what": "Says which env keys exist (present, empty or missing) without ever printing a value.", "when": "Run by onboard to detect SENTRY_AUTH_TOKEN, POSTHOG_PERSONAL_API_KEY or migration DB URLs, and allowed in permissions for runs.", "how": "Reads .env.local or .env itself and prints one word per key; guard-secrets lets a plain call through while still blocking cat, grep or source on dotenv files.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-env-check.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-secrets.py"]}, {"id": "collect-custom", "label": "custom source fetcher", "kind": "script", "what": "The custom source: extra sources a project added in onboard (an http API, a CLI command, or an MCP server), stored in collect.custom[].", "when": "Run by onboard step 7 (classify, ping, add) and by /super-collect for every custom source (list, normalize).", "how": "`collect_custom.py` classifies the typed text, pings read-only before saving, refuses commands that look like they change something, and turns output into candidates with fp `custom|<name>|<key>`. MCP reads go through the agent and `normalize`.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/collect_custom.py"]}, {"id": "get-sh", "label": "get.sh", "kind": "script", "what": "One-line installer: `curl -fsSL …/get.sh | bash` fetches the latest super-board release and runs install.sh.", "when": "Eric (or a user) runs it in a project folder to install or upgrade; options --target, --ref, --no-helper-skills, and --no-hooks / --protect-main passed through.", "how": "Downloads the release tarball, runs install.sh, adds Matt Pocock's skills via `npx skills@latest add mattpocock/skills` unless told not to, and prints the next step once.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/get.sh"]}, {"id": "plugin-mkt", "label": "plugin marketplace install", "kind": "board", "what": "The Claude Code plugin form of the pack (marketplace.json + plugin.json): ships the seven skills only.", "when": "A user adds the marketplace and installs the plugin instead of running get.sh.", "how": "Skills carry the plugin prefix (/super-board:super-board onboard); onboard step 1 then installs the guard hooks, .claude/bin scripts and workflows a plugin cannot ship from the plugin's own copy.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/.claude-plugin/marketplace.json", "https://github.com/mnphuc/super-board-gitea/blob/main/.claude-plugin/plugin.json"]}, {"id": "onboard-answers", "label": "onboard answers file", "kind": "board", "what": "`.claude/super-board/onboard-answers.json`: every onboard answer, saved the moment it is given (gitignored).", "when": "Written after each answer; read when onboard re-runs or resumes after a halt.", "how": "Atomic writes; `last_step` drives the \"Continue where you left off?\" screen, and a finished setup's values fill the step-8 table on re-run.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md"]}, {"id": "upgrade-json", "label": "upgrade record", "kind": "board", "what": "`.claude/super-board/upgrade.json`: the version an install replaced, so onboard knows to upgrade a 2.x setup.", "when": "Written by install.sh (or get.sh) when it finds an older install.", "how": "super-board-setup.py fix reads it and reports \"Upgraded for you\": old folders removed, config keys migrated, labels mapped, Skipped cards moved to Done.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/install.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/RELEASE-NOTES.md"]}, {"id": "git-sync", "label": "/git-sync", "kind": "public", "what": "Commits the working tree as one commit per logical change, merge-pulls, pushes the current branch without force, and reports what it did.", "when": "Eric runs /git-sync or says \"sync\", \"commit and push\" or \"pull and push\", usually at the end of a piece of work.", "how": "Stages each group by path (never `git add -A`), refuses secrets, writes the host's commit format or the writing standard, gates `supabase/` changes on a migration file and advisors, then `git pull --no-rebase` and `git push`. The default or a protected branch needs a yes.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/git-sync/SKILL.md"], "sublabel": "commit · pull · push", "opensView": "git-sync", "author": "EricTechPro"}], "edges": [{"id": "r-board-build", "from": "super-board", "to": "super-build", "label": "starts Build lane", "when": "a planned Ready card labelled feature or bug (or unlabelled) passes pre-flight"}, {"id": "r-board-qa", "from": "super-board", "to": "super-qa", "label": "starts QA lane", "when": "a card is in QA, or in Ready with the qa label (skips Building)"}, {"id": "r-board-review", "from": "super-board", "to": "super-review", "label": "starts Review lane", "when": "a card is in Review"}, {"id": "r-board-gh", "from": "super-board", "to": "gh-board", "label": "drains", "when": "every wave until drained or halted"}, {"id": "r-board-config", "from": "super-board", "to": "sb-config", "label": "reads config", "when": "onboard writes it; every run reads it"}, {"id": "r-collect-gh", "from": "super-collect", "to": "gh-board", "label": "files to Backlog", "when": "the verifier says file or needs-triage and the run is confirmed"}, {"id": "r-collect-config", "from": "super-collect", "to": "sb-config", "label": "reads collect block", "when": "every run, to resolve sources, window and board"}, {"id": "r-build-qa", "from": "super-build", "to": "super-qa", "label": "hands off", "when": "the draft PR is open and the card moved to QA"}, {"id": "r-qa-review", "from": "super-qa", "to": "super-review", "label": "hands off", "when": "every AC passes and evidence is committed; a fail sends the card back to Ready"}, {"id": "r-review-build", "from": "super-review", "to": "super-build", "label": "bounces [builder]", "when": "a code-side finding or an unfixed prior finding"}, {"id": "r-review-base", "from": "super-review", "to": "base-branch", "label": "merges via gate", "when": "review is clean, tests rerun green, and merge_policy lets the robot merge"}, {"id": "r-review-hooks", "from": "super-review", "to": "hooks", "label": "triggers cleanup-wt", "when": "the merge gate merged a PR and cleanup-wt is installed"}, {"id": "r-refine-base", "from": "ui-refine-loop", "to": "base-branch", "label": "opens draft PR", "when": "the loop stops; it pushes refine/<slug> only and never merges"}, {"id": "r-visual-base", "from": "visual", "to": "base-branch", "label": "reads git facts", "when": "recap mode, or any mode reading the repo"}, {"id": "r-refine-config", "from": "ui-refine-loop", "to": "sb-config", "label": "reads refine block", "when": "setup, when a super-board config exists"}, {"id": "run-claim", "from": "sb-run", "to": "gh-board", "label": "claims + drains", "when": "each wave: claims cards by bot_identity assignee after sweep/flag/stranded, until drained or halted"}, {"id": "sb-v-onboard", "from": "super-board", "to": "sb-onboard", "label": "routes onboard", "when": "Eric runs /super-board onboard"}, {"id": "sb-v-lint", "from": "super-board", "to": "sb-lint", "label": "routes lint", "when": "Eric runs /super-board lint"}, {"id": "sb-v-status", "from": "super-board", "to": "sb-status", "label": "routes status", "when": "Eric runs /super-board status"}, {"id": "sb-v-run", "from": "super-board", "to": "sb-run", "label": "routes run", "when": "Eric runs /super-board run, or asks to resume"}, {"id": "sb-v-stop", "from": "super-board", "to": "sb-stop", "label": "routes stop", "when": "Eric runs /super-board stop or says pause"}, {"id": "sb-onb-config", "from": "sb-onboard", "to": "sb-config", "label": "8 · writes config", "when": "step 8, after \"Write everything\", with the active pointer"}, {"id": "sb-onb-gh", "from": "sb-onboard", "to": "gh-board", "label": "3 · picks board", "when": "step 3: reuse the best-ranked board (missing columns and labels added) or create one"}, {"id": "sb-lint-gh", "from": "sb-lint", "to": "gh-board", "label": "flags, labels cards", "when": "an active issue fails a criterion; proposed labels and AC fixes apply on approve"}, {"id": "sb-status-gh", "from": "sb-status", "to": "gh-board", "label": "reads counts", "when": "every status call; read-only"}, {"id": "sb-stop-gh", "from": "sb-stop", "to": "gh-board", "label": "releases claims", "when": "posts stopped-mid-flight comments and strips assignees"}, {"id": "lint-grill", "from": "sb-lint", "to": "grilling", "label": "grills Eric", "when": "an issue needs a rethink (criteria 10, 11) or has several readings (12)"}, {"id": "lint-diag", "from": "sb-lint", "to": "diagnosing-bugs", "label": "drafts repro", "when": "a bug ticket has no repro steps"}, {"id": "lint-shape", "from": "sb-lint", "to": "v-shape", "label": "shapes UX", "when": "a feature ticket has undefined UX"}, {"id": "lint-clarify", "from": "sb-lint", "to": "v-clarify", "label": "fixes copy ACs", "when": "an AC is about copy, microcopy or an error message"}, {"id": "lint-qatp", "from": "sb-lint", "to": "qa-test-planner", "label": "plans tests", "when": "a QA ticket has a vague test surface"}, {"id": "run-plan", "from": "sb-run", "to": "wave-plan", "label": "plans wave", "when": "after the rate guard and the usage guard pass; resume list included"}, {"id": "run-launch", "from": "sb-run", "to": "wave-js", "label": "launches workflow", "when": "one or more cards were claimed"}, {"id": "wave-build", "from": "wave-js", "to": "super-build", "label": "runs Build lane", "when": "card enters at Ready (feature, bug or no label) and pre-flight said proceed"}, {"id": "wave-qa", "from": "wave-js", "to": "super-qa", "label": "runs QA lane", "when": "card enters at QA, or Ready with the qa label"}, {"id": "wave-review", "from": "wave-js", "to": "super-review", "label": "runs Review lane", "when": "card enters at Review; always on the session model"}, {"id": "review-gate", "from": "super-review", "to": "merge-gate", "label": "calls merge gate", "when": "clean review, threads resolved, truth score over threshold, tests green"}, {"id": "gate-cleanup", "from": "merge-gate", "to": "cleanup-wt", "label": "runs post-merge", "when": "the merge landed and .claude/hooks/cleanup-wt.py exists"}, {"id": "gate-base", "from": "merge-gate", "to": "base-branch", "label": "squash-merges", "when": "policy allows the robot, the branch still passes against the current base inside the lock, allowed migrations ran"}, {"id": "run-manifest-e", "from": "sb-run", "to": "run-manifest", "label": "appends manifest", "when": "reconcile, once the wave returns; claims are released too"}, {"id": "b-pony", "from": "super-build", "to": "ponytail", "label": "climbs ladder first", "when": "every ticket, before the first line of code"}, {"id": "b-impl", "from": "super-build", "to": "implement", "label": "routes feature", "when": "type label feature or ux (then tdd, codebase-design)"}, {"id": "b-diag", "from": "super-build", "to": "diagnosing-bugs", "label": "routes bug", "when": "type label bug (then tdd)"}, {"id": "b-design", "from": "super-build", "to": "codebase-design", "label": "routes refactor", "when": "type label refactor or tech-debt, or feature"}, {"id": "b-tdd", "from": "super-build", "to": "tdd", "label": "builds test-first", "when": "every ticket except docs"}, {"id": "b-docs", "from": "super-build", "to": "context7", "label": "reads current docs", "when": "the ticket touches a third-party surface, an upgrade, or auth/billing"}, {"id": "b-verify", "from": "super-build", "to": "verification", "label": "proves before commit", "when": "before the final commit"}, {"id": "b-review", "from": "super-build", "to": "code-review", "label": "reviews own diff", "when": "once, against the merge-base, before the final commit"}, {"id": "b-conflict", "from": "super-build", "to": "resolving-merge-conflicts", "label": "resolves conflict", "when": "a live conflict, e.g. after merge-gate exit 2 or 5"}, {"id": "b-askmatt", "from": "super-build", "to": "ask-matt", "label": "asks the router", "when": "the right flow is unclear"}, {"id": "b-gh", "from": "super-build", "to": "gh-board", "label": "moves card to QA", "when": "draft PR opened and comments posted"}, {"id": "q-tdd", "from": "super-qa", "to": "tdd", "label": "writes gaps red-first", "when": "the test-gap check finds a High gap"}, {"id": "q-tddv2", "from": "super-qa", "to": "tdd-v2", "label": "picks the rung", "when": "the repo has tdd-v2 (used instead of plain tdd)"}, {"id": "q-diag", "from": "super-qa", "to": "diagnosing-bugs", "label": "diagnoses failures", "when": "a spec goes red and the cause is unclear"}, {"id": "q-verify", "from": "super-qa", "to": "verification", "label": "proves the pass", "when": "before a pass handoff"}, {"id": "q-askmatt", "from": "super-qa", "to": "ask-matt", "label": "asks the router", "when": "the right flow is unclear"}, {"id": "q-strat", "from": "super-qa", "to": "testing-strategy", "label": "judges coverage", "when": "deciding what is worth testing per component type"}, {"id": "q-vitest", "from": "super-qa", "to": "vitest", "label": "writes unit tests", "when": "the ladder stops at unit or integration in TS/JS"}, {"id": "q-pw", "from": "super-qa", "to": "playwright-bp", "label": "writes e2e specs", "when": "the browser is the thing that broke, or standalone crawl specs"}, {"id": "q-gh", "from": "super-qa", "to": "gh-board", "label": "moves card", "when": "pass: QA to Review; fail: QA to Ready (loop:rebuild-N); a qa card first moves itself Ready to QA"}, {"id": "q-filebug", "from": "super-qa", "to": "file-bug", "label": "files red spec", "when": "a standalone crawl finds a failing spec, or a qa card finds a defect tests alone cannot fix"}, {"id": "filebug-qaboard", "from": "file-bug", "to": "qa-board", "label": "sets Status Bug", "when": "the body passes validation"}, {"id": "v-cr", "from": "super-review", "to": "code-review", "label": "runs two-axis review", "when": "every card, with the merge-base as the fixed point"}, {"id": "v-design", "from": "super-review", "to": "codebase-design", "label": "reads diff shape", "when": "step 2, and when writing every deepening opportunity"}, {"id": "v-pony", "from": "super-review", "to": "ponytail-review", "label": "hunts over-engineering", "when": "step 3, on the merge-base diff; inline ladder if absent"}, {"id": "v-refactor", "from": "super-review", "to": "file-refactor", "label": "files deepening card", "when": "the diff is correct but leaves a shallow module or misplaced seam"}, {"id": "v-gh", "from": "super-review", "to": "gh-board", "label": "bounces or closes", "when": "unresolved [builder]/[qa] threads bounce; a confirmed merge moves the card to Done"}, {"id": "c-sentry", "from": "super-collect", "to": "collect-sentry", "label": "fetches sentry", "when": "sentry is requested or enabled in collect.sources"}, {"id": "c-posthog", "from": "super-collect", "to": "collect-posthog", "label": "fetches posthog", "when": "posthog is requested or enabled"}, {"id": "c-github", "from": "super-collect", "to": "gh-issues", "label": "reads github", "when": "github is requested or enabled"}, {"id": "c-prs", "from": "super-collect", "to": "collect-prs", "label": "fetches merged PRs", "when": "prs is requested or enabled"}, {"id": "c-ica", "from": "super-collect", "to": "improve-codebase-architecture", "label": "finds refactors", "when": "architecture source; read-only finder, findings only"}, {"id": "c-design", "from": "super-collect", "to": "codebase-design", "label": "finds refactors", "when": "architecture source when improve-codebase-architecture is not installed"}, {"id": "c-audit", "from": "super-collect", "to": "ponytail-audit", "label": "finds bloat", "when": "architecture source, always alongside the finder"}, {"id": "c-file", "from": "super-collect", "to": "collect-file", "label": "files if verified", "when": "one fresh verifier per candidate says file or needs-triage (duplicate gets a comment)"}, {"id": "file-gh", "from": "collect-file", "to": "gh-board", "label": "files to Backlog", "when": "--yes or confirmed dry-run; dedupe by exact fingerprint"}, {"id": "u-grill", "from": "ui-refine-loop", "to": "grilling", "label": "grills Eric", "when": "after reading the target's code; at most 10 questions in waves"}, {"id": "u-taste", "from": "ui-refine-loop", "to": "taste-file", "label": "commits taste", "when": "answers in hand; first commit on refine/<slug>"}, {"id": "u-imp", "from": "ui-refine-loop", "to": "impeccable", "label": "detects + loads", "when": "setup (detect, context) and the finish reviewer's craft-floor verdict pass"}, {"id": "u-shoot", "from": "ui-refine-loop", "to": "shoot", "label": "takes shots", "when": "round 0 at setup, then AFTER shots each fix round"}, {"id": "u-critique", "from": "ui-refine-loop", "to": "v-critique", "label": "design reviewer runs", "when": "every check, isolated from the detector"}, {"id": "u-detect", "from": "ui-refine-loop", "to": "imp-detect", "label": "detector runs", "when": "every check, in parallel with the design reviewer"}, {"id": "u-detect-audit", "from": "imp-detect", "to": "v-audit", "label": "feeds audit", "when": "same detector sub-agent; verified hits become problems"}, {"id": "u-crit-verbs", "from": "v-critique", "to": "verbs-group", "label": "checker ranks, routes", "when": "checker merges A and B into at most 8 typed problems"}, {"id": "u-audit-verbs", "from": "v-audit", "to": "verbs-group", "label": "checker ranks, routes", "when": "same merge; the fixer chains the routed verbs"}, {"id": "u-verbs-polish", "from": "verbs-group", "to": "v-polish", "label": "then polish last", "when": "every fix round, once, over all touched files"}, {"id": "u-ledger", "from": "ui-refine-loop", "to": "refine-ledger", "label": "appends ledger", "when": "after every check; stop rules read it"}, {"id": "u-human", "from": "ui-refine-loop", "to": "humanizer", "label": "humanizes PR", "when": "finish, after the finish reviewer graded every fix"}, {"id": "u-pr", "from": "ui-refine-loop", "to": "draft-pr", "label": "opens draft PR", "when": "finish; pushes refine/<slug> only"}, {"id": "iv-v-distill", "from": "verbs-group", "to": "v-distill", "label": "routes cluttered", "when": "a problem is typed cluttered"}, {"id": "iv-v-extract", "from": "verbs-group", "to": "v-extract", "label": "routes drift", "when": "a problem is typed drift"}, {"id": "iv-v-layout", "from": "verbs-group", "to": "v-layout", "label": "routes spacing", "when": "a problem is typed spacing-hierarchy"}, {"id": "iv-v-adapt", "from": "verbs-group", "to": "v-adapt", "label": "routes responsive", "when": "a problem is typed responsive"}, {"id": "iv-v-typeset", "from": "verbs-group", "to": "v-typeset", "label": "routes typography", "when": "a problem is typed typography"}, {"id": "iv-v-colorize", "from": "verbs-group", "to": "v-colorize", "label": "routes dull color", "when": "typed dull-color and the direction asks for more"}, {"id": "iv-v-quieter", "from": "verbs-group", "to": "v-quieter", "label": "routes too-loud", "when": "a problem is typed too-loud"}, {"id": "iv-v-bolder", "from": "verbs-group", "to": "v-bolder", "label": "routes bland", "when": "typed bland and the direction asks for more"}, {"id": "iv-v-clarify", "from": "verbs-group", "to": "v-clarify", "label": "routes confusing copy", "when": "a problem is typed confusing-copy"}, {"id": "iv-v-harden", "from": "verbs-group", "to": "v-harden", "label": "routes edge cases, a11y", "when": "a problem is typed edge-cases or accessibility"}, {"id": "iv-v-onboard", "from": "verbs-group", "to": "v-onboard", "label": "routes first-run", "when": "a problem is typed first-run-empty"}, {"id": "iv-late-verbs", "from": "verbs-group", "to": "late-verbs", "label": "routes motion, perf", "when": "a problem is typed needs-motion, personality or performance"}, {"id": "lv-animate", "from": "late-verbs", "to": "v-animate", "label": "routes needs-motion", "when": "typed needs-motion and the brief asks for motion"}, {"id": "lv-delight", "from": "late-verbs", "to": "v-delight", "label": "routes personality", "when": "typed personality and the brief asks for character"}, {"id": "lv-optimize", "from": "late-verbs", "to": "v-optimize", "label": "routes performance", "when": "a problem is typed performance"}, {"id": "lv-del-anim", "from": "v-delight", "to": "v-animate", "label": "calls", "when": "delight needs motion for its touches"}, {"id": "lv-polish", "from": "late-verbs", "to": "v-polish", "label": "then polish last", "when": "always, after the last tier"}, {"id": "im-init", "from": "impeccable", "to": "v-init", "label": "suggests init", "when": "PRODUCT.md is missing"}, {"id": "im-critique", "from": "impeccable", "to": "v-critique", "label": "suggests critique", "when": "an existing UI needs a review"}, {"id": "im-audit", "from": "impeccable", "to": "v-audit", "label": "offers audit", "when": "technical quality needs checking"}, {"id": "im-shape", "from": "impeccable", "to": "v-shape", "label": "offers shape", "when": "planning UX before code"}, {"id": "im-live", "from": "impeccable", "to": "v-live", "label": "offers live", "when": "interactive browser iteration"}, {"id": "im-overdrive", "from": "impeccable", "to": "v-overdrive", "label": "offers overdrive", "when": "an ambitious, unconventional effect is wanted"}, {"id": "im-verbs", "from": "impeccable", "to": "verbs-group", "label": "offers refine verbs", "when": "fix, refine and enhance work on an existing UI"}, {"id": "im-shape-init", "from": "v-shape", "to": "v-init", "label": "requires", "when": "always; shape needs PRODUCT.md"}, {"id": "im-doc-init", "from": "v-document", "to": "v-init", "label": "requires", "when": "always; document needs PRODUCT.md"}, {"id": "im-audit-harden", "from": "v-audit", "to": "v-harden", "label": "suggests", "when": "audit found edge-case or accessibility gaps"}, {"id": "im-audit-opt", "from": "v-audit", "to": "v-optimize", "label": "suggests", "when": "audit found performance gaps"}, {"id": "im-crit-polish", "from": "v-critique", "to": "v-polish", "label": "feeds", "when": "critique findings feed the final pass"}, {"id": "im-live-polish", "from": "v-live", "to": "v-polish", "label": "calls", "when": "a variant was chosen"}, {"id": "vi-py", "from": "visual", "to": "visual-py", "label": "detects, renders", "when": "every run: detect with no argument, facts in recap, render after data.json"}, {"id": "vi-py-base", "from": "visual-py", "to": "base-branch", "label": "reads git diff", "when": "recap mode collects files, +/- and hunks from git"}, {"id": "h-wt", "from": "claude-settings", "to": "guard-worktree-path", "label": "PreToolUse Bash", "when": "every shell command"}, {"id": "h-del", "from": "claude-settings", "to": "guard-delete-outside", "label": "PreToolUse Bash", "when": "every shell command"}, {"id": "h-sec", "from": "claude-settings", "to": "guard-secrets", "label": "Pre Bash|Read|Grep", "when": "every read, grep or shell command"}, {"id": "h-key", "from": "claude-settings", "to": "guard-key-literals", "label": "Pre/PostToolUse writes", "when": "Edit/MultiEdit/Write/NotebookEdit (and Bash before)"}, {"id": "h-session", "from": "claude-settings", "to": "cleanup-wt", "label": "SessionStart --auto", "when": "a base branch tip moved since the last session"}, {"id": "h-push", "from": "install-sh", "to": "guard-protected-push", "label": "--protect-main wires", "when": "install with --protect-main, or onboard's yes"}, {"id": "h-gate", "from": "hooks", "to": "gate-skill-evals", "label": "dev-only Stop", "when": "only in the pack repo or EricOS; a skill changed without a newer eval"}, {"id": "h-readme", "from": "hooks", "to": "readme-sync", "label": "dev-only sync", "when": "edits or commits under skills/ in the pack repo"}, {"id": "tdd-design", "from": "tdd", "to": "codebase-design", "label": "borrows vocabulary", "when": "the interface or seam shape is itself in question"}, {"id": "tdd-cr", "from": "tdd", "to": "code-review", "label": "defers refactor to", "when": "refactoring belongs to review, not the red-green loop"}, {"id": "tddv2-tdd", "from": "tdd-v2", "to": "tdd", "label": "defers discipline to", "when": "always; tdd owns seams and red-before-green"}, {"id": "impl-tddv2", "from": "implement", "to": "tdd-v2", "label": "builds at the rung", "when": "where possible, at pre-agreed seams"}, {"id": "impl-tdd", "from": "implement", "to": "tdd", "label": "red-green under it", "when": "every slice"}, {"id": "impl-cr", "from": "implement", "to": "code-review", "label": "reviews when done", "when": "once the work is done, before committing"}, {"id": "cr-setup", "from": "code-review", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "docs/agents/issue-tracker.md is missing"}, {"id": "db-ica", "from": "diagnosing-bugs", "to": "improve-codebase-architecture", "label": "hands off post-mortem", "when": "the fix is in and the real finding is a missing seam"}, {"id": "ica-design", "from": "improve-codebase-architecture", "to": "codebase-design", "label": "uses vocabulary", "when": "every suggestion, and design-it-twice for alternatives"}, {"id": "ica-grill", "from": "improve-codebase-architecture", "to": "grilling", "label": "grills the pick", "when": "the user picks a candidate (skipped by super-collect)"}, {"id": "ica-dm", "from": "improve-codebase-architecture", "to": "domain-modeling", "label": "updates CONTEXT.md", "when": "a new term or a rejected candidate worth an ADR"}, {"id": "am-grill-with-docs", "from": "ask-matt", "to": "grill-with-docs", "label": "1 · sharpens idea", "when": "start of the main flow, in a working directory"}, {"id": "am-handoff", "from": "ask-matt", "to": "handoff", "label": "bridges detours", "when": "a question needs a prototype, or a phase boundary"}, {"id": "am-prototype", "from": "ask-matt", "to": "prototype", "label": "answers by code", "when": "a question needs a runnable answer"}, {"id": "am-to-spec", "from": "ask-matt", "to": "to-spec", "label": "multi-session: spec", "when": "the build spans several sessions"}, {"id": "am-to-tickets", "from": "ask-matt", "to": "to-tickets", "label": "splits into tickets", "when": "after to-spec, with blocking edges"}, {"id": "am-implement", "from": "ask-matt", "to": "implement", "label": "builds each ticket", "when": "every ticket, or in place for a small build"}, {"id": "am-tdd", "from": "ask-matt", "to": "tdd", "label": "test-first alone", "when": "a concrete behaviour without a full spec"}, {"id": "am-code-review", "from": "ask-matt", "to": "code-review", "label": "reviews a branch", "when": "reviewing against a fixed point"}, {"id": "am-triage", "from": "ask-matt", "to": "triage", "label": "on-ramp: triage", "when": "raw bugs and requests pile up"}, {"id": "am-diagnosing-bugs", "from": "ask-matt", "to": "diagnosing-bugs", "label": "on-ramp: broken", "when": "something is broken and resists a first look"}, {"id": "am-wayfinder", "from": "ask-matt", "to": "wayfinder", "label": "on-ramp: foggy", "when": "a huge effort too big for one session"}, {"id": "am-improve-codebase-architecture", "from": "ask-matt", "to": "improve-codebase-architecture", "label": "codebase health", "when": "a spare moment for upkeep"}, {"id": "am-domain-modeling", "from": "ask-matt", "to": "domain-modeling", "label": "vocabulary", "when": "the words, not the process, are the problem"}, {"id": "gwd-grill", "from": "grill-with-docs", "to": "grilling", "label": "runs grilling", "when": "every session"}, {"id": "gwd-dm", "from": "grill-with-docs", "to": "domain-modeling", "label": "keeps glossary", "when": "a term is fuzzy or a decision is hard to reverse"}, {"id": "ts-setup", "from": "to-spec", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker and triage labels are not configured"}, {"id": "tt-setup", "from": "to-tickets", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker and triage labels are not configured"}, {"id": "tr-grill", "from": "triage", "to": "grilling", "label": "grills if needed", "when": "an issue is too unclear to brief"}, {"id": "tr-dm", "from": "triage", "to": "domain-modeling", "label": "checks vocabulary", "when": "writing the agent-ready brief"}, {"id": "tr-setup", "from": "triage", "to": "setup-matt-pocock-skills", "label": "needs label map", "when": "the triage label mapping is missing"}, {"id": "wf-grill", "from": "wayfinder", "to": "grilling", "label": "names destination", "when": "first step, and every grilling ticket"}, {"id": "wf-dm", "from": "wayfinder", "to": "domain-modeling", "label": "pins terms", "when": "alongside every grilling session"}, {"id": "wf-proto", "from": "wayfinder", "to": "prototype", "label": "raises fidelity", "when": "a prototype ticket needs UI or logic code"}, {"id": "wf-setup", "from": "wayfinder", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker is not configured"}, {"id": "r-install-hooks", "from": "install-sh", "to": "hooks", "label": "copies guards", "when": "install without --no-hooks (--protect-main adds the push guard)"}, {"id": "onb-answers", "from": "sb-onboard", "to": "onboard-answers", "label": "saves each answer", "when": "the moment each answer is given; resume reads it"}, {"id": "onb-setup", "from": "sb-onboard", "to": "setup-py", "label": "1 · Checks: fix", "when": "every run, first; asks only for system tools or sign-ins"}, {"id": "setup-install", "from": "setup-py", "to": "install-sh", "label": "fix re-runs install", "when": "skills, scripts, workflows, guards or settings entries are missing or old"}, {"id": "setup-gh", "from": "setup-py", "to": "gh-board", "label": "board-rank, migrate", "when": "step 3 (or step 1 on an upgrade): ranks boards, adds columns and labels"}, {"id": "onb-branch", "from": "sb-onboard", "to": "base-branch", "label": "4 · picks base", "when": "step 4; no staging → offers `git push origin main:staging`"}, {"id": "onb-agents", "from": "sb-onboard", "to": "agents-md-py", "label": "5 · AGENTS.md", "when": "step 5: move CLAUDE.md rules, or only add the section"}, {"id": "agents-write", "from": "agents-md-py", "to": "agents-file", "label": "writes block, pointer", "when": "step 8 write, after backup and coverage pass"}, {"id": "onb-settings", "from": "sb-onboard", "to": "settings-py", "label": "6 · Policies", "when": "step 6 answers: safe defaults and N permission lines"}, {"id": "settings-write", "from": "settings-py", "to": "claude-settings", "label": "merges entries", "when": "install (hooks) or onboard step 8 (allow lines)"}, {"id": "settings-push", "from": "settings-py", "to": "guard-protected-push", "label": "wires push guard", "when": "Policies said block pushes to main and the script is installed"}, {"id": "onb-env", "from": "sb-onboard", "to": "env-check", "label": "checks key names", "when": "silent detect and step 7, for Sentry, PostHog and DB keys"}, {"id": "onb-custom", "from": "sb-onboard", "to": "collect-custom", "label": "7 · adds a source", "when": "\"➕ Add another source\": classify, ping read-only, add on ✅"}, {"id": "custom-config", "from": "collect-custom", "to": "sb-config", "label": "saves custom[]", "when": "the ping succeeded; staged until step 8"}, {"id": "lint-tickets", "from": "sb-lint", "to": "to-tickets", "label": "splits too-big", "when": "criterion 15: likely over ~400 changed lines or many areas"}, {"id": "wave-preflight", "from": "wave-js", "to": "preflight", "label": "pre-flights batches", "when": "Ready cards the Builder would take, up to 5 per agent"}, {"id": "preflight-gh", "from": "preflight", "to": "gh-board", "label": "holds to Blocked", "when": "already done, in progress, overlapping, unclear or too big"}, {"id": "gate-needsyou", "from": "merge-gate", "to": "needs-you", "label": "parks (exit 7/8)", "when": "merge_policy says a human merges, or a migration/human step is needed"}, {"id": "needsyou-plan", "from": "needs-you", "to": "wave-plan", "label": "resumes on done", "when": "a human comments done or labels needs-you:done"}, {"id": "super-build-prbody", "from": "super-build", "to": "pr-body", "label": "writes PR blocks", "when": "opening the draft PR and on every rebuild"}, {"id": "super-build-human", "from": "super-build", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "super-qa-prbody", "from": "super-qa", "to": "pr-body", "label": "ticks ac, visual", "when": "every pass or fail handoff"}, {"id": "super-qa-human", "from": "super-qa", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "super-review-prbody", "from": "super-review", "to": "pr-body", "label": "updates status", "when": "after a merge (✅ Merged) or a block"}, {"id": "super-review-human", "from": "super-review", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "review-needsyou", "from": "super-review", "to": "needs-you", "label": "posts 🙋 checklist", "when": "the merge gate exits 7 or 8"}, {"id": "c-custom", "from": "super-collect", "to": "collect-custom", "label": "runs custom sources", "when": "a custom source is requested by name or enabled in collect.sources"}, {"id": "u-prbody", "from": "ui-refine-loop", "to": "pr-body", "label": "builds PR body", "when": "finish: --skeleton marker blocks for the draft PR"}, {"id": "install-settings", "from": "install-sh", "to": "settings-py", "label": "merges hook block", "when": "install without --no-hooks"}, {"id": "secrets-envcheck", "from": "guard-secrets", "to": "env-check", "label": "allows plain call", "when": "a single env-check call with no pipe, chain or redirect"}, {"id": "get-install", "from": "get-sh", "to": "install-sh", "label": "runs install", "when": "after downloading the release tarball"}, {"id": "plugin-onboard", "from": "plugin-mkt", "to": "sb-onboard", "label": "needs onboard", "when": "a plugin ships skills only; onboard step 1 adds the rest"}, {"id": "install-upgrade", "from": "install-sh", "to": "upgrade-json", "label": "records old version", "when": "an older super-board install was found"}, {"id": "upgrade-setup", "from": "upgrade-json", "to": "setup-py", "label": "triggers upgrade", "when": "onboard step 1 runs fix and finds the record"}, {"id": "r-gitsync-base", "from": "git-sync", "to": "base-branch", "label": "pulls, pushes", "when": "every run; a push to the default or a protected branch waits for a yes"}, {"id": "gs-base", "from": "git-sync", "to": "base-branch", "label": "merge-pulls, pushes", "when": "`git pull --no-rebase`, then `git push`; never force"}, {"id": "gs-conflict", "from": "git-sync", "to": "resolving-merge-conflicts", "label": "resolves conflict", "when": "the pull conflicts and the skill is installed; otherwise hunk by hunk"}, {"id": "gs-push", "from": "git-sync", "to": "guard-protected-push", "label": "push checked by", "when": "the opt-in push guard is installed"}], "views": [{"id": "root", "parent": null, "title": "super-board pack", "caption": "Collect verified tickets into the board; the board contains Build → QA → Review. UI refinement, visuals and Git sync are standalone skills. Open a family or step for its tools and policies.", "nodeIds": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "ui-refine-loop", "visual", "git-sync"], "edges": [{"from": "super-collect", "to": "super-board", "label": "Backlog → lint"}, {"from": "super-board", "to": "super-build", "label": "Ready cards"}, "r-build-qa", "r-qa-review", {"from": "super-review", "to": "super-collect", "label": "review done → collect the next tickets", "kind": "feeds", "when": "the board drains; /super-collect files the next verified tickets into Backlog"}], "lanes": false, "layout": {"super-collect": [0, 0], "super-board": [1, 0], "super-build": [2, 0], "super-qa": [3, 0], "super-review": [4, 0], "ui-refine-loop": [5, 0], "visual": [5, 1], "git-sync": [5, 2]}, "nodeOverrides": {"super-collect": {"verbs": [], "sublabel": "Find verified tickets", "emphasis": true}, "super-board": {"verbs": [], "sublabel": "Run the board", "emphasis": true}, "ui-refine-loop": {"verbs": [], "sublabel": "Refine a page", "emphasis": true}, "visual": {"verbs": [], "sublabel": "Draw one visual", "emphasis": true}, "super-build": {"emphasis": true}, "super-qa": {"emphasis": true}, "super-review": {"emphasis": true}, "git-sync": {"verbs": [], "sublabel": "Commit · pull · push", "emphasis": true}}, "containers": [{"id": "collect-family", "label": "/super-collect · intake feeds the board", "nodeIds": ["super-collect"]}, {"id": "board-family", "parent": "collect-family", "label": "/super-board · Build → QA → Review", "nodeIds": ["super-board", "super-build", "super-qa", "super-review"]}], "browserOrder": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "ui-refine-loop", "visual", "git-sync", "hooks", "install"], "intake": [{"label": "Sentry", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMzNjJENTkiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+U2VudHJ5PC90aXRsZT48cGF0aCBkPSJNMTMuOTEgMi41MDVjLS44NzMtMS40NDgtMi45NzItMS40NDgtMy44NDQgMEw2LjkwNCA3LjkyYTE1LjQ3OCAxNS40NzggMCAwIDEgOC41MyAxMi44MTFoLTIuMjIxQTEzLjMwMSAxMy4zMDEgMCAwIDAgNS43ODQgOS44MTRsLTIuOTI2IDUuMDZhNy42NSA3LjY1IDAgMCAxIDQuNDM1IDUuODQ4SDIuMTk0YS4zNjUuMzY1IDAgMCAxLS4yOTgtLjUzNGwxLjQxMy0yLjQwMmE1LjE2IDUuMTYgMCAwIDAtMS42MTQtLjkxM0wuMjk2IDE5LjI3NWEyLjE4MiAyLjE4MiAwIDAgMCAuODEyIDIuOTk5IDIuMjQgMi4yNCAwIDAgMCAxLjA4Ni4yODhoNi45ODNhOS4zMjIgOS4zMjIgMCAwIDAtMy44NDUtOC4zMThsMS4xMS0xLjkyMmExMS40NyAxMS40NyAwIDAgMSA0Ljk1IDEwLjI0aDUuOTE1YTE3LjI0MiAxNy4yNDIgMCAwIDAtNy44ODUtMTUuMjhsMi4yNDQtMy44NDVhLjM3LjM3IDAgMCAxIC41MDQtLjEzYy4yNTUuMTQgOS43NSAxNi43MDggOS45MjggMTYuOWEuMzY1LjM2NSAwIDAgMS0uMzI3LjU0M2gtMi4yODdjLjAyOS42MTIuMDI5IDEuMjIzIDAgMS44MzFoMi4yOTdhMi4yMDYgMi4yMDYgMCAwIDAgMS45MjItMy4zMXoiLz48L3N2Zz4=", "to": "super-collect"}, {"label": "PostHog", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMwMDAwMDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+UG9zdEhvZzwvdGl0bGU+PHBhdGggZD0iTTkuODU0IDE0LjUgNSA5LjY0Ny44NTQgNS41QS41LjUgMCAwIDAgMCA1Ljg1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ni4zNTNMNSAxMy42NDdsLjE0Ny4xNDZMOS44NTQgMTguNWwuMTQ2LjE0N3YtLjA0OWMuMDY1LjAzLjEzNC4wNDkuMjA3LjA0OWgyLjU4NmEuNS41IDAgMCAwIC4zNTMtLjg1NEw5Ljg1NCAxNC41em0wLTUtNC00YS40ODcuNDg3IDAgMCAwLS40MDktLjE0NC41MTUuNTE1IDAgMCAwLS4zNTYuMjEuNDkzLjQ5MyAwIDAgMC0uMDg5LjI4OFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsOSA5YS41LjUgMCAwIDAgLjg1My0uMzU0di0yLjU4NWEuNS41IDAgMCAwLS4xNDYtLjM1NGwtNS01em0xLTRhLjUuNSAwIDAgMC0uODU0LjM1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsNCA0YS41LjUgMCAwIDAgLjg1My0uMzU0VjkuODU0YS41LjUgMCAwIDAtLjE0Ni0uMzU0bC00LTR6bTEyLjY0NyAxMS41MTVhMy44NjMgMy44NjMgMCAwIDEtMi4yMzItMS4xbC00LjcwOC00LjcwN2EuNS41IDAgMCAwLS44NTQuMzU0djYuNTg1YS41LjUgMCAwIDAgLjUuNUgyMy41YS41LjUgMCAwIDAgLjUtLjV2LS42YzAtLjI3Ni0uMjI1LS40OTctLjQ5OS0uNTMyem0tNS4zOTQuMDMyYS44LjggMCAxIDEgMC0xLjYuOC44IDAgMCAxIDAgMS42ek0uODU0IDE1LjVhLjUuNSAwIDAgMC0uODU0LjM1NHYyLjI5M2EuNS41IDAgMCAwIC41LjVoMi4yOTNjLjIyMiAwIC4zOS0uMTM1LjQ2Mi0uMzA5YS40OTMuNDkzIDAgMCAwLS4xMDktLjU0NUwuODU0IDE1LjUwMXpNNSAxNC42NDcuODU0IDEwLjVhLjUuNSAwIDAgMC0uODU0LjM1M3YyLjU4NmEuNS41IDAgMCAwIC4xNDYuMzUzTDQuODU0IDE4LjVsLjE0Ni4xNDdoMi43OTNhLjUuNSAwIDAgMCAuMzUzLS44NTRMNSAxNC42NDd6Ii8+PC9zdmc+", "to": "super-collect"}, {"label": "GitHub", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "super-collect"}], "tour": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "super-collect"]}, {"id": "super-board", "parent": "root", "title": "/super-board · five verbs", "caption": "Onboard sets up; lint makes cards ready; run delegates the lanes. Status inspects a run; stop halts it.", "nodeIds": ["super-board", "sb-onboard", "sb-lint", "sb-status", "sb-run", "sb-stop"], "edges": ["sb-v-onboard", "sb-v-lint", "sb-v-status", "sb-v-run", "sb-v-stop"], "lanes": [{"title": "Prepare", "nodeIds": ["sb-onboard", "sb-lint"]}, {"title": "Run", "nodeIds": ["sb-run"]}, {"title": "Control", "nodeIds": ["sb-status", "sb-stop"]}], "nodeOverrides": {"super-board": {"label": "/super-board", "verbs": [], "sublabel": "Five verbs", "emphasis": true}, "sb-onboard": {"label": "onboard", "verbs": [], "sublabel": "Set up the project", "emphasis": true}, "sb-lint": {"label": "lint", "verbs": [], "sublabel": "Check ticket readiness", "emphasis": true}, "sb-run": {"label": "run", "verbs": [], "sublabel": "Delegate build · QA · review", "emphasis": true}, "sb-status": {"label": "status", "verbs": [], "sublabel": "Inspect the run", "emphasis": true}, "sb-stop": {"label": "stop", "verbs": [], "sublabel": "Halt the run", "emphasis": true}}, "browserOrder": ["super-build", "super-qa", "super-review", "sb-onboard", "sb-lint", "super-board-run", "sb-status", "sb-stop"]}, {"id": "sb-lint", "parent": "super-board", "title": "/super-board lint · Phase 4 routing", "caption": "Interactive-only skills live here, never inside an unattended worker. Ticket-format fixes (criteria 16–18) and catch-alls get an inline draft.", "nodeIds": ["sb-lint", "grilling", "diagnosing-bugs", "v-shape", "v-clarify", "qa-test-planner", "gh-board", "to-tickets"], "edges": ["lint-grill", "lint-diag", "lint-shape", "lint-clarify", "lint-qatp", "sb-lint-gh", "lint-tickets"]}, {"id": "super-board-run", "parent": "super-board", "title": "/super-board run · main steps", "caption": "One wave: classify → pre-flight → delegate → merge → done. Up to min(16, CPUs − 2) cards run at once; the runtime queues the rest. Pre-flight checks batches of 5. Open a step for scripts and policies.", "nodeIds": ["sb-run", "run-classify", "run-preflight", "run-delegate", "run-merge", "run-done"], "edges": [{"from": "sb-run", "to": "run-classify", "label": ""}, {"from": "run-classify", "to": "run-preflight", "label": ""}, {"from": "run-preflight", "to": "run-delegate", "label": ""}, {"from": "run-delegate", "to": "run-merge", "label": ""}, {"from": "run-merge", "to": "run-done", "label": ""}], "render": "process", "nodes": [{"id": "run-classify", "label": "Classify cards", "kind": "step", "what": "Route qa, bug and feature cards by label. Classify unlabelled cards as bug or feature.", "when": "Each Ready card enters the classifier. Existing type labels take priority.", "how": "Read the issue body and comments. Judge complexity as low, medium or high; choose the worker model tier.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/workflows/super-board-wave.js"], "opensView": "run-classify", "sublabel": "qa / bug / feature"}, {"id": "run-preflight", "label": "Pre-flight check", "kind": "step", "what": "Check whether a Ready build card is already done or in progress. Flag overlap, unclear scope and excessive size.", "when": "Before any worktree or Builder starts. Check build cards in batches of up to five.", "how": "Combine mechanical checks with semantic matches. Return proceed, hold, sequence or skipped.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-preflight.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "opensView": "run-preflight", "sublabel": "Done? overlap? too big?"}, {"id": "run-delegate", "label": "Delegate to lanes", "kind": "step", "what": "Run the Build, QA and Review lane agents. QA-labelled cards skip Building.", "when": "After pre-flight allows a build card to proceed. QA and Review cards enter their current lane.", "how": "Build advances to QA, then Review. A non-advanced exit stops that card’s chain; Review uses the session model. The runtime caps concurrent agents at min(16, CPUs − 2), and queues the rest.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/workflows/super-board-wave.js"], "opensView": "run-lanes", "sublabel": "Build → QA → Review"}, {"id": "run-merge", "label": "Merge gate", "kind": "step", "what": "Re-prove the branch under an atomic merge lock. Apply merge policy before squash-merging.", "when": "Once Review passes. Human-only steps park the card in Blocked.", "how": "Check the current base and permitted migrations. Match the PR head before merge; clean the worktree afterwards.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-policy.py"], "opensView": "merge-gate", "sublabel": "Prove + apply policy"}, {"id": "run-done", "label": "Done", "kind": "step", "what": "Squash-merge the approved PR and clean its worktree. Reconcile the returned card result.", "when": "After Review and the merge gate pass. Report the wave before selecting the next one.", "how": "Record merged, bounced, blocked or failed outcomes. Repeat waves until the board drains or a halt gate fires.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/cleanup-wt.py", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-gate.sh"], "opensView": "run-done", "sublabel": "Merge · clean · reconcile"}], "mainSteps": true, "lanes": false, "layout": {"sb-run": [0, 0], "run-classify": [1, 0], "run-preflight": [2, 0], "run-delegate": [3, 0], "run-merge": [4, 0], "run-done": [5, 0]}, "nodeOverrides": {"sb-run": {"label": "Run a wave", "verbs": [], "sublabel": "Claim ready cards", "opensView": "run-start"}}}, {"id": "super-build", "parent": "super-board", "title": "super-build · skills by ticket type", "caption": "An explicit `Skills:` line wins; otherwise the type label picks the chain. Each PR stays under 400 changed lines. grilling is forbidden here and lives in lint.", "nodeIds": ["super-build", "ponytail", "implement", "diagnosing-bugs", "codebase-design", "tdd", "context7", "verification", "code-review", "resolving-merge-conflicts", "ask-matt", "gh-board", "pr-body", "humanizer"], "edges": ["b-pony", "b-impl", "b-diag", "b-design", "b-tdd", "b-docs", "b-verify", "b-review", "b-conflict", "b-askmatt", "b-gh", "super-build-prbody", "super-build-human"], "nodeOverrides": {"verification": {"label": "verification"}, "resolving-merge-conflicts": {"label": "resolve conflicts"}}}, {"id": "super-qa", "parent": "super-board", "title": "super-qa · test plan, gap check, evidence", "caption": "Issue-scoped inside a run (qa-labelled cards skip Building); standalone it crawls routes and files onto the Super Ultimate QA board.", "nodeIds": ["super-qa", "tdd", "tdd-v2", "diagnosing-bugs", "verification", "ask-matt", "testing-strategy", "vitest", "playwright-bp", "gh-board", "file-bug", "qa-board", "pr-body", "humanizer"], "edges": ["q-tdd", "q-tddv2", "q-diag", "q-verify", "q-askmatt", "q-strat", "q-vitest", "q-pw", "q-gh", "q-filebug", "filebug-qaboard", "super-qa-prbody", "super-qa-human"], "nodeOverrides": {"verification": {"label": "verification"}, "playwright-bp": {"label": "Playwright practices"}}}, {"id": "super-review", "parent": "super-board", "title": "super-review · own pass, memory, merge gate", "caption": "Fresh review, adversarial grounding and refactor findings. Passing review enters the merge gate; human-only steps open their own view.", "nodeIds": ["super-review", "code-review", "codebase-design", "ponytail-review", "file-refactor", "merge-gate", "gh-board", "pr-body", "humanizer", "needs-you"], "edges": ["v-cr", "v-design", "v-pony", "v-refactor", "review-gate", "v-gh", "super-review-prbody", "super-review-human", "review-needsyou"], "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "super-collect", "parent": "root", "title": "/super-collect · fetch, verify, file", "caption": "Fetch sources → verify → confirm → file to Backlog. Five built-in sources plus custom ones; collecting never moves a card to Ready.", "nodeIds": ["collect-fetch", "collect-verify", "collect-confirm", "collect-submit"], "edges": [{"from": "collect-fetch", "to": "collect-verify", "label": "candidates"}, {"from": "collect-verify", "to": "collect-confirm", "label": "real ones"}, {"from": "collect-confirm", "to": "collect-submit", "label": "on yes"}], "nodes": [{"id": "collect-fetch", "label": "Fetch sources", "kind": "step", "what": "Fetch the enabled built-in sources. Include any custom sources added in onboard.", "when": "When /super-collect runs for the project. Use the requested window or the default 14 days.", "how": "Read the selected adapters and findings. Send each candidate to a fresh verifier.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-sources", "sublabel": "Last 14 days by default"}, {"id": "collect-verify", "label": "Verify", "kind": "step", "what": "Check whether each candidate is real and still happening. Reject fixed or duplicate problems.", "when": "After source adapters return candidates. Use one fresh verifier for each candidate.", "how": "Verify against the project evidence. Mark unclear candidates needs-triage before filing.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-verify", "sublabel": "One fresh check each"}, {"id": "collect-confirm", "label": "Confirm", "kind": "step", "what": "Show the proposed filing plan. Keep collection dry-run by default.", "when": "After verification produces the candidate results. Before writing tickets to the board.", "how": "Present the plan table for confirmation. Use --yes when filing is already authorized.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-confirm", "sublabel": "Dry run until you say yes"}, {"id": "collect-submit", "label": "File to Backlog", "kind": "step", "what": "File verified problems into Backlog. Apply fingerprints and duplicate checks.", "when": "After confirmation or an authorized --yes run. File candidates marked file or needs-triage.", "how": "Use one filing entry point for all sources. Route bugs, features and fixes separately from refactors.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/super-collect-file.sh"], "opensView": "collect-submit", "sublabel": "Then lint"}], "mainSteps": true, "render": "process", "lanes": false, "layout": {"collect-fetch": [0, 0], "collect-verify": [1, 0], "collect-confirm": [2, 0], "collect-submit": [3, 0]}, "intake": [{"label": "Sentry", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMzNjJENTkiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+U2VudHJ5PC90aXRsZT48cGF0aCBkPSJNMTMuOTEgMi41MDVjLS44NzMtMS40NDgtMi45NzItMS40NDgtMy44NDQgMEw2LjkwNCA3LjkyYTE1LjQ3OCAxNS40NzggMCAwIDEgOC41MyAxMi44MTFoLTIuMjIxQTEzLjMwMSAxMy4zMDEgMCAwIDAgNS43ODQgOS44MTRsLTIuOTI2IDUuMDZhNy42NSA3LjY1IDAgMCAxIDQuNDM1IDUuODQ4SDIuMTk0YS4zNjUuMzY1IDAgMCAxLS4yOTgtLjUzNGwxLjQxMy0yLjQwMmE1LjE2IDUuMTYgMCAwIDAtMS42MTQtLjkxM0wuMjk2IDE5LjI3NWEyLjE4MiAyLjE4MiAwIDAgMCAuODEyIDIuOTk5IDIuMjQgMi4yNCAwIDAgMCAxLjA4Ni4yODhoNi45ODNhOS4zMjIgOS4zMjIgMCAwIDAtMy44NDUtOC4zMThsMS4xMS0xLjkyMmExMS40NyAxMS40NyAwIDAgMSA0Ljk1IDEwLjI0aDUuOTE1YTE3LjI0MiAxNy4yNDIgMCAwIDAtNy44ODUtMTUuMjhsMi4yNDQtMy44NDVhLjM3LjM3IDAgMCAxIC41MDQtLjEzYy4yNTUuMTQgOS43NSAxNi43MDggOS45MjggMTYuOWEuMzY1LjM2NSAwIDAgMS0uMzI3LjU0M2gtMi4yODdjLjAyOS42MTIuMDI5IDEuMjIzIDAgMS44MzFoMi4yOTdhMi4yMDYgMi4yMDYgMCAwIDAgMS45MjItMy4zMXoiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "PostHog", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMwMDAwMDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+UG9zdEhvZzwvdGl0bGU+PHBhdGggZD0iTTkuODU0IDE0LjUgNSA5LjY0Ny44NTQgNS41QS41LjUgMCAwIDAgMCA1Ljg1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ni4zNTNMNSAxMy42NDdsLjE0Ny4xNDZMOS44NTQgMTguNWwuMTQ2LjE0N3YtLjA0OWMuMDY1LjAzLjEzNC4wNDkuMjA3LjA0OWgyLjU4NmEuNS41IDAgMCAwIC4zNTMtLjg1NEw5Ljg1NCAxNC41em0wLTUtNC00YS40ODcuNDg3IDAgMCAwLS40MDktLjE0NC41MTUuNTE1IDAgMCAwLS4zNTYuMjEuNDkzLjQ5MyAwIDAgMC0uMDg5LjI4OFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsOSA5YS41LjUgMCAwIDAgLjg1My0uMzU0di0yLjU4NWEuNS41IDAgMCAwLS4xNDYtLjM1NGwtNS01em0xLTRhLjUuNSAwIDAgMC0uODU0LjM1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsNCA0YS41LjUgMCAwIDAgLjg1My0uMzU0VjkuODU0YS41LjUgMCAwIDAtLjE0Ni0uMzU0bC00LTR6bTEyLjY0NyAxMS41MTVhMy44NjMgMy44NjMgMCAwIDEtMi4yMzItMS4xbC00LjcwOC00LjcwN2EuNS41IDAgMCAwLS44NTQuMzU0djYuNTg1YS41LjUgMCAwIDAgLjUuNUgyMy41YS41LjUgMCAwIDAgLjUtLjV2LS42YzAtLjI3Ni0uMjI1LS40OTctLjQ5OS0uNTMyem0tNS4zOTQuMDMyYS44LjggMCAxIDEgMC0xLjYuOC44IDAgMCAxIDAgMS42ek0uODU0IDE1LjVhLjUuNSAwIDAgMC0uODU0LjM1NHYyLjI5M2EuNS41IDAgMCAwIC41LjVoMi4yOTNjLjIyMiAwIC4zOS0uMTM1LjQ2Mi0uMzA5YS40OTMuNDkzIDAgMCAwLS4xMDktLjU0NUwuODU0IDE1LjUwMXpNNSAxNC42NDcuODU0IDEwLjVhLjUuNSAwIDAgMC0uODU0LjM1M3YyLjU4NmEuNS41IDAgMCAwIC4xNDYuMzUzTDQuODU0IDE4LjVsLjE0Ni4xNDdoMi43OTNhLjUuNSAwIDAgMCAuMzUzLS44NTRMNSAxNC42NDd6Ii8+PC9zdmc+", "to": "collect-fetch"}, {"label": "GitHub issues", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "Merged PRs", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "Architecture", "mark": "◇", "to": "collect-fetch"}, {"label": "custom", "mark": "+", "dashed": true, "to": "collect-fetch"}]}, {"id": "ui-refine-loop", "parent": "root", "title": "/ui-refine-loop · main steps", "caption": "Standalone: direction → check → fix → review → draft PR. Default 5 rounds; stop after two clean P0/P1 checks, two reverted rounds or a dead agent.", "nodeIds": ["ui-refine-loop", "refine-brief", "refine-check", "refine-fix", "refine-review", "refine-pr", "grilling", "impeccable", "verbs-group", "humanizer"], "edges": [{"from": "ui-refine-loop", "to": "refine-brief", "label": ""}, {"from": "refine-brief", "to": "refine-check", "label": ""}, {"from": "refine-check", "to": "refine-fix", "label": ""}, {"from": "refine-fix", "to": "refine-review", "label": ""}, {"from": "refine-review", "to": "refine-pr", "label": ""}], "render": "process", "nodes": [{"id": "refine-brief", "label": "Grill + save direction", "kind": "step", "what": "Read the target code and clarify the intended UI. Save taste and direction for the loop.", "when": "At the start of a standalone refine task. Before unattended checking and fixing begins.", "how": "Ask at most ten questions. Write the agreed direction into the taste file.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-brief", "sublabel": "Agree what good means"}, {"id": "refine-check", "label": "Check the UI", "kind": "step", "what": "Use fresh checkers to identify UI problems. Rank typed findings before a fix.", "when": "At the start of each refinement round. Check the chosen page or component.", "how": "Capture screenshots and run critique or audit. Route typed findings to the appropriate fix verbs.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-check", "sublabel": "Rank typed problems"}, {"id": "refine-fix", "label": "Fix by routed verbs", "kind": "step", "what": "Apply the Impeccable verbs matched to the findings. Run polish last.", "when": "After checkers have ranked the problems. Use a fresh fixer for the round.", "how": "Chain the verbs in their prescribed order. Keep additive motion within the brief’s permission.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-fix", "sublabel": "Polish comes last"}, {"id": "refine-review", "label": "Review each fix", "kind": "step", "what": "Grade every fix with a finish reviewer. Record or revert each round.", "when": "After the round’s fixer completes. Run five rounds by default unless a stop condition fires.", "how": "Write the outcome to the refine ledger. Stop after two clean checks, two reverted rounds or a dead agent.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-review", "sublabel": "Default: 5 rounds"}, {"id": "refine-pr", "label": "Draft the PR", "kind": "step", "what": "Create the final draft PR. Include a Before | After evidence table.", "when": "When the standalone refinement loop finishes. After fixes have received their finish review.", "how": "Use the PR body marker blocks. Follow the writing standard with humanizer.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/scripts/pr-shots.sh"], "opensView": "refine-pr", "sublabel": "Before | After evidence"}], "mainSteps": true, "lanes": false, "layout": {"ui-refine-loop": [0, 0], "refine-brief": [1, 0], "refine-check": [2, 0], "refine-fix": [3, 0], "refine-review": [4, 0], "refine-pr": [5, 0], "grilling": [1, 1], "impeccable": [2, 1], "verbs-group": [3, 1], "humanizer": [4, 1]}, "nodeOverrides": {"ui-refine-loop": {"label": "Refine a UI", "verbs": [], "sublabel": "Page or component", "opensView": "refine-brief"}, "grilling": {"verbs": []}, "impeccable": {"verbs": []}, "verbs-group": {"verbs": []}, "humanizer": {"verbs": []}}, "stepIds": ["ui-refine-loop", "refine-brief", "refine-check", "refine-fix", "refine-review", "refine-pr"], "containers": [{"id": "refine-family", "label": "/ui-refine-loop · standalone refinement", "nodeIds": ["ui-refine-loop", "refine-pr"]}, {"id": "refine-brief-family", "parent": "refine-family", "label": "Direction · tools", "nodeIds": ["refine-brief", "grilling"]}, {"id": "refine-check-family", "parent": "refine-family", "label": "Check · tools", "nodeIds": ["refine-check", "impeccable"]}, {"id": "refine-fix-family", "parent": "refine-family", "label": "Fix · tools", "nodeIds": ["refine-fix", "verbs-group"]}, {"id": "refine-review-family", "parent": "refine-family", "label": "Review · tools", "nodeIds": ["refine-review", "humanizer"]}]}, {"id": "impeccable-verbs", "parent": "ui-refine-loop", "title": "impeccable fix verbs · routing", "caption": "Chain order: distill/extract, then layout/adapt, then typeset/colorize/quieter/bolder, then clarify/harden/onboard, then animate/delight/optimize, and polish last.", "nodeIds": ["verbs-group", "v-distill", "v-extract", "v-layout", "v-adapt", "v-typeset", "v-colorize", "v-quieter", "v-bolder", "v-clarify", "v-harden", "v-onboard", "late-verbs", "v-polish"], "edges": ["iv-v-distill", "iv-v-extract", "iv-v-layout", "iv-v-adapt", "iv-v-typeset", "iv-v-colorize", "iv-v-quieter", "iv-v-bolder", "iv-v-clarify", "iv-v-harden", "iv-v-onboard", "iv-late-verbs", "u-verbs-polish"]}, {"id": "late-verbs", "parent": "impeccable-verbs", "title": "motion + perf verbs", "caption": "The last tier before polish; animate and delight are additive and need the brief's go-ahead.", "nodeIds": ["late-verbs", "v-animate", "v-delight", "v-optimize", "v-polish"], "edges": ["lv-animate", "lv-delight", "lv-optimize", "lv-del-anim", "lv-polish"]}, {"id": "impeccable", "parent": "ui-refine-loop", "title": "impeccable · how its commands connect", "caption": "From the Impeccable command table and diagrams/impeccable/commands.json; the loop never runs shape, live or overdrive.", "nodeIds": ["impeccable", "v-init", "v-document", "v-shape", "v-critique", "v-audit", "v-harden", "v-optimize", "v-polish", "v-live", "v-overdrive", "verbs-group"], "edges": ["im-init", "im-critique", "im-audit", "im-shape", "im-live", "im-overdrive", "im-verbs"]}, {"id": "visual", "parent": "root", "title": "/visual · one page", "caption": "Triggers no other skill; one helper script does detection, git facts and rendering.", "nodeIds": ["visual", "visual-py", "base-branch"], "edges": ["vi-py", "vi-py-base"], "layout": {"visual": [0, 0], "visual-py": [1, 0], "base-branch": [2, 2]}}, {"id": "hooks", "parent": "root", "title": "guard hooks · events and matchers", "caption": "Four guards and cleanup-wt are on by default; the push guard is opt-in; the eval gate and readme sync are dev-only.", "nodeIds": ["hooks", "guard-worktree-path", "guard-delete-outside", "guard-secrets", "guard-key-literals", "guard-protected-push", "cleanup-wt", "gate-skill-evals", "readme-sync"], "edges": ["h-wt", "h-del", "h-sec", "h-key", "h-session", "h-push", "h-gate", "h-readme"], "layout": {"hooks": [0, 2], "guard-worktree-path": [0, 7], "guard-delete-outside": [0, 3], "guard-secrets": [0, 0], "guard-key-literals": [0, 4], "guard-protected-push": [0, 5], "cleanup-wt": [0, 6], "gate-skill-evals": [1, 0], "readme-sync": [1, 1]}}, {"id": "tdd", "parent": "super-build", "title": "tdd · discipline", "caption": "tdd consults, it does not run sessions.", "nodeIds": ["tdd", "codebase-design", "code-review"], "edges": ["tdd-design", "tdd-cr"], "layout": {"tdd": [0, 0], "codebase-design": [1, 0], "code-review": [1, 2]}}, {"id": "tdd-v2", "parent": "super-qa", "title": "tdd-v2 · the testing ladder", "caption": "tdd-v2 owns the rung; tdd owns the loop.", "nodeIds": ["tdd-v2", "tdd"], "edges": ["tddv2-tdd"], "layout": {"tdd-v2": [0, 0], "tdd": [1, 0]}}, {"id": "implement", "parent": "super-build", "title": "implement · build then review", "caption": "EricOS local override of the mattpocock skill.", "nodeIds": ["implement", "tdd-v2", "tdd", "code-review"], "edges": ["impl-tddv2", "impl-tdd", "impl-cr"]}, {"id": "code-review", "parent": "super-build", "title": "code-review · two axes", "caption": "Standards and Spec run as parallel sub-agents and are reported side by side.", "nodeIds": ["code-review", "setup-matt-pocock-skills"], "edges": ["cr-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"code-review": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "diagnosing-bugs", "parent": "super-build", "title": "diagnosing-bugs · six phases", "caption": "Feedback loop, reproduce, hypothesise, instrument, fix + regression test, cleanup + post-mortem.", "nodeIds": ["diagnosing-bugs", "improve-codebase-architecture"], "edges": ["db-ica"], "layout": {"diagnosing-bugs": [0, 0], "improve-codebase-architecture": [1, 0]}}, {"id": "improve-codebase-architecture", "parent": "super-collect", "title": "improve-codebase-architecture", "caption": "super-collect's finder uses only the findings: no HTML report, no grilling.", "nodeIds": ["improve-codebase-architecture", "codebase-design", "grilling", "domain-modeling"], "edges": ["ica-design", "ica-grill", "ica-dm"]}, {"id": "ask-matt", "parent": "super-build", "title": "ask-matt · idea to ship", "caption": "The router's main flow and on-ramps; codebase-design is the other vocabulary underneath.", "nodeIds": ["ask-matt", "grill-with-docs", "handoff", "prototype", "to-spec", "to-tickets", "implement", "tdd", "code-review", "triage", "diagnosing-bugs", "wayfinder", "improve-codebase-architecture", "domain-modeling"], "edges": ["am-grill-with-docs", "am-handoff", "am-prototype", "am-to-spec", "am-to-tickets", "am-implement", "am-tdd", "am-code-review", "am-triage", "am-diagnosing-bugs", "am-wayfinder", "am-improve-codebase-architecture", "am-domain-modeling"]}, {"id": "grill-with-docs", "parent": "ask-matt", "title": "grill-with-docs", "caption": "The grilling primitive plus a paper trail.", "nodeIds": ["grill-with-docs", "grilling", "domain-modeling"], "edges": ["gwd-grill", "gwd-dm"], "layout": {"grill-with-docs": [0, 0], "grilling": [1, 0], "domain-modeling": [1, 2]}}, {"id": "to-spec", "parent": "ask-matt", "title": "to-spec", "caption": "Synthesis only, no interview.", "nodeIds": ["to-spec", "setup-matt-pocock-skills"], "edges": ["ts-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"to-spec": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "to-tickets", "parent": "ask-matt", "title": "to-tickets", "caption": "Tracer-bullet tickets with blocking edges.", "nodeIds": ["to-tickets", "setup-matt-pocock-skills"], "edges": ["tt-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"to-tickets": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "triage", "parent": "ask-matt", "title": "triage · role state machine", "caption": "Only for issues you did not create.", "nodeIds": ["triage", "grilling", "domain-modeling", "setup-matt-pocock-skills"], "edges": ["tr-grill", "tr-dm", "tr-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}}, {"id": "wayfinder", "parent": "ask-matt", "title": "wayfinder · decision map", "caption": "Produces decisions, not deliverables; hands off to to-spec.", "nodeIds": ["wayfinder", "grilling", "domain-modeling", "prototype", "setup-matt-pocock-skills"], "edges": ["wf-grill", "wf-dm", "wf-proto", "wf-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}}, {"id": "sb-onboard", "parent": "super-board", "title": "/super-board onboard · setup", "caption": "Eight questions, grouped into five phases. Answers save as you go; files change once at the final “Write everything” step.", "nodeIds": ["sb-onboard", "onboard-checks", "onboard-project", "onboard-policies", "onboard-sources", "onboard-write"], "edges": [{"from": "sb-onboard", "to": "onboard-checks", "label": ""}, {"from": "onboard-checks", "to": "onboard-project", "label": ""}, {"from": "onboard-project", "to": "onboard-policies", "label": ""}, {"from": "onboard-policies", "to": "onboard-sources", "label": ""}, {"from": "onboard-sources", "to": "onboard-write", "label": ""}], "render": "process", "nodes": [{"id": "onboard-checks", "label": "Check prerequisites", "kind": "step", "what": "Check required tools and GitHub access. Repair missing installation prerequisites.", "when": "At the first Checks and GitHub setup questions. Re-run onboard to repair an existing setup.", "how": "Run the setup helper for must-haves. Save answers as each question completes.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-checks", "sublabel": "Checks · GitHub"}, {"id": "onboard-project", "label": "Choose board + branch", "kind": "step", "what": "Choose the GitHub Project board. Choose the repository’s base branch.", "when": "During the Board and Branch questions. After required tools and GitHub access are ready.", "how": "Record the board and branch in the saved answers. Write the config only after the final review.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-project", "sublabel": "Board · Branch"}, {"id": "onboard-policies", "label": "Set standards + policy", "kind": "step", "what": "Set AGENTS.md standards and merge policies. Choose whether to protect base-branch pushes.", "when": "During the AGENTS.md and Policies questions. Before the final write of repository files.", "how": "Generate the standards and hook settings. Enable the protected-push guard only when chosen.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-policies", "sublabel": "AGENTS.md · Policies"}, {"id": "onboard-sources", "label": "Choose bug sources", "kind": "step", "what": "Enable built-in collection sources. Add any custom source fetchers.", "when": "During the Bug sources setup question. After standards and policies are selected.", "how": "Save source choices in the collect config. Review all answers before writing files.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"], "opensView": "onboard-sources", "sublabel": "Bug sources"}, {"id": "onboard-write", "label": "Review + write once", "kind": "step", "what": "Review all saved setup answers. Write repository files once at step eight.", "when": "When the owner chooses “Write everything”. After all setup questions are complete.", "how": "Apply the setup and config writes together. End by naming /super-board lint as the next command.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-write", "sublabel": "Review · then lint"}], "mainSteps": true, "lanes": false, "layout": {"sb-onboard": [0, 0], "onboard-checks": [1, 0], "onboard-project": [2, 0], "onboard-policies": [3, 0], "onboard-sources": [4, 0], "onboard-write": [5, 0]}, "nodeOverrides": {"sb-onboard": {"label": "Onboard", "sublabel": "New or existing project", "opensView": "onboard-checks"}}}, {"id": "install", "parent": "root", "title": "install · get.sh, plugin, install.sh", "caption": "Three ways in: the one-line get.sh, the plugin marketplace, or ./install.sh from a checkout. Onboard repairs whatever is missing.", "nodeIds": ["get-sh", "plugin-mkt", "install-sh", "upgrade-json", "setup-py", "sb-onboard", "settings-py", "claude-settings", "hooks"], "edges": ["get-install", "plugin-onboard", "install-upgrade", "upgrade-setup", "onb-setup", "setup-install", "install-settings", "settings-write", "r-install-hooks"], "nodeOverrides": {"plugin-mkt": {"label": "plugin marketplace install"}}, "layout": {"get-sh": [0, 1], "plugin-mkt": [0, 0], "install-sh": [1, 1], "sb-onboard": [1, 0], "upgrade-json": [2, 2], "settings-py": [2, 5], "hooks": [2, 0], "setup-py": [3, 1], "claude-settings": [3, 3]}}, {"id": "run-start", "parent": "super-board-run", "title": "Run trigger · planner and guards", "caption": "", "nodeIds": ["sb-run", "wave-plan", "run-manifest", "policy-usage-pause"], "edges": [{"from": "sb-run", "to": "wave-plan", "label": "plan"}, {"from": "sb-run", "to": "run-manifest", "label": "record"}, {"from": "sb-run", "to": "policy-usage-pause", "label": "guard"}], "node": "sb-run", "nodes": [{"id": "policy-usage-pause", "label": "Usage pause", "kind": "step", "what": "Pause when the rate or usage guard requires it. Report the reset time and remaining cards.", "when": "Before the planner at the start of a wave. Resume with /super-board run.", "how": "Check the rate guard and usage window. Halt on repeated zero progress, a high block rate or an explicit stop.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run-workflow.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "opensView": "usage-pause"}], "nodeOverrides": {"wave-plan": {"label": "wave planner"}}}, {"id": "usage-pause", "parent": "run-start", "title": "Usage pause · halt and resume", "caption": "", "nodeIds": ["policy-usage-pause", "sb-run", "sb-stop"], "edges": [{"from": "policy-usage-pause", "to": "sb-stop", "label": "halt"}, {"from": "policy-usage-pause", "to": "sb-run", "label": "resume"}], "node": "policy-usage-pause", "layout": {"policy-usage-pause": [0, 0], "sb-stop": [1, 0], "sb-run": [1, 2]}}, {"id": "run-classify", "parent": "super-board-run", "title": "Classifier · labels, planner and state", "caption": "", "nodeIds": ["run-classify", "wave-js", "wave-plan", "gh-board", "sb-config"], "edges": [{"from": "run-classify", "to": "wave-js", "label": "label routing"}, {"from": "run-classify", "to": "wave-plan", "label": "eligible cards"}, {"from": "run-classify", "to": "gh-board", "label": "board state"}, {"from": "run-classify", "to": "sb-config", "label": "worker tier"}], "node": "run-classify", "nodeOverrides": {"wave-plan": {"label": "wave planner"}}}, {"id": "run-preflight", "parent": "super-board-run", "title": "Pre-flight · readiness and size", "caption": "", "nodeIds": ["run-preflight", "preflight", "sb-lint", "policy-size-cap"], "edges": [{"from": "run-preflight", "to": "preflight", "label": "mechanical checks"}, {"from": "run-preflight", "to": "sb-lint", "label": "readiness"}, {"from": "run-preflight", "to": "policy-size-cap", "label": "size check"}], "node": "run-preflight", "nodes": [{"id": "policy-size-cap", "label": "400-line cap", "kind": "step", "what": "Keep each PR below 400 changed lines. Split a card that is too large.", "when": "During lint and pre-flight readiness checks. Recheck during Build and at the merge gate.", "how": "The Builder stops and proposes a /to-tickets split. Merge policy escalates a diff over auto_max_lines.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/references/decision-policy.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/references/worker-preamble.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "opensView": "size-cap"}], "nodeOverrides": {"preflight": {"label": "pre-flight script"}}}, {"id": "size-cap", "parent": "run-preflight", "title": "400-line cap · split before building", "caption": "", "nodeIds": ["policy-size-cap", "super-build", "to-tickets", "merge-gate"], "edges": [{"from": "policy-size-cap", "to": "super-build", "label": "stop if too big"}, {"from": "policy-size-cap", "to": "to-tickets", "label": "split the card"}, {"from": "policy-size-cap", "to": "merge-gate", "label": "recheck diff"}], "node": "policy-size-cap", "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "run-lanes", "parent": "super-board-run", "title": "Delegate · Build → QA → Review", "caption": "Each card enters the lane selected by its label. Review gets a fresh context.", "nodeIds": ["run-delegate", "super-build", "super-qa", "super-review"], "edges": [{"from": "run-delegate", "to": "super-build", "label": "bug / feature"}, {"from": "run-delegate", "to": "super-qa", "label": "qa skips Build"}, "r-build-qa", "r-qa-review"], "node": "run-delegate", "lanes": [{"title": "Build", "nodeIds": ["super-build"]}, {"title": "QA", "nodeIds": ["super-qa"]}, {"title": "Review", "nodeIds": ["super-review"]}], "layout": {"run-delegate": [0, 0], "super-build": [1, 2], "super-qa": [2, 0], "super-review": [3, 0]}}, {"id": "merge-gate", "parent": "super-board-run", "title": "Merge gate · proof, policy and human handoff", "caption": "", "nodeIds": ["merge-gate", "policy-merge", "needs-you", "cleanup-wt", "base-branch", "guard-protected-push"], "edges": [{"from": "merge-gate", "to": "policy-merge", "label": "who may merge?"}, "gate-needsyou", "gate-cleanup", "gate-base", {"from": "merge-gate", "to": "guard-protected-push", "label": "protect base"}], "node": "merge-gate", "nodes": [{"id": "policy-merge", "label": "Merge policy", "kind": "step", "what": "Decide whether the robot can merge. Route sensitive changes and human steps to needs-you.", "when": "After Review passes. Decide inside the atomic merge lock.", "how": "Exit 7 for money, auth, destructive schema or excessive size. Exit 8 for a disallowed migration or declared human step.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-policy.py"], "opensView": "merge-policy"}], "lanes": [{"title": "Policy", "nodeIds": ["policy-merge", "needs-you", "guard-protected-push"]}, {"title": "Finish", "nodeIds": ["cleanup-wt", "base-branch"]}], "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "merge-policy", "parent": "merge-gate", "title": "Merge policy · automatic or human", "caption": "", "nodeIds": ["policy-merge", "policy-size-cap", "needs-you"], "edges": [{"from": "policy-merge", "to": "policy-size-cap", "label": "diff limit"}, {"from": "policy-merge", "to": "needs-you", "label": "human-only step"}], "node": "policy-merge", "layout": {"policy-merge": [0, 1], "policy-size-cap": [1, 0], "needs-you": [1, 1]}}, {"id": "needs-you", "parent": "merge-gate", "title": "Needs you · human handoff and resume", "caption": "", "nodeIds": ["needs-you", "wave-plan", "super-review"], "edges": ["needsyou-plan", {"from": "needs-you", "to": "super-review", "label": "done → re-review"}], "node": "needs-you", "nodeOverrides": {"wave-plan": {"label": "wave planner"}}, "layout": {"needs-you": [0, 0], "wave-plan": [1, 0], "super-review": [1, 2]}}, {"id": "guard-protected-push", "parent": "merge-gate", "title": "Protected push · opt-in base guard", "caption": "", "nodeIds": ["guard-protected-push", "sb-onboard", "install-sh", "claude-settings"], "edges": [{"from": "guard-protected-push", "to": "sb-onboard", "label": "Policies yes"}, {"from": "guard-protected-push", "to": "install-sh", "label": "--protect-main"}, {"from": "guard-protected-push", "to": "claude-settings", "label": "PreToolUse Bash"}], "node": "guard-protected-push"}, {"id": "run-done", "parent": "super-board-run", "title": "Done · cleanup and reconciliation", "caption": "", "nodeIds": ["run-done", "cleanup-wt", "base-branch", "run-manifest", "gh-board"], "edges": [{"from": "run-done", "to": "cleanup-wt", "label": "remove worktree"}, {"from": "run-done", "to": "base-branch", "label": "merged head"}, {"from": "run-done", "to": "run-manifest", "label": "reconcile"}, {"from": "run-done", "to": "gh-board", "label": "update cards"}], "node": "run-done"}, {"id": "onboard-checks", "parent": "sb-onboard", "title": "Prerequisites · repair and install", "caption": "", "nodeIds": ["onboard-checks", "setup-py", "install-sh", "env-check", "onboard-answers"], "edges": [{"from": "onboard-checks", "to": "setup-py", "label": "repair"}, {"from": "onboard-checks", "to": "install-sh", "label": "install"}, {"from": "onboard-checks", "to": "env-check", "label": "tools + auth"}, {"from": "onboard-checks", "to": "onboard-answers", "label": "save answers"}], "node": "onboard-checks", "nodeOverrides": {"env-check": {"label": "environment check"}}}, {"id": "onboard-project", "parent": "sb-onboard", "title": "Project · board, branch and config", "caption": "", "nodeIds": ["onboard-project", "gh-board", "base-branch", "sb-config"], "edges": [{"from": "onboard-project", "to": "gh-board", "label": "choose board"}, {"from": "onboard-project", "to": "base-branch", "label": "choose base"}, {"from": "onboard-project", "to": "sb-config", "label": "save config"}], "node": "onboard-project"}, {"id": "onboard-policies", "parent": "sb-onboard", "title": "Standards + policies · files and guards", "caption": "", "nodeIds": ["onboard-policies", "agents-md-py", "agents-file", "settings-py", "claude-settings", "guard-protected-push", "policy-merge"], "edges": [{"from": "onboard-policies", "to": "agents-md-py", "label": "generate standards"}, {"from": "onboard-policies", "to": "agents-file", "label": "repo standards"}, {"from": "onboard-policies", "to": "settings-py", "label": "write settings"}, {"from": "onboard-policies", "to": "claude-settings", "label": "hook settings"}, {"from": "onboard-policies", "to": "guard-protected-push", "label": "opt-in guard"}, {"from": "onboard-policies", "to": "policy-merge", "label": "merge rules"}], "node": "onboard-policies", "nodeOverrides": {"agents-md-py": {"label": "standards writer"}}}, {"id": "onboard-sources", "parent": "sb-onboard", "title": "Sources · built-in and custom", "caption": "", "nodeIds": ["onboard-sources", "super-collect", "collect-custom", "sb-config"], "edges": [{"from": "onboard-sources", "to": "super-collect", "label": "five built-ins"}, {"from": "onboard-sources", "to": "collect-custom", "label": "custom fetcher"}, {"from": "onboard-sources", "to": "sb-config", "label": "enabled sources"}], "node": "onboard-sources"}, {"id": "onboard-write", "parent": "sb-onboard", "title": "Review · saved answers and final write", "caption": "", "nodeIds": ["onboard-write", "onboard-answers", "setup-py", "sb-config", "sb-lint"], "edges": [{"from": "onboard-write", "to": "onboard-answers", "label": "review answers"}, {"from": "onboard-write", "to": "setup-py", "label": "write everything"}, {"from": "onboard-write", "to": "sb-config", "label": "save once"}, {"from": "onboard-write", "to": "sb-lint", "label": "next command"}], "node": "onboard-write"}, {"id": "collect-sources", "parent": "super-collect", "title": "Fetch · source adapters", "caption": "", "nodeIds": ["collect-fetch", "collect-sentry", "collect-posthog", "gh-issues", "collect-prs", "improve-codebase-architecture", "collect-custom"], "edges": [{"from": "collect-fetch", "to": "collect-sentry", "label": "sentry"}, {"from": "collect-fetch", "to": "collect-posthog", "label": "posthog"}, {"from": "collect-fetch", "to": "gh-issues", "label": "github"}, {"from": "collect-fetch", "to": "collect-prs", "label": "prs"}, {"from": "collect-fetch", "to": "improve-codebase-architecture", "label": "architecture"}, {"from": "collect-fetch", "to": "collect-custom", "label": "custom"}], "node": "collect-fetch"}, {"id": "collect-verify", "parent": "super-collect", "title": "Verify · a fresh pass for every candidate", "caption": "", "nodeIds": ["collect-verify", "codebase-design", "ponytail-audit", "collect-file"], "edges": [{"from": "collect-verify", "to": "codebase-design", "label": "architecture vocabulary"}, {"from": "collect-verify", "to": "ponytail-audit", "label": "audit findings"}, {"from": "collect-verify", "to": "collect-file", "label": "file / needs-triage"}], "node": "collect-verify"}, {"id": "collect-confirm", "parent": "super-collect", "title": "Confirm · dry-run and enabled sources", "caption": "", "nodeIds": ["collect-confirm", "sb-config", "collect-file"], "edges": [{"from": "collect-confirm", "to": "sb-config", "label": "enabled sources"}, {"from": "collect-confirm", "to": "collect-file", "label": "confirm → --yes"}], "node": "collect-confirm", "layout": {"collect-confirm": [0, 0], "collect-file": [1, 0], "sb-config": [1, 2]}}, {"id": "collect-submit", "parent": "super-collect", "title": "File · one entry point and dedupe", "caption": "", "nodeIds": ["collect-submit", "collect-file", "file-bug", "file-refactor", "gh-board"], "edges": [{"from": "collect-submit", "to": "collect-file", "label": "single entry point"}, {"from": "collect-submit", "to": "file-bug", "label": "bug / feature / fix"}, {"from": "collect-submit", "to": "file-refactor", "label": "refactor"}, {"from": "collect-submit", "to": "gh-board", "label": "Backlog"}], "node": "collect-submit"}, {"id": "refine-brief", "parent": "ui-refine-loop", "title": "Direction · brief and taste", "caption": "", "nodeIds": ["refine-brief", "grilling", "taste-file", "sb-config"], "edges": [{"from": "refine-brief", "to": "grilling", "label": "at most 10 questions"}, {"from": "refine-brief", "to": "taste-file", "label": "save direction"}, {"from": "refine-brief", "to": "sb-config", "label": "refine settings"}], "node": "refine-brief"}, {"id": "refine-check", "parent": "ui-refine-loop", "title": "Check · screenshot, critique and audit", "caption": "", "nodeIds": ["refine-check", "shoot", "v-critique", "imp-detect", "v-audit", "impeccable"], "edges": [{"from": "refine-check", "to": "shoot", "label": "screenshots"}, {"from": "refine-check", "to": "v-critique", "label": "design problems"}, {"from": "refine-check", "to": "imp-detect", "label": "typed checker"}, {"from": "refine-check", "to": "v-audit", "label": "functional audit"}, {"from": "refine-check", "to": "impeccable", "label": "command reference"}], "node": "refine-check"}, {"id": "refine-fix", "parent": "ui-refine-loop", "title": "Fix · routed verbs, polish last", "caption": "", "nodeIds": ["refine-fix", "verbs-group", "v-polish"], "edges": [{"from": "refine-fix", "to": "verbs-group", "label": "route by problem"}, {"from": "verbs-group", "to": "v-polish", "label": "last"}], "node": "refine-fix", "layout": {"refine-fix": [0, 0], "verbs-group": [1, 0], "v-polish": [2, 0]}}, {"id": "refine-review", "parent": "ui-refine-loop", "title": "Review · ledger and finish standard", "caption": "", "nodeIds": ["refine-review", "refine-ledger", "humanizer"], "edges": [{"from": "refine-review", "to": "refine-ledger", "label": "grade / record / revert"}, {"from": "refine-review", "to": "humanizer", "label": "writing standard"}], "node": "refine-review", "layout": {"refine-review": [0, 0], "humanizer": [1, 0], "refine-ledger": [1, 2]}}, {"id": "refine-pr", "parent": "ui-refine-loop", "title": "Draft PR · evidence and marker blocks", "caption": "", "nodeIds": ["refine-pr", "draft-pr", "pr-body", "base-branch"], "edges": [{"from": "refine-pr", "to": "draft-pr", "label": "Before | After"}, {"from": "refine-pr", "to": "pr-body", "label": "marker blocks"}, {"from": "refine-pr", "to": "base-branch", "label": "standalone branch"}], "node": "refine-pr"}, {"id": "hook-settings", "parent": "hooks", "title": "Hook installation · settings and environment", "caption": "Install writes hook settings; onboard repairs installation. Merge policy has its own drill-down.", "nodeIds": ["install-sh", "settings-py", "claude-settings", "env-check", "merge-gate"], "edges": ["install-settings", "settings-write"], "nodeOverrides": {"env-check": {"label": "environment check"}, "merge-gate": {"label": "merge gate script"}}, "layout": {"install-sh": [0, 0], "env-check": [0, 1], "merge-gate": [0, 2], "settings-py": [1, 0], "claude-settings": [2, 3]}}, {"id": "sb-status", "parent": "super-board", "title": "/super-board status", "caption": "Inspect active work, lane outcomes and the dispatcher status without starting a worker.", "nodeIds": ["sb-status"], "edges": [], "layout": {"sb-status": [0, 0]}}, {"id": "sb-stop", "parent": "super-board", "title": "/super-board stop", "caption": "Halt the active dispatcher and report what was stopped.", "nodeIds": ["sb-stop"], "edges": [], "layout": {"sb-stop": [0, 0]}}, {"id": "git-sync", "parent": "root", "title": "/git-sync · commit, pull, push", "caption": "Standalone; no lane runs it. Merges, never rebases, and never force-pushes.", "nodeIds": ["git-sync", "base-branch", "resolving-merge-conflicts", "guard-protected-push"], "edges": ["gs-base", "gs-conflict", "gs-push"]}], "notes": ["Refreshed to super-board v3.0.0 (feat/sb-cleanup @ b67241e1, 28 commits after cd199b2d). Source paths are repo-root-relative.", "Board: seven columns, no Skipped (a dropped card is closed as not planned → Done with 🤷). Labels qa · bug · feature route cards; qa skips Building; the classifier adds feature or bug, never qa. The per-board `variant` is gone and a `qa-only` config is refused with exit 65 until onboard upgrades it.", "Onboarding is an 8-step wizard (Checks · GitHub · Board · Branch · AGENTS.md · Policies · Bug sources · Review) backed by super-board-setup.py (check, fix, migrate-config, names, branch, board-rank, board-migrate). New view sb-onboard; its steps are edge labels, not nodes.", "Merge policy and DB migrations live in the merge gate (super-board-merge-policy.py): money, auth, destructive schema or a diff over auto_max_lines (400 changed lines, lockfiles/generated/snapshots/migration SQL excluded) exits 7; a migration outside allowed_envs, a failed migrate or a declared human step exits 8. Both park the card in Blocked with the 🙋 checklist and the needs-you label, with no extra column; `done` sends it back through the planner's resume list.", "Builder pre-flight (super-board-preflight.sh, a Pre-flight phase in super-board-wave.js, batches of 5) checks already done / in progress / file overlap / unclear / too big before any card is built. Lint has 18 criteria now: 15 = too big (split via /to-tickets), 16–18 = ticket format.", "Writing standard (references/writing-standard.md): commits `<emoji> [type] scope: subject` + bullets, tickets Problem · Context · Fix · AC · Risk · Blocked by, PR bodies in marker blocks rewritten per lane with super-board-pr-body.sh, comments `[role] [label] status`, prose through humanizer when installed. That is why every lane view now shows pr-body and humanizer.", "super-collect gained custom sources (collect_custom.py: http, cli, mcp) added in onboard's \"➕ Add another source\", with fingerprint `custom|<name>|<key>` and the same verifier and filer.", "Install: get.sh one-liner, a plugin marketplace (skills only; onboard adds hooks, scripts and workflows), install.sh with grouped output and an upgrade record, and super-board-settings.py for hook and allow-line merges. There is a new install view under root. env-check (key names only) is allowed through guard-secrets. The AGENTS.md helper is super-board-agents-md.py.", "Added nodes: preflight, pr-body, needs-you, setup-py, agents-md-py, agents-file, settings-py, env-check, collect-custom, get-sh, plugin-mkt, onboard-answers, upgrade-json. Added views: sb-onboard, install. Removed edges: sb-onb-push (now settings-push in sb-onboard), h-install and h-ships (now install-sh → settings-py and install-sh → hooks). Nothing was renamed.", "Also since 88c27812: super-review truth-check sub-agents get a fixed verbatim brief (Over-engineering never blocks), and status lists columns in board order with Backlog. Disagreement: the coordinator listed 'labels qa/bug/feature routing'. That matches, with one addition: no label is also built (treated as feature).", "Kept as-is but stale in the files: the merge protocol and the wave.js `humanApprovesMerge` arg still mention human_approves_merge, which onboard now migrates into merge_policy. super-qa standalone still files onto the separate Super Ultimate QA board.", "The Builder only proposes a /to-tickets split in a PR comment when a build outgrows the cap; it does not run to-tickets, so there is no super-build → to-tickets edge. lint does dispatch it.", "Unchanged from v2: ui-refine-loop is standalone, now stated in super-review and super-qa as 'file a UI ticket; a human can run /ui-refine-loop'. cleanup-wt still runs at SessionStart and post-merge. qa-test-planner, testing-strategy, vitest and playwright-best-practices are still not installed in EricOS."], "authors": {"EricTechPro": {"name": "Eric Tech", "url": "https://github.com/EricTechPro", "avatar": "data:image/jpeg;base64,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"}, "mattpocock": {"name": "Matt Pocock", "url": "https://github.com/mattpocock", "avatar": "data:image/png;base64,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"}, "DietrichGebert": {"name": "Dietrich Gebert", "url": "https://github.com/DietrichGebert", "avatar": "data:image/png;base64,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"}, "pbakaus": {"name": "Paul Bakaus", "url": "https://github.com/pbakaus", "avatar": "data:image/jpeg;base64,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"}, "blader": {"name": "blader", "url": "https://github.com/blader", "avatar": "data:image/jpeg;base64,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"}, "upstash": {"name": "Upstash", "url": "https://github.com/upstash", "avatar": "data:image/png;base64,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"}, "obra": {"name": "Jesse Vincent (obra/superpowers, inferred)", "url": "https://github.com/obra", "avatar": "data:image/jpeg;base64,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"}, "BuilderIO": {"name": "Builder.io", "url": "https://github.com/BuilderIO", "avatar": "data:image/png;base64,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"}, "tt-a1i": {"name": "tt-a1i (archify)", "url": "https://github.com/tt-a1i", "avatar": "data:image/jpeg;base64,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"}}, "version": "3.0.0", "kind": "map", "source": "diagrams/skill-map.json", "avatarsEmbedded": 9, "meta": {"generated": "2026-10-03T20:20", "project": "super-board", "sourceBase": "https://github.com/mnphuc/super-board-gitea/blob/main/", "root": ""}}</script> <script> (() => { const D = JSON.parse(document.getElementById('visual-data').textContent) || {}; diff --git a/diagrams/visual/skill-map.html b/diagrams/visual/skill-map.html index 051221ce..7db3b500 100644 --- a/diagrams/visual/skill-map.html +++ b/diagrams/visual/skill-map.html @@ -558,7 +558,7 @@ <body> <div class="bar"><div class="wrap"><span class="brand">/visual</span><nav id="nav"></nav><button class="btn" id="theme" type="button" aria-label="Toggle theme">◐</button></div></div> <main class="wrap" id="app"></main> -<script id="visual-data" type="application/json">{"title": "super-board skill map", "pack": "_skills/vendor/super-board", "branch": "feat/sb-cleanup @ b67241e1 (v3.0.0)", "sourcesBase": "", "kinds": {"public": "skill or command a user triggers directly", "lane": "board lane skill: started by /super-board run, also runnable standalone", "external": "skill from outside the pack (origin field says where)", "verb": "an Impeccable command", "script": "shell, python, node script or saved Workflow", "hook": "Claude Code hook or guard", "board": "state: GitHub Project, config, ledgers, repo"}, "nodes": [{"id": "super-board", "label": "/super-board", "kind": "public", "what": "The autonomous GitHub-Project pipeline: five verbs (onboard, lint, status, run, stop) take one board shape (Backlog · Ready · Building · QA · Review · Blocked · Done) from empty to drained, with labels qa · bug · feature routing each card.", "when": "Eric types /super-board <verb>, or says \"drain my GitHub project\" or \"stop super-board\"; with no verb it asks which one.", "how": "The session is an orchestrator only: it routes the verb to its reference file, dispatches lane agents, and never does product work itself. Board state is the only state, so `run` is also resume. Every commit, ticket, PR body and comment follows references/writing-standard.md.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/writing-standard.md"], "verbs": ["onboard", "lint", "status", "run", "stop"], "sublabel": "onboard · lint · status · run · stop", "opensView": "super-board", "author": "EricTechPro"}, {"id": "super-collect", "label": "/super-collect", "kind": "public", "what": "Finds problems in one project and files them as verified tickets into its super-board Backlog: five built-in sources plus any custom source added in onboard. It never builds, edits app code, or moves a card to Ready.", "when": "Eric runs /super-collect (all enabled sources) or /super-collect <source…> with sentry, posthog, github, prs, architecture or a custom source's name; optional --since and --yes.", "how": "Fetches each source for the window (default 14 days), sends every candidate to one fresh verifier sub-agent, then files through super-collect-file.sh. Dry-run by default: it shows a plan table and files on confirm.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"], "verbs": ["sentry", "posthog", "github", "prs", "architecture", "custom"], "sublabel": "sentry · posthog · github · prs · architecture · custom", "opensView": "super-collect", "author": "EricTechPro"}, {"id": "ui-refine-loop", "label": "/ui-refine-loop", "kind": "public", "what": "Unattended Impeccable check-then-fix loop on one page or component that ends in a draft PR with a Before | After table. Standalone: no board lane ever starts it.", "when": "Eric runs /ui-refine-loop <route | component | description> [\"what's wrong\"] [--rounds N], or says \"refine loop\" or \"polish this page with impeccable\".", "how": "Reads the target's code, grills Eric (at most 10 questions) into a taste file, then runs the saved ui-refine-loop workflow: each round fresh checkers rank typed problems and a fresh fixer chains Impeccable verbs, polish last. Default 5 rounds; a finish reviewer grades every fix. Commits are `💄 [ui] <slug>: …` and the PR body uses super-board-pr-body.sh's marker blocks.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js"], "verbs": ["<route|component>", "--rounds N"], "sublabel": "grill · check · fix · draft PR", "opensView": "ui-refine-loop", "author": "EricTechPro"}, {"id": "visual", "label": "/visual", "kind": "public", "what": "Turns the current work into one self-contained HTML page: a branch recap, a plan, or a map of a folder or architecture, with diagrams, a file map and annotated code.", "when": "Eric runs /visual, /visual recap [base], /visual plan [file] or /visual <path>; with no argument visual.py detect picks the mode.", "how": "Writes a data.json from git facts or the plan, then visual.py render injects it into an inline template with no build step. It screenshots the page headless to check it, and offers to publish only on a yes.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/visual/SKILL.md"], "verbs": ["recap", "plan", "explore"], "sublabel": "recap · plan · explore", "opensView": "visual", "author": "EricTechPro", "credits": ["BuilderIO", "tt-a1i"]}, {"id": "sb-onboard", "label": "/super-board onboard", "kind": "public", "what": "An 8-step setup wizard (Checks · GitHub · Board · Branch · AGENTS.md · Policies · Bug sources · Review) that installs or repairs what the board needs and writes the config once.", "when": "Eric runs /super-board onboard (or /super-board:super-board onboard after a plugin install), on a new project, after an upgrade from 2.x, or to check and repair an existing setup.", "how": "One AskUserQuestion per step with the recommended option first; must-haves are fixed without asking by super-board-setup.py. Answers save to onboard-answers.json as they come, so a halt resumes, and repo files change only at step 8 after \"Write everything\". It ends by naming /super-board lint.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"], "author": "EricTechPro", "opensView": "sb-onboard"}, {"id": "sb-lint", "label": "/super-board lint", "kind": "public", "what": "Pre-flight readiness check that walks Ready, Building, QA and Review, flags issues that fail any of 18 criteria, proposes a qa/bug/feature label, and dispatches a helper skill per flagged issue.", "when": "Eric runs /super-board lint before a run, typically after /super-collect filed new Backlog cards.", "how": "Criteria 13–18 cover what the loop needs: a parseable `## Blocked by` line, a fake with no follow-up card, too big (over ~400 changed lines or many areas), the ticket sections, a checklist AC, and lettered Context steps. Phase 4 routes each flagged pattern to one skill sub-agent while Eric keeps the pace.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/lint.md"], "opensView": "sb-lint", "author": "EricTechPro"}, {"id": "sb-status", "label": "/super-board status", "kind": "public", "what": "Read-only snapshot of the active config, every column in board order (Backlog included), and in-flight workers.", "when": "Eric runs /super-board status to see where a run stands.", "how": "super-board-status.py reads the board and local in-flight state and prints the columns in the board's own order; it changes nothing.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/status.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-status.py"], "author": "EricTechPro"}, {"id": "sb-run", "label": "/super-board run", "kind": "public", "what": "The autonomous loop: repeated waves of the super-board-wave workflow from this session until the board drains or a halt gate fires. Also the resume command.", "when": "Eric runs /super-board run [--low|--high] [<slug>]; the default worker_backend \"workflow\" stays in-session, \"claude-p\" opts into the legacy headless runner.", "how": "Each wave: rate and usage guard, plan with super-board-wave-plan.sh (which refuses an old `variant: qa-only` config with exit 65), act on sweep/flag/stranded/resume, claim cards by assignee, launch the workflow, reconcile, report. Halts after 3 zero-progress waves, a high block rate, or a stop.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run-workflow.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "verbs": ["--low", "--high"], "opensView": "super-board-run", "author": "EricTechPro"}, {"id": "sb-stop", "label": "/super-board stop", "kind": "public", "what": "Graceful shutdown: stops the wave, posts \"stopped mid-flight\" comments, releases assignee claims, and removes the wave lock so the next run resumes.", "when": "Eric runs /super-board stop or says \"stop the run\" / \"pause the loop\".", "how": "Stops the workflow (or kills the legacy dispatcher via super-board-stop.sh), comments on every in-flight issue and PR, and strips bot_identity assignees. Resume is just `run` again.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/stop.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-stop.sh"], "author": "EricTechPro"}, {"id": "super-build", "label": "super-build", "kind": "lane", "what": "Builder lane: takes a pre-flighted Ready card into its own worktree, makes the smallest safe change test-first under the 400-line PR cap, opens a draft PR and moves the card to QA. It never merges.", "when": "Started by the board: the super-board-wave workflow runs it for Ready cards labelled feature or bug (or unlabelled) once pre-flight says proceed. Also runnable standalone as /super-build (legacy headless claude -p dispatch).", "how": "Follows run.md's Builder lifecycle. An explicit `Skills:` line wins, else the type label picks the chain, always plus ponytail first, verification-before-completion and a code-review of its own diff. Past the size cap mid-build it stops and proposes a /to-tickets split. Commits and PR blocks follow the writing standard via super-board-pr-body.sh.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-build/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-build/references/decision-policy.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-build/references/worker-preamble.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "opensView": "super-build", "author": "EricTechPro"}, {"id": "super-qa", "label": "super-qa", "kind": "lane", "what": "Tester lane: builds an issue-scoped test plan, runs a test-gap check on the Builder's diff, captures evidence and screenshots, then passes the card to Review or bounces it to Build.", "when": "Started by the board for cards in QA, and straight from Ready for cards labelled qa (they skip Building). Also runnable standalone as /super-qa, a BFS route-crawling bug-bash, or /super-qa <url> for a live site with no repo.", "how": "One observable test per AC plus the test-gap ledger, High gaps written red-first. On a qa card it creates the issue branch itself and files real defects as bug cards. It ticks the PR's ac block, writes visual and history rows with super-board-pr-body.sh, and posts `[qa] [report]` comments with screenshots pinned to a sha.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/references/iteration-preamble.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "opensView": "super-qa", "author": "EricTechPro"}, {"id": "super-review", "label": "super-review", "kind": "lane", "what": "Reviewer lane and standalone PR review: forms its own hypotheses first, remembers prior findings, classes every finding, and merges only through the merge gate.", "when": "Started by the board for cards in Review (always on the session model). Also runnable standalone when Eric says \"review this branch\" or \"is this merge-ready\".", "how": "Thread scan, prior-report round 1, own pass with code-review, codebase-design and ponytail-review, a rerun of the Tester's exact test command, then an adversarial truth-check on non-trivial diffs. One report comment is edited in place every round. A clean review merges through the gate pinned to the reviewed head SHA; exit 7 or 8 parks the card in Blocked with 🙋. Visual problems become a UI ticket, never a ui-refine-loop run. The truth-check sub-agents get a fixed verbatim brief, and Over-engineering is never a Blocker from any of them.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-review/SKILL.md"], "opensView": "super-review", "author": "EricTechPro"}, {"id": "gh-board", "label": "GitHub Project board", "kind": "board", "what": "The configured GitHub Project with seven columns (Backlog, Ready, Building, QA, Review, Blocked, Done) and three routing labels (qa, bug, feature); the only loop state. There is no Skipped column.", "when": "Read and written on every wave, by every lane move, and by /super-collect filing into Backlog.", "how": "Cards move by `gh project item-edit`; assignees act as claim mutexes; PR threads start with their owner lane [builder] / [qa] / [reviewer] plus a label. A card dropped on purpose is closed as not planned and moved to Done with a 🤷 comment.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run-workflow.md"]}, {"id": "sb-config", "label": "super-board config", "kind": "board", "what": "Per-project JSON config: board, base branch, timezone, the seven columns, labels, merge_policy, migrations, worker backend, model tier, truth gate, plus `collect` (sources and custom[]) and `refine` blocks. No `variant` key.", "when": "Written once by onboard at step 8 (and migrated to v3 keys by super-board-setup.py fix); read at the start of every run, collect and ui-refine-loop setup.", "how": "Lives at `.claude/super-board/configs/<slug>.json` with `.claude/super-board/active` pointing at it, validated against config-schema.json.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/config-schema.json"]}, {"id": "base-branch", "label": "repo · base branch", "kind": "board", "what": "The project's git repo and configured base branch (never assumed to be main); a card is Done only when its merge commit is an ancestor of it.", "when": "Changed only by a merge-gate squash-merge; read by /visual and branched from by every worktree.", "how": "Lanes and ui-refine-loop work on their own branches under .worktrees/ or .claude/worktrees/; the opt-in protected-push guard can block direct pushes to it.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-review/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"]}, {"id": "run-manifest", "label": "run manifest", "kind": "board", "what": "Per-run ledger at `docs/super-board/runs/<date>-<slug>.md`, one line per card per wave.", "when": "Appended during each wave's reconcile step.", "how": "Each line records card, lanes run, final status, column and detail: `| #N | <lanesRun> | <finalStatus> | <column> | <detail> |`.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run-workflow.md"]}, {"id": "qa-board", "label": "Super Ultimate QA board", "kind": "board", "what": "Separate GitHub Project (Queue, Testing, Done, Bug, Flaky, Skip) used by standalone /super-qa as its loop state.", "when": "Written when a standalone super-qa iteration finds a red spec; /super-collect bugs and qa-card defects also go through the same filer.", "how": "super-qa-file-bug.sh creates a `source:qa` issue with the evidence body and sets its Status to Bug (Flaky and Skip for the other outcomes).", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/SKILL.md"]}, {"id": "taste-file", "label": "taste + direction file", "kind": "board", "what": "Per-project design taste file (default `docs/design/taste.md`) holding the grill's goal, direction, keep and avoid answers plus taste rules and slop tells.", "when": "Written after the grill and committed as the refine branch's first commit; read first by every checker, fixer and finish reviewer.", "how": "Starts from the neutral references/taste.md when absent; each target gets a `### <target>` block under Direction, with \"you pick\" answers marked (picked).", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/grill.md", "https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/taste.md"]}, {"id": "refine-ledger", "label": "refine ledger", "kind": "board", "what": "The only memory carried between refine rounds: one line per check with score /40, before-vs-now, and problem ids.", "when": "Appended by the workflow after every check; written to `<run>/ledger.md` at finish.", "how": "Checkers reuse ledger ids so a problem that survives three checks is called out; stop rules read it (two clean checks, two reverts in a row).", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/ledger.md"]}, {"id": "draft-pr", "label": "refine draft PR", "kind": "board", "what": "The draft PR from `refine/<slug>` against the recorded base branch, with a Before | After table, score line and finish grades.", "when": "Opened once at the end of a ui-refine-loop run; never merged by the loop.", "how": "pr-shots.sh commits round-0 and final shots to `docs/ui-refine/<slug>/` and prints a Before | After table pinned to both shas; the body uses the writing standard's marker blocks (status, problem, solution, ac, history, visual, risk) and is humanized before `gh pr create --draft`.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/scripts/pr-shots.sh"]}, {"id": "gh-issues", "label": "open GitHub issues", "kind": "board", "what": "The repo's open issues that are not yet on the board and carry no `source:*` label.", "when": "Read by the /super-collect github source.", "how": "Fetched with `gh issue list --state open`; real work is adopted onto the board (`--adopt <n>`), never copied into a new issue.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"]}, {"id": "claude-settings", "label": ".claude/settings.json", "kind": "board", "what": "The target project's Claude Code settings, where install.sh merges the guard hook block from settings-snippet.json.", "when": "Written by install.sh (backed up first, never adding a command twice); read by Claude Code at every session.", "how": "Wires PreToolUse, PostToolUse and SessionStart commands to the scripts copied into `.claude/hooks/`; `--protect-main` adds settings-protect-main.json.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/settings-snippet.json", "https://github.com/EricTechPro/super-board/blob/main/hooks/settings-protect-main.json", "https://github.com/EricTechPro/super-board/blob/main/install.sh"]}, {"id": "hooks", "label": "guard hooks", "kind": "hook", "what": "The pack's Claude Code hooks: four default guards, an opt-in push guard, post-merge worktree cleanup, and two dev-only hooks for the pack itself.", "when": "Installed by install.sh unless --no-hooks; each fires on its Claude Code event and matcher.", "how": "Python 3 stdlib scripts that read hook JSON on stdin, print a decision only when they block, and exit 0 on their own errors so a broken guard never stops work.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/README.md"], "opensView": "hooks"}, {"id": "guard-worktree-path", "label": "guard-worktree-path", "kind": "hook", "what": "Denies `git worktree add|move` whose target resolves outside `<repo>/.claude/worktrees/`.", "when": "PreToolUse, matcher Bash, on every shell command.", "how": "Parses the command, honouring `cd X &&` and `git -C X`, resolves the target path, and blocks when it escapes the worktrees folder.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/guard-worktree-path.py"]}, {"id": "guard-secrets", "label": "guard-secrets", "kind": "hook", "what": "Denies reading or piping dotenv files, SSH keys, .npmrc, credentials(.json), service-account JSON and .pem files; .env.example stays readable.", "when": "PreToolUse, matcher Bash|Read|Grep.", "how": "Matches file paths in Read/Grep input and in shell commands against secret-file patterns and blocks the call. One plain call to super-board-env-check.sh (no pipe, chain or redirect) is allowed, since it prints only present / empty / missing.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/guard-secrets.py"]}, {"id": "guard-key-literals", "label": "guard-key-literals", "kind": "hook", "what": "Stops a live-looking API key from being written into a file, and flags one already on disk.", "when": "PreToolUse on Edit|MultiEdit|Write|NotebookEdit|Bash, and PostToolUse on Edit|MultiEdit|Write|NotebookEdit.", "how": "Scans the content being written for key-shaped literals and reports line numbers only, never the value.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/guard-key-literals.py"]}, {"id": "guard-delete-outside", "label": "guard-delete-outside", "kind": "hook", "what": "Denies rm, rmdir, unlink, find -delete / -exec rm and git clean whose target resolves outside $CLAUDE_PROJECT_DIR, and always `/` or `~` itself.", "when": "PreToolUse, matcher Bash.", "how": "Resolves each target (honouring cd, git -C, ~ and $HOME); temp dirs stay allowed, and a path known only at run time is allowed.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/guard-delete-outside.py"]}, {"id": "guard-protected-push", "label": "guard-protected-push", "kind": "hook", "what": "Opt-in guard that denies a git push that would update or delete main, master, any configured base_branch, or a name in SB_PROTECTED_BRANCHES.", "when": "PreToolUse, matcher Bash, only after onboard's Policies yes (step 6) or `./install.sh --protect-main`.", "how": "Catches force pushes, explicit refspecs, --delete, --all/--mirror and a bare push while the base is checked out; feature-branch force pushes stay allowed. SB_ALLOW_PROTECTED_PUSH=1 turns it off for a session.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/guard-protected-push.py", "https://github.com/EricTechPro/super-board/blob/main/hooks/settings-protect-main.json"]}, {"id": "cleanup-wt", "label": "cleanup-wt", "kind": "hook", "what": "Removes worktrees and local branches already merged into a base branch; never deletes unmerged work.", "when": "SessionStart with `--auto --fetch` when a base tip moved since the last session, and after every merge when the merge gate calls it with `--post-merge`.", "how": "Wip-commits a dirty worktree on a merged branch and keeps its branch, never touches bases or its own worktree, and writes a recovery TSV under `<git-common-dir>/cleanup-wt/` before acting.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/cleanup-wt.py", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-gate.sh"]}, {"id": "gate-skill-evals", "label": "gate-skill-evals (dev)", "kind": "hook", "what": "Dev-only Stop hook that blocks ending a session when a skill changed and no `claude plugin eval` result is newer than the change.", "when": "Stop event in the pack's own `.claude/settings.json` (and EricOS if added by hand); never installed into target projects.", "how": "A changed SKILL.md always counts; a changed reference, script or workflow counts when the skill has an eval case. SKILL_EVAL_GATE=off, a running eval or `.claude/eval-gate-ignore` globs stand it down.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/dev/gate-skill-evals.py", "https://github.com/EricTechPro/super-board/blob/main/.claude/settings.json"]}, {"id": "readme-sync", "label": "readme-sync (dev)", "kind": "hook", "what": "Dev-only hooks that keep README.md's skill tables in step with skills/*/SKILL.md and families.json.", "when": "PostToolUse on Edit|Write|MultiEdit in the pack repo, and as a git pre-commit hook when it is symlinked in.", "how": "Runs super-board-readme-sync.py; the pre-commit version stops the commit when README.md had to change so it can be staged.", "source": ["https://github.com/EricTechPro/super-board/blob/main/.claude/settings.json", "https://github.com/EricTechPro/super-board/blob/main/hooks/pre-commit-readme.sh", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-readme-sync.py"]}, {"id": "wave-plan", "label": "super-board-wave-plan.sh", "kind": "script", "what": "Read-only planner that computes the next wave from board state: cards (each with its lane and labels) plus the sweep, flag, stranded and resume lists.", "when": "Run by the orchestrator at the start of every wave, after the rate and usage guards pass.", "how": "Reads the board and `## Blocked by` dependencies (via super-board-deps.sh); a Ready card labelled qa gets lane qa, every other Ready card lane build. `resume` lists 🙋 cards a human approved with `done`. A `variant: qa-only` config is refused with exit 65.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-wave-plan.sh", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-deps.sh"]}, {"id": "wave-js", "label": "super-board-wave.js", "kind": "script", "what": "Saved Workflow that drains one wave: a Pre-flight phase for cards about to be built, a haiku classify router, then Build, QA and Review lane agents per card.", "when": "Launched by /super-board run with {configPath, cards (with lane and labels), humanApprovesMerge, tier}; a stale `variant` other than full is refused.", "how": "Pre-flights Ready build cards in batches of 5 and never builds a card without a proceed verdict. The classifier keeps a card's qa/bug/feature label and adds feature or bug to unlabelled ones, never qa. A qa card goes Ready → QA. Model ladder by tier and complexity; Review always on the session model.", "source": ["https://github.com/EricTechPro/super-board/blob/main/workflows/super-board-wave.js"]}, {"id": "merge-gate", "label": "super-board-merge-gate.sh", "kind": "script", "what": "The only path to the base branch: takes an atomic mkdir lock, applies merge_policy, re-proves the branch against the current base inside the lock, runs allowed DB migrations, then squash-merges.", "when": "Called by the Reviewer once a review passes (and human_approves_merge is not set).", "how": "super-board-merge-policy.py decides who merges: money, auth, destructive schema or a diff over auto_max_lines (400 changed lines, lockfiles/generated/snapshots/migration SQL excluded) exits 7; a migration it may not run or a declared human step exits 8. Otherwise it merges with `--match-head-commit` (exit 6 when the head moved) and runs cleanup-wt --post-merge.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-policy.py"]}, {"id": "file-bug", "label": "super-qa-file-bug.sh", "kind": "script", "what": "Files one finding as a GitHub issue with a validated body onto the Super Ultimate QA board.", "when": "Called by standalone super-qa on a red spec, and by super-collect-file.sh for bug, feature and fix tickets.", "how": "Rejects bodies missing the ticket-format sections (Problem · Context · Fix · Acceptance Criteria · Risk, bugs with the folded Evidence table) or holding placeholders; adds type, source, priority and area labels and sets the project Status, falling back through Bug, Ready, Todo, Backlog, Triage.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-qa-file-bug.sh"]}, {"id": "file-refactor", "label": "review-file-refactor.sh", "kind": "script", "what": "Files a deepening opportunity as a `refactor` card, deduped by fingerprint.", "when": "Called by super-review for shape findings that must not block a merge, and by super-collect-file.sh for architecture tickets.", "how": "A body with an `## Acceptance criteria` section goes straight to Ready; otherwise it lands in the holding column for lint. It appends `## Blocked by` when missing.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-review-file-refactor.sh"]}, {"id": "collect-file", "label": "super-collect-file.sh", "kind": "script", "what": "Single filing entry point for /super-collect that routes each verified ticket to the pack's filers.", "when": "Called once per candidate the verifier marked file or needs-triage (dry-run without --yes, real filing with it), or with --adopt <n>.", "how": "bug/feature/fix go to super-qa-file-bug.sh, refactor to super-review-file-refactor.sh, every body in the writing-standard ticket format. It enforces per-source fingerprints (custom `custom|<name>|<key>`), exact-fingerprint dedupe and the board's holding column.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/super-collect-file.sh"]}, {"id": "collect-sentry", "label": "sentry fetcher", "kind": "script", "what": "The sentry source: lists unresolved Sentry issues in the window and pulls event and tag evidence.", "when": "Run when /super-collect includes sentry and the config has a sentry block.", "how": "`collect_sentry.py list --since <w>` calls the Sentry REST API with SENTRY_AUTH_TOKEN from .env; `check <id>` answers still-happening for the verifier. One issue becomes one bug, fp `err|sentry|<id>`.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/collect_sentry.py"]}, {"id": "collect-posthog", "label": "posthog fetcher", "kind": "script", "what": "The posthog source: exceptions, configured failure events, rage and dead clicks, web vitals, surveys, plus tracking gaps.", "when": "Run when /super-collect includes posthog.", "how": "`collect_posthog.py list|events|funnel|check` runs HogQL queries with POSTHOG_PERSONAL_API_KEY; signal groups over the thresholds become bugs, and missing workflow events become `analytics` feature tickets.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/collect_posthog.py"]}, {"id": "collect-prs", "label": "prs fetcher", "kind": "script", "what": "The prs source: merged PRs in the window with their comments, reviews, review threads and flagged super-review reports.", "when": "Run when /super-collect includes prs.", "how": "`collect_prs.py list` runs one paginated GraphQL search; Claude then clusters recurring root causes at a shared boundary into fix, refactor or feature tickets (fp `prs|<boundary>|<cause>`).", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/collect_prs.py"]}, {"id": "shoot", "label": "shoot.mjs", "kind": "script", "what": "Playwright screenshot script for the refine loop: light and dark at 1440 and 390, section crops, and before | after sheets.", "when": "Run for round-0 shots at setup and for AFTER shots at the end of every fix round.", "how": "Writes `<label>-<state>-<desktop|mobile>-<light|dark>.png` grown to the scroll height; `--compare round-0` adds cmp sheets the next checker judges.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/scripts/shoot.mjs"]}, {"id": "imp-detect", "label": "impeccable detect", "kind": "script", "what": "Impeccable's mechanical anti-pattern detector, run over every scope path holding markup or styles.", "when": "Run by the isolated detector sub-agent in every check, alongside the audit.", "how": "Invoked as `scripts/impeccable detect --json` (v4.4+) or `node scripts/detect.mjs --json` (v4.0.x), as found by refine-setup.sh detect; exit 2 means findings, which are checked in source for false positives.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/checker-brief.md", "https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/scripts/refine-setup.sh"]}, {"id": "install-sh", "label": "install.sh", "kind": "script", "what": "Installs the pack into a target project: skills, .claude/bin scripts, workflows and the guard hooks, with grouped emoji output.", "when": "Run by get.sh, by super-board-setup.py fix during onboard, or by hand: `./install.sh [--no-hooks] [--protect-main] [target]`.", "how": "Copies hooks/*.py to `.claude/hooks/` (never hooks/dev/) and merges the hook block through super-board-settings.py; `--no-hooks --protect-main` installs only the push guard. It records an older install in `.claude/super-board/upgrade.json` and ends with one next step: /super-board onboard.", "source": ["https://github.com/EricTechPro/super-board/blob/main/install.sh"], "opensView": "install"}, {"id": "visual-py", "label": "visual.py", "kind": "script", "what": "The /visual helper: detect picks the mode, facts collects git data, render injects data.json into the inline template.", "when": "Run by /visual at every step: detect with no argument, facts in recap mode, render after data.json is written.", "how": "render prints `{out, missingHunks}`; grounded hunks come from git via `hunks[].file + contains`, and output lands in a gitignored `_tmp/<date>-visual/` or `.visual/`.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/visual/scripts/visual.py"]}, {"id": "grilling", "label": "grilling", "kind": "external", "what": "Interview pattern that walks a design tree in rounds: numbered questions, each with a recommended answer, until the frontier is empty.", "when": "Reached by /ui-refine-loop's grill step and by /super-board lint for vague or multi-reading tickets; forbidden inside unattended workers.", "how": "Asks the whole frontier per round and waits; facts come from sub-agents, decisions from the user. ui-refine-loop caps it at 10 questions in waves of 3, then 4.", "source": [".agents/skills/grilling/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "tdd", "label": "tdd", "kind": "external", "what": "Test-driven development discipline: tests at agreed seams through public interfaces, red before green, one vertical slice at a time.", "when": "Reached by super-build for every non-docs ticket, by super-qa when writing High test gaps, and by implement.", "how": "Defines good tests, the anti-patterns (implementation-coupled, tautological, horizontal slicing) and the loop rules; refactoring belongs to the code-review stage.", "source": [".agents/skills/tdd/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "tdd", "author": "mattpocock"}, {"id": "tdd-v2", "label": "tdd-v2", "kind": "external", "what": "The EricOS testing ladder: which rung a test belongs at (unit, isolated render, e2e) and the gate for climbing to the next.", "when": "Reached by super-qa's test-gap check \"where the repo has it\", and by implement as its preferred test skill.", "how": "Building climbs bottom-up; chasing a defect walks down to the first rung that still reproduces. It owns the layer and defers red-green discipline to tdd.", "source": [".agents/skills/tdd-v2/SKILL.md"], "external": true, "origin": "EricOS local skill", "opensView": "tdd-v2", "author": "EricTechPro"}, {"id": "implement", "label": "implement", "kind": "external", "what": "Implements a piece of work from a spec or tickets, test-first, then reviews and commits it.", "when": "Reached by super-build when the issue's type label is feature or ux (implement → tdd → codebase-design).", "how": "Uses tdd-v2 at pre-agreed seams with tdd underneath, runs typecheck and single tests often and the full suite once, then runs code-review before committing.", "source": [".agents/skills/implement/SKILL.md"], "external": true, "origin": "mattpocock-skills (EricOS local override)", "opensView": "implement", "author": "mattpocock"}, {"id": "code-review", "label": "code-review", "kind": "external", "what": "Two-axis review of the diff since a fixed point: Standards (repo rules plus a Fowler smell baseline) and Spec (does it match the issue).", "when": "Reached by super-build once against its own diff before the final commit, by super-review on every card, and by implement and tdd.", "how": "Pins the fixed point (the lanes pass the merge-base so it never asks), runs a Standards and a Spec sub-agent in parallel, and reports them side by side without reranking.", "source": [".agents/skills/code-review/SKILL.md"], "external": true, "origin": "mattpocock-skills (EricOS local override)", "opensView": "code-review", "author": "mattpocock"}, {"id": "diagnosing-bugs", "label": "diagnosing-bugs", "kind": "external", "what": "Diagnosis loop for hard bugs and perf regressions: build a tight red feedback loop, reproduce, hypothesise, instrument, fix with a regression test.", "when": "Reached by super-build for `bug`-labelled tickets, by super-qa as a required dependency, and by lint for bug tickets with no repro.", "how": "Six phases; refuses to theorise before one command goes red on this bug. Its post-mortem hands off to improve-codebase-architecture when no good seam exists.", "source": [".agents/skills/diagnosing-bugs/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "diagnosing-bugs", "author": "mattpocock"}, {"id": "codebase-design", "label": "codebase-design", "kind": "external", "what": "Shared deep-module vocabulary: module, interface, depth, seam, adapter, leverage, locality, and the deletion test.", "when": "Reached by super-build for feature and refactor tickets, by super-review in step 2 and for every deepening opportunity, and by super-collect's architecture finder as a fallback.", "how": "A reference to consult, not a session: no report, no prompts. Its design-it-twice pattern runs parallel sub-agents when an interface needs alternatives.", "source": [".agents/skills/codebase-design/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "ask-matt", "label": "ask-matt", "kind": "external", "what": "Router over the Matt Pocock skills: which flow fits the situation, from idea to ship.", "when": "Reached by super-build and super-qa workers when the right flow is unclear.", "how": "Main flow: grill-with-docs, optional prototype via handoff, to-spec and to-tickets for multi-session work, then implement (driving tdd) and code-review. On-ramps: triage, diagnosing-bugs, wayfinder.", "source": [".agents/skills/ask-matt/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "ask-matt", "author": "mattpocock"}, {"id": "humanizer", "label": "humanizer", "kind": "external", "what": "Strips AI writing tells from a finished draft so it reads like a person wrote it, with Eric Tech plain-words overrides.", "when": "Reached whenever a lane or ui-refine-loop writes prose: the writing standard says ALWAYS run commits, tickets, PR bodies and comments through it when installed.", "how": "Applies the vendored blader/humanizer rule set (32 patterns) as a silent pass; without it the writing standard's plain-words rules apply (short sentences, plain words, no hype).", "source": [".agents/skills/humanizer/SKILL.md", "erictech-skills/skills/humanizer/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/writing-standard.md"], "external": true, "origin": "erictech-skills (vendored blader/humanizer)", "author": "blader"}, {"id": "verification", "label": "verification-before-compl.", "kind": "external", "what": "Evidence before assertions: run the verification command and read its output before claiming work is done, fixed or passing.", "when": "Reached by super-build before its final commit and by super-qa as a required dependency.", "how": "A gate function: identify the proving command, run it fresh, read the full output, and only then state the result.", "source": [".agents/skills/verification-before-completion/SKILL.md"], "external": true, "origin": "EricOS .agents/skills (origin not recorded)", "author": "obra"}, {"id": "context7", "label": "context7 (docs)", "kind": "external", "what": "MCP docs lookup used to read current official documentation for a library or API version.", "when": "Reached by super-build when a ticket touches a third-party API, an upgrade, or auth/billing.", "how": "Builder reads the exact surface and installed major's docs (context7 when available, else vendor docs by web search) and cites them as `Docs:` bullets in the PR's Solution block.", "source": ["~/.claude/plugins/marketplaces/claude-plugins-official/external_plugins/context7/README.md"], "external": true, "origin": "claude-plugins-official (MCP plugin)", "author": "upstash"}, {"id": "resolving-merge-conflicts", "label": "resolving-merge-conflicts", "kind": "external", "what": "Resolves an in-progress merge or rebase conflict by reading each side's intent, then runs the project's checks.", "when": "Reached by super-build on a live conflict, e.g. when the merge gate exits 2 or 5 and the card returns to the Builder, and by /git-sync when its pull conflicts.", "how": "Finds primary sources per hunk, preserves both intents where possible, never aborts; the Builder's finish line is green verification, not an empty conflict list.", "source": [".agents/skills/resolving-merge-conflicts/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "improve-codebase-architecture", "label": "improve-codebase-arch.", "kind": "external", "what": "Scans a codebase for deepening opportunities, presents them as an HTML report, then grills through the one picked.", "when": "Reached by /super-collect's architecture finder (findings only, no report or grilling) and by diagnosing-bugs' post-mortem; never loaded inside the Review lane.", "how": "Explores hot spots from git history with codebase-design vocabulary and CONTEXT.md/ADRs, writes the report, then runs grilling and domain-modeling on the chosen candidate.", "source": [".agents/skills/improve-codebase-architecture/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "improve-codebase-architecture", "author": "mattpocock"}, {"id": "domain-modeling", "label": "domain-modeling", "kind": "external", "what": "Sharpens a project's domain language in CONTEXT.md and records hard-to-reverse decisions as ADRs.", "when": "Reached from improve-codebase-architecture, grill-with-docs, triage and wayfinder sessions, and listed in super-build's skill map for terminology and ADRs.", "how": "Challenges fuzzy or overloaded terms and updates CONTEXT.md inline; offers an ADR only when a future reader would need the reason.", "source": [".agents/skills/domain-modeling/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "ponytail", "label": "ponytail", "kind": "external", "what": "Forces the simplest solution that works via a ladder: needed at all, already in the codebase, stdlib, native, installed dep, one line, then minimal code.", "when": "Reached by super-build on every ticket, before the first line of code (full intensity).", "how": "Runs after understanding the problem; bug fixes go to the root cause in the shared function. Inline ladder fallback when the plugin is absent.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "ponytail-review", "label": "ponytail-review", "kind": "external", "what": "Diff review that hunts only over-engineering, one line per finding tagged delete, stdlib, native, yagni or shrink.", "when": "Reached by super-review on the merge-base diff in step 3.", "how": "Ends with `net: -N lines possible`; findings are Over-engineering, always Should fix and never a merge blocker alone. It applies nothing.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail-review/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "ponytail-audit", "label": "ponytail-audit", "kind": "external", "what": "Whole-repo version of ponytail-review: a ranked list of what to delete, simplify or replace with stdlib or native features.", "when": "Reached by /super-collect's architecture finder for over-engineering findings.", "how": "Same tags as ponytail-review, biggest cut first, ending `net: -N lines, -M deps possible`; one-shot and read-only.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail-audit/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "impeccable", "label": "impeccable", "kind": "external", "what": "Frontend design skill whose commands critique, audit and refine UI: build, evaluate, refine, enhance, fix and iterate categories.", "when": "Reached by /ui-refine-loop at setup (detect and context), by every checker and fixer, and by lint for shape and clarify.", "how": "Each command has a playbook under reference/<command>.md plus craft-floor.md; refine-setup.sh finds v4.0.x node scripts or the v4.4+ launcher in this or any parent dir, warning loudly when missing.", "source": [".agents/skills/impeccable/SKILL.md"], "external": true, "origin": "pbakaus/impeccable", "opensView": "impeccable", "author": "pbakaus"}, {"id": "testing-strategy", "label": "testing-strategy", "kind": "external", "what": "Coverage judgment per component type: what is worth testing and what to skip.", "when": "Listed by super-build's skill map and super-qa's dependencies for deciding which kind of test a change needs.", "how": "Informs coverage only; the localisation ladder, not this skill, picks the test layer. Not installed in EricOS.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-build/references/decision-policy.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "vitest", "label": "vitest", "kind": "external", "what": "Mechanics for unit and integration tests in a TS/JS repo.", "when": "Listed by super-qa and super-build when the localisation ladder stops at unit or integration in a TS/JS repo.", "how": "Its references (core-expect, features-mocking, features-coverage, core-hooks, advanced-vi) guide test code. Not installed in EricOS.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/SKILL.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "playwright-bp", "label": "playwright-best-practices", "kind": "external", "what": "Mechanics for browser e2e specs: locators, fixtures, test data factories, page objects.", "when": "Listed by super-qa when writing or refactoring a Playwright spec.", "how": "data-testid first with getByRole fallback, custom fixtures for auth and seeding, POM for reusable interactions. Not installed in EricOS.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-qa/SKILL.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "qa-test-planner", "label": "qa-test-planner", "kind": "external", "what": "Test-plan helper lint dispatches for QA tickets with a vague test surface.", "when": "Reached by /super-board lint Phase 4 for QA tickets whose test surface is vague.", "how": "One sub-agent per flagged issue drafts a concrete test plan. Not installed in EricOS.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/lint.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "setup-matt-pocock-skills", "label": "setup-matt-pocock-skills", "kind": "external", "what": "One-time repo setup for the engineering skills: issue tracker, triage label vocabulary, domain doc layout.", "when": "Reached when code-review, to-spec, to-tickets, triage or wayfinder find `docs/agents/issue-tracker.md` missing.", "how": "Asks a few sections with recommended answers and records them under docs/agents/ so the other skills know whether to call gh or write markdown files.", "source": [".agents/skills/setup-matt-pocock-skills/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "grill-with-docs", "label": "grill-with-docs", "kind": "external", "what": "Stateful grilling that builds CONTEXT.md and ADRs and checkpoints every answer to a capture file.", "when": "Reached from ask-matt as step 1 of the main flow whenever there is a working directory.", "how": "Runs the grilling primitive and drives domain-modeling to keep the glossary clean; user-invoked only.", "source": [".agents/skills/grill-with-docs/SKILL.md", "erictech-skills/skills/grill-with-docs/SKILL.md"], "external": true, "origin": "erictech-skills (override of mattpocock grill-with-docs)", "opensView": "grill-with-docs", "author": "EricTechPro"}, {"id": "prototype", "label": "prototype", "kind": "external", "what": "Throwaway prototype that answers one design question: a logic demo or a UI to look at.", "when": "Reached from ask-matt when a question needs a runnable answer, and from wayfinder prototype tickets.", "how": "Throwaway from day one, trivial to run, no persistence, no polish; the learning is handed back via handoff.", "source": [".agents/skills/prototype/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "handoff", "label": "handoff", "kind": "external", "what": "Compacts the conversation into a handoff document for a fresh agent.", "when": "Reached from ask-matt to bridge a prototype detour or a phase boundary.", "how": "Writes the summary to the OS temp directory, not the workspace, so another session can pick it up.", "source": [".agents/skills/handoff/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "to-spec", "label": "to-spec", "kind": "external", "what": "Turns the current conversation into a spec and publishes it to the issue tracker, no interview.", "when": "Reached from ask-matt for multi-session builds; listed in super-build's skill map.", "how": "Writes the spec from a template and applies the `ready-for-agent` label; needs the tracker config from setup-matt-pocock-skills.", "source": [".agents/skills/to-spec/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "to-spec", "author": "mattpocock"}, {"id": "to-tickets", "label": "to-tickets", "kind": "external", "what": "Breaks a plan or spec into tracer-bullet tickets, each declaring its blocking edges.", "when": "Reached from ask-matt after to-spec, and from /super-board lint to split a too-big ticket (criterion 15) into vertical slices; its `## Blocked by` template is why lint criterion 13 exists.", "how": "Publishes blockers first so edges reference real ids, as files locally or native blocking links on a real tracker.", "source": [".agents/skills/to-tickets/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "to-tickets", "author": "mattpocock"}, {"id": "triage", "label": "triage", "kind": "external", "what": "Moves raw issues and external PRs through a state machine of triage roles into agent-ready briefs.", "when": "Reached from ask-matt when bugs and requests pile up that you did not create.", "how": "Categorise, verify, grill if needed, write the brief; every comment carries an AI disclaimer and labels come from setup-matt-pocock-skills.", "source": [".agents/skills/triage/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "triage", "author": "mattpocock"}, {"id": "wayfinder", "label": "wayfinder", "kind": "external", "what": "Charts a shared map of decision tickets for a huge, foggy effort and resolves them one at a time.", "when": "Reached from ask-matt for greenfield projects or builds too big for one session.", "how": "Tickets are research, prototype, grilling or task, HITL or AFK; it hands off to to-spec when the map clears instead of building.", "source": [".agents/skills/wayfinder/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "wayfinder", "author": "mattpocock"}, {"id": "verbs-group", "label": "impeccable fix verbs", "kind": "verb", "what": "The 15 Impeccable commands the ui-refine-loop fixer may chain, one per problem type, with polish always last.", "when": "Each fix round, after the checker returns ranked, typed P0–P3 problems.", "how": "The workflow attaches routing.md's default command per type and suggests a chain (severity order, structural before surface, additive verbs only when the direction asks); the fixer reads each playbook and craft-floor, then makes the final call.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/routing.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js", "https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/fixer-brief.md"], "opensView": "impeccable-verbs", "author": "pbakaus"}, {"id": "late-verbs", "label": "motion + perf verbs", "kind": "verb", "what": "The last tier of the chain before polish: animate, delight and optimize.", "when": "When a problem is typed needs-motion, personality or performance.", "how": "routing.md runs these after the structural, surface and fix tiers; animate and delight are additive, so they run only when the brief or taste direction asks for more.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/references/routing.md"], "opensView": "late-verbs", "author": "pbakaus"}, {"id": "v-critique", "label": "critique", "kind": "verb", "what": "UX design review with scoring; the loop uses Assessment A only, scored /20 across specificity, hierarchy, typography, color and composition.", "when": "Every check, run by the isolated design reviewer sub-agent in parallel with the detector.", "how": "Reads critique.md (Assessment A) and craft-floor.md, every shot and crop in both themes and widths, then the scope files; returns up to 8 typed problems. No Nielsen heuristics.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/critique.md"], "author": "pbakaus"}, {"id": "v-audit", "label": "audit", "kind": "verb", "what": "Technical quality check scored /20 across accessibility, performance, responsive, theming and implementation integrity.", "when": "Every check, run by the isolated detector sub-agent after impeccable detect.", "how": "Reads audit.md, scores five dimensions 0–4, and turns each verified detector cluster or audit gap into a typed problem; it never sees the screenshots or the design review.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/audit.md"], "author": "pbakaus"}, {"id": "v-polish", "label": "polish", "kind": "verb", "what": "Final quality pass over everything the round touched: small misalignments and inconsistencies, no structural change.", "when": "Always the last command of every fix round, even when no problem was typed polish.", "how": "Runs once over all touched files after the routed chain; then checks must be green before the round's single commit.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/polish.md"], "author": "pbakaus"}, {"id": "v-distill", "label": "distill", "kind": "verb", "what": "Strips a surface to its essence, removing duplicate actions and competing chrome.", "when": "Routed for problems typed `cluttered`.", "how": "Structural tier, so it runs first in the chain alongside extract; follows reference/distill.md as a refinement of the existing design.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/distill.md"], "author": "pbakaus"}, {"id": "v-bolder", "label": "bolder", "kind": "verb", "what": "Amplifies a safe, bland design so it has more presence.", "when": "Routed for `bland`, only when the brief or taste direction asks for more.", "how": "Additive surface-tier verb; skipped with a reason like \"direction says calmer\", and dropped when it pulls against quieter on the same element.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/bolder.md"], "author": "pbakaus"}, {"id": "v-quieter", "label": "quieter", "kind": "verb", "what": "Tones down an aggressive design: fewer colors, weights, borders, shadows or badges.", "when": "Routed for problems typed `too-loud`.", "how": "Surface tier after layout/adapt; when it conflicts with bolder on one element the higher-severity problem wins.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/quieter.md"], "author": "pbakaus"}, {"id": "v-colorize", "label": "colorize", "kind": "verb", "what": "Adds strategic color where gray or flat UI should carry meaning.", "when": "Routed for `dull-color`, only when the direction asks for more.", "how": "Additive surface-tier verb; changes must hold in light and dark and use tokens, not raw values.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/colorize.md"], "author": "pbakaus"}, {"id": "v-layout", "label": "layout", "kind": "verb", "what": "Fixes spacing, rhythm, grouping, alignment and visual hierarchy.", "when": "Routed for problems typed `spacing-hierarchy`.", "how": "Second tier, after distill/extract; a cramped look caused by a copied card is rerouted to extract by the fixer.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/layout.md"], "author": "pbakaus"}, {"id": "v-typeset", "label": "typeset", "kind": "verb", "what": "Improves typography: fonts, type scale, weights, line length and figures.", "when": "Routed for problems typed `typography`.", "how": "Surface tier with colorize, quieter and bolder; follows reference/typeset.md within the taste file's type rules.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/typeset.md"], "author": "pbakaus"}, {"id": "v-adapt", "label": "adapt", "kind": "verb", "what": "Adapts the surface to other screen sizes: breakpoints, touch targets, no sideways scroll at 390.", "when": "Routed for problems typed `responsive`.", "how": "Second tier with layout; the after shots at 390 in both themes prove it.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/adapt.md"], "author": "pbakaus"}, {"id": "v-optimize", "label": "optimize", "kind": "verb", "what": "Diagnoses and fixes UI performance: jank, layout shift, heavy images or bundles.", "when": "Routed for problems typed `performance`.", "how": "Last tier with animate and delight, before polish; follows reference/optimize.md.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/optimize.md"], "author": "pbakaus"}, {"id": "v-onboard", "label": "onboard", "kind": "verb", "what": "Designs first-run flows and empty states that point to the next action.", "when": "Routed for problems typed `first-run-empty`.", "how": "Fix tier with clarify and harden; no dense fixture means no dense shots, never fabricated data.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/onboard.md"], "author": "pbakaus"}, {"id": "v-clarify", "label": "clarify", "kind": "verb", "what": "Improves UX copy: labels, errors, status words and instructions.", "when": "Routed for `confusing-copy` in the refine loop; also dispatched by /super-board lint for copy or error-message ACs.", "how": "Fix tier; refinement keeps the meaning of factual copy and never adds claims.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/clarify.md"], "author": "pbakaus"}, {"id": "v-harden", "label": "harden", "kind": "verb", "what": "Production-readiness: long content, errors, loading, i18n, overflow, and accessibility (contrast, focus, names, keyboard).", "when": "Routed for problems typed `edge-cases` or `accessibility`.", "how": "Fix tier; the only verb two problem types share in routing.md.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/harden.md"], "author": "pbakaus"}, {"id": "v-animate", "label": "animate", "kind": "verb", "what": "Adds purposeful motion and state-change feedback.", "when": "Routed for `needs-motion`, only when the brief or direction asks for motion.", "how": "Additive last-tier verb; delight may call it.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/animate.md"], "author": "pbakaus"}, {"id": "v-delight", "label": "delight", "kind": "verb", "what": "Adds personality and memorable touches to a correct but lifeless surface.", "when": "Routed for `personality`, only when the brief asks for character.", "how": "Additive last-tier verb that calls animate for motion; followed by polish.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/delight.md"], "author": "pbakaus"}, {"id": "v-extract", "label": "extract", "kind": "verb", "what": "Pulls repeated UI into shared tokens and components.", "when": "Routed for `drift`: the same pattern copied 3+ times, raw values next to tokens, one-off components.", "how": "Structural tier, first in the chain; shared components change only behind a new prop that defaults to today's behaviour.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/extract.md"], "author": "pbakaus"}, {"id": "v-shape", "label": "shape", "kind": "verb", "what": "Plans UX/UI for a feature before code is written.", "when": "Dispatched by /super-board lint for feature tickets with undefined UX; never typed as a refine-loop problem.", "how": "Requires init's PRODUCT.md; a redesign need found in the loop goes to openQuestions instead.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/shape.md"], "author": "pbakaus"}, {"id": "v-init", "label": "init", "kind": "verb", "what": "Captures durable product context in PRODUCT.md.", "when": "Suggested by /impeccable when PRODUCT.md is missing; not run by the refine loop.", "how": "Shape and document require it; its context feeds live mode.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/init.md"], "author": "pbakaus"}, {"id": "v-document", "label": "document", "kind": "verb", "what": "Generates DESIGN.md from existing project code.", "when": "When DESIGN.md is missing; the refine loop reads DESIGN.md if present but never runs this.", "how": "Requires init; doctor feeds it when files go stale.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/document.md"], "author": "pbakaus"}, {"id": "v-live", "label": "live", "kind": "verb", "what": "Visual variant mode: pick elements in the browser and generate alternatives.", "when": "Interactive iteration only; the refine loop forbids it as a problem type.", "how": "Fed by init's context and calls polish on the chosen variant.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/live.md"], "author": "pbakaus"}, {"id": "v-overdrive", "label": "overdrive", "kind": "verb", "what": "Pushes a design past conventional limits for a wow factor.", "when": "Interactive only; the refine loop never types a problem as overdrive.", "how": "A redesign-scale command, so the checker sends such needs to openQuestions.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/overdrive.md"], "author": "pbakaus"}, {"id": "preflight", "label": "super-board-preflight.sh", "kind": "script", "what": "Builder pre-flight check: is a Ready card already done, already in progress, overlapping an open PR's files, or unclear?", "when": "Run once per batch of up to 5 Ready build cards by the wave's Pre-flight agent (or by the Builder as step 0 on the legacy backend), before any worktree.", "how": "Prints mechanical verdicts and near-miss candidates; the agent adds 'too big' and semantic matches, then returns proceed, hold, sequence or skipped. Hold and sequence move the card to Blocked with the block template; skipped leaves it in Ready.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-preflight.sh", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"]}, {"id": "pr-body", "label": "super-board-pr-body.sh", "kind": "script", "what": "Rewrites one marker block of a PR body (redcheck, status, problem, solution, ac, history, visual, risk) without clobbering other lanes' blocks.", "when": "Called by every lane when it updates its part of the PR, and with --skeleton by ui-refine-loop for a fresh body.", "how": "`--pr N --block <name> --expect-head <sha>` with --body-file or --append-file (history rows); `--time` prints local time in the config's timezone.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-pr-body.sh", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/writing-standard.md"]}, {"id": "needs-you", "label": "Blocked · 🙋 needs you", "kind": "board", "what": "A card parked in Blocked with the 🙋 template and the `needs-you` label: a step only a human may take. There is no separate column.", "when": "The merge gate exits 7 (merge_policy: money, auth, destructive schema, over 400 lines) or 8 (a migration the robot may not run, or a declared human step).", "how": "The comment opens \"🙋 Your turn on #N\" with the exact commands as checkboxes; a human merges it, or comments `done` / labels `needs-you:done` so the planner's resume list sends it back to Review.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/block-template.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"]}, {"id": "setup-py", "label": "super-board-setup.py", "kind": "script", "what": "The deterministic half of onboard: finds what is missing or old and fixes the must-haves, and handles boards and branches.", "when": "Run by onboard step 1 (check / fix), step 3 (board-rank, board-migrate, names) and step 4 (branch).", "how": "`fix` installs or refreshes skills, scripts, workflows, guard hooks and settings (via install.sh), removes super-refine / cleanup-wt / arch-loop folders, migrates config keys to v3, runs git init and adds Matt Pocock's skills, all backed up first. `board-migrate` adds missing columns and the three labels and moves Skipped cards to Done.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"]}, {"id": "agents-md-py", "label": "super-board-agents-md.py", "kind": "script", "what": "The deterministic half of the AGENTS.md step: detect, backup, the managed super-board block, the CLAUDE.md pointer, coverage and size checks.", "when": "Run by onboard step 5 to stage the merge and at step 8 to write it; install.sh refreshes the managed block on re-install.", "how": "The agent merges rules semantically (duplicates once, conflicts asked one by one); the script proves every rule unit maps to a line (`coverage`), keeps AGENTS.md ≤ 200 lines with one marker pair, and writes atomically.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-agents-md.py", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/agents-md-block.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md"]}, {"id": "agents-file", "label": "AGENTS.md + CLAUDE.md", "kind": "board", "what": "The project's instruction files: AGENTS.md as the single source of truth with a managed super-board block, and CLAUDE.md as `@AGENTS.md` plus Claude-only rules.", "when": "Written at onboard step 8 when Eric chose to move his rules (or only add the section); the block is rewritten on re-install.", "how": "The block sits between `<!-- super-board:begin -->` and `<!-- super-board:end -->`, rendered from agents-md-block.md with a Writing table that links the writing standard; nothing outside the markers is touched.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/agents-md-block.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md"]}, {"id": "settings-py", "label": "super-board-settings.py", "kind": "script", "what": "Merges hook blocks and permission allow rules into .claude/settings.json without losing anything.", "when": "Run by install.sh for the guard hooks, and by onboard step 6/8 for the permission lines and the protect-main hook.", "how": "`hooks <settings> <snippet>` and `allow <settings> <rules…>` keep every existing key, back the file up, write atomically, and leave an invalid settings.json untouched; `--dry-run` prints the diff onboard shows as \"N lines\".", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-settings.py"]}, {"id": "env-check", "label": "super-board-env-check.sh", "kind": "script", "what": "Says which env keys exist (present, empty or missing) without ever printing a value.", "when": "Run by onboard to detect SENTRY_AUTH_TOKEN, POSTHOG_PERSONAL_API_KEY or migration DB URLs, and allowed in permissions for runs.", "how": "Reads .env.local or .env itself and prints one word per key; guard-secrets lets a plain call through while still blocking cat, grep or source on dotenv files.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-env-check.sh", "https://github.com/EricTechPro/super-board/blob/main/hooks/guard-secrets.py"]}, {"id": "collect-custom", "label": "custom source fetcher", "kind": "script", "what": "The custom source: extra sources a project added in onboard (an http API, a CLI command, or an MCP server), stored in collect.custom[].", "when": "Run by onboard step 7 (classify, ping, add) and by /super-collect for every custom source (list, normalize).", "how": "`collect_custom.py` classifies the typed text, pings read-only before saving, refuses commands that look like they change something, and turns output into candidates with fp `custom|<name>|<key>`. MCP reads go through the agent and `normalize`.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/collect_custom.py"]}, {"id": "get-sh", "label": "get.sh", "kind": "script", "what": "One-line installer: `curl -fsSL …/get.sh | bash` fetches the latest super-board release and runs install.sh.", "when": "Eric (or a user) runs it in a project folder to install or upgrade; options --target, --ref, --no-helper-skills, and --no-hooks / --protect-main passed through.", "how": "Downloads the release tarball, runs install.sh, adds Matt Pocock's skills via `npx skills@latest add mattpocock/skills` unless told not to, and prints the next step once.", "source": ["https://github.com/EricTechPro/super-board/blob/main/get.sh"]}, {"id": "plugin-mkt", "label": "plugin marketplace install", "kind": "board", "what": "The Claude Code plugin form of the pack (marketplace.json + plugin.json): ships the seven skills only.", "when": "A user adds the marketplace and installs the plugin instead of running get.sh.", "how": "Skills carry the plugin prefix (/super-board:super-board onboard); onboard step 1 then installs the guard hooks, .claude/bin scripts and workflows a plugin cannot ship from the plugin's own copy.", "source": ["https://github.com/EricTechPro/super-board/blob/main/.claude-plugin/marketplace.json", "https://github.com/EricTechPro/super-board/blob/main/.claude-plugin/plugin.json"]}, {"id": "onboard-answers", "label": "onboard answers file", "kind": "board", "what": "`.claude/super-board/onboard-answers.json`: every onboard answer, saved the moment it is given (gitignored).", "when": "Written after each answer; read when onboard re-runs or resumes after a halt.", "how": "Atomic writes; `last_step` drives the \"Continue where you left off?\" screen, and a finished setup's values fill the step-8 table on re-run.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md"]}, {"id": "upgrade-json", "label": "upgrade record", "kind": "board", "what": "`.claude/super-board/upgrade.json`: the version an install replaced, so onboard knows to upgrade a 2.x setup.", "when": "Written by install.sh (or get.sh) when it finds an older install.", "how": "super-board-setup.py fix reads it and reports \"Upgraded for you\": old folders removed, config keys migrated, labels mapped, Skipped cards moved to Done.", "source": ["https://github.com/EricTechPro/super-board/blob/main/install.sh", "https://github.com/EricTechPro/super-board/blob/main/RELEASE-NOTES.md"]}, {"id": "git-sync", "label": "/git-sync", "kind": "public", "what": "Commits the working tree as one commit per logical change, merge-pulls, pushes the current branch without force, and reports what it did.", "when": "Eric runs /git-sync or says \"sync\", \"commit and push\" or \"pull and push\", usually at the end of a piece of work.", "how": "Stages each group by path (never `git add -A`), refuses secrets, writes the host's commit format or the writing standard, gates `supabase/` changes on a migration file and advisors, then `git pull --no-rebase` and `git push`. The default or a protected branch needs a yes.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/git-sync/SKILL.md"], "sublabel": "commit · pull · push", "opensView": "git-sync", "author": "EricTechPro"}], "edges": [{"id": "r-board-build", "from": "super-board", "to": "super-build", "label": "starts Build lane", "when": "a planned Ready card labelled feature or bug (or unlabelled) passes pre-flight"}, {"id": "r-board-qa", "from": "super-board", "to": "super-qa", "label": "starts QA lane", "when": "a card is in QA, or in Ready with the qa label (skips Building)"}, {"id": "r-board-review", "from": "super-board", "to": "super-review", "label": "starts Review lane", "when": "a card is in Review"}, {"id": "r-board-gh", "from": "super-board", "to": "gh-board", "label": "drains", "when": "every wave until drained or halted"}, {"id": "r-board-config", "from": "super-board", "to": "sb-config", "label": "reads config", "when": "onboard writes it; every run reads it"}, {"id": "r-collect-gh", "from": "super-collect", "to": "gh-board", "label": "files to Backlog", "when": "the verifier says file or needs-triage and the run is confirmed"}, {"id": "r-collect-config", "from": "super-collect", "to": "sb-config", "label": "reads collect block", "when": "every run, to resolve sources, window and board"}, {"id": "r-build-qa", "from": "super-build", "to": "super-qa", "label": "hands off", "when": "the draft PR is open and the card moved to QA"}, {"id": "r-qa-review", "from": "super-qa", "to": "super-review", "label": "hands off", "when": "every AC passes and evidence is committed; a fail sends the card back to Ready"}, {"id": "r-review-build", "from": "super-review", "to": "super-build", "label": "bounces [builder]", "when": "a code-side finding or an unfixed prior finding"}, {"id": "r-review-base", "from": "super-review", "to": "base-branch", "label": "merges via gate", "when": "review is clean, tests rerun green, and merge_policy lets the robot merge"}, {"id": "r-review-hooks", "from": "super-review", "to": "hooks", "label": "triggers cleanup-wt", "when": "the merge gate merged a PR and cleanup-wt is installed"}, {"id": "r-refine-base", "from": "ui-refine-loop", "to": "base-branch", "label": "opens draft PR", "when": "the loop stops; it pushes refine/<slug> only and never merges"}, {"id": "r-visual-base", "from": "visual", "to": "base-branch", "label": "reads git facts", "when": "recap mode, or any mode reading the repo"}, {"id": "r-refine-config", "from": "ui-refine-loop", "to": "sb-config", "label": "reads refine block", "when": "setup, when a super-board config exists"}, {"id": "run-claim", "from": "sb-run", "to": "gh-board", "label": "claims + drains", "when": "each wave: claims cards by bot_identity assignee after sweep/flag/stranded, until drained or halted"}, {"id": "sb-v-onboard", "from": "super-board", "to": "sb-onboard", "label": "routes onboard", "when": "Eric runs /super-board onboard"}, {"id": "sb-v-lint", "from": "super-board", "to": "sb-lint", "label": "routes lint", "when": "Eric runs /super-board lint"}, {"id": "sb-v-status", "from": "super-board", "to": "sb-status", "label": "routes status", "when": "Eric runs /super-board status"}, {"id": "sb-v-run", "from": "super-board", "to": "sb-run", "label": "routes run", "when": "Eric runs /super-board run, or asks to resume"}, {"id": "sb-v-stop", "from": "super-board", "to": "sb-stop", "label": "routes stop", "when": "Eric runs /super-board stop or says pause"}, {"id": "sb-onb-config", "from": "sb-onboard", "to": "sb-config", "label": "8 · writes config", "when": "step 8, after \"Write everything\", with the active pointer"}, {"id": "sb-onb-gh", "from": "sb-onboard", "to": "gh-board", "label": "3 · picks board", "when": "step 3: reuse the best-ranked board (missing columns and labels added) or create one"}, {"id": "sb-lint-gh", "from": "sb-lint", "to": "gh-board", "label": "flags, labels cards", "when": "an active issue fails a criterion; proposed labels and AC fixes apply on approve"}, {"id": "sb-status-gh", "from": "sb-status", "to": "gh-board", "label": "reads counts", "when": "every status call; read-only"}, {"id": "sb-stop-gh", "from": "sb-stop", "to": "gh-board", "label": "releases claims", "when": "posts stopped-mid-flight comments and strips assignees"}, {"id": "lint-grill", "from": "sb-lint", "to": "grilling", "label": "grills Eric", "when": "an issue needs a rethink (criteria 10, 11) or has several readings (12)"}, {"id": "lint-diag", "from": "sb-lint", "to": "diagnosing-bugs", "label": "drafts repro", "when": "a bug ticket has no repro steps"}, {"id": "lint-shape", "from": "sb-lint", "to": "v-shape", "label": "shapes UX", "when": "a feature ticket has undefined UX"}, {"id": "lint-clarify", "from": "sb-lint", "to": "v-clarify", "label": "fixes copy ACs", "when": "an AC is about copy, microcopy or an error message"}, {"id": "lint-qatp", "from": "sb-lint", "to": "qa-test-planner", "label": "plans tests", "when": "a QA ticket has a vague test surface"}, {"id": "run-plan", "from": "sb-run", "to": "wave-plan", "label": "plans wave", "when": "after the rate guard and the usage guard pass; resume list included"}, {"id": "run-launch", "from": "sb-run", "to": "wave-js", "label": "launches workflow", "when": "one or more cards were claimed"}, {"id": "wave-build", "from": "wave-js", "to": "super-build", "label": "runs Build lane", "when": "card enters at Ready (feature, bug or no label) and pre-flight said proceed"}, {"id": "wave-qa", "from": "wave-js", "to": "super-qa", "label": "runs QA lane", "when": "card enters at QA, or Ready with the qa label"}, {"id": "wave-review", "from": "wave-js", "to": "super-review", "label": "runs Review lane", "when": "card enters at Review; always on the session model"}, {"id": "review-gate", "from": "super-review", "to": "merge-gate", "label": "calls merge gate", "when": "clean review, threads resolved, truth score over threshold, tests green"}, {"id": "gate-cleanup", "from": "merge-gate", "to": "cleanup-wt", "label": "runs post-merge", "when": "the merge landed and .claude/hooks/cleanup-wt.py exists"}, {"id": "gate-base", "from": "merge-gate", "to": "base-branch", "label": "squash-merges", "when": "policy allows the robot, the branch still passes against the current base inside the lock, allowed migrations ran"}, {"id": "run-manifest-e", "from": "sb-run", "to": "run-manifest", "label": "appends manifest", "when": "reconcile, once the wave returns; claims are released too"}, {"id": "b-pony", "from": "super-build", "to": "ponytail", "label": "climbs ladder first", "when": "every ticket, before the first line of code"}, {"id": "b-impl", "from": "super-build", "to": "implement", "label": "routes feature", "when": "type label feature or ux (then tdd, codebase-design)"}, {"id": "b-diag", "from": "super-build", "to": "diagnosing-bugs", "label": "routes bug", "when": "type label bug (then tdd)"}, {"id": "b-design", "from": "super-build", "to": "codebase-design", "label": "routes refactor", "when": "type label refactor or tech-debt, or feature"}, {"id": "b-tdd", "from": "super-build", "to": "tdd", "label": "builds test-first", "when": "every ticket except docs"}, {"id": "b-docs", "from": "super-build", "to": "context7", "label": "reads current docs", "when": "the ticket touches a third-party surface, an upgrade, or auth/billing"}, {"id": "b-verify", "from": "super-build", "to": "verification", "label": "proves before commit", "when": "before the final commit"}, {"id": "b-review", "from": "super-build", "to": "code-review", "label": "reviews own diff", "when": "once, against the merge-base, before the final commit"}, {"id": "b-conflict", "from": "super-build", "to": "resolving-merge-conflicts", "label": "resolves conflict", "when": "a live conflict, e.g. after merge-gate exit 2 or 5"}, {"id": "b-askmatt", "from": "super-build", "to": "ask-matt", "label": "asks the router", "when": "the right flow is unclear"}, {"id": "b-gh", "from": "super-build", "to": "gh-board", "label": "moves card to QA", "when": "draft PR opened and comments posted"}, {"id": "q-tdd", "from": "super-qa", "to": "tdd", "label": "writes gaps red-first", "when": "the test-gap check finds a High gap"}, {"id": "q-tddv2", "from": "super-qa", "to": "tdd-v2", "label": "picks the rung", "when": "the repo has tdd-v2 (used instead of plain tdd)"}, {"id": "q-diag", "from": "super-qa", "to": "diagnosing-bugs", "label": "diagnoses failures", "when": "a spec goes red and the cause is unclear"}, {"id": "q-verify", "from": "super-qa", "to": "verification", "label": "proves the pass", "when": "before a pass handoff"}, {"id": "q-askmatt", "from": "super-qa", "to": "ask-matt", "label": "asks the router", "when": "the right flow is unclear"}, {"id": "q-strat", "from": "super-qa", "to": "testing-strategy", "label": "judges coverage", "when": "deciding what is worth testing per component type"}, {"id": "q-vitest", "from": "super-qa", "to": "vitest", "label": "writes unit tests", "when": "the ladder stops at unit or integration in TS/JS"}, {"id": "q-pw", "from": "super-qa", "to": "playwright-bp", "label": "writes e2e specs", "when": "the browser is the thing that broke, or standalone crawl specs"}, {"id": "q-gh", "from": "super-qa", "to": "gh-board", "label": "moves card", "when": "pass: QA to Review; fail: QA to Ready (loop:rebuild-N); a qa card first moves itself Ready to QA"}, {"id": "q-filebug", "from": "super-qa", "to": "file-bug", "label": "files red spec", "when": "a standalone crawl finds a failing spec, or a qa card finds a defect tests alone cannot fix"}, {"id": "filebug-qaboard", "from": "file-bug", "to": "qa-board", "label": "sets Status Bug", "when": "the body passes validation"}, {"id": "v-cr", "from": "super-review", "to": "code-review", "label": "runs two-axis review", "when": "every card, with the merge-base as the fixed point"}, {"id": "v-design", "from": "super-review", "to": "codebase-design", "label": "reads diff shape", "when": "step 2, and when writing every deepening opportunity"}, {"id": "v-pony", "from": "super-review", "to": "ponytail-review", "label": "hunts over-engineering", "when": "step 3, on the merge-base diff; inline ladder if absent"}, {"id": "v-refactor", "from": "super-review", "to": "file-refactor", "label": "files deepening card", "when": "the diff is correct but leaves a shallow module or misplaced seam"}, {"id": "v-gh", "from": "super-review", "to": "gh-board", "label": "bounces or closes", "when": "unresolved [builder]/[qa] threads bounce; a confirmed merge moves the card to Done"}, {"id": "c-sentry", "from": "super-collect", "to": "collect-sentry", "label": "fetches sentry", "when": "sentry is requested or enabled in collect.sources"}, {"id": "c-posthog", "from": "super-collect", "to": "collect-posthog", "label": "fetches posthog", "when": "posthog is requested or enabled"}, {"id": "c-github", "from": "super-collect", "to": "gh-issues", "label": "reads github", "when": "github is requested or enabled"}, {"id": "c-prs", "from": "super-collect", "to": "collect-prs", "label": "fetches merged PRs", "when": "prs is requested or enabled"}, {"id": "c-ica", "from": "super-collect", "to": "improve-codebase-architecture", "label": "finds refactors", "when": "architecture source; read-only finder, findings only"}, {"id": "c-design", "from": "super-collect", "to": "codebase-design", "label": "finds refactors", "when": "architecture source when improve-codebase-architecture is not installed"}, {"id": "c-audit", "from": "super-collect", "to": "ponytail-audit", "label": "finds bloat", "when": "architecture source, always alongside the finder"}, {"id": "c-file", "from": "super-collect", "to": "collect-file", "label": "files if verified", "when": "one fresh verifier per candidate says file or needs-triage (duplicate gets a comment)"}, {"id": "file-gh", "from": "collect-file", "to": "gh-board", "label": "files to Backlog", "when": "--yes or confirmed dry-run; dedupe by exact fingerprint"}, {"id": "u-grill", "from": "ui-refine-loop", "to": "grilling", "label": "grills Eric", "when": "after reading the target's code; at most 10 questions in waves"}, {"id": "u-taste", "from": "ui-refine-loop", "to": "taste-file", "label": "commits taste", "when": "answers in hand; first commit on refine/<slug>"}, {"id": "u-imp", "from": "ui-refine-loop", "to": "impeccable", "label": "detects + loads", "when": "setup (detect, context) and the finish reviewer's craft-floor verdict pass"}, {"id": "u-shoot", "from": "ui-refine-loop", "to": "shoot", "label": "takes shots", "when": "round 0 at setup, then AFTER shots each fix round"}, {"id": "u-critique", "from": "ui-refine-loop", "to": "v-critique", "label": "design reviewer runs", "when": "every check, isolated from the detector"}, {"id": "u-detect", "from": "ui-refine-loop", "to": "imp-detect", "label": "detector runs", "when": "every check, in parallel with the design reviewer"}, {"id": "u-detect-audit", "from": "imp-detect", "to": "v-audit", "label": "feeds audit", "when": "same detector sub-agent; verified hits become problems"}, {"id": "u-crit-verbs", "from": "v-critique", "to": "verbs-group", "label": "checker ranks, routes", "when": "checker merges A and B into at most 8 typed problems"}, {"id": "u-audit-verbs", "from": "v-audit", "to": "verbs-group", "label": "checker ranks, routes", "when": "same merge; the fixer chains the routed verbs"}, {"id": "u-verbs-polish", "from": "verbs-group", "to": "v-polish", "label": "then polish last", "when": "every fix round, once, over all touched files"}, {"id": "u-ledger", "from": "ui-refine-loop", "to": "refine-ledger", "label": "appends ledger", "when": "after every check; stop rules read it"}, {"id": "u-human", "from": "ui-refine-loop", "to": "humanizer", "label": "humanizes PR", "when": "finish, after the finish reviewer graded every fix"}, {"id": "u-pr", "from": "ui-refine-loop", "to": "draft-pr", "label": "opens draft PR", "when": "finish; pushes refine/<slug> only"}, {"id": "iv-v-distill", "from": "verbs-group", "to": "v-distill", "label": "routes cluttered", "when": "a problem is typed cluttered"}, {"id": "iv-v-extract", "from": "verbs-group", "to": "v-extract", "label": "routes drift", "when": "a problem is typed drift"}, {"id": "iv-v-layout", "from": "verbs-group", "to": "v-layout", "label": "routes spacing", "when": "a problem is typed spacing-hierarchy"}, {"id": "iv-v-adapt", "from": "verbs-group", "to": "v-adapt", "label": "routes responsive", "when": "a problem is typed responsive"}, {"id": "iv-v-typeset", "from": "verbs-group", "to": "v-typeset", "label": "routes typography", "when": "a problem is typed typography"}, {"id": "iv-v-colorize", "from": "verbs-group", "to": "v-colorize", "label": "routes dull color", "when": "typed dull-color and the direction asks for more"}, {"id": "iv-v-quieter", "from": "verbs-group", "to": "v-quieter", "label": "routes too-loud", "when": "a problem is typed too-loud"}, {"id": "iv-v-bolder", "from": "verbs-group", "to": "v-bolder", "label": "routes bland", "when": "typed bland and the direction asks for more"}, {"id": "iv-v-clarify", "from": "verbs-group", "to": "v-clarify", "label": "routes confusing copy", "when": "a problem is typed confusing-copy"}, {"id": "iv-v-harden", "from": "verbs-group", "to": "v-harden", "label": "routes edge cases, a11y", "when": "a problem is typed edge-cases or accessibility"}, {"id": "iv-v-onboard", "from": "verbs-group", "to": "v-onboard", "label": "routes first-run", "when": "a problem is typed first-run-empty"}, {"id": "iv-late-verbs", "from": "verbs-group", "to": "late-verbs", "label": "routes motion, perf", "when": "a problem is typed needs-motion, personality or performance"}, {"id": "lv-animate", "from": "late-verbs", "to": "v-animate", "label": "routes needs-motion", "when": "typed needs-motion and the brief asks for motion"}, {"id": "lv-delight", "from": "late-verbs", "to": "v-delight", "label": "routes personality", "when": "typed personality and the brief asks for character"}, {"id": "lv-optimize", "from": "late-verbs", "to": "v-optimize", "label": "routes performance", "when": "a problem is typed performance"}, {"id": "lv-del-anim", "from": "v-delight", "to": "v-animate", "label": "calls", "when": "delight needs motion for its touches"}, {"id": "lv-polish", "from": "late-verbs", "to": "v-polish", "label": "then polish last", "when": "always, after the last tier"}, {"id": "im-init", "from": "impeccable", "to": "v-init", "label": "suggests init", "when": "PRODUCT.md is missing"}, {"id": "im-critique", "from": "impeccable", "to": "v-critique", "label": "suggests critique", "when": "an existing UI needs a review"}, {"id": "im-audit", "from": "impeccable", "to": "v-audit", "label": "offers audit", "when": "technical quality needs checking"}, {"id": "im-shape", "from": "impeccable", "to": "v-shape", "label": "offers shape", "when": "planning UX before code"}, {"id": "im-live", "from": "impeccable", "to": "v-live", "label": "offers live", "when": "interactive browser iteration"}, {"id": "im-overdrive", "from": "impeccable", "to": "v-overdrive", "label": "offers overdrive", "when": "an ambitious, unconventional effect is wanted"}, {"id": "im-verbs", "from": "impeccable", "to": "verbs-group", "label": "offers refine verbs", "when": "fix, refine and enhance work on an existing UI"}, {"id": "im-shape-init", "from": "v-shape", "to": "v-init", "label": "requires", "when": "always; shape needs PRODUCT.md"}, {"id": "im-doc-init", "from": "v-document", "to": "v-init", "label": "requires", "when": "always; document needs PRODUCT.md"}, {"id": "im-audit-harden", "from": "v-audit", "to": "v-harden", "label": "suggests", "when": "audit found edge-case or accessibility gaps"}, {"id": "im-audit-opt", "from": "v-audit", "to": "v-optimize", "label": "suggests", "when": "audit found performance gaps"}, {"id": "im-crit-polish", "from": "v-critique", "to": "v-polish", "label": "feeds", "when": "critique findings feed the final pass"}, {"id": "im-live-polish", "from": "v-live", "to": "v-polish", "label": "calls", "when": "a variant was chosen"}, {"id": "vi-py", "from": "visual", "to": "visual-py", "label": "detects, renders", "when": "every run: detect with no argument, facts in recap, render after data.json"}, {"id": "vi-py-base", "from": "visual-py", "to": "base-branch", "label": "reads git diff", "when": "recap mode collects files, +/- and hunks from git"}, {"id": "h-wt", "from": "claude-settings", "to": "guard-worktree-path", "label": "PreToolUse Bash", "when": "every shell command"}, {"id": "h-del", "from": "claude-settings", "to": "guard-delete-outside", "label": "PreToolUse Bash", "when": "every shell command"}, {"id": "h-sec", "from": "claude-settings", "to": "guard-secrets", "label": "Pre Bash|Read|Grep", "when": "every read, grep or shell command"}, {"id": "h-key", "from": "claude-settings", "to": "guard-key-literals", "label": "Pre/PostToolUse writes", "when": "Edit/MultiEdit/Write/NotebookEdit (and Bash before)"}, {"id": "h-session", "from": "claude-settings", "to": "cleanup-wt", "label": "SessionStart --auto", "when": "a base branch tip moved since the last session"}, {"id": "h-push", "from": "install-sh", "to": "guard-protected-push", "label": "--protect-main wires", "when": "install with --protect-main, or onboard's yes"}, {"id": "h-gate", "from": "hooks", "to": "gate-skill-evals", "label": "dev-only Stop", "when": "only in the pack repo or EricOS; a skill changed without a newer eval"}, {"id": "h-readme", "from": "hooks", "to": "readme-sync", "label": "dev-only sync", "when": "edits or commits under skills/ in the pack repo"}, {"id": "tdd-design", "from": "tdd", "to": "codebase-design", "label": "borrows vocabulary", "when": "the interface or seam shape is itself in question"}, {"id": "tdd-cr", "from": "tdd", "to": "code-review", "label": "defers refactor to", "when": "refactoring belongs to review, not the red-green loop"}, {"id": "tddv2-tdd", "from": "tdd-v2", "to": "tdd", "label": "defers discipline to", "when": "always; tdd owns seams and red-before-green"}, {"id": "impl-tddv2", "from": "implement", "to": "tdd-v2", "label": "builds at the rung", "when": "where possible, at pre-agreed seams"}, {"id": "impl-tdd", "from": "implement", "to": "tdd", "label": "red-green under it", "when": "every slice"}, {"id": "impl-cr", "from": "implement", "to": "code-review", "label": "reviews when done", "when": "once the work is done, before committing"}, {"id": "cr-setup", "from": "code-review", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "docs/agents/issue-tracker.md is missing"}, {"id": "db-ica", "from": "diagnosing-bugs", "to": "improve-codebase-architecture", "label": "hands off post-mortem", "when": "the fix is in and the real finding is a missing seam"}, {"id": "ica-design", "from": "improve-codebase-architecture", "to": "codebase-design", "label": "uses vocabulary", "when": "every suggestion, and design-it-twice for alternatives"}, {"id": "ica-grill", "from": "improve-codebase-architecture", "to": "grilling", "label": "grills the pick", "when": "the user picks a candidate (skipped by super-collect)"}, {"id": "ica-dm", "from": "improve-codebase-architecture", "to": "domain-modeling", "label": "updates CONTEXT.md", "when": "a new term or a rejected candidate worth an ADR"}, {"id": "am-grill-with-docs", "from": "ask-matt", "to": "grill-with-docs", "label": "1 · sharpens idea", "when": "start of the main flow, in a working directory"}, {"id": "am-handoff", "from": "ask-matt", "to": "handoff", "label": "bridges detours", "when": "a question needs a prototype, or a phase boundary"}, {"id": "am-prototype", "from": "ask-matt", "to": "prototype", "label": "answers by code", "when": "a question needs a runnable answer"}, {"id": "am-to-spec", "from": "ask-matt", "to": "to-spec", "label": "multi-session: spec", "when": "the build spans several sessions"}, {"id": "am-to-tickets", "from": "ask-matt", "to": "to-tickets", "label": "splits into tickets", "when": "after to-spec, with blocking edges"}, {"id": "am-implement", "from": "ask-matt", "to": "implement", "label": "builds each ticket", "when": "every ticket, or in place for a small build"}, {"id": "am-tdd", "from": "ask-matt", "to": "tdd", "label": "test-first alone", "when": "a concrete behaviour without a full spec"}, {"id": "am-code-review", "from": "ask-matt", "to": "code-review", "label": "reviews a branch", "when": "reviewing against a fixed point"}, {"id": "am-triage", "from": "ask-matt", "to": "triage", "label": "on-ramp: triage", "when": "raw bugs and requests pile up"}, {"id": "am-diagnosing-bugs", "from": "ask-matt", "to": "diagnosing-bugs", "label": "on-ramp: broken", "when": "something is broken and resists a first look"}, {"id": "am-wayfinder", "from": "ask-matt", "to": "wayfinder", "label": "on-ramp: foggy", "when": "a huge effort too big for one session"}, {"id": "am-improve-codebase-architecture", "from": "ask-matt", "to": "improve-codebase-architecture", "label": "codebase health", "when": "a spare moment for upkeep"}, {"id": "am-domain-modeling", "from": "ask-matt", "to": "domain-modeling", "label": "vocabulary", "when": "the words, not the process, are the problem"}, {"id": "gwd-grill", "from": "grill-with-docs", "to": "grilling", "label": "runs grilling", "when": "every session"}, {"id": "gwd-dm", "from": "grill-with-docs", "to": "domain-modeling", "label": "keeps glossary", "when": "a term is fuzzy or a decision is hard to reverse"}, {"id": "ts-setup", "from": "to-spec", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker and triage labels are not configured"}, {"id": "tt-setup", "from": "to-tickets", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker and triage labels are not configured"}, {"id": "tr-grill", "from": "triage", "to": "grilling", "label": "grills if needed", "when": "an issue is too unclear to brief"}, {"id": "tr-dm", "from": "triage", "to": "domain-modeling", "label": "checks vocabulary", "when": "writing the agent-ready brief"}, {"id": "tr-setup", "from": "triage", "to": "setup-matt-pocock-skills", "label": "needs label map", "when": "the triage label mapping is missing"}, {"id": "wf-grill", "from": "wayfinder", "to": "grilling", "label": "names destination", "when": "first step, and every grilling ticket"}, {"id": "wf-dm", "from": "wayfinder", "to": "domain-modeling", "label": "pins terms", "when": "alongside every grilling session"}, {"id": "wf-proto", "from": "wayfinder", "to": "prototype", "label": "raises fidelity", "when": "a prototype ticket needs UI or logic code"}, {"id": "wf-setup", "from": "wayfinder", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker is not configured"}, {"id": "r-install-hooks", "from": "install-sh", "to": "hooks", "label": "copies guards", "when": "install without --no-hooks (--protect-main adds the push guard)"}, {"id": "onb-answers", "from": "sb-onboard", "to": "onboard-answers", "label": "saves each answer", "when": "the moment each answer is given; resume reads it"}, {"id": "onb-setup", "from": "sb-onboard", "to": "setup-py", "label": "1 · Checks: fix", "when": "every run, first; asks only for system tools or sign-ins"}, {"id": "setup-install", "from": "setup-py", "to": "install-sh", "label": "fix re-runs install", "when": "skills, scripts, workflows, guards or settings entries are missing or old"}, {"id": "setup-gh", "from": "setup-py", "to": "gh-board", "label": "board-rank, migrate", "when": "step 3 (or step 1 on an upgrade): ranks boards, adds columns and labels"}, {"id": "onb-branch", "from": "sb-onboard", "to": "base-branch", "label": "4 · picks base", "when": "step 4; no staging → offers `git push origin main:staging`"}, {"id": "onb-agents", "from": "sb-onboard", "to": "agents-md-py", "label": "5 · AGENTS.md", "when": "step 5: move CLAUDE.md rules, or only add the section"}, {"id": "agents-write", "from": "agents-md-py", "to": "agents-file", "label": "writes block, pointer", "when": "step 8 write, after backup and coverage pass"}, {"id": "onb-settings", "from": "sb-onboard", "to": "settings-py", "label": "6 · Policies", "when": "step 6 answers: safe defaults and N permission lines"}, {"id": "settings-write", "from": "settings-py", "to": "claude-settings", "label": "merges entries", "when": "install (hooks) or onboard step 8 (allow lines)"}, {"id": "settings-push", "from": "settings-py", "to": "guard-protected-push", "label": "wires push guard", "when": "Policies said block pushes to main and the script is installed"}, {"id": "onb-env", "from": "sb-onboard", "to": "env-check", "label": "checks key names", "when": "silent detect and step 7, for Sentry, PostHog and DB keys"}, {"id": "onb-custom", "from": "sb-onboard", "to": "collect-custom", "label": "7 · adds a source", "when": "\"➕ Add another source\": classify, ping read-only, add on ✅"}, {"id": "custom-config", "from": "collect-custom", "to": "sb-config", "label": "saves custom[]", "when": "the ping succeeded; staged until step 8"}, {"id": "lint-tickets", "from": "sb-lint", "to": "to-tickets", "label": "splits too-big", "when": "criterion 15: likely over ~400 changed lines or many areas"}, {"id": "wave-preflight", "from": "wave-js", "to": "preflight", "label": "pre-flights batches", "when": "Ready cards the Builder would take, up to 5 per agent"}, {"id": "preflight-gh", "from": "preflight", "to": "gh-board", "label": "holds to Blocked", "when": "already done, in progress, overlapping, unclear or too big"}, {"id": "gate-needsyou", "from": "merge-gate", "to": "needs-you", "label": "parks (exit 7/8)", "when": "merge_policy says a human merges, or a migration/human step is needed"}, {"id": "needsyou-plan", "from": "needs-you", "to": "wave-plan", "label": "resumes on done", "when": "a human comments done or labels needs-you:done"}, {"id": "super-build-prbody", "from": "super-build", "to": "pr-body", "label": "writes PR blocks", "when": "opening the draft PR and on every rebuild"}, {"id": "super-build-human", "from": "super-build", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "super-qa-prbody", "from": "super-qa", "to": "pr-body", "label": "ticks ac, visual", "when": "every pass or fail handoff"}, {"id": "super-qa-human", "from": "super-qa", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "super-review-prbody", "from": "super-review", "to": "pr-body", "label": "updates status", "when": "after a merge (✅ Merged) or a block"}, {"id": "super-review-human", "from": "super-review", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "review-needsyou", "from": "super-review", "to": "needs-you", "label": "posts 🙋 checklist", "when": "the merge gate exits 7 or 8"}, {"id": "c-custom", "from": "super-collect", "to": "collect-custom", "label": "runs custom sources", "when": "a custom source is requested by name or enabled in collect.sources"}, {"id": "u-prbody", "from": "ui-refine-loop", "to": "pr-body", "label": "builds PR body", "when": "finish: --skeleton marker blocks for the draft PR"}, {"id": "install-settings", "from": "install-sh", "to": "settings-py", "label": "merges hook block", "when": "install without --no-hooks"}, {"id": "secrets-envcheck", "from": "guard-secrets", "to": "env-check", "label": "allows plain call", "when": "a single env-check call with no pipe, chain or redirect"}, {"id": "get-install", "from": "get-sh", "to": "install-sh", "label": "runs install", "when": "after downloading the release tarball"}, {"id": "plugin-onboard", "from": "plugin-mkt", "to": "sb-onboard", "label": "needs onboard", "when": "a plugin ships skills only; onboard step 1 adds the rest"}, {"id": "install-upgrade", "from": "install-sh", "to": "upgrade-json", "label": "records old version", "when": "an older super-board install was found"}, {"id": "upgrade-setup", "from": "upgrade-json", "to": "setup-py", "label": "triggers upgrade", "when": "onboard step 1 runs fix and finds the record"}, {"id": "r-gitsync-base", "from": "git-sync", "to": "base-branch", "label": "pulls, pushes", "when": "every run; a push to the default or a protected branch waits for a yes"}, {"id": "gs-base", "from": "git-sync", "to": "base-branch", "label": "merge-pulls, pushes", "when": "`git pull --no-rebase`, then `git push`; never force"}, {"id": "gs-conflict", "from": "git-sync", "to": "resolving-merge-conflicts", "label": "resolves conflict", "when": "the pull conflicts and the skill is installed; otherwise hunk by hunk"}, {"id": "gs-push", "from": "git-sync", "to": "guard-protected-push", "label": "push checked by", "when": "the opt-in push guard is installed"}], "views": [{"id": "root", "parent": null, "title": "super-board pack", "caption": "Collect verified tickets into the board; the board contains Build → QA → Review. UI refinement, visuals and Git sync are standalone skills. Open a family or step for its tools and policies.", "nodeIds": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "ui-refine-loop", "visual", "git-sync"], "edges": [{"from": "super-collect", "to": "super-board", "label": "Backlog → lint"}, {"from": "super-board", "to": "super-build", "label": "Ready cards"}, "r-build-qa", "r-qa-review", {"from": "super-review", "to": "super-collect", "label": "review done → collect the next tickets", "kind": "feeds", "when": "the board drains; /super-collect files the next verified tickets into Backlog"}], "lanes": false, "layout": {"super-collect": [0, 0], "super-board": [1, 0], "super-build": [2, 0], "super-qa": [3, 0], "super-review": [4, 0], "ui-refine-loop": [5, 0], "visual": [5, 1], "git-sync": [5, 2]}, "nodeOverrides": {"super-collect": {"verbs": [], "sublabel": "Find verified tickets", "emphasis": true}, "super-board": {"verbs": [], "sublabel": "Run the board", "emphasis": true}, "ui-refine-loop": {"verbs": [], "sublabel": "Refine a page", "emphasis": true}, "visual": {"verbs": [], "sublabel": "Draw one visual", "emphasis": true}, "super-build": {"emphasis": true}, "super-qa": {"emphasis": true}, "super-review": {"emphasis": true}, "git-sync": {"verbs": [], "sublabel": "Commit · pull · push", "emphasis": true}}, "containers": [{"id": "collect-family", "label": "/super-collect · intake feeds the board", "nodeIds": ["super-collect"]}, {"id": "board-family", "parent": "collect-family", "label": "/super-board · Build → QA → Review", "nodeIds": ["super-board", "super-build", "super-qa", "super-review"]}], "browserOrder": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "ui-refine-loop", "visual", "git-sync", "hooks", "install"], "intake": [{"label": "Sentry", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMzNjJENTkiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+U2VudHJ5PC90aXRsZT48cGF0aCBkPSJNMTMuOTEgMi41MDVjLS44NzMtMS40NDgtMi45NzItMS40NDgtMy44NDQgMEw2LjkwNCA3LjkyYTE1LjQ3OCAxNS40NzggMCAwIDEgOC41MyAxMi44MTFoLTIuMjIxQTEzLjMwMSAxMy4zMDEgMCAwIDAgNS43ODQgOS44MTRsLTIuOTI2IDUuMDZhNy42NSA3LjY1IDAgMCAxIDQuNDM1IDUuODQ4SDIuMTk0YS4zNjUuMzY1IDAgMCAxLS4yOTgtLjUzNGwxLjQxMy0yLjQwMmE1LjE2IDUuMTYgMCAwIDAtMS42MTQtLjkxM0wuMjk2IDE5LjI3NWEyLjE4MiAyLjE4MiAwIDAgMCAuODEyIDIuOTk5IDIuMjQgMi4yNCAwIDAgMCAxLjA4Ni4yODhoNi45ODNhOS4zMjIgOS4zMjIgMCAwIDAtMy44NDUtOC4zMThsMS4xMS0xLjkyMmExMS40NyAxMS40NyAwIDAgMSA0Ljk1IDEwLjI0aDUuOTE1YTE3LjI0MiAxNy4yNDIgMCAwIDAtNy44ODUtMTUuMjhsMi4yNDQtMy44NDVhLjM3LjM3IDAgMCAxIC41MDQtLjEzYy4yNTUuMTQgOS43NSAxNi43MDggOS45MjggMTYuOWEuMzY1LjM2NSAwIDAgMS0uMzI3LjU0M2gtMi4yODdjLjAyOS42MTIuMDI5IDEuMjIzIDAgMS44MzFoMi4yOTdhMi4yMDYgMi4yMDYgMCAwIDAgMS45MjItMy4zMXoiLz48L3N2Zz4=", "to": "super-collect"}, {"label": "PostHog", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMwMDAwMDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+UG9zdEhvZzwvdGl0bGU+PHBhdGggZD0iTTkuODU0IDE0LjUgNSA5LjY0Ny44NTQgNS41QS41LjUgMCAwIDAgMCA1Ljg1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ni4zNTNMNSAxMy42NDdsLjE0Ny4xNDZMOS44NTQgMTguNWwuMTQ2LjE0N3YtLjA0OWMuMDY1LjAzLjEzNC4wNDkuMjA3LjA0OWgyLjU4NmEuNS41IDAgMCAwIC4zNTMtLjg1NEw5Ljg1NCAxNC41em0wLTUtNC00YS40ODcuNDg3IDAgMCAwLS40MDktLjE0NC41MTUuNTE1IDAgMCAwLS4zNTYuMjEuNDkzLjQ5MyAwIDAgMC0uMDg5LjI4OFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsOSA5YS41LjUgMCAwIDAgLjg1My0uMzU0di0yLjU4NWEuNS41IDAgMCAwLS4xNDYtLjM1NGwtNS01em0xLTRhLjUuNSAwIDAgMC0uODU0LjM1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsNCA0YS41LjUgMCAwIDAgLjg1My0uMzU0VjkuODU0YS41LjUgMCAwIDAtLjE0Ni0uMzU0bC00LTR6bTEyLjY0NyAxMS41MTVhMy44NjMgMy44NjMgMCAwIDEtMi4yMzItMS4xbC00LjcwOC00LjcwN2EuNS41IDAgMCAwLS44NTQuMzU0djYuNTg1YS41LjUgMCAwIDAgLjUuNUgyMy41YS41LjUgMCAwIDAgLjUtLjV2LS42YzAtLjI3Ni0uMjI1LS40OTctLjQ5OS0uNTMyem0tNS4zOTQuMDMyYS44LjggMCAxIDEgMC0xLjYuOC44IDAgMCAxIDAgMS42ek0uODU0IDE1LjVhLjUuNSAwIDAgMC0uODU0LjM1NHYyLjI5M2EuNS41IDAgMCAwIC41LjVoMi4yOTNjLjIyMiAwIC4zOS0uMTM1LjQ2Mi0uMzA5YS40OTMuNDkzIDAgMCAwLS4xMDktLjU0NUwuODU0IDE1LjUwMXpNNSAxNC42NDcuODU0IDEwLjVhLjUuNSAwIDAgMC0uODU0LjM1M3YyLjU4NmEuNS41IDAgMCAwIC4xNDYuMzUzTDQuODU0IDE4LjVsLjE0Ni4xNDdoMi43OTNhLjUuNSAwIDAgMCAuMzUzLS44NTRMNSAxNC42NDd6Ii8+PC9zdmc+", "to": "super-collect"}, {"label": "GitHub", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "super-collect"}], "tour": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "super-collect"]}, {"id": "super-board", "parent": "root", "title": "/super-board · five verbs", "caption": "Onboard sets up; lint makes cards ready; run delegates the lanes. Status inspects a run; stop halts it.", "nodeIds": ["super-board", "sb-onboard", "sb-lint", "sb-status", "sb-run", "sb-stop"], "edges": ["sb-v-onboard", "sb-v-lint", "sb-v-status", "sb-v-run", "sb-v-stop"], "lanes": [{"title": "Prepare", "nodeIds": ["sb-onboard", "sb-lint"]}, {"title": "Run", "nodeIds": ["sb-run"]}, {"title": "Control", "nodeIds": ["sb-status", "sb-stop"]}], "nodeOverrides": {"super-board": {"label": "/super-board", "verbs": [], "sublabel": "Five verbs", "emphasis": true}, "sb-onboard": {"label": "onboard", "verbs": [], "sublabel": "Set up the project", "emphasis": true}, "sb-lint": {"label": "lint", "verbs": [], "sublabel": "Check ticket readiness", "emphasis": true}, "sb-run": {"label": "run", "verbs": [], "sublabel": "Delegate build · QA · review", "emphasis": true}, "sb-status": {"label": "status", "verbs": [], "sublabel": "Inspect the run", "emphasis": true}, "sb-stop": {"label": "stop", "verbs": [], "sublabel": "Halt the run", "emphasis": true}}, "browserOrder": ["super-build", "super-qa", "super-review", "sb-onboard", "sb-lint", "super-board-run", "sb-status", "sb-stop"]}, {"id": "sb-lint", "parent": "super-board", "title": "/super-board lint · Phase 4 routing", "caption": "Interactive-only skills live here, never inside an unattended worker. Ticket-format fixes (criteria 16–18) and catch-alls get an inline draft.", "nodeIds": ["sb-lint", "grilling", "diagnosing-bugs", "v-shape", "v-clarify", "qa-test-planner", "gh-board", "to-tickets"], "edges": ["lint-grill", "lint-diag", "lint-shape", "lint-clarify", "lint-qatp", "sb-lint-gh", "lint-tickets"]}, {"id": "super-board-run", "parent": "super-board", "title": "/super-board run · main steps", "caption": "One wave: classify → pre-flight → delegate → merge → done. Up to min(16, CPUs − 2) cards run at once; the runtime queues the rest. Pre-flight checks batches of 5. Open a step for scripts and policies.", "nodeIds": ["sb-run", "run-classify", "run-preflight", "run-delegate", "run-merge", "run-done"], "edges": [{"from": "sb-run", "to": "run-classify", "label": ""}, {"from": "run-classify", "to": "run-preflight", "label": ""}, {"from": "run-preflight", "to": "run-delegate", "label": ""}, {"from": "run-delegate", "to": "run-merge", "label": ""}, {"from": "run-merge", "to": "run-done", "label": ""}], "render": "process", "nodes": [{"id": "run-classify", "label": "Classify cards", "kind": "step", "what": "Route qa, bug and feature cards by label. Classify unlabelled cards as bug or feature.", "when": "Each Ready card enters the classifier. Existing type labels take priority.", "how": "Read the issue body and comments. Judge complexity as low, medium or high; choose the worker model tier.", "source": ["https://github.com/EricTechPro/super-board/blob/main/workflows/super-board-wave.js"], "opensView": "run-classify", "sublabel": "qa / bug / feature"}, {"id": "run-preflight", "label": "Pre-flight check", "kind": "step", "what": "Check whether a Ready build card is already done or in progress. Flag overlap, unclear scope and excessive size.", "when": "Before any worktree or Builder starts. Check build cards in batches of up to five.", "how": "Combine mechanical checks with semantic matches. Return proceed, hold, sequence or skipped.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-preflight.sh", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "opensView": "run-preflight", "sublabel": "Done? overlap? too big?"}, {"id": "run-delegate", "label": "Delegate to lanes", "kind": "step", "what": "Run the Build, QA and Review lane agents. QA-labelled cards skip Building.", "when": "After pre-flight allows a build card to proceed. QA and Review cards enter their current lane.", "how": "Build advances to QA, then Review. A non-advanced exit stops that card’s chain; Review uses the session model. The runtime caps concurrent agents at min(16, CPUs − 2), and queues the rest.", "source": ["https://github.com/EricTechPro/super-board/blob/main/workflows/super-board-wave.js"], "opensView": "run-lanes", "sublabel": "Build → QA → Review"}, {"id": "run-merge", "label": "Merge gate", "kind": "step", "what": "Re-prove the branch under an atomic merge lock. Apply merge policy before squash-merging.", "when": "Once Review passes. Human-only steps park the card in Blocked.", "how": "Check the current base and permitted migrations. Match the PR head before merge; clean the worktree afterwards.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-policy.py"], "opensView": "merge-gate", "sublabel": "Prove + apply policy"}, {"id": "run-done", "label": "Done", "kind": "step", "what": "Squash-merge the approved PR and clean its worktree. Reconcile the returned card result.", "when": "After Review and the merge gate pass. Report the wave before selecting the next one.", "how": "Record merged, bounced, blocked or failed outcomes. Repeat waves until the board drains or a halt gate fires.", "source": ["https://github.com/EricTechPro/super-board/blob/main/hooks/cleanup-wt.py", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-gate.sh"], "opensView": "run-done", "sublabel": "Merge · clean · reconcile"}], "mainSteps": true, "lanes": false, "layout": {"sb-run": [0, 0], "run-classify": [1, 0], "run-preflight": [2, 0], "run-delegate": [3, 0], "run-merge": [4, 0], "run-done": [5, 0]}, "nodeOverrides": {"sb-run": {"label": "Run a wave", "verbs": [], "sublabel": "Claim ready cards", "opensView": "run-start"}}}, {"id": "super-build", "parent": "super-board", "title": "super-build · skills by ticket type", "caption": "An explicit `Skills:` line wins; otherwise the type label picks the chain. Each PR stays under 400 changed lines. grilling is forbidden here and lives in lint.", "nodeIds": ["super-build", "ponytail", "implement", "diagnosing-bugs", "codebase-design", "tdd", "context7", "verification", "code-review", "resolving-merge-conflicts", "ask-matt", "gh-board", "pr-body", "humanizer"], "edges": ["b-pony", "b-impl", "b-diag", "b-design", "b-tdd", "b-docs", "b-verify", "b-review", "b-conflict", "b-askmatt", "b-gh", "super-build-prbody", "super-build-human"], "nodeOverrides": {"verification": {"label": "verification"}, "resolving-merge-conflicts": {"label": "resolve conflicts"}}}, {"id": "super-qa", "parent": "super-board", "title": "super-qa · test plan, gap check, evidence", "caption": "Issue-scoped inside a run (qa-labelled cards skip Building); standalone it crawls routes and files onto the Super Ultimate QA board.", "nodeIds": ["super-qa", "tdd", "tdd-v2", "diagnosing-bugs", "verification", "ask-matt", "testing-strategy", "vitest", "playwright-bp", "gh-board", "file-bug", "qa-board", "pr-body", "humanizer"], "edges": ["q-tdd", "q-tddv2", "q-diag", "q-verify", "q-askmatt", "q-strat", "q-vitest", "q-pw", "q-gh", "q-filebug", "filebug-qaboard", "super-qa-prbody", "super-qa-human"], "nodeOverrides": {"verification": {"label": "verification"}, "playwright-bp": {"label": "Playwright practices"}}}, {"id": "super-review", "parent": "super-board", "title": "super-review · own pass, memory, merge gate", "caption": "Fresh review, adversarial grounding and refactor findings. Passing review enters the merge gate; human-only steps open their own view.", "nodeIds": ["super-review", "code-review", "codebase-design", "ponytail-review", "file-refactor", "merge-gate", "gh-board", "pr-body", "humanizer", "needs-you"], "edges": ["v-cr", "v-design", "v-pony", "v-refactor", "review-gate", "v-gh", "super-review-prbody", "super-review-human", "review-needsyou"], "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "super-collect", "parent": "root", "title": "/super-collect · fetch, verify, file", "caption": "Fetch sources → verify → confirm → file to Backlog. Five built-in sources plus custom ones; collecting never moves a card to Ready.", "nodeIds": ["collect-fetch", "collect-verify", "collect-confirm", "collect-submit"], "edges": [{"from": "collect-fetch", "to": "collect-verify", "label": "candidates"}, {"from": "collect-verify", "to": "collect-confirm", "label": "real ones"}, {"from": "collect-confirm", "to": "collect-submit", "label": "on yes"}], "nodes": [{"id": "collect-fetch", "label": "Fetch sources", "kind": "step", "what": "Fetch the enabled built-in sources. Include any custom sources added in onboard.", "when": "When /super-collect runs for the project. Use the requested window or the default 14 days.", "how": "Read the selected adapters and findings. Send each candidate to a fresh verifier.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-sources", "sublabel": "Last 14 days by default"}, {"id": "collect-verify", "label": "Verify", "kind": "step", "what": "Check whether each candidate is real and still happening. Reject fixed or duplicate problems.", "when": "After source adapters return candidates. Use one fresh verifier for each candidate.", "how": "Verify against the project evidence. Mark unclear candidates needs-triage before filing.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-verify", "sublabel": "One fresh check each"}, {"id": "collect-confirm", "label": "Confirm", "kind": "step", "what": "Show the proposed filing plan. Keep collection dry-run by default.", "when": "After verification produces the candidate results. Before writing tickets to the board.", "how": "Present the plan table for confirmation. Use --yes when filing is already authorized.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-confirm", "sublabel": "Dry run until you say yes"}, {"id": "collect-submit", "label": "File to Backlog", "kind": "step", "what": "File verified problems into Backlog. Apply fingerprints and duplicate checks.", "when": "After confirmation or an authorized --yes run. File candidates marked file or needs-triage.", "how": "Use one filing entry point for all sources. Route bugs, features and fixes separately from refactors.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/scripts/super-collect-file.sh"], "opensView": "collect-submit", "sublabel": "Then lint"}], "mainSteps": true, "render": "process", "lanes": false, "layout": {"collect-fetch": [0, 0], "collect-verify": [1, 0], "collect-confirm": [2, 0], "collect-submit": [3, 0]}, "intake": [{"label": "Sentry", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMzNjJENTkiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+U2VudHJ5PC90aXRsZT48cGF0aCBkPSJNMTMuOTEgMi41MDVjLS44NzMtMS40NDgtMi45NzItMS40NDgtMy44NDQgMEw2LjkwNCA3LjkyYTE1LjQ3OCAxNS40NzggMCAwIDEgOC41MyAxMi44MTFoLTIuMjIxQTEzLjMwMSAxMy4zMDEgMCAwIDAgNS43ODQgOS44MTRsLTIuOTI2IDUuMDZhNy42NSA3LjY1IDAgMCAxIDQuNDM1IDUuODQ4SDIuMTk0YS4zNjUuMzY1IDAgMCAxLS4yOTgtLjUzNGwxLjQxMy0yLjQwMmE1LjE2IDUuMTYgMCAwIDAtMS42MTQtLjkxM0wuMjk2IDE5LjI3NWEyLjE4MiAyLjE4MiAwIDAgMCAuODEyIDIuOTk5IDIuMjQgMi4yNCAwIDAgMCAxLjA4Ni4yODhoNi45ODNhOS4zMjIgOS4zMjIgMCAwIDAtMy44NDUtOC4zMThsMS4xMS0xLjkyMmExMS40NyAxMS40NyAwIDAgMSA0Ljk1IDEwLjI0aDUuOTE1YTE3LjI0MiAxNy4yNDIgMCAwIDAtNy44ODUtMTUuMjhsMi4yNDQtMy44NDVhLjM3LjM3IDAgMCAxIC41MDQtLjEzYy4yNTUuMTQgOS43NSAxNi43MDggOS45MjggMTYuOWEuMzY1LjM2NSAwIDAgMS0uMzI3LjU0M2gtMi4yODdjLjAyOS42MTIuMDI5IDEuMjIzIDAgMS44MzFoMi4yOTdhMi4yMDYgMi4yMDYgMCAwIDAgMS45MjItMy4zMXoiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "PostHog", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMwMDAwMDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+UG9zdEhvZzwvdGl0bGU+PHBhdGggZD0iTTkuODU0IDE0LjUgNSA5LjY0Ny44NTQgNS41QS41LjUgMCAwIDAgMCA1Ljg1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ni4zNTNMNSAxMy42NDdsLjE0Ny4xNDZMOS44NTQgMTguNWwuMTQ2LjE0N3YtLjA0OWMuMDY1LjAzLjEzNC4wNDkuMjA3LjA0OWgyLjU4NmEuNS41IDAgMCAwIC4zNTMtLjg1NEw5Ljg1NCAxNC41em0wLTUtNC00YS40ODcuNDg3IDAgMCAwLS40MDktLjE0NC41MTUuNTE1IDAgMCAwLS4zNTYuMjEuNDkzLjQ5MyAwIDAgMC0uMDg5LjI4OFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsOSA5YS41LjUgMCAwIDAgLjg1My0uMzU0di0yLjU4NWEuNS41IDAgMCAwLS4xNDYtLjM1NGwtNS01em0xLTRhLjUuNSAwIDAgMC0uODU0LjM1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsNCA0YS41LjUgMCAwIDAgLjg1My0uMzU0VjkuODU0YS41LjUgMCAwIDAtLjE0Ni0uMzU0bC00LTR6bTEyLjY0NyAxMS41MTVhMy44NjMgMy44NjMgMCAwIDEtMi4yMzItMS4xbC00LjcwOC00LjcwN2EuNS41IDAgMCAwLS44NTQuMzU0djYuNTg1YS41LjUgMCAwIDAgLjUuNUgyMy41YS41LjUgMCAwIDAgLjUtLjV2LS42YzAtLjI3Ni0uMjI1LS40OTctLjQ5OS0uNTMyem0tNS4zOTQuMDMyYS44LjggMCAxIDEgMC0xLjYuOC44IDAgMCAxIDAgMS42ek0uODU0IDE1LjVhLjUuNSAwIDAgMC0uODU0LjM1NHYyLjI5M2EuNS41IDAgMCAwIC41LjVoMi4yOTNjLjIyMiAwIC4zOS0uMTM1LjQ2Mi0uMzA5YS40OTMuNDkzIDAgMCAwLS4xMDktLjU0NUwuODU0IDE1LjUwMXpNNSAxNC42NDcuODU0IDEwLjVhLjUuNSAwIDAgMC0uODU0LjM1M3YyLjU4NmEuNS41IDAgMCAwIC4xNDYuMzUzTDQuODU0IDE4LjVsLjE0Ni4xNDdoMi43OTNhLjUuNSAwIDAgMCAuMzUzLS44NTRMNSAxNC42NDd6Ii8+PC9zdmc+", "to": "collect-fetch"}, {"label": "GitHub issues", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "Merged PRs", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "Architecture", "mark": "◇", "to": "collect-fetch"}, {"label": "custom", "mark": "+", "dashed": true, "to": "collect-fetch"}]}, {"id": "ui-refine-loop", "parent": "root", "title": "/ui-refine-loop · main steps", "caption": "Standalone: direction → check → fix → review → draft PR. Default 5 rounds; stop after two clean P0/P1 checks, two reverted rounds or a dead agent.", "nodeIds": ["ui-refine-loop", "refine-brief", "refine-check", "refine-fix", "refine-review", "refine-pr", "grilling", "impeccable", "verbs-group", "humanizer"], "edges": [{"from": "ui-refine-loop", "to": "refine-brief", "label": ""}, {"from": "refine-brief", "to": "refine-check", "label": ""}, {"from": "refine-check", "to": "refine-fix", "label": ""}, {"from": "refine-fix", "to": "refine-review", "label": ""}, {"from": "refine-review", "to": "refine-pr", "label": ""}], "render": "process", "nodes": [{"id": "refine-brief", "label": "Grill + save direction", "kind": "step", "what": "Read the target code and clarify the intended UI. Save taste and direction for the loop.", "when": "At the start of a standalone refine task. Before unattended checking and fixing begins.", "how": "Ask at most ten questions. Write the agreed direction into the taste file.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-brief", "sublabel": "Agree what good means"}, {"id": "refine-check", "label": "Check the UI", "kind": "step", "what": "Use fresh checkers to identify UI problems. Rank typed findings before a fix.", "when": "At the start of each refinement round. Check the chosen page or component.", "how": "Capture screenshots and run critique or audit. Route typed findings to the appropriate fix verbs.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-check", "sublabel": "Rank typed problems"}, {"id": "refine-fix", "label": "Fix by routed verbs", "kind": "step", "what": "Apply the Impeccable verbs matched to the findings. Run polish last.", "when": "After checkers have ranked the problems. Use a fresh fixer for the round.", "how": "Chain the verbs in their prescribed order. Keep additive motion within the brief’s permission.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-fix", "sublabel": "Polish comes last"}, {"id": "refine-review", "label": "Review each fix", "kind": "step", "what": "Grade every fix with a finish reviewer. Record or revert each round.", "when": "After the round’s fixer completes. Run five rounds by default unless a stop condition fires.", "how": "Write the outcome to the refine ledger. Stop after two clean checks, two reverted rounds or a dead agent.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-review", "sublabel": "Default: 5 rounds"}, {"id": "refine-pr", "label": "Draft the PR", "kind": "step", "what": "Create the final draft PR. Include a Before | After evidence table.", "when": "When the standalone refinement loop finishes. After fixes have received their finish review.", "how": "Use the PR body marker blocks. Follow the writing standard with humanizer.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/ui-refine-loop/scripts/pr-shots.sh"], "opensView": "refine-pr", "sublabel": "Before | After evidence"}], "mainSteps": true, "lanes": false, "layout": {"ui-refine-loop": [0, 0], "refine-brief": [1, 0], "refine-check": [2, 0], "refine-fix": [3, 0], "refine-review": [4, 0], "refine-pr": [5, 0], "grilling": [1, 1], "impeccable": [2, 1], "verbs-group": [3, 1], "humanizer": [4, 1]}, "nodeOverrides": {"ui-refine-loop": {"label": "Refine a UI", "verbs": [], "sublabel": "Page or component", "opensView": "refine-brief"}, "grilling": {"verbs": []}, "impeccable": {"verbs": []}, "verbs-group": {"verbs": []}, "humanizer": {"verbs": []}}, "stepIds": ["ui-refine-loop", "refine-brief", "refine-check", "refine-fix", "refine-review", "refine-pr"], "containers": [{"id": "refine-family", "label": "/ui-refine-loop · standalone refinement", "nodeIds": ["ui-refine-loop", "refine-pr"]}, {"id": "refine-brief-family", "parent": "refine-family", "label": "Direction · tools", "nodeIds": ["refine-brief", "grilling"]}, {"id": "refine-check-family", "parent": "refine-family", "label": "Check · tools", "nodeIds": ["refine-check", "impeccable"]}, {"id": "refine-fix-family", "parent": "refine-family", "label": "Fix · tools", "nodeIds": ["refine-fix", "verbs-group"]}, {"id": "refine-review-family", "parent": "refine-family", "label": "Review · tools", "nodeIds": ["refine-review", "humanizer"]}]}, {"id": "impeccable-verbs", "parent": "ui-refine-loop", "title": "impeccable fix verbs · routing", "caption": "Chain order: distill/extract, then layout/adapt, then typeset/colorize/quieter/bolder, then clarify/harden/onboard, then animate/delight/optimize, and polish last.", "nodeIds": ["verbs-group", "v-distill", "v-extract", "v-layout", "v-adapt", "v-typeset", "v-colorize", "v-quieter", "v-bolder", "v-clarify", "v-harden", "v-onboard", "late-verbs", "v-polish"], "edges": ["iv-v-distill", "iv-v-extract", "iv-v-layout", "iv-v-adapt", "iv-v-typeset", "iv-v-colorize", "iv-v-quieter", "iv-v-bolder", "iv-v-clarify", "iv-v-harden", "iv-v-onboard", "iv-late-verbs", "u-verbs-polish"]}, {"id": "late-verbs", "parent": "impeccable-verbs", "title": "motion + perf verbs", "caption": "The last tier before polish; animate and delight are additive and need the brief's go-ahead.", "nodeIds": ["late-verbs", "v-animate", "v-delight", "v-optimize", "v-polish"], "edges": ["lv-animate", "lv-delight", "lv-optimize", "lv-del-anim", "lv-polish"]}, {"id": "impeccable", "parent": "ui-refine-loop", "title": "impeccable · how its commands connect", "caption": "From the Impeccable command table and diagrams/impeccable/commands.json; the loop never runs shape, live or overdrive.", "nodeIds": ["impeccable", "v-init", "v-document", "v-shape", "v-critique", "v-audit", "v-harden", "v-optimize", "v-polish", "v-live", "v-overdrive", "verbs-group"], "edges": ["im-init", "im-critique", "im-audit", "im-shape", "im-live", "im-overdrive", "im-verbs"]}, {"id": "visual", "parent": "root", "title": "/visual · one page", "caption": "Triggers no other skill; one helper script does detection, git facts and rendering.", "nodeIds": ["visual", "visual-py", "base-branch"], "edges": ["vi-py", "vi-py-base"], "layout": {"visual": [0, 0], "visual-py": [1, 0], "base-branch": [2, 2]}}, {"id": "hooks", "parent": "root", "title": "guard hooks · events and matchers", "caption": "Four guards and cleanup-wt are on by default; the push guard is opt-in; the eval gate and readme sync are dev-only.", "nodeIds": ["hooks", "guard-worktree-path", "guard-delete-outside", "guard-secrets", "guard-key-literals", "guard-protected-push", "cleanup-wt", "gate-skill-evals", "readme-sync"], "edges": ["h-wt", "h-del", "h-sec", "h-key", "h-session", "h-push", "h-gate", "h-readme"], "layout": {"hooks": [0, 2], "guard-worktree-path": [0, 7], "guard-delete-outside": [0, 3], "guard-secrets": [0, 0], "guard-key-literals": [0, 4], "guard-protected-push": [0, 5], "cleanup-wt": [0, 6], "gate-skill-evals": [1, 0], "readme-sync": [1, 1]}}, {"id": "tdd", "parent": "super-build", "title": "tdd · discipline", "caption": "tdd consults, it does not run sessions.", "nodeIds": ["tdd", "codebase-design", "code-review"], "edges": ["tdd-design", "tdd-cr"], "layout": {"tdd": [0, 0], "codebase-design": [1, 0], "code-review": [1, 2]}}, {"id": "tdd-v2", "parent": "super-qa", "title": "tdd-v2 · the testing ladder", "caption": "tdd-v2 owns the rung; tdd owns the loop.", "nodeIds": ["tdd-v2", "tdd"], "edges": ["tddv2-tdd"], "layout": {"tdd-v2": [0, 0], "tdd": [1, 0]}}, {"id": "implement", "parent": "super-build", "title": "implement · build then review", "caption": "EricOS local override of the mattpocock skill.", "nodeIds": ["implement", "tdd-v2", "tdd", "code-review"], "edges": ["impl-tddv2", "impl-tdd", "impl-cr"]}, {"id": "code-review", "parent": "super-build", "title": "code-review · two axes", "caption": "Standards and Spec run as parallel sub-agents and are reported side by side.", "nodeIds": ["code-review", "setup-matt-pocock-skills"], "edges": ["cr-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"code-review": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "diagnosing-bugs", "parent": "super-build", "title": "diagnosing-bugs · six phases", "caption": "Feedback loop, reproduce, hypothesise, instrument, fix + regression test, cleanup + post-mortem.", "nodeIds": ["diagnosing-bugs", "improve-codebase-architecture"], "edges": ["db-ica"], "layout": {"diagnosing-bugs": [0, 0], "improve-codebase-architecture": [1, 0]}}, {"id": "improve-codebase-architecture", "parent": "super-collect", "title": "improve-codebase-architecture", "caption": "super-collect's finder uses only the findings: no HTML report, no grilling.", "nodeIds": ["improve-codebase-architecture", "codebase-design", "grilling", "domain-modeling"], "edges": ["ica-design", "ica-grill", "ica-dm"]}, {"id": "ask-matt", "parent": "super-build", "title": "ask-matt · idea to ship", "caption": "The router's main flow and on-ramps; codebase-design is the other vocabulary underneath.", "nodeIds": ["ask-matt", "grill-with-docs", "handoff", "prototype", "to-spec", "to-tickets", "implement", "tdd", "code-review", "triage", "diagnosing-bugs", "wayfinder", "improve-codebase-architecture", "domain-modeling"], "edges": ["am-grill-with-docs", "am-handoff", "am-prototype", "am-to-spec", "am-to-tickets", "am-implement", "am-tdd", "am-code-review", "am-triage", "am-diagnosing-bugs", "am-wayfinder", "am-improve-codebase-architecture", "am-domain-modeling"]}, {"id": "grill-with-docs", "parent": "ask-matt", "title": "grill-with-docs", "caption": "The grilling primitive plus a paper trail.", "nodeIds": ["grill-with-docs", "grilling", "domain-modeling"], "edges": ["gwd-grill", "gwd-dm"], "layout": {"grill-with-docs": [0, 0], "grilling": [1, 0], "domain-modeling": [1, 2]}}, {"id": "to-spec", "parent": "ask-matt", "title": "to-spec", "caption": "Synthesis only, no interview.", "nodeIds": ["to-spec", "setup-matt-pocock-skills"], "edges": ["ts-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"to-spec": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "to-tickets", "parent": "ask-matt", "title": "to-tickets", "caption": "Tracer-bullet tickets with blocking edges.", "nodeIds": ["to-tickets", "setup-matt-pocock-skills"], "edges": ["tt-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"to-tickets": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "triage", "parent": "ask-matt", "title": "triage · role state machine", "caption": "Only for issues you did not create.", "nodeIds": ["triage", "grilling", "domain-modeling", "setup-matt-pocock-skills"], "edges": ["tr-grill", "tr-dm", "tr-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}}, {"id": "wayfinder", "parent": "ask-matt", "title": "wayfinder · decision map", "caption": "Produces decisions, not deliverables; hands off to to-spec.", "nodeIds": ["wayfinder", "grilling", "domain-modeling", "prototype", "setup-matt-pocock-skills"], "edges": ["wf-grill", "wf-dm", "wf-proto", "wf-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}}, {"id": "sb-onboard", "parent": "super-board", "title": "/super-board onboard · setup", "caption": "Eight questions, grouped into five phases. Answers save as you go; files change once at the final “Write everything” step.", "nodeIds": ["sb-onboard", "onboard-checks", "onboard-project", "onboard-policies", "onboard-sources", "onboard-write"], "edges": [{"from": "sb-onboard", "to": "onboard-checks", "label": ""}, {"from": "onboard-checks", "to": "onboard-project", "label": ""}, {"from": "onboard-project", "to": "onboard-policies", "label": ""}, {"from": "onboard-policies", "to": "onboard-sources", "label": ""}, {"from": "onboard-sources", "to": "onboard-write", "label": ""}], "render": "process", "nodes": [{"id": "onboard-checks", "label": "Check prerequisites", "kind": "step", "what": "Check required tools and GitHub access. Repair missing installation prerequisites.", "when": "At the first Checks and GitHub setup questions. Re-run onboard to repair an existing setup.", "how": "Run the setup helper for must-haves. Save answers as each question completes.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-checks", "sublabel": "Checks · GitHub"}, {"id": "onboard-project", "label": "Choose board + branch", "kind": "step", "what": "Choose the GitHub Project board. Choose the repository’s base branch.", "when": "During the Board and Branch questions. After required tools and GitHub access are ready.", "how": "Record the board and branch in the saved answers. Write the config only after the final review.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-project", "sublabel": "Board · Branch"}, {"id": "onboard-policies", "label": "Set standards + policy", "kind": "step", "what": "Set AGENTS.md standards and merge policies. Choose whether to protect base-branch pushes.", "when": "During the AGENTS.md and Policies questions. Before the final write of repository files.", "how": "Generate the standards and hook settings. Enable the protected-push guard only when chosen.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-policies", "sublabel": "AGENTS.md · Policies"}, {"id": "onboard-sources", "label": "Choose bug sources", "kind": "step", "what": "Enable built-in collection sources. Add any custom source fetchers.", "when": "During the Bug sources setup question. After standards and policies are selected.", "how": "Save source choices in the collect config. Review all answers before writing files.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-collect/SKILL.md"], "opensView": "onboard-sources", "sublabel": "Bug sources"}, {"id": "onboard-write", "label": "Review + write once", "kind": "step", "what": "Review all saved setup answers. Write repository files once at step eight.", "when": "When the owner chooses “Write everything”. After all setup questions are complete.", "how": "Apply the setup and config writes together. End by naming /super-board lint as the next command.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/onboard.md", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-write", "sublabel": "Review · then lint"}], "mainSteps": true, "lanes": false, "layout": {"sb-onboard": [0, 0], "onboard-checks": [1, 0], "onboard-project": [2, 0], "onboard-policies": [3, 0], "onboard-sources": [4, 0], "onboard-write": [5, 0]}, "nodeOverrides": {"sb-onboard": {"label": "Onboard", "sublabel": "New or existing project", "opensView": "onboard-checks"}}}, {"id": "install", "parent": "root", "title": "install · get.sh, plugin, install.sh", "caption": "Three ways in: the one-line get.sh, the plugin marketplace, or ./install.sh from a checkout. Onboard repairs whatever is missing.", "nodeIds": ["get-sh", "plugin-mkt", "install-sh", "upgrade-json", "setup-py", "sb-onboard", "settings-py", "claude-settings", "hooks"], "edges": ["get-install", "plugin-onboard", "install-upgrade", "upgrade-setup", "onb-setup", "setup-install", "install-settings", "settings-write", "r-install-hooks"], "nodeOverrides": {"plugin-mkt": {"label": "plugin marketplace install"}}, "layout": {"get-sh": [0, 1], "plugin-mkt": [0, 0], "install-sh": [1, 1], "sb-onboard": [1, 0], "upgrade-json": [2, 2], "settings-py": [2, 5], "hooks": [2, 0], "setup-py": [3, 1], "claude-settings": [3, 3]}}, {"id": "run-start", "parent": "super-board-run", "title": "Run trigger · planner and guards", "caption": "", "nodeIds": ["sb-run", "wave-plan", "run-manifest", "policy-usage-pause"], "edges": [{"from": "sb-run", "to": "wave-plan", "label": "plan"}, {"from": "sb-run", "to": "run-manifest", "label": "record"}, {"from": "sb-run", "to": "policy-usage-pause", "label": "guard"}], "node": "sb-run", "nodes": [{"id": "policy-usage-pause", "label": "Usage pause", "kind": "step", "what": "Pause when the rate or usage guard requires it. Report the reset time and remaining cards.", "when": "Before the planner at the start of a wave. Resume with /super-board run.", "how": "Check the rate guard and usage window. Halt on repeated zero progress, a high block rate or an explicit stop.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run-workflow.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "opensView": "usage-pause"}], "nodeOverrides": {"wave-plan": {"label": "wave planner"}}}, {"id": "usage-pause", "parent": "run-start", "title": "Usage pause · halt and resume", "caption": "", "nodeIds": ["policy-usage-pause", "sb-run", "sb-stop"], "edges": [{"from": "policy-usage-pause", "to": "sb-stop", "label": "halt"}, {"from": "policy-usage-pause", "to": "sb-run", "label": "resume"}], "node": "policy-usage-pause", "layout": {"policy-usage-pause": [0, 0], "sb-stop": [1, 0], "sb-run": [1, 2]}}, {"id": "run-classify", "parent": "super-board-run", "title": "Classifier · labels, planner and state", "caption": "", "nodeIds": ["run-classify", "wave-js", "wave-plan", "gh-board", "sb-config"], "edges": [{"from": "run-classify", "to": "wave-js", "label": "label routing"}, {"from": "run-classify", "to": "wave-plan", "label": "eligible cards"}, {"from": "run-classify", "to": "gh-board", "label": "board state"}, {"from": "run-classify", "to": "sb-config", "label": "worker tier"}], "node": "run-classify", "nodeOverrides": {"wave-plan": {"label": "wave planner"}}}, {"id": "run-preflight", "parent": "super-board-run", "title": "Pre-flight · readiness and size", "caption": "", "nodeIds": ["run-preflight", "preflight", "sb-lint", "policy-size-cap"], "edges": [{"from": "run-preflight", "to": "preflight", "label": "mechanical checks"}, {"from": "run-preflight", "to": "sb-lint", "label": "readiness"}, {"from": "run-preflight", "to": "policy-size-cap", "label": "size check"}], "node": "run-preflight", "nodes": [{"id": "policy-size-cap", "label": "400-line cap", "kind": "step", "what": "Keep each PR below 400 changed lines. Split a card that is too large.", "when": "During lint and pre-flight readiness checks. Recheck during Build and at the merge gate.", "how": "The Builder stops and proposes a /to-tickets split. Merge policy escalates a diff over auto_max_lines.", "source": ["https://github.com/EricTechPro/super-board/blob/main/skills/super-build/SKILL.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-build/references/decision-policy.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-build/references/worker-preamble.md", "https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/run.md"], "opensView": "size-cap"}], "nodeOverrides": {"preflight": {"label": "pre-flight script"}}}, {"id": "size-cap", "parent": "run-preflight", "title": "400-line cap · split before building", "caption": "", "nodeIds": ["policy-size-cap", "super-build", "to-tickets", "merge-gate"], "edges": [{"from": "policy-size-cap", "to": "super-build", "label": "stop if too big"}, {"from": "policy-size-cap", "to": "to-tickets", "label": "split the card"}, {"from": "policy-size-cap", "to": "merge-gate", "label": "recheck diff"}], "node": "policy-size-cap", "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "run-lanes", "parent": "super-board-run", "title": "Delegate · Build → QA → Review", "caption": "Each card enters the lane selected by its label. Review gets a fresh context.", "nodeIds": ["run-delegate", "super-build", "super-qa", "super-review"], "edges": [{"from": "run-delegate", "to": "super-build", "label": "bug / feature"}, {"from": "run-delegate", "to": "super-qa", "label": "qa skips Build"}, "r-build-qa", "r-qa-review"], "node": "run-delegate", "lanes": [{"title": "Build", "nodeIds": ["super-build"]}, {"title": "QA", "nodeIds": ["super-qa"]}, {"title": "Review", "nodeIds": ["super-review"]}], "layout": {"run-delegate": [0, 0], "super-build": [1, 2], "super-qa": [2, 0], "super-review": [3, 0]}}, {"id": "merge-gate", "parent": "super-board-run", "title": "Merge gate · proof, policy and human handoff", "caption": "", "nodeIds": ["merge-gate", "policy-merge", "needs-you", "cleanup-wt", "base-branch", "guard-protected-push"], "edges": [{"from": "merge-gate", "to": "policy-merge", "label": "who may merge?"}, "gate-needsyou", "gate-cleanup", "gate-base", {"from": "merge-gate", "to": "guard-protected-push", "label": "protect base"}], "node": "merge-gate", "nodes": [{"id": "policy-merge", "label": "Merge policy", "kind": "step", "what": "Decide whether the robot can merge. Route sensitive changes and human steps to needs-you.", "when": "After Review passes. Decide inside the atomic merge lock.", "how": "Exit 7 for money, auth, destructive schema or excessive size. Exit 8 for a disallowed migration or declared human step.", "source": ["https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/EricTechPro/super-board/blob/main/scripts/super-board-merge-policy.py"], "opensView": "merge-policy"}], "lanes": [{"title": "Policy", "nodeIds": ["policy-merge", "needs-you", "guard-protected-push"]}, {"title": "Finish", "nodeIds": ["cleanup-wt", "base-branch"]}], "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "merge-policy", "parent": "merge-gate", "title": "Merge policy · automatic or human", "caption": "", "nodeIds": ["policy-merge", "policy-size-cap", "needs-you"], "edges": [{"from": "policy-merge", "to": "policy-size-cap", "label": "diff limit"}, {"from": "policy-merge", "to": "needs-you", "label": "human-only step"}], "node": "policy-merge", "layout": {"policy-merge": [0, 1], "policy-size-cap": [1, 0], "needs-you": [1, 1]}}, {"id": "needs-you", "parent": "merge-gate", "title": "Needs you · human handoff and resume", "caption": "", "nodeIds": ["needs-you", "wave-plan", "super-review"], "edges": ["needsyou-plan", {"from": "needs-you", "to": "super-review", "label": "done → re-review"}], "node": "needs-you", "nodeOverrides": {"wave-plan": {"label": "wave planner"}}, "layout": {"needs-you": [0, 0], "wave-plan": [1, 0], "super-review": [1, 2]}}, {"id": "guard-protected-push", "parent": "merge-gate", "title": "Protected push · opt-in base guard", "caption": "", "nodeIds": ["guard-protected-push", "sb-onboard", "install-sh", "claude-settings"], "edges": [{"from": "guard-protected-push", "to": "sb-onboard", "label": "Policies yes"}, {"from": "guard-protected-push", "to": "install-sh", "label": "--protect-main"}, {"from": "guard-protected-push", "to": "claude-settings", "label": "PreToolUse Bash"}], "node": "guard-protected-push"}, {"id": "run-done", "parent": "super-board-run", "title": "Done · cleanup and reconciliation", "caption": "", "nodeIds": ["run-done", "cleanup-wt", "base-branch", "run-manifest", "gh-board"], "edges": [{"from": "run-done", "to": "cleanup-wt", "label": "remove worktree"}, {"from": "run-done", "to": "base-branch", "label": "merged head"}, {"from": "run-done", "to": "run-manifest", "label": "reconcile"}, {"from": "run-done", "to": "gh-board", "label": "update cards"}], "node": "run-done"}, {"id": "onboard-checks", "parent": "sb-onboard", "title": "Prerequisites · repair and install", "caption": "", "nodeIds": ["onboard-checks", "setup-py", "install-sh", "env-check", "onboard-answers"], "edges": [{"from": "onboard-checks", "to": "setup-py", "label": "repair"}, {"from": "onboard-checks", "to": "install-sh", "label": "install"}, {"from": "onboard-checks", "to": "env-check", "label": "tools + auth"}, {"from": "onboard-checks", "to": "onboard-answers", "label": "save answers"}], "node": "onboard-checks", "nodeOverrides": {"env-check": {"label": "environment check"}}}, {"id": "onboard-project", "parent": "sb-onboard", "title": "Project · board, branch and config", "caption": "", "nodeIds": ["onboard-project", "gh-board", "base-branch", "sb-config"], "edges": [{"from": "onboard-project", "to": "gh-board", "label": "choose board"}, {"from": "onboard-project", "to": "base-branch", "label": "choose base"}, {"from": "onboard-project", "to": "sb-config", "label": "save config"}], "node": "onboard-project"}, {"id": "onboard-policies", "parent": "sb-onboard", "title": "Standards + policies · files and guards", "caption": "", "nodeIds": ["onboard-policies", "agents-md-py", "agents-file", "settings-py", "claude-settings", "guard-protected-push", "policy-merge"], "edges": [{"from": "onboard-policies", "to": "agents-md-py", "label": "generate standards"}, {"from": "onboard-policies", "to": "agents-file", "label": "repo standards"}, {"from": "onboard-policies", "to": "settings-py", "label": "write settings"}, {"from": "onboard-policies", "to": "claude-settings", "label": "hook settings"}, {"from": "onboard-policies", "to": "guard-protected-push", "label": "opt-in guard"}, {"from": "onboard-policies", "to": "policy-merge", "label": "merge rules"}], "node": "onboard-policies", "nodeOverrides": {"agents-md-py": {"label": "standards writer"}}}, {"id": "onboard-sources", "parent": "sb-onboard", "title": "Sources · built-in and custom", "caption": "", "nodeIds": ["onboard-sources", "super-collect", "collect-custom", "sb-config"], "edges": [{"from": "onboard-sources", "to": "super-collect", "label": "five built-ins"}, {"from": "onboard-sources", "to": "collect-custom", "label": "custom fetcher"}, {"from": "onboard-sources", "to": "sb-config", "label": "enabled sources"}], "node": "onboard-sources"}, {"id": "onboard-write", "parent": "sb-onboard", "title": "Review · saved answers and final write", "caption": "", "nodeIds": ["onboard-write", "onboard-answers", "setup-py", "sb-config", "sb-lint"], "edges": [{"from": "onboard-write", "to": "onboard-answers", "label": "review answers"}, {"from": "onboard-write", "to": "setup-py", "label": "write everything"}, {"from": "onboard-write", "to": "sb-config", "label": "save once"}, {"from": "onboard-write", "to": "sb-lint", "label": "next command"}], "node": "onboard-write"}, {"id": "collect-sources", "parent": "super-collect", "title": "Fetch · source adapters", "caption": "", "nodeIds": ["collect-fetch", "collect-sentry", "collect-posthog", "gh-issues", "collect-prs", "improve-codebase-architecture", "collect-custom"], "edges": [{"from": "collect-fetch", "to": "collect-sentry", "label": "sentry"}, {"from": "collect-fetch", "to": "collect-posthog", "label": "posthog"}, {"from": "collect-fetch", "to": "gh-issues", "label": "github"}, {"from": "collect-fetch", "to": "collect-prs", "label": "prs"}, {"from": "collect-fetch", "to": "improve-codebase-architecture", "label": "architecture"}, {"from": "collect-fetch", "to": "collect-custom", "label": "custom"}], "node": "collect-fetch"}, {"id": "collect-verify", "parent": "super-collect", "title": "Verify · a fresh pass for every candidate", "caption": "", "nodeIds": ["collect-verify", "codebase-design", "ponytail-audit", "collect-file"], "edges": [{"from": "collect-verify", "to": "codebase-design", "label": "architecture vocabulary"}, {"from": "collect-verify", "to": "ponytail-audit", "label": "audit findings"}, {"from": "collect-verify", "to": "collect-file", "label": "file / needs-triage"}], "node": "collect-verify"}, {"id": "collect-confirm", "parent": "super-collect", "title": "Confirm · dry-run and enabled sources", "caption": "", "nodeIds": ["collect-confirm", "sb-config", "collect-file"], "edges": [{"from": "collect-confirm", "to": "sb-config", "label": "enabled sources"}, {"from": "collect-confirm", "to": "collect-file", "label": "confirm → --yes"}], "node": "collect-confirm", "layout": {"collect-confirm": [0, 0], "collect-file": [1, 0], "sb-config": [1, 2]}}, {"id": "collect-submit", "parent": "super-collect", "title": "File · one entry point and dedupe", "caption": "", "nodeIds": ["collect-submit", "collect-file", "file-bug", "file-refactor", "gh-board"], "edges": [{"from": "collect-submit", "to": "collect-file", "label": "single entry point"}, {"from": "collect-submit", "to": "file-bug", "label": "bug / feature / fix"}, {"from": "collect-submit", "to": "file-refactor", "label": "refactor"}, {"from": "collect-submit", "to": "gh-board", "label": "Backlog"}], "node": "collect-submit"}, {"id": "refine-brief", "parent": "ui-refine-loop", "title": "Direction · brief and taste", "caption": "", "nodeIds": ["refine-brief", "grilling", "taste-file", "sb-config"], "edges": [{"from": "refine-brief", "to": "grilling", "label": "at most 10 questions"}, {"from": "refine-brief", "to": "taste-file", "label": "save direction"}, {"from": "refine-brief", "to": "sb-config", "label": "refine settings"}], "node": "refine-brief"}, {"id": "refine-check", "parent": "ui-refine-loop", "title": "Check · screenshot, critique and audit", "caption": "", "nodeIds": ["refine-check", "shoot", "v-critique", "imp-detect", "v-audit", "impeccable"], "edges": [{"from": "refine-check", "to": "shoot", "label": "screenshots"}, {"from": "refine-check", "to": "v-critique", "label": "design problems"}, {"from": "refine-check", "to": "imp-detect", "label": "typed checker"}, {"from": "refine-check", "to": "v-audit", "label": "functional audit"}, {"from": "refine-check", "to": "impeccable", "label": "command reference"}], "node": "refine-check"}, {"id": "refine-fix", "parent": "ui-refine-loop", "title": "Fix · routed verbs, polish last", "caption": "", "nodeIds": ["refine-fix", "verbs-group", "v-polish"], "edges": [{"from": "refine-fix", "to": "verbs-group", "label": "route by problem"}, {"from": "verbs-group", "to": "v-polish", "label": "last"}], "node": "refine-fix", "layout": {"refine-fix": [0, 0], "verbs-group": [1, 0], "v-polish": [2, 0]}}, {"id": "refine-review", "parent": "ui-refine-loop", "title": "Review · ledger and finish standard", "caption": "", "nodeIds": ["refine-review", "refine-ledger", "humanizer"], "edges": [{"from": "refine-review", "to": "refine-ledger", "label": "grade / record / revert"}, {"from": "refine-review", "to": "humanizer", "label": "writing standard"}], "node": "refine-review", "layout": {"refine-review": [0, 0], "humanizer": [1, 0], "refine-ledger": [1, 2]}}, {"id": "refine-pr", "parent": "ui-refine-loop", "title": "Draft PR · evidence and marker blocks", "caption": "", "nodeIds": ["refine-pr", "draft-pr", "pr-body", "base-branch"], "edges": [{"from": "refine-pr", "to": "draft-pr", "label": "Before | After"}, {"from": "refine-pr", "to": "pr-body", "label": "marker blocks"}, {"from": "refine-pr", "to": "base-branch", "label": "standalone branch"}], "node": "refine-pr"}, {"id": "hook-settings", "parent": "hooks", "title": "Hook installation · settings and environment", "caption": "Install writes hook settings; onboard repairs installation. Merge policy has its own drill-down.", "nodeIds": ["install-sh", "settings-py", "claude-settings", "env-check", "merge-gate"], "edges": ["install-settings", "settings-write"], "nodeOverrides": {"env-check": {"label": "environment check"}, "merge-gate": {"label": "merge gate script"}}, "layout": {"install-sh": [0, 0], "env-check": [0, 1], "merge-gate": [0, 2], "settings-py": [1, 0], "claude-settings": [2, 3]}}, {"id": "sb-status", "parent": "super-board", "title": "/super-board status", "caption": "Inspect active work, lane outcomes and the dispatcher status without starting a worker.", "nodeIds": ["sb-status"], "edges": [], "layout": {"sb-status": [0, 0]}}, {"id": "sb-stop", "parent": "super-board", "title": "/super-board stop", "caption": "Halt the active dispatcher and report what was stopped.", "nodeIds": ["sb-stop"], "edges": [], "layout": {"sb-stop": [0, 0]}}, {"id": "git-sync", "parent": "root", "title": "/git-sync · commit, pull, push", "caption": "Standalone; no lane runs it. Merges, never rebases, and never force-pushes.", "nodeIds": ["git-sync", "base-branch", "resolving-merge-conflicts", "guard-protected-push"], "edges": ["gs-base", "gs-conflict", "gs-push"]}], "notes": ["Refreshed to super-board v3.0.0 (feat/sb-cleanup @ b67241e1, 28 commits after cd199b2d). Source paths are repo-root-relative.", "Board: seven columns, no Skipped (a dropped card is closed as not planned → Done with 🤷). Labels qa · bug · feature route cards; qa skips Building; the classifier adds feature or bug, never qa. The per-board `variant` is gone and a `qa-only` config is refused with exit 65 until onboard upgrades it.", "Onboarding is an 8-step wizard (Checks · GitHub · Board · Branch · AGENTS.md · Policies · Bug sources · Review) backed by super-board-setup.py (check, fix, migrate-config, names, branch, board-rank, board-migrate). New view sb-onboard; its steps are edge labels, not nodes.", "Merge policy and DB migrations live in the merge gate (super-board-merge-policy.py): money, auth, destructive schema or a diff over auto_max_lines (400 changed lines, lockfiles/generated/snapshots/migration SQL excluded) exits 7; a migration outside allowed_envs, a failed migrate or a declared human step exits 8. Both park the card in Blocked with the 🙋 checklist and the needs-you label, with no extra column; `done` sends it back through the planner's resume list.", "Builder pre-flight (super-board-preflight.sh, a Pre-flight phase in super-board-wave.js, batches of 5) checks already done / in progress / file overlap / unclear / too big before any card is built. Lint has 18 criteria now: 15 = too big (split via /to-tickets), 16–18 = ticket format.", "Writing standard (references/writing-standard.md): commits `<emoji> [type] scope: subject` + bullets, tickets Problem · Context · Fix · AC · Risk · Blocked by, PR bodies in marker blocks rewritten per lane with super-board-pr-body.sh, comments `[role] [label] status`, prose through humanizer when installed. That is why every lane view now shows pr-body and humanizer.", "super-collect gained custom sources (collect_custom.py: http, cli, mcp) added in onboard's \"➕ Add another source\", with fingerprint `custom|<name>|<key>` and the same verifier and filer.", "Install: get.sh one-liner, a plugin marketplace (skills only; onboard adds hooks, scripts and workflows), install.sh with grouped output and an upgrade record, and super-board-settings.py for hook and allow-line merges. There is a new install view under root. env-check (key names only) is allowed through guard-secrets. The AGENTS.md helper is super-board-agents-md.py.", "Added nodes: preflight, pr-body, needs-you, setup-py, agents-md-py, agents-file, settings-py, env-check, collect-custom, get-sh, plugin-mkt, onboard-answers, upgrade-json. Added views: sb-onboard, install. Removed edges: sb-onb-push (now settings-push in sb-onboard), h-install and h-ships (now install-sh → settings-py and install-sh → hooks). Nothing was renamed.", "Also since 88c27812: super-review truth-check sub-agents get a fixed verbatim brief (Over-engineering never blocks), and status lists columns in board order with Backlog. Disagreement: the coordinator listed 'labels qa/bug/feature routing'. That matches, with one addition: no label is also built (treated as feature).", "Kept as-is but stale in the files: the merge protocol and the wave.js `humanApprovesMerge` arg still mention human_approves_merge, which onboard now migrates into merge_policy. super-qa standalone still files onto the separate Super Ultimate QA board.", "The Builder only proposes a /to-tickets split in a PR comment when a build outgrows the cap; it does not run to-tickets, so there is no super-build → to-tickets edge. lint does dispatch it.", "Unchanged from v2: ui-refine-loop is standalone, now stated in super-review and super-qa as 'file a UI ticket; a human can run /ui-refine-loop'. cleanup-wt still runs at SessionStart and post-merge. qa-test-planner, testing-strategy, vitest and playwright-best-practices are still not installed in EricOS."], "authors": {"EricTechPro": {"name": "Eric Tech", "url": "https://github.com/EricTechPro", "avatar": "data:image/jpeg;base64,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"}, "mattpocock": {"name": "Matt Pocock", "url": "https://github.com/mattpocock", "avatar": "data:image/png;base64,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"}, "DietrichGebert": {"name": "Dietrich Gebert", "url": "https://github.com/DietrichGebert", "avatar": "data:image/png;base64,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"}, "pbakaus": {"name": "Paul Bakaus", "url": "https://github.com/pbakaus", "avatar": "data:image/jpeg;base64,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"}, "blader": {"name": "blader", "url": "https://github.com/blader", "avatar": "data:image/jpeg;base64,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"}, "upstash": {"name": "Upstash", "url": "https://github.com/upstash", "avatar": "data:image/png;base64,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"}, "obra": {"name": "Jesse Vincent (obra/superpowers, inferred)", "url": "https://github.com/obra", "avatar": "data:image/jpeg;base64,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"}, "BuilderIO": {"name": "Builder.io", "url": "https://github.com/BuilderIO", "avatar": "data:image/png;base64,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"}, "tt-a1i": {"name": "tt-a1i (archify)", "url": "https://github.com/tt-a1i", "avatar": "data:image/jpeg;base64,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"}}, "version": "3.0.0", "kind": "map", "source": "diagrams/skill-map.json", "avatarsEmbedded": 9, "meta": {"generated": "2026-10-03T20:20", "project": "super-board", "sourceBase": "https://github.com/EricTechPro/super-board/blob/main/", "root": ""}}</script> +<script id="visual-data" type="application/json">{"title": "super-board skill map", "pack": "_skills/vendor/super-board", "branch": "feat/sb-cleanup @ b67241e1 (v3.0.0)", "sourcesBase": "", "kinds": {"public": "skill or command a user triggers directly", "lane": "board lane skill: started by /super-board run, also runnable standalone", "external": "skill from outside the pack (origin field says where)", "verb": "an Impeccable command", "script": "shell, python, node script or saved Workflow", "hook": "Claude Code hook or guard", "board": "state: GitHub Project, config, ledgers, repo"}, "nodes": [{"id": "super-board", "label": "/super-board", "kind": "public", "what": "The autonomous GitHub-Project pipeline: five verbs (onboard, lint, status, run, stop) take one board shape (Backlog · Ready · Building · QA · Review · Blocked · Done) from empty to drained, with labels qa · bug · feature routing each card.", "when": "Eric types /super-board <verb>, or says \"drain my GitHub project\" or \"stop super-board\"; with no verb it asks which one.", "how": "The session is an orchestrator only: it routes the verb to its reference file, dispatches lane agents, and never does product work itself. Board state is the only state, so `run` is also resume. Every commit, ticket, PR body and comment follows references/writing-standard.md.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/writing-standard.md"], "verbs": ["onboard", "lint", "status", "run", "stop"], "sublabel": "onboard · lint · status · run · stop", "opensView": "super-board", "author": "EricTechPro"}, {"id": "super-collect", "label": "/super-collect", "kind": "public", "what": "Finds problems in one project and files them as verified tickets into its super-board Backlog: five built-in sources plus any custom source added in onboard. It never builds, edits app code, or moves a card to Ready.", "when": "Eric runs /super-collect (all enabled sources) or /super-collect <source…> with sentry, posthog, github, prs, architecture or a custom source's name; optional --since and --yes.", "how": "Fetches each source for the window (default 14 days), sends every candidate to one fresh verifier sub-agent, then files through super-collect-file.sh. Dry-run by default: it shows a plan table and files on confirm.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"], "verbs": ["sentry", "posthog", "github", "prs", "architecture", "custom"], "sublabel": "sentry · posthog · github · prs · architecture · custom", "opensView": "super-collect", "author": "EricTechPro"}, {"id": "ui-refine-loop", "label": "/ui-refine-loop", "kind": "public", "what": "Unattended Impeccable check-then-fix loop on one page or component that ends in a draft PR with a Before | After table. Standalone: no board lane ever starts it.", "when": "Eric runs /ui-refine-loop <route | component | description> [\"what's wrong\"] [--rounds N], or says \"refine loop\" or \"polish this page with impeccable\".", "how": "Reads the target's code, grills Eric (at most 10 questions) into a taste file, then runs the saved ui-refine-loop workflow: each round fresh checkers rank typed problems and a fresh fixer chains Impeccable verbs, polish last. Default 5 rounds; a finish reviewer grades every fix. Commits are `💄 [ui] <slug>: …` and the PR body uses super-board-pr-body.sh's marker blocks.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js"], "verbs": ["<route|component>", "--rounds N"], "sublabel": "grill · check · fix · draft PR", "opensView": "ui-refine-loop", "author": "EricTechPro"}, {"id": "visual", "label": "/visual", "kind": "public", "what": "Turns the current work into one self-contained HTML page: a branch recap, a plan, or a map of a folder or architecture, with diagrams, a file map and annotated code.", "when": "Eric runs /visual, /visual recap [base], /visual plan [file] or /visual <path>; with no argument visual.py detect picks the mode.", "how": "Writes a data.json from git facts or the plan, then visual.py render injects it into an inline template with no build step. It screenshots the page headless to check it, and offers to publish only on a yes.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/visual/SKILL.md"], "verbs": ["recap", "plan", "explore"], "sublabel": "recap · plan · explore", "opensView": "visual", "author": "EricTechPro", "credits": ["BuilderIO", "tt-a1i"]}, {"id": "sb-onboard", "label": "/super-board onboard", "kind": "public", "what": "An 8-step setup wizard (Checks · GitHub · Board · Branch · AGENTS.md · Policies · Bug sources · Review) that installs or repairs what the board needs and writes the config once.", "when": "Eric runs /super-board onboard (or /super-board:super-board onboard after a plugin install), on a new project, after an upgrade from 2.x, or to check and repair an existing setup.", "how": "One AskUserQuestion per step with the recommended option first; must-haves are fixed without asking by super-board-setup.py. Answers save to onboard-answers.json as they come, so a halt resumes, and repo files change only at step 8 after \"Write everything\". It ends by naming /super-board lint.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"], "author": "EricTechPro", "opensView": "sb-onboard"}, {"id": "sb-lint", "label": "/super-board lint", "kind": "public", "what": "Pre-flight readiness check that walks Ready, Building, QA and Review, flags issues that fail any of 18 criteria, proposes a qa/bug/feature label, and dispatches a helper skill per flagged issue.", "when": "Eric runs /super-board lint before a run, typically after /super-collect filed new Backlog cards.", "how": "Criteria 13–18 cover what the loop needs: a parseable `## Blocked by` line, a fake with no follow-up card, too big (over ~400 changed lines or many areas), the ticket sections, a checklist AC, and lettered Context steps. Phase 4 routes each flagged pattern to one skill sub-agent while Eric keeps the pace.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/lint.md"], "opensView": "sb-lint", "author": "EricTechPro"}, {"id": "sb-status", "label": "/super-board status", "kind": "public", "what": "Read-only snapshot of the active config, every column in board order (Backlog included), and in-flight workers.", "when": "Eric runs /super-board status to see where a run stands.", "how": "super-board-status.py reads the board and local in-flight state and prints the columns in the board's own order; it changes nothing.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/status.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-status.py"], "author": "EricTechPro"}, {"id": "sb-run", "label": "/super-board run", "kind": "public", "what": "The autonomous loop: repeated waves of the super-board-wave workflow from this session until the board drains or a halt gate fires. Also the resume command.", "when": "Eric runs /super-board run [--low|--high] [<slug>]; the default worker_backend \"workflow\" stays in-session, \"claude-p\" opts into the legacy headless runner.", "how": "Each wave: rate and usage guard, plan with super-board-wave-plan.sh (which refuses an old `variant: qa-only` config with exit 65), act on sweep/flag/stranded/resume, claim cards by assignee, launch the workflow, reconcile, report. Halts after 3 zero-progress waves, a high block rate, or a stop.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run-workflow.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "verbs": ["--low", "--high"], "opensView": "super-board-run", "author": "EricTechPro"}, {"id": "sb-stop", "label": "/super-board stop", "kind": "public", "what": "Graceful shutdown: stops the wave, posts \"stopped mid-flight\" comments, releases assignee claims, and removes the wave lock so the next run resumes.", "when": "Eric runs /super-board stop or says \"stop the run\" / \"pause the loop\".", "how": "Stops the workflow (or kills the legacy dispatcher via super-board-stop.sh), comments on every in-flight issue and PR, and strips bot_identity assignees. Resume is just `run` again.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/stop.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-stop.sh"], "author": "EricTechPro"}, {"id": "super-build", "label": "super-build", "kind": "lane", "what": "Builder lane: takes a pre-flighted Ready card into its own worktree, makes the smallest safe change test-first under the 400-line PR cap, opens a draft PR and moves the card to QA. It never merges.", "when": "Started by the board: the super-board-wave workflow runs it for Ready cards labelled feature or bug (or unlabelled) once pre-flight says proceed. Also runnable standalone as /super-build (legacy headless claude -p dispatch).", "how": "Follows run.md's Builder lifecycle. An explicit `Skills:` line wins, else the type label picks the chain, always plus ponytail first, verification-before-completion and a code-review of its own diff. Past the size cap mid-build it stops and proposes a /to-tickets split. Commits and PR blocks follow the writing standard via super-board-pr-body.sh.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/references/decision-policy.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/references/worker-preamble.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "opensView": "super-build", "author": "EricTechPro"}, {"id": "super-qa", "label": "super-qa", "kind": "lane", "what": "Tester lane: builds an issue-scoped test plan, runs a test-gap check on the Builder's diff, captures evidence and screenshots, then passes the card to Review or bounces it to Build.", "when": "Started by the board for cards in QA, and straight from Ready for cards labelled qa (they skip Building). Also runnable standalone as /super-qa, a BFS route-crawling bug-bash, or /super-qa <url> for a live site with no repo.", "how": "One observable test per AC plus the test-gap ledger, High gaps written red-first. On a qa card it creates the issue branch itself and files real defects as bug cards. It ticks the PR's ac block, writes visual and history rows with super-board-pr-body.sh, and posts `[qa] [report]` comments with screenshots pinned to a sha.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/references/iteration-preamble.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "opensView": "super-qa", "author": "EricTechPro"}, {"id": "super-review", "label": "super-review", "kind": "lane", "what": "Reviewer lane and standalone PR review: forms its own hypotheses first, remembers prior findings, classes every finding, and merges only through the merge gate.", "when": "Started by the board for cards in Review (always on the session model). Also runnable standalone when Eric says \"review this branch\" or \"is this merge-ready\".", "how": "Thread scan, prior-report round 1, own pass with code-review, codebase-design and ponytail-review, a rerun of the Tester's exact test command, then an adversarial truth-check on non-trivial diffs. One report comment is edited in place every round. A clean review merges through the gate pinned to the reviewed head SHA; exit 7 or 8 parks the card in Blocked with 🙋. Visual problems become a UI ticket, never a ui-refine-loop run. The truth-check sub-agents get a fixed verbatim brief, and Over-engineering is never a Blocker from any of them.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-review/SKILL.md"], "opensView": "super-review", "author": "EricTechPro"}, {"id": "gh-board", "label": "GitHub Project board", "kind": "board", "what": "The configured GitHub Project with seven columns (Backlog, Ready, Building, QA, Review, Blocked, Done) and three routing labels (qa, bug, feature); the only loop state. There is no Skipped column.", "when": "Read and written on every wave, by every lane move, and by /super-collect filing into Backlog.", "how": "Cards move by `gh project item-edit`; assignees act as claim mutexes; PR threads start with their owner lane [builder] / [qa] / [reviewer] plus a label. A card dropped on purpose is closed as not planned and moved to Done with a 🤷 comment.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run-workflow.md"]}, {"id": "sb-config", "label": "super-board config", "kind": "board", "what": "Per-project JSON config: board, base branch, timezone, the seven columns, labels, merge_policy, migrations, worker backend, model tier, truth gate, plus `collect` (sources and custom[]) and `refine` blocks. No `variant` key.", "when": "Written once by onboard at step 8 (and migrated to v3 keys by super-board-setup.py fix); read at the start of every run, collect and ui-refine-loop setup.", "how": "Lives at `.claude/super-board/configs/<slug>.json` with `.claude/super-board/active` pointing at it, validated against config-schema.json.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/config-schema.json"]}, {"id": "base-branch", "label": "repo · base branch", "kind": "board", "what": "The project's git repo and configured base branch (never assumed to be main); a card is Done only when its merge commit is an ancestor of it.", "when": "Changed only by a merge-gate squash-merge; read by /visual and branched from by every worktree.", "how": "Lanes and ui-refine-loop work on their own branches under .worktrees/ or .claude/worktrees/; the opt-in protected-push guard can block direct pushes to it.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-review/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"]}, {"id": "run-manifest", "label": "run manifest", "kind": "board", "what": "Per-run ledger at `docs/super-board/runs/<date>-<slug>.md`, one line per card per wave.", "when": "Appended during each wave's reconcile step.", "how": "Each line records card, lanes run, final status, column and detail: `| #N | <lanesRun> | <finalStatus> | <column> | <detail> |`.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run-workflow.md"]}, {"id": "qa-board", "label": "Super Ultimate QA board", "kind": "board", "what": "Separate GitHub Project (Queue, Testing, Done, Bug, Flaky, Skip) used by standalone /super-qa as its loop state.", "when": "Written when a standalone super-qa iteration finds a red spec; /super-collect bugs and qa-card defects also go through the same filer.", "how": "super-qa-file-bug.sh creates a `source:qa` issue with the evidence body and sets its Status to Bug (Flaky and Skip for the other outcomes).", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/SKILL.md"]}, {"id": "taste-file", "label": "taste + direction file", "kind": "board", "what": "Per-project design taste file (default `docs/design/taste.md`) holding the grill's goal, direction, keep and avoid answers plus taste rules and slop tells.", "when": "Written after the grill and committed as the refine branch's first commit; read first by every checker, fixer and finish reviewer.", "how": "Starts from the neutral references/taste.md when absent; each target gets a `### <target>` block under Direction, with \"you pick\" answers marked (picked).", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/grill.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/taste.md"]}, {"id": "refine-ledger", "label": "refine ledger", "kind": "board", "what": "The only memory carried between refine rounds: one line per check with score /40, before-vs-now, and problem ids.", "when": "Appended by the workflow after every check; written to `<run>/ledger.md` at finish.", "how": "Checkers reuse ledger ids so a problem that survives three checks is called out; stop rules read it (two clean checks, two reverts in a row).", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/ledger.md"]}, {"id": "draft-pr", "label": "refine draft PR", "kind": "board", "what": "The draft PR from `refine/<slug>` against the recorded base branch, with a Before | After table, score line and finish grades.", "when": "Opened once at the end of a ui-refine-loop run; never merged by the loop.", "how": "pr-shots.sh commits round-0 and final shots to `docs/ui-refine/<slug>/` and prints a Before | After table pinned to both shas; the body uses the writing standard's marker blocks (status, problem, solution, ac, history, visual, risk) and is humanized before `gh pr create --draft`.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/scripts/pr-shots.sh"]}, {"id": "gh-issues", "label": "open GitHub issues", "kind": "board", "what": "The repo's open issues that are not yet on the board and carry no `source:*` label.", "when": "Read by the /super-collect github source.", "how": "Fetched with `gh issue list --state open`; real work is adopted onto the board (`--adopt <n>`), never copied into a new issue.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"]}, {"id": "claude-settings", "label": ".claude/settings.json", "kind": "board", "what": "The target project's Claude Code settings, where install.sh merges the guard hook block from settings-snippet.json.", "when": "Written by install.sh (backed up first, never adding a command twice); read by Claude Code at every session.", "how": "Wires PreToolUse, PostToolUse and SessionStart commands to the scripts copied into `.claude/hooks/`; `--protect-main` adds settings-protect-main.json.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/settings-snippet.json", "https://github.com/mnphuc/super-board-gitea/blob/main/hooks/settings-protect-main.json", "https://github.com/mnphuc/super-board-gitea/blob/main/install.sh"]}, {"id": "hooks", "label": "guard hooks", "kind": "hook", "what": "The pack's Claude Code hooks: four default guards, an opt-in push guard, post-merge worktree cleanup, and two dev-only hooks for the pack itself.", "when": "Installed by install.sh unless --no-hooks; each fires on its Claude Code event and matcher.", "how": "Python 3 stdlib scripts that read hook JSON on stdin, print a decision only when they block, and exit 0 on their own errors so a broken guard never stops work.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/README.md"], "opensView": "hooks"}, {"id": "guard-worktree-path", "label": "guard-worktree-path", "kind": "hook", "what": "Denies `git worktree add|move` whose target resolves outside `<repo>/.claude/worktrees/`.", "when": "PreToolUse, matcher Bash, on every shell command.", "how": "Parses the command, honouring `cd X &&` and `git -C X`, resolves the target path, and blocks when it escapes the worktrees folder.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-worktree-path.py"]}, {"id": "guard-secrets", "label": "guard-secrets", "kind": "hook", "what": "Denies reading or piping dotenv files, SSH keys, .npmrc, credentials(.json), service-account JSON and .pem files; .env.example stays readable.", "when": "PreToolUse, matcher Bash|Read|Grep.", "how": "Matches file paths in Read/Grep input and in shell commands against secret-file patterns and blocks the call. One plain call to super-board-env-check.sh (no pipe, chain or redirect) is allowed, since it prints only present / empty / missing.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-secrets.py"]}, {"id": "guard-key-literals", "label": "guard-key-literals", "kind": "hook", "what": "Stops a live-looking API key from being written into a file, and flags one already on disk.", "when": "PreToolUse on Edit|MultiEdit|Write|NotebookEdit|Bash, and PostToolUse on Edit|MultiEdit|Write|NotebookEdit.", "how": "Scans the content being written for key-shaped literals and reports line numbers only, never the value.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-key-literals.py"]}, {"id": "guard-delete-outside", "label": "guard-delete-outside", "kind": "hook", "what": "Denies rm, rmdir, unlink, find -delete / -exec rm and git clean whose target resolves outside $CLAUDE_PROJECT_DIR, and always `/` or `~` itself.", "when": "PreToolUse, matcher Bash.", "how": "Resolves each target (honouring cd, git -C, ~ and $HOME); temp dirs stay allowed, and a path known only at run time is allowed.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-delete-outside.py"]}, {"id": "guard-protected-push", "label": "guard-protected-push", "kind": "hook", "what": "Opt-in guard that denies a git push that would update or delete main, master, any configured base_branch, or a name in SB_PROTECTED_BRANCHES.", "when": "PreToolUse, matcher Bash, only after onboard's Policies yes (step 6) or `./install.sh --protect-main`.", "how": "Catches force pushes, explicit refspecs, --delete, --all/--mirror and a bare push while the base is checked out; feature-branch force pushes stay allowed. SB_ALLOW_PROTECTED_PUSH=1 turns it off for a session.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-protected-push.py", "https://github.com/mnphuc/super-board-gitea/blob/main/hooks/settings-protect-main.json"]}, {"id": "cleanup-wt", "label": "cleanup-wt", "kind": "hook", "what": "Removes worktrees and local branches already merged into a base branch; never deletes unmerged work.", "when": "SessionStart with `--auto --fetch` when a base tip moved since the last session, and after every merge when the merge gate calls it with `--post-merge`.", "how": "Wip-commits a dirty worktree on a merged branch and keeps its branch, never touches bases or its own worktree, and writes a recovery TSV under `<git-common-dir>/cleanup-wt/` before acting.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/cleanup-wt.py", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-gate.sh"]}, {"id": "gate-skill-evals", "label": "gate-skill-evals (dev)", "kind": "hook", "what": "Dev-only Stop hook that blocks ending a session when a skill changed and no `claude plugin eval` result is newer than the change.", "when": "Stop event in the pack's own `.claude/settings.json` (and EricOS if added by hand); never installed into target projects.", "how": "A changed SKILL.md always counts; a changed reference, script or workflow counts when the skill has an eval case. SKILL_EVAL_GATE=off, a running eval or `.claude/eval-gate-ignore` globs stand it down.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/dev/gate-skill-evals.py", "https://github.com/mnphuc/super-board-gitea/blob/main/.claude/settings.json"]}, {"id": "readme-sync", "label": "readme-sync (dev)", "kind": "hook", "what": "Dev-only hooks that keep README.md's skill tables in step with skills/*/SKILL.md and families.json.", "when": "PostToolUse on Edit|Write|MultiEdit in the pack repo, and as a git pre-commit hook when it is symlinked in.", "how": "Runs super-board-readme-sync.py; the pre-commit version stops the commit when README.md had to change so it can be staged.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/.claude/settings.json", "https://github.com/mnphuc/super-board-gitea/blob/main/hooks/pre-commit-readme.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-readme-sync.py"]}, {"id": "wave-plan", "label": "super-board-wave-plan.sh", "kind": "script", "what": "Read-only planner that computes the next wave from board state: cards (each with its lane and labels) plus the sweep, flag, stranded and resume lists.", "when": "Run by the orchestrator at the start of every wave, after the rate and usage guards pass.", "how": "Reads the board and `## Blocked by` dependencies (via super-board-deps.sh); a Ready card labelled qa gets lane qa, every other Ready card lane build. `resume` lists 🙋 cards a human approved with `done`. A `variant: qa-only` config is refused with exit 65.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-wave-plan.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-deps.sh"]}, {"id": "wave-js", "label": "super-board-wave.js", "kind": "script", "what": "Saved Workflow that drains one wave: a Pre-flight phase for cards about to be built, a haiku classify router, then Build, QA and Review lane agents per card.", "when": "Launched by /super-board run with {configPath, cards (with lane and labels), humanApprovesMerge, tier}; a stale `variant` other than full is refused.", "how": "Pre-flights Ready build cards in batches of 5 and never builds a card without a proceed verdict. The classifier keeps a card's qa/bug/feature label and adds feature or bug to unlabelled ones, never qa. A qa card goes Ready → QA. Model ladder by tier and complexity; Review always on the session model.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/workflows/super-board-wave.js"]}, {"id": "merge-gate", "label": "super-board-merge-gate.sh", "kind": "script", "what": "The only path to the base branch: takes an atomic mkdir lock, applies merge_policy, re-proves the branch against the current base inside the lock, runs allowed DB migrations, then squash-merges.", "when": "Called by the Reviewer once a review passes (and human_approves_merge is not set).", "how": "super-board-merge-policy.py decides who merges: money, auth, destructive schema or a diff over auto_max_lines (400 changed lines, lockfiles/generated/snapshots/migration SQL excluded) exits 7; a migration it may not run or a declared human step exits 8. Otherwise it merges with `--match-head-commit` (exit 6 when the head moved) and runs cleanup-wt --post-merge.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-policy.py"]}, {"id": "file-bug", "label": "super-qa-file-bug.sh", "kind": "script", "what": "Files one finding as a GitHub issue with a validated body onto the Super Ultimate QA board.", "when": "Called by standalone super-qa on a red spec, and by super-collect-file.sh for bug, feature and fix tickets.", "how": "Rejects bodies missing the ticket-format sections (Problem · Context · Fix · Acceptance Criteria · Risk, bugs with the folded Evidence table) or holding placeholders; adds type, source, priority and area labels and sets the project Status, falling back through Bug, Ready, Todo, Backlog, Triage.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-qa-file-bug.sh"]}, {"id": "file-refactor", "label": "review-file-refactor.sh", "kind": "script", "what": "Files a deepening opportunity as a `refactor` card, deduped by fingerprint.", "when": "Called by super-review for shape findings that must not block a merge, and by super-collect-file.sh for architecture tickets.", "how": "A body with an `## Acceptance criteria` section goes straight to Ready; otherwise it lands in the holding column for lint. It appends `## Blocked by` when missing.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-review-file-refactor.sh"]}, {"id": "collect-file", "label": "super-collect-file.sh", "kind": "script", "what": "Single filing entry point for /super-collect that routes each verified ticket to the pack's filers.", "when": "Called once per candidate the verifier marked file or needs-triage (dry-run without --yes, real filing with it), or with --adopt <n>.", "how": "bug/feature/fix go to super-qa-file-bug.sh, refactor to super-review-file-refactor.sh, every body in the writing-standard ticket format. It enforces per-source fingerprints (custom `custom|<name>|<key>`), exact-fingerprint dedupe and the board's holding column.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/super-collect-file.sh"]}, {"id": "collect-sentry", "label": "sentry fetcher", "kind": "script", "what": "The sentry source: lists unresolved Sentry issues in the window and pulls event and tag evidence.", "when": "Run when /super-collect includes sentry and the config has a sentry block.", "how": "`collect_sentry.py list --since <w>` calls the Sentry REST API with SENTRY_AUTH_TOKEN from .env; `check <id>` answers still-happening for the verifier. One issue becomes one bug, fp `err|sentry|<id>`.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/collect_sentry.py"]}, {"id": "collect-posthog", "label": "posthog fetcher", "kind": "script", "what": "The posthog source: exceptions, configured failure events, rage and dead clicks, web vitals, surveys, plus tracking gaps.", "when": "Run when /super-collect includes posthog.", "how": "`collect_posthog.py list|events|funnel|check` runs HogQL queries with POSTHOG_PERSONAL_API_KEY; signal groups over the thresholds become bugs, and missing workflow events become `analytics` feature tickets.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/collect_posthog.py"]}, {"id": "collect-prs", "label": "prs fetcher", "kind": "script", "what": "The prs source: merged PRs in the window with their comments, reviews, review threads and flagged super-review reports.", "when": "Run when /super-collect includes prs.", "how": "`collect_prs.py list` runs one paginated GraphQL search; Claude then clusters recurring root causes at a shared boundary into fix, refactor or feature tickets (fp `prs|<boundary>|<cause>`).", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/collect_prs.py"]}, {"id": "shoot", "label": "shoot.mjs", "kind": "script", "what": "Playwright screenshot script for the refine loop: light and dark at 1440 and 390, section crops, and before | after sheets.", "when": "Run for round-0 shots at setup and for AFTER shots at the end of every fix round.", "how": "Writes `<label>-<state>-<desktop|mobile>-<light|dark>.png` grown to the scroll height; `--compare round-0` adds cmp sheets the next checker judges.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/scripts/shoot.mjs"]}, {"id": "imp-detect", "label": "impeccable detect", "kind": "script", "what": "Impeccable's mechanical anti-pattern detector, run over every scope path holding markup or styles.", "when": "Run by the isolated detector sub-agent in every check, alongside the audit.", "how": "Invoked as `scripts/impeccable detect --json` (v4.4+) or `node scripts/detect.mjs --json` (v4.0.x), as found by refine-setup.sh detect; exit 2 means findings, which are checked in source for false positives.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/checker-brief.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/scripts/refine-setup.sh"]}, {"id": "install-sh", "label": "install.sh", "kind": "script", "what": "Installs the pack into a target project: skills, .claude/bin scripts, workflows and the guard hooks, with grouped emoji output.", "when": "Run by get.sh, by super-board-setup.py fix during onboard, or by hand: `./install.sh [--no-hooks] [--protect-main] [target]`.", "how": "Copies hooks/*.py to `.claude/hooks/` (never hooks/dev/) and merges the hook block through super-board-settings.py; `--no-hooks --protect-main` installs only the push guard. It records an older install in `.claude/super-board/upgrade.json` and ends with one next step: /super-board onboard.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/install.sh"], "opensView": "install"}, {"id": "visual-py", "label": "visual.py", "kind": "script", "what": "The /visual helper: detect picks the mode, facts collects git data, render injects data.json into the inline template.", "when": "Run by /visual at every step: detect with no argument, facts in recap mode, render after data.json is written.", "how": "render prints `{out, missingHunks}`; grounded hunks come from git via `hunks[].file + contains`, and output lands in a gitignored `_tmp/<date>-visual/` or `.visual/`.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/visual/scripts/visual.py"]}, {"id": "grilling", "label": "grilling", "kind": "external", "what": "Interview pattern that walks a design tree in rounds: numbered questions, each with a recommended answer, until the frontier is empty.", "when": "Reached by /ui-refine-loop's grill step and by /super-board lint for vague or multi-reading tickets; forbidden inside unattended workers.", "how": "Asks the whole frontier per round and waits; facts come from sub-agents, decisions from the user. ui-refine-loop caps it at 10 questions in waves of 3, then 4.", "source": [".agents/skills/grilling/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "tdd", "label": "tdd", "kind": "external", "what": "Test-driven development discipline: tests at agreed seams through public interfaces, red before green, one vertical slice at a time.", "when": "Reached by super-build for every non-docs ticket, by super-qa when writing High test gaps, and by implement.", "how": "Defines good tests, the anti-patterns (implementation-coupled, tautological, horizontal slicing) and the loop rules; refactoring belongs to the code-review stage.", "source": [".agents/skills/tdd/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "tdd", "author": "mattpocock"}, {"id": "tdd-v2", "label": "tdd-v2", "kind": "external", "what": "The EricOS testing ladder: which rung a test belongs at (unit, isolated render, e2e) and the gate for climbing to the next.", "when": "Reached by super-qa's test-gap check \"where the repo has it\", and by implement as its preferred test skill.", "how": "Building climbs bottom-up; chasing a defect walks down to the first rung that still reproduces. It owns the layer and defers red-green discipline to tdd.", "source": [".agents/skills/tdd-v2/SKILL.md"], "external": true, "origin": "EricOS local skill", "opensView": "tdd-v2", "author": "EricTechPro"}, {"id": "implement", "label": "implement", "kind": "external", "what": "Implements a piece of work from a spec or tickets, test-first, then reviews and commits it.", "when": "Reached by super-build when the issue's type label is feature or ux (implement → tdd → codebase-design).", "how": "Uses tdd-v2 at pre-agreed seams with tdd underneath, runs typecheck and single tests often and the full suite once, then runs code-review before committing.", "source": [".agents/skills/implement/SKILL.md"], "external": true, "origin": "mattpocock-skills (EricOS local override)", "opensView": "implement", "author": "mattpocock"}, {"id": "code-review", "label": "code-review", "kind": "external", "what": "Two-axis review of the diff since a fixed point: Standards (repo rules plus a Fowler smell baseline) and Spec (does it match the issue).", "when": "Reached by super-build once against its own diff before the final commit, by super-review on every card, and by implement and tdd.", "how": "Pins the fixed point (the lanes pass the merge-base so it never asks), runs a Standards and a Spec sub-agent in parallel, and reports them side by side without reranking.", "source": [".agents/skills/code-review/SKILL.md"], "external": true, "origin": "mattpocock-skills (EricOS local override)", "opensView": "code-review", "author": "mattpocock"}, {"id": "diagnosing-bugs", "label": "diagnosing-bugs", "kind": "external", "what": "Diagnosis loop for hard bugs and perf regressions: build a tight red feedback loop, reproduce, hypothesise, instrument, fix with a regression test.", "when": "Reached by super-build for `bug`-labelled tickets, by super-qa as a required dependency, and by lint for bug tickets with no repro.", "how": "Six phases; refuses to theorise before one command goes red on this bug. Its post-mortem hands off to improve-codebase-architecture when no good seam exists.", "source": [".agents/skills/diagnosing-bugs/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "diagnosing-bugs", "author": "mattpocock"}, {"id": "codebase-design", "label": "codebase-design", "kind": "external", "what": "Shared deep-module vocabulary: module, interface, depth, seam, adapter, leverage, locality, and the deletion test.", "when": "Reached by super-build for feature and refactor tickets, by super-review in step 2 and for every deepening opportunity, and by super-collect's architecture finder as a fallback.", "how": "A reference to consult, not a session: no report, no prompts. Its design-it-twice pattern runs parallel sub-agents when an interface needs alternatives.", "source": [".agents/skills/codebase-design/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "ask-matt", "label": "ask-matt", "kind": "external", "what": "Router over the Matt Pocock skills: which flow fits the situation, from idea to ship.", "when": "Reached by super-build and super-qa workers when the right flow is unclear.", "how": "Main flow: grill-with-docs, optional prototype via handoff, to-spec and to-tickets for multi-session work, then implement (driving tdd) and code-review. On-ramps: triage, diagnosing-bugs, wayfinder.", "source": [".agents/skills/ask-matt/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "ask-matt", "author": "mattpocock"}, {"id": "humanizer", "label": "humanizer", "kind": "external", "what": "Strips AI writing tells from a finished draft so it reads like a person wrote it, with Eric Tech plain-words overrides.", "when": "Reached whenever a lane or ui-refine-loop writes prose: the writing standard says ALWAYS run commits, tickets, PR bodies and comments through it when installed.", "how": "Applies the vendored blader/humanizer rule set (32 patterns) as a silent pass; without it the writing standard's plain-words rules apply (short sentences, plain words, no hype).", "source": [".agents/skills/humanizer/SKILL.md", "erictech-skills/skills/humanizer/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/writing-standard.md"], "external": true, "origin": "erictech-skills (vendored blader/humanizer)", "author": "blader"}, {"id": "verification", "label": "verification-before-compl.", "kind": "external", "what": "Evidence before assertions: run the verification command and read its output before claiming work is done, fixed or passing.", "when": "Reached by super-build before its final commit and by super-qa as a required dependency.", "how": "A gate function: identify the proving command, run it fresh, read the full output, and only then state the result.", "source": [".agents/skills/verification-before-completion/SKILL.md"], "external": true, "origin": "EricOS .agents/skills (origin not recorded)", "author": "obra"}, {"id": "context7", "label": "context7 (docs)", "kind": "external", "what": "MCP docs lookup used to read current official documentation for a library or API version.", "when": "Reached by super-build when a ticket touches a third-party API, an upgrade, or auth/billing.", "how": "Builder reads the exact surface and installed major's docs (context7 when available, else vendor docs by web search) and cites them as `Docs:` bullets in the PR's Solution block.", "source": ["~/.claude/plugins/marketplaces/claude-plugins-official/external_plugins/context7/README.md"], "external": true, "origin": "claude-plugins-official (MCP plugin)", "author": "upstash"}, {"id": "resolving-merge-conflicts", "label": "resolving-merge-conflicts", "kind": "external", "what": "Resolves an in-progress merge or rebase conflict by reading each side's intent, then runs the project's checks.", "when": "Reached by super-build on a live conflict, e.g. when the merge gate exits 2 or 5 and the card returns to the Builder, and by /git-sync when its pull conflicts.", "how": "Finds primary sources per hunk, preserves both intents where possible, never aborts; the Builder's finish line is green verification, not an empty conflict list.", "source": [".agents/skills/resolving-merge-conflicts/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "improve-codebase-architecture", "label": "improve-codebase-arch.", "kind": "external", "what": "Scans a codebase for deepening opportunities, presents them as an HTML report, then grills through the one picked.", "when": "Reached by /super-collect's architecture finder (findings only, no report or grilling) and by diagnosing-bugs' post-mortem; never loaded inside the Review lane.", "how": "Explores hot spots from git history with codebase-design vocabulary and CONTEXT.md/ADRs, writes the report, then runs grilling and domain-modeling on the chosen candidate.", "source": [".agents/skills/improve-codebase-architecture/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "improve-codebase-architecture", "author": "mattpocock"}, {"id": "domain-modeling", "label": "domain-modeling", "kind": "external", "what": "Sharpens a project's domain language in CONTEXT.md and records hard-to-reverse decisions as ADRs.", "when": "Reached from improve-codebase-architecture, grill-with-docs, triage and wayfinder sessions, and listed in super-build's skill map for terminology and ADRs.", "how": "Challenges fuzzy or overloaded terms and updates CONTEXT.md inline; offers an ADR only when a future reader would need the reason.", "source": [".agents/skills/domain-modeling/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "ponytail", "label": "ponytail", "kind": "external", "what": "Forces the simplest solution that works via a ladder: needed at all, already in the codebase, stdlib, native, installed dep, one line, then minimal code.", "when": "Reached by super-build on every ticket, before the first line of code (full intensity).", "how": "Runs after understanding the problem; bug fixes go to the root cause in the shared function. Inline ladder fallback when the plugin is absent.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "ponytail-review", "label": "ponytail-review", "kind": "external", "what": "Diff review that hunts only over-engineering, one line per finding tagged delete, stdlib, native, yagni or shrink.", "when": "Reached by super-review on the merge-base diff in step 3.", "how": "Ends with `net: -N lines possible`; findings are Over-engineering, always Should fix and never a merge blocker alone. It applies nothing.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail-review/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "ponytail-audit", "label": "ponytail-audit", "kind": "external", "what": "Whole-repo version of ponytail-review: a ranked list of what to delete, simplify or replace with stdlib or native features.", "when": "Reached by /super-collect's architecture finder for over-engineering findings.", "how": "Same tags as ponytail-review, biggest cut first, ending `net: -N lines, -M deps possible`; one-shot and read-only.", "source": ["~/.claude/plugins/cache/ponytail/ponytail/4.10.0/skills/ponytail-audit/SKILL.md"], "external": true, "origin": "ponytail plugin", "author": "DietrichGebert"}, {"id": "impeccable", "label": "impeccable", "kind": "external", "what": "Frontend design skill whose commands critique, audit and refine UI: build, evaluate, refine, enhance, fix and iterate categories.", "when": "Reached by /ui-refine-loop at setup (detect and context), by every checker and fixer, and by lint for shape and clarify.", "how": "Each command has a playbook under reference/<command>.md plus craft-floor.md; refine-setup.sh finds v4.0.x node scripts or the v4.4+ launcher in this or any parent dir, warning loudly when missing.", "source": [".agents/skills/impeccable/SKILL.md"], "external": true, "origin": "pbakaus/impeccable", "opensView": "impeccable", "author": "pbakaus"}, {"id": "testing-strategy", "label": "testing-strategy", "kind": "external", "what": "Coverage judgment per component type: what is worth testing and what to skip.", "when": "Listed by super-build's skill map and super-qa's dependencies for deciding which kind of test a change needs.", "how": "Informs coverage only; the localisation ladder, not this skill, picks the test layer. Not installed in EricOS.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/references/decision-policy.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "vitest", "label": "vitest", "kind": "external", "what": "Mechanics for unit and integration tests in a TS/JS repo.", "when": "Listed by super-qa and super-build when the localisation ladder stops at unit or integration in a TS/JS repo.", "how": "Its references (core-expect, features-mocking, features-coverage, core-hooks, advanced-vi) guide test code. Not installed in EricOS.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/SKILL.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "playwright-bp", "label": "playwright-best-practices", "kind": "external", "what": "Mechanics for browser e2e specs: locators, fixtures, test data factories, page objects.", "when": "Listed by super-qa when writing or refactoring a Playwright spec.", "how": "data-testid first with getByRole fallback, custom fixtures for auth and seeding, POM for reusable interactions. Not installed in EricOS.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-qa/SKILL.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "qa-test-planner", "label": "qa-test-planner", "kind": "external", "what": "Test-plan helper lint dispatches for QA tickets with a vague test surface.", "when": "Reached by /super-board lint Phase 4 for QA tickets whose test surface is vague.", "how": "One sub-agent per flagged issue drafts a concrete test plan. Not installed in EricOS.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/lint.md"], "external": true, "origin": "not installed in EricOS"}, {"id": "setup-matt-pocock-skills", "label": "setup-matt-pocock-skills", "kind": "external", "what": "One-time repo setup for the engineering skills: issue tracker, triage label vocabulary, domain doc layout.", "when": "Reached when code-review, to-spec, to-tickets, triage or wayfinder find `docs/agents/issue-tracker.md` missing.", "how": "Asks a few sections with recommended answers and records them under docs/agents/ so the other skills know whether to call gh or write markdown files.", "source": [".agents/skills/setup-matt-pocock-skills/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "grill-with-docs", "label": "grill-with-docs", "kind": "external", "what": "Stateful grilling that builds CONTEXT.md and ADRs and checkpoints every answer to a capture file.", "when": "Reached from ask-matt as step 1 of the main flow whenever there is a working directory.", "how": "Runs the grilling primitive and drives domain-modeling to keep the glossary clean; user-invoked only.", "source": [".agents/skills/grill-with-docs/SKILL.md", "erictech-skills/skills/grill-with-docs/SKILL.md"], "external": true, "origin": "erictech-skills (override of mattpocock grill-with-docs)", "opensView": "grill-with-docs", "author": "EricTechPro"}, {"id": "prototype", "label": "prototype", "kind": "external", "what": "Throwaway prototype that answers one design question: a logic demo or a UI to look at.", "when": "Reached from ask-matt when a question needs a runnable answer, and from wayfinder prototype tickets.", "how": "Throwaway from day one, trivial to run, no persistence, no polish; the learning is handed back via handoff.", "source": [".agents/skills/prototype/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "handoff", "label": "handoff", "kind": "external", "what": "Compacts the conversation into a handoff document for a fresh agent.", "when": "Reached from ask-matt to bridge a prototype detour or a phase boundary.", "how": "Writes the summary to the OS temp directory, not the workspace, so another session can pick it up.", "source": [".agents/skills/handoff/SKILL.md"], "external": true, "origin": "mattpocock-skills", "author": "mattpocock"}, {"id": "to-spec", "label": "to-spec", "kind": "external", "what": "Turns the current conversation into a spec and publishes it to the issue tracker, no interview.", "when": "Reached from ask-matt for multi-session builds; listed in super-build's skill map.", "how": "Writes the spec from a template and applies the `ready-for-agent` label; needs the tracker config from setup-matt-pocock-skills.", "source": [".agents/skills/to-spec/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "to-spec", "author": "mattpocock"}, {"id": "to-tickets", "label": "to-tickets", "kind": "external", "what": "Breaks a plan or spec into tracer-bullet tickets, each declaring its blocking edges.", "when": "Reached from ask-matt after to-spec, and from /super-board lint to split a too-big ticket (criterion 15) into vertical slices; its `## Blocked by` template is why lint criterion 13 exists.", "how": "Publishes blockers first so edges reference real ids, as files locally or native blocking links on a real tracker.", "source": [".agents/skills/to-tickets/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "to-tickets", "author": "mattpocock"}, {"id": "triage", "label": "triage", "kind": "external", "what": "Moves raw issues and external PRs through a state machine of triage roles into agent-ready briefs.", "when": "Reached from ask-matt when bugs and requests pile up that you did not create.", "how": "Categorise, verify, grill if needed, write the brief; every comment carries an AI disclaimer and labels come from setup-matt-pocock-skills.", "source": [".agents/skills/triage/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "triage", "author": "mattpocock"}, {"id": "wayfinder", "label": "wayfinder", "kind": "external", "what": "Charts a shared map of decision tickets for a huge, foggy effort and resolves them one at a time.", "when": "Reached from ask-matt for greenfield projects or builds too big for one session.", "how": "Tickets are research, prototype, grilling or task, HITL or AFK; it hands off to to-spec when the map clears instead of building.", "source": [".agents/skills/wayfinder/SKILL.md"], "external": true, "origin": "mattpocock-skills", "opensView": "wayfinder", "author": "mattpocock"}, {"id": "verbs-group", "label": "impeccable fix verbs", "kind": "verb", "what": "The 15 Impeccable commands the ui-refine-loop fixer may chain, one per problem type, with polish always last.", "when": "Each fix round, after the checker returns ranked, typed P0–P3 problems.", "how": "The workflow attaches routing.md's default command per type and suggests a chain (severity order, structural before surface, additive verbs only when the direction asks); the fixer reads each playbook and craft-floor, then makes the final call.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/routing.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/fixer-brief.md"], "opensView": "impeccable-verbs", "author": "pbakaus"}, {"id": "late-verbs", "label": "motion + perf verbs", "kind": "verb", "what": "The last tier of the chain before polish: animate, delight and optimize.", "when": "When a problem is typed needs-motion, personality or performance.", "how": "routing.md runs these after the structural, surface and fix tiers; animate and delight are additive, so they run only when the brief or taste direction asks for more.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/references/routing.md"], "opensView": "late-verbs", "author": "pbakaus"}, {"id": "v-critique", "label": "critique", "kind": "verb", "what": "UX design review with scoring; the loop uses Assessment A only, scored /20 across specificity, hierarchy, typography, color and composition.", "when": "Every check, run by the isolated design reviewer sub-agent in parallel with the detector.", "how": "Reads critique.md (Assessment A) and craft-floor.md, every shot and crop in both themes and widths, then the scope files; returns up to 8 typed problems. No Nielsen heuristics.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/critique.md"], "author": "pbakaus"}, {"id": "v-audit", "label": "audit", "kind": "verb", "what": "Technical quality check scored /20 across accessibility, performance, responsive, theming and implementation integrity.", "when": "Every check, run by the isolated detector sub-agent after impeccable detect.", "how": "Reads audit.md, scores five dimensions 0–4, and turns each verified detector cluster or audit gap into a typed problem; it never sees the screenshots or the design review.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/audit.md"], "author": "pbakaus"}, {"id": "v-polish", "label": "polish", "kind": "verb", "what": "Final quality pass over everything the round touched: small misalignments and inconsistencies, no structural change.", "when": "Always the last command of every fix round, even when no problem was typed polish.", "how": "Runs once over all touched files after the routed chain; then checks must be green before the round's single commit.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/polish.md"], "author": "pbakaus"}, {"id": "v-distill", "label": "distill", "kind": "verb", "what": "Strips a surface to its essence, removing duplicate actions and competing chrome.", "when": "Routed for problems typed `cluttered`.", "how": "Structural tier, so it runs first in the chain alongside extract; follows reference/distill.md as a refinement of the existing design.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/distill.md"], "author": "pbakaus"}, {"id": "v-bolder", "label": "bolder", "kind": "verb", "what": "Amplifies a safe, bland design so it has more presence.", "when": "Routed for `bland`, only when the brief or taste direction asks for more.", "how": "Additive surface-tier verb; skipped with a reason like \"direction says calmer\", and dropped when it pulls against quieter on the same element.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/bolder.md"], "author": "pbakaus"}, {"id": "v-quieter", "label": "quieter", "kind": "verb", "what": "Tones down an aggressive design: fewer colors, weights, borders, shadows or badges.", "when": "Routed for problems typed `too-loud`.", "how": "Surface tier after layout/adapt; when it conflicts with bolder on one element the higher-severity problem wins.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/quieter.md"], "author": "pbakaus"}, {"id": "v-colorize", "label": "colorize", "kind": "verb", "what": "Adds strategic color where gray or flat UI should carry meaning.", "when": "Routed for `dull-color`, only when the direction asks for more.", "how": "Additive surface-tier verb; changes must hold in light and dark and use tokens, not raw values.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/colorize.md"], "author": "pbakaus"}, {"id": "v-layout", "label": "layout", "kind": "verb", "what": "Fixes spacing, rhythm, grouping, alignment and visual hierarchy.", "when": "Routed for problems typed `spacing-hierarchy`.", "how": "Second tier, after distill/extract; a cramped look caused by a copied card is rerouted to extract by the fixer.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/layout.md"], "author": "pbakaus"}, {"id": "v-typeset", "label": "typeset", "kind": "verb", "what": "Improves typography: fonts, type scale, weights, line length and figures.", "when": "Routed for problems typed `typography`.", "how": "Surface tier with colorize, quieter and bolder; follows reference/typeset.md within the taste file's type rules.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/typeset.md"], "author": "pbakaus"}, {"id": "v-adapt", "label": "adapt", "kind": "verb", "what": "Adapts the surface to other screen sizes: breakpoints, touch targets, no sideways scroll at 390.", "when": "Routed for problems typed `responsive`.", "how": "Second tier with layout; the after shots at 390 in both themes prove it.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/adapt.md"], "author": "pbakaus"}, {"id": "v-optimize", "label": "optimize", "kind": "verb", "what": "Diagnoses and fixes UI performance: jank, layout shift, heavy images or bundles.", "when": "Routed for problems typed `performance`.", "how": "Last tier with animate and delight, before polish; follows reference/optimize.md.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/optimize.md"], "author": "pbakaus"}, {"id": "v-onboard", "label": "onboard", "kind": "verb", "what": "Designs first-run flows and empty states that point to the next action.", "when": "Routed for problems typed `first-run-empty`.", "how": "Fix tier with clarify and harden; no dense fixture means no dense shots, never fabricated data.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/onboard.md"], "author": "pbakaus"}, {"id": "v-clarify", "label": "clarify", "kind": "verb", "what": "Improves UX copy: labels, errors, status words and instructions.", "when": "Routed for `confusing-copy` in the refine loop; also dispatched by /super-board lint for copy or error-message ACs.", "how": "Fix tier; refinement keeps the meaning of factual copy and never adds claims.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/clarify.md"], "author": "pbakaus"}, {"id": "v-harden", "label": "harden", "kind": "verb", "what": "Production-readiness: long content, errors, loading, i18n, overflow, and accessibility (contrast, focus, names, keyboard).", "when": "Routed for problems typed `edge-cases` or `accessibility`.", "how": "Fix tier; the only verb two problem types share in routing.md.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/harden.md"], "author": "pbakaus"}, {"id": "v-animate", "label": "animate", "kind": "verb", "what": "Adds purposeful motion and state-change feedback.", "when": "Routed for `needs-motion`, only when the brief or direction asks for motion.", "how": "Additive last-tier verb; delight may call it.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/animate.md"], "author": "pbakaus"}, {"id": "v-delight", "label": "delight", "kind": "verb", "what": "Adds personality and memorable touches to a correct but lifeless surface.", "when": "Routed for `personality`, only when the brief asks for character.", "how": "Additive last-tier verb that calls animate for motion; followed by polish.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/delight.md"], "author": "pbakaus"}, {"id": "v-extract", "label": "extract", "kind": "verb", "what": "Pulls repeated UI into shared tokens and components.", "when": "Routed for `drift`: the same pattern copied 3+ times, raw values next to tokens, one-off components.", "how": "Structural tier, first in the chain; shared components change only behind a new prop that defaults to today's behaviour.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/extract.md"], "author": "pbakaus"}, {"id": "v-shape", "label": "shape", "kind": "verb", "what": "Plans UX/UI for a feature before code is written.", "when": "Dispatched by /super-board lint for feature tickets with undefined UX; never typed as a refine-loop problem.", "how": "Requires init's PRODUCT.md; a redesign need found in the loop goes to openQuestions instead.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/shape.md"], "author": "pbakaus"}, {"id": "v-init", "label": "init", "kind": "verb", "what": "Captures durable product context in PRODUCT.md.", "when": "Suggested by /impeccable when PRODUCT.md is missing; not run by the refine loop.", "how": "Shape and document require it; its context feeds live mode.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/init.md"], "author": "pbakaus"}, {"id": "v-document", "label": "document", "kind": "verb", "what": "Generates DESIGN.md from existing project code.", "when": "When DESIGN.md is missing; the refine loop reads DESIGN.md if present but never runs this.", "how": "Requires init; doctor feeds it when files go stale.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/document.md"], "author": "pbakaus"}, {"id": "v-live", "label": "live", "kind": "verb", "what": "Visual variant mode: pick elements in the browser and generate alternatives.", "when": "Interactive iteration only; the refine loop forbids it as a problem type.", "how": "Fed by init's context and calls polish on the chosen variant.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/live.md"], "author": "pbakaus"}, {"id": "v-overdrive", "label": "overdrive", "kind": "verb", "what": "Pushes a design past conventional limits for a wow factor.", "when": "Interactive only; the refine loop never types a problem as overdrive.", "how": "A redesign-scale command, so the checker sends such needs to openQuestions.", "source": [".agents/skills/impeccable/SKILL.md", ".agents/skills/impeccable/reference/overdrive.md"], "author": "pbakaus"}, {"id": "preflight", "label": "super-board-preflight.sh", "kind": "script", "what": "Builder pre-flight check: is a Ready card already done, already in progress, overlapping an open PR's files, or unclear?", "when": "Run once per batch of up to 5 Ready build cards by the wave's Pre-flight agent (or by the Builder as step 0 on the legacy backend), before any worktree.", "how": "Prints mechanical verdicts and near-miss candidates; the agent adds 'too big' and semantic matches, then returns proceed, hold, sequence or skipped. Hold and sequence move the card to Blocked with the block template; skipped leaves it in Ready.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-preflight.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"]}, {"id": "pr-body", "label": "super-board-pr-body.sh", "kind": "script", "what": "Rewrites one marker block of a PR body (redcheck, status, problem, solution, ac, history, visual, risk) without clobbering other lanes' blocks.", "when": "Called by every lane when it updates its part of the PR, and with --skeleton by ui-refine-loop for a fresh body.", "how": "`--pr N --block <name> --expect-head <sha>` with --body-file or --append-file (history rows); `--time` prints local time in the config's timezone.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-pr-body.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/writing-standard.md"]}, {"id": "needs-you", "label": "Blocked · 🙋 needs you", "kind": "board", "what": "A card parked in Blocked with the 🙋 template and the `needs-you` label: a step only a human may take. There is no separate column.", "when": "The merge gate exits 7 (merge_policy: money, auth, destructive schema, over 400 lines) or 8 (a migration the robot may not run, or a declared human step).", "how": "The comment opens \"🙋 Your turn on #N\" with the exact commands as checkboxes; a human merges it, or comments `done` / labels `needs-you:done` so the planner's resume list sends it back to Review.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/block-template.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"]}, {"id": "setup-py", "label": "super-board-setup.py", "kind": "script", "what": "The deterministic half of onboard: finds what is missing or old and fixes the must-haves, and handles boards and branches.", "when": "Run by onboard step 1 (check / fix), step 3 (board-rank, board-migrate, names) and step 4 (branch).", "how": "`fix` installs or refreshes skills, scripts, workflows, guard hooks and settings (via install.sh), removes super-refine / cleanup-wt / arch-loop folders, migrates config keys to v3, runs git init and adds Matt Pocock's skills, all backed up first. `board-migrate` adds missing columns and the three labels and moves Skipped cards to Done.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"]}, {"id": "agents-md-py", "label": "super-board-agents-md.py", "kind": "script", "what": "The deterministic half of the AGENTS.md step: detect, backup, the managed super-board block, the CLAUDE.md pointer, coverage and size checks.", "when": "Run by onboard step 5 to stage the merge and at step 8 to write it; install.sh refreshes the managed block on re-install.", "how": "The agent merges rules semantically (duplicates once, conflicts asked one by one); the script proves every rule unit maps to a line (`coverage`), keeps AGENTS.md ≤ 200 lines with one marker pair, and writes atomically.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-agents-md.py", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/agents-md-block.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md"]}, {"id": "agents-file", "label": "AGENTS.md + CLAUDE.md", "kind": "board", "what": "The project's instruction files: AGENTS.md as the single source of truth with a managed super-board block, and CLAUDE.md as `@AGENTS.md` plus Claude-only rules.", "when": "Written at onboard step 8 when Eric chose to move his rules (or only add the section); the block is rewritten on re-install.", "how": "The block sits between `<!-- super-board:begin -->` and `<!-- super-board:end -->`, rendered from agents-md-block.md with a Writing table that links the writing standard; nothing outside the markers is touched.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/agents-md-block.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md"]}, {"id": "settings-py", "label": "super-board-settings.py", "kind": "script", "what": "Merges hook blocks and permission allow rules into .claude/settings.json without losing anything.", "when": "Run by install.sh for the guard hooks, and by onboard step 6/8 for the permission lines and the protect-main hook.", "how": "`hooks <settings> <snippet>` and `allow <settings> <rules…>` keep every existing key, back the file up, write atomically, and leave an invalid settings.json untouched; `--dry-run` prints the diff onboard shows as \"N lines\".", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-settings.py"]}, {"id": "env-check", "label": "super-board-env-check.sh", "kind": "script", "what": "Says which env keys exist (present, empty or missing) without ever printing a value.", "when": "Run by onboard to detect SENTRY_AUTH_TOKEN, POSTHOG_PERSONAL_API_KEY or migration DB URLs, and allowed in permissions for runs.", "how": "Reads .env.local or .env itself and prints one word per key; guard-secrets lets a plain call through while still blocking cat, grep or source on dotenv files.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-env-check.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/hooks/guard-secrets.py"]}, {"id": "collect-custom", "label": "custom source fetcher", "kind": "script", "what": "The custom source: extra sources a project added in onboard (an http API, a CLI command, or an MCP server), stored in collect.custom[].", "when": "Run by onboard step 7 (classify, ping, add) and by /super-collect for every custom source (list, normalize).", "how": "`collect_custom.py` classifies the typed text, pings read-only before saving, refuses commands that look like they change something, and turns output into candidates with fp `custom|<name>|<key>`. MCP reads go through the agent and `normalize`.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/collect_custom.py"]}, {"id": "get-sh", "label": "get.sh", "kind": "script", "what": "One-line installer: `curl -fsSL …/get.sh | bash` fetches the latest super-board release and runs install.sh.", "when": "Eric (or a user) runs it in a project folder to install or upgrade; options --target, --ref, --no-helper-skills, and --no-hooks / --protect-main passed through.", "how": "Downloads the release tarball, runs install.sh, adds Matt Pocock's skills via `npx skills@latest add mattpocock/skills` unless told not to, and prints the next step once.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/get.sh"]}, {"id": "plugin-mkt", "label": "plugin marketplace install", "kind": "board", "what": "The Claude Code plugin form of the pack (marketplace.json + plugin.json): ships the seven skills only.", "when": "A user adds the marketplace and installs the plugin instead of running get.sh.", "how": "Skills carry the plugin prefix (/super-board:super-board onboard); onboard step 1 then installs the guard hooks, .claude/bin scripts and workflows a plugin cannot ship from the plugin's own copy.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/.claude-plugin/marketplace.json", "https://github.com/mnphuc/super-board-gitea/blob/main/.claude-plugin/plugin.json"]}, {"id": "onboard-answers", "label": "onboard answers file", "kind": "board", "what": "`.claude/super-board/onboard-answers.json`: every onboard answer, saved the moment it is given (gitignored).", "when": "Written after each answer; read when onboard re-runs or resumes after a halt.", "how": "Atomic writes; `last_step` drives the \"Continue where you left off?\" screen, and a finished setup's values fill the step-8 table on re-run.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md"]}, {"id": "upgrade-json", "label": "upgrade record", "kind": "board", "what": "`.claude/super-board/upgrade.json`: the version an install replaced, so onboard knows to upgrade a 2.x setup.", "when": "Written by install.sh (or get.sh) when it finds an older install.", "how": "super-board-setup.py fix reads it and reports \"Upgraded for you\": old folders removed, config keys migrated, labels mapped, Skipped cards moved to Done.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/install.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/RELEASE-NOTES.md"]}, {"id": "git-sync", "label": "/git-sync", "kind": "public", "what": "Commits the working tree as one commit per logical change, merge-pulls, pushes the current branch without force, and reports what it did.", "when": "Eric runs /git-sync or says \"sync\", \"commit and push\" or \"pull and push\", usually at the end of a piece of work.", "how": "Stages each group by path (never `git add -A`), refuses secrets, writes the host's commit format or the writing standard, gates `supabase/` changes on a migration file and advisors, then `git pull --no-rebase` and `git push`. The default or a protected branch needs a yes.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/git-sync/SKILL.md"], "sublabel": "commit · pull · push", "opensView": "git-sync", "author": "EricTechPro"}], "edges": [{"id": "r-board-build", "from": "super-board", "to": "super-build", "label": "starts Build lane", "when": "a planned Ready card labelled feature or bug (or unlabelled) passes pre-flight"}, {"id": "r-board-qa", "from": "super-board", "to": "super-qa", "label": "starts QA lane", "when": "a card is in QA, or in Ready with the qa label (skips Building)"}, {"id": "r-board-review", "from": "super-board", "to": "super-review", "label": "starts Review lane", "when": "a card is in Review"}, {"id": "r-board-gh", "from": "super-board", "to": "gh-board", "label": "drains", "when": "every wave until drained or halted"}, {"id": "r-board-config", "from": "super-board", "to": "sb-config", "label": "reads config", "when": "onboard writes it; every run reads it"}, {"id": "r-collect-gh", "from": "super-collect", "to": "gh-board", "label": "files to Backlog", "when": "the verifier says file or needs-triage and the run is confirmed"}, {"id": "r-collect-config", "from": "super-collect", "to": "sb-config", "label": "reads collect block", "when": "every run, to resolve sources, window and board"}, {"id": "r-build-qa", "from": "super-build", "to": "super-qa", "label": "hands off", "when": "the draft PR is open and the card moved to QA"}, {"id": "r-qa-review", "from": "super-qa", "to": "super-review", "label": "hands off", "when": "every AC passes and evidence is committed; a fail sends the card back to Ready"}, {"id": "r-review-build", "from": "super-review", "to": "super-build", "label": "bounces [builder]", "when": "a code-side finding or an unfixed prior finding"}, {"id": "r-review-base", "from": "super-review", "to": "base-branch", "label": "merges via gate", "when": "review is clean, tests rerun green, and merge_policy lets the robot merge"}, {"id": "r-review-hooks", "from": "super-review", "to": "hooks", "label": "triggers cleanup-wt", "when": "the merge gate merged a PR and cleanup-wt is installed"}, {"id": "r-refine-base", "from": "ui-refine-loop", "to": "base-branch", "label": "opens draft PR", "when": "the loop stops; it pushes refine/<slug> only and never merges"}, {"id": "r-visual-base", "from": "visual", "to": "base-branch", "label": "reads git facts", "when": "recap mode, or any mode reading the repo"}, {"id": "r-refine-config", "from": "ui-refine-loop", "to": "sb-config", "label": "reads refine block", "when": "setup, when a super-board config exists"}, {"id": "run-claim", "from": "sb-run", "to": "gh-board", "label": "claims + drains", "when": "each wave: claims cards by bot_identity assignee after sweep/flag/stranded, until drained or halted"}, {"id": "sb-v-onboard", "from": "super-board", "to": "sb-onboard", "label": "routes onboard", "when": "Eric runs /super-board onboard"}, {"id": "sb-v-lint", "from": "super-board", "to": "sb-lint", "label": "routes lint", "when": "Eric runs /super-board lint"}, {"id": "sb-v-status", "from": "super-board", "to": "sb-status", "label": "routes status", "when": "Eric runs /super-board status"}, {"id": "sb-v-run", "from": "super-board", "to": "sb-run", "label": "routes run", "when": "Eric runs /super-board run, or asks to resume"}, {"id": "sb-v-stop", "from": "super-board", "to": "sb-stop", "label": "routes stop", "when": "Eric runs /super-board stop or says pause"}, {"id": "sb-onb-config", "from": "sb-onboard", "to": "sb-config", "label": "8 · writes config", "when": "step 8, after \"Write everything\", with the active pointer"}, {"id": "sb-onb-gh", "from": "sb-onboard", "to": "gh-board", "label": "3 · picks board", "when": "step 3: reuse the best-ranked board (missing columns and labels added) or create one"}, {"id": "sb-lint-gh", "from": "sb-lint", "to": "gh-board", "label": "flags, labels cards", "when": "an active issue fails a criterion; proposed labels and AC fixes apply on approve"}, {"id": "sb-status-gh", "from": "sb-status", "to": "gh-board", "label": "reads counts", "when": "every status call; read-only"}, {"id": "sb-stop-gh", "from": "sb-stop", "to": "gh-board", "label": "releases claims", "when": "posts stopped-mid-flight comments and strips assignees"}, {"id": "lint-grill", "from": "sb-lint", "to": "grilling", "label": "grills Eric", "when": "an issue needs a rethink (criteria 10, 11) or has several readings (12)"}, {"id": "lint-diag", "from": "sb-lint", "to": "diagnosing-bugs", "label": "drafts repro", "when": "a bug ticket has no repro steps"}, {"id": "lint-shape", "from": "sb-lint", "to": "v-shape", "label": "shapes UX", "when": "a feature ticket has undefined UX"}, {"id": "lint-clarify", "from": "sb-lint", "to": "v-clarify", "label": "fixes copy ACs", "when": "an AC is about copy, microcopy or an error message"}, {"id": "lint-qatp", "from": "sb-lint", "to": "qa-test-planner", "label": "plans tests", "when": "a QA ticket has a vague test surface"}, {"id": "run-plan", "from": "sb-run", "to": "wave-plan", "label": "plans wave", "when": "after the rate guard and the usage guard pass; resume list included"}, {"id": "run-launch", "from": "sb-run", "to": "wave-js", "label": "launches workflow", "when": "one or more cards were claimed"}, {"id": "wave-build", "from": "wave-js", "to": "super-build", "label": "runs Build lane", "when": "card enters at Ready (feature, bug or no label) and pre-flight said proceed"}, {"id": "wave-qa", "from": "wave-js", "to": "super-qa", "label": "runs QA lane", "when": "card enters at QA, or Ready with the qa label"}, {"id": "wave-review", "from": "wave-js", "to": "super-review", "label": "runs Review lane", "when": "card enters at Review; always on the session model"}, {"id": "review-gate", "from": "super-review", "to": "merge-gate", "label": "calls merge gate", "when": "clean review, threads resolved, truth score over threshold, tests green"}, {"id": "gate-cleanup", "from": "merge-gate", "to": "cleanup-wt", "label": "runs post-merge", "when": "the merge landed and .claude/hooks/cleanup-wt.py exists"}, {"id": "gate-base", "from": "merge-gate", "to": "base-branch", "label": "squash-merges", "when": "policy allows the robot, the branch still passes against the current base inside the lock, allowed migrations ran"}, {"id": "run-manifest-e", "from": "sb-run", "to": "run-manifest", "label": "appends manifest", "when": "reconcile, once the wave returns; claims are released too"}, {"id": "b-pony", "from": "super-build", "to": "ponytail", "label": "climbs ladder first", "when": "every ticket, before the first line of code"}, {"id": "b-impl", "from": "super-build", "to": "implement", "label": "routes feature", "when": "type label feature or ux (then tdd, codebase-design)"}, {"id": "b-diag", "from": "super-build", "to": "diagnosing-bugs", "label": "routes bug", "when": "type label bug (then tdd)"}, {"id": "b-design", "from": "super-build", "to": "codebase-design", "label": "routes refactor", "when": "type label refactor or tech-debt, or feature"}, {"id": "b-tdd", "from": "super-build", "to": "tdd", "label": "builds test-first", "when": "every ticket except docs"}, {"id": "b-docs", "from": "super-build", "to": "context7", "label": "reads current docs", "when": "the ticket touches a third-party surface, an upgrade, or auth/billing"}, {"id": "b-verify", "from": "super-build", "to": "verification", "label": "proves before commit", "when": "before the final commit"}, {"id": "b-review", "from": "super-build", "to": "code-review", "label": "reviews own diff", "when": "once, against the merge-base, before the final commit"}, {"id": "b-conflict", "from": "super-build", "to": "resolving-merge-conflicts", "label": "resolves conflict", "when": "a live conflict, e.g. after merge-gate exit 2 or 5"}, {"id": "b-askmatt", "from": "super-build", "to": "ask-matt", "label": "asks the router", "when": "the right flow is unclear"}, {"id": "b-gh", "from": "super-build", "to": "gh-board", "label": "moves card to QA", "when": "draft PR opened and comments posted"}, {"id": "q-tdd", "from": "super-qa", "to": "tdd", "label": "writes gaps red-first", "when": "the test-gap check finds a High gap"}, {"id": "q-tddv2", "from": "super-qa", "to": "tdd-v2", "label": "picks the rung", "when": "the repo has tdd-v2 (used instead of plain tdd)"}, {"id": "q-diag", "from": "super-qa", "to": "diagnosing-bugs", "label": "diagnoses failures", "when": "a spec goes red and the cause is unclear"}, {"id": "q-verify", "from": "super-qa", "to": "verification", "label": "proves the pass", "when": "before a pass handoff"}, {"id": "q-askmatt", "from": "super-qa", "to": "ask-matt", "label": "asks the router", "when": "the right flow is unclear"}, {"id": "q-strat", "from": "super-qa", "to": "testing-strategy", "label": "judges coverage", "when": "deciding what is worth testing per component type"}, {"id": "q-vitest", "from": "super-qa", "to": "vitest", "label": "writes unit tests", "when": "the ladder stops at unit or integration in TS/JS"}, {"id": "q-pw", "from": "super-qa", "to": "playwright-bp", "label": "writes e2e specs", "when": "the browser is the thing that broke, or standalone crawl specs"}, {"id": "q-gh", "from": "super-qa", "to": "gh-board", "label": "moves card", "when": "pass: QA to Review; fail: QA to Ready (loop:rebuild-N); a qa card first moves itself Ready to QA"}, {"id": "q-filebug", "from": "super-qa", "to": "file-bug", "label": "files red spec", "when": "a standalone crawl finds a failing spec, or a qa card finds a defect tests alone cannot fix"}, {"id": "filebug-qaboard", "from": "file-bug", "to": "qa-board", "label": "sets Status Bug", "when": "the body passes validation"}, {"id": "v-cr", "from": "super-review", "to": "code-review", "label": "runs two-axis review", "when": "every card, with the merge-base as the fixed point"}, {"id": "v-design", "from": "super-review", "to": "codebase-design", "label": "reads diff shape", "when": "step 2, and when writing every deepening opportunity"}, {"id": "v-pony", "from": "super-review", "to": "ponytail-review", "label": "hunts over-engineering", "when": "step 3, on the merge-base diff; inline ladder if absent"}, {"id": "v-refactor", "from": "super-review", "to": "file-refactor", "label": "files deepening card", "when": "the diff is correct but leaves a shallow module or misplaced seam"}, {"id": "v-gh", "from": "super-review", "to": "gh-board", "label": "bounces or closes", "when": "unresolved [builder]/[qa] threads bounce; a confirmed merge moves the card to Done"}, {"id": "c-sentry", "from": "super-collect", "to": "collect-sentry", "label": "fetches sentry", "when": "sentry is requested or enabled in collect.sources"}, {"id": "c-posthog", "from": "super-collect", "to": "collect-posthog", "label": "fetches posthog", "when": "posthog is requested or enabled"}, {"id": "c-github", "from": "super-collect", "to": "gh-issues", "label": "reads github", "when": "github is requested or enabled"}, {"id": "c-prs", "from": "super-collect", "to": "collect-prs", "label": "fetches merged PRs", "when": "prs is requested or enabled"}, {"id": "c-ica", "from": "super-collect", "to": "improve-codebase-architecture", "label": "finds refactors", "when": "architecture source; read-only finder, findings only"}, {"id": "c-design", "from": "super-collect", "to": "codebase-design", "label": "finds refactors", "when": "architecture source when improve-codebase-architecture is not installed"}, {"id": "c-audit", "from": "super-collect", "to": "ponytail-audit", "label": "finds bloat", "when": "architecture source, always alongside the finder"}, {"id": "c-file", "from": "super-collect", "to": "collect-file", "label": "files if verified", "when": "one fresh verifier per candidate says file or needs-triage (duplicate gets a comment)"}, {"id": "file-gh", "from": "collect-file", "to": "gh-board", "label": "files to Backlog", "when": "--yes or confirmed dry-run; dedupe by exact fingerprint"}, {"id": "u-grill", "from": "ui-refine-loop", "to": "grilling", "label": "grills Eric", "when": "after reading the target's code; at most 10 questions in waves"}, {"id": "u-taste", "from": "ui-refine-loop", "to": "taste-file", "label": "commits taste", "when": "answers in hand; first commit on refine/<slug>"}, {"id": "u-imp", "from": "ui-refine-loop", "to": "impeccable", "label": "detects + loads", "when": "setup (detect, context) and the finish reviewer's craft-floor verdict pass"}, {"id": "u-shoot", "from": "ui-refine-loop", "to": "shoot", "label": "takes shots", "when": "round 0 at setup, then AFTER shots each fix round"}, {"id": "u-critique", "from": "ui-refine-loop", "to": "v-critique", "label": "design reviewer runs", "when": "every check, isolated from the detector"}, {"id": "u-detect", "from": "ui-refine-loop", "to": "imp-detect", "label": "detector runs", "when": "every check, in parallel with the design reviewer"}, {"id": "u-detect-audit", "from": "imp-detect", "to": "v-audit", "label": "feeds audit", "when": "same detector sub-agent; verified hits become problems"}, {"id": "u-crit-verbs", "from": "v-critique", "to": "verbs-group", "label": "checker ranks, routes", "when": "checker merges A and B into at most 8 typed problems"}, {"id": "u-audit-verbs", "from": "v-audit", "to": "verbs-group", "label": "checker ranks, routes", "when": "same merge; the fixer chains the routed verbs"}, {"id": "u-verbs-polish", "from": "verbs-group", "to": "v-polish", "label": "then polish last", "when": "every fix round, once, over all touched files"}, {"id": "u-ledger", "from": "ui-refine-loop", "to": "refine-ledger", "label": "appends ledger", "when": "after every check; stop rules read it"}, {"id": "u-human", "from": "ui-refine-loop", "to": "humanizer", "label": "humanizes PR", "when": "finish, after the finish reviewer graded every fix"}, {"id": "u-pr", "from": "ui-refine-loop", "to": "draft-pr", "label": "opens draft PR", "when": "finish; pushes refine/<slug> only"}, {"id": "iv-v-distill", "from": "verbs-group", "to": "v-distill", "label": "routes cluttered", "when": "a problem is typed cluttered"}, {"id": "iv-v-extract", "from": "verbs-group", "to": "v-extract", "label": "routes drift", "when": "a problem is typed drift"}, {"id": "iv-v-layout", "from": "verbs-group", "to": "v-layout", "label": "routes spacing", "when": "a problem is typed spacing-hierarchy"}, {"id": "iv-v-adapt", "from": "verbs-group", "to": "v-adapt", "label": "routes responsive", "when": "a problem is typed responsive"}, {"id": "iv-v-typeset", "from": "verbs-group", "to": "v-typeset", "label": "routes typography", "when": "a problem is typed typography"}, {"id": "iv-v-colorize", "from": "verbs-group", "to": "v-colorize", "label": "routes dull color", "when": "typed dull-color and the direction asks for more"}, {"id": "iv-v-quieter", "from": "verbs-group", "to": "v-quieter", "label": "routes too-loud", "when": "a problem is typed too-loud"}, {"id": "iv-v-bolder", "from": "verbs-group", "to": "v-bolder", "label": "routes bland", "when": "typed bland and the direction asks for more"}, {"id": "iv-v-clarify", "from": "verbs-group", "to": "v-clarify", "label": "routes confusing copy", "when": "a problem is typed confusing-copy"}, {"id": "iv-v-harden", "from": "verbs-group", "to": "v-harden", "label": "routes edge cases, a11y", "when": "a problem is typed edge-cases or accessibility"}, {"id": "iv-v-onboard", "from": "verbs-group", "to": "v-onboard", "label": "routes first-run", "when": "a problem is typed first-run-empty"}, {"id": "iv-late-verbs", "from": "verbs-group", "to": "late-verbs", "label": "routes motion, perf", "when": "a problem is typed needs-motion, personality or performance"}, {"id": "lv-animate", "from": "late-verbs", "to": "v-animate", "label": "routes needs-motion", "when": "typed needs-motion and the brief asks for motion"}, {"id": "lv-delight", "from": "late-verbs", "to": "v-delight", "label": "routes personality", "when": "typed personality and the brief asks for character"}, {"id": "lv-optimize", "from": "late-verbs", "to": "v-optimize", "label": "routes performance", "when": "a problem is typed performance"}, {"id": "lv-del-anim", "from": "v-delight", "to": "v-animate", "label": "calls", "when": "delight needs motion for its touches"}, {"id": "lv-polish", "from": "late-verbs", "to": "v-polish", "label": "then polish last", "when": "always, after the last tier"}, {"id": "im-init", "from": "impeccable", "to": "v-init", "label": "suggests init", "when": "PRODUCT.md is missing"}, {"id": "im-critique", "from": "impeccable", "to": "v-critique", "label": "suggests critique", "when": "an existing UI needs a review"}, {"id": "im-audit", "from": "impeccable", "to": "v-audit", "label": "offers audit", "when": "technical quality needs checking"}, {"id": "im-shape", "from": "impeccable", "to": "v-shape", "label": "offers shape", "when": "planning UX before code"}, {"id": "im-live", "from": "impeccable", "to": "v-live", "label": "offers live", "when": "interactive browser iteration"}, {"id": "im-overdrive", "from": "impeccable", "to": "v-overdrive", "label": "offers overdrive", "when": "an ambitious, unconventional effect is wanted"}, {"id": "im-verbs", "from": "impeccable", "to": "verbs-group", "label": "offers refine verbs", "when": "fix, refine and enhance work on an existing UI"}, {"id": "im-shape-init", "from": "v-shape", "to": "v-init", "label": "requires", "when": "always; shape needs PRODUCT.md"}, {"id": "im-doc-init", "from": "v-document", "to": "v-init", "label": "requires", "when": "always; document needs PRODUCT.md"}, {"id": "im-audit-harden", "from": "v-audit", "to": "v-harden", "label": "suggests", "when": "audit found edge-case or accessibility gaps"}, {"id": "im-audit-opt", "from": "v-audit", "to": "v-optimize", "label": "suggests", "when": "audit found performance gaps"}, {"id": "im-crit-polish", "from": "v-critique", "to": "v-polish", "label": "feeds", "when": "critique findings feed the final pass"}, {"id": "im-live-polish", "from": "v-live", "to": "v-polish", "label": "calls", "when": "a variant was chosen"}, {"id": "vi-py", "from": "visual", "to": "visual-py", "label": "detects, renders", "when": "every run: detect with no argument, facts in recap, render after data.json"}, {"id": "vi-py-base", "from": "visual-py", "to": "base-branch", "label": "reads git diff", "when": "recap mode collects files, +/- and hunks from git"}, {"id": "h-wt", "from": "claude-settings", "to": "guard-worktree-path", "label": "PreToolUse Bash", "when": "every shell command"}, {"id": "h-del", "from": "claude-settings", "to": "guard-delete-outside", "label": "PreToolUse Bash", "when": "every shell command"}, {"id": "h-sec", "from": "claude-settings", "to": "guard-secrets", "label": "Pre Bash|Read|Grep", "when": "every read, grep or shell command"}, {"id": "h-key", "from": "claude-settings", "to": "guard-key-literals", "label": "Pre/PostToolUse writes", "when": "Edit/MultiEdit/Write/NotebookEdit (and Bash before)"}, {"id": "h-session", "from": "claude-settings", "to": "cleanup-wt", "label": "SessionStart --auto", "when": "a base branch tip moved since the last session"}, {"id": "h-push", "from": "install-sh", "to": "guard-protected-push", "label": "--protect-main wires", "when": "install with --protect-main, or onboard's yes"}, {"id": "h-gate", "from": "hooks", "to": "gate-skill-evals", "label": "dev-only Stop", "when": "only in the pack repo or EricOS; a skill changed without a newer eval"}, {"id": "h-readme", "from": "hooks", "to": "readme-sync", "label": "dev-only sync", "when": "edits or commits under skills/ in the pack repo"}, {"id": "tdd-design", "from": "tdd", "to": "codebase-design", "label": "borrows vocabulary", "when": "the interface or seam shape is itself in question"}, {"id": "tdd-cr", "from": "tdd", "to": "code-review", "label": "defers refactor to", "when": "refactoring belongs to review, not the red-green loop"}, {"id": "tddv2-tdd", "from": "tdd-v2", "to": "tdd", "label": "defers discipline to", "when": "always; tdd owns seams and red-before-green"}, {"id": "impl-tddv2", "from": "implement", "to": "tdd-v2", "label": "builds at the rung", "when": "where possible, at pre-agreed seams"}, {"id": "impl-tdd", "from": "implement", "to": "tdd", "label": "red-green under it", "when": "every slice"}, {"id": "impl-cr", "from": "implement", "to": "code-review", "label": "reviews when done", "when": "once the work is done, before committing"}, {"id": "cr-setup", "from": "code-review", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "docs/agents/issue-tracker.md is missing"}, {"id": "db-ica", "from": "diagnosing-bugs", "to": "improve-codebase-architecture", "label": "hands off post-mortem", "when": "the fix is in and the real finding is a missing seam"}, {"id": "ica-design", "from": "improve-codebase-architecture", "to": "codebase-design", "label": "uses vocabulary", "when": "every suggestion, and design-it-twice for alternatives"}, {"id": "ica-grill", "from": "improve-codebase-architecture", "to": "grilling", "label": "grills the pick", "when": "the user picks a candidate (skipped by super-collect)"}, {"id": "ica-dm", "from": "improve-codebase-architecture", "to": "domain-modeling", "label": "updates CONTEXT.md", "when": "a new term or a rejected candidate worth an ADR"}, {"id": "am-grill-with-docs", "from": "ask-matt", "to": "grill-with-docs", "label": "1 · sharpens idea", "when": "start of the main flow, in a working directory"}, {"id": "am-handoff", "from": "ask-matt", "to": "handoff", "label": "bridges detours", "when": "a question needs a prototype, or a phase boundary"}, {"id": "am-prototype", "from": "ask-matt", "to": "prototype", "label": "answers by code", "when": "a question needs a runnable answer"}, {"id": "am-to-spec", "from": "ask-matt", "to": "to-spec", "label": "multi-session: spec", "when": "the build spans several sessions"}, {"id": "am-to-tickets", "from": "ask-matt", "to": "to-tickets", "label": "splits into tickets", "when": "after to-spec, with blocking edges"}, {"id": "am-implement", "from": "ask-matt", "to": "implement", "label": "builds each ticket", "when": "every ticket, or in place for a small build"}, {"id": "am-tdd", "from": "ask-matt", "to": "tdd", "label": "test-first alone", "when": "a concrete behaviour without a full spec"}, {"id": "am-code-review", "from": "ask-matt", "to": "code-review", "label": "reviews a branch", "when": "reviewing against a fixed point"}, {"id": "am-triage", "from": "ask-matt", "to": "triage", "label": "on-ramp: triage", "when": "raw bugs and requests pile up"}, {"id": "am-diagnosing-bugs", "from": "ask-matt", "to": "diagnosing-bugs", "label": "on-ramp: broken", "when": "something is broken and resists a first look"}, {"id": "am-wayfinder", "from": "ask-matt", "to": "wayfinder", "label": "on-ramp: foggy", "when": "a huge effort too big for one session"}, {"id": "am-improve-codebase-architecture", "from": "ask-matt", "to": "improve-codebase-architecture", "label": "codebase health", "when": "a spare moment for upkeep"}, {"id": "am-domain-modeling", "from": "ask-matt", "to": "domain-modeling", "label": "vocabulary", "when": "the words, not the process, are the problem"}, {"id": "gwd-grill", "from": "grill-with-docs", "to": "grilling", "label": "runs grilling", "when": "every session"}, {"id": "gwd-dm", "from": "grill-with-docs", "to": "domain-modeling", "label": "keeps glossary", "when": "a term is fuzzy or a decision is hard to reverse"}, {"id": "ts-setup", "from": "to-spec", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker and triage labels are not configured"}, {"id": "tt-setup", "from": "to-tickets", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker and triage labels are not configured"}, {"id": "tr-grill", "from": "triage", "to": "grilling", "label": "grills if needed", "when": "an issue is too unclear to brief"}, {"id": "tr-dm", "from": "triage", "to": "domain-modeling", "label": "checks vocabulary", "when": "writing the agent-ready brief"}, {"id": "tr-setup", "from": "triage", "to": "setup-matt-pocock-skills", "label": "needs label map", "when": "the triage label mapping is missing"}, {"id": "wf-grill", "from": "wayfinder", "to": "grilling", "label": "names destination", "when": "first step, and every grilling ticket"}, {"id": "wf-dm", "from": "wayfinder", "to": "domain-modeling", "label": "pins terms", "when": "alongside every grilling session"}, {"id": "wf-proto", "from": "wayfinder", "to": "prototype", "label": "raises fidelity", "when": "a prototype ticket needs UI or logic code"}, {"id": "wf-setup", "from": "wayfinder", "to": "setup-matt-pocock-skills", "label": "needs tracker setup", "when": "the tracker is not configured"}, {"id": "r-install-hooks", "from": "install-sh", "to": "hooks", "label": "copies guards", "when": "install without --no-hooks (--protect-main adds the push guard)"}, {"id": "onb-answers", "from": "sb-onboard", "to": "onboard-answers", "label": "saves each answer", "when": "the moment each answer is given; resume reads it"}, {"id": "onb-setup", "from": "sb-onboard", "to": "setup-py", "label": "1 · Checks: fix", "when": "every run, first; asks only for system tools or sign-ins"}, {"id": "setup-install", "from": "setup-py", "to": "install-sh", "label": "fix re-runs install", "when": "skills, scripts, workflows, guards or settings entries are missing or old"}, {"id": "setup-gh", "from": "setup-py", "to": "gh-board", "label": "board-rank, migrate", "when": "step 3 (or step 1 on an upgrade): ranks boards, adds columns and labels"}, {"id": "onb-branch", "from": "sb-onboard", "to": "base-branch", "label": "4 · picks base", "when": "step 4; no staging → offers `git push origin main:staging`"}, {"id": "onb-agents", "from": "sb-onboard", "to": "agents-md-py", "label": "5 · AGENTS.md", "when": "step 5: move CLAUDE.md rules, or only add the section"}, {"id": "agents-write", "from": "agents-md-py", "to": "agents-file", "label": "writes block, pointer", "when": "step 8 write, after backup and coverage pass"}, {"id": "onb-settings", "from": "sb-onboard", "to": "settings-py", "label": "6 · Policies", "when": "step 6 answers: safe defaults and N permission lines"}, {"id": "settings-write", "from": "settings-py", "to": "claude-settings", "label": "merges entries", "when": "install (hooks) or onboard step 8 (allow lines)"}, {"id": "settings-push", "from": "settings-py", "to": "guard-protected-push", "label": "wires push guard", "when": "Policies said block pushes to main and the script is installed"}, {"id": "onb-env", "from": "sb-onboard", "to": "env-check", "label": "checks key names", "when": "silent detect and step 7, for Sentry, PostHog and DB keys"}, {"id": "onb-custom", "from": "sb-onboard", "to": "collect-custom", "label": "7 · adds a source", "when": "\"➕ Add another source\": classify, ping read-only, add on ✅"}, {"id": "custom-config", "from": "collect-custom", "to": "sb-config", "label": "saves custom[]", "when": "the ping succeeded; staged until step 8"}, {"id": "lint-tickets", "from": "sb-lint", "to": "to-tickets", "label": "splits too-big", "when": "criterion 15: likely over ~400 changed lines or many areas"}, {"id": "wave-preflight", "from": "wave-js", "to": "preflight", "label": "pre-flights batches", "when": "Ready cards the Builder would take, up to 5 per agent"}, {"id": "preflight-gh", "from": "preflight", "to": "gh-board", "label": "holds to Blocked", "when": "already done, in progress, overlapping, unclear or too big"}, {"id": "gate-needsyou", "from": "merge-gate", "to": "needs-you", "label": "parks (exit 7/8)", "when": "merge_policy says a human merges, or a migration/human step is needed"}, {"id": "needsyou-plan", "from": "needs-you", "to": "wave-plan", "label": "resumes on done", "when": "a human comments done or labels needs-you:done"}, {"id": "super-build-prbody", "from": "super-build", "to": "pr-body", "label": "writes PR blocks", "when": "opening the draft PR and on every rebuild"}, {"id": "super-build-human", "from": "super-build", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "super-qa-prbody", "from": "super-qa", "to": "pr-body", "label": "ticks ac, visual", "when": "every pass or fail handoff"}, {"id": "super-qa-human", "from": "super-qa", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "super-review-prbody", "from": "super-review", "to": "pr-body", "label": "updates status", "when": "after a merge (✅ Merged) or a block"}, {"id": "super-review-human", "from": "super-review", "to": "humanizer", "label": "humanizes prose", "when": "writing commits, PR text and comments, when humanizer is installed"}, {"id": "review-needsyou", "from": "super-review", "to": "needs-you", "label": "posts 🙋 checklist", "when": "the merge gate exits 7 or 8"}, {"id": "c-custom", "from": "super-collect", "to": "collect-custom", "label": "runs custom sources", "when": "a custom source is requested by name or enabled in collect.sources"}, {"id": "u-prbody", "from": "ui-refine-loop", "to": "pr-body", "label": "builds PR body", "when": "finish: --skeleton marker blocks for the draft PR"}, {"id": "install-settings", "from": "install-sh", "to": "settings-py", "label": "merges hook block", "when": "install without --no-hooks"}, {"id": "secrets-envcheck", "from": "guard-secrets", "to": "env-check", "label": "allows plain call", "when": "a single env-check call with no pipe, chain or redirect"}, {"id": "get-install", "from": "get-sh", "to": "install-sh", "label": "runs install", "when": "after downloading the release tarball"}, {"id": "plugin-onboard", "from": "plugin-mkt", "to": "sb-onboard", "label": "needs onboard", "when": "a plugin ships skills only; onboard step 1 adds the rest"}, {"id": "install-upgrade", "from": "install-sh", "to": "upgrade-json", "label": "records old version", "when": "an older super-board install was found"}, {"id": "upgrade-setup", "from": "upgrade-json", "to": "setup-py", "label": "triggers upgrade", "when": "onboard step 1 runs fix and finds the record"}, {"id": "r-gitsync-base", "from": "git-sync", "to": "base-branch", "label": "pulls, pushes", "when": "every run; a push to the default or a protected branch waits for a yes"}, {"id": "gs-base", "from": "git-sync", "to": "base-branch", "label": "merge-pulls, pushes", "when": "`git pull --no-rebase`, then `git push`; never force"}, {"id": "gs-conflict", "from": "git-sync", "to": "resolving-merge-conflicts", "label": "resolves conflict", "when": "the pull conflicts and the skill is installed; otherwise hunk by hunk"}, {"id": "gs-push", "from": "git-sync", "to": "guard-protected-push", "label": "push checked by", "when": "the opt-in push guard is installed"}], "views": [{"id": "root", "parent": null, "title": "super-board pack", "caption": "Collect verified tickets into the board; the board contains Build → QA → Review. UI refinement, visuals and Git sync are standalone skills. Open a family or step for its tools and policies.", "nodeIds": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "ui-refine-loop", "visual", "git-sync"], "edges": [{"from": "super-collect", "to": "super-board", "label": "Backlog → lint"}, {"from": "super-board", "to": "super-build", "label": "Ready cards"}, "r-build-qa", "r-qa-review", {"from": "super-review", "to": "super-collect", "label": "review done → collect the next tickets", "kind": "feeds", "when": "the board drains; /super-collect files the next verified tickets into Backlog"}], "lanes": false, "layout": {"super-collect": [0, 0], "super-board": [1, 0], "super-build": [2, 0], "super-qa": [3, 0], "super-review": [4, 0], "ui-refine-loop": [5, 0], "visual": [5, 1], "git-sync": [5, 2]}, "nodeOverrides": {"super-collect": {"verbs": [], "sublabel": "Find verified tickets", "emphasis": true}, "super-board": {"verbs": [], "sublabel": "Run the board", "emphasis": true}, "ui-refine-loop": {"verbs": [], "sublabel": "Refine a page", "emphasis": true}, "visual": {"verbs": [], "sublabel": "Draw one visual", "emphasis": true}, "super-build": {"emphasis": true}, "super-qa": {"emphasis": true}, "super-review": {"emphasis": true}, "git-sync": {"verbs": [], "sublabel": "Commit · pull · push", "emphasis": true}}, "containers": [{"id": "collect-family", "label": "/super-collect · intake feeds the board", "nodeIds": ["super-collect"]}, {"id": "board-family", "parent": "collect-family", "label": "/super-board · Build → QA → Review", "nodeIds": ["super-board", "super-build", "super-qa", "super-review"]}], "browserOrder": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "ui-refine-loop", "visual", "git-sync", "hooks", "install"], "intake": [{"label": "Sentry", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMzNjJENTkiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+U2VudHJ5PC90aXRsZT48cGF0aCBkPSJNMTMuOTEgMi41MDVjLS44NzMtMS40NDgtMi45NzItMS40NDgtMy44NDQgMEw2LjkwNCA3LjkyYTE1LjQ3OCAxNS40NzggMCAwIDEgOC41MyAxMi44MTFoLTIuMjIxQTEzLjMwMSAxMy4zMDEgMCAwIDAgNS43ODQgOS44MTRsLTIuOTI2IDUuMDZhNy42NSA3LjY1IDAgMCAxIDQuNDM1IDUuODQ4SDIuMTk0YS4zNjUuMzY1IDAgMCAxLS4yOTgtLjUzNGwxLjQxMy0yLjQwMmE1LjE2IDUuMTYgMCAwIDAtMS42MTQtLjkxM0wuMjk2IDE5LjI3NWEyLjE4MiAyLjE4MiAwIDAgMCAuODEyIDIuOTk5IDIuMjQgMi4yNCAwIDAgMCAxLjA4Ni4yODhoNi45ODNhOS4zMjIgOS4zMjIgMCAwIDAtMy44NDUtOC4zMThsMS4xMS0xLjkyMmExMS40NyAxMS40NyAwIDAgMSA0Ljk1IDEwLjI0aDUuOTE1YTE3LjI0MiAxNy4yNDIgMCAwIDAtNy44ODUtMTUuMjhsMi4yNDQtMy44NDVhLjM3LjM3IDAgMCAxIC41MDQtLjEzYy4yNTUuMTQgOS43NSAxNi43MDggOS45MjggMTYuOWEuMzY1LjM2NSAwIDAgMS0uMzI3LjU0M2gtMi4yODdjLjAyOS42MTIuMDI5IDEuMjIzIDAgMS44MzFoMi4yOTdhMi4yMDYgMi4yMDYgMCAwIDAgMS45MjItMy4zMXoiLz48L3N2Zz4=", "to": "super-collect"}, {"label": "PostHog", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMwMDAwMDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+UG9zdEhvZzwvdGl0bGU+PHBhdGggZD0iTTkuODU0IDE0LjUgNSA5LjY0Ny44NTQgNS41QS41LjUgMCAwIDAgMCA1Ljg1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ni4zNTNMNSAxMy42NDdsLjE0Ny4xNDZMOS44NTQgMTguNWwuMTQ2LjE0N3YtLjA0OWMuMDY1LjAzLjEzNC4wNDkuMjA3LjA0OWgyLjU4NmEuNS41IDAgMCAwIC4zNTMtLjg1NEw5Ljg1NCAxNC41em0wLTUtNC00YS40ODcuNDg3IDAgMCAwLS40MDktLjE0NC41MTUuNTE1IDAgMCAwLS4zNTYuMjEuNDkzLjQ5MyAwIDAgMC0uMDg5LjI4OFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsOSA5YS41LjUgMCAwIDAgLjg1My0uMzU0di0yLjU4NWEuNS41IDAgMCAwLS4xNDYtLjM1NGwtNS01em0xLTRhLjUuNSAwIDAgMC0uODU0LjM1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsNCA0YS41LjUgMCAwIDAgLjg1My0uMzU0VjkuODU0YS41LjUgMCAwIDAtLjE0Ni0uMzU0bC00LTR6bTEyLjY0NyAxMS41MTVhMy44NjMgMy44NjMgMCAwIDEtMi4yMzItMS4xbC00LjcwOC00LjcwN2EuNS41IDAgMCAwLS44NTQuMzU0djYuNTg1YS41LjUgMCAwIDAgLjUuNUgyMy41YS41LjUgMCAwIDAgLjUtLjV2LS42YzAtLjI3Ni0uMjI1LS40OTctLjQ5OS0uNTMyem0tNS4zOTQuMDMyYS44LjggMCAxIDEgMC0xLjYuOC44IDAgMCAxIDAgMS42ek0uODU0IDE1LjVhLjUuNSAwIDAgMC0uODU0LjM1NHYyLjI5M2EuNS41IDAgMCAwIC41LjVoMi4yOTNjLjIyMiAwIC4zOS0uMTM1LjQ2Mi0uMzA5YS40OTMuNDkzIDAgMCAwLS4xMDktLjU0NUwuODU0IDE1LjUwMXpNNSAxNC42NDcuODU0IDEwLjVhLjUuNSAwIDAgMC0uODU0LjM1M3YyLjU4NmEuNS41IDAgMCAwIC4xNDYuMzUzTDQuODU0IDE4LjVsLjE0Ni4xNDdoMi43OTNhLjUuNSAwIDAgMCAuMzUzLS44NTRMNSAxNC42NDd6Ii8+PC9zdmc+", "to": "super-collect"}, {"label": "GitHub", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "super-collect"}], "tour": ["super-collect", "super-board", "super-build", "super-qa", "super-review", "super-collect"]}, {"id": "super-board", "parent": "root", "title": "/super-board · five verbs", "caption": "Onboard sets up; lint makes cards ready; run delegates the lanes. Status inspects a run; stop halts it.", "nodeIds": ["super-board", "sb-onboard", "sb-lint", "sb-status", "sb-run", "sb-stop"], "edges": ["sb-v-onboard", "sb-v-lint", "sb-v-status", "sb-v-run", "sb-v-stop"], "lanes": [{"title": "Prepare", "nodeIds": ["sb-onboard", "sb-lint"]}, {"title": "Run", "nodeIds": ["sb-run"]}, {"title": "Control", "nodeIds": ["sb-status", "sb-stop"]}], "nodeOverrides": {"super-board": {"label": "/super-board", "verbs": [], "sublabel": "Five verbs", "emphasis": true}, "sb-onboard": {"label": "onboard", "verbs": [], "sublabel": "Set up the project", "emphasis": true}, "sb-lint": {"label": "lint", "verbs": [], "sublabel": "Check ticket readiness", "emphasis": true}, "sb-run": {"label": "run", "verbs": [], "sublabel": "Delegate build · QA · review", "emphasis": true}, "sb-status": {"label": "status", "verbs": [], "sublabel": "Inspect the run", "emphasis": true}, "sb-stop": {"label": "stop", "verbs": [], "sublabel": "Halt the run", "emphasis": true}}, "browserOrder": ["super-build", "super-qa", "super-review", "sb-onboard", "sb-lint", "super-board-run", "sb-status", "sb-stop"]}, {"id": "sb-lint", "parent": "super-board", "title": "/super-board lint · Phase 4 routing", "caption": "Interactive-only skills live here, never inside an unattended worker. Ticket-format fixes (criteria 16–18) and catch-alls get an inline draft.", "nodeIds": ["sb-lint", "grilling", "diagnosing-bugs", "v-shape", "v-clarify", "qa-test-planner", "gh-board", "to-tickets"], "edges": ["lint-grill", "lint-diag", "lint-shape", "lint-clarify", "lint-qatp", "sb-lint-gh", "lint-tickets"]}, {"id": "super-board-run", "parent": "super-board", "title": "/super-board run · main steps", "caption": "One wave: classify → pre-flight → delegate → merge → done. Up to min(16, CPUs − 2) cards run at once; the runtime queues the rest. Pre-flight checks batches of 5. Open a step for scripts and policies.", "nodeIds": ["sb-run", "run-classify", "run-preflight", "run-delegate", "run-merge", "run-done"], "edges": [{"from": "sb-run", "to": "run-classify", "label": ""}, {"from": "run-classify", "to": "run-preflight", "label": ""}, {"from": "run-preflight", "to": "run-delegate", "label": ""}, {"from": "run-delegate", "to": "run-merge", "label": ""}, {"from": "run-merge", "to": "run-done", "label": ""}], "render": "process", "nodes": [{"id": "run-classify", "label": "Classify cards", "kind": "step", "what": "Route qa, bug and feature cards by label. Classify unlabelled cards as bug or feature.", "when": "Each Ready card enters the classifier. Existing type labels take priority.", "how": "Read the issue body and comments. Judge complexity as low, medium or high; choose the worker model tier.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/workflows/super-board-wave.js"], "opensView": "run-classify", "sublabel": "qa / bug / feature"}, {"id": "run-preflight", "label": "Pre-flight check", "kind": "step", "what": "Check whether a Ready build card is already done or in progress. Flag overlap, unclear scope and excessive size.", "when": "Before any worktree or Builder starts. Check build cards in batches of up to five.", "how": "Combine mechanical checks with semantic matches. Return proceed, hold, sequence or skipped.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-preflight.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "opensView": "run-preflight", "sublabel": "Done? overlap? too big?"}, {"id": "run-delegate", "label": "Delegate to lanes", "kind": "step", "what": "Run the Build, QA and Review lane agents. QA-labelled cards skip Building.", "when": "After pre-flight allows a build card to proceed. QA and Review cards enter their current lane.", "how": "Build advances to QA, then Review. A non-advanced exit stops that card’s chain; Review uses the session model. The runtime caps concurrent agents at min(16, CPUs − 2), and queues the rest.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/workflows/super-board-wave.js"], "opensView": "run-lanes", "sublabel": "Build → QA → Review"}, {"id": "run-merge", "label": "Merge gate", "kind": "step", "what": "Re-prove the branch under an atomic merge lock. Apply merge policy before squash-merging.", "when": "Once Review passes. Human-only steps park the card in Blocked.", "how": "Check the current base and permitted migrations. Match the PR head before merge; clean the worktree afterwards.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-policy.py"], "opensView": "merge-gate", "sublabel": "Prove + apply policy"}, {"id": "run-done", "label": "Done", "kind": "step", "what": "Squash-merge the approved PR and clean its worktree. Reconcile the returned card result.", "when": "After Review and the merge gate pass. Report the wave before selecting the next one.", "how": "Record merged, bounced, blocked or failed outcomes. Repeat waves until the board drains or a halt gate fires.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/hooks/cleanup-wt.py", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-gate.sh"], "opensView": "run-done", "sublabel": "Merge · clean · reconcile"}], "mainSteps": true, "lanes": false, "layout": {"sb-run": [0, 0], "run-classify": [1, 0], "run-preflight": [2, 0], "run-delegate": [3, 0], "run-merge": [4, 0], "run-done": [5, 0]}, "nodeOverrides": {"sb-run": {"label": "Run a wave", "verbs": [], "sublabel": "Claim ready cards", "opensView": "run-start"}}}, {"id": "super-build", "parent": "super-board", "title": "super-build · skills by ticket type", "caption": "An explicit `Skills:` line wins; otherwise the type label picks the chain. Each PR stays under 400 changed lines. grilling is forbidden here and lives in lint.", "nodeIds": ["super-build", "ponytail", "implement", "diagnosing-bugs", "codebase-design", "tdd", "context7", "verification", "code-review", "resolving-merge-conflicts", "ask-matt", "gh-board", "pr-body", "humanizer"], "edges": ["b-pony", "b-impl", "b-diag", "b-design", "b-tdd", "b-docs", "b-verify", "b-review", "b-conflict", "b-askmatt", "b-gh", "super-build-prbody", "super-build-human"], "nodeOverrides": {"verification": {"label": "verification"}, "resolving-merge-conflicts": {"label": "resolve conflicts"}}}, {"id": "super-qa", "parent": "super-board", "title": "super-qa · test plan, gap check, evidence", "caption": "Issue-scoped inside a run (qa-labelled cards skip Building); standalone it crawls routes and files onto the Super Ultimate QA board.", "nodeIds": ["super-qa", "tdd", "tdd-v2", "diagnosing-bugs", "verification", "ask-matt", "testing-strategy", "vitest", "playwright-bp", "gh-board", "file-bug", "qa-board", "pr-body", "humanizer"], "edges": ["q-tdd", "q-tddv2", "q-diag", "q-verify", "q-askmatt", "q-strat", "q-vitest", "q-pw", "q-gh", "q-filebug", "filebug-qaboard", "super-qa-prbody", "super-qa-human"], "nodeOverrides": {"verification": {"label": "verification"}, "playwright-bp": {"label": "Playwright practices"}}}, {"id": "super-review", "parent": "super-board", "title": "super-review · own pass, memory, merge gate", "caption": "Fresh review, adversarial grounding and refactor findings. Passing review enters the merge gate; human-only steps open their own view.", "nodeIds": ["super-review", "code-review", "codebase-design", "ponytail-review", "file-refactor", "merge-gate", "gh-board", "pr-body", "humanizer", "needs-you"], "edges": ["v-cr", "v-design", "v-pony", "v-refactor", "review-gate", "v-gh", "super-review-prbody", "super-review-human", "review-needsyou"], "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "super-collect", "parent": "root", "title": "/super-collect · fetch, verify, file", "caption": "Fetch sources → verify → confirm → file to Backlog. Five built-in sources plus custom ones; collecting never moves a card to Ready.", "nodeIds": ["collect-fetch", "collect-verify", "collect-confirm", "collect-submit"], "edges": [{"from": "collect-fetch", "to": "collect-verify", "label": "candidates"}, {"from": "collect-verify", "to": "collect-confirm", "label": "real ones"}, {"from": "collect-confirm", "to": "collect-submit", "label": "on yes"}], "nodes": [{"id": "collect-fetch", "label": "Fetch sources", "kind": "step", "what": "Fetch the enabled built-in sources. Include any custom sources added in onboard.", "when": "When /super-collect runs for the project. Use the requested window or the default 14 days.", "how": "Read the selected adapters and findings. Send each candidate to a fresh verifier.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-sources", "sublabel": "Last 14 days by default"}, {"id": "collect-verify", "label": "Verify", "kind": "step", "what": "Check whether each candidate is real and still happening. Reject fixed or duplicate problems.", "when": "After source adapters return candidates. Use one fresh verifier for each candidate.", "how": "Verify against the project evidence. Mark unclear candidates needs-triage before filing.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-verify", "sublabel": "One fresh check each"}, {"id": "collect-confirm", "label": "Confirm", "kind": "step", "what": "Show the proposed filing plan. Keep collection dry-run by default.", "when": "After verification produces the candidate results. Before writing tickets to the board.", "how": "Present the plan table for confirmation. Use --yes when filing is already authorized.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"], "opensView": "collect-confirm", "sublabel": "Dry run until you say yes"}, {"id": "collect-submit", "label": "File to Backlog", "kind": "step", "what": "File verified problems into Backlog. Apply fingerprints and duplicate checks.", "when": "After confirmation or an authorized --yes run. File candidates marked file or needs-triage.", "how": "Use one filing entry point for all sources. Route bugs, features and fixes separately from refactors.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/scripts/super-collect-file.sh"], "opensView": "collect-submit", "sublabel": "Then lint"}], "mainSteps": true, "render": "process", "lanes": false, "layout": {"collect-fetch": [0, 0], "collect-verify": [1, 0], "collect-confirm": [2, 0], "collect-submit": [3, 0]}, "intake": [{"label": "Sentry", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMzNjJENTkiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+U2VudHJ5PC90aXRsZT48cGF0aCBkPSJNMTMuOTEgMi41MDVjLS44NzMtMS40NDgtMi45NzItMS40NDgtMy44NDQgMEw2LjkwNCA3LjkyYTE1LjQ3OCAxNS40NzggMCAwIDEgOC41MyAxMi44MTFoLTIuMjIxQTEzLjMwMSAxMy4zMDEgMCAwIDAgNS43ODQgOS44MTRsLTIuOTI2IDUuMDZhNy42NSA3LjY1IDAgMCAxIDQuNDM1IDUuODQ4SDIuMTk0YS4zNjUuMzY1IDAgMCAxLS4yOTgtLjUzNGwxLjQxMy0yLjQwMmE1LjE2IDUuMTYgMCAwIDAtMS42MTQtLjkxM0wuMjk2IDE5LjI3NWEyLjE4MiAyLjE4MiAwIDAgMCAuODEyIDIuOTk5IDIuMjQgMi4yNCAwIDAgMCAxLjA4Ni4yODhoNi45ODNhOS4zMjIgOS4zMjIgMCAwIDAtMy44NDUtOC4zMThsMS4xMS0xLjkyMmExMS40NyAxMS40NyAwIDAgMSA0Ljk1IDEwLjI0aDUuOTE1YTE3LjI0MiAxNy4yNDIgMCAwIDAtNy44ODUtMTUuMjhsMi4yNDQtMy44NDVhLjM3LjM3IDAgMCAxIC41MDQtLjEzYy4yNTUuMTQgOS43NSAxNi43MDggOS45MjggMTYuOWEuMzY1LjM2NSAwIDAgMS0uMzI3LjU0M2gtMi4yODdjLjAyOS42MTIuMDI5IDEuMjIzIDAgMS44MzFoMi4yOTdhMi4yMDYgMi4yMDYgMCAwIDAgMS45MjItMy4zMXoiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "PostHog", "logo": "data:image/svg+xml;base64,PHN2ZyByb2xlPSJpbWciIGZpbGw9IiMwMDAwMDAiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48dGl0bGU+UG9zdEhvZzwvdGl0bGU+PHBhdGggZD0iTTkuODU0IDE0LjUgNSA5LjY0Ny44NTQgNS41QS41LjUgMCAwIDAgMCA1Ljg1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ni4zNTNMNSAxMy42NDdsLjE0Ny4xNDZMOS44NTQgMTguNWwuMTQ2LjE0N3YtLjA0OWMuMDY1LjAzLjEzNC4wNDkuMjA3LjA0OWgyLjU4NmEuNS41IDAgMCAwIC4zNTMtLjg1NEw5Ljg1NCAxNC41em0wLTUtNC00YS40ODcuNDg3IDAgMCAwLS40MDktLjE0NC41MTUuNTE1IDAgMCAwLS4zNTYuMjEuNDkzLjQ5MyAwIDAgMC0uMDg5LjI4OFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsOSA5YS41LjUgMCAwIDAgLjg1My0uMzU0di0yLjU4NWEuNS41IDAgMCAwLS4xNDYtLjM1NGwtNS01em0xLTRhLjUuNSAwIDAgMC0uODU0LjM1NFY4LjQ0YS41LjUgMCAwIDAgLjE0Ny4zNTNsNCA0YS41LjUgMCAwIDAgLjg1My0uMzU0VjkuODU0YS41LjUgMCAwIDAtLjE0Ni0uMzU0bC00LTR6bTEyLjY0NyAxMS41MTVhMy44NjMgMy44NjMgMCAwIDEtMi4yMzItMS4xbC00LjcwOC00LjcwN2EuNS41IDAgMCAwLS44NTQuMzU0djYuNTg1YS41LjUgMCAwIDAgLjUuNUgyMy41YS41LjUgMCAwIDAgLjUtLjV2LS42YzAtLjI3Ni0uMjI1LS40OTctLjQ5OS0uNTMyem0tNS4zOTQuMDMyYS44LjggMCAxIDEgMC0xLjYuOC44IDAgMCAxIDAgMS42ek0uODU0IDE1LjVhLjUuNSAwIDAgMC0uODU0LjM1NHYyLjI5M2EuNS41IDAgMCAwIC41LjVoMi4yOTNjLjIyMiAwIC4zOS0uMTM1LjQ2Mi0uMzA5YS40OTMuNDkzIDAgMCAwLS4xMDktLjU0NUwuODU0IDE1LjUwMXpNNSAxNC42NDcuODU0IDEwLjVhLjUuNSAwIDAgMC0uODU0LjM1M3YyLjU4NmEuNS41IDAgMCAwIC4xNDYuMzUzTDQuODU0IDE4LjVsLjE0Ni4xNDdoMi43OTNhLjUuNSAwIDAgMCAuMzUzLS44NTRMNSAxNC42NDd6Ii8+PC9zdmc+", "to": "collect-fetch"}, {"label": "GitHub issues", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "Merged PRs", "logo": "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAyNC40MjciIGhlaWdodD0iOTk4LjgyNyIgdmlld0JveD0iLTAuNDI3IDAgMTAyNC40MjcgOTk4LjgyNyIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiBmaWxsPSJub25lIj48cGF0aCBmaWxsPSIjMWIxZjIzIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik01MTIgMEMyMjkuMTIgMCAwIDIyOS4xMiAwIDUxMmMwIDIyNi41NiAxNDYuNTYgNDE3LjkyIDM1MC4wOCA0ODUuNzYgMjUuNiA0LjQ4IDM1LjItMTAuODggMzUuMi0yNC4zMiAwLTEyLjE2LS42NC01Mi40OC0uNjQtOTUuMzYtMTI4LjY0IDIzLjY4LTE2MS45Mi0zMS4zNi0xNzIuMTYtNjAuMTYtNS43Ni0xNC43Mi0zMC43Mi02MC4xNi01Mi40OC03Mi4zMi0xNy45Mi05LjYtNDMuNTItMzMuMjgtLjY0LTMzLjkyIDQwLjMyLS42NCA2OS4xMiAzNy4xMiA3OC43MiA1Mi40OCA0Ni4wOCA3Ny40NCAxMTkuNjggNTUuNjggMTQ5LjEyIDQyLjI0IDQuNDgtMzMuMjggMTcuOTItNTUuNjggMzIuNjQtNjguNDgtMTEzLjkyLTEyLjgtMjMyLjk2LTU2Ljk2LTIzMi45Ni0yNTIuOCAwLTU1LjY4IDE5Ljg0LTEwMS43NiA1Mi40OC0xMzcuNi01LjEyLTEyLjgtMjMuMDQtNjUuMjggNS4xMi0xMzUuNjggMCAwIDQyLjg4LTEzLjQ0IDE0MC44IDUyLjQ4IDQwLjk2LTExLjUyIDg0LjQ4LTE3LjI4IDEyOC0xNy4yOHM4Ny4wNCA1Ljc2IDEyOCAxNy4yOGM5Ny45Mi02Ni41NiAxNDAuOC01Mi40OCAxNDAuOC01Mi40OCAyOC4xNiA3MC40IDEwLjI0IDEyMi44OCA1LjEyIDEzNS42OCAzMi42NCAzNS44NCA1Mi40OCA4MS4yOCA1Mi40OCAxMzcuNiAwIDE5Ni40OC0xMTkuNjggMjQwLTIzMy42IDI1Mi44IDE4LjU2IDE2IDM0LjU2IDQ2LjcyIDM0LjU2IDk0LjcyIDAgNjguNDgtLjY0IDEyMy41Mi0uNjQgMTQwLjggMCAxMy40NCA5LjYgMjkuNDQgMzUuMiAyNC4zMkM4NzcuNDQgOTI5LjkyIDEwMjQgNzM3LjkyIDEwMjQgNTEyIDEwMjQgMjI5LjEyIDc5NC44OCAwIDUxMiAwIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=", "to": "collect-fetch"}, {"label": "Architecture", "mark": "◇", "to": "collect-fetch"}, {"label": "custom", "mark": "+", "dashed": true, "to": "collect-fetch"}]}, {"id": "ui-refine-loop", "parent": "root", "title": "/ui-refine-loop · main steps", "caption": "Standalone: direction → check → fix → review → draft PR. Default 5 rounds; stop after two clean P0/P1 checks, two reverted rounds or a dead agent.", "nodeIds": ["ui-refine-loop", "refine-brief", "refine-check", "refine-fix", "refine-review", "refine-pr", "grilling", "impeccable", "verbs-group", "humanizer"], "edges": [{"from": "ui-refine-loop", "to": "refine-brief", "label": ""}, {"from": "refine-brief", "to": "refine-check", "label": ""}, {"from": "refine-check", "to": "refine-fix", "label": ""}, {"from": "refine-fix", "to": "refine-review", "label": ""}, {"from": "refine-review", "to": "refine-pr", "label": ""}], "render": "process", "nodes": [{"id": "refine-brief", "label": "Grill + save direction", "kind": "step", "what": "Read the target code and clarify the intended UI. Save taste and direction for the loop.", "when": "At the start of a standalone refine task. Before unattended checking and fixing begins.", "how": "Ask at most ten questions. Write the agreed direction into the taste file.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-brief", "sublabel": "Agree what good means"}, {"id": "refine-check", "label": "Check the UI", "kind": "step", "what": "Use fresh checkers to identify UI problems. Rank typed findings before a fix.", "when": "At the start of each refinement round. Check the chosen page or component.", "how": "Capture screenshots and run critique or audit. Route typed findings to the appropriate fix verbs.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-check", "sublabel": "Rank typed problems"}, {"id": "refine-fix", "label": "Fix by routed verbs", "kind": "step", "what": "Apply the Impeccable verbs matched to the findings. Run polish last.", "when": "After checkers have ranked the problems. Use a fresh fixer for the round.", "how": "Chain the verbs in their prescribed order. Keep additive motion within the brief’s permission.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-fix", "sublabel": "Polish comes last"}, {"id": "refine-review", "label": "Review each fix", "kind": "step", "what": "Grade every fix with a finish reviewer. Record or revert each round.", "when": "After the round’s fixer completes. Run five rounds by default unless a stop condition fires.", "how": "Write the outcome to the refine ledger. Stop after two clean checks, two reverted rounds or a dead agent.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/workflows/ui-refine-loop.js"], "opensView": "refine-review", "sublabel": "Default: 5 rounds"}, {"id": "refine-pr", "label": "Draft the PR", "kind": "step", "what": "Create the final draft PR. Include a Before | After evidence table.", "when": "When the standalone refinement loop finishes. After fixes have received their finish review.", "how": "Use the PR body marker blocks. Follow the writing standard with humanizer.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/ui-refine-loop/scripts/pr-shots.sh"], "opensView": "refine-pr", "sublabel": "Before | After evidence"}], "mainSteps": true, "lanes": false, "layout": {"ui-refine-loop": [0, 0], "refine-brief": [1, 0], "refine-check": [2, 0], "refine-fix": [3, 0], "refine-review": [4, 0], "refine-pr": [5, 0], "grilling": [1, 1], "impeccable": [2, 1], "verbs-group": [3, 1], "humanizer": [4, 1]}, "nodeOverrides": {"ui-refine-loop": {"label": "Refine a UI", "verbs": [], "sublabel": "Page or component", "opensView": "refine-brief"}, "grilling": {"verbs": []}, "impeccable": {"verbs": []}, "verbs-group": {"verbs": []}, "humanizer": {"verbs": []}}, "stepIds": ["ui-refine-loop", "refine-brief", "refine-check", "refine-fix", "refine-review", "refine-pr"], "containers": [{"id": "refine-family", "label": "/ui-refine-loop · standalone refinement", "nodeIds": ["ui-refine-loop", "refine-pr"]}, {"id": "refine-brief-family", "parent": "refine-family", "label": "Direction · tools", "nodeIds": ["refine-brief", "grilling"]}, {"id": "refine-check-family", "parent": "refine-family", "label": "Check · tools", "nodeIds": ["refine-check", "impeccable"]}, {"id": "refine-fix-family", "parent": "refine-family", "label": "Fix · tools", "nodeIds": ["refine-fix", "verbs-group"]}, {"id": "refine-review-family", "parent": "refine-family", "label": "Review · tools", "nodeIds": ["refine-review", "humanizer"]}]}, {"id": "impeccable-verbs", "parent": "ui-refine-loop", "title": "impeccable fix verbs · routing", "caption": "Chain order: distill/extract, then layout/adapt, then typeset/colorize/quieter/bolder, then clarify/harden/onboard, then animate/delight/optimize, and polish last.", "nodeIds": ["verbs-group", "v-distill", "v-extract", "v-layout", "v-adapt", "v-typeset", "v-colorize", "v-quieter", "v-bolder", "v-clarify", "v-harden", "v-onboard", "late-verbs", "v-polish"], "edges": ["iv-v-distill", "iv-v-extract", "iv-v-layout", "iv-v-adapt", "iv-v-typeset", "iv-v-colorize", "iv-v-quieter", "iv-v-bolder", "iv-v-clarify", "iv-v-harden", "iv-v-onboard", "iv-late-verbs", "u-verbs-polish"]}, {"id": "late-verbs", "parent": "impeccable-verbs", "title": "motion + perf verbs", "caption": "The last tier before polish; animate and delight are additive and need the brief's go-ahead.", "nodeIds": ["late-verbs", "v-animate", "v-delight", "v-optimize", "v-polish"], "edges": ["lv-animate", "lv-delight", "lv-optimize", "lv-del-anim", "lv-polish"]}, {"id": "impeccable", "parent": "ui-refine-loop", "title": "impeccable · how its commands connect", "caption": "From the Impeccable command table and diagrams/impeccable/commands.json; the loop never runs shape, live or overdrive.", "nodeIds": ["impeccable", "v-init", "v-document", "v-shape", "v-critique", "v-audit", "v-harden", "v-optimize", "v-polish", "v-live", "v-overdrive", "verbs-group"], "edges": ["im-init", "im-critique", "im-audit", "im-shape", "im-live", "im-overdrive", "im-verbs"]}, {"id": "visual", "parent": "root", "title": "/visual · one page", "caption": "Triggers no other skill; one helper script does detection, git facts and rendering.", "nodeIds": ["visual", "visual-py", "base-branch"], "edges": ["vi-py", "vi-py-base"], "layout": {"visual": [0, 0], "visual-py": [1, 0], "base-branch": [2, 2]}}, {"id": "hooks", "parent": "root", "title": "guard hooks · events and matchers", "caption": "Four guards and cleanup-wt are on by default; the push guard is opt-in; the eval gate and readme sync are dev-only.", "nodeIds": ["hooks", "guard-worktree-path", "guard-delete-outside", "guard-secrets", "guard-key-literals", "guard-protected-push", "cleanup-wt", "gate-skill-evals", "readme-sync"], "edges": ["h-wt", "h-del", "h-sec", "h-key", "h-session", "h-push", "h-gate", "h-readme"], "layout": {"hooks": [0, 2], "guard-worktree-path": [0, 7], "guard-delete-outside": [0, 3], "guard-secrets": [0, 0], "guard-key-literals": [0, 4], "guard-protected-push": [0, 5], "cleanup-wt": [0, 6], "gate-skill-evals": [1, 0], "readme-sync": [1, 1]}}, {"id": "tdd", "parent": "super-build", "title": "tdd · discipline", "caption": "tdd consults, it does not run sessions.", "nodeIds": ["tdd", "codebase-design", "code-review"], "edges": ["tdd-design", "tdd-cr"], "layout": {"tdd": [0, 0], "codebase-design": [1, 0], "code-review": [1, 2]}}, {"id": "tdd-v2", "parent": "super-qa", "title": "tdd-v2 · the testing ladder", "caption": "tdd-v2 owns the rung; tdd owns the loop.", "nodeIds": ["tdd-v2", "tdd"], "edges": ["tddv2-tdd"], "layout": {"tdd-v2": [0, 0], "tdd": [1, 0]}}, {"id": "implement", "parent": "super-build", "title": "implement · build then review", "caption": "EricOS local override of the mattpocock skill.", "nodeIds": ["implement", "tdd-v2", "tdd", "code-review"], "edges": ["impl-tddv2", "impl-tdd", "impl-cr"]}, {"id": "code-review", "parent": "super-build", "title": "code-review · two axes", "caption": "Standards and Spec run as parallel sub-agents and are reported side by side.", "nodeIds": ["code-review", "setup-matt-pocock-skills"], "edges": ["cr-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"code-review": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "diagnosing-bugs", "parent": "super-build", "title": "diagnosing-bugs · six phases", "caption": "Feedback loop, reproduce, hypothesise, instrument, fix + regression test, cleanup + post-mortem.", "nodeIds": ["diagnosing-bugs", "improve-codebase-architecture"], "edges": ["db-ica"], "layout": {"diagnosing-bugs": [0, 0], "improve-codebase-architecture": [1, 0]}}, {"id": "improve-codebase-architecture", "parent": "super-collect", "title": "improve-codebase-architecture", "caption": "super-collect's finder uses only the findings: no HTML report, no grilling.", "nodeIds": ["improve-codebase-architecture", "codebase-design", "grilling", "domain-modeling"], "edges": ["ica-design", "ica-grill", "ica-dm"]}, {"id": "ask-matt", "parent": "super-build", "title": "ask-matt · idea to ship", "caption": "The router's main flow and on-ramps; codebase-design is the other vocabulary underneath.", "nodeIds": ["ask-matt", "grill-with-docs", "handoff", "prototype", "to-spec", "to-tickets", "implement", "tdd", "code-review", "triage", "diagnosing-bugs", "wayfinder", "improve-codebase-architecture", "domain-modeling"], "edges": ["am-grill-with-docs", "am-handoff", "am-prototype", "am-to-spec", "am-to-tickets", "am-implement", "am-tdd", "am-code-review", "am-triage", "am-diagnosing-bugs", "am-wayfinder", "am-improve-codebase-architecture", "am-domain-modeling"]}, {"id": "grill-with-docs", "parent": "ask-matt", "title": "grill-with-docs", "caption": "The grilling primitive plus a paper trail.", "nodeIds": ["grill-with-docs", "grilling", "domain-modeling"], "edges": ["gwd-grill", "gwd-dm"], "layout": {"grill-with-docs": [0, 0], "grilling": [1, 0], "domain-modeling": [1, 2]}}, {"id": "to-spec", "parent": "ask-matt", "title": "to-spec", "caption": "Synthesis only, no interview.", "nodeIds": ["to-spec", "setup-matt-pocock-skills"], "edges": ["ts-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"to-spec": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "to-tickets", "parent": "ask-matt", "title": "to-tickets", "caption": "Tracer-bullet tickets with blocking edges.", "nodeIds": ["to-tickets", "setup-matt-pocock-skills"], "edges": ["tt-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}, "layout": {"to-tickets": [0, 0], "setup-matt-pocock-skills": [1, 0]}}, {"id": "triage", "parent": "ask-matt", "title": "triage · role state machine", "caption": "Only for issues you did not create.", "nodeIds": ["triage", "grilling", "domain-modeling", "setup-matt-pocock-skills"], "edges": ["tr-grill", "tr-dm", "tr-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}}, {"id": "wayfinder", "parent": "ask-matt", "title": "wayfinder · decision map", "caption": "Produces decisions, not deliverables; hands off to to-spec.", "nodeIds": ["wayfinder", "grilling", "domain-modeling", "prototype", "setup-matt-pocock-skills"], "edges": ["wf-grill", "wf-dm", "wf-proto", "wf-setup"], "nodeOverrides": {"setup-matt-pocock-skills": {"label": "setup Matt skills"}}}, {"id": "sb-onboard", "parent": "super-board", "title": "/super-board onboard · setup", "caption": "Eight questions, grouped into five phases. Answers save as you go; files change once at the final “Write everything” step.", "nodeIds": ["sb-onboard", "onboard-checks", "onboard-project", "onboard-policies", "onboard-sources", "onboard-write"], "edges": [{"from": "sb-onboard", "to": "onboard-checks", "label": ""}, {"from": "onboard-checks", "to": "onboard-project", "label": ""}, {"from": "onboard-project", "to": "onboard-policies", "label": ""}, {"from": "onboard-policies", "to": "onboard-sources", "label": ""}, {"from": "onboard-sources", "to": "onboard-write", "label": ""}], "render": "process", "nodes": [{"id": "onboard-checks", "label": "Check prerequisites", "kind": "step", "what": "Check required tools and GitHub access. Repair missing installation prerequisites.", "when": "At the first Checks and GitHub setup questions. Re-run onboard to repair an existing setup.", "how": "Run the setup helper for must-haves. Save answers as each question completes.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-checks", "sublabel": "Checks · GitHub"}, {"id": "onboard-project", "label": "Choose board + branch", "kind": "step", "what": "Choose the GitHub Project board. Choose the repository’s base branch.", "when": "During the Board and Branch questions. After required tools and GitHub access are ready.", "how": "Record the board and branch in the saved answers. Write the config only after the final review.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-project", "sublabel": "Board · Branch"}, {"id": "onboard-policies", "label": "Set standards + policy", "kind": "step", "what": "Set AGENTS.md standards and merge policies. Choose whether to protect base-branch pushes.", "when": "During the AGENTS.md and Policies questions. Before the final write of repository files.", "how": "Generate the standards and hook settings. Enable the protected-push guard only when chosen.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-policies", "sublabel": "AGENTS.md · Policies"}, {"id": "onboard-sources", "label": "Choose bug sources", "kind": "step", "what": "Enable built-in collection sources. Add any custom source fetchers.", "when": "During the Bug sources setup question. After standards and policies are selected.", "how": "Save source choices in the collect config. Review all answers before writing files.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-collect/SKILL.md"], "opensView": "onboard-sources", "sublabel": "Bug sources"}, {"id": "onboard-write", "label": "Review + write once", "kind": "step", "what": "Review all saved setup answers. Write repository files once at step eight.", "when": "When the owner chooses “Write everything”. After all setup questions are complete.", "how": "Apply the setup and config writes together. End by naming /super-board lint as the next command.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/onboard.md", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-setup.py"], "opensView": "onboard-write", "sublabel": "Review · then lint"}], "mainSteps": true, "lanes": false, "layout": {"sb-onboard": [0, 0], "onboard-checks": [1, 0], "onboard-project": [2, 0], "onboard-policies": [3, 0], "onboard-sources": [4, 0], "onboard-write": [5, 0]}, "nodeOverrides": {"sb-onboard": {"label": "Onboard", "sublabel": "New or existing project", "opensView": "onboard-checks"}}}, {"id": "install", "parent": "root", "title": "install · get.sh, plugin, install.sh", "caption": "Three ways in: the one-line get.sh, the plugin marketplace, or ./install.sh from a checkout. Onboard repairs whatever is missing.", "nodeIds": ["get-sh", "plugin-mkt", "install-sh", "upgrade-json", "setup-py", "sb-onboard", "settings-py", "claude-settings", "hooks"], "edges": ["get-install", "plugin-onboard", "install-upgrade", "upgrade-setup", "onb-setup", "setup-install", "install-settings", "settings-write", "r-install-hooks"], "nodeOverrides": {"plugin-mkt": {"label": "plugin marketplace install"}}, "layout": {"get-sh": [0, 1], "plugin-mkt": [0, 0], "install-sh": [1, 1], "sb-onboard": [1, 0], "upgrade-json": [2, 2], "settings-py": [2, 5], "hooks": [2, 0], "setup-py": [3, 1], "claude-settings": [3, 3]}}, {"id": "run-start", "parent": "super-board-run", "title": "Run trigger · planner and guards", "caption": "", "nodeIds": ["sb-run", "wave-plan", "run-manifest", "policy-usage-pause"], "edges": [{"from": "sb-run", "to": "wave-plan", "label": "plan"}, {"from": "sb-run", "to": "run-manifest", "label": "record"}, {"from": "sb-run", "to": "policy-usage-pause", "label": "guard"}], "node": "sb-run", "nodes": [{"id": "policy-usage-pause", "label": "Usage pause", "kind": "step", "what": "Pause when the rate or usage guard requires it. Report the reset time and remaining cards.", "when": "Before the planner at the start of a wave. Resume with /super-board run.", "how": "Check the rate guard and usage window. Halt on repeated zero progress, a high block rate or an explicit stop.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run-workflow.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "opensView": "usage-pause"}], "nodeOverrides": {"wave-plan": {"label": "wave planner"}}}, {"id": "usage-pause", "parent": "run-start", "title": "Usage pause · halt and resume", "caption": "", "nodeIds": ["policy-usage-pause", "sb-run", "sb-stop"], "edges": [{"from": "policy-usage-pause", "to": "sb-stop", "label": "halt"}, {"from": "policy-usage-pause", "to": "sb-run", "label": "resume"}], "node": "policy-usage-pause", "layout": {"policy-usage-pause": [0, 0], "sb-stop": [1, 0], "sb-run": [1, 2]}}, {"id": "run-classify", "parent": "super-board-run", "title": "Classifier · labels, planner and state", "caption": "", "nodeIds": ["run-classify", "wave-js", "wave-plan", "gh-board", "sb-config"], "edges": [{"from": "run-classify", "to": "wave-js", "label": "label routing"}, {"from": "run-classify", "to": "wave-plan", "label": "eligible cards"}, {"from": "run-classify", "to": "gh-board", "label": "board state"}, {"from": "run-classify", "to": "sb-config", "label": "worker tier"}], "node": "run-classify", "nodeOverrides": {"wave-plan": {"label": "wave planner"}}}, {"id": "run-preflight", "parent": "super-board-run", "title": "Pre-flight · readiness and size", "caption": "", "nodeIds": ["run-preflight", "preflight", "sb-lint", "policy-size-cap"], "edges": [{"from": "run-preflight", "to": "preflight", "label": "mechanical checks"}, {"from": "run-preflight", "to": "sb-lint", "label": "readiness"}, {"from": "run-preflight", "to": "policy-size-cap", "label": "size check"}], "node": "run-preflight", "nodes": [{"id": "policy-size-cap", "label": "400-line cap", "kind": "step", "what": "Keep each PR below 400 changed lines. Split a card that is too large.", "when": "During lint and pre-flight readiness checks. Recheck during Build and at the merge gate.", "how": "The Builder stops and proposes a /to-tickets split. Merge policy escalates a diff over auto_max_lines.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/SKILL.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/references/decision-policy.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-build/references/worker-preamble.md", "https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/run.md"], "opensView": "size-cap"}], "nodeOverrides": {"preflight": {"label": "pre-flight script"}}}, {"id": "size-cap", "parent": "run-preflight", "title": "400-line cap · split before building", "caption": "", "nodeIds": ["policy-size-cap", "super-build", "to-tickets", "merge-gate"], "edges": [{"from": "policy-size-cap", "to": "super-build", "label": "stop if too big"}, {"from": "policy-size-cap", "to": "to-tickets", "label": "split the card"}, {"from": "policy-size-cap", "to": "merge-gate", "label": "recheck diff"}], "node": "policy-size-cap", "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "run-lanes", "parent": "super-board-run", "title": "Delegate · Build → QA → Review", "caption": "Each card enters the lane selected by its label. Review gets a fresh context.", "nodeIds": ["run-delegate", "super-build", "super-qa", "super-review"], "edges": [{"from": "run-delegate", "to": "super-build", "label": "bug / feature"}, {"from": "run-delegate", "to": "super-qa", "label": "qa skips Build"}, "r-build-qa", "r-qa-review"], "node": "run-delegate", "lanes": [{"title": "Build", "nodeIds": ["super-build"]}, {"title": "QA", "nodeIds": ["super-qa"]}, {"title": "Review", "nodeIds": ["super-review"]}], "layout": {"run-delegate": [0, 0], "super-build": [1, 2], "super-qa": [2, 0], "super-review": [3, 0]}}, {"id": "merge-gate", "parent": "super-board-run", "title": "Merge gate · proof, policy and human handoff", "caption": "", "nodeIds": ["merge-gate", "policy-merge", "needs-you", "cleanup-wt", "base-branch", "guard-protected-push"], "edges": [{"from": "merge-gate", "to": "policy-merge", "label": "who may merge?"}, "gate-needsyou", "gate-cleanup", "gate-base", {"from": "merge-gate", "to": "guard-protected-push", "label": "protect base"}], "node": "merge-gate", "nodes": [{"id": "policy-merge", "label": "Merge policy", "kind": "step", "what": "Decide whether the robot can merge. Route sensitive changes and human steps to needs-you.", "when": "After Review passes. Decide inside the atomic merge lock.", "how": "Exit 7 for money, auth, destructive schema or excessive size. Exit 8 for a disallowed migration or declared human step.", "source": ["https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-gate.sh", "https://github.com/mnphuc/super-board-gitea/blob/main/scripts/super-board-merge-policy.py"], "opensView": "merge-policy"}], "lanes": [{"title": "Policy", "nodeIds": ["policy-merge", "needs-you", "guard-protected-push"]}, {"title": "Finish", "nodeIds": ["cleanup-wt", "base-branch"]}], "nodeOverrides": {"merge-gate": {"label": "merge gate script"}}}, {"id": "merge-policy", "parent": "merge-gate", "title": "Merge policy · automatic or human", "caption": "", "nodeIds": ["policy-merge", "policy-size-cap", "needs-you"], "edges": [{"from": "policy-merge", "to": "policy-size-cap", "label": "diff limit"}, {"from": "policy-merge", "to": "needs-you", "label": "human-only step"}], "node": "policy-merge", "layout": {"policy-merge": [0, 1], "policy-size-cap": [1, 0], "needs-you": [1, 1]}}, {"id": "needs-you", "parent": "merge-gate", "title": "Needs you · human handoff and resume", "caption": "", "nodeIds": ["needs-you", "wave-plan", "super-review"], "edges": ["needsyou-plan", {"from": "needs-you", "to": "super-review", "label": "done → re-review"}], "node": "needs-you", "nodeOverrides": {"wave-plan": {"label": "wave planner"}}, "layout": {"needs-you": [0, 0], "wave-plan": [1, 0], "super-review": [1, 2]}}, {"id": "guard-protected-push", "parent": "merge-gate", "title": "Protected push · opt-in base guard", "caption": "", "nodeIds": ["guard-protected-push", "sb-onboard", "install-sh", "claude-settings"], "edges": [{"from": "guard-protected-push", "to": "sb-onboard", "label": "Policies yes"}, {"from": "guard-protected-push", "to": "install-sh", "label": "--protect-main"}, {"from": "guard-protected-push", "to": "claude-settings", "label": "PreToolUse Bash"}], "node": "guard-protected-push"}, {"id": "run-done", "parent": "super-board-run", "title": "Done · cleanup and reconciliation", "caption": "", "nodeIds": ["run-done", "cleanup-wt", "base-branch", "run-manifest", "gh-board"], "edges": [{"from": "run-done", "to": "cleanup-wt", "label": "remove worktree"}, {"from": "run-done", "to": "base-branch", "label": "merged head"}, {"from": "run-done", "to": "run-manifest", "label": "reconcile"}, {"from": "run-done", "to": "gh-board", "label": "update cards"}], "node": "run-done"}, {"id": "onboard-checks", "parent": "sb-onboard", "title": "Prerequisites · repair and install", "caption": "", "nodeIds": ["onboard-checks", "setup-py", "install-sh", "env-check", "onboard-answers"], "edges": [{"from": "onboard-checks", "to": "setup-py", "label": "repair"}, {"from": "onboard-checks", "to": "install-sh", "label": "install"}, {"from": "onboard-checks", "to": "env-check", "label": "tools + auth"}, {"from": "onboard-checks", "to": "onboard-answers", "label": "save answers"}], "node": "onboard-checks", "nodeOverrides": {"env-check": {"label": "environment check"}}}, {"id": "onboard-project", "parent": "sb-onboard", "title": "Project · board, branch and config", "caption": "", "nodeIds": ["onboard-project", "gh-board", "base-branch", "sb-config"], "edges": [{"from": "onboard-project", "to": "gh-board", "label": "choose board"}, {"from": "onboard-project", "to": "base-branch", "label": "choose base"}, {"from": "onboard-project", "to": "sb-config", "label": "save config"}], "node": "onboard-project"}, {"id": "onboard-policies", "parent": "sb-onboard", "title": "Standards + policies · files and guards", "caption": "", "nodeIds": ["onboard-policies", "agents-md-py", "agents-file", "settings-py", "claude-settings", "guard-protected-push", "policy-merge"], "edges": [{"from": "onboard-policies", "to": "agents-md-py", "label": "generate standards"}, {"from": "onboard-policies", "to": "agents-file", "label": "repo standards"}, {"from": "onboard-policies", "to": "settings-py", "label": "write settings"}, {"from": "onboard-policies", "to": "claude-settings", "label": "hook settings"}, {"from": "onboard-policies", "to": "guard-protected-push", "label": "opt-in guard"}, {"from": "onboard-policies", "to": "policy-merge", "label": "merge rules"}], "node": "onboard-policies", "nodeOverrides": {"agents-md-py": {"label": "standards writer"}}}, {"id": "onboard-sources", "parent": "sb-onboard", "title": "Sources · built-in and custom", "caption": "", "nodeIds": ["onboard-sources", "super-collect", "collect-custom", "sb-config"], "edges": [{"from": "onboard-sources", "to": "super-collect", "label": "five built-ins"}, {"from": "onboard-sources", "to": "collect-custom", "label": "custom fetcher"}, {"from": "onboard-sources", "to": "sb-config", "label": "enabled sources"}], "node": "onboard-sources"}, {"id": "onboard-write", "parent": "sb-onboard", "title": "Review · saved answers and final write", "caption": "", "nodeIds": ["onboard-write", "onboard-answers", "setup-py", "sb-config", "sb-lint"], "edges": [{"from": "onboard-write", "to": "onboard-answers", "label": "review answers"}, {"from": "onboard-write", "to": "setup-py", "label": "write everything"}, {"from": "onboard-write", "to": "sb-config", "label": "save once"}, {"from": "onboard-write", "to": "sb-lint", "label": "next command"}], "node": "onboard-write"}, {"id": "collect-sources", "parent": "super-collect", "title": "Fetch · source adapters", "caption": "", "nodeIds": ["collect-fetch", "collect-sentry", "collect-posthog", "gh-issues", "collect-prs", "improve-codebase-architecture", "collect-custom"], "edges": [{"from": "collect-fetch", "to": "collect-sentry", "label": "sentry"}, {"from": "collect-fetch", "to": "collect-posthog", "label": "posthog"}, {"from": "collect-fetch", "to": "gh-issues", "label": "github"}, {"from": "collect-fetch", "to": "collect-prs", "label": "prs"}, {"from": "collect-fetch", "to": "improve-codebase-architecture", "label": "architecture"}, {"from": "collect-fetch", "to": "collect-custom", "label": "custom"}], "node": "collect-fetch"}, {"id": "collect-verify", "parent": "super-collect", "title": "Verify · a fresh pass for every candidate", "caption": "", "nodeIds": ["collect-verify", "codebase-design", "ponytail-audit", "collect-file"], "edges": [{"from": "collect-verify", "to": "codebase-design", "label": "architecture vocabulary"}, {"from": "collect-verify", "to": "ponytail-audit", "label": "audit findings"}, {"from": "collect-verify", "to": "collect-file", "label": "file / needs-triage"}], "node": "collect-verify"}, {"id": "collect-confirm", "parent": "super-collect", "title": "Confirm · dry-run and enabled sources", "caption": "", "nodeIds": ["collect-confirm", "sb-config", "collect-file"], "edges": [{"from": "collect-confirm", "to": "sb-config", "label": "enabled sources"}, {"from": "collect-confirm", "to": "collect-file", "label": "confirm → --yes"}], "node": "collect-confirm", "layout": {"collect-confirm": [0, 0], "collect-file": [1, 0], "sb-config": [1, 2]}}, {"id": "collect-submit", "parent": "super-collect", "title": "File · one entry point and dedupe", "caption": "", "nodeIds": ["collect-submit", "collect-file", "file-bug", "file-refactor", "gh-board"], "edges": [{"from": "collect-submit", "to": "collect-file", "label": "single entry point"}, {"from": "collect-submit", "to": "file-bug", "label": "bug / feature / fix"}, {"from": "collect-submit", "to": "file-refactor", "label": "refactor"}, {"from": "collect-submit", "to": "gh-board", "label": "Backlog"}], "node": "collect-submit"}, {"id": "refine-brief", "parent": "ui-refine-loop", "title": "Direction · brief and taste", "caption": "", "nodeIds": ["refine-brief", "grilling", "taste-file", "sb-config"], "edges": [{"from": "refine-brief", "to": "grilling", "label": "at most 10 questions"}, {"from": "refine-brief", "to": "taste-file", "label": "save direction"}, {"from": "refine-brief", "to": "sb-config", "label": "refine settings"}], "node": "refine-brief"}, {"id": "refine-check", "parent": "ui-refine-loop", "title": "Check · screenshot, critique and audit", "caption": "", "nodeIds": ["refine-check", "shoot", "v-critique", "imp-detect", "v-audit", "impeccable"], "edges": [{"from": "refine-check", "to": "shoot", "label": "screenshots"}, {"from": "refine-check", "to": "v-critique", "label": "design problems"}, {"from": "refine-check", "to": "imp-detect", "label": "typed checker"}, {"from": "refine-check", "to": "v-audit", "label": "functional audit"}, {"from": "refine-check", "to": "impeccable", "label": "command reference"}], "node": "refine-check"}, {"id": "refine-fix", "parent": "ui-refine-loop", "title": "Fix · routed verbs, polish last", "caption": "", "nodeIds": ["refine-fix", "verbs-group", "v-polish"], "edges": [{"from": "refine-fix", "to": "verbs-group", "label": "route by problem"}, {"from": "verbs-group", "to": "v-polish", "label": "last"}], "node": "refine-fix", "layout": {"refine-fix": [0, 0], "verbs-group": [1, 0], "v-polish": [2, 0]}}, {"id": "refine-review", "parent": "ui-refine-loop", "title": "Review · ledger and finish standard", "caption": "", "nodeIds": ["refine-review", "refine-ledger", "humanizer"], "edges": [{"from": "refine-review", "to": "refine-ledger", "label": "grade / record / revert"}, {"from": "refine-review", "to": "humanizer", "label": "writing standard"}], "node": "refine-review", "layout": {"refine-review": [0, 0], "humanizer": [1, 0], "refine-ledger": [1, 2]}}, {"id": "refine-pr", "parent": "ui-refine-loop", "title": "Draft PR · evidence and marker blocks", "caption": "", "nodeIds": ["refine-pr", "draft-pr", "pr-body", "base-branch"], "edges": [{"from": "refine-pr", "to": "draft-pr", "label": "Before | After"}, {"from": "refine-pr", "to": "pr-body", "label": "marker blocks"}, {"from": "refine-pr", "to": "base-branch", "label": "standalone branch"}], "node": "refine-pr"}, {"id": "hook-settings", "parent": "hooks", "title": "Hook installation · settings and environment", "caption": "Install writes hook settings; onboard repairs installation. Merge policy has its own drill-down.", "nodeIds": ["install-sh", "settings-py", "claude-settings", "env-check", "merge-gate"], "edges": ["install-settings", "settings-write"], "nodeOverrides": {"env-check": {"label": "environment check"}, "merge-gate": {"label": "merge gate script"}}, "layout": {"install-sh": [0, 0], "env-check": [0, 1], "merge-gate": [0, 2], "settings-py": [1, 0], "claude-settings": [2, 3]}}, {"id": "sb-status", "parent": "super-board", "title": "/super-board status", "caption": "Inspect active work, lane outcomes and the dispatcher status without starting a worker.", "nodeIds": ["sb-status"], "edges": [], "layout": {"sb-status": [0, 0]}}, {"id": "sb-stop", "parent": "super-board", "title": "/super-board stop", "caption": "Halt the active dispatcher and report what was stopped.", "nodeIds": ["sb-stop"], "edges": [], "layout": {"sb-stop": [0, 0]}}, {"id": "git-sync", "parent": "root", "title": "/git-sync · commit, pull, push", "caption": "Standalone; no lane runs it. Merges, never rebases, and never force-pushes.", "nodeIds": ["git-sync", "base-branch", "resolving-merge-conflicts", "guard-protected-push"], "edges": ["gs-base", "gs-conflict", "gs-push"]}], "notes": ["Refreshed to super-board v3.0.0 (feat/sb-cleanup @ b67241e1, 28 commits after cd199b2d). Source paths are repo-root-relative.", "Board: seven columns, no Skipped (a dropped card is closed as not planned → Done with 🤷). Labels qa · bug · feature route cards; qa skips Building; the classifier adds feature or bug, never qa. The per-board `variant` is gone and a `qa-only` config is refused with exit 65 until onboard upgrades it.", "Onboarding is an 8-step wizard (Checks · GitHub · Board · Branch · AGENTS.md · Policies · Bug sources · Review) backed by super-board-setup.py (check, fix, migrate-config, names, branch, board-rank, board-migrate). New view sb-onboard; its steps are edge labels, not nodes.", "Merge policy and DB migrations live in the merge gate (super-board-merge-policy.py): money, auth, destructive schema or a diff over auto_max_lines (400 changed lines, lockfiles/generated/snapshots/migration SQL excluded) exits 7; a migration outside allowed_envs, a failed migrate or a declared human step exits 8. Both park the card in Blocked with the 🙋 checklist and the needs-you label, with no extra column; `done` sends it back through the planner's resume list.", "Builder pre-flight (super-board-preflight.sh, a Pre-flight phase in super-board-wave.js, batches of 5) checks already done / in progress / file overlap / unclear / too big before any card is built. Lint has 18 criteria now: 15 = too big (split via /to-tickets), 16–18 = ticket format.", "Writing standard (references/writing-standard.md): commits `<emoji> [type] scope: subject` + bullets, tickets Problem · Context · Fix · AC · Risk · Blocked by, PR bodies in marker blocks rewritten per lane with super-board-pr-body.sh, comments `[role] [label] status`, prose through humanizer when installed. That is why every lane view now shows pr-body and humanizer.", "super-collect gained custom sources (collect_custom.py: http, cli, mcp) added in onboard's \"➕ Add another source\", with fingerprint `custom|<name>|<key>` and the same verifier and filer.", "Install: get.sh one-liner, a plugin marketplace (skills only; onboard adds hooks, scripts and workflows), install.sh with grouped output and an upgrade record, and super-board-settings.py for hook and allow-line merges. There is a new install view under root. env-check (key names only) is allowed through guard-secrets. The AGENTS.md helper is super-board-agents-md.py.", "Added nodes: preflight, pr-body, needs-you, setup-py, agents-md-py, agents-file, settings-py, env-check, collect-custom, get-sh, plugin-mkt, onboard-answers, upgrade-json. Added views: sb-onboard, install. Removed edges: sb-onb-push (now settings-push in sb-onboard), h-install and h-ships (now install-sh → settings-py and install-sh → hooks). Nothing was renamed.", "Also since 88c27812: super-review truth-check sub-agents get a fixed verbatim brief (Over-engineering never blocks), and status lists columns in board order with Backlog. Disagreement: the coordinator listed 'labels qa/bug/feature routing'. That matches, with one addition: no label is also built (treated as feature).", "Kept as-is but stale in the files: the merge protocol and the wave.js `humanApprovesMerge` arg still mention human_approves_merge, which onboard now migrates into merge_policy. super-qa standalone still files onto the separate Super Ultimate QA board.", "The Builder only proposes a /to-tickets split in a PR comment when a build outgrows the cap; it does not run to-tickets, so there is no super-build → to-tickets edge. lint does dispatch it.", "Unchanged from v2: ui-refine-loop is standalone, now stated in super-review and super-qa as 'file a UI ticket; a human can run /ui-refine-loop'. cleanup-wt still runs at SessionStart and post-merge. qa-test-planner, testing-strategy, vitest and playwright-best-practices are still not installed in EricOS."], "authors": {"EricTechPro": {"name": "Eric Tech", "url": "https://github.com/EricTechPro", "avatar": "data:image/jpeg;base64,/9j/2wCEAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDIBCQkJDAsMGA0NGDIhHCEyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMv/AABEIAGAAYAMBIgACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/APcKKKKACiignAyelABRXm/i74y6D4cuGs7QHUbteG8px5a+xbnJ+lcU37Qd62RDpVuWPTe5AH4Clcdj32ivF9J+OzyuBqejqE/vWznI/A/416R4d8aaH4nBGnXeZlGWgkG1x+H+FFxWOgooopgFFFFABRRRQAjOqKWdgqjkk9q8R+L/AMS0W0GiaBfI5mDLdSxH7o6bc/nmvXtfcx+HtRcYyttIRk4HCmvjAD7bcsBuMjucjrSbGkUmySc5J7k05B82MV2mn+C5ZYQ5AJ9xV3/hCH4dFOfpWftYmyw89zlLSN9gO1PXBXn86vQ6jNp08c8DvDKhyrISCp9Qeoroo/CF0QMBtp4IA6Gql14F1Bo3aLLMmcjB5pe0iDpTS2Pefhp41bxforrc4+32m1ZSvSQEcN7E4OR7V29fO3wMuru08bXWnMpRHtm8wHPO0jH8zX0TWqMXuFFFFMQUUUUAQ3lut3ZT2zjKTRtGw9iMV8s+GvDgivbya6xmGdovbIPNfUeoyXEOm3MtqqtcJEzRq3QsBwK8S061muLaWTy8y3E8szqo7lyaxrSsrG9CF5XNax+wQQAvMq4/vcCtq0SxnTKMj57g1yyy6jADHF4diuhux+9uI0I98H/Gtuzs3NwgSDyMnDKpyB9D3FcrSSuejFu9jWdtNsVLTlFHqakgu9NueYF3DHJxWZrNrdWuZYbcXDgfKGOBn3PYUaLd65fW8RutKtbcnO5FnGVHY8ZB796Vk1cbk07E/h/RLfTviQLy2QKt1YSE/UOv+NejVy9tA8WsWMwxlQ8bH/ZYA/zUV1FddF3iebiIcs/UKKKK2MAooooAK8wkgOia7NZumE3lo/QoSSK9Prg/iHbtHNY3q9MGJj6dx/Wsq0bxN8PPlnY0IhayxiR40LepAqpFLE+oAKMKp69jXOwahMlsGZjs9arNJcz3YeC5KAnO0Ywa4eU9W5315JHFgsMqTjPpTYpIgnyYH0rCtVu2jY3VwWUr9wkYz/OqcF7Kty8QbKr0PtT5dQ5klqdnpg8+9LdoxmtysXw2payecjHmNgfQVtV3Uo2ieTXnzTYUUUVoYhRRRQAVm6/pa6xo89pxvI3Rk9nHT/D8aXWde0vw9Ym81a+htIBwGkPLH0AHJPsK861n47+H7fZDolvPqd1I2xQQYUGeBkkZ/DH5UmroabTujJs5gyS2VwuBkqQeoPoabpsFtp8xiaCCSIHIEseSB6A9u3Y1ii+aLVXnk/1czkuPQk9a7K3hs7pA+8ZwDXAnZnrwtJe8iTyLTUoRAltFHGQN+xMEj0zVi0sA17HY2qgMxwM9h3qeL7JZxEhh0pNFnaPVheMvQ8DPbpQnd3YquitFHfWtulpbRwJ91Bj6+9TVyNt8SPDjam+l3t4thqEchjaK44XI7h/u4PbJB9q6yORJY1kjdXRhlWU5BHqDXerW0PJd76jqKKKYjN1vX9K8OWBvdWvY7WDO0F+Sx9AByT9K8W8Y/HuV91r4VhMQB5vLhAWP+6hyB9T+QrybxD4k1XxPqkl/ql080jE7Vz8sY9FHYVjkc0AaOteIdW8RXn2rVr+a7m7GRuFHoB0A9hVXTZ1tdUtbh/uxyq7fQEVWpKGgPZZIlngBUgjGQR3qzpxaLClnA7FTXmmi+LbjTIFtpo/PgX7vOGUeldJD8QdPRRm3nB9MD/GuOVKSZ3xrwa1Z6RbRM7BmZm/3jmrmoaxaeH9Jlv7t8RxDhR1Y9gPc15nN8U4IosWthK8n/TRgoH5Zridc8S6l4huBJey/u1+5EnCL+H9apUm9yZ14rYj1DUptU1O5v5j+9nlaRvYk5xXXeG/it4j8LWCWFrLDPaoSyRXCbgueSAQQQPbNcKpwowKRicV0I5HqfV3gT4naV4xgjgkK2eq4+a1ZuH90J6/Tr/Ou5r4cLbApViCvQjtXtfw6+L1tpWmjTPEtxcSInMF0QZCq/wB1u5HoeeuO1MVj/9k="}, "mattpocock": {"name": "Matt Pocock", "url": "https://github.com/mattpocock", "avatar": "data:image/png;base64,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"}, "DietrichGebert": {"name": "Dietrich Gebert", "url": "https://github.com/DietrichGebert", "avatar": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAABgCAIAAABt+uBvAAA/40lEQVR4nGT9SaxtWZImBC+z1ezudLd7rfcR4dFVZP2Vv6hMkipVklBCggFTkJgwQjVAYsIICabMQUKMkFBJMCgokFBVUllkZFQSkRHh0XhGhEfrvb/2tqfb3WrMkK197nVPeP703rv3nLvP3mtZ831mny03/91//4+r0j16eGKtvby87Dx/9OR6O3JIKgRiRaSYmfMfCADyb620xhgT51eUAqUAMLx1dvL1R4s375enJ8sQUz/wzTi8vNxer/1m17eRhqQudv0QkmJChfnHVMqXMRqNNUyUKKXEiRgQVf5YpQ5/E8vN5M8DJX/JzUB+Q2KF8g15JTFV1s6te/u1e3/r7dPjxaIuoTRsUAMiAJKKF5eb55fty4v9882464eiKEihj7Ebxq7rlcJ9N4REidG4olQAbTsgDtfXW+PKwhkIiUJUkG+HId/i4a5U/gJRI3KMEeSmlLNYKvjX3jj+1//W/dKxdu76eoCkRuCqKu1+fPhgYZ1NBL/86Pyzy41x1hhttAGFu/2ekkopIHJVlMR6GEZE0KiJOKSUN0CWkpPCz28D5M7gsFzACmQDCREKq0+P5ibGRW3qsgTFTECkjIOqMvN5pa16dLJYzdZd//F2DKwqTxRCWG82oA0iGu2cTYFGVGxu1tv5rLnZ7BG5cGUi0giKSfZn2idZp7wM033Jv8hqnVcHEVTp7L2mujefv/agrmfWaFlehYZVpEQxxhh8WZZOY0jh3rwYfWmsVQpCJDAYRkyaU1IGsShstkomVta6tu3EZpUCBs43Iasy3VP+S94p5iULJ3dibdNU86aeV+5sUT66fyweQGkcY6FLq3VTFdYahYRWrZr64b0zr1p/vm67/W7fa+Nms3nf98PgFbB1JkU2RHyz3S7ms6bA+/ePuq5nW279Zowj320SHu6Lp68BSZxPiRUpKqwdwthFMJrHMfaURk/dAD6EGAMoWC7mwzicHC073j84ns3rYj+MSkHXD7owM7fYdcPgozEWmIBVYW0k8aq6rjvxyHRw7ds9ymvCSrZR/iL5li5LPWvKCvWytG8+ODk7apyTjbTGgopE0dnKWqtYUVJtu+97n5h3+27XtoP31pm6mQ+Dn/wYlLKoFSYDzFVZGe2stUVhNcJ114aQyqoc9704tRh3vhuxKjUt1XTT8gWrYezB6sdHi7qq2jb0Id7se2VKzSrFxCkcHTUpOqu5Kkul/K7vUwyIunRmNqtPFma3a7ddJNCbdlh3e1YSKTSa0XsihSD/UaDJvQ9+P91H9jSjoKnsqw+PFmWpmU6P6+XCakyFLbSRUGYAC2uyczInaLvh6flms077ru+GQIDZFXAYhrbttLZKkTM2hkQAppk1kWG37/perXctav3i4qYfyacRxYQ0o+wWAGitDkGZAZUisXjWoBUkpfjNB2eo7Xa3i4iJIQy9Bl0W7pWHjUZMRKNPY4gSI1zByoXog/cpSdQw1pUOIqtuGMYQctRDZo8ABEqjTokkHstWfcHXeAqM6Iz5xldeP125EjD64DRSIiyNlTCnNFO2P2Kl/BBSTC8vd89eDiwfAUnRers1xmkjsaquKiJyukTU3ehV8Kaum4vrtVIYklr3vY9xHGPeNsw+NcXAvPj5vylg5sXJWwhi4KfLuqyKaTcQTVPZfhwKV6A2Sd4GNBJIuEgpxfxjTPnXfn0FcYA4cLsd9tfNbmvGvVI6QTGoKtg5lEdUrQBMdu28U3fJQtYOFfPxycIa1MwawacApuAkVmdQGQ3IrJUyGhFVTByTrHak0Pdp3Y7r9QYRUoqAoI1JMUXvj5aL5bxe79t9b8y2G0JMkULTzCHEGCkkMsYgqaRuU7hSEnRUysHosH8AymhVFfBg0XzlwZI49ANpLY9SFq4oXZJfhKBiIqbko1hE8CGGOLabfn0+bs8htqWGFHwce/S+GIdCqRBj1/V69CnFSIzNQ/Po96C5HxnuwmJOIOAKSbr1zMYwIolDOWvC6Gd1WVhtNDiDTqNFrutCa2QmkjQP1undbqBAjeQlNXKCfEkmKg289vDkwenyYr3/4MmF2bd9348kS7BDCWlaXBJMXhGJQEYjEO3HGEBDDokgjszW0d/78sO3H8xtYaK8W1y6sHZmtM6YhImHMCZWiZTkNebkh835p+uLJ77bKIahH7TRCSiOHccRWVljE5ExejazqFsdvJJgufWf/LmuTvD4G2H52mSSOfwxJ7IGh3a8Gcb7s/tGG2XlBusaqxKr0jaVKbSyBq01xCoGHoYwDB4Bj1fz1ZKXq+pXn1zuxyC+7aNmXM7rWQ2F09aYOI4mElvnisKFmABxVjjvRw3KIi9mpUV1b7Wwmn792dV1x+PolYFC61cf1F+5t/jG6/cRYNv1npTkbOAJi0nQM1prTInaYSBWfmzf+Vf/cnP10jmjQfxOUKjccexldYY0DtboCReWzaKu6npsmPx2s+m6VvZo/9LsLqJb6bOv8/JN1kYp5f3YtuJBVGitBb3UtXGI86qY12Y5M85Zp0E8ERSF1Lf+xcvrwLopG2MtoKpn4Xef3ZSWHCpnjNH67GRxulqhUkPXphjMOMZ5UzaNHQeBksBUOmMN3l+ViwKI6XThTldNSuF6258e3V9Udl7pk6O6RC4K5SOhnsxTNU0NgIkpMXGSSGVdUQH85pe/+ld//qdOImHR7rq6xhBC23YCxSU/RUXMEQfvU/Sg+OrmZrVaFWUJAMfHJ2enJ/0wXFxcgtI6bLuP/2IsfqHf+HtQn0j4iImVwkp3XXe8LKtKN87V1hRa16VxhSAkxexHv9n0m73g413XA+JqdaSS2u32V5ubqnDHR4vjxax0unJOLpqSQX748Niw4khxMVsMpt93EsBSTGigdqaw2gePSpUavvHasQ/D6fFy1hgAUmwyfFNpAG1UGjuBdlqXZSGJhiUa5wDOv/zrd9/96U9OTx6CStv1pTFwc33V973WrqiaJASCE0Vt7PFi7seegg+jf/H8eTsMdTVrmmbWlE3l6rK4vr4p6/miWFxenQ8/+9/dw28Wr/0+6kopttZmoGhKqwtnLKJBnbkMo/g6t303+uCDtxooh+p91yGaq5vdrKlKY5FUVRanqzkQ913fSxZWM0H8TjhK7ZwBVRg7dCMZmNUlUkLUhXMIGhScHjVFMTPGgMY7CBKTIk67ttu1XV1XTd0YiykdKAgz/fIXP//1ez9vZst2v/P9HgRPDOOYFLp+HEPioqzLqiJrQaW+HwvrtDHzul4sZ+vN7uL88vnTjTZ2Ma9ffXDv+Oj4w08+XR2dFK58+fQ5bP9qcfPywe/9CVdza/SsqQUnIxtFVWkLp1VmHuJcTHVTNVW9mBXBq8HTxXr/dP2imS/HQJBSN/hFVR8t5oVFTqyqIilVk9KWzbKyr50tTme42aqeTdRDPaus+LNsQjf4q2F9unDMGCNp0AL94TbtJ2o7WR1KNAETAU7iZfLiZx9/8tfvvtsH3l6+BJUWTZFCMLao50dl1QxDP3Td0Heppb7r2r6TK5IvDcxKdEZXpfvSW69/9NHTT59dfvb05tmzzeuvnZ6enD15dl7WtbZu2w2b938Bsf3K3/2HZ6tXmqrQyAbRaqu1No7RatI6wxIsTIGkXGH8kF55cOQHPwyx6/1ms4eklrPl0aqqS3ZGRWEnbA03lTFDMH/wpbOmdkUBEsW20bmSMqjCHLE0QEwpU1dh2gjBoYNbG5J3EknYtdqKbbESVKYB8PzFs3d//OPNpt1049HqpHRW0bhd7/sxdDfns9ns9OSeqzSCSaGNWtVOM2IM0HX7oQvWYByH09Xy/snKaPPycrdZt599+rKalcYWF5dXSttx9CGqF8+e9t/5Xyo1fPnhv6cQtEbUYvKCPw0SZn57C51QaW1pOcOTlRspfHa+ixTu3V/dOzleLZxBpTPUIwSjBRoLVPiv/vN/1AjoNBHs0/ONjxRjOr+8KW0xK4tZaY/mtQZy1hAJDrLWYDaiRAJwuk6wU10VTmig8ANWvNvtv/0v/2w/xM6no5N7qF2iNIiNoIQqg8kP7W479u3Q79LQVoVVFHfr6+3NlWLWrIaujyHtdm30XmdW6iwYrYa+Z07G2X3Xk4JEyVjXD769eXa0XD169TVnhR8iqrLQtjSyl3ewMkMDzQLFjcGmKUrnfKS6LqoCa2ckdvEBjJqMLBG1cdrt293O88UmPL/aoHZWmy7h1X6sDb754GjZWOIUvIA9jTrYpJzOhAiIwTm7XKBzTvhThvSc6Cfv/OD8Zl3Uq+P7j/ohIqh2t765ujldHSk1xDAGP1BkI5sr0FVDWjTVvDy7ucbNtvW919qkxBLuUrJavXpSWl0ljrtuaH3a9P540VzvxlkjbLZuZtvr3U/+8v987a3X4dVXvbC8BWe6qw4lm0waD/xNrEziMsqGLublvo/eS7IQfEcCbrVFa61lEwLp/+I/+0+eXre/eP/Z06t+N9AQ4q7tEymryRnFyc+ampnCOMZIViKTLK2kcwnGwuyN1ZiXGxQqhk8//uSvfvDO8vhBOVslZRTq7Xb37MlnhTWzurKyqTyf1avFXCVvKGnFFHy33WiV7i+ro1o23qo4c/DwePbKcfH6afXavdmj49nZzC1Lya1a5YpdSojY933XdWVZjUPLoX/tS18ritJpcA5slbfgc/ORoCCBLgpq1ajBYP6jSJEnqBIy3HeltdmExJQ27fDp+XoMHD0q0CEMQuySECVtdB+4jbHUbAsjWUGsJn8QSWwST9cHTq+E9Kjddvud734XygXpYvSpH6I2pp7N3nrryxz60O+N4tOjU1n4dlvlKo6wdI3R6IrDaVHW85k6nokLx3G1qOaFAA6jdRK0XnSrZr4d6qK92PUppesuzpuqG2Lf90zulz979+1v/u2/8wd/P4RIUStSCg+2flsFIMWI4oJIijM/w1w0pRxRwRgrLE7J0uXHJONDqp2tHx5dbOPmxTaboZCdeVNToi7SZjeUK1uVtZCHlEiZpDASpwR8m+9zRYRToh//9Kdd0rOTU6XMzeV1iLExDcfgxwHDYCk5UDzsnYHZzNrZMY998iNw0shnS7cqLLDSWiJdirEyqnQS8SglNiTs1AciR4kLZzIN2l/uxpT0EOLgx6v17sd/9Z3f+//9/5vVUd2UmcoeqqHZfia+Swc+mWtuLBzAKxXz/cvXmvU4jsaayVCMNfT2qyfO2vdf7D692A7+gImTwjbiru1Hup5X90ATcHJGo2eAXEBQmc/flrGY+cWLl7/56NMuAXgyGId2rxAun9/MynImbMbMzLxAKi0ARyZfAJumMBgLjYWG0lBlgJizC+eAqpKQZiImJBJWJ4ZQa2vccZAESxyEV6+HlyGM4whKPX/yZHP59CtffmQLo25L14c1mko1U8GSZblZ3I19iIyZ5DCpBDGR0spJ+JAkbc6OZ0KeFLR9vH9S989bH9KuHUbv69L6oa+L6pMLv9tc1qU7PhKQtKjNrLbGWQDIewTAQMTv/eLXY+T1zboo5tdXV1fPnmpnXn30SlO4unCLsjhuqmUOQ+R7lUYgD35EDJiCA3YmGiTJlWmqYzKqpCgEP7Ii8WCxbS4sWmOKiLtZNUQGGJh1G2idyIew3+82V5fG2EO18baIPqESlTsQpFSSeKz6bhzHKLCAJ5tS+UXBTcLXjQ2hM1brqa4zb8qT1eKTFx0AEFE/Ji8sia6G9Pyj8zGE0pXV1f7V+8sHi+o40nIBhbVysWxK293u1x9+cHm5YcD15Yv91c2iKl959ZVHDx/Nm9lquWyqat7M5ZNCy/0V+I7CIHk1BWCvOWimFEfFSTxBvHKfqz2yewQSDkCxUFLZWbGHk2U5CuE1TEM38z5EHzl4v1lfD/3AZAzm1kkmHOpQT+KcWwTWbXZdNwyJDII2WoVMCUPwANCIxTtKcidmu/cC+pXe9DT0wVrM7E8lkrCIADdtK59MFCl1XlmNkJKz86pMeZ01Gk2JP/34s+fPnhb1wqLzY1gt5l9+5dVvfO1rpiiLsiyrZjY/UkYLfOotY8+YoNA89kKXmJAlfHIKqCXLaK1t4VIYBavKvYL3kjimgMdKdr1xuKjs4CnMij6VfQj70RstITcS6ZjGIWiTeaPL4ZjlByPFdhy71veDlywzeapwa0k/1rmJmlCUp3OmMB88X2t0N7v1k+vxpo8KdKLAedPEc1Hn1eHshrKXlKL3Y0h113tQydlGa0wxXJw/T37YhXRy/9Wz5enjs6MvP358dHKSGLSxzXyBGnM0iUwJBQxKCmRXqjSqmFIEzYmTV2IyHMee4yDbDSkFQSnaGJUmDjxVpsFpWNXl6FVi3fr+xmGI4AxM1YTgo8Hcj9FCr0gd2msxpq7zwxhkjQGi2A2lFCXkaW2dy8FIjaMX8ExkrvbCS3atf3rZdzGnKcWU1KHYmj1ZA06B01m3nM+bCoVx1oVk6SnLg+r61mgwRp+sVl/60pcenqwWdYnGIqBxJQvii5Bi8qOlyNFPaEQcXxuKgjDkDSr3S4TeB5Cb4BQDxaAmnIVoQKVs+cIbkJ2G0mnn49G82nYxEIGGixfPYiJtkBJrLVauSBAaKex6v90PPuT2Q45qlFuVOYgLT7ltkaphGFvqE5PZtfhyvet92owhJnn75K453QrKQQFASis0ACe1mdc4n1UaCLWayp8hBFBcV8Klm+Xi/v2T+axoqiJGUlbNmhmgkQgChIqAoooDqBFR9i2njmSMTkorZVWyMQYE0FoH8QDZdIkzRLf9wc+pAwBYo5xBq1Vp1PGi6vwQctQZfABwYqDaTLQ6pNQO/uJyF6eOkiJFUyMrRzeYgngE0iFQkCjDXixXmU/P1+04CE5KkdIEF+SaApYVGZRPEFyJ2mJ6dG8xa8qMDzgXmoklKwMqTMSuKI+OTmazWmgfYNlUpqiMdYkEnIlxp6TiyMMeUuDkWUyGJuwGYBhIaZNDBSvrLDQcPUtGoxgjUQKU7IGgJGgIoGEALgusgiOiRQXzumxH2a0UyUO0RvsQCslosN+351dbn3DK9FP2B4CU3XZqYUF2FJbLC1LO3wSTmFbL5Wa3t1ql6HOPm0trj1fLvtsuZnXlCmuw77qqLBazZhyHdr8tnJs3FssCGDRqbYSLV81ysTopi6pyVWELV1ba5sYGRUCDzkDi6Edt64wrGHHk0LM4ldHaJiY0JWrNESYhgIQOYIQEk88riYyY8z+n6SGhNMqhCsY4E0uHbR/7tk258pIiBZ+S53bo15tNSqh0TmlTv1WiibhYXi/QGqy1k21mHiFZQ2tt5rPaWV2Y2Rj5yfl1IKXBAmC7361WdVkU6+sbBFgtZ86ZQPDs5dWssqB1jKksrLM6g/UUIhfVrJkvF4ujuqiN4AfZEErZP1BpawSlzlfcG5UaNSKPW4GrKlCS7TK2TICcFLHnDKw4dyCS0lDUOV4kBVowkQocD2HXgJpZHAY2yEUBs7oc200KQTkrFtuncfT7vo9ZH5FXB0KMwkVoYk1iKELkywIU5FZF3gkBpuJ/JneHk3PWOr2obO8TihlKtGal1pvtZtvOmjrEUFh9dbMhULNZU1dlWbhM5zgmGkMaQzJlU8xW1mpjIWMxIR+ADDlfKADxy9x2tPJlBToSBQVC9xnl1tHoXHpDYmSlI5uYQoyEKJbKwpASiPHExJTjhsTHprBjjJueNIN1GMf24uVz/cprEcHHmNuzghs4Q2PvSa6YVyL3i1lCSW7TKUmZYlkxyu/JvswweoSSGWMITWErawlx343Hi0W7b7dt71wBgF3Xcwx1KdFIckwYjHZVVaDOuIXIGCvgWltn7OTlk6hFAccYJGoEoow8kWI3DiaRyehf3EnomGS06AfZGgVRmcjUjV3XjiGlmH+zLF6Y16Z2CGg5xvw5AnFKpy2i0RpC0JBuLs6b5bExJpNUpUELKWXlffCSifg21AqRAYYUeaARQBNxzCVjiUG5M2mscSEQYpjNGq1N2/XamOSHs8aGoJlhCH5V20dnC1axKktEmJWucOrsqCmcZtAS6HK5NTMBtlrDAaqovu9ubq7b/As1xiQMCjkB0VFZNsY7HkwaaehN7nfmheD9GNfb3cvLq5dXl1dX1xSDRqoKN59XBslpunc8a5xurJacqPIagSqcKcaEzCl0+/UVsUpEOYFIvks5quQ8nbOixDiTt1HciijKOmrhZSGlkARhYDYts+vH4MNyUSvUfvRiXSl+9UsPa20/u1xLdincN7/y6KuPlh9+9vJoMUNQzum6BIe5c5+hBGWzlLgDB95HxOvd7uWLq/Vmvd9udrvN+fmLzWY99B1Q1AhvPHrwzS+/cX9VzV0wkIahZYqDD/sxfvLsxfsfPX12cXO13SlSVaGrQh0vGpULTsaw90krfO3efFGhomC0RYnlClUqUEAUd+vCOa3zvdBEQznle81KmgwOY0RZRCCekDQqL+RhSgcTpxWQ044+xaS7YbpOSqlA/fC4urhek+ARdFaHELq2PZ1VZ8eVAsrRXrx1u99nMJr8KAtrrHPWZJYJ7ejPL6/3u+3FiydIhL6v2A9ptAYpYgz+5uL8hVDeh3ppGzcDGGgYwrhdX+2uXjzvdut5aVazM2dc4bSxWIvZCkym1CsOVVnu+97pqnROGwMpCGpDqAsDiONn73a/frT45h8CIuWEhwoS39Y9BKznig3xIaNRrgep3CVXt7w/ry72MQWl2jEMYyyrilL6+lurs1VhbKly+i2NoRhX8+bhvWXd2Nmsnqya5HJxHH0I8glNVSo+IKPEtO/7LA7z89o49ib0Nah7s6ZUFLtdCTwvy33X3+xjqE7t6RtmdgKKDfnQbtLQzyuXfP/y+Yv1zVozW6Jus718/nK/3pbGHS+WR01ZlVWQJAACoG6LhlVhlw4fat//8H/b/PQ7GTDnAhnkYnMugzGrjKskUSVKIYQ4iRKm4D0xPnHMXG9MxILfSQ1+bDt0RbFcLQHsT957OkqcQq3glUfHp6sZgyxvmqopE7jKJQIENd5sxq5PClLoBVuT+GlpDAN24/bpR787uv/23/qDv5/Gzfr842effPDZJ092N4DOeqzV8lV3b5mYq/ZSt9cOwIcwDAmiev3xG/OzR0Mazjfbylb3Vqv1zcX56F9/7cQ4XWQRAKiEjBYF96cQnHNnlZtppHHc/uTPVr/3R2CckrSXVFahJQUhR/wY0yTJmNYkG1qmPnhQ/OlcLjXOmKqwFELhDCJst/v1ukWmEayXp8WmWr54dvG1+/OyLnJNwVOMU/LIBFZvX1wNL29OF8cX3Z4E3YJzxaxWXdhu95vnH304W56++rVvff9Xv3v65ANqzxfKr2ZVLmNYAiMMQ9e2OmJTjYkgeaf1oi4aWxerk483/vm+22/2jxbFsNvPLBiNyQesDQJrBJPvwhiotNKKSw3zqiggucZdr/f9xVN9+jiS8iGwrEIODVEYXjrkFk65DDepdJQSg8SD2CczPmdMhsX16clRYYS5tO2w23dGy3sQhWoR2cknd/t9PwwTutJaF8aVzgyXV6aolotVabTROW1kgzaZO589fMOV9fe+83/de/zw06ub77/3weWoHr/55ZOjo8eP33jw6NXC2DB6yiIelahx+GA1O1tUpeYH985Wi6q9vjip7dsPj7/y2oN2dzP2mxS7GHrgWNrcMRCqqJoCmso5i0olhGR1qoyK55+Oo89iQA6RRh+EcUqyjBOIjjkmTJntwEImvpqNSqiGYu677mS5MMgJebVo6qaRfMxRKZXD8756bS5O2lLM0UwDOGuNFvYLoOJ2Wz98+8yW19sLVEkrYGGJQM7ce/w6FnW62f+Dv/3Hs/nx8h/+W+kPv1VrwnFI86P5G19fnD6oHCofVE66iOgwNQVrKsqzxrfXX142X/2jb0Ealw5QjcffektrVZZW87iqS20dpZFTkHBp1LJyWhfOmgKjAqqc8f02JImJcucx19SJk8SaDJfTRFzhtmp80BhOzSuFAKSMD9EZPY5jLJhi9GGMiSyqs8WMuSNWxyt3elRKxBWbhKzEyi1XZI0sGHnsXFGaYua0zakVBLLVGnNd682z+w8DuHJB++3DAtaX63Z7g66sH79dzBaz2ha5W4JoojAlKIw+qulqN+4T+75Lm0unsamKIZBiXxRYl3VZmrIoCmsU6sRZSkisAaui0Gj2N5vj06U4Q4GddsMYaAo0wrBzruc7RsG5STxViybZLEkg54MKLiZlnFYuMwPvg5ZfZr3d3TuazWqsi7qqyqNlOasKo03vh3zFrM1TrLPAzSBiGGUxoi/F6YrkvbaucAUCW2c9ow5jd/HJ+tlnYXvFRX3y5v3F6r5entbHyxqTZczKNUmYSrtCjIJPFlyTA5hTpk6syBS6Lm1d2txTZmdkgzn5iSSklFDr0mIc6dknLxa6OD2pfRpjMU9CGiDlttGtLD3rdm/DzCSI/FzjnJtnaJCBiaM5W1RNU2Yont9MkWKklFZN0VS2qayzMK+LBBN/mKI8ZNyJxmhQXFYF7Hft1cfj1eX9s2MKI6gGmDB6x8pqVy8bWhyd3X/M0ZP3LLfM5dGZy0ocSb+y/0DgCIyz5RhSCbHQLEwLNYPLNEZyCEVvjBZAqoTwpBjUZBkKKOVCSPSLerlZ72ZzjEr1biW5nFMuaefe16GtdZDq52fBSfjLk4PIb574qgI2VQGZnOtcYCGLti7KGFNVWo02q55UCNELaYKpHyMRWkCZrLDwoNOzuL0OF09xu4boyTCmKCg0jDoxap0EwzmlNSGQSjEqLOfVYumHUSlMMWqlVJZOMRqNwqpAGUBli5gokkINpHIpxgrdIjxUPggR01QVzJkIQRdV5e6d9NtLVByrIyrnGSjTQZOPBy1qTiQoV8jK2enFpGSfpkCdK4yyTMa5qdIsXileDXZi83LPMSllS+tyPS/bpHw75ZdlxxJgSqSPz/xHT1W/pXan4qiSIu9t6ViBVpGHjcZOZaWiFnwpn2TMghmRQIkBATJxu49+zGUcIUGUAuSZEOdMogmWSoDA3DzgJOYvtxGEBkwLhBYUcFlVQ9vl2inG4pSz/M2ABp11AzTVShNOaJkRsvqJQa6oKIePTJ8zvpOMbGx+R5LwnqIS/k0se5YoKk59z8tZhblMLfwfeJKVE7GniFmUrqsShNSDcKQQjLPMgSmCtrJXkhECh94pIdPalUVRI7JmP3b7LPwgMUgWO0qyaxLlDeohDCm6qi5zeMCJ8ymVYgpZiIOSM1ISs2d16/dMYez2m9IZZhjLY6VAI1rtcqmHtEEQX85Vp0P9fyoSidUIJpYrcdaBs86rZWa1y+ZhKQPkSf2cNczTSA8Nw1AYwxlv5t4JGhKonruFPFWGJZcr0NZ27TCvyuhH1IU14laKFaYRKJAftVI87K2xMGzH9XkIrlndT5FtaeWh/X4cxzAmJnCuzF3ArqhqVxRZygzRj0pFJf6bAkEWUKQsBLzVJjBvt1fHJ4tF0wx9D6evWWNMrqNm2J81eRPH1iqnZZrU6HkCQkyGsrBncq68PnmBSB3Givzo1e3wU6YQ8vhRDIumICepg3KVHsBIuBB6rZ2GWVPcfwSbrR/k+WLotS4gB5TcGZHcn0jZovTdlocdpa3frrl5VSJStz3fXtj+Mmwu+t2+3/dNYSpjlMKh6za7fmVKQyjESOvoBxIULJk79wKEowPoRClLcvjs9Gxe6rFrdbPAxT35GYSsVjxkqRxtJVgYDblKnibyqtSkRVO51popB+a+X1UgEeXpsGgNhhAmbYOGSdiuouSAoJRwEyCCLNvRn18Riqq4VmTOXnlzfrzuN5S1Bil6nUoCDWjAgkoRBLuydaUKfdxtqN0rd2/9/KNv//N/dv/NNx+elMPF+fri5W9+/TFH9cd/9FUhcuh8UIPn0rIRM8gYTLzd58kyoU+UcxCAnlogABz84KzZVvf1bAk5mchWCzyRpcFJx5TrZ8YIXA4HX8vLJmEuj27k9cw9K+Q4db2AUyBkTcyFUAaVRfLJhwgqN2glxub7INk1CYO5Y0ZK2ZlFXig8s36/vnlCCVQKaewk5GuTBxocqAHCnnxL3Xrc7ZIuGPT1xRMLQ7u52kG9u7oKQ//aK2dDu3757JOjo9Xq6ITR+jFocBKatItjP80wZLQnkTUpASzGVjl7M8URDDAbOnnLWCsrMT1v3lSEQxeaATXkprxSJqPsaUVo8p4DYxWoZQTLkIpETkFENBY5ZzvIvE1cIyatFQmXF7/XSlYQxUyYNHGUDFdUzu9aplLcW2mCwBySz+MnaWSxuygUs73WafDtNhLY09fT0aPj+YMv16cQw/jyN0Pfla6CkqqKlrNyvpjbwhnrgkSaxFFSMqCTpc/l4ikbEwXI7cGYc3lWAemhOMZHXxPzyfogMa8sbTeYtQQH6dlBjOqsYcbbOabDmIx8jXL1zC9jtjgkI8lbVlhgW645QhY9TzVKytAym7YR9KUShEP+x6qAtqOUZ2DQMoUo7FlYkrWFbHFMNOzYhxTHROyOXjHHj3k2R4UPF6vd1adq9/7q3oPZfBbDDsLaGIbCKmvAaGtkd3WO9wya89jaocyOZhp/lKwvT26UsmH1avrqn0A1z6gt5/Es5UTUxugpNx2KHBlc50UzlAfJpmWZwMEE/AQLKzPhv9zMzG1vxWJEPA06SoLFnNzFQTkDTcrGmEIeY82LrhdO7VVuMrowtjFGgyr5VkcvKSAlFb1CTabUJ2f26A1VLKKsYgre8+ZlicGujurlUeyx37UAMYIycjOUn00CJd5C4FySSvm33DlK1mGOId7/5vDg68XpI7BumnqZyoM6/2iuneWUxhxv57p0NjPUGTKSnWB9FMpG0zylsUZTlKSlEQlp6k/DXdn9dgySpxJklmTx4ZfkNX23QkrBjFMbiJMxTgJoDGEYWAwbctkYyRRQHbvFvajKyMlHP/gWU2yMkNQgKbUaogFtwLrAaSTyMRhjCkW5u2YTTcB4Gn0UyMbiP1PhGYvH3yhOX8cDJhJoOk0DM5DEo9yom0DM9AAwFbVykJKMa7RgzxCyp0C2TTSYu7+CgCa0peGO1KnbAgncjqxO7TRJ8gysc1KMnNWOONVRVAV27vy2jzHR6PEAGQwBCpusZlDWO++TCugkfBmlClCFLgiXMF/RMNB675JGKyhn8D0p1kYHjVXuJqFG1rKCh4HMXPljAWQcoJgv7om7TaEo72ZiFXzSAnCiJJRsRJHUvh1SpLpuCky5naGEBHFME9EHzYd9UCbFGOPtikJeDvHCvGF8qzCWGxCAyZS7fDF7ZMb6E1Y4NIazV+vCUeY6EzvI+o0CrU1KCNzm4uN971kXxWxVl8u0Hy4//cy/fMFd66zeX77QKqHhjjZcElYGrHZWV4sZKWc1oQGlSptK74eJDwgIn1o3zbGyVWYSgqyn+k83jCGwQTdGHkNczps8ShjaPq63e7vrF01x2piyrGGC/DGA5GZDSo3D2HLWKmd8o25nHA+a4gm4T2D8IIHIyCD72mRqU+gXKDCJ0nCiITkwTBU6cKWualPNNWhhC8NmOP/02WdPtoNdnLxO3sDG10bZlMb17rrtAMEIwdpux00buuthYEdf/errj5s5AYKQmMiBBW2gyS1vzvnFxBRTda+PlGWBWUWi1K4LF9c9MViMCLCcF0URDR7cMya1ve73XSrMkiEYa6aR/SwrjLuu37V+t++MgKEMm4FYG5xaIZEOJTfIK5K3RE0RW+X4LKQBhW9mNRxMjpR9Pq+q0YIBjBbjNYWyhdLaAPnNYJgXVemqe7a+v3x0f2aKktj6vYkt06hoHNvLsbvphq1n31OAAmyBToPJsw5p9DmNHnozkxtQIs9q71btpnUulmXpnBnH8Xo/3LQ0jmNRWKfVbFYIJslSxMI5bYqRk2/h/Sf702OtAbtu6MdgXGmsa7vOj2MMwUhGlyCqCfNUqYKUS7xTA+du7HoiIIkznubDguXuxm2ViQ4xPdcIrPx0SqCtQB4hhBonl6iaR19+VB6/pexCY6G6nna7GPfDeC5rnzxxF11sZnUZuUpR+DskDRLxrbY0kfhcGMzz/FqAPqSRjbfL2IduTG6Mztpt213sox8jp2StEFYhGTmFUUox0c22/eT8uu+oKtzxegaUcogC4nFWFSrLt4wpzBSDMxnXAg1A6AFky6FJhpcTFE/jxhNVy6sgtjNtJUzepya2L+tTlSyBiUCB0Sqx0BeIQSEUzcIdvYL1MhKHOGgdlPVE6wSbQDFycDWqiD6NCVgZbS2GGDh5DJR0it5jVn0I5SOdGAOiJ/BQklt4CTy0H9M4du0wepoaPXxysqpMVprlckpM6eXLy7YfZmWZ4rDrh3aMAiONLgpttRrToAIB82LVmFwhyYPqU+9xmubII+Ah3KUzvkv12SElrx6KBbn7fVi7W/mVMbo6Ot68fK6yDMfnQQ+dekqs56dqdqTLOo09xT7GbRovWHVRU0hJWxOVsF1EtjYrFDiBpHJKNCqfFFFMMWNZEykNJIgmkErLIzdbxtETQ9fGq33nQ7DGjv0AANdbfzozhYFuGEpb7Pc9Kb06OtJ9iMmModv7UYWojS7ZApNWUFnHpMbrvVG3284T4sqIMRf3MOEhFGUCc4Dh6vMjPKbhB4YJTt8ORUxvqo6Wu/WachvBKpWCF77qGp1zTWIQ1upHcT4LEjk9WuH8Yr7JTmU8niRlwrdVrq6oJME4eCKVFEamMY8LEyNBaVhZo31UfR+HIXhOnqDvIzHsP7kY7s3vHRXzslrH8eJm3Y/UEVztegCzH0LebI4+xBgr5yTMRlnZEJKZuj8HYoKG8UBzMlsHmA6L+MJMEf8NffaE+w8vHVyQVEqEBudn9y4+eQKYAIbMCtm6GZhCSKIrKXjjHAdjaF4gFRa1ysquOAj655FigOSBlTMmphBCoAQphqyjxDHByLlvPvq6qvr11fXT583pvd6HMQTKIXwMkbROMaqorvtAHK7V7uHJScg/e7P325GY/VQigkMkEaBojZ6aiUbzJLSWbBBTCjFmR5V7UDn9H0aYp98K8KDHvs0hcFD7HchvRrRxqk4SF02trOmGcYwppJTrEhDSYQxAmwLAiBPlGkSuMGvWWmJTiLn4g5PoN6UwhnH0vh+8z4fyBFI+8RBS1w9a60Ij7S//2//6v/z2v/jTboiYZ8t9oBBpEgMl5qvN7sV1uwvQK9sGutztd7lJM3EWSYWHJwGtjcttv6o0R4tGcFAeduEJQE+zppPcKusDAQimziweGPAtIcqjM1Mj7JYiTTEMOcuhFfLi5PTFp58ag0krXWpFQVNUuW7qbMHGsZY/aZRLh0yU0bnodzHmdqc2eUwJiVQ/JoHkWrjCENO2j7veI6h5WRZI1vDFdv2//pN//MFvf/UP/v3/CDSSj4myZ6qpzoxjUps+bT56MoxiW4kluUwnARxoPCulwTqLAE1VzhrdFNpk1jDVDikdurCHoojKzcVppjEDgHwMBQsI4EPXRE0M8G5oLX+LM97HjBPLej7f7LdV4ZQiy8kqBG2N0kNMLBCgjKMTo025ngYYYwpZ6J4ob1HwFKkfU2DwMWHilKgf/bYPWttl5WR1hJnI54c4vveLn8yWR2//G/9umk4X4YOHEKtAmIa8PaSn85A4Ixn8PILKY0aVKlfM6rJ2uevPt4dzTIMNWSeNmaDdrsDUgYQDKYWs856MRk+1uVxUEHIPmXHfUhQmUojVbB5SvNnceG+KsSgbHUnpoUcskDn0O+6usW9T30/vpzjGEPM5UuIo0fcU024QhOhjlnelFLzXxi3qoi60RbaoMA9LsVI++I9/8+6jb/xdVa2mIePDZma/UBkHTVz3i8H08wjLMI6x0jY3VSWDmelnJoYOjLfdwdyKycEpfwhl/8oAKWeaL6b/rOhQt50hnpBlPjVLPX9xfrRcLlbHrNTFsyfJD81qtVisaldP1E7TGLp1aq8x9rmrxDGOXb83SJKFKMRxGPphDNz1/RQcgbko3KwuK6OEnU0wRalcNQJiNfTd01+98/jv/Ns4TazetVOZA+d6zmQ+U9+Z7/qIE51UIVA3+L0xgFQZzKezZKlevuGMjg+zZzi1wW7Lb7ninc1lWsIJI0nOUlnFlIdApioM5SrUxcX6n/zTP/1P/9F/vB36qpmfPXj85JMPnnz2SV1fzeqFs8YAc2hju07DzqhJ3xZCDD4KJiDylMI49LkxKClE59ETV7i6LCqLtUUjLEAj4EyPj+duPfaTvO7lh784euXt6t4bdxZ0OEvnblsPBZqcwW45+WE8RWHrfdjEpJrZ0cKEEFgeDGlqth7qBLezaIfjepTVU/vk8ypIyj2pfIhJXlLUeYWnzAaJ1T/7F9/54JNPjTHOua7v58vV4ze+9PzppzdXl/vdTjhjCiq2PHSUxug9qCxCUORD4ER+HEkWhctCG1SFNgaUs6Ypi8rp0qDJBm+MRgCD/Mdvzxjxw6s+21n4+N1vf+3f/A+VKW519bdPwndzdndV1sNy3fkcsFDZvYApNpOMKBc0DgzwVtuQqRMKLdPamvwPnBpCh4SlcmmOFE3dNlJfqAisN9u/+Mvvulyiq6oGskJ0Nl/dfwTWFjcXz/v9tttc++5GxTixpLowMcbRDzH6NE26sCokTeYeG7AzUDisS11ZLIzCrLw0GoX0pXRUwx+9XiLweStZeHv5/OJ3P7339T+club2fCb1//3F8IWpzcMa5CZYSC+vt+agBOGD19DnsQUmY7DamHxoDsU7dUS2lNwJEuKvKA9PwR1gVEr9+Xe+/+z5i4f3j1NIRruqFESVx0YwH1iA60vrrB53JkkYjqXwawVQJKrywJUPIRrNRlHpdGl1gaowUJW6LLQDNjCVKgHVNMxEGmFZ8Jur4rr3uSOoPvnF9+b3X6+OHv6N5fh/rY76ovEcKm3TIERIdNV6kxvwuVV0aEvfRnN157+ohW7RhBGnIYZc+BQvS+ow7wwT1so/5kP47vd+OGSpUaJUOJubfDZPUhvQCjQa59pNtUc7tDeQfJlnOfLRg37sGQt2WSRggUsHpVGVgTz8ZIykLW1R8JfWgnCVCsyjZi6MXVQIymdBvxra/ft/9X9840/+A13Ov0CQJoQ3DfTmae3DqXq3KqHbZBMi+BDMQfaafecgEhZ8OI17Z2Cgp8OwdIJp/jhOhZisZs2ttkNlbTIvVMi/+uVvP/704zyHlSiFOChTFsbYXAwmLuvEapW1Jix2AGG/zkdmMYopMoB2pmBKGriwqnZQanYGjVg1ZTG/BiZnNcWBUsh6hgjAxroo3AjV4eA8tbk8/+t//j8ePXx99fgr89PHWDXqUHM8PN1B8guK75LR4dSNg4GZdJjIUiHFELKkGFWRD4LAQ4Nj6oiaSbsPEptl6SNNMtqpOXUb+hRvNvu/+O6PhfoQN4XReQwDmPC2mmYlprhR22a+lIvFUaUQKJCw0GQwT8/lrp7TXFpVGiitUFmnxWyE03IqjFUcswHAQficJz6u9h1rkxj0bd9r6LbnH//yye9+VpT12etfO33zm7OTRwcZx91BkZPpTKTrLqnl+WsT4pS6KGTGpBSYfKCJzR3/TFKEXikPE7ee5kBipBRldW5xtwC7J09ffPf7P/3w6eXl9Q0TWQ6PT1a5e0kU5Ofx0GvJDWmUFI1AhTVkTG4Dcz5rk5BJK+GohU5aRYtmSvDWOpc7z1ZyB6d0eLYJw2rUIajP1iOx1ZByJQYzlct6Haa2a/1v/vrp+79YnT64/9bXj1/9uirKgzjodqae1Z2FMebBGxPEEQQExUAT5ENlpvrphMUPxig0AFKiPJciKDAeap+QYvrt+x/+39//8U9/8Rs3W7liFnNBtnS2cSqmlEcWD8Q2Tz7JhZ2xKo6L0g2hTq1VxmUabQ1yNjqyhhwqC2gNGESbxVxKPMsajpRCLsJkMKhVTGyt3rWw82oaCpuqoFM2JhL2I7gBExJen3+6vf6see/7J6995eSNbxXL+2oqhE7NszvclNXAhjM+Zc7KpsxOp2WKKaGR8EOTZF8lQQfTHAyDMCZiP4bf/ubD7/3wp+/99v31rq0Xq7qsQz7Fymi3qgunqNvt6+OTXF9LuTYgZH1qR6JS0Y8a1bypR/ZkFKqkgbKajgzS1Ni3yPlMKa1YjMhohng44BURSRliDimixg9e9GGSeOU27F3pIZdfNN11JnKm2sWr7lfrlx++t3z05tkb32ruvaq0vTtJ5/PiH/EUZmI+NTIfejldhigl5HyEbCZGgsLFsiKFpNquf+fHP/2L7/7gat2NfmzbFq2rqtkwekTNnAyooxoLHDY3L8+OV7mDPeFQ4QQUhbcNXVc40w9tYbSpSnAqxdFqZQRbBcXRoLF5OiZXP7QTD1NKReHHWUQ7dZUS88gq6ObD9Yay1iVTSZ2bqGrquKhpwkd9XkEXJ6Toad9/9KvrJx/U86OzL31r9erXTVEfxuwyMTCZbMGEiQ9nJh7GdXLvBGFqc2DuG8UQX7y4+P47P/7eOz9dtx0rCCF6740xpmhSbkVmbzLCCRwWMGzPn7QPX6maWS5xTwd8gdM6op438+CVKvrEwRUFJHlBcQQiYNRoMFsZsHKyNiYLT1NWumiGpNBKbgkp9zzDh+frm46m8zGTfBAcjiPIm6MP8sq7dI8HFpmNg4h8eNmtL56/9/3VwzdP3/q96vghoGEmoXjEtwBGTUqswzUSTdhIJYEW4YP3P/7hj9796c/e2+z2aBwrGL0PuTWciFazWVK39GTSl6Ap0fjden31zBav46Q2y0lNAdel6RKOMcmDWwuQtC4VeWDNJLRLjIhIo67KUueD1DiE/PiHcW6FebiSMaFOtvjV857QwBfqnxMZmvS7cOtu05ThXZKfFms6NHuk5Pf78eNfrV9+vLr32tGrX6vvvWbSNCM9nS8BBw4BU4siR7ih7X/y7s++9/0fffjJZyHGnDt1ymd6hpi0FhssXJF1lDqfiJunz7UhinVhwN/025ebqp6vTkChnaq4ilBRXVqOVYQ0hj73kbLnSGYD4KitMZK/wJosb8kQAZEphSRQzaak5OZBE+LLfvzwatS5hjCp7SY+mjMZ3h2xpG6r759DwoOYCg5n6AD4mGLbh8/e3zz/aHZ0YuBQzbkl7ofeiIohXFxcvvPOuz/6yc9eXl9lSJE1oVPXVDZHWW0nf66aWUhBbiRhHtJQxpj1kKrKmHQD7Xq4PjeART2TYKLyKB8HVNQURVBUgEL2iiJI6AkqRoTEKTCTRbA641ZQxtro+0RBaUfTQGY+sJWM+rOf/GZMEHNeNUYfSsTTgdPT+PcB8SDfOYi6KyBPZa/DqLXKAy8S1FLqXj41kEu2UyTKc7c8dN17v/jVj37086eX5+vtZhyGXI/OUi0hHJANkrTYyF1zEfJRIDS9R3iJ1ruOR7aFGcGv2S/H3RoVYllOp2PnAyoYkLEoGFlFSFFRjCpBVq6SBsiScZzKrDRVGRWjKWPMhxeZcurDv/e7859/uiVOKR8ipvORB7cNmWnuC6eTC/8GC8sRPr8tn2Jz+83JG8U98+smpXCX/G6ubn70o3d/9JOfr/ddyJ1X772+HQ7Kk2aTpeEdyjiMnR2QumJKUx8bUQ+En110v//WmeFOp14lH4dWa9Cly4afYShA1hsLZcvK+YgT8T2cQzFptSXiTse+ALjg88izsDH5tJf78D99++eJMXLUwmDxIPDIN517DllexPH2AFh1t3CfL8pdVfr25WneB/Jgq7jUzdXND37wox+886P1vpf8RWmCP2L709gn5yMJD7MMnAeED1tktQ7e5yVLt+fwKEQHuvjgXAhWqTxQiwKtxuA1AGnrLJok9MZzHKPvKHqhI6xuhe6Yz8JQtiyzfHI6FYX7wYs7aIdCNCiC/Z+//d2rNk2SgXzQXJ6CPhz0rCb0Dqhz8S+P4kuwg9sCsvriWeef/+OOnTKYH/7w3V//5oPf/PaDzX6fpooG3RYM786Xz4lOCP+hhjmRFpjUWuLhMaA2nHueh+wgAbn89Lr77m93/87vP1ChRb8T9j3CmCKUCawTsq5zWks6JuVz1UIWN/8/AXIvWB6WMvTKIxcqZ387VUl7Mv/Dn77zzgdXpDRRUNPpQtP5Qge1PNyeVcIht4m/6GV8+/90YL49Kf92rb5oXPrZy91nz152wygeTlPPnvNhLSlRPEj1DqZzqzWD2z5ztsmiLGOKea8yF8+cO9P+MaT08YvdV159fH9pOYzaFKSymneKoqTM1GhmQlSlsYVzVhvjLOYDIz9Xr9EkOCBGC6hJmc7M/5t/+pc//PWzQMB+jLJD2lhzF56/0GQQbNa1++lcdpjM7MDiP3e3Awq8tay7V9H7IQoNOwyF5FBHmVFENams6K7YSNNxDneFOSGX00FDOYLwNJCV6f7/Q9nV9MZRBNGu6p6ZXa9tDEpARjlwhQMHbpz5eTkhJG7kwCUHDsgSSIRwiRASJBjFkASwRRTZKwJ2PBnvfGR7pj9QV/XMrI0VxGoPq5U/tL3Vr1+/fvXaOcsH2WUrdu4+aXFDCm11gdCiN5a/T0qYktRuqjhmMAZlOSoHBKnYkcRRGx0Vt/O4hPU7+8/2/jgNgGcpLzzUluT1yMfoTSQNPexzyTjmhpV9QM/xSHQsq4tPZDs+U6/+hhHrvRlo9Xgu4MUo5/aRXxB+LyArBjppVxDOIV++Idzj48X8xVSoaeIaZRspDKU0tdY5IAYohSd8FeRZkEqpwJtpBSPEDcQgTC6ZAKp68sZi+71bd3/nAyBnWm8NDiUQXW1IYhMrpWitGZ1h5yVFgLFqLn2gj35YLhYb5phg/YN8k+Jfx0deRP+e5w5q0vT4P1MgIZn5icEByjRVSVbV+sNPv7i3/zQghF0mwvGeio6Foy5D/mHJW3YQSspUkmoYd9eopMpkltnZlc13P/h5fjyfHwXIs8Z7CxhoF8kVSIWDnk0UZM6ngCwDfSTnZar0+c/nVyyaQijHTa0Bnm2Udvo1O14FA9B3CPVRe24F9j3SWbyDvkWcQM+LqKIFYth5kVfdja/2Jlny/jsTdHWG05bXVJDsyGSfBMubSZLxt8uOVgSK809mR/li5/t7i1sPH/7ywLVdWLlZ4GIbIU0rwdMUgTb0ZIsDr/UyAg8MW3xYBeOXPORsuuVjrK+Np2iDpjbU3tiiB6vD7GMurPJxeQ+7bqZaAL5uFs+f52flmXVukiTait1fn3Sde/ut7WmWAFKgAg8r8sm34zri6cn+CNrV4UkjPvr82xtf/nj099nh4bw8zQMfd3YIRQSQSPORndDx/gQ6MhPCVdWZ5LszIBqmhzX+vwdosrbhXOdpgR+v8lkZDoDV63QuVqMQIssy7m+QxNAQwHT65OTPosiN0bQAi9n6BgBoC/vz4rv7B8K77Subm69sUtef4OnsBSkYnC4WXhsvfOPw693H12/efnSYd8Z35BxpdaMkG3ccfWYlMeX8KGosQt7x8wlKVZ117QvGMmA9B/BS3PGcntnDCj9lNlmPIEJwAufJQvxD4zsX2Hok7EQRrNbLulkUxbP89KQN1HH4MZitzTzZaxCxMrC7f/TD3m/XXt9687VXo0AFwxwD6rfxBsRfZfvxZ7dvfrNb6Bgb6ymFryjyVmtETFOFUvWXMSGnUFA1JSgVgZrKT4+pi1H243L56EBUWll6hUFuk1k2EzGsKHKm/zVAxpiqqqqmLKuyrkutG2M6VgQwdkUEtF6bTpmP+9hqBItld//RwdVpcu3qFqfPc1M7cn9Imt55cHD9k52fDp6aaA+IPK1r27qujDXNcqnbpQBMkjSQSoqT548vRPg6qnpRlkXXauqwjbMPIhbgywYovhNe/hMAAP//1qTUQGbX4pUAAAAASUVORK5CYII="}, "pbakaus": {"name": "Paul Bakaus", "url": "https://github.com/pbakaus", "avatar": "data:image/jpeg;base64,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"}, "blader": {"name": "blader", "url": "https://github.com/blader", "avatar": "data:image/jpeg;base64,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"}, "upstash": {"name": "Upstash", "url": "https://github.com/upstash", "avatar": "data:image/png;base64,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"}, "obra": {"name": "Jesse Vincent (obra/superpowers, inferred)", "url": "https://github.com/obra", "avatar": "data:image/jpeg;base64,/9j/2wCEAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDIBCQkJDAsMGA0NGDIhHCEyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMv/AABEIAGAAYAMBIgACEQEDEQH/xAGiAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgsQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+gEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoLEQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/AO7K03bVgrTNteqcFxgWl21IFrnvEnie20KLaxzKRnA7U3JRV2CTbsjdwB1IppK5xuFeTXnjO+v1aRJjbRjI4bcT/SsuDxJqryF7bUDMF5ZG7gdfpXP9bgnY3+rTtc9sIppFcZovjONrQtesUYDoTn8qvW3i22upMHKKT97IwPritlWg1uZOnJdDoiKaRUcFyJuDw3UY6Ee1TEVV7kjMUoFGKcBUMZpFKbsqyUppXHNMky9X1KHRtMmvZ/uRjP1PYV8863rk+u6tNcSuAGYlVXoPT+VdP8U/GzX13JolopWG3kIlc/xMP6CvNreXac88nmuWtPm0R1UYW1Z0c8Rlt4reLgEYz/P9TWtonhu0icSOZHk/3qztIEl3KMjhOg9O9drYxCIgnGa86cmkelSim9SrceDLG6hCwyzQMM4Kvkc+xridZ0vV/C86O8zSW7NhZl6H2I7GvYLXaVHFLf6Rbaxpc9ncrlJFx9PQj3rnjiJQeux3TwkKkdNGcr4H8VSXDJaztluqehHfFeoq29Aa+f8ASbeXR9ZazmJEttPjI7+/0IP617tpcvnWEZPUDBr2sPU5lY+exFPlZaxSijFKBW7Zzm+Y6jdPkNXTHWL4ru303wpqd5GCXit3K47HHWo5wSufL/it1ufEupSREtEbh2Bz1G41mWEBnnCqPwouJSxbg4xyfeus8G30VpaMfsLTSE/MeACPr/8AWrgqzaV0rnoU43djW0fTzBEqqpLHk4Ga2GnjtVLTRzKo6t5TY/lVvUPENxa+EkutPi8qeWby8KAdnUnHbsPzrko/FfiZCrm8YLn5gWJIHrXBGpUqXsl9/wDwD0OWMLancaXqtleQExTcjsRitT7RDBKVlnRT3ycVyHhbXrjW76a31CCCdlRnWfywrLt56jkj61qeINQsYbG2uhpiyyzZ3LNkldpAPy9D1rlm2p8jR3U6nucxznji1WLxBZ30IDC4j2kr3ZSP1wQK9R0GF00mHzPvkZP41xek3F1qZDRaZG8UJ/1BtUwD2IO3jpXf6NPNd2Aa4hWKRSUZV6AgkGvTwdbkkoSW55OOp86dRNaE2ylCVY8ulEdeo5Hk2OkKVXvbOO8spraQZSVCjD2IxUvnj1o84etcHtjf2TPl3xF4YfQ7y6sZ4sukwCnH3h2P0IrQ0+0S0iMKgDA4xXrnj7w6+rRJf20QllgQq8ajLOvbHrjmvKvJkhPkyRyRunG2RSpH4Hmovc676JmlbpFeadLYPIiSeYJYt5wCcEFc9utV5tBnWJi1vIAB128fnWc83z4/SrdzbxR2O9nRG25wRzXO48r0e51QlzR9CCzmXTXaO2IaaQ7ZWj5CL1259ScZ+ldjJBFqFhbySbVkBJXdgA5ABH6A15rbW09xeRw29zJGoJPy9PfPrXoun7jpEYa4MmBuAZcA1liYJWfU6sHK909jd0q6urNRDb6c00khC4B2hAO59q6qxsGtbNI3O6TlnI7sTk/rWL4SuBNcthcKIj/MV1bMtb4WVoqTODHx/eOMfIq+RSiGpi4oDiul1jh9kzg28R3zKrRXI5GRuWgeLL+3liimMbeZ0IFcys0UKnOV7A1I9xZGSOWWXcUHBBrnUZHa3A6K48aXtqW3xxkDvmuJ1vV31bUPtzoFZwBge3FWLzUdMm+X94WPoKpfZ1ki+VCoBOA3WtYqyMm9TJeQCUMe5zVrWY/PitHgk5ZMuuM9OlUr2IJJydtWdPlUrtlOU9fSoktU10NYSsmn1H6JEVvVYvCpAxycZFdxcQuulOYliDBDt2HNc3Hp1teToYQAVAJNdZDCsNrtwAu0twOprkru7TPSw1lBoj0PXY9DtUE6NLK8YB21rDx1bH71rMK4BUXWdTl8u/EBjOwRMMNgd6uroWpTKZIb1jEvB3qc120qXuK55Vereo7Haf8ACb2PeOUH0xT18a2RIAilP4V5Fd3lxDcsmJG2nbuKkZq1pN8Ddo9x56jPG1Cav2SM+dkizzEfvGGBzzS27G5VngZWjGSXAyo/H19q51XZpBa3l4bgMyhkUYwOpzjHHvW6jvrSCOIm00W1GCU4M2OuPRf59K1VNMycmT2ttcahOYbQBImyGuGHzN649B/nmte70+LTrKOCDcRyWc9WPqas+HYy8Mk7R+WrALFH/cQdBVzUIfMUIfwrKpLotjanDvucPcoXY/JvPaqUlhqCMpjgcKezcV2MujfZpBIzg45AFSW1orz+ZLkAc8kmuV1XvE640Ve0tzA0W11xJyqWhw3qeBXR6ytzZ+Hrl5ZwLhFUqqHPIYEjP0Bz9asXGsJboYbNQCPvPjp9PeuU8SajImjXBLndsO0k/rToUZ1Je0mrIutWp0o+zpu7NqKW2vdS0xJ40eaZCszlQGJAG05HNXtdu9e8PviG2WeyAGyXzMH6H3rnPDzPdeI7UqS3lRZOD2ODXql9DaajYPbXYD28i7X3cAj/AB/qK3nNwaRzKmqkWzy/VPEl1FCd1gyzsm4MAHUZ+lZmm+KbsP8A6RcxJz0e3yP0qDS7ex+3XNst3cpAsjIH8wY2gnk8eldHbyeH41x9vhfbwd7A5rdO5yONj//Z"}, "BuilderIO": {"name": "Builder.io", "url": "https://github.com/BuilderIO", "avatar": "data:image/png;base64,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"}, "tt-a1i": {"name": "tt-a1i (archify)", "url": "https://github.com/tt-a1i", "avatar": "data:image/jpeg;base64,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"}}, "version": "3.0.0", "kind": "map", "source": "diagrams/skill-map.json", "avatarsEmbedded": 9, "meta": {"generated": "2026-10-03T20:20", "project": "super-board", "sourceBase": "https://github.com/mnphuc/super-board-gitea/blob/main/", "root": ""}}</script> <script> (() => { const D = JSON.parse(document.getElementById('visual-data').textContent) || {}; diff --git a/diagrams/writing-standard/reference.html b/diagrams/writing-standard/reference.html index d539a894..8f8a2944 100644 --- a/diagrams/writing-standard/reference.html +++ b/diagrams/writing-standard/reference.html @@ -90,12 +90,12 @@ <a class="logo" href="../"><svg viewBox="0 0 96 96" aria-hidden="true"><rect x="4" y="4" width="88" height="88" rx="20" fill="#0d1117" stroke="#3d444d" stroke-width="2"/><rect x="14" y="16" width="20" height="64" rx="5" fill="#fff" fill-opacity=".08"/><rect x="38" y="16" width="20" height="64" rx="5" fill="#fff" fill-opacity=".08"/><rect x="62" y="16" width="20" height="64" rx="5" fill="#fff" fill-opacity=".08"/><rect x="17" y="20" width="14" height="10" rx="2.5" fill="#d97757"/><rect x="17" y="33" width="14" height="10" rx="2.5" fill="#d97757" fill-opacity=".55"/><rect x="41" y="20" width="14" height="10" rx="2.5" fill="#58a6ff"/><rect x="65" y="20" width="14" height="10" rx="2.5" fill="#3fb950"/><rect x="65" y="33" width="14" height="10" rx="2.5" fill="#3fb950"/><rect x="65" y="46" width="14" height="10" rx="2.5" fill="#3fb950"/></svg>super-board</a><span class="vpill">v3.0.2</span> <span class="sp"></span> <a class="lk hide-s" href="../skill-map/">Skill map</a> - <a class="lk" href="https://github.com/EricTechPro/super-board">GitHub</a> + <a class="lk" href="https://github.com/mnphuc/super-board-gitea">GitHub</a> <button class="tbtn" id="tt" type="button" aria-label="Toggle light or dark theme">Theme</button> </div></header> <main class="page"> <h1>Writing standard</h1> -<p class="lead">How super-board writes commits, PR bodies, tickets and comments, in the pack and in every project it is installed in. The rules live in <a href="https://github.com/EricTechPro/super-board/blob/main/skills/super-board/references/writing-standard.md"><code>writing-standard.md</code></a>.</p> +<p class="lead">How super-board writes commits, PR bodies, tickets and comments, in the pack and in every project it is installed in. The rules live in <a href="https://github.com/mnphuc/super-board-gitea/blob/main/skills/super-board/references/writing-standard.md"><code>writing-standard.md</code></a>.</p> <nav class="toc" aria-label="Sections"><a href="#commit">Commit</a><a href="#status">PR status card</a><a href="#problem">PR · Problem</a><a href="#solution">PR · Solution</a><a href="#ac">Acceptance criteria</a><a href="#history">Iteration history</a><a href="#beforeafter">Before | After</a><a href="#risk">Risk</a><a href="#ticket">Ticket</a><a href="#evidence">Bug · Evidence</a><a href="#comment">Lane comment</a><a href="#agents">AGENTS.md section</a></nav> <section class="ref" id="commit"><h2>Commit</h2><p class="purpose">The commit message, in the super-board repo and every project it is installed in. Emoji map: ✨ feat · 🐛 fix · 🔧 chore · ♻️ refactor · 🧪 test · ⚡ perf · 📝 docs · 👷 ci · 💄 ui · 🔒 security · ⏪ revert · 🚧 wip. Squash merge = PR title + bullet body.</p><div class="card"><div class="chead">Short bullets</div><div class="render"> <pre>🐛 [fix] receipts: show a size error over 10 MB diff --git a/docs/blocked-column-audit.html b/docs/blocked-column-audit.html index a4a6b7ce..20f3bb5d 100644 --- a/docs/blocked-column-audit.html +++ b/docs/blocked-column-audit.html @@ -746,7 +746,7 @@ <h2>The three install sites</h2> </tr> <tr> <td>Upstream <code>main</code></td> - <td class="mono">github.com/EricTechPro/super-board</td> + <td class="mono">github.com/mnphuc/super-board-gitea</td> <td class="ver">2.3.0</td> <td><span class="state ok">in sync</span></td> </tr> diff --git a/get.sh b/get.sh index 5029093d..cc514675 100755 --- a/get.sh +++ b/get.sh @@ -1,8 +1,8 @@ #!/usr/bin/env bash # super-board one-line installer. # -# curl -fsSL https://raw.githubusercontent.com/EricTechPro/super-board/main/get.sh | bash -# curl -fsSL https://raw.githubusercontent.com/EricTechPro/super-board/main/get.sh | bash -s -- --protect-main +# curl -fsSL https://raw.githubusercontent.com/mnphuc/super-board-gitea/main/get.sh | bash +# curl -fsSL https://raw.githubusercontent.com/mnphuc/super-board-gitea/main/get.sh | bash -s -- --protect-main # # Options (everything else that starts with "-" goes straight to install.sh): # --target <dir> project to install into (default: the current folder) @@ -13,7 +13,7 @@ # # Environment: # SUPER_BOARD_REF same as --ref -# SUPER_BOARD_REPO GitHub owner/repo to fetch from (default EricTechPro/super-board) +# SUPER_BOARD_REPO GitHub owner/repo to fetch from (default mnphuc/super-board-gitea) # SUPER_BOARD_TARBALL exact tarball URL to fetch instead (file:// works; used by tests) # # Written for bash 3.2 (stock macOS). The whole script lives in main(), called on @@ -43,7 +43,7 @@ helper_skills_present() { main() { local target="" ref="${SUPER_BOARD_REF:-}" helpers=1 - local repo="${SUPER_BOARD_REPO:-EricTechPro/super-board}" + local repo="${SUPER_BOARD_REPO:-mnphuc/super-board-gitea}" local pass=() while [ $# -gt 0 ]; do @@ -79,6 +79,9 @@ main() { have python3 || die "python3 is missing. super-board's installer and scripts use it. Install Python 3 (https://www.python.org/downloads/) and run this again." 69 # One grouped line: what is here ✓, what is not ✗ (onboard's 🔍 Checks installs it). + # tea (the Gitea CLI) is deliberately not inventoried here: whether it is + # required depends on the board's forge, which only onboard knows — its + # 🔍 Checks (super-board-setup.py) lists tea in `needs` for gitea configs. local later="" ok="" t for t in curl tar git python3 gh jq node; do case "$t" in diff --git a/skills/super-board/references/onboard.md b/skills/super-board/references/onboard.md index 1d55e58e..046c3bd5 100644 --- a/skills/super-board/references/onboard.md +++ b/skills/super-board/references/onboard.md @@ -113,7 +113,8 @@ the step-8 table, then "Onboard found an existing setup. What now?" [Keep all ```json { "version": 2, "updated": "<iso>", "last_step": "policies", - "answers": { "github": {"login": "erictech", "remote": "github.com/erictech/my-app"}, + "answers": { "forge": {"kind": "github"}, + "github": {"login": "erictech", "remote": "github.com/erictech/my-app"}, "board": {"owner": "erictech", "number": 4, "title": "Ledgerly Roadmap", "reused": true}, "base_branch": "staging", "agents": "merged", "policies": {"merge_default": "auto", "protect_main": true, "allowed_envs": ["test", "staging"]}, @@ -121,6 +122,10 @@ the step-8 table, then "Onboard found an existing setup. What now?" [Keep all "custom": [{"name": "linear", "kind": "mcp", "target": "linear"}] } } ``` +On a Gitea board, `answers.forge` is `{"kind": "gitea", "host": "https://gitea.example.com", +"login": "<tea login name>", "remote": "gitea.example.com/acme/app", "project_id": 4}` and the +`github` block is replaced by `gitea` with the same `login`/`remote` meaning. + Write it atomically (temp file + rename) after every answer. A halt never loses work. --- @@ -144,6 +149,9 @@ Write it atomically (temp file + rename) after every answer. A halt never loses │ For creation or upkeep read `../../super-qa/references/project-verifier.md`; │ stage real project checks only when source names accepted features. Optional │ verifier gaps never replace or block the required verification commands. + ├─ forge hint: `git remote get-url origin` — a non-github.com host (gitea/forgejo) stages + │ "Gitea" as the step-2 default; github.com or no remote stages "GitHub". A hint, never + │ a decision: step 2 is the question. └─ machine time zone for config `timezone`: $TZ, else readlink /etc/localtime | sed 's#.*zoneinfo/##', else timedatectl show -p Timezone --value, else "UTC". Shown at step 8. @@ -198,7 +206,38 @@ Write it atomically (temp file + rename) after every answer. A halt never loses root (or with the same `--root`). It resumes the saved plan and verifies remote results; it never takes a new snapshot over a partially upgraded board. No extra setup question. -2. 🔑 GITHUB +2. 🔑 FORGE (GitHub or Gitea) + ├─ One AskUserQuestion (header "Forge"), pre-selected from the step-0 hint: + │ "Where do the board, issues and pull requests live?" + │ • GitHub (Recommended when the remote is github.com) + │ • Gitea — a self-hosted Gitea/Forgejo instance (Recommended when the remote is one) + │ An existing config with `forge` set skips the question and shows the value. + ├─ GITEA branch (everything below about gh is skipped; see references/gitea.md): + │ ├─ tea present AND answering: step 1's needs list installs it (winget Gitea.tea / + │ │ brew install tea / the dl.gitea.com binary). A tea that hangs on `tea --version` + │ │ (>5 s) counts as missing — reinstall it; the check re-runs. + │ ├─ Host: from the origin remote, else AskUserQuestion "Other" → type the instance URL + │ │ (e.g. https://gitea.example.com or http://localhost:3000). + │ ├─ Capability gate (no question): `tea api swagger` (or GET <host>/api/v1/swagger) must + │ │ contain the projects-columns operations (`RepoListProjectColumns`, + │ │ `RepoMoveProjectIssue`). Missing → halt: "This Gitea is too old for board + │ │ columns — upgrade the instance or use forge github." The board needs them. + │ ├─ Sign-in: the user creates a token in the Gitea UI (Settings → Applications; scopes + │ │ write:issue, write:repository, and projects when the instance gates them), then + │ │ Bash(tea login add --name <slug> --url <host> --token <token>) — the permission + │ │ prompt is the question; the token itself is typed into the prompt, never into a + │ │ file. CI/headless: GITEA_TOKEN + TEA_HOST env instead (never persisted by tea). + │ ├─ Verify: `tea api /user` → `✓ Gitea connected as <login>.` + │ ├─ No remote → the repo must exist on the instance first (create it in the Gitea UI or + │ │ with tea), then `git remote add origin <host>/<owner>/<repo>.git`. Refused/missing + │ │ → "Not now — the robot can't open pull requests" is still a valid answer. + │ ├─ Second account: offered only as a one-liner ("On Gitea a bot user mainly keeps + │ │ comments separate — the rate-limit budget reason doesn't apply"). Default: skip. + │ └─ bot_identity: the login from `tea api /user` (a bot user's plain username — Gitea + │ has no `[bot]` suffix); stage it with the forge answers: + │ forge: "gitea", forge_host: <host>, forge_login: <tea login name>, + │ project.number: the board's API id (step 3 records it). + └─ GITHUB branch (default, unchanged): ├─ Bash(gh auth status). Signed in with project scopes → `✓ GitHub connected.`; continue below. ├─ Not signed in → one line, then Bash(gh auth login) — the permission prompt asks. ├─ Missing scopes → "This opens a browser to approve board access — needed to move cards and @@ -229,6 +268,8 @@ Write it atomically (temp file + rename) after every answer. A halt never loses │ Labels: feature · bug · qa (qa skips Building; no label = feature) ├─ python3 $SB/super-board-setup.py board-rank --owner <owner> (boards ranked by matching │ columns; `recommend` = the best with ≥ 4 of 7) + │ Gitea: board-rank --owner <owner> --repo <owner/name> --forge gitea — the repo's + │ projects, same output shape; a board's `number` there is its API id. │ python3 $SB/super-board-setup.py names (two names from │ package.json / README / folder) ├─ AskUserQuestion "Which board?" (header "Board"): @@ -239,9 +280,15 @@ Write it atomically (temp file + rename) after every answer. A halt never loses │ "Other" = Type a name. ├─ Reuse → board-migrate --owner <o> --number <n> --repo <owner/repo>: adds the missing │ columns, the three labels, keeps every card. Prints `<title> ready`. + │ Gitea: board-migrate --forge gitea … — additive only (columns/labels created when + │ missing, Skipped→Done); it snapshots to .claude/super-board/migrations/ first and + │ re-running the same command finishes an interrupted upgrade. └─ New → gh project create --owner <o> --title "<name>", link it to the repo, then board-migrate --prune-empty on it (the seven columns replace GitHub's default Todo / In Progress; labels). Prints its URL. + Gitea: tea api -X POST repos/<owner>/<repo>/projects -d '{"title":"<name>"}' — record the + returned id as project.number, then board-migrate --forge gitea --prune-empty creates the + seven colored columns and the three labels. There is no "Needs you" column and no Skipped column: a card waiting on a person goes to Blocked with 🙋 (block-template.md); a card dropped on purpose is closed and moved to Done. Second account chosen in step 2 → finish references/second-account.md now; verify bot access. @@ -314,7 +361,9 @@ Write it atomically (temp file + rename) after every answer. A halt never loses Permission lines: the base list in run-workflow.md → "Mid-run permission prompts", plus the merge lines when merge_policy.default is "auto" ("Bash(bash .claude/bin/super-board-merge-gate.sh:*)", "Bash(gh pr merge:*)"), one "Bash(<migrate command>)" per allowed env, "Bash(bash - .claude/bin/super-board-env-check.sh:*)" and the test runner. N counts what is NOT already in + .claude/bin/super-board-env-check.sh:*)" and the test runner. On a Gitea board the gh lines + are replaced by "Bash(tea:*)" (all board calls go through the tea CLI) and the merge-gate + line stays — the gate owns merges on both forges. N counts what is NOT already in settings.json: `super-board-settings.py allow .claude/settings.json <rules…> --dry-run`. 7. 📥 BUG SOURCES — tick sources; "Add another source" is the free-text box @@ -341,6 +390,7 @@ Write it atomically (temp file + rename) after every answer. A halt never loses │ python3 .claude/skills/super-collect/scripts/collect_sentry.py --config <staged> ping │ python3 .claude/skills/super-collect/scripts/collect_posthog.py --config <staged> ping │ gh api graphql -f query='{viewer{login}}' (github, prs) + │ tea api /user (gitea: github/prs sources) └─ One result block, one line per source; a failure leaves that source out, never halts: ✅ linear — can read issues (12 open bugs); saved in this project's config ✅ sentry · github · prs · architecture @@ -357,7 +407,9 @@ Write it atomically (temp file + rename) after every answer. A halt never loses ├─ AskUserQuestion "Write everything?" (header "Save") [Write everything (Recommended) / │ Change one thing → pick the step, walk only it, back here / Cancel — nothing written]. ├─ Write, in order (each atomic; stop and report on the first failure — answers are kept): - │ ├─ .claude/super-board/configs/<slug>.json (committed): description, project, target + │ ├─ .claude/super-board/configs/<slug>.json (committed): description, forge ("github" or + │ │ "gitea" — plus forge_host/forge_login on gitea; project.number is the board's API + │ │ id there), project, target │ │ {type: repo | repo+url}, repo, base_branch, timezone, columns (the seven), labels, │ │ paths, merge_policy, migrations, collect (incl. custom), notifications {channel: │ │ "session", bot_identity}, worker_backend "workflow", verify_commands (non-blank project checks). No `variant`. @@ -380,6 +432,7 @@ DONE — run `python3 $SB/super-board-verification-ready.py --config <saved conf ⏺ Bash(self-check) ⎿ all good ⏺ 🎉 Onboard complete. 📋 Board: github.com/users/<owner>/projects/<n> (<title>) + — on Gitea: <host>/<owner>/<repo>?project=<id> (<title>) 🧹 Next: /super-board lint — checks every ticket has clear success criteria. 🤖 Then: /super-board run. ``` @@ -454,6 +507,9 @@ answers are kept and it resumes at <step>". | 1 | settings.json invalid JSON | `✋ .claude/settings.json is not valid JSON; I left it untouched. Fix it, then re-run — only the settings entries repeat.` | | 2 | Scope refused in the browser | `🔑 GitHub asked for project,read:project,repo and you said no. Without them I can't read or move cards. Re-run: gh auth refresh -s project,read:project,repo.` | | 2 | Repo create refused | `📦 GitHub refused to create the repo (org admin required, or the free-repo quota). Pick an existing repo, or create one in the web UI, then re-run.` | +| 2 (gitea) | tea installed but hangs | `🔑 tea did not answer \`tea --version\` within 5s — a broken build blocks every board call. Reinstall it (winget install --id Gitea.tea -e · brew install tea · binary from dl.gitea.com/tea), then re-run onboard.` | +| 2 (gitea) | Token refused (401/403) | `🔑 <host> refused the token. Recreate it with write:issue + write:repository (and projects when the instance gates it), then re-run: tea login add --name <slug> --url <host> --token <token>.` | +| 2 (gitea) | Instance lacks the projects-columns API | `🔑 This Gitea has no project-columns API (swagger lacks RepoMoveProjectIssue). Upgrade the instance, or keep forge github. Nothing was written.` | | 3 | Org project denied | `🔑 You can't create projects under <org>. Ask an org admin, or use your account: gh project create --owner @me.` | | 3 | Board read-only | `🔑 That board is read-only for your account. Get write access, or pick another.` | | 3 | board-migrate exits 2 | Show its `error` and recovery-file path. Some changes may already be applied. Keep the board stopped and the recovery file; fix the access/read/write failure, then re-run the same command from the same project root. A concurrent-edit conflict needs review of the saved original/desired state; never delete the record to bypass it. | @@ -485,10 +541,13 @@ remove a pending recovery record; use its saved state to reconcile a conflict be 1. **Config validates** — `.claude/super-board/configs/<slug>.json` parses, has every required field from `config-schema.json` (incl. `notifications.bot_identity`, `merge_policy`, - `migrations`), has no `variant`, and `columns` is the seven. + `migrations`), has no `variant`, and `columns` is the seven. On a gitea config `forge`, + `forge_host` are present and `project.number` is the board's API id. 2. **Active pointer** — `.claude/super-board/active` holds exactly the slug + `\n`. 3. **Board columns and labels** — `gh project field-list <n> --owner <o>` returns Backlog, Ready, Building, QA, Review, Blocked, Done (no Skipped); `gh label list` has qa, bug, feature. + Gitea: `python3 .claude/bin/super-board-gitea-read.py --kind fields --fields <owner>/<repo>/<id>` + returns the seven options, and `tea api repos/<owner>/<repo>/labels` lists qa, bug, feature. 4. **Setup green** — `python3 .claude/bin/super-board-setup.py check` exits 0 (or only `needs` the user declined). 5. **Workflow runtime** — unless `worker_backend` is `"claude-p"`, the step-1 `node --check` passes. From 22f18936632932b7e9299104d660455a1ad48e28 Mon Sep 17 00:00:00 2001 From: PhucMN <phucmnp@gmail.com> Date: Fri, 16 Oct 2026 17:59:27 +0700 Subject: [PATCH 7/8] =?UTF-8?q?=F0=9F=93=9D=20[docs]=20forge:=20gitea=20re?= =?UTF-8?q?ference=20+=20dual-forge=20docs=20pass?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - writing-standard.md FIRST (repo rule): screenshot embed rule is now forge-parameterized — GitHub /raw/<sha>/ vs Gitea /raw/commit/<sha>/ (branch: raw/branch/<b>/) - new references/gitea.md: model mapping, gh↔tea command dictionary, gitea-read kinds, lane checklist, accepted degradations (no GraphQL, no CAS claim, Closes-trailer links, stateReason, draft cards), troubleshooting (hung tea.exe, 401, old instances, API-id vs UI number) - one conditional note per SKILL.md (build/qa/review/collect/git-sync) instead of duplicating commands - run.md preconditions (forge auth + guard rows), run-workflow.md (wave args gain forge; tea permission line), stop.md, status.md, lint.md tool line, second-account.md Gitea section, rate-limit-etiquette.md gitea budget discipline + forge-neutral gh-quota-on-exit line - README.md, skills/super-board/README.md, docs/super-board/README.md (forge key + Gitea note), CLAUDE.md (forge dispatch code map, worker rules, install tree, board shape) Co-Authored-By: Claude Code <noreply@anthropic.com> --- CLAUDE.md | 31 +++--- README.md | 4 +- docs/super-board/README.md | 7 ++ skills/git-sync/SKILL.md | 4 + skills/super-board/README.md | 2 +- skills/super-board/references/gitea.md | 95 +++++++++++++++++++ skills/super-board/references/lint.md | 2 +- .../references/rate-limit-etiquette.md | 9 +- skills/super-board/references/run-workflow.md | 10 +- skills/super-board/references/run.md | 4 +- .../super-board/references/second-account.md | 6 ++ skills/super-board/references/status.md | 2 + skills/super-board/references/stop.md | 2 +- .../references/writing-standard.md | 6 +- skills/super-build/SKILL.md | 6 +- skills/super-collect/SKILL.md | 4 + skills/super-qa/SKILL.md | 4 + skills/super-review/SKILL.md | 4 + 18 files changed, 176 insertions(+), 26 deletions(-) create mode 100644 skills/super-board/references/gitea.md diff --git a/CLAUDE.md b/CLAUDE.md index 2f6aefd3..cce31c3c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -5,6 +5,9 @@ This repo ships eight skills under `skills/`: five you type (`super-board`, `sup `super-review`). Architecture findings come from `/super-collect architecture`. Worktree cleanup (`hooks/cleanup-wt.py`) is a hook, not a skill. README skill tables are generated by `scripts/super-board-readme-sync.py` from SKILL.md frontmatter and `skills/families.json`. +A board runs on **GitHub (default) or Gitea** — the config's `forge` key decides; every forge +rule, mapping and degradation lives in `skills/super-board/references/gitea.md`. Forge dispatch +code: `scripts/super-board-forge.{py,sh}` + `super-board-gitea-{read.py,api.sh}`. ## The cardinal rule @@ -20,22 +23,26 @@ The orchestrator MUST NOT: - Build, test, review, or fix issues itself. All product work is delegated to workflow lane agents (or `claude -p` workers on the legacy backend). - Patch the dispatcher script or skill files mid-run, even if it sees a problem. Capture the symptom and tell the user; wait for explicit approval. -- Wait on individual workers or relay their work. They write their evidence back to the GitHub issue + PR. The orchestrator's user-facing output is the dispatch confirmation (claude-p) or one short report per wave (workflow), not the run result. -- Hold context for multi-card progress. State lives on the GitHub Project board + the inflight lockfiles, not in the orchestrator's session. +- Wait on individual workers or relay their work. They write their evidence back to the forge issue + PR (GitHub or Gitea). The orchestrator's user-facing output is the dispatch confirmation (claude-p) or one short report per wave (workflow), not the run result. +- Hold context for multi-card progress. State lives on the board (GitHub Project / Gitea project) + the inflight lockfiles, not in the orchestrator's session. If a problem surfaces during the run, the orchestrator's reply is: "I saw X. Want me to dig in or stop the runner?" — not "I went ahead and fixed it." ## Worker rules -Workers (`super-build`, `super-qa`, `super-review`) share the dispatcher's `gh` token bucket. They MUST: +Workers (`super-build`, `super-qa`, `super-review`) share the dispatcher's forge token bucket +(the `gh` GraphQL+REST budget, or the Gitea instance's API limits — often disabled, in which +case the per-worker call budget is the only guard). They MUST: -- Required GitHub reads use `.claude/bin/super-board-github-read.py`; exit 79 stops the run. -- Check its `--check` before GitHub writes, migrations, merges, and new dispatch; preserve work when halted. -- Source `.claude/bin/super-board-gh-guard.sh` (`scripts/` in this repo) at worker start. -- Call `sb_gh_guard_check 200` before any burst of `gh` calls. -- Prefer local `git blame` / `git log` over `gh api graphql` for any sub-agent that doesn't need fresh state. -- Cap adversarial sub-agents at 50 gh calls each. If a sub-agent runs out, it returns `confidence: insufficient_data` rather than burning the shared quota. -- Append `gh-quota-on-exit: graphql=<n>/5000 rest=<n>/5000` to the PR handoff comment. +- Required reads use the forge's wrapper — `.claude/bin/super-board-github-read.py`, or + `.claude/bin/super-board-gitea-read.py` on gitea boards; exit 79 stops the run. +- Check its `--check` before forge writes, migrations, merges, and new dispatch; preserve work when halted. +- Source `.claude/bin/super-board-gh-guard.sh` (`scripts/` in this repo) at worker start — it is forge-aware. +- Call `sb_gh_guard_check 200` before any burst of forge calls. +- Prefer local `git blame` / `git log` over forge API calls for any sub-agent that doesn't need fresh state. +- Cap adversarial sub-agents at 50 forge calls each. If a sub-agent runs out, it returns `confidence: insufficient_data` rather than burning the shared quota. +- Append `gh-quota-on-exit: graphql=<n>/5000 rest=<n>/5000` (GitHub) or + `gh-quota-on-exit: budget=<n> rate_limits=off|<rem>/<limit>` (Gitea) to the PR handoff comment. See `skills/super-board/references/rate-limit-etiquette.md` for the full discipline. @@ -48,7 +55,7 @@ See `skills/super-board/references/rate-limit-etiquette.md` for the full discipl ├── skills/<all eight>/... ├── hooks/guard-*.py, cleanup-wt.py (wired into settings.json; --no-hooks skips) ├── workflows/super-board-wave.js, ui-refine-loop.js -└── bin/super-board-*.sh (incl. pr-body), super-board-*.py (status, merge-policy, agents-md, settings, setup), super-qa-file-bug.sh, super-review-file-refactor.sh +└── bin/super-board-*.sh (incl. pr-body, forge, gitea-api), super-board-*.py (status, merge-policy, agents-md, settings, setup, forge, gitea-read), super-qa-file-bug.sh, super-review-file-refactor.sh ``` It also refreshes the managed `<!-- super-board:begin … -->` block in the target's AGENTS.md when @@ -63,6 +70,8 @@ Columns are always Backlog · Ready · Building · QA · Review · Blocked · Do per-board `variant`. Labels `qa` · `bug` · `feature` route cards: `qa` skips Building, everything else (and no label) is built. Change routing in `scripts/super-board-wave-plan.sh`, `workflows/super-board-wave.js` and `run.md` → "Lanes and label routing" together. +On Gitea the seven columns are repo-project columns (`project.number` = the project's API id); +`super-board-card.sh` normalizes both forges into one `{items,totalCount}` shape. Skills call the dispatcher scripts as `.claude/bin/<script>`. diff --git a/README.md b/README.md index 89274d2c..c9291bf9 100644 --- a/README.md +++ b/README.md @@ -39,7 +39,7 @@ Or as a Claude Code plugin: ``` > [!NOTE] -> The plugin ships the skills only. Run `/super-board:super-board onboard` and its 🔍 Checks step adds the guard hooks, scripts and workflows. Needs Claude Code, `gh`, `jq`, bash 3.2+ and Python 3.9+; the installer checks. +> The plugin ships the skills only. Run `/super-board:super-board onboard` and its 🔍 Checks step adds the guard hooks, scripts and workflows. Needs Claude Code, `gh` (GitHub boards) or `tea` v0.16+ (Gitea boards — `forge: "gitea"`), `jq`, bash 3.2+ and Python 3.9+; the installer checks. Optional post-run learning can delegate an already installed `calibrate` skill after verified selected work completes. It applies only to explicitly permitted existing @@ -60,7 +60,7 @@ curl -fsSL https://raw.githubusercontent.com/mnphuc/super-board-gitea/main/get.s /super-board onboard ``` -Checks · GitHub · Board · Branch · AGENTS.md · Policies · Bug sources · Review. <kbd>Enter</kbd> takes the recommended answer. +Checks · Forge (GitHub or Gitea) · Board · Branch · AGENTS.md · Policies · Bug sources · Review. <kbd>Enter</kbd> takes the recommended answer. ### 3. Run diff --git a/docs/super-board/README.md b/docs/super-board/README.md index 3a602a00..5d2fd509 100644 --- a/docs/super-board/README.md +++ b/docs/super-board/README.md @@ -251,6 +251,7 @@ Minimal config at `.claude/super-board/configs/<slug>.json`: ``` worker_backend workflow | claude-p + forge github (default, absent = github) | gitea — plus forge_host (+ optional forge_login) on gitea columns Backlog · Ready · Building · QA · Review · Blocked · Done (always all seven) human_approves_merge legacy: true = never auto-merge (prefer merge_policy.default "human") merge_policy default auto|human · auto_max_lines (400) · size_exclude · always_human {money, auth, schema} @@ -274,6 +275,12 @@ Minimal config at `.claude/super-board/configs/<slug>.json`: Every key, with notes: `skills/super-board/references/config-schema.json`. +**Gitea boards** (`"forge": "gitea"`) run the same pipeline against a Gitea/Forgejo instance +through the `tea` CLI: the board is a repo Project whose columns are the seven statuses, and +`project.number` is the project's API id. Onboard asks for the host and token; every script +resolves the forge from config/env. Full mapping, command dictionary and degradations: +`skills/super-board/references/gitea.md`. + ## How workers decide what test to write Three layers, three questions. None substitutes for another. diff --git a/skills/git-sync/SKILL.md b/skills/git-sync/SKILL.md index 8453a1ea..91f6f5c3 100644 --- a/skills/git-sync/SKILL.md +++ b/skills/git-sync/SKILL.md @@ -5,6 +5,10 @@ description: Sync the current branch in one pass — commit the working tree as # /git-sync +> **Gitea boards:** when the active config sets `"forge": "gitea"`, every `gh` command in this +> skill is replaced by its `tea` equivalent in [gitea.md](../super-board/references/gitea.md); +> the board scripts (card.sh, merge-gate, filers, read wrappers) resolve the forge themselves. + Commit what is in the working tree, pull, push, report. One step per line. Stop and tell the user when a step says stop. NEVER force push, rebase shared history, or skip a hook (`--no-verify`). diff --git a/skills/super-board/README.md b/skills/super-board/README.md index 694e55af..7c615b46 100644 --- a/skills/super-board/README.md +++ b/skills/super-board/README.md @@ -28,4 +28,4 @@ Drives a GitHub Project board on its own: drag a card into `Ready`, and it comes ## Install -Part of the super-board pack: `./install.sh /path/to/project`. Needs `gh` (authenticated), `jq`, bash 3.2+, a GitHub Project (v2) with a `Status` field, dynamic workflows on in `/config`, and the [mattpocock/skills](https://github.com/mattpocock/skills) pack. Full reference: [`docs/super-board/README.md`](../../docs/super-board/README.md). +Part of the super-board pack: `./install.sh /path/to/project`. Needs `gh` (authenticated) — or `tea` v0.16+ for a Gitea board (`forge: "gitea"`, see [gitea.md](references/gitea.md)) — plus `jq`, bash 3.2+, a GitHub Project (v2) with a `Status` field or a Gitea repo project, dynamic workflows on in `/config`, and the [mattpocock/skills](https://github.com/mattpocock/skills) pack. Full reference: [`docs/super-board/README.md`](../../docs/super-board/README.md). diff --git a/skills/super-board/references/gitea.md b/skills/super-board/references/gitea.md new file mode 100644 index 00000000..6ec7e45e --- /dev/null +++ b/skills/super-board/references/gitea.md @@ -0,0 +1,95 @@ +# gitea.md — running super-board against Gitea + +One page for every lane and script that talks to a forge. A board is Gitea when its +config (`.claude/super-board/configs/<slug>.json`) sets `"forge": "gitea"` (+ `forge_host`, +optional `forge_login`), or the environment says `SB_FORGE=gitea`. Absent both, the board is +GitHub and nothing on this page applies. Resolution order everywhere: **env → config → git +remote (advisory) → github** (`super-board-forge.py`). + +Everything goes through the **tea CLI (v0.16.x pinned semantics)**: native commands where they +exist, `tea api` for the REST surface. Auth: `tea login add --name <slug> --url <host> --token` +(interactive) or `GITEA_TOKEN` + `TEA_HOST` (CI, never persisted). `SB_GITEA_TEA` overrides the +executable (tests point it at `evals/_stubs/bin/tea`). + +## Model mapping + +| GitHub | Gitea | Notes | +|---|---|---| +| Projects v2 board (`project.number`) | repo Project (`project.number` = **API id**) | UI URL: `<host>/<owner>/<repo>?project=<id>` | +| Status single-select field + options | project **columns** | `card.sh` synthesizes a `Status` field from columns; option ids are column ids (strings) | +| `updateProjectV2ItemFieldValue` | `POST …/projects/{id}/issues/{gid}/move {column_id}` | `gid` = issue **global id**, not the repo-local number | +| project item id (`PVTI_…`) | `gitea:<global id>` | same cache slots in `board-<owner>-<number>.json` | +| GraphQL (`gh api graphql`) | none — REST only | every read is 1+ `tea api` GETs | +| `gh pr merge --squash --match-head-commit X` | `POST …/pulls/{i}/merge {do:"squash", head_commit_id:X, delete_branch_after_merge:true}` | merge-gate owns it on both forges | +| `closingIssuesReferences` | `Closes #N` trailer parse | writing standard guarantees the trailer; no trailer → no link → approval fails closed | +| `stateReason` | absent | closed issues read as `COMPLETED` | +| rate limits (5000 pts/hr GraphQL + REST) | `X-RateLimit-*` headers, often **disabled** | `--kind quota` answers `rate_limits_disabled:true` with sentinel 5000s; the per-worker budget (exit 73) is then the only guard | +| `[bot]` app identity | plain bot user | `bot_identity` = username, no suffix | +| assignee claim mutex (atomic edit) | best-effort assign | local `inflight/` lock stays the primary claim | +| review threads / `resolveReviewThread` | no thread API | use PR review comments + `tea pulls resolve` where the server supports it | +| DraftIssue board cards | impossible | — | +| org-level boards | out of scope (v1) | repo projects only | + +## gh ↔ tea dictionary (the literal commands skills quote) + +| Task | GitHub | Gitea | +|---|---|---| +| Read issue body | `gh issue view N --json number,title,body` | `python3 .claude/bin/super-board-gitea-read.py --kind issue --issue N` | +| Read issue comments | `gh api repos/{o}/{r}/issues/N/comments --paginate` | `…gitea-read.py --kind comments --issue N` | +| Issue state | `gh issue view N --json state` | `…gitea-read.py --kind state --issue N` | +| PR head | `gh pr view N --json headRefName,headRefOid` | `…gitea-read.py --kind head --pr N` | +| PR metadata / diff | `gh pr view --json …` / `gh pr diff` | `…gitea-read.py --kind metadata --pr N` / `--kind diff --pr N --meta <file>` | +| Board read / move | `super-board-card.sh` | `super-board-card.sh` (same verbs; forge inside) | +| Add label | `gh issue edit N --add-label L` | `bash -c '. .claude/bin/super-board-forge.sh && sb_forge_resolve <cfg> && sb_forge_label_add N L'` | +| Comment | `gh issue comment N --body …` | `bash -c '. .claude/bin/super-board-gitea-api.sh && sb_gitea_api POST repos/{o}/{r}/issues/N/comments "$(jq -cn --arg b … '{body:$b}')"'` | +| Create issue | `gh issue create …` | `sb_gitea_api POST repos/{o}/{r}/issues '{"title":…,"body":…,"labels":[ids]}'` (labels are **ids**; resolve/create first) | +| Default branch | `gh repo view --json defaultBranchRef` | `tea api repos/{o}/{r}` → `.default_branch` | +| Quota line on exit | `gh-quota-on-exit: graphql=<n>/5000 rest=<n>/5000` | `gh-quota-on-exit: budget=<n> rate_limits=off` or `budget=<n> rate_limits=<rem>/<limit>` | + +Scripts must never hardcode a forge: source `.claude/bin/super-board-forge.sh`, call +`sb_forge_resolve <config>`, then use `sb_forge_read` / `sb_forge_write_once` (github) / +`sb_forge_tea_write` (gitea) / `sb_forge_label_add`. Exit codes are identical on both forges: +79 halt · 73 budget · 69 board · 67 CLI fail · 64 usage/shape · 66 config · 6 head moved. + +## Kinds served by `super-board-gitea-read.py` + +Passthrough kinds (`-- <tea api GET …>`): `json`, `scalar`, `object`, `array`, `issue-number`. +Composites (the wrapper performs the calls and prints the **github-normalized** shape): +`--issue N` → issue/state/comments · `--pr N` → head/body/merge-state/metadata/diff/approval · +`--items o/r/pid` → items · `--fields o/r/pid` → fields · `--project`/`--projects` · +`--permission o/r` · `--issue-history o/r` · `--deps o/r` · `--prs-open`/`--prs-merged`/ +`--issues-closed o/r` · `--quota`. Same halt file as github-read +(`.claude/super-board/github-halt.json`), same `--check/--halt/--resume` contract, exit 79/64. + +## Lane checklist (Gitea runs) + +1. `SB_FORGE`, `SB_FORGE_HOST`, `SB_FORGE_LOGIN`, `GITEA_REPO` come from + `sb_forge_resolve <config>`; lanes that run bare commands export them first. +2. Required reads still go through the read wrapper (`…gitea-read.py`); `--check` before every + write burst; a halt (79) preserves work exactly as on GitHub. +3. Board moves: `super-board-card.sh --config <cfg> move <issue> <Status>` — never raw + `tea api …/move`. +4. Merges: `super-board-merge-gate.sh` only — never bare `tea pulls merge`. +5. Screenshots in tickets/PRs use the Gitea raw form (writing-standard.md → Rules). + +## Degradations (accepted, fail-closed) + +- **No GraphQL**: multi-object reads are several REST calls (`--deps` = 1 + N comments reads). + Budget your calls; `sb_gh_budget_spend` still caps every worker (exit 73). +- **No compare-and-swap on assignees**: two dispatchers can claim the same card remotely; the + local inflight lock is authoritative for a single machine. +- **`head_commit_id` on merge**: enforced on current Gitea; an old server ignoring it narrows + the pin to the gate's own re-read (documented risk, see merge-gate). +- **Approval trust**: repo owner = admin; listed collaborators = write; nobody else approves. + An unreadable collaborator list fails closed. +- **collect `prs` source**: no review threads; `mergedAt` is `closed_at`/`updated_at`. + +## Troubleshooting + +| Symptom | Fix | +|---|---| +| every tea call times out (Windows) | the tea binary itself hangs — reinstall: `winget install --id Gitea.tea -e`, `brew install tea`, or the `dl.gitea.com/tea` binary; onboard's `tea_probe` (5 s) catches this | +| `HTTP 401/403` on first read | token scopes — recreate with `write:issue`, `write:repository` (+ projects when gated), then `tea login add …` again | +| onboard says "no project-columns API" | the instance predates the columns endpoints — upgrade Gitea or keep `forge: github` | +| guard never sleeps, runs fast, then 429s | instance rate limits were enabled mid-run — the throttle steps `max_workers` down from lane-result evidence | +| cards visible in UI but `items` empty | the project id in config is the UI number, not the API id — re-run `board-rank --forge gitea` and fix `project.number` | diff --git a/skills/super-board/references/lint.md b/skills/super-board/references/lint.md index 8e600d40..5d245091 100644 --- a/skills/super-board/references/lint.md +++ b/skills/super-board/references/lint.md @@ -226,7 +226,7 @@ Sub-agent scans all linted issues + PROJECT.md to extract operational requiremen [ ] Stripe test secret key (issue #31) 🛠 Tools the loop will need: - [✓] gh CLI authenticated (verified) + [✓] forge CLI authenticated — gh, or tea on a gitea board (verified) [ ] Playwright Chromium → run: `npx playwright install chromium` [✓] Node 20+ (verified) diff --git a/skills/super-board/references/rate-limit-etiquette.md b/skills/super-board/references/rate-limit-etiquette.md index 3d1ce997..6e13fcec 100644 --- a/skills/super-board/references/rate-limit-etiquette.md +++ b/skills/super-board/references/rate-limit-etiquette.md @@ -2,7 +2,10 @@ The dispatcher's `gh_rate_guard` only protects the dispatcher's own ticks. Workers (Builder / Tester / Reviewer) run as independent `claude -p` sessions and **share the same gh-auth token bucket** — 5000 GraphQL points/hr for a PAT, 15000/hr for a GitHub App. The #381 worker storm (2026-05-21) drained the bucket because nothing in the worker contract told workers to watch the quota. -This file is the worker-side contract. Every worker MUST follow it. +This file is the worker-side contract. Every worker MUST follow it. On a **Gitea** board the +same contract runs against the instance's `X-RateLimit-*` headers (often disabled — then the +per-worker budget below is the ONLY guard, and `sb_gh_guard_check` never sleeps); the price list +is GitHub-specific, the disciplines are not. See gitea.md. ## Price list @@ -89,7 +92,9 @@ If a `gh` call returns 403 or a body containing `secondary rate limit`, do NOT r Every worker's PR handoff comment MUST include a final line: ``` -gh-quota-on-exit: graphql=<n>/5000 rest=<n>/5000 +gh-quota-on-exit: graphql=<n>/5000 rest=<n>/5000 ← GitHub +gh-quota-on-exit: budget=<n> rate_limits=off ← Gitea, limits disabled +gh-quota-on-exit: budget=<n> rate_limits=<rem>/<limit> ← Gitea, limits on ``` Use `sb_gh_guard_summary` to grab the snapshot. This gives the run manifest visibility into which lane is the heaviest consumer over time. diff --git a/skills/super-board/references/run-workflow.md b/skills/super-board/references/run-workflow.md index 8721d90a..1dd0cf11 100644 --- a/skills/super-board/references/run-workflow.md +++ b/skills/super-board/references/run-workflow.md @@ -244,8 +244,10 @@ Repeat until a done condition or halt gate fires: 4. **Launch** — With `--codex`, or no Workflow tool, or the host check printing `codex`, use "Codex runs" above; otherwise Workflow tool with `scriptPath: .claude/workflows/super-board-wave.js` and - `args: { configPath, cards, humanApprovesMerge, tier }` (`cards` hydrated after the planner: each - carries `lane` and `labels`, and a `qa` card skips the Builder). Runs in the background; the + `args: { configPath, cards, humanApprovesMerge, tier, forge }` (`cards` hydrated after the planner: each + carries `lane` and `labels`, and a `qa` card skips the Builder; `forge` is the config's + `forge` value — `"gitea"` switches every lane prompt to the tea read shapes, gitea.md). + Runs in the background; the orchestrator stays responsive. `humanApprovesMerge` comes from the config; when false the workflow serializes Review-lane agents (merge-race guard, execution side). `tier` is the run's model ladder: `'low'` when the user invoked `super-board run --low` (haiku/sonnet/opus by card complexity), `'high'` @@ -319,7 +321,9 @@ reported as skipped and does not change the completed product work. Lane agents inherit the session allowlist and run in acceptEdits. Add these to your project's `.claude/settings.json` → `permissions.allow` so waves -don't stall on prompts: +don't stall on prompts (on a Gitea board the `gh …` lines are replaced by one +`"Bash(tea:*)"` — every forge call goes through the tea CLI; the script lines +are forge-neutral and stay — gitea.md): "Bash(gh issue view:*)", "Bash(gh issue edit:*)", "Bash(gh issue comment:*)", "Bash(gh pr view:*)", "Bash(gh pr diff:*)", "Bash(gh pr checks:*)", "Bash(gh pr comment:*)", diff --git a/skills/super-board/references/run.md b/skills/super-board/references/run.md index 81eb4bf2..f61f0991 100644 --- a/skills/super-board/references/run.md +++ b/skills/super-board/references/run.md @@ -63,7 +63,7 @@ bounded receipt and delegate the external skill after normal final reconciliatio | Usable verification commands | Run `python3 .claude/bin/super-board-verification-ready.py --config <config>`. Exit 9 halts setup before dispatch: configure the owning project's checks, then restart explicitly. | | Active config exists | Halt: "Run `super-board onboard` first." | | Project + required columns exist | Halt: "Project / columns missing. Run `super-board onboard` to repair." | -| `gh auth` valid with required scopes | Halt: "Re-auth: `gh auth refresh -s project,read:project,repo`." | +| Forge auth valid | GitHub: `gh auth` with required scopes — Halt: "Re-auth: `gh auth refresh -s project,read:project,repo`." Gitea (`forge: "gitea"`): `tea api /user` answers — Halt: "Re-auth: `tea login add …` or set GITEA_TOKEN + TEA_HOST" (see gitea.md). | | `pre-flight.md` all items `[✓]` | Halt: "Pre-flight incomplete — fix these: [list]." | | No issues missing ACs in active columns | Halt: "N issues need clarification. Run `super-board lint`." | | Clean git working tree on base branch | Halt: "Working tree dirty. Stash or commit before running." | @@ -72,7 +72,7 @@ bounded receipt and delegate the external skill after normal final reconciliatio | Production-merge guard | If `base_branch == "main"` AND `human_approves_merge == false` AND `merge_policy.default != "human"` AND `merge_policy.allow_auto_on_production != true` AND production-detection signals fire (see onboard → base branch), halt with: `🛡 Refusing to start: would auto-merge to production main. Set merge_policy.default: "human", switch base_branch to staging, or re-run super-board onboard to opt in explicitly.` | | Orphan-worker scan (added 2026-05-22 after #381 worker storm) | `pgrep -f 'claude -p .*super-board run'` must return zero. If any super-board worker is already alive from a prior crashed run, halt with: `🛑 ${N} super-board workers already running. Stop them first: pkill -f 'claude -p .*super-board run'`. The dispatcher must never run while orphan workers exist — they will collide on assignee claims and produce duplicate PRs. | | Database reach | Run every `migrations.checks[env]` for an env in `allowed_envs` (read-only, e.g. `supabase migration list --db-url …`). On failure halt with its error: "Migrate URL for <env> does not connect — fix it before a wave builds work the gate cannot land." | -| GraphQL rate-limit guard | Before each tick, `sb_gh_guard_check` (super-board-gh-guard.sh — it reads GraphQL's own `rateLimit`, because `gh api rate_limit` misreports the GraphQL bucket). If GraphQL remaining < 200, sleep until reset. Prevents the runner from dying mid-loop when the user has burned quota in another tool. | +| Rate-limit guard | Before each tick, `sb_gh_guard_check` (super-board-gh-guard.sh — on GitHub it reads GraphQL's own `rateLimit`, because `gh api rate_limit` misreports the GraphQL bucket; on Gitea it reads the instance's `X-RateLimit-*` headers and no-ops when the instance has limits disabled — gitea.md). If remaining < 200, sleep until reset. Prevents the runner from dying mid-loop when the user has burned quota in another tool. | ## Lanes and label routing diff --git a/skills/super-board/references/second-account.md b/skills/super-board/references/second-account.md index 871cba48..f8ffb2e5 100644 --- a/skills/super-board/references/second-account.md +++ b/skills/super-board/references/second-account.md @@ -4,6 +4,12 @@ Follow this when onboard step 2 chooses "Yes". Allow about 10 minutes. Keep the owner active until step 3 has picked or created the Project. Replace every `<placeholder>` below before running a command. NEVER read a `.env` file. +> **On Gitea this page mostly does not apply.** There is no shared 5,000-points GraphQL budget — +> a bot user is only worth it to keep robot comments visually separate, or when the instance +> rate-limits per token. Create a plain bot user in the Gitea admin, give it repo write access, +> mint its token, and `tea login add --name <bot> --url <host> --token <token>`; set +> `forge_login` and `notifications.bot_identity` to its username (no `[bot]` suffix on Gitea). + ## Why GraphQL calls from `gh issue`, `gh pr` and `gh project` use the signed-in user's diff --git a/skills/super-board/references/status.md b/skills/super-board/references/status.md index 07672c2d..d33b9b7c 100644 --- a/skills/super-board/references/status.md +++ b/skills/super-board/references/status.md @@ -2,6 +2,8 @@ > This is the **only read-only verb** in the `super-board` skill. It performs > no GitHub mutations and is safe to invoke during a headless `super-board run`. +> On a Gitea board (`forge: "gitea"`) the same snapshot renders from the tea-based +> reads — see gitea.md; it is pure-read there too. --- diff --git a/skills/super-board/references/stop.md b/skills/super-board/references/stop.md index cb0c1b4a..77d52aab 100644 --- a/skills/super-board/references/stop.md +++ b/skills/super-board/references/stop.md @@ -24,7 +24,7 @@ Progress: ✅ onboard → ✅ run → 🛑 stop (you are here) |---|---| | Active config exists (arg or `.claude/super-board/active`) | Exit 64: usage hint | | Config file readable | Exit 66: "config not found" | -| `gh auth` valid | Continue anyway — comments may fail, kills still work | +| `gh auth` valid (gitea: `tea api /user` answers) | Continue anyway — comments may fail, kills still work | Nothing else. Stop is intentionally tolerant — its job is to bring the system to rest, not to enforce policy. diff --git a/skills/super-board/references/writing-standard.md b/skills/super-board/references/writing-standard.md index 41ec2433..127c910b 100644 --- a/skills/super-board/references/writing-standard.md +++ b/skills/super-board/references/writing-standard.md @@ -11,8 +11,10 @@ Every template in this pack points here. Change the format here first, then the - ALWAYS run prose through the `humanizer` skill when it is installed. Without it, use the plain-words rules at the bottom. - ONE step per line. NEVER chain steps with arrows (`→`) in Problem, Context or Steps. -- EMBED screenshots (`![desktop](https://github.com/<o>/<r>/raw/<sha>/<path>)`), pinned to a - commit sha. NEVER link to them, NEVER upload to a public image host. +- EMBED screenshots, pinned to a commit sha. NEVER link to them, NEVER upload to a public + image host. GitHub form: `![desktop](https://github.com/<o>/<r>/raw/<sha>/<path>)`. + Gitea form: `![desktop](https://<host>/<o>/<r>/raw/commit/<sha>/<path>)` — note the extra + `commit/` segment; a branch pin uses `raw/branch/<branch>/<path>`. - NEVER write a "Not verified" section or a "Next" section in a PR body. An unchecked AC with its one-line reason replaces both. - DON'T repeat a changed-file list in status comments. Explain each file in its own PR diff --git a/skills/super-build/SKILL.md b/skills/super-build/SKILL.md index 16c7f017..a8d4fc20 100644 --- a/skills/super-build/SKILL.md +++ b/skills/super-build/SKILL.md @@ -5,6 +5,10 @@ description: Builder lane of the super-board pipeline — takes a `Ready` GitHub # Super Build — Builder lane and legacy headless GitHub-Project executor +> **Gitea boards:** when the active config sets `"forge": "gitea"`, every `gh` command in this +> skill is replaced by its `tea` equivalent in [gitea.md](../super-board/references/gitea.md); +> the board scripts (card.sh, merge-gate, filers, read wrappers) resolve the forge themselves. + Inside `super-board run`, Super Build is the Builder lane: a lane agent in the in-session wave workflow (`workflows/super-board-wave.js`) that follows "super-board integration" below. Run on its own, `/super-build` is the **legacy headless path (opt-in)**: you are the orchestrator, the source of truth is the **`Ready` column of the configured GitHub Project board**, and your job is to dispatch every issue in `Ready` (in board order) as a headless `claude -p` worker in its own git worktree, open a PR for each finished branch, and move its card to `QA` so the Tester and Reviewer take it from there. Super Build never merges — merging happens only through the Reviewer's merge gate (`scripts/super-board-merge-gate.sh`). **Curation contract:** the human moves cards into `Ready` when they should be worked. The loop never reads `Backlog`, `In Progress`, or `Done` cards. If `Ready` is empty, the loop reports "queue empty" and exits cleanly — no error. @@ -40,7 +44,7 @@ Surface: `🎯 Reading project: <owner>/<title> (#<n>), column "Ready"`. Before reading the board: - Confirm the main worktree is clean: `git status --porcelain` must be empty. -- Confirm `gh auth status` works and the repo remote points at the expected GitHub repo. +- Confirm `gh auth status` works and the repo remote points at the expected GitHub repo (on a Gitea board: `tea api /user` answers and the remote points at the expected instance — gitea.md). - Confirm `jq`, `git`, and `claude` are available. - Resolve and print `BUILD_LOOP_OWNER` and `BUILD_LOOP_PROJECT`. - Run `git fetch origin` and identify the base branch from the current checkout; do **not** assume `main`. diff --git a/skills/super-collect/SKILL.md b/skills/super-collect/SKILL.md index cb43da28..5bfa1a5d 100644 --- a/skills/super-collect/SKILL.md +++ b/skills/super-collect/SKILL.md @@ -5,6 +5,10 @@ description: Find problems in one project and file them as tickets into its supe # super-collect — find problems, file them into Backlog +> **Gitea boards:** when the active config sets `"forge": "gitea"`, every `gh` command in this +> skill is replaced by its `tea` equivalent in [gitea.md](../super-board/references/gitea.md); +> the board scripts (card.sh, merge-gate, filers, read wrappers) resolve the forge themselves. + One job: find problems and file tickets into the board's **Backlog**. The board fixes them. super-collect never builds, never edits app code, and never moves a card to `Ready` — `super-board lint` decides that. Per project only: it reads the active project's super-board diff --git a/skills/super-qa/SKILL.md b/skills/super-qa/SKILL.md index 3f6801a7..317d868f 100644 --- a/skills/super-qa/SKILL.md +++ b/skills/super-qa/SKILL.md @@ -17,6 +17,10 @@ on missing requirements and recheck each conditional helper before use. # super-qa — BFS Route-Crawler that Builds the Spec Suite +> **Gitea boards:** when the active config sets `"forge": "gitea"`, every `gh` command in this +> skill is replaced by its `tea` equivalent in [gitea.md](../super-board/references/gitea.md); +> the board scripts (card.sh, merge-gate, filers, read wrappers) resolve the forge themselves. + ## Auth bootstrap — auto-discover, never ask Before iter 1, resolve a test login. **Never ask the user; discover or create.** Order: diff --git a/skills/super-review/SKILL.md b/skills/super-review/SKILL.md index 669613fa..090ebece 100644 --- a/skills/super-review/SKILL.md +++ b/skills/super-review/SKILL.md @@ -10,6 +10,10 @@ on missing requirements and recheck each conditional helper before use. # Super Review — PR/code readiness reviewer +> **Gitea boards:** when the active config sets `"forge": "gitea"`, every `gh` command in this +> skill is replaced by its `tea` equivalent in [gitea.md](../super-board/references/gitea.md); +> the board scripts (card.sh, merge-gate, filers, read wrappers) resolve the forge themselves. + **Super Review** is the super-board reviewer. It checks whether a branch or PR is safe to merge, records actionable findings, and routes fixes to the right Super workflow. Super Review should be conservative with claims: only say **merge-ready** when review evidence is clean and verification has passed. If evidence is missing, say what is unverified. From f240401be0244f8d527e776a14383c6ecefb9520 Mon Sep 17 00:00:00 2001 From: PhucMN <phucmnp@gmail.com> Date: Fri, 16 Oct 2026 18:11:00 +0700 Subject: [PATCH 8/8] =?UTF-8?q?=F0=9F=94=A7=20[chore]=20release:=203.2.0?= =?UTF-8?q?=20=E2=80=94=20gitea=20forge=20support?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - VERSION + skills/super-board/VERSION → 3.2.0 - RELEASE-NOTES: the forge adapter layer, gitea-read/api, projects-columns board, merge-gate pinning, onboard forge step, rate-limit honesty, offline tea stub + 10 new suites, Windows onboard repairs, gitea.md, minimum tea 0.16.x + projects-columns Gitea - evals/README: the stateful tea stub protocol (fixtures, tea-state.json, calls/writes logs) Co-Authored-By: Claude Code <noreply@anthropic.com> --- RELEASE-NOTES.md | 46 ++++++++++++++++++++++++++++++++++++++ VERSION | 2 +- evals/README.md | 10 +++++++++ skills/super-board/VERSION | 2 +- 4 files changed, 58 insertions(+), 2 deletions(-) diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md index 4091160f..1ff5d0b8 100644 --- a/RELEASE-NOTES.md +++ b/RELEASE-NOTES.md @@ -1,5 +1,51 @@ # Release notes +## v3.2.0 — 2026-10-16 + +A board can live on **Gitea**, not only GitHub: one config key (`"forge": "gitea"`) and the +whole pipeline — board, lanes, merge gate, collectors, onboard — runs against a Gitea/Forgejo +instance through the `tea` CLI. GitHub stays the default and is untouched. + +- ✨ **Forge adapter layer.** `super-board-forge.py/.sh` resolve the forge once (env `SB_FORGE` + → config `forge`/`forge_host`/`forge_login` → git remote → github) and dispatch reads/writes; + every script keeps its verbs, exit codes (79/73/69/67/64/66) and the one shared halt file. +- ✨ **`super-board-gitea-read.py`** — the bounded, read-only twin of github-read: same CLI, + retries, permanent-error halts and `--kind` shapes, with composite reads that normalize + Gitea REST into the github shapes (items/fields/quota/approval/diff…). Writes go through + `super-board-gitea-api.sh` (`tea api`, every spawn timeout-bounded — a hung tea.exe on + Windows fails instead of blocking a worker). +- ✨ **The board is a Gitea repo project.** The seven columns are project columns; + `project.number` is the project's API id. `card.sh` moves a card in one + `POST …/issues/{gid}/move` with the same cache and stale-id retry; onboard's + `board-rank`/`board-migrate` gained `--forge gitea` (additive columns/labels, Skipped→Done, + idempotent re-runs, snapshot first). +- ✨ **Merge gate on Gitea** squash-merges via `POST pulls/{i}/merge` pinned with + `head_commit_id` (the `--match-head-commit` analog); the lost-response reconciliation and + human-approval flow are unchanged. Approval trust fails closed: owner = admin, listed + collaborators = write, `Closes #N` trailers replace `closingIssuesReferences`. +- ✨ **Onboard asks the forge.** Step 2 becomes 🔑 FORGE: tea install/probe (a binary that + hangs counts as missing), host, token via `tea login add` or `GITEA_TOKEN`+`TEA_HOST`, and a + swagger capability gate on the projects-columns API before anything is written. +- ⚡ **Rate-limit honesty.** Gitea instances without limits report `rate_limits_disabled`; + the guard never sleeps on sentinels and the per-worker budget (exit 73) becomes the primary + protection; the throttle steps `max_workers` down only on real 429 evidence. +- 🧪 **Offline tea stub + suites.** `evals/_stubs/bin/tea` is a stateful offline Gitea + (fixtures → `.git/tea-state.json`, calls/writes logs, rate-limit headers); new suites + `test_forge.py`, `test-forge.sh`, `test_gitea_reads.py`, `test-gitea-api.sh`, + `test-card-gitea.sh`, `test-status-gitea.sh`, `test-setup-gitea.sh`, + `test-gh-guard-gitea.sh`, `test-pr-body-gitea.sh`, `test-deps-gitea.sh` plus gitea cases in + `test-throttle.sh` — all in `run-safety.sh`, no network. +- 🐛 **Windows onboard repairs.** `super-board-setup.py` resolves bash via `shutil.which` (a + broken WSL relay no longer shadows Git bash), and reads/writes child output as UTF-8 — + emoji-heavy install output crashed onboard on cp1252 consoles. +- 📝 **`references/gitea.md`** — the mapping table, a gh↔tea dictionary for every literal + command the skills quote, lane checklist and the accepted degradations (no GraphQL economy, + best-effort assignee claims, no draft-issue cards). Screenshot URLs: Gitea pins with + `/raw/commit/<sha>/` (writing-standard.md first, as always). +- Minimum versions: **tea 0.16.x** (`tea api` required; 1.0 renames commands — pinned + spellings live in gitea-read/gitea-api) and a Gitea new enough to serve the + projects-columns endpoints (onboard refuses older instances with a named fix). + ## v3.1.2 — 2026-10-11 `/super-collect` dedupes on the exact fingerprint and says when Sentry or PostHog is down. diff --git a/VERSION b/VERSION index ef538c28..944880fa 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -3.1.2 +3.2.0 diff --git a/evals/README.md b/evals/README.md index c52f6dff..395de09a 100644 --- a/evals/README.md +++ b/evals/README.md @@ -38,6 +38,16 @@ Offline regression tests for the same skill (no model, no cost) run in `tests/ru `issues.json`, `prs-merged.json`, `project-items.json`, `fields.json` and `graphql.json`. Writes are recorded, never sent: `issue create` bodies go to `.git/gh-created.md`, comments to `.git/gh-comments.md`, and every call to `.git/gh-calls.log` (plain text, for graders). +- `tea` — offline, STATEFUL. Serves the gitea twin of the gh stub for boards with + `"forge": "gitea"`: first call seeds `.git/tea-state.json` from `.git/tea-fixture/` + (`issues.json` `pulls.json` `labels.json` `projects.json` `columns.json` + `board.json` = [{column, numbers}] placements, `pull-<n>-files.json`, `pull-<n>.diff`, + `version.json`, `user.json`, `repo.json`, `no-ratelimit`, `ratelimit-remaining`), then + reads AND writes go through that state (create/comment/label/move/merge all mutate it, so + a grader can assert the final board). Calls log to `.git/tea-calls.log`, writes to + `.git/tea-writes.log`. Only `tea api` (+ `--version`, `login ls`) is implemented — the + gitea adapter never calls anything else. `{owner}/{repo}` placeholders expand from + `GITEA_REPO`, like the real CLI. - `py/sitecustomize.py` — offline Sentry and PostHog. `collect-seed.sh` puts it on `PYTHONPATH` with `SC_FIXTURES` pointing at a rendered copy of `tests/fixtures/collect/`, so the real `collect_sentry.py` / `collect_posthog.py` read canned payloads through diff --git a/skills/super-board/VERSION b/skills/super-board/VERSION index ef538c28..944880fa 100644 --- a/skills/super-board/VERSION +++ b/skills/super-board/VERSION @@ -1 +1 @@ -3.1.2 +3.2.0