task-pipeline-skill 1.79.1 → 1.80.0

package/plugins/task-pipeline/skills/task-pipeline/references/spec.md

@@ -13,6 +13,7 @@ Writing the approved design down so a zero-context implementer — human or suba
 
 - Order of operations
 - UX track (user-facing tasks only)
+- The COPY and VISUAL tracks, and their convergence
 - Write the spec
 - Module dossier — when the run is one brick of a platform
 - Self-review — before showing it
@@ -65,6 +66,60 @@ These skills are **idempotent** — extend the existing `docs/ux/` layers, never
 rebuild them. If the chain already exists and is validated (typically when the run
 entered from super-ux), verify it and embed it; build only what's missing.
 
+## The COPY and VISUAL tracks, and their convergence
+
+Three tracks, three questions, and they do not substitute for each other:
+super-ux decides what the interface must **do**; `copywriting` how it
+**sounds**; `sheleg-design` how it **looks**. Until 2026-08-10 stage 3 named
+only the first, so a run designed a flow, then wrote its strings by taste and
+picked its values at the keyboard — and every gate in the pipeline reported
+green over both.
+
+- **COPY track — how it sounds.** Every string a product's user will read is written
+  through super-ux's `copywriting`, against the brand pack (`docs/brand/voice.md`,
+  `terminology.md`, `facts.md`). No pack ⇒ `/brand-init` **before** the first string,
+  not after: a voice reverse-engineered from copy already written is a description of
+  what happened, not a decision. In scope: interface strings, errors, empty states,
+  the landing, pricing, the user-facing changelog. **Out of scope, and saying so is
+  what keeps the track honest:** commit messages, PR descriptions, code comments, a
+  developer README, internal docs. Running a brand pack over a line in a contributors'
+  changelog is the fastest way to teach an agent to route around the track.
+- **VISUAL track — how it looks.** Where the task has a visual surface, the visual
+  layer goes through `sheleg-design` ([`companion-skills.md`](companion-skills.md)):
+  tokens and themes, typography and rhythm, motion and how it degrades to rest, the
+  boundary with Figma (tokens as variables, never raw values carried across). Not
+  through it: a purely structural change — what sits where is the UX track's — text,
+  a backend, an internal script.
+- **Each track's refusal is a sentence, never a silence.** *"Без дизайна" / "as is"*
+  ends the visual track; *"без бренда" / "draft"* ends the copy track. Either one is
+  the operator's to make and costs nothing — but it is **recorded in the brief and
+  said out loud in the close-out**, because a track skipped silently and a track that
+  ran are the same thing in a transcript. This is the rail's `⊘` rule one layer up: a
+  skip nobody can see is indistinguishable from work that happened.
+- **Two of the three are a parallel layer, and the third is their only real dependency.**
+  COPY and VISUAL both consume the UX track's scenarios; **neither consumes the other**.
+  Copy is written against the brand pack and the scenarios, not against tokens; the visual
+  is built from the frame and the style pack, not from strings. Writing them in a line —
+  which this doctrine did until 2026-08-15 — teaches a run to wait for a result that never
+  arrives. The order is `UX → { COPY ∥ VISUAL }`, and the only thing crossing each of
+  those two arrows is **the scenario set**.
+- **Their convergence needs a check, and it has a real contradiction to catch.** Both land
+  on the same screen, so the failure is not that one is wrong: it is that each is right
+  alone and they disagree together. Before the spec is committed, compare the two outputs
+  and record the answer:
+  1. **A string the layout has no room for** — a label, an error or an empty state longer
+     than the frame's element, at the frame's own width.
+  2. **A state one track has and the other does not** — copy for an empty state the design
+     never drew, or a loading state drawn with no string.
+  3. **Two names for one thing** — the design system's component name against the
+     terminology file's noun, where a user reads both.
+  4. **A tone the visual contradicts** — a calm, plain register on a screen whose motion
+     and colour say urgency.
+  `Tracks converge: clean` is the answer most runs write, and writing it is the point —
+  a check whose silence is indistinguishable from not having run is not evidence. This is
+  the same rule the harvest applies at stage 0 and the build applies to a fanned-out group
+  at stage 5 ([`build.md`](build.md) §4.2a); one shape, three places.
+
 ## Write the spec
 
 Path: `<artifacts>/specs/YYYY-MM-DD-<topic>-design.md`, committed, **same
@@ -212,7 +267,11 @@ and every REQ in the brief appears in at least one section.** For UI tasks it
 additionally requires: the chain (foundation → flows → screens → scenarios)
 designed, validated and approved; `/ux-lint` green; every user-facing requirement
 traced to a scenario ID — or an explicit waiver from the operator recorded in the
-spec.
+spec. **Every user-facing string went through the COPY track or the refusal is
+recorded, the visual layer went through the VISUAL track or the refusal is
+recorded** — a recorded refusal passes and an unmentioned one does not — **and
+where both tracks ran, their convergence check is recorded**: findings with the
+ruling, or `Tracks converge: clean` (*The COPY and VISUAL tracks*, above).
 
 With Figma on, one more, and it is mechanical: **the canonical record names a file,
 and every frame link in `screens.md` carries that same file key.** Deep links are

package/plugins/task-pipeline/skills/task-pipeline/references/stages.md

@@ -2,7 +2,9 @@
 
 For each stage: what it does, what to invoke, artifacts, and the **GATE** that
 must pass before advancing. Each gate is tagged with its **type** — `auto` (the
-orchestrator verifies the check itself, pass/fail) or `manual` (wait for the
+orchestrator verifies the check itself, pass/fail), `judgment` (a named judge
+rules where no complete deterministic check exists — [`gates.md`](gates.md) →
+*The judgment gate*) or `manual` (wait for the
 operator's explicit go). These stages (0 intake + 1→10) are the plugin's
 **example** flow, encoded in `pipeline.example.json` against the universal contract
 `pipeline.schema.json`; a host project replaces it with its own
@@ -149,9 +151,10 @@ never that the work was skipped quietly.
 
   ```
   1. files the request names, resolved        git ls-files -- <paths>       -> N
-  2. any of them a public contract            the version-synced surfaces,
-                                              pipeline.schema.json, the
-                                              command, the README           -> yes/no
+  2. any of them a public contract            the surfaces the host's release
+                                              syncs, its schema or config
+                                              contracts, a shipped command,
+                                              its README                    -> yes/no
   3. behaviour a user or a caller observes changes                          -> yes/no
   ```
 
@@ -336,55 +339,18 @@ never that the work was skipped quietly.
   never rebuild from scratch. If the chain already exists and is validated (e.g.
   the task entered from super-ux), just verify (linter green) and embed it into
   the spec; only build the parts that are missing.
-- **COPY track — how it sounds.** Every string a product's user will read is written
-  through super-ux's `copywriting`, against the brand pack (`docs/brand/voice.md`,
-  `terminology.md`, `facts.md`). No pack ⇒ `/brand-init` **before** the first string,
-  not after: a voice reverse-engineered from copy already written is a description of
-  what happened, not a decision. In scope: interface strings, errors, empty states,
-  the landing, pricing, the user-facing changelog. **Out of scope, and saying so is
-  what keeps the track honest:** commit messages, PR descriptions, code comments, a
-  developer README, internal docs. Running a brand pack over a line in a contributors'
-  changelog is the fastest way to teach an agent to route around the track.
-- **VISUAL track — how it looks.** Where the task has a visual surface, the visual
-  layer goes through `sheleg-design` ([`companion-skills.md`](companion-skills.md)):
-  tokens and themes, typography and rhythm, motion and how it degrades to rest, the
-  boundary with Figma (tokens as variables, never raw values carried across). Not
-  through it: a purely structural change — what sits where is the UX track's — text,
-  a backend, an internal script.
-- **Each track's refusal is a sentence, never a silence.** *"Без дизайна" / "as is"*
-  ends the visual track; *"без бренда" / "draft"* ends the copy track. Either one is
-  the operator's to make and costs nothing — but it is **recorded in the brief and
-  said out loud in the close-out**, because a track skipped silently and a track that
-  ran are the same thing in a transcript. This is the `⊘` rule one layer up: a skip
-  nobody can see is indistinguishable from work that happened.
-- **Three tracks, three questions, and they do not substitute for each other.** super-ux
-  decides what the interface must **do**; `copywriting` how it **sounds**;
-  `sheleg-design` how it **looks**. Until 2026-08-10 this stage named only the first,
-  so a run designed a flow, then wrote its strings by taste and picked its values at the
-  keyboard — and every gate in the pipeline reported green over both.
-- **Two of the three are a parallel layer, and the third is their only real dependency.**
-  COPY and VISUAL both consume the UX track's scenarios; **neither consumes the other**.
-  Copy is written against the brand pack and the scenarios, not against tokens; the visual
-  is built from the frame and the style pack, not from strings. Writing them in a line —
-  which this file did until 2026-08-15 — teaches a run to wait for a result that never
-  arrives. The order is `UX → { COPY ∥ VISUAL }`, and the only thing crossing each of
-  those two arrows is **the scenario set**.
-- **Their convergence needs a check, and it has a real contradiction to catch.** Both land
-  on the same screen, so the failure is not that one is wrong: it is that each is right
-  alone and they disagree together. Before the spec is committed, compare the two outputs
-  and record the answer:
-  1. **A string the layout has no room for** — a label, an error or an empty state longer
-     than the frame's element, at the frame's own width.
-  2. **A state one track has and the other does not** — copy for an empty state the design
-     never drew, or a loading state drawn with no string.
-  3. **Two names for one thing** — the design system's component name against the
-     terminology file's noun, where a user reads both.
-  4. **A tone the visual contradicts** — a calm, plain register on a screen whose motion
-     and colour say urgency.
-  `Tracks converge: clean` is the answer most runs write, and writing it is the point —
-  a check whose silence is indistinguishable from not having run is not evidence. This is
-  the same rule the harvest applies at stage 0 and the build applies to a fanned-out group
-  at stage 5 ([`build.md`](build.md) §4.2a); one shape, three places.
+- **COPY track and VISUAL track — a parallel layer after UX, and their
+  convergence.** Three tracks, three questions, none substituting for another:
+  super-ux decides what the interface must **do**, `copywriting` how it
+  **sounds** (every string a product's user will read, against the brand pack),
+  `sheleg-design` how it **looks** (tokens, themes, typography, motion). COPY and
+  VISUAL are **parallel** — both consume the UX track's scenarios, neither
+  consumes the other — and where both ran, **their convergence check is run and
+  recorded before the spec is committed**: each can be right alone and the two
+  disagree together on one screen. The full doctrine — each track's scope and
+  out-of-scope, the refusal sentences, the four contradictions the check
+  catches — is [`spec.md`](spec.md) → *The COPY and VISUAL tracks, and their
+  convergence*, its one home.
 - **Spec:** write the approved design to
   `<artifacts>/specs/YYYY-MM-DD-<topic>-design.md` and commit it. Lock all
   shared contracts (types, schemas, signatures, file layout). For UI tasks the
@@ -468,6 +434,12 @@ never that the work was skipped quietly.
   implementer that wrote it is still dispatched. The matrix pointed this companion at
   stages 5–6 from the day it was added and **this stage had never named it** — found by
   the guard comparing the two, not by a reader.
+- **Domain companions, where the task is on their ground** — recommended, never a
+  gate ([`companion-skills.md`](companion-skills.md)): `sheleg-dev` when the build
+  wires money, tracking, sign-in or page speed; `agent-stack` when the thing being
+  built is an agent system; `telegram-dev` when Telegram is the platform rather
+  than the transport. Absent, the build ships on the host's own doctrine and the
+  close-out names the seam nobody checked.
 - **Integration closes the stage:** sync with the base branch, re-run the full suite
   on the result, land it the project's way (merge, or a PR — outward, so it needs a
   go), remove the worktree. Stages 7–9 act on the integrated result, so a branch the
@@ -493,7 +465,9 @@ never that the work was skipped quietly.
   same as stage 5.
 - **GATE (auto):** **the hygiene gate green over the whole tree**, its six counts
   printed beside their floors; the **full** suite is green (not just the new tests); new/changed code
-  is covered; no `skip`/`xfail` smuggling a red suite past the gate. Never advance
+  is covered; **every check this run added or widened has been probed both ways —
+  seen rejecting a planted defect and passing the clean tree, asserted on its exit
+  code** ([`probing.md`](probing.md)); no `skip`/`xfail` smuggling a red suite past the gate. Never advance
   to deploy on a red or partial run. **The carry-over count is printed beside this
   verdict** — a ratchet nobody prints is a TODO with a better name
   ([`audit.md`](audit.md)) — **and so are the disclosures**, `abstained` and
@@ -590,6 +564,10 @@ never that the work was skipped quietly.
   on anything but `success`, and one of the three states stated — including **`no run
   found`**, out loud, because a project without CI is a legitimate state and not a
   green one.
+- **A public surface a logged-out reader will see** can additionally be audited for
+  search and answer-engine visibility with `seo-aeo-audit`
+  ([`companion-skills.md`](companion-skills.md)) — recommended, never a gate;
+  absent, visibility ships unaudited and the close-out says so.
 - **GATE (auto):** clean boot confirmed, or an **honest degradation report** with next
   steps — never silent success. **The CI verdict is one of the reported facts, with
   its run id** — "CI is green" written without a command behind it prints the same

package/plugins/task-pipeline/skills/task-pipeline/references/work-graph.md

@@ -40,7 +40,7 @@ turn of every loop.
 | `nodes[].serves` | the REQ or goal clause it exists for. A node serving neither is **parked with that as the reason** |
 | `nodes[].blocked_by` | what must close first. This is what the frontier obeys |
 | `nodes[].touches` | what it **mutates**. Two runnable nodes writing one file is the false parallelism [`planning.md`](planning.md) refuses — *distinct is not the same as independent, and the check is what they touch, never what they are called* |
-| `nodes[].check` | **how this node will be closed** — one command, or the named judgement where no command can decide it. Required on every node except a `parked` one. `agents/verifier.md` runs it and reports its output as the evidence row; before this field existed that instruction pointed at an absence, leaving the verifier the two things it forbids — invent a check, or run everything (B-080) |
+| `nodes[].check` | **how this node will be closed** — one command, or the named judgement where no command can decide it. Required on every node except a `parked` one. The certification's `unit` tier runs it and reports its output as the evidence row ([`certification.md`](certification.md) — three blind tiers close a node, not one reader); before this field existed that instruction pointed at an absence, leaving a verifier the two things it forbids — invent a check, or run everything (B-080) |
 | `nodes[].evidence` | required when `status` is `done`. A node called done by assertion is what evidence exists to prevent |
 | `nodes[].parked_reason` | required when `status` is `parked`. A park with no reason is indistinguishable, a week later, from work quietly dropped |
 | `edges[].payload` | what the dependency hands over. **An edge carrying no named artifact is chronology drawn as architecture** |

package/plugins/task-pipeline/skills/task-pipeline/scripts/graph.py

@@ -549,8 +549,14 @@ SEVERITIES = ("breaks", "risk")
 # A tier report that quotes another tier's verdict was not written blind. Cheap
 # to detect and worth detecting: the failure it prevents is three reports that
 # agree because the second two read the first.
-CROSS_TIER = re.compile(r"\b(?:unit|seam|product)\s+tier\s+(?:passed|failed|says)"
-                        r"|\btier\s+\d\s+(?:passed|failed)"
+# The verb set was `passed|failed|says` and the R-005 reader measured five
+# citations sliding past it ("the seam tier confirmed…", "the unit tier said…",
+# "the unit tier's verdict…"). Widened to the tense and possessive forms the
+# reader planted; still a closed list on purpose — a looser net here starts
+# matching a report's honest prose about its OWN tier.
+CROSS_TIER = re.compile(r"\b(?:unit|seam|product)\s+tier(?:'s)?\s+"
+                        r"(?:passed|failed|says|said|confirm\w*|verdict|report)"
+                        r"|\btier\s+\d\s+(?:passed|failed|says|said|confirm\w*)"
                         r"|as\s+the\s+(?:unit|seam|product)\s+tier", re.I)
 
 
@@ -639,13 +645,30 @@ def tier_violations(t):
                        "— a fail that does not say what broke is a fail the next round "
                        "cannot act on" % t["tier"])
 
-    # Blind, and checked. Only the prose fields can carry it.
-    for k in ("confirms", "evidence", "not_examined"):
+    # Blind, and checked. EVERY prose field can carry it — the scan covered three
+    # of the six and a citation hiding in `scope` or a finding's `what`/`fix`
+    # passed untouched (certification.md claims the refusal for the whole report).
+    for k in ("confirms", "evidence", "not_examined", "scope"):
         for i, e in enumerate(t[k]):
             if isinstance(e, str) and CROSS_TIER.search(e):
                 out.append("tier report `%s[%d]` cites another tier's verdict (%r) — the "
                            "three run blind, because three reports that read each other "
                            "are one opinion with three signatures" % (k, i, e.strip()[:70]))
+    # Enumerated over the RAW list, so the index in this refusal and the index
+    # in the shape refusals above name the same object — the filtered list
+    # renumbered them (R-005 reader). `check` and `where` scan too: `check` is
+    # mandatory on every breaks finding, so it is the field a failing tier most
+    # reliably writes prose into.
+    for i, f in enumerate(t["findings"]):
+        if not isinstance(f, dict):
+            continue
+        for k in ("what", "fix", "check", "where"):
+            v = f.get(k)
+            if isinstance(v, str) and CROSS_TIER.search(v):
+                out.append("tier report `findings[%d].%s` cites another tier's verdict "
+                           "(%r) — the three run blind, because three reports that read "
+                           "each other are one opinion with three signatures"
+                           % (i, k, v.strip()[:70]))
     return out
 
 # --- verbs --------------------------------------------------------------------
@@ -1042,7 +1065,7 @@ def cmd_producer(graph, args):
 def cmd_doctrine(graph, args):
     """Which doctrine this run actually read — B-061.
 
-    The bundle is 37 reference files. A run reads some subset and nothing recorded which,
+    The bundle is 38 reference files. A run reads some subset and nothing recorded which,
     so **a skipped file and a read one were indistinguishable** — the class every guard in
     this repository exists to catch, left standing over the doctrine itself.
 

package/plugins/task-pipeline/skills/task-pipeline/templates/backlog.md

@@ -35,8 +35,12 @@
   `age_bonus` is `1` past 14 days and `2` past 30. The formula is repeated here on
   purpose — the inputs are in this table, so a reader checks the arithmetic rather than
   trusting the ranking. Full doctrine: the skill's `references/backlog.md`.
-- **State** — `open` · `in-flight` · `closed` · `dropped`. `dropped` needs the
-  operator's agreement and the date they gave it.
+- **State** — `open` · `in-flight` · `closed` · `dropped` · `parked — <branch or
+  commit>` · `waived — revisit: <condition>`. `dropped` needs the operator's
+  agreement and the date they gave it. `parked` claims work exists and must say
+  where — a branch or a commit, never a directory. `waived` is a decision, not
+  debt: it carries the condition that reopens it. Both long forms:
+  the skill's `references/backlog.md`.
 - **Home** — an issue id where a tracker exists, `—` where this file *is* the tracker.
 
 ## Closed

package/plugins/task-pipeline/skills/task-pipeline/templates/run.md

@@ -20,7 +20,7 @@ Run: `<topic>` · started `<YYYY-MM-DD>` · module map: `<path or "none">`
 
 ## `read:` — which doctrine this run actually opened
 
-The bundle is 37 reference files and nothing recorded which of them a run read, so **a
+The bundle is 38 reference files and nothing recorded which of them a run read, so **a
 skipped file and a read one were indistinguishable** — the class every guard in this
 pipeline exists to catch, left standing over the doctrine itself.
 
@@ -48,7 +48,7 @@ same claim one level down.
 |---|---|---|
 | `unmeasured — no run ledger` | there is no ledger | nothing to read from |
 | `unmeasured — the ledger carries no read: lines` | the hook is absent, **or** the run opened no doctrine | two opposite facts, and the ledger cannot separate them, so neither is claimed |
-| `N of 37 reference files read — unattested`, then each unread one | the hook is installed and fired | the count alone says there is a gap, not where — and `unattested` says the ledger cannot name who wrote the lines |
+| `N of 38 reference files read — unattested`, then each unread one | the hook is installed and fired | the count alone says there is a gap, not where — and `unattested` says the ledger cannot name who wrote the lines |
 
 **It is a disclosure: no floor, no direction, never a target.** A run that needs four files
 and reads four is not worse than one that reads thirty — and the moment the number becomes