task-pipeline-skill 1.78.4 → 1.80.0

package/evals/project-audit.evals.json

@@ -0,0 +1,108 @@
+{
+  "_note": "Behavioural evaluations for the project-audit skill. Same format and dimensions as task-pipeline.evals.json. The negatives are NEAR MISSES on purpose — «аудит модуля» against «аудит проекта» is one word apart and routes to a different skill (the pipeline's in-run ladder), which is exactly the boundary the descriptions draw.",
+  "skill": "project-audit",
+  "models": ["haiku", "sonnet", "opus"],
+  "evals": [
+    {
+      "id": "TRIG-01",
+      "category": "should_trigger",
+      "skills": ["project-audit"],
+      "query": "сделай аудит проекта — что реально готово, что наполовину, что сломано?",
+      "expected_behavior": [
+        "Invokes the project-audit skill, not the pipeline's in-run audit ladder",
+        "Starts with discovery (what the project IS) before choosing probes",
+        "Leaves the HTML report and the JSON sidecar; proposes board rows and commits nothing"
+      ],
+      "why": "«аудит проекта» is the declared trigger; the failure is running a fixed checklist or treating it as a change-task."
+    },
+    {
+      "id": "TRIG-02",
+      "category": "should_trigger",
+      "skills": ["project-audit"],
+      "query": "What is actually true of this project right now — what is finished, what is half-built, what has nobody looked at?",
+      "expected_behavior": [
+        "Invokes the project-audit skill — the subject is the whole project, not one change",
+        "Reads production evidence (published artefact vs source, CI history, telemetry presence), not only the working tree"
+      ],
+      "why": "The skill's own opening sentence as a user query; the failure is answering from the README."
+    },
+    {
+      "id": "TRIG-03",
+      "category": "should_trigger",
+      "skills": ["project-audit"],
+      "query": "Run a project health check on this repository and leave me the report",
+      "expected_behavior": [
+        "Invokes the project-audit skill",
+        "Blind probes are rendered as their own section with reasons — a probe that could not look is not a probe that found nothing"
+      ],
+      "why": "'project health check' is a declared trigger; the blind verdict is the design worth probing for."
+    },
+    {
+      "id": "NOTRIG-01",
+      "category": "should_not_trigger",
+      "skills": ["project-audit"],
+      "query": "сделай аудит модуля оплат",
+      "expected_behavior": [
+        "Routes to the pipeline's audit path (a finding that lands in the repository), not to project-audit",
+        "Does NOT start a cold whole-project discovery for a one-module question"
+      ],
+      "why": "Near miss by one word: «аудит проекта» is this skill, «аудит модуля» is one deliverable inside a run — the pipeline's own ladder."
+    },
+    {
+      "id": "NOTRIG-02",
+      "category": "should_not_trigger",
+      "skills": ["project-audit"],
+      "query": "Review PR #24 and tell me what is wrong with it",
+      "expected_behavior": [
+        "Routes to the pipeline's PR-review findings path or answers directly",
+        "Does NOT invoke project-audit — reviewing a diff is its declared Not-for"
+      ],
+      "why": "A diff has a change as its subject; project-audit's subject is the project."
+    },
+    {
+      "id": "NOTRIG-03",
+      "category": "should_not_trigger",
+      "skills": ["project-audit"],
+      "query": "проверь, соответствует ли этот скил стандарту Agent Skills",
+      "expected_behavior": [
+        "Routes to make-skill's audit (/skill-audit), not to project-audit",
+        "Does NOT run whole-project probes over a skill-construction question"
+      ],
+      "why": "The disambiguation table's own row: a skill's construction belongs to make-skill even when the word 'audit' appears."
+    },
+    {
+      "id": "AMB-01",
+      "category": "ambiguous",
+      "skills": ["project-audit"],
+      "query": "проверь проект",
+      "expected_behavior": [
+        "Names the route it is taking in one line — whole-project diagnosis (project-audit) versus a specific check the operator may mean",
+        "Does not silently start either the full audit or a random spot-check"
+      ],
+      "why": "Two words with no object; the observable is the named route, not the choice."
+    },
+    {
+      "id": "COEX-01",
+      "category": "coexistence",
+      "skills": ["project-audit", "task-pipeline"],
+      "query": "Audit the whole project, then fix the three worst things you find",
+      "expected_behavior": [
+        "project-audit produces the findings as proposed board rows, read-only",
+        "The fixes are carried by task-pipeline runs off those rows — the audit itself commits nothing"
+      ],
+      "why": "The seam the two skills share: diagnosis is read-only, delivery is the pipeline's; collapsing them makes the audit unrepeatable."
+    },
+    {
+      "id": "INSTR-01",
+      "category": "instruction_following",
+      "skills": ["project-audit"],
+      "query": "Audit this project",
+      "expected_behavior": [
+        "Discovery runs first and the probes are chosen from the profile, not from a fixed list",
+        "The three-verdict vocabulary is kept: clean, finding, blind — with blind reasons on the page",
+        "Findings leave priced with the board header's declared formula; effort never ranks"
+      ],
+      "why": "The procedure's own load-bearing steps, each of which a helpful shortcut would skip."
+    }
+  ]
+}

package/evals/run.py

@@ -17,12 +17,17 @@ What it does:
 
 Zero dependencies, same as the validator.
 """
+import glob
 import json
 import os
 import re
 import sys
 
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+# EVERY suite, discovered — the directory held one suite per skill from
+# 2026-08-31 (evidence-docs and project-audit joined task-pipeline), and a
+# runner pinned to one filename would validate a third of what ships.
+SUITES = sorted(glob.glob(os.path.join(ROOT, "evals", "*.evals.json")))
 SUITE = os.path.join(ROOT, "evals", "task-pipeline.evals.json")
 RESULTS = os.path.join(ROOT, "evals", "RESULTS.md")
 
@@ -34,14 +39,12 @@ REQUIRED = ("should_trigger", "should_not_trigger", "ambiguous",
 MIN_EVALS = 3          # Anthropic: "At least three evaluations created"
 
 
-def main(argv):
+def validate_suite(path):
+    """Every gap in one suite, in a stable order. The rules are the same for
+    every skill's suite — a second rule set would drift."""
     errors = []
-    if not os.path.isfile(SUITE):
-        print(f"FAIL: no suite at {os.path.relpath(SUITE, ROOT)}")
-        return 2
-    suite = json.load(open(SUITE, encoding="utf-8"))
+    suite = json.load(open(path, encoding="utf-8"))
     evals = suite.get("evals") or []
-
     seen = set()
     for e in evals:
         where = e.get("id", "<no id>")
@@ -68,6 +71,18 @@ def main(argv):
     for cat in REQUIRED:
         if cat not in covered:
             errors.append(f"no eval covers {cat!r}")
+    return suite, evals, errors
+
+
+def main(argv):
+    if not os.path.isfile(SUITE):
+        print(f"FAIL: no suite at {os.path.relpath(SUITE, ROOT)}")
+        return 2
+    parsed, errors = [], []
+    for _sp in SUITES:
+        _suite, _evals, _errs = validate_suite(_sp)
+        parsed.append((os.path.basename(_sp), _suite, _evals))
+        errors += [f"{os.path.basename(_sp)}: {e}" for e in _errs]
 
     if errors:
         print("FAIL: evaluation suite invalid")
@@ -75,31 +90,42 @@ def main(argv):
             print("  - " + e)
         return 1
 
+    suite = next(s for n, s, ev in parsed if n == "task-pipeline.evals.json")
+    evals = [e for _, _, ev in parsed for e in ev]
     by_cat = {}
     for e in evals:
         by_cat.setdefault(e["category"], []).append(e)
 
     if "--list" in argv:
-        for cat in REQUIRED:
-            for e in by_cat.get(cat, []):
-                print(f"  {e['id']:<10} {cat:<22} {e['query'][:60]}")
-        print(f"\n{len(evals)} evals across {len(by_cat)} categories")
+        for name, _s, ev in parsed:
+            print(f"{name} — {_s.get('skill', '?')}")
+            for cat in REQUIRED:
+                for e in ev:
+                    if e["category"] == cat:
+                        print(f"  {e['id']:<10} {cat:<22} {e['query'][:60]}")
+        print(f"\n{len(evals)} evals across {len(by_cat)} categories, "
+              f"{len(parsed)} suite(s)")
         return 0
 
     print("=" * 72)
-    print("task-pipeline evaluation protocol")
+    print("task-pipeline plugin evaluation protocol (one section per suite)")
     print("=" * 72)
-    print("Run each query in a FRESH session with the skill installed, once per")
+    print("Run each query in a FRESH session with the pack installed, once per")
     print("model in", suite.get("models", []), "— effectiveness varies by model.")
     print("Record every verdict in evals/RESULTS.md with the date and the model.")
     print("A query you did not run is not a pass; leave it blank and say so.\n")
-    for cat in REQUIRED:
-        print(f"\n--- {cat} ---")
-        for e in by_cat.get(cat, []):
-            print(f"\n[{e['id']}] {e['query']}")
-            print(f"    why: {e['why']}")
-            for b in e["expected_behavior"]:
-                print(f"    [ ] {b}")
+    for name, _s, ev in parsed:
+        print(f"\n=== {name} — {_s.get('skill', '?')} ===")
+        for cat in REQUIRED:
+            group = [e for e in ev if e["category"] == cat]
+            if not group:
+                continue
+            print(f"\n--- {cat} ---")
+            for e in group:
+                print(f"\n[{e['id']}] {e['query']}")
+                print(f"    why: {e['why']}")
+                for b in e["expected_behavior"]:
+                    print(f"    [ ] {b}")
 
     print("\n" + "=" * 72)
     if not os.path.isfile(RESULTS):
@@ -118,6 +144,8 @@ def main(argv):
         if not infence:
             outside.append(ln)
     runs = [l for l in outside if re.match(r"^## 20\d{2}-\d{2}-\d{2}\b", l)]
+    print("suites: " + " · ".join(f"{n.replace('.evals.json', '')} {len(ev)}"
+                                    for n, _s, ev in parsed))
     print(f"suite: {len(evals)} evals · recorded runs: {len(runs)}")
     if not runs:
         print("RESULTS.md carries no dated run — the suite is authored and unexecuted.")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.78.4",
+  "version": "1.80.0",
   "description": "Full-cycle delivery pipeline for coding agents: a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine ships inside the skill — no companion plugin required. This package is the installer CLI.",
   "bin": {
     "task-pipeline": "bin/task-pipeline.js"

package/plugins/task-pipeline/.claude-plugin/plugin.json

@@ -1,8 +1,9 @@
 {
+  "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "task-pipeline",
   "displayName": "Task Pipeline",
-  "description": "Runs a substantial task through a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine is built into the skill — no companion plugin required — with typed auto/manual gates, a frozen requirement spine that closes with evidence, a work board and a verification ledger that outlive a run, an exposure line naming what shipped unconfirmed, a progress rail computed from the project's own config, a loop guard whose review ceiling measures rather than stops, and stage-3 tracks for what a product does, how it sounds and how it looks. Two modes need no task: `checkup` (what is unverified) and `setup` (audit existing docs). Retro insights can publish upstream as issues, opt-in and redacted.",
-  "version": "1.78.4",
+  "description": "Runs a substantial task through a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine is built into the skill — no companion plugin required — with typed auto/judgment/manual gates, a frozen requirement spine that closes with evidence, a work board and a verification ledger that outlive a run, an exposure line naming what shipped unconfirmed, a progress rail computed from the project's own config, a loop guard whose review ceiling measures rather than stops, and stage-3 tracks for what a product does, how it sounds and how it looks. Two modes need no task: `checkup` (what is unverified) and `setup` (audit existing docs). Retro insights can publish upstream as issues, opt-in and redacted.",
+  "version": "1.80.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

package/plugins/task-pipeline/commands/task-pipeline.md

@@ -100,7 +100,8 @@ Anything deferred enters the carry-over ledger the moment it is said.
 | 9 | Docs + wiki | **three artifacts, not two** — module docs, the wiki, **and the code graph** |
 | 10 | Acceptance | the ladder walk first, then the table, then the retrospective |
 
-**Honor every gate by its type**: `auto` — verify the check yourself; `manual` — wait
+**Honor every gate by its type**: `auto` — verify the check yourself; `judgment` —
+record the named judge's ruling as judgement, never as a measurement; `manual` — wait
 for an explicit go.
 
 ## Cross-cutting — the three that fire at any stage

package/plugins/task-pipeline/hooks/build-gate.sh

@@ -64,7 +64,12 @@ def build_stage_id():
     try:
         cfg = json.load(open(os.path.join(project, "pipeline.json"), encoding="utf-8"))
         for s in cfg.get("stages") or []:
-            if isinstance(s, dict) and s.get("state") == "build":
+            # `build` OR `dev` — mirroring this hook's own ledger fallback
+            # (`build|dev`) below. Matching only `build` meant the shipped
+            # pipeline.example.json, whose build stage is `state: "dev"`, never
+            # armed this gate: the canonical config disarmed the hook it ships
+            # beside.
+            if isinstance(s, dict) and s.get("state") in ("build", "dev"):
                 return str(s.get("id"))
     except Exception:
         pass

package/plugins/task-pipeline/hooks/gate-observer.sh

@@ -49,40 +49,61 @@ try:
 except Exception:
     raise SystemExit(0)
 
-target = None
-for s in cfg.get("stages") or []:
-    if isinstance(s, dict) and (s.get("gate") or {}).get("command"):
-        target = (str(s.get("id")), (s.get("gate") or {})["command"].strip())
-        break
-if not target:
+# EVERY stage that declares a command, not the first. A first-match scan meant
+# a lint stage declared before the tests stage was the only one ever observed,
+# so the real suite's runs left no trace for the release gate to corroborate —
+# the same first-match break the release gate's own stage scan shipped with,
+# fixed together (sweep the class, not the instance).
+declared = [(str(s.get("id")), (s.get("gate") or {})["command"].strip())
+            for s in cfg.get("stages") or []
+            if isinstance(s, dict) and (s.get("gate") or {}).get("command")]
+if not declared:
     raise SystemExit(0)
 
-stage_id, declared = target
-
 # Compared on the normalised command line, not on a substring: `echo "npm test"`
 # and `npm test --watch` are not the project's gate, and treating them as one puts
 # a fabricated observation in the ledger the release gate trusts.
 def norm(s):
     return " ".join(s.split())
 
-if norm(cmd) != norm(declared):
+matches = [(sid, d) for sid, d in declared if norm(cmd) == norm(d)]
+if not matches:
     raise SystemExit(0)
 
 # PostToolUse fires on success; PostToolUseFailure carries the error. Both are
 # wired to this script, and `error` present means the command did not exit 0.
 failed = bool(data.get("error")) or data.get("hook_event_name") == "PostToolUseFailure"
-out = data.get("tool_output") or {}
-if isinstance(out, dict) and out.get("exit_code") is not None:
+# The harness documents the result field as `tool_response`; `tool_output` is the
+# name this script shipped reading, so it stays as a fallback rather than a
+# breaking change. Reading only the wrong name left the exit-code branch dead.
+# The fallback is BY FIELD, not by object: the real Bash `tool_response` is
+# {stdout, stderr, interrupted} with no exit_code, and `resp or legacy` made a
+# legacy exit_code unreachable behind it — found by the R-005 reader, measured,
+# before this shipped. The same reading found `interrupted`: a gate cut short
+# is not a gate that passed, whatever a stale exit_code says, so a failure
+# event or an interruption is never recorded as exit 0.
+out = {}
+interrupted = False
+for cand in (data.get("tool_response"), data.get("tool_output")):
+    if isinstance(cand, dict):
+        interrupted = interrupted or bool(cand.get("interrupted"))
+        if not out and cand.get("exit_code") is not None:
+            out = cand
+if out:
     code = int(out["exit_code"])
 else:
     code = 1 if failed else 0
+if (failed or interrupted) and code == 0:
+    code = 1
 
 stamp = datetime.datetime.now(datetime.timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
-line = 'gate:  %s — command "%s" — exit %d — %s\n' % (stage_id, norm(declared), code, stamp)
 
 # Append-only, like every other line in this file. A ledger that is rewritten is a
-# ledger whose history can be edited to say the suite passed.
+# ledger whose history can be edited to say the suite passed. One line per stage
+# that declared this exact command: two stages declaring the same command is two
+# observations, because each stage's gate is corroborated separately.
 with open(ledger, "a", encoding="utf-8") as fh:
-    fh.write(line)
+    for stage_id, decl in matches:
+        fh.write('gate:  %s — command "%s" — exit %d — %s\n' % (stage_id, norm(decl), code, stamp))
 PY
 exit 0

package/plugins/task-pipeline/hooks/release-gate.sh

@@ -54,13 +54,36 @@ decide() {
   # JSON from there. Watched failing — the gate allowed every release, silently,
   # because `sys.stdin.read()` came back empty and an empty payload is a skip.
   HOOK_INPUT="$input" python3 - "$ledger" "$project" <<'PY'
-import json, shlex, sys, os, re
+import datetime, json, shlex, sys, os, re
 
 ledger, project = sys.argv[1], sys.argv[2]
 raw = os.environ.get("HOOK_INPUT", "")
 try:
     data = json.loads(raw)
-except Exception:
+    if not isinstance(data, dict):
+        raise ValueError("payload is not a JSON object")
+except Exception as exc:
+    # An empty or unreadable payload is the gate NOT SEEING — it says nothing
+    # about whether a release is happening. With no run in flight that is
+    # nobody's business, so stay silent. With a run in flight, a silent skip
+    # here is the fail-open this hook exists to close: watched happening —
+    # `printf '' | release-gate.sh` exited 0 with no output, and the gate
+    # allowed every release for as long as its stdin plumbing was broken. A
+    # component that never receives its input is indistinguishable from
+    # approval, so it fails CLOSED, and the blindness is written into the
+    # ledger (append-only, the lifecycle grammar) so the run can see the gate
+    # went blind even after the refusal scrolls away.
+    if os.path.exists(ledger):
+        why = ("empty payload" if not raw.strip()
+               else "unparseable payload (%s)" % type(exc).__name__)
+        try:
+            stamp = (datetime.datetime.now(datetime.timezone.utc)
+                     .replace(microsecond=0).isoformat().replace("+00:00", "Z"))
+            with open(ledger, "a", encoding="utf-8") as fh:
+                fh.write("event: gate-blind — %s — %s\n" % (why, stamp))
+        except Exception:
+            pass  # recording failed; the block below still stands
+        print("blind\t%s" % why); raise SystemExit(0)
     print("skip"); raise SystemExit(0)
 
 cmd = ((data.get("tool_input") or {}).get("command") or "")
@@ -99,8 +122,22 @@ def outward(tokens):
                         return "git push <tag>"
         if t.endswith("gh") and rest[:2] == ["release", "create"]:
             return "gh release create"
-        if t.endswith("npm") and "publish" in rest:
-            return "npm publish"
+        if t.endswith("npm"):
+            # `publish` must be npm's SUBCOMMAND — the first non-flag token after
+            # npm. `"publish" in rest` matched anywhere in the argument list, so a
+            # project's own `npm run publish` script was gated as the registry
+            # act; fail-closed overmatch is still overmatch, and a gate that
+            # fights an ordinary script daily is a gate that gets removed. Known
+            # narrowness, stated rather than discovered: a flag whose value is a
+            # separate token (`npm --loglevel silent publish`) hides the
+            # subcommand from this scan; the `--flag=value` spelling is read
+            # correctly.
+            for a in rest:
+                if a.startswith("-"):
+                    continue
+                if a == "publish":
+                    return "npm publish"
+                break
     return None
 
 
@@ -122,16 +159,25 @@ stage_lines = [l.strip() for l in text.splitlines() if l.strip().startswith("sta
 
 
 def declared_test_stage():
-    """The tests stage, from the project's own flow. `(id, command)` or None."""
+    """The tests stage, from the project's own flow. `(id, command)` or None.
+
+    TWO PASSES, and the order is the fix. One pass took the first stage that was
+    declared `tests` OR merely carried a gate command — so a lint stage declared
+    before the tests stage became "the tests stage", and its green observation
+    released a tag with the suite never run. A stage the project DECLARED as
+    tests outranks any stage that happens to carry a command; the command-bearing
+    fallback remains for flows that declare no `tests` state at all."""
     try:
         cfg = json.load(open(os.path.join(project, "pipeline.json"), encoding="utf-8"))
     except Exception:
         return None
-    for s in cfg.get("stages") or []:
-        if not isinstance(s, dict):
-            continue
+    stages = [s for s in cfg.get("stages") or [] if isinstance(s, dict)]
+    for s in stages:
+        if s.get("state") == "tests":
+            return (str(s.get("id")), (s.get("gate") or {}).get("command"))
+    for s in stages:
         gate = s.get("gate") or {}
-        if s.get("state") == "tests" or gate.get("command"):
+        if gate.get("command"):
             return (str(s.get("id")), gate.get("command"))
     return None
 
@@ -207,6 +253,21 @@ why=$(printf '%s' "$verdict" | cut -f3)
 
 case "$state" in
   skip|ok) exit 0 ;;
+  blind)
+    # act holds the reason here — the payload never carried a command to name.
+    cat >&2 <<EOF
+task-pipeline: this project has a run in flight ($ledger) and the release gate
+received an unreadable hook payload ($act), so it cannot tell whether this
+command is an outward act. A gate that cannot see fails CLOSED — a blind gate
+that waves things through is indistinguishable from approval, and that is the
+exact shape it once shipped with.
+
+An \`event: gate-blind\` line was appended to the ledger. Check the hook wiring
+(stdin must carry the PreToolUse JSON), then re-run the command. To work without
+the pipeline, remove the ledger ($ledger) or say «без пайплайна» and take the
+route by hand.
+EOF
+    exit 2 ;;
   block)
     cat >&2 <<EOF
 task-pipeline: \`$act\` is an outward, irreversible act and the tests gate has not

package/plugins/task-pipeline/skills/evidence-docs/SKILL.md

@@ -24,6 +24,7 @@ The full statement of each canon, its rationale and its enforcement live in
 7. **Silence is not a pass** — ask what a mechanism prints when it did not look.
 8. **An estimate is never announced as a measurement** — a rule states its evidence condition.
 9. **What was not checked is printed beside what was.**
+   - **9a. A measured zero and an unmeasured quantity may not print the same** — canon 9 says carry the absence; 9a says refuse the number when nothing measured it.
 10. **The document ships in the change that made it true** — and a correction is appended, never written over.
 
 They are **epistemic**: what makes a claim documentation. The operational layer — what to
@@ -62,8 +63,38 @@ way to teach an agent to route around the rule where it actually protects someth
 pass through here: do it directly and **say out loud** that the claim is unbacked, rather
 than presenting an estimate as a measurement (canon 8).
 
+## Whom the canons serve
+
+**The operator's intent is the point. Evidence is how it survives contact with reality —
+not a licence to refuse it.**
+
+Everything above exists so the operator gets the result they actually wanted and nothing
+breaks quietly on the way. It does not exist to decide *what they are allowed to say*. A
+skill that reads canon 8 as "I may not write an unverified claim" and refuses the work has
+inverted its own purpose: it protected a rule and lost the person the rule was for.
+
+The line, and it is not the same line:
+
+| The operator may | The operator may not, and this is refusal ground |
+|---|---|
+| assert something not yet true — a landing page describing the product they are building, a roadmap, a pitch | make a **measurement** say something it did not: a test that passed, a benchmark, a count, a citation |
+| ship an unbacked claim knowingly, after being told once | have an estimate **presented as** a measurement (canon 8), which is the one thing no intent authorises |
+
+**So the sequence on an unproven claim is: say it once, label it, do the work.** Not a
+negotiation, not a second warning, and never a silent refusal dressed as a question. If
+the operator confirms they know, the claim ships with a marker naming it as forward-looking
+— that marker is the whole of what this skill owes here, and the task gets done.
+
+**Then do the harder half.** Following intent is the floor, not the service. The service is
+making that intent *better* — more structural, more predictable, easier to maintain and
+extend than the operator asked for — while still being the thing they asked for. An agent
+that only obeys is a slower keyboard.
+
 ## The one test
 
 Before a document ships, read it for the sentence that would embarrass you if someone
-asked *"how do you know?"* — and either give that sentence its address, or delete it.
-Everything above is that question, made mechanical.
+asked *"how do you know?"* — then do one of **three** things: give that sentence its
+address, delete it, or **mark it as an unbacked claim the operator chose to make and ship
+it**. The third option is not a loophole; it is the reason the other two are worth
+anything. A rule with no way to proceed under it becomes a rule people route around, and
+then nothing carries an address.

package/plugins/task-pipeline/skills/project-audit/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: project-audit
 description: "Use when someone asks what is actually true of a whole project right now — what is finished, what is half-built, what is broken, and what nobody has looked at. Walks a cold start: discover what the project is, run a registry of probes chosen from that, read production evidence (published artefact against source, CI history, telemetry present or absent), then leave a self-contained HTML report and a JSON sidecar so the next audit can say what moved. Read-only: it proposes board rows and commits nothing. Triggers - 'project audit', 'audit the project', 'codebase audit', 'state of the project', 'what is unfinished', 'project health check', 'аудит проекта', 'проаудируй проект', 'состояние проекта', 'что не доделано', 'аудит кодовой базы'. Not for: auditing one deliverable inside a run (that is the pipeline's own ladder), reviewing a diff, or checking a skill's construction — say 'без диагностики' to opt out."
+compatibility: "The collector (scripts/audit.py) needs python3 and reads committed state, so it needs git. Probes needing gh, npm, network or a browser declare it and report blind when it is absent — degraded, never silent."
 ---
 
 # Project audit — what is true of this project right now
@@ -33,6 +34,7 @@ next audit reads.
 | this skill | the **procedure** — cold start, probes, production, the report | a whole project is the subject |
 | `/skill-audit` (make-skill) | a skill's construction against the standard | the thing audited is a skill or plugin |
 | `/ux-audit` (super-ux) | code against documented scenarios | the question is user-facing behaviour |
+| `/seo-aeo-audit` (seo-aeo-audit) | a public surface's search and answer-engine visibility | the question is whether a machine will find it |
 
 **The method is not restated here.** Phase 4 below hands off to `audit.md` and
 comes back; a second copy of the ladder would be a second rule, and the two
@@ -96,8 +98,11 @@ the same object.
 ### 6. Propose — rows, not edits
 
 **This skill commits nothing.** Findings leave as board rows in the project's
-own vocabulary, priced with the project's own formula —
-`P = blast × (1 + age_runs) / effort` — and the operator accepts them. An audit
+own vocabulary, priced with **the board header's declared formula** — the shipped
+default is `Sev × Blast + age_bonus` (`references/backlog.md`, the pipeline's
+board doctrine) — and the operator accepts them. Effort never ranks inside an
+audit: what a fix costs is the fixer's decision, not the finder's
+(`references/prioritisation.md`). An audit
 that edits while it reads cannot be re-run to check itself.
 
 ## Three verdicts, and why the third one exists