fix(lint): make the Vale gate actually gate, drop VagueQualifier

Round-3 review of PR #85 found the "enforcing" pre-commit hook enforced
nothing. Vale's exit code keys on error-level alerts alone: five of the
six rules were level: warning, so they exited 0, and pre-commit hides
output from a passing hook — the alerts were invisible and blocked
nothing. ADR-0013 rejected a report-only trial tier and then shipped one
by accident.

Flatten every rule to level: error. Vale's own exit code is then correct,
so the hook entry drops to a bare vale-wrap.sh call and the graded
error->FAIL / warning->SUGGESTION mapping disappears from both audit
skills: every alert is a FAIL, in the gate and the audit alike. No
ignorable tier, matching shellcheck, the test suite and
conventional-pre-commit.

Delete Kyberforge.VagueQualifier. Measured against the 41 skill/agent
files as they stood before the rule ever ran: 2 hits. One marginal
("very different" -> "fundamentally different"), one an unfixable false
positive — caveman/SKILL.md quotes "of course" as an example of filler,
a mention not a use — which forced the only Vale suppression comments in
the repo. Those four lines go with it; two of them were dead anyway,
suppressing a frontmatter-scoped rule on a body line. Held-out prose (273
files) fired 15 times, 9 inside out-of-scope research examples and the
rest one word in two idioms in a single doc. SentenceOpenerThereIs
survives: 22 held-out hits, both in-corpus hits clean rewrites, zero
suppressions.

Widen .vale.ini's globs to [**/SKILL.md], [**/agents/*.md] and
[**/*.agent.md]. The plugins/*/-prefixed globs scoped nothing — Vale's *
crosses /, so they already matched docs/research/examples/**/agents/*.md
and assets/templates/SKILL.md, the two paths CONTEXT.md claimed they
excluded. Scoping is and was the hook's files: regex. The old globs also
hid a silent false negative: a skill outside plugins/ matched no section,
so Vale reported 0 files and exited 0, which both audits read as clean.
They now treat a 0-file run as NOT RUN and fall back to full judgment.

Also:
- vale-wrap.sh resolves relative --config values and file arguments
  against the caller's cwd, as vale does, instead of the repo root, which
  hard-errored from a subdirectory and silently skipped flattening for
  file args that did not resolve from the root. Absolute paths inside the
  cwd are relativized so reports cite resolvable paths, not scratch ones.
- vale-run's exit-code model was documented backwards ("exits non-zero
  whenever it finds an alert at or above MinAlertLevel") and would have
  led anyone following it to build a gate that passes everything. Its
  Markdown suppression syntax was MDX-only and does not suppress in .md;
  corrected in the skill and its troubleshooting reference, with
  backtick/fence exemption documented as the first resort.
- skill-size-check.sh fails only above 500 lines, agreeing with
  skill-audit's validate.sh <= 500 pass.
- ADR-0013 and CONTEXT.md amended to match, recording why graded
  severities cannot gate.

Verified: 9 test scripts / 15 vale-wrap cases pass; vale-audit-prefilter,
skill-size-check and shellcheck pass --all-files; check-manifests and
claude plugin validate --strict clean. New tests fail against the old
script (3 of them) and pass against the new one.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MCQ648fLSFXPHGZdQ8gn58

tests/test-skill-size-check.sh

@@ -83,31 +83,33 @@ make_line_fixture() {
   echo "$file"
 }
 
-# The line ceiling is exclusive of the limit itself ("stay under $MAX_LINES
-# lines", per skill-authoring.md), enforced via `>=` — so $((MAX_LINES - 1))
-# must pass and $MAX_LINES itself must already fail.
+# The line ceiling is inclusive of the limit itself, enforced via `>` — so
+# exactly $MAX_LINES must pass and $((MAX_LINES + 1)) must fail. This matches
+# skill-audit/scripts/validate.sh's `line_count <= 500` pass condition; the two
+# previously disagreed at exactly $MAX_LINES lines, so a SKILL.md could pass its
+# own audit and still be blocked by the commit hook.
 echo ""
-echo "--- passes a file at $((MAX_LINES - 1)) lines, just under the $MAX_LINES-line boundary ---"
-AT_LINES="$(make_line_fixture at-line-limit "$((MAX_LINES - 1))")"
+echo "--- passes a file at exactly the $MAX_LINES-line boundary ---"
+AT_LINES="$(make_line_fixture at-line-limit "$MAX_LINES")"
 ACTUAL_LINES=$(awk 'END{print NR}' "$AT_LINES")
-if [[ "$ACTUAL_LINES" -ne "$((MAX_LINES - 1))" ]]; then
-  fail "fixture has $ACTUAL_LINES lines, expected exactly $((MAX_LINES - 1))"
+if [[ "$ACTUAL_LINES" -ne "$MAX_LINES" ]]; then
+  fail "fixture has $ACTUAL_LINES lines, expected exactly $MAX_LINES"
 elif "$SCRIPT" "$AT_LINES"; then
-  pass "file at $((MAX_LINES - 1)) lines exits 0"
+  pass "file at exactly $MAX_LINES lines exits 0"
 else
-  fail "file at $((MAX_LINES - 1)) lines should have exited 0"
+  fail "file at exactly $MAX_LINES lines should have exited 0 (the off-by-one this test guards against)"
 fi
 
 echo ""
-echo "--- fails a file at exactly the $MAX_LINES-line boundary ---"
-OVER_LINES="$(make_line_fixture over-line-limit "$MAX_LINES")"
+echo "--- fails a file one line over the $MAX_LINES-line boundary ---"
+OVER_LINES="$(make_line_fixture over-line-limit "$((MAX_LINES + 1))")"
 ACTUAL_OVER_LINES=$(awk 'END{print NR}' "$OVER_LINES")
-if [[ "$ACTUAL_OVER_LINES" -ne "$MAX_LINES" ]]; then
-  fail "fixture has $ACTUAL_OVER_LINES lines, expected exactly $MAX_LINES"
+if [[ "$ACTUAL_OVER_LINES" -ne "$((MAX_LINES + 1))" ]]; then
+  fail "fixture has $ACTUAL_OVER_LINES lines, expected exactly $((MAX_LINES + 1))"
 elif "$SCRIPT" "$OVER_LINES" 2>/dev/null; then
-  fail "file at exactly $MAX_LINES lines should have exited non-zero (>= ceiling, the boundary bug this test guards against)"
+  fail "file at $((MAX_LINES + 1)) lines should have exited non-zero"
 else
-  pass "file at exactly $MAX_LINES lines exits non-zero"
+  pass "file at $((MAX_LINES + 1)) lines exits non-zero"
 fi
 
 # make_word_fixture builds a file with an exact total word count (frontmatter