task-pipeline-skill 1.38.0 → 1.40.0

package/CHANGELOG.md

@@ -1,5 +1,176 @@
 # Changelog
 
+## v1.40.0 — the loop had a cadence and no queue
+
+`run.loop` said how **often** to continue. It never said **what the next item is**, so an
+armed mode still left the run choosing its next move by recollection — `learned.md` rule
+16, once per fire. And nothing scheduled the next turn at all: on 2026-08-10 a run of
+this pipeline wrote *«продолжаю без остановки»* and the turn ended, because a sentence
+about future behaviour is not a wakeup. That run is this release's occasion and its
+evidence.
+
+### The queue is stage 2's
+
+The **module map** when the brief was a platform, the plan's task list otherwise. Both
+already existed, both were already ordered, and neither had ever been named as the thing
+the loop walks. `run.loop.queue` names it; `run.loop.arm` says where the mode is armed,
+and the default for a queue-bearing run is **after decomposition** — arming at preflight
+arms a loop with nothing to walk.
+
+Arming is a consequence, not a request, for the same reason the mode is recorded rather
+than asked for: a capability the operator must remember to switch on is one they forget
+on exactly the run that needed it.
+
+**What arming does not change is stated where it could be missed.** The four stops are
+the four stops; a `manual` gate still waits; an outward act still needs its own specific
+authorization. *A generic flag is not a specific authorization*, and arming a queue is
+the most generic flag there is — guarded, because that sentence is what the deploy floor
+rests on.
+
+### `mode: dynamic`
+
+`interval` was the only mode while a fixed tick was the only primitive. A harness that
+can schedule its own next turn picks each delay from what it is waiting for, and **prints
+the delay it chose** — the disclosure that replaces an interval run's job id. A run
+silent about its pacing cannot be told apart from one that quietly stopped, which is the
+claim this file already forbade for harnesses with no primitive at all.
+
+### The goal is re-read between items, not only the board
+
+Each iteration already re-measured the work-list, which answers *what is open*. It did
+not answer *whether the open thing still serves what this run was for*. A queue built at
+stage 2 outlives the reason it was built, because the operator learns things between
+items and says so. So the bottom of an iteration now quotes the goal, states whether the
+next item still serves it, and re-orders or re-scopes when it does not — a row that stops
+serving the goal leaves for the board with its reason.
+
+A queue re-derived only by `age` and `sev` is honest about priority and silent about
+purpose. Both numbers can be right while the run finishes something the operator stopped
+wanting two items ago.
+
+### The reader found the contradiction, not the bug
+
+R-005's reader defeated all five guards and then read the doctrine as a reader rather
+than its author. Part 1a said *"arming is a consequence, not a request"* and stated its
+trigger as a fact about the **work** — a queue with more than one item — with no
+antecedent about configuration. Two sections above, the same file says **Default off.
+Silence arms nothing, exactly as silence authorizes no deploy**, and `grill.md`'s deploy
+floor is explicitly said to rest on that distinction. Read cold, Part 1a arms a loop in a
+project with no `pipeline.json` at all.
+
+The contradiction was in the phrasing, not the intent — `stages.md` had already restated
+the rule with the antecedent intact. **Part 1a gave way**, and a guard now requires it to
+state its precondition, because five guards checked for the presence of strings and not
+one would have noticed either reading.
+
+What the reader took apart in the guards, all verified by planting the defect and
+watching `PASS`:
+
+- **a deleted contract was a skip, not a failure.** Removing the whole `run.loop` block
+  left CI green with two tidy `unlooked` lines — and `run` allows additional properties,
+  so the example still conformed while meaning nothing;
+- **`_loop_block` searched instead of addressing.** A deprecated top-level `loop` earlier
+  in file order answered for the real contract;
+- **presence tests let the release's own thesis be reverted.** `arm` existed, so setting
+  the example back to `preflight` passed;
+- **`if _qv and …` short-circuited itself** — an open string in place of the queue enum
+  passed, which is precisely the failure the guard was written for;
+- **the floor guard had never tested its own rule.** Its phrase entered the file in
+  v1.11.0, twenty-nine releases earlier; both doctrinal statements could be deleted and a
+  Rationalizations row kept it green;
+- **the dynamic-disclosure regex was content-blind** — a sentence keeping the words and
+  inverting the obligation passed — and it triggered off the prose word, so renaming the
+  mode switched the guard off;
+- **`arm the mode` matched a bullet forbidding arming**, and `"loop"` matched any
+  sentence about any loop. Both now key on the schema's own tokens.
+
+Guards 233 → **248**: seven more probes than the first pass shipped with, six of them for
+fail sites that did not exist until the reader's findings were fixed.
+
+### Also
+
+- **A guard was listing the legal modes instead of reading them.** Adding `dynamic`
+  failed the guard on a correct example — a check enforcing its own staleness. It now
+  reads the enum out of the schema.
+- Guards: 233 → **248**, one per new fail site, each with its planted defect.
+
+## v1.39.0 — the skill could not be reached by the word "audit"
+
+`references/audit.md` has said since v0.1.0 that an audit may be **the whole task** —
+stages 3–5 producing findings and fixes instead of a feature. No routing surface named
+it. Every trigger noun was build-shaped, and the exclusion clause read *"Not for:
+answering a question, explaining or reading code"* — which is the opening move of an
+audit, a bug hunt, a production check and a PR review alike.
+
+### Measured, not supposed
+
+Ten routing queries, one fresh agent each, holding nothing but the competing skill
+descriptions and one user sentence (`evals/routing/render.py`, results in
+`evals/routing/RESULTS.md`). **7 / 10 before.** The three misses were the three the board
+row predicted, and none of them was a failure to find a match — each agent **quoted this
+skill's own exclusion clause back as the reason it refused**:
+
+- «проверь, нет ли ошибок в обработчике вебхуков» → `none`
+- «проверь, всё ли живо в проде после вчерашнего релиза» → `none`
+- «посмотри PR #24 и скажи, что там не так» → `none`
+
+A fourth result only the reasoning shows: «сделай аудит модуля оплат» *did* route, and
+justified it by stretching the build verb `hardening`. A right answer resting on a
+stretch is one rewording from a miss.
+
+### The boundary is what a request ends in
+
+Not whether it reads. An answer stops in the conversation; a change **or a finding**
+lands in the tree, and the pipeline is what carries REQ rows, board rows and fixes
+there. The description, the portable routing rule and the Cursor rule now all say so,
+and `reading` is gone from the exclusions — guarded, so it cannot come back quietly.
+
+### Two things the harvest found before the first grill question
+
+- **`перевести` was locked into the verb list by the v1.9.0 design and never shipped.**
+  It existed in exactly one place in this repository: the design that locked it.
+- **`REQ-003` was accepted `verified` anyway.** The evidence recorded was the clause's
+  *shape* and its character count — neither of which can see a missing member of the
+  list the REQ locked. An L1→L2 absence that passed an L5 check. A guard now reads the
+  locked list out of that design and compares it to the shipped surface, so the next
+  dropped verb is a failure rather than a week.
+
+### The reader earned its standing instruction
+
+R-005 exists because an author's probes only exercise the shapes the author already
+thought of. Dispatched on the nine new guards, an independent reader defeated them
+**fifteen ways**, each verified by planting the text and watching the validator still
+print `PASS`. The three worth naming:
+
+- **A presence test over a whole file proves a word exists, not that the rule says it.**
+  The reader deleted the entire boundary clause from the Cursor rule, put the old
+  exclusion back, added one unrelated sentence elsewhere containing the same four class
+  names — and the guard passed. Both cross-surface checks are now scoped to the
+  `## Routing` section.
+- **A `should_not_trigger` control counted as coverage.** The eval-coverage guard joined
+  every query regardless of category, so deleting all four findings evals and mentioning
+  the words in one negative control certified *named and untested* — the exact state it
+  cites `B-046` for — as green. It now reads `should_trigger` queries only.
+- **The anti-dormancy sentinel was itself one synonym from dormant**, and the
+  locked-verb guard read a regex out of a document this repo forbids maintaining, so
+  relabelling one heading in a superseded design would have silenced the check that
+  exists because a verb was silently dropped. Both now fail loudly instead.
+
+Nine of the fifteen were in checks written that same hour. The tenth fail site had no
+probe at all — ten branches, nine tests — which is the invariant the repository states
+about itself and did not keep.
+
+### Also
+
+- **False-positive controls, because widening a vocabulary can steal work.** Three
+  competitors already claim the word *audit* — `seo-aeo-audit`, `ux-audit`,
+  `make-skill`. All three are eval cases now, and all three still won their query.
+- **R-003 sweep** turned up the same word-map ceiling that produced R-006, in the
+  redaction-rule count: past ten it compared against the digit alone. It now accepts
+  either form and names both when it fails.
+- Guards: 218 → **233**; eval cases 21 → **28**; description 956 → 1004 of 1024, paid for
+  by cutting mechanism prose that could not affect routing.
+
 ## v1.38.0 — the wall came down, and a green started meaning something
 
 An audit of this skill measured nineteen problems and asked one question of all of them:

package/CONTRIBUTING.md

@@ -191,7 +191,7 @@ reads those files, and a partial read shows whichever sections come first.
 `run` block in `pipeline.schema.json` carries the loop mode; the shipped example
 sets `run.loop.mode` explicitly rather than omitting it, because the example is
 what gets copied and an absent field reads as an oversight instead of a decision.
-*(guard: `no explicit run.loop.mode`)*
+*(guard: `run.loop.mode is` … `and the schema's legal set is`)*
 
 **25. The run-wide mode is named by every stage that could be misled by it.**
 `SKILL.md`, `references/grill.md`, `references/build.md`, `references/stages.md`

package/SKILL-CARD.md

@@ -12,7 +12,7 @@ harmless.
 |---|---|
 | **Purpose** | Runs a substantial task through ten gated delivery stages — intake grill, docs study, brainstorm, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs+registers, acceptance — refusing to advance until each gate passes |
 | **Owner** | ssheleg ([github.com/ssheleg/task-pipeline](https://github.com/ssheleg/task-pipeline)) |
-| **Version** | 1.38.0 |
+| **Version** | 1.40.0 |
 | **Surface** | Claude Code (filesystem skill + plugin) and the vercel `skills` CLI. **Not** uploaded to the Skills API; custom Skills do not sync across surfaces |
 | **Dependencies** | None required. Optional: `context7` (MCP), `figma` (MCP), super-ux, agent-sync, graphify, obsidian-wiki. Every stage's doctrine ships in-repo; the one conditional requirement is super-ux for the stage-3 UX track on a user-facing task |
 | **Evaluation status** | Suite authored, 5 categories. One recorded run, **self-observed by the author**; **zero blind runs on zero of three models** — the split, and the numbers, live in [`evals/RESULTS.md`](evals/RESULTS.md) and are computed by `evals/run.py` |

package/cursor/rules/task-pipeline.mdc

@@ -605,11 +605,17 @@ track that ran look identical afterwards.
 
 ## Routing — when this applies at all
 
-**Work that CHANGES THE REPOSITORY goes through the pipeline** — a feature, fix,
-refactor, migration, integration, rewrite, adoption or hardening pass, in any
-phrasing. **Not** for a question, an explanation, reading code, a typo or a one-line
-edit. The operator opts out of a qualifying task by saying "без пайплайна" or
-"quick"; when they do, say out loud that the cycle was skipped at their request.
+**Work that LANDS IN THE REPOSITORY goes through the pipeline**, in two shapes: a
+**change** — a feature, fix, refactor, migration, integration, rewrite, adoption or
+hardening pass — and a **finding that lands** — an audit, a bug hunt, a production
+check, a PR review, whose output is REQ rows, board rows and fixes rather than an
+answer in the chat. In any phrasing.
+
+**Not** for a question, an explanation, mapping code for a person to read, a typo or a
+one-line edit. **Reading is not the test**: an audit, a bug hunt and a PR review all
+begin by reading and all three end in the tree. The operator opts out of a qualifying
+task by saying "без пайплайна" or "quick"; when they do, say out loud that the cycle
+was skipped at their request.
 
 A borderline case is named, not silently chosen: state which route you are taking and
 why, in one line.

package/evals/routing/RESULTS.md

@@ -0,0 +1,79 @@
+# Routing measurement — results
+
+Method: `evals/routing/render.py`. Ten queries, **one fresh agent per query**, holding
+nothing but the competing skill descriptions and one user sentence.
+
+> **Limits, stated before the numbers.** This measures the **descriptions'**
+> discriminating power, not Claude Code's selection machinery, which sees more than a
+> description. A subagent is fresh in *context*, not blind in *disposition* — this is
+> **not** the multi-model blind run board row `B-002` asks for and no line here may be
+> quoted as one. And see §3: **one sample per cell is too few**, which this measurement
+> found out about itself by being run twice.
+
+## 1. The three runs
+
+| id | query | expected | **A** before | **B** after | **C** after + prod pair |
+|---|---|---|---|---|---|
+| AUD-01 | сделай аудит модуля оплат | task-pipeline | ✓ *(stretch)* | ✓ | ✓ |
+| BUG-01 | проверь, нет ли ошибок в обработчике вебхуков | task-pipeline | **none** | ✓ | ✓ |
+| PRD-01 | проверь, всё ли живо в проде после вчерашнего релиза | task-pipeline | **none** | **none** | **none** |
+| PRR-01 | посмотри PR #24 и скажи, что там не так | task-pipeline | **none** | ✓ | ✓ |
+| FEA-01 | добавь экспорт в CSV на страницу отчётов | task-pipeline | ✓ | ✓ | **none** |
+| QST-01 | объясни, как наш auth middleware решает… | none | ✓ | ✓ | ✓ |
+| TYP-01 | поправь опечатку в заголовке README | none | ✓ | ✓ | ✓ |
+| SEO-01 | сделай аудит лендинга — почему упал трафик | seo-aeo-audit | ✓ | ✓ | ✓ |
+| UXA-01 | проверь, что код соответствует UX-сценариям | ux-audit | ✓ | ✓ | ✓ |
+| SKL-01 | проверь, соответствует ли этот скил стандарту | make-skill | ✓ | ✓ | ✓ |
+| | | | **7 / 10** | **9 / 10** | **8 / 10** |
+
+- **A** — `9f67dcd`, description 956/1024, before any edit.
+- **B** — the findings clause added, description 1004/1024.
+- **C** — `production check` given its Russian pair, description 1008/1024.
+
+## 2. What is robust, and what is one sample
+
+**Robust — the same result in both after-runs, for the stated reason:**
+
+- **BUG-01 and PRR-01: `none` → `task-pipeline`, 2/2.** In A both agents *quoted this
+  skill's own exclusion clause* as the reason they refused — *"matching task-pipeline's
+  own exclusion 'Not for: … explaining or reading code'"*, *"task-pipeline's is scoped to
+  'work changes the repository', not 'explaining or reading code'"*. In B and C both
+  quote the new clause instead. The mechanism named in the refusal is the mechanism the
+  change removed.
+- **AUD-01's *reason* changed, 2/2.** It routed in A too — by stretching the build verb
+  `hardening`, with nothing in the description naming an audit. In B and C it quotes
+  `audit/аудит`. The answer did not move; the ground under it did.
+- **PRD-01 never routed: 0/2 after.** Adding `/проверь прод` did not fix it. In C the
+  agent said the request has *"no repository change and no matching trigger"* and
+  reached for `checkup` before rejecting it. The production-check class is **named and
+  still unreachable** — the vocabulary was necessary and is not sufficient.
+
+**One sample, and therefore not a result:**
+
+- **FEA-01 flipped to `none` in C** on reasoning that does not parse — *"no such change
+  applies here because none of the listed skills is task-pipeline's own trigger"*. This
+  is a control that passed in A and B with the same description clause C did not touch.
+  Read as run-to-run variance, **not** as a regression caused by the edit — and the
+  measurement as built cannot prove that reading, which is the point of §3.
+
+## 3. The measurement's own defect, found by running it twice
+
+**One agent per query cannot separate an effect from noise.** Three runs produced three
+totals — 7, 9, 8 — and one of the moves between them (FEA-01) is almost certainly the
+sampler, not the surface. Had the run stopped at B, this file would have reported
+**9/10 and a clean win**, and the claim would have rested on single samples exactly like
+the one that flipped.
+
+What a next version needs, in order of value:
+
+1. **N ≥ 3 per cell, majority-scored**, so a flip is visible as a split rather than a
+   result. Cost scales linearly and the queries are tiny.
+2. **The controls scored separately from the targets.** A false-positive control that
+   flips is a different fact from a target that does not move.
+3. **The reason recorded, not only the answer.** Every real finding in this file came
+   from *why* an agent chose, not from what it chose — AUD-01 passed in A for a reason
+   that was one rewording from failing.
+
+Filed as a board row rather than fixed here: the run that needed the harness is the run
+that found the harness too thin, and rebuilding it mid-run would leave the before-numbers
+measured by a different instrument than the after-numbers.

package/evals/routing/render.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Render the routing-measurement prompt for one query.
+
+The measurement asks a fresh agent, holding nothing but competing skill
+descriptions and one user sentence, which skill it would use. Run before a
+description change and after it; the only thing that may differ between the two
+runs is the text of the descriptions themselves — this file renders everything
+else identically, which is the whole reason it is a file and not a paste.
+
+    python3 evals/routing/render.py <query-id>      # prompt to stdout
+    python3 evals/routing/render.py --list          # the queries and expectations
+
+Honest limits, stated here because a reader of the results will not see them:
+  * this measures the DESCRIPTIONS' discriminating power, not Claude Code's own
+    selection machinery, which sees more than a description;
+  * a subagent carries its host's system prompt, so it is fresh in CONTEXT, not
+    in disposition — this is not the blind multi-model run board row B-002 asks
+    for, and no result here may be quoted as one.
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# task-pipeline's description is read from the WORKING TREE, so the after-run
+# picks up the edit; the competitors are read from the installed plugins, so an
+# unrelated release of theirs cannot silently move the baseline between runs.
+SELF = os.path.join(ROOT, "plugins/task-pipeline/skills/task-pipeline/SKILL.md")
+MARKETPLACES = os.path.expanduser("~/.claude/plugins/marketplaces")
+COMPETITORS = ["super-ux", "sheleg-design", "make-skill", "agent-sync", "seo-aeo-audit"]
+
+QUERIES = [
+    # id,           the sentence,                                            what should win, why it is here
+    ("AUD-01", "сделай аудит модуля оплат", "task-pipeline",
+     "findings on code — audit.md:350 says an audit may be the whole task"),
+    ("BUG-01", "проверь, нет ли ошибок в обработчике вебхуков", "task-pipeline",
+     "bug hunt — findings that land in the repo"),
+    ("PRD-01", "проверь, всё ли живо в проде после вчерашнего релиза", "task-pipeline",
+     "production check"),
+    ("PRR-01", "посмотри PR #24 и скажи, что там не так", "task-pipeline",
+     "PR review — review.md owns the reader contract"),
+    ("FEA-01", "добавь экспорт в CSV на страницу отчётов", "task-pipeline",
+     "CONTROL+ — build work already routes; must not regress"),
+    ("QST-01", "объясни, как наш auth middleware решает, какие роуты публичные", "none",
+     "CONTROL− — a question; the exclusion must survive the rewording"),
+    ("TYP-01", "поправь опечатку в заголовке README", "none",
+     "CONTROL− — a one-line edit; the exclusion must survive"),
+    ("SEO-01", "сделай аудит лендинга — почему упал трафик из поиска", "seo-aeo-audit",
+     "FALSE-POSITIVE test — 'аудит' must not be stolen from its owner"),
+    ("UXA-01", "проверь, что код соответствует UX-сценариям", "ux-audit",
+     "FALSE-POSITIVE test — the scenario audit has an owner"),
+    ("SKL-01", "проверь, соответствует ли этот скил стандарту", "make-skill",
+     "FALSE-POSITIVE test — skill-shaped audit has an owner"),
+]
+
+
+def _desc(path):
+    """The description as the platform reads it: the frontmatter field, unwrapped."""
+    t = open(path, encoding="utf-8").read()
+    n = re.search(r"^name:\s*(.+)$", t, re.M)
+    d = re.search(r"^description:\s*(.+?)(?=^[a-z_-]+:\s|^---)", t, re.M | re.S)
+    if not (n and d):
+        return None
+    return n.group(1).strip(), " ".join(d.group(1).split()).strip("\"' ")
+
+
+def choices():
+    out = []
+    s = _desc(SELF)
+    if s:
+        out.append(s)
+    for m in COMPETITORS:
+        base = os.path.join(MARKETPLACES, m)
+        if not os.path.isdir(base):
+            continue
+        found = subprocess.run(["find", base, "-name", "SKILL.md"],
+                               capture_output=True, text=True).stdout.split()
+        for f in sorted(found):
+            got = _desc(f)
+            if got and got[0] not in {o[0] for o in out}:
+                out.append(got)
+    return out
+
+
+PROMPT = """You are choosing which skill, if any, to invoke for one user request.
+
+Below are the skills available, each with the description its author wrote. You have
+nothing else — no repository, no history, no knowledge of these tools beyond what is
+written here.
+
+{catalogue}
+
+The user says:
+
+    {query}
+
+Answer with exactly two lines and nothing else:
+
+SKILL: <the skill name, or the word none>
+WHY: <one sentence, quoting the phrase in the description that decided it>
+"""
+
+
+def main():
+    if "--list" in sys.argv:
+        for qid, q, exp, why in QUERIES:
+            print(f"{qid:<8}{exp:<16}{q}\n{'':8}{'':16}# {why}")
+        return 0
+    if "--choices" in sys.argv:
+        for name, d in choices():
+            print(f"{name:<18}{len(d):>5} chars")
+        return 0
+    if len(sys.argv) < 2:
+        print(__doc__)
+        return 2
+    qid = sys.argv[1]
+    row = next((r for r in QUERIES if r[0] == qid), None)
+    if row is None:
+        print(f"unknown query id {qid}; --list to see them", file=sys.stderr)
+        return 2
+    cat = "\n".join(f"- **{name}** — {d}" for name, d in choices())
+    print(PROMPT.format(catalogue=cat, query=row[1]))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/evals/task-pipeline.evals.json

@@ -307,6 +307,92 @@
         "Does NOT invoke task-pipeline, does not open a grill and does not write a brief"
       ],
       "why": "Answering a question is on the skill's own not-for list. The description carries that boundary and nothing has ever measured whether a model honours it."
+    },
+    {
+      "id": "TRIG-07",
+      "category": "should_trigger",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "сделай аудит модуля оплат",
+      "expected_behavior": [
+        "Invokes the skill: the output is a finding that lands in the repository, which the description names",
+        "Runs audit.md's L0->L7 ladder as the whole task — stages 3-5 produce findings and fixes rather than a feature",
+        "Does NOT justify the routing by stretching a build verb such as 'hardening'"
+      ],
+      "why": "Measured 2026-08-10: before the findings clause this routed, but its stated reason was the build-verb list. A right answer resting on a stretch is one rewording from a miss."
+    },
+    {
+      "id": "TRIG-08",
+      "category": "should_trigger",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "проверь, нет ли ошибок в обработчике вебхуков",
+      "expected_behavior": [
+        "Invokes the skill rather than answering in the chat",
+        "Findings become REQ or board rows with file:line and a minimal fix, ordered by seam"
+      ],
+      "why": "Measured before the change: answered `none`, quoting the exclusion clause 'explaining or reading code'. Reading is the opening move, not the boundary."
+    },
+    {
+      "id": "TRIG-09",
+      "category": "should_trigger",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "проверь, всё ли живо в проде после вчерашнего релиза",
+      "expected_behavior": [
+        "Invokes the skill; the verification trio, not one of three",
+        "Reads the CI run and the platform's own log command rather than assuming a verdict"
+      ],
+      "why": "Measured before the change: answered `none` on the same exclusion. A production check ends in a verification row, which lands."
+    },
+    {
+      "id": "TRIG-10",
+      "category": "should_trigger",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "посмотри PR #24 и скажи, что там не так",
+      "expected_behavior": [
+        "Invokes the skill and applies review.md's reviewer contract, including the three reader states",
+        "Prints NO READER rather than staying silent when no independent reader is available"
+      ],
+      "why": "Measured before the change: answered `none` because no description offered a phrase for reviewing a PR, while review.md owns exactly that contract."
+    },
+    {
+      "id": "NOTRIG-06",
+      "category": "should_not_trigger",
+      "skills": [],
+      "query": "сделай аудит лендинга — почему упал трафик из поиска",
+      "expected_behavior": [
+        "Routes to seo-aeo-audit, whose description names 'почему упал трафик' verbatim",
+        "The widened findings vocabulary does not claim an audit that has an owner"
+      ],
+      "why": "False-positive control. Widening 'audit' must not steal work: gates.md sets the false-positive budget at zero."
+    },
+    {
+      "id": "NOTRIG-07",
+      "category": "should_not_trigger",
+      "skills": [],
+      "query": "проверь, что код соответствует UX-сценариям",
+      "expected_behavior": [
+        "Routes to ux-audit, which owns the scenario audit",
+        "The findings vocabulary in task-pipeline's description does not override an owner that names the surface exactly"
+      ],
+      "why": "False-positive control against the second competing claim on the word audit."
+    },
+    {
+      "id": "NOTRIG-08",
+      "category": "should_not_trigger",
+      "skills": [],
+      "query": "проверь, соответствует ли этот скил стандарту",
+      "expected_behavior": [
+        "Routes to make-skill, which owns skill-shaped audits",
+        "The findings vocabulary in task-pipeline's description does not override an owner that names the artefact exactly"
+      ],
+      "why": "False-positive control against the third competing claim on the word audit."
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.38.0",
+  "version": "1.40.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

@@ -2,7 +2,7 @@
   "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.38.0",
+  "version": "1.40.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

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

@@ -1,6 +1,6 @@
 ---
 name: task-pipeline
-description: "Runs a substantial task through a full delivery pipeline: an intake grill that expands the request into a locked brief, then docs study, brainstorm, spec, plan, subagent build, tests, lint/deploy, post-deploy check, docs/wiki sync and acceptance — gated stages whose doctrine ships inside this skill (no required companions). Use when work changes the repository — a feature, fix, refactor, migration, integration, rewrite, adoption or hardening; фича, фикс, рефактор, миграция, интеграция, доработать, починить, внедрить — or on 'run this through the pipeline' / 'прогони по конвейеру', 'the full cycle' / 'полный цикл', /task-pipeline. Two modes need no task at all: 'checkup' / 'чекап' reports what has shipped without a person confirming it and what to look at first; 'setup' audits the documentation a project already has. Not for: answering a question, explaining or reading code, a typo or a one-line edit — say 'без пайплайна' / 'quick' to opt out."
+description: "Runs a substantial task through a full delivery pipeline: an intake grill that locks the request into a brief, then docs study, brainstorm, spec, plan, subagent build, tests, lint/deploy, post-deploy check, docs/wiki sync and acceptance. Use when work changes the repository — a feature, fix, refactor, migration, integration, rewrite, adoption or hardening; фича, фикс, рефактор, миграция, интеграция, доработать, починить, внедрить, перевести — or when the output is a finding that lands in it: audit/аудит, bug hunt/проверь ошибки, production check/проверь прод, PR review/ревью PR — or on 'run this through the pipeline' / 'прогони по конвейеру', 'the full cycle' / 'полный цикл', /task-pipeline. Two modes need no task at all: 'checkup' / 'чекап' reports what has shipped without a person confirming it and what to look at first; 'setup' audits the documentation a project already has. Not for: answering a question, explaining code, a typo or a one-line edit — say 'без пайплайна' / 'quick' to opt out."
 license: MIT
 ---
 

package/plugins/task-pipeline/skills/task-pipeline/pipeline.example.json

@@ -46,7 +46,7 @@
       ],
       "gate": {
         "type": "manual",
-        "check": "the user approves the design AND the UI verdict is recorded (does the task touch a user-facing surface — web/mobile/CLI/TUI? this arms the stage-3 UX track). Every REQ is answered by the design, or explicitly dropped by the operator into the carry-over ledger. For a platform (several independent capabilities or shippable surfaces): the module map specs/<topic>-modules.md is committed and approved — brick criteria met or excepted in writing, dependency graph acyclic, build order topological with the walking skeleton first, every REQ mapped to exactly one module, cross-module contracts named with their owner. Single-module work records 'single module: <name>' instead — a skipped decomposition is a recorded decision, never an omission"
+        "check": "the user approves the design AND the UI verdict is recorded (does the task touch a user-facing surface — web/mobile/CLI/TUI? this arms the stage-3 UX track). Every REQ is answered by the design, or explicitly dropped by the operator into the carry-over ledger. For a platform (several independent capabilities or shippable surfaces): the module map specs/<topic>-modules.md is committed and approved — brick criteria met or excepted in writing, dependency graph acyclic, build order topological with the walking skeleton first, every REQ mapped to exactly one module, cross-module contracts named with their owner. Single-module work records 'single module: <name>' instead — a skipped decomposition is a recorded decision, never an omission. THE LOOP'S ARMING STATE IS PRINTED — armed with its queue and pacing, or not armed with the reason; the queue exists at this stage and a loop armed earlier has nothing to walk."
       }
     },
     {
@@ -172,7 +172,12 @@
   ],
   "_run_note": "Run-wide pacing. Shipped explicitly OFF so this example DEMONSTRATES the default rather than relying on its absence — see references/continuity.md. Set mode to 'interval' and a project stops being asked whether to run item-by-item; it still stops at every manual gate. There is no context-budget field here on purpose: the threshold is not measurable, so it is unconditional doctrine, not config.",
   "run": {
-    "loop": { "mode": "off", "interval": "5m", "command": "/loop" }
+    "loop": {
+      "mode": "dynamic",
+      "queue": "module-map",
+      "arm": "after-decomposition",
+      "command": "/loop"
+    }
   },
   "release": {
     "enabled": true,

package/plugins/task-pipeline/skills/task-pipeline/pipeline.schema.json

@@ -48,18 +48,34 @@
             "mode": {
               "enum": [
                 "off",
-                "interval"
+                "interval",
+                "dynamic"
               ],
-              "description": "off (the default when absent) = the run pauses between items as it always did. interval = the run is armed with the harness's own loop primitive and advances one item per fire, stopping only at a manual gate, an unresolvable block, a genuine ambiguity, or completion."
+              "description": "off (the default when absent) = the run pauses between items as it always did. interval = armed with the harness's fixed-tick primitive, one item per fire. dynamic = the harness schedules its own next turn and the run picks each delay from what it is waiting for; a wait on nothing is minutes, not a tick nobody chose. interval and dynamic stop at the same four things — a manual gate, an unresolvable block, a genuine ambiguity, completion — and neither collapses an outward act: a generic flag is not a specific authorization."
             },
             "interval": {
               "type": "string",
               "pattern": "^[0-9]+[smhd]$",
-              "description": "Required when mode is 'interval'. Must divide its unit cleanly (5m, 10m, 2h — not 7m or 90m); a value that does not is rounded to the nearest that does, and the rounding is stated out loud. Pick the shortest interval that is longer than a typical item."
+              "description": "Required when mode is 'interval', and meaningless when it is 'dynamic' — a self-pacing run chooses each delay. Must divide its unit cleanly (5m, 10m, 2h — not 7m or 90m); a value that does not is rounded to the nearest that does, and the rounding is stated out loud. Pick the shortest interval that is longer than a typical item."
             },
             "command": {
               "type": "string",
               "description": "How this harness arms it, e.g. '/loop'. Harness-specific and therefore project-recorded rather than assumed: on a harness with no loop primitive, omit it — the mode then degrades to prose discipline plus the build ledger, and the run says so instead of implying it is armed."
+            },
+            "queue": {
+              "enum": [
+                "module-map",
+                "plan-tasks",
+                "none"
+              ],
+              "description": "What the loop walks. A loop with no queue is a timer: it says how often to continue and never what the next item is, so the run picks its next move by recollection. module-map = stage 2's decomposition (a platform); plan-tasks = stage 4's task list; none = the mode is armed for the stage boundaries only. Doctrine: references/continuity.md -> Part 1a."
+            },
+            "arm": {
+              "enum": [
+                "preflight",
+                "after-decomposition"
+              ],
+              "description": "When the mode is armed. preflight = at the top of the run, the original behaviour. after-decomposition = at the close of stage 2, once the queue exists and has more than one item — the default for a queue-bearing run, because a capability the operator must remember to switch on is one they forget on the run that needed it. Arming never collapses a manual gate or an outward action."
             }
           }
         },

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

@@ -11,6 +11,7 @@ almost no window left, loses the middle of it, and re-derives what it already di
 
 - The limit, before the capability
 - Part 1 — the loop
+- Part 1a — the queue is stage 2's, and the loop arms on it
 - Arming it on Claude Code
 - Other harnesses, and honest degradation
 - What one iteration means
@@ -62,6 +63,62 @@ the boundary between one agent turn and the next. This file is that reach.
 is never asked again — which is the entire point. A mode that has to be requested
 every run is not a mode, it is a habit the operator maintains by hand.
 
+## Part 1a — the queue is stage 2's, and the loop arms on it
+
+**A loop with no queue is a timer.** Until this section existed, `run.loop` said *how
+often* to continue and never said *what the next item is*, so the mode could be armed
+and still leave the run picking its next move by recollection — which is the failure
+[`learned.md`](learned.md) rule 16 is about, running once per fire.
+
+**The queue is the module map** ([`decomposition.md`](decomposition.md)) when the brief
+was a platform, and the plan's task list otherwise. Both already exist and both are
+already ordered; neither was ever named as the thing the loop walks.
+
+**Arming is the execution of a recorded decision, not a fresh request.** Where the mode
+is **recorded** and the queue has more than one item, the loop arms **at the close of
+stage 2** and the run says so in one line. It is not asked for at that point, for the
+same reason the mode is recorded rather than requested: re-asking would rebuild the habit
+the config exists to retire.
+
+**Where nothing is recorded, nothing arms.** Silence arms nothing here too — this section
+moves *where* a recorded mode is armed, from preflight to the close of stage 2. It does
+not make arming unconditional, and a reader who takes it that way would arm a loop in a
+project with no `pipeline.json` at all. That reading was in this section's first draft;
+an independent reader found it before it shipped.
+
+**What arming does NOT change, and this is load-bearing:** the four stops are the four
+stops. A `manual` gate still waits. An outward or irreversible act still needs its own
+specific authorization — *a generic flag is not a specific authorization*, and arming a
+queue is the most generic flag there is. Arming decides only that the run does not stop
+to ask *"shall I take the next one?"*.
+
+**`mode: dynamic` — when the harness paces itself.** `interval` was the only mode while
+the only primitive was a fixed tick. A harness that can schedule its own next turn
+should: the run picks the delay from what it is waiting for, and a wait on nothing is a
+wait of minutes rather than a fixed tick nobody chose. On a harness with neither
+primitive the mode degrades to prose discipline plus the build ledger, and **the run
+says which one it is running** — the rule below about claiming a capability you do not
+have is unchanged and applies to `dynamic` first.
+
+### The goal is re-read between items, not only the board
+
+Each iteration already re-measures the work-list. That answers *what is open*. It does
+not answer *whether the open thing still serves what this run was for* — and a queue
+built at stage 2 outlives the reason it was built, because the operator learns things
+between items and says so.
+
+So at the bottom of an iteration, beside the re-derived `prio`:
+
+1. re-read the brief's goal — one line, quoted, not recalled;
+2. state whether the next item still serves it;
+3. if it does not, **re-order or re-scope the queue and say what moved and why.** A row
+   that stops serving the goal leaves for the board with its reason
+   ([`backlog.md`](backlog.md)), it does not get worked because it was next.
+
+A queue re-derived only by `age` and `sev` is a queue that is honest about priority and
+silent about purpose. Both numbers can be right while the run is finishing something the
+operator stopped wanting two items ago.
+
 ## Arming it on Claude Code
 
 ```
@@ -85,10 +142,22 @@ silent failures otherwise:
   stops on day eight is worse than one that was never armed, because the operator
   believes work is still moving.
 
-Where `run.loop.mode` is `interval`, the **preflight arms it** and prints the job
-id and the cancel command. Arming is not a new decision at that point — the config
-is the recorded authorization, and re-asking would rebuild the habit the config
-exists to retire.
+**Where it arms is `run.loop.arm`,** and there are two points because there are two
+kinds of run:
+
+- `preflight` — the top of the run. Right when the loop walks stage boundaries rather
+  than a list, and the only option before Part 1a existed.
+- `after-decomposition` — the close of stage 2, once the queue exists and holds more
+  than one item. Arming earlier would arm a loop with nothing to walk.
+
+Either way the run **prints the job id and the cancel command**, and arming is not a new
+decision at that point — the config is the recorded authorization, and re-asking would
+rebuild the habit the config exists to retire.
+
+Under `mode: dynamic` there is no job id: the run schedules its own next turn each time
+and prints **the delay it chose and why**, which is the same disclosure in the form that
+mode has. A dynamic run that says nothing about its pacing is indistinguishable from a
+run that quietly stopped.
 
 ## Other harnesses, and honest degradation
 

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

@@ -258,13 +258,21 @@ never that the work was skipped quietly.
   its status, in build order with the walking skeleton first. Single-module work
   records `single module: <name>` in the design and moves on — a skipped
   decomposition is a decision, never an omission.
+- **The queue exists here, so the loop arms here** ([`continuity.md`](continuity.md) →
+  *Part 1a*). Where `run.loop.arm` is `after-decomposition` and the map holds more than
+  one module, arm the mode at the close of this stage and print one line: the mode, and
+  either the job id and its cancel command (`interval`) or the delay chosen and why
+  (`dynamic`). Arming collapses no gate and authorizes no outward act; it decides only
+  that the run does not stop to ask *"shall I take the next one?"*. Single-module work
+  arms nothing and says so — a loop with one item is a timer.
 - **GATE (manual):** the user approves the design, the UI verdict is recorded,
   **every REQ is answered by the design** — a requirement the design doesn't
   address is either covered now or explicitly dropped by the operator, with the
   drop recorded in the carry-over ledger — **and, for a platform, the module map is
   approved**: brick criteria met or excepted in writing, dependency graph acyclic,
   build order topological, every REQ mapped to exactly one module, cross-module
-  contracts named with their owner.
+  contracts named with their owner — **and the loop's arming state is printed**:
+  armed with its queue and pacing, or not armed with the reason.
 
 ## 3 — Spec — with UX track for user-facing tasks
 - **Freedom: medium** — what the contract says is judgement; which contracts must be locked is a list ([`gates.md`](gates.md) → *Axis C*).

package/plugins/task-pipeline/skills/task-pipeline/templates/routing-rule.md

@@ -17,20 +17,32 @@ than no boundary.
 
 ---
 
-## Routing — repo-changing work goes through the pipeline
+## Routing — work that lands in the repository goes through the pipeline
 
-**When `task-pipeline` is installed, any work that CHANGES THE REPOSITORY goes
-through it** — without being asked for. A feature, a fix, a refactor, a migration, an
-integration, a rewrite, an adoption, a hardening pass; in any language and any
-phrasing. Saying *"run this through the pipeline"* is an accelerator, not a
-precondition.
+**When `task-pipeline` is installed, any work that LANDS IN THE REPOSITORY goes
+through it** — without being asked for. Two shapes, not one:
 
-**The boundary is "changes the repository", and it cuts both ways.** Not through the
-pipeline:
+- **a change** — a feature, a fix, a refactor, a migration, an integration, a rewrite,
+  an adoption, a hardening pass;
+- **a finding that lands** — an audit, a bug hunt, a production check, a PR review. Its
+  output is not an answer in the chat: it is REQ rows, board rows, ledger rows and
+  fixes, and the pipeline is what carries them there.
 
-- a question and its answer, an explanation, reading or mapping code;
+In any language and any phrasing. Saying *"run this through the pipeline"* is an
+accelerator, not a precondition.
+
+**The boundary is what the request ENDS IN, and it cuts both ways.** An answer stops in
+the conversation; a change or a finding lands in the tree. Not through the pipeline:
+
+- a question and its answer, an explanation, mapping code so a person can read it;
 - a typo, a one-line edit, a mechanical rename;
-- reconnaissance or measurement that commits nothing.
+- reconnaissance or measurement that lands nothing.
+
+**Reading is not the test.** An audit, a bug hunt and a PR review all *begin* by reading,
+and all three end in the repository. Excluding them because they read is how a skill with
+a whole doctrine file for audits (`references/audit.md`) never gets reached by the word
+*audit* — measured, not supposed: three of ten routing queries were refused with this
+rule's own exclusion quoted back as the reason.
 
 Running ten gated stages for one character is the fastest way to teach an agent to
 route around the pipeline entirely.