task-pipeline-skill 1.43.0 → 1.45.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +80 -0
- package/SKILL-CARD.md +1 -1
- package/package.json +1 -1
- package/plugins/task-pipeline/.claude-plugin/plugin.json +1 -1
- package/plugins/task-pipeline/skills/task-pipeline/SKILL.md +58 -87
- package/plugins/task-pipeline/skills/task-pipeline/references/acceptance.md +52 -0
- package/plugins/task-pipeline/skills/task-pipeline/references/gates.md +75 -0
- package/plugins/task-pipeline/skills/task-pipeline/references/retrospective.md +37 -0
- package/plugins/task-pipeline/skills/task-pipeline/references/stages.md +6 -1
- package/plugins/task-pipeline/skills/task-pipeline/references/tdd.md +47 -0
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,85 @@
|
|
|
1
1
|
# Changelog
|
|
2
2
|
|
|
3
|
+
## v1.45.0
|
|
4
|
+
|
|
5
|
+
### Changed
|
|
6
|
+
|
|
7
|
+
- **The body went 367 lines / 7514 tokens to 338 / 6088** — measured with
|
|
8
|
+
`cl100k`. The reference routing existed **three times**: a 36-row "Built-in
|
|
9
|
+
doctrine" table, a flat `## References` catalogue below it, and again in the
|
|
10
|
+
stage table's `Invoke` column. One home now — the routing table, keyed by the
|
|
11
|
+
stage that sends you there — and the four files that lived only in the flat
|
|
12
|
+
list gained rows so nothing lost its trigger.
|
|
13
|
+
|
|
14
|
+
- **The description is 970 chars**, exactly the 5% headroom the canon asks for,
|
|
15
|
+
down from 1010. Getting there took three attempts: the validator locks the
|
|
16
|
+
`Not for:` exclusions and the verbs `adopt`/`harden` against the NOTRIG evals
|
|
17
|
+
from the 2026-08-03 design, and refused two rewordings before accepting one
|
|
18
|
+
in text nothing had locked.
|
|
19
|
+
|
|
20
|
+
### Known gap
|
|
21
|
+
|
|
22
|
+
- **The body is still 6088 tokens against a 5000 cap.** What remains is a
|
|
23
|
+
36-entry routing table and a five-step operating procedure, and both are what
|
|
24
|
+
the skill *is* — a body that indexes 32 references cannot be smaller than its
|
|
25
|
+
index. Cutting further would mean removing the routing this skill exists to
|
|
26
|
+
do. Recorded rather than papered over: the number is real and the canon's cap
|
|
27
|
+
does not have a clause for a skill whose body is a router.
|
|
28
|
+
|
|
29
|
+
## v1.44.0 — six lessons other projects paid for, carried home by the mechanism that exists for it
|
|
30
|
+
|
|
31
|
+
`retro.publish` sends a skill-level lesson upstream as an issue. Six arrived in one day
|
|
32
|
+
from projects that are not this one, and every one is a diagnosis: the class, why the
|
|
33
|
+
existing doctrine did not catch it, and the fix by grade. This release is those six.
|
|
34
|
+
|
|
35
|
+
| Issue | What it bought |
|
|
36
|
+
|---|---|
|
|
37
|
+
| #30 | a name in `verified by` **resolves**, or the row is `unknown` — never `verified` |
|
|
38
|
+
| #31 | a probe that mutates a file asserts its plant landed **— now a guard** |
|
|
39
|
+
| #32 | a seam is not a deliverable: an explicit REQ for the boundary, phrased as a journey |
|
|
40
|
+
| #33 | the tests gate names **what each case consumes**; a timeout is unclassified, not slow |
|
|
41
|
+
| #34 | stage 10 carries a `publish:` line — an unarmed path stops looking like silence |
|
|
42
|
+
| #35 | a ratchet's matcher is itself a check: feed it a **near-miss it must reject** |
|
|
43
|
+
|
|
44
|
+
### Two of them had already been found here, independently
|
|
45
|
+
|
|
46
|
+
**#35 is the neighbour probe**, shipped in v1.42.0 after a reader defeated six guards whose
|
|
47
|
+
evidence sat next to their subject. The reporting project reached it from a ratchet whose
|
|
48
|
+
matcher credited every parent with its child's coverage. Same class, two routes, no
|
|
49
|
+
contact — which is the strongest evidence either had.
|
|
50
|
+
|
|
51
|
+
**#31 is R-001**, born here on 2026-08-03 and **retired in v1.38.0** on its own trigger:
|
|
52
|
+
*"a probe harness exists that asserts the plant changed the parsed text"*. The harness does
|
|
53
|
+
exist. The retirement was still premature, because the condition was *"a harness exists"*
|
|
54
|
+
and the thing that mattered was *"the harness is used everywhere"*. It cost the reporting
|
|
55
|
+
project three incidents in one day and this repository six in this session's own releases.
|
|
56
|
+
**A retirement trigger phrased as the existence of a mechanism, rather than its reach, is
|
|
57
|
+
a trigger that fires early.**
|
|
58
|
+
|
|
59
|
+
### The number that took four attempts
|
|
60
|
+
|
|
61
|
+
Enforcing #31 meant counting probes that mutate a file without asserting the plant landed:
|
|
62
|
+
|
|
63
|
+
```
|
|
64
|
+
hand-written classifier 206 of 206 already carry it (wrong)
|
|
65
|
+
the guard, first version 22 do not (wrong — one spelling)
|
|
66
|
+
the sweep that followed "fixed" 6 sound probes, corrupted 5
|
|
67
|
+
the truth 16
|
|
68
|
+
```
|
|
69
|
+
|
|
70
|
+
The guard corrected the hand count that motivated it. Then the guard was itself the class
|
|
71
|
+
two sections above — keyed to one spelling, it reported as defective six probes that
|
|
72
|
+
obeyed the rule in different words, and a sweep written from that verdict split five live
|
|
73
|
+
statements. Found by `compile()` and a restore from git.
|
|
74
|
+
|
|
75
|
+
**Every** mutating probe carries the assertion, and **no figure is written here** — the
|
|
76
|
+
third attempt to put one beside it was wrong too. The count is a `grep` away and the
|
|
77
|
+
guard computes it on every run; a number in prose next to a check that can count is
|
|
78
|
+
restating instead of computing, which is the rule this very release imports and which
|
|
79
|
+
this paragraph broke three times before it stopped trying.
|
|
80
|
+
|
|
81
|
+
- Guards: 261 → **275**.
|
|
82
|
+
|
|
3
83
|
## v1.43.0 — the rail said where, and nothing said what happened
|
|
4
84
|
|
|
5
85
|
A fourteen-iteration session on this repository ended each return with the same question
|
package/SKILL-CARD.md
CHANGED
|
@@ -12,7 +12,7 @@ harmless.
|
|
|
12
12
|
|---|---|
|
|
13
13
|
| **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 |
|
|
14
14
|
| **Owner** | ssheleg ([github.com/ssheleg/task-pipeline](https://github.com/ssheleg/task-pipeline)) |
|
|
15
|
-
| **Version** | 1.
|
|
15
|
+
| **Version** | 1.45.0 |
|
|
16
16
|
| **Surface** | Claude Code (filesystem skill + plugin) and the vercel `skills` CLI. **Not** uploaded to the Skills API; custom Skills do not sync across surfaces |
|
|
17
17
|
| **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 |
|
|
18
18
|
| **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/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "task-pipeline-skill",
|
|
3
|
-
"version": "1.
|
|
3
|
+
"version": "1.45.0",
|
|
4
4
|
"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.",
|
|
5
5
|
"bin": {
|
|
6
6
|
"task-pipeline": "bin/task-pipeline.js"
|
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
"name": "task-pipeline",
|
|
3
3
|
"displayName": "Task Pipeline",
|
|
4
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/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.",
|
|
5
|
-
"version": "1.
|
|
5
|
+
"version": "1.45.0",
|
|
6
6
|
"author": {
|
|
7
7
|
"name": "ssheleg",
|
|
8
8
|
"url": "https://x.com/sshlg93"
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: task-pipeline
|
|
3
|
-
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
|
|
3
|
+
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 shipped unconfirmed and what to look at first; 'setup' audits existing documentation. Not for: answering a question, explaining code, a typo or a one-line edit — say 'без пайплайна' / 'quick' to opt out."
|
|
4
4
|
license: MIT
|
|
5
5
|
---
|
|
6
6
|
|
|
@@ -46,32 +46,32 @@ gate stops until it is installed.
|
|
|
46
46
|
|
|
47
47
|
| Stage | Built-in doctrine |
|
|
48
48
|
|---|---|
|
|
49
|
-
| 0
|
|
50
|
-
| any
|
|
51
|
-
| 6–10
|
|
52
|
-
| 7–8 · Deploy targets |
|
|
53
|
-
| any
|
|
54
|
-
| 0 Knowledge harvest (pre-grill) |
|
|
55
|
-
| 0
|
|
56
|
-
| 0 Intake grill |
|
|
57
|
-
| 2 Brainstorm |
|
|
58
|
-
| 2 Decompose (platforms only) |
|
|
59
|
-
| 3 Spec |
|
|
60
|
-
| 4 Plan |
|
|
61
|
-
| 5 Build (worktree, subagents, fix loop) |
|
|
62
|
-
| 5–6 TDD + suite gate |
|
|
63
|
-
| 10 Acceptance (REQ close-out) |
|
|
64
|
-
| 10 Retrospective (the run's last act) |
|
|
65
|
-
| 10 + any audit (what's *missing*) |
|
|
66
|
-
| **first run in a project** (new or existing) |
|
|
67
|
-
| **first run · the entry audit** (offered once) |
|
|
68
|
-
| **what travels with the bundle vs stays in a project** |
|
|
69
|
-
| any repeating loop |
|
|
70
|
-
| run-wide · what the run **prints about itself** — the rail, the iteration line |
|
|
71
|
-
| run-wide · how a run keeps going (the loop mode + the context budget) |
|
|
72
|
-
| run-wide · the work-list **between** runs, and how its priority is computed |
|
|
73
|
-
| run-wide · whether a **human** ever confirmed what shipped, and when |
|
|
74
|
-
| run-wide · how much unconfirmed work has piled up, and what to look at first |
|
|
49
|
+
| 0, 9 · The documentation system | `references/documentation.md` |
|
|
50
|
+
| any stage · The canons, and where each is enforced | [`evidence-docs`](../evidence-docs/SKILL.md) — the sibling skill in this plugin |
|
|
51
|
+
| 6–10 · Gates | `references/gates.md` |
|
|
52
|
+
| 7–8 · Deploy targets | `references/deploy-targets.md` |
|
|
53
|
+
| any stage · Hooks | `references/hooks.md` |
|
|
54
|
+
| 0 Knowledge harvest (pre-grill) | `references/knowledge-sources.md` |
|
|
55
|
+
| 0, 9 The code graph (graphify — recommended, never required) | `references/knowledge-graph.md` |
|
|
56
|
+
| 0 Intake grill | `references/grill.md` |
|
|
57
|
+
| 2 Brainstorm | `references/brainstorm.md` |
|
|
58
|
+
| 2 Decompose (platforms only) | `references/decomposition.md` |
|
|
59
|
+
| 3 Spec | `references/spec.md` |
|
|
60
|
+
| 4 Plan | `references/planning.md` |
|
|
61
|
+
| 5 Build (worktree, subagents, fix loop) | `references/build.md` + `references/review.md` |
|
|
62
|
+
| 5–6 TDD + suite gate | `references/tdd.md` |
|
|
63
|
+
| 10 Acceptance (REQ close-out) | `references/acceptance.md` |
|
|
64
|
+
| 10 Retrospective (the run's last act) | `references/retrospective.md` |
|
|
65
|
+
| 10 + any audit (what's *missing*) | `references/audit.md` |
|
|
66
|
+
| **first run in a project** (new or existing) | `references/adoption.md` |
|
|
67
|
+
| **first run · the entry audit** (offered once) | `references/setup.md` |
|
|
68
|
+
| **what travels with the bundle vs stays in a project** | `references/portability.md` |
|
|
69
|
+
| any repeating loop | `references/loop-guard.md` |
|
|
70
|
+
| run-wide · what the run **prints about itself** — the rail, the iteration line | `references/progress.md` |
|
|
71
|
+
| run-wide · how a run keeps going (the loop mode + the context budget) | `references/continuity.md` |
|
|
72
|
+
| run-wide · the work-list **between** runs, and how its priority is computed | `references/backlog.md` |
|
|
73
|
+
| run-wide · whether a **human** ever confirmed what shipped, and when | `references/verification.md` |
|
|
74
|
+
| run-wide · how much unconfirmed work has piled up, and what to look at first | `references/exposure.md` |
|
|
75
75
|
|
|
76
76
|
**Optional bridge.** If the operator already runs an equivalent skill set (e.g.
|
|
77
77
|
`superpowers:brainstorming` / `writing-plans` / `subagent-driven-development` /
|
|
@@ -101,7 +101,7 @@ workflow for the WHY→UI→scenario chain (`/ux`, `ux-foundation`, `ux-flows`,
|
|
|
101
101
|
it — install before stage 3, otherwise stop and ask the operator to install.
|
|
102
102
|
|
|
103
103
|
**The grill is built in — no companion skill, nothing to install.** Stage 0 ships
|
|
104
|
-
with this skill: the full doctrine lives in
|
|
104
|
+
with this skill: the full doctrine lives in `references/grill.md`
|
|
105
105
|
(interview loop, domain awareness, autonomy sweep, output). It is **mandatory** —
|
|
106
106
|
no "clear enough task" exemption, no starting stage 1 without a committed,
|
|
107
107
|
operator-confirmed brief. The one sanctioned bypass is the entry-from-super-ux
|
|
@@ -113,17 +113,17 @@ stage 4's gate is a mechanical set-comparison against them, and **stage 10 accou
|
|
|
113
113
|
for every one** — which is what turns the pipeline from a funnel into a circle.
|
|
114
114
|
|
|
115
115
|
**Harvest before you ask.** Stage 0 opens with a **knowledge harvest**
|
|
116
|
-
(
|
|
116
|
+
(`references/knowledge-sources.md`), not a
|
|
117
117
|
question: pull what the project already knows about this task from the code, the
|
|
118
118
|
**code graph** if one is built
|
|
119
|
-
(
|
|
119
|
+
(`references/knowledge-graph.md` — graphify;
|
|
120
120
|
recommended, never required),
|
|
121
121
|
`CLAUDE.md`, `CONTEXT.md`/ADRs, **the decision register**, `docs/` + `docs/ux/`,
|
|
122
122
|
past pipeline briefs, **the retro's standing instructions and run stamps** —
|
|
123
123
|
`docs/superpowers/retro.md`, read in full because they *bind* this run and are
|
|
124
124
|
bounded by construction (ten rows; one line per run), while its **recent log** and the
|
|
125
125
|
archive under `docs/superpowers/retro/` are **queried** by the task's nouns
|
|
126
|
-
(
|
|
126
|
+
(`references/retrospective.md`) —
|
|
127
127
|
the **knowledge wiki** if one is installed
|
|
128
128
|
([obsidian-wiki](https://github.com/ar9av/obsidian-wiki) — recommended, never
|
|
129
129
|
required) and any **other repo or hosted doc system the project names as its
|
|
@@ -138,11 +138,11 @@ queries first, so a stale one is a false premise carrying the authority of a
|
|
|
138
138
|
machine. Refreshing it also buys the **graph↔docs divergence check**: a hub no
|
|
139
139
|
document names, an edge the docs deny, a doc naming a module the graph no longer
|
|
140
140
|
has. Doc-side findings are fixed at stage 9; absences become REQ rows at stage 10
|
|
141
|
-
(
|
|
142
|
-
|
|
141
|
+
(`references/knowledge-graph.md`,
|
|
142
|
+
`references/audit.md`).
|
|
143
143
|
|
|
144
144
|
**Documentation is a deliverable, and it has a gate**
|
|
145
|
-
(
|
|
145
|
+
(`references/documentation.md`). Stage 0's harvest
|
|
146
146
|
reads what the project knows; a second phase asks the four questions that make it a
|
|
147
147
|
*system* — where settled things live, what each fact's single home is, what a change
|
|
148
148
|
of type X obliges, and what proves it — and writes them to `docs/DOCMAP.md`. From
|
|
@@ -157,7 +157,7 @@ plus a stable id, never a second act of thinking.
|
|
|
157
157
|
*this* run and blind across runs, so the same class of failure can be caught, fixed
|
|
158
158
|
and forgotten five times with nothing noticing it is the same one. The last act of
|
|
159
159
|
stage 10 is therefore the **retrospective**
|
|
160
|
-
(
|
|
160
|
+
(`references/retrospective.md`, written to
|
|
161
161
|
`docs/superpowers/retro.md`): **stamp the run first** — one line, and the only thing
|
|
162
162
|
that makes the next step computable — **then prune**, every standing instruction
|
|
163
163
|
checked against its retirement triggers (it became a check · its surface is gone · it
|
|
@@ -170,7 +170,7 @@ a gate criterion and not a good intention: a rule nobody reads to the end is wor
|
|
|
170
170
|
than no rule, because everyone believes it is covered. **The order is load-bearing,
|
|
171
171
|
not stylistic** — one retirement trigger counts firings across the last five run
|
|
172
172
|
stamps, so a prune placed ahead of the stamp reads a counter its own stage writes
|
|
173
|
-
afterwards and can never run on real data (
|
|
173
|
+
afterwards and can never run on real data (`references/learned.md` rule 21).
|
|
174
174
|
|
|
175
175
|
Three things the grill does beyond clarifying the request:
|
|
176
176
|
- **Domain awareness.** It reads the project's own `CONTEXT.md` / `docs/adr/` and
|
|
@@ -183,6 +183,10 @@ Three things the grill does beyond clarifying the request:
|
|
|
183
183
|
mid-flight (test/lint/deploy commands, branch policy, log locations, docs
|
|
184
184
|
targets, the model decision, deploy authorization). Autonomy is bought here or
|
|
185
185
|
not at all — an unasked question is a scheduled interruption.
|
|
186
|
+
| any stage · Where each artifact belongs | `references/artifacts.md` |
|
|
187
|
+
| preflight · Companion skills and their fallbacks | `references/companion-skills.md` |
|
|
188
|
+
| 6–10 · How the host project's CLAUDE.md is read | `references/conventions.md` |
|
|
189
|
+
| preflight · Model map, ids and the override | `references/model-tiering.md` |
|
|
186
190
|
|
|
187
191
|
## How to run
|
|
188
192
|
|
|
@@ -261,19 +265,19 @@ Three things the grill does beyond clarifying the request:
|
|
|
261
265
|
All stages run on the **one model confirmed at preflight** (default: the most
|
|
262
266
|
capable available — see `references/model-tiering.md`).
|
|
263
267
|
|
|
264
|
-
| # | Stage |
|
|
265
|
-
|
|
266
|
-
| 0 | Intake grill — **mandatory** |
|
|
267
|
-
| 1 | Docs study |
|
|
268
|
-
| 2 | Brainstorm + decompose |
|
|
269
|
-
| 3 | Spec |
|
|
270
|
-
| 4 | Plan |
|
|
271
|
-
| 5 | Dev |
|
|
272
|
-
| 6 | Tests |
|
|
273
|
-
| 7 | Lint + deploy |
|
|
274
|
-
| 8 | Post-deploy |
|
|
275
|
-
| 9 | Docs + wiki |
|
|
276
|
-
| 10 | **Acceptance** |
|
|
268
|
+
| # | Stage | Gate | Type |
|
|
269
|
+
|---|---|---|---|
|
|
270
|
+
| 0 | Intake grill — **mandatory** | source ledger written; **the documentation inventory answered into `docs/DOCMAP.md`** — registers, single homes, the propagation matrix, the gate command — and **intent reconciled against as-built**, every divergence resolved ([`references/documentation.md`](references/documentation.md)); the retro read in full and its archive queried; shared understanding reached; autonomy sweep covered; brief locked + confirmed | manual |
|
|
271
|
+
| 1 | Docs study | contracts grounded on fetched docs | auto |
|
|
272
|
+
| 2 | Brainstorm + decompose | design approved; UI verdict recorded; every REQ answered; platform: module map approved | manual |
|
|
273
|
+
| 3 | Spec | committed + reviewed; UI: chain validated, linter green, scenarios/`SCR-` traced | manual |
|
|
274
|
+
| 4 | Plan | parallel-ready, DoD per task | auto |
|
|
275
|
+
| 5 | Dev | tasks DONE, TDD green per task, branch integrated per the brief; **anything generated passes its own checks, and local infrastructure does not publish the host's default ports** ([`references/learned.md`](references/learned.md)) | auto |
|
|
276
|
+
| 6 | Tests | full suite green; new/changed code covered; **every new check probed both ways and asserted on its exit code**, and the suite run once against a cold environment ; **on a web front end the surface is checked in a browser, not in the diff** — a green suite cannot see a component that renders under a fixed header, a request that 404s past its mock, or a console error (`chrome-devtools`, [`references/companion-skills.md`](references/companion-skills.md); absent → say *verified by reading the diff* and record it as the weaker claim it is) | auto |
|
|
277
|
+
| 7 | Lint + deploy | lint clean + suite green before deploy; deploy needs a go (or the brief's specific standing authorization) | manual |
|
|
278
|
+
| 8 | Post-deploy | clean boot or honest degradation report; **a deployed web target is opened, not curled** — a `200` proves the server answered and says nothing about a 404'd bundle or a console full of errors on load (`chrome-devtools`; absent → call it an HTTP response, which is its honest name) | auto |
|
|
279
|
+
| 9 | Docs + wiki | every stale row of the stage-0 source ledger updated; **the propagation matrix walked for every change type this run produced** — the ledger names what you read, the matrix names what you owe — every settled thing recorded with an id, every answered question resolved, and **the documentation gate green with its ratchet counts printed**; docs synced; wiki synced; **the code graph refreshed where one exists** and checked against the docs (a hub no doc names, a doc naming a node the graph lost); **every number computed rather than restated, every named command or file resolvable** ([`references/learned.md`](references/learned.md)); the carry-over count printed beside the verdict | auto |
|
|
280
|
+
| 10 | **Acceptance** | ladder walk ran, its absences became REQ rows; every REQ accounted for with evidence from a check seen failing once; ledger has no unresolved row; **axis rotation recorded** (new findings vs self-inflicted, rule 1 of [`references/learned.md`](references/learned.md)), **every closure verified against the artefact rather than the document describing it**, **each correction swept across its class**, **every deferral a printed ratchet rather than a TODO**; **in a multi-repository project, every repository is clean, pushed and pointed at** (below); **the hand-back is written** — the request quoted as given, progress against it, what was solved, what surfaced unasked, waiting decisions asked here, and the ambiguity count computed ([`references/progress.md`](references/progress.md)); operator signs off; **every check this close-out leans on — the documentation gate included — has been seen failing once against a planted defect, and its ratchet counts are printed beside the verdict**; **the retrospective written last, and in order — the run stamped with its commit FIRST (the cold-retirement trigger reads that stamp), then the prune with the list at or under its cap and every deletion logged, then the entry; every deletion and every entry carrying its commit, entries older than five stamps rotated into the archive, counts printed** ; **both disclosures printed beside the verdict** — `abstained` (what the run declined to claim) and `unlooked` (what a check never looked at), neither a ratchet, neither with a floor, neither ever a target ([`references/gates.md`](references/gates.md) → *Disclosures*) | manual |
|
|
277
281
|
|
|
278
282
|
|
|
279
283
|
### Stage 10 in a project of several repositories
|
|
@@ -331,41 +335,8 @@ automation is on — `pipeline.schema.json` is the only contract.
|
|
|
331
335
|
|
|
332
336
|
## References
|
|
333
337
|
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
- `references/acceptance.md` — the built-in stage-10 close-out: REQ coverage, evidence, sign-off
|
|
340
|
-
- `references/retrospective.md` — stage 10's last act: the project retro (`docs/superpowers/retro.md`), the three grades of fix, the mandatory prune and its cap of ten
|
|
341
|
-
- `references/documentation.md` — cross-cutting: the doc inventory, registers and ids, SSOT, the Doc Loop, supersede semantics, the propagation matrix, intent vs as-built
|
|
342
|
-
- `references/gates.md` — cross-cutting: the three axes, the promotion ladder, gate anatomy, the probe recipe, ratchet floors, where a gate runs
|
|
343
|
-
- `references/deploy-targets.md` — stages 7–8: writing the runbook when there is none, the template, per-platform deploy and log verbs, and the verification trio
|
|
344
|
-
- `references/hooks.md` — agent-time enforcement: the PreToolUse contract, the fail-open hazard, placement, and the Claude-Code-only limit
|
|
345
|
-
- `references/audit.md` — cross-cutting: the L0→L7 ladder and its seams (what was never written), axis rotation, ratchets, proven checks
|
|
346
|
-
- `references/learned.md` — cross-cutting: rules earned by failure on a real multi-repository build, each with the incident behind it, its check and its exit criterion; plus the two that no check can decide. The table is the count — a number written here is a number that goes stale on the next rule
|
|
347
|
-
- `references/brainstorm.md` — stage 2: design dialogue, approaches, UI detection, hard gate
|
|
348
|
-
- `references/spec.md` — stage 3: UX track order, the spec contract, self-review, review gate
|
|
349
|
-
- `references/planning.md` — stage 4: zero-context plan format, parallel groups, no placeholders
|
|
350
|
-
- `references/build.md` — stage 5: isolation, ledger, subagent task loop, fix loop, final review
|
|
351
|
-
- `references/review.md` — the review rubric, diff packages and the three reviewer prompts
|
|
352
|
-
- `references/tdd.md` — stages 5–6: the iron law, red/green/refactor, the suite gate
|
|
353
|
-
- `references/stages.md` — per-stage detail + exact gate criteria + gate types
|
|
354
|
-
- `references/model-tiering.md` — model map, ids, the `/model` reminder mechanic, override
|
|
355
|
-
- `references/setup.md` — the entry audit: seven passes over the docs you already
|
|
356
|
-
have, offered once, output as a fix plan; plus the inward check for rules that
|
|
357
|
-
belong upstream
|
|
358
|
-
- `references/portability.md` — the manifest of workflow decisions and their homes
|
|
359
|
-
inside the bundle, and the boundary against a project's own answers
|
|
360
|
-
- `references/adoption.md` — the first run in a project: greenfield seeding, and the
|
|
361
|
-
brownfield walkthrough whose third step baselines the ratchets at today
|
|
362
|
-
- `references/continuity.md` — run-wide pacing: the loop mode (`run.loop`, default
|
|
363
|
-
off, and it never collapses a manual gate), how it is armed on Claude Code and
|
|
364
|
-
what that costs, and the context budget — which fires on a harness signal, never
|
|
365
|
-
on an estimate
|
|
366
|
-
- `references/conventions.md` — how stages 6–10 read the host project's CLAUDE.md
|
|
367
|
-
- `references/companion-skills.md` — companion skills, install lines, preflight recommendation
|
|
368
|
-
- `references/artifacts.md` — the canonical document/artifact layout per stage
|
|
369
|
-
- `templates/` — skeletons seeded into the host project: `brief.md` (stage 0),
|
|
370
|
-
`carryover.md` (seeded at 0, appended by every stage, read in full at 10),
|
|
371
|
-
`context.md` and `adr.md` (format references the grill writes lazily)
|
|
338
|
+
Every reference is routed from the **Built-in doctrine** table above, keyed by
|
|
339
|
+
the stage that sends you there — one home for that mapping rather than two. The
|
|
340
|
+
two config contracts sit beside this file: `pipeline.schema.json` (the universal
|
|
341
|
+
stages + release contract) and `pipeline.example.json` (this plugin's default
|
|
342
|
+
flow as config).
|
|
@@ -17,6 +17,8 @@ requirement.** It is what turns the pipeline from a funnel into a circle.
|
|
|
17
17
|
- Several repositories — a submodule is finished when its parent says so
|
|
18
18
|
- The closing question
|
|
19
19
|
- The retrospective — the run's last act
|
|
20
|
+
- A `verified by` name is a claim until it resolves
|
|
21
|
+
- A seam is not a deliverable, and REQ rows are written against deliverables
|
|
20
22
|
- GATE (manual)
|
|
21
23
|
- When the answer is "something's missing"
|
|
22
24
|
|
|
@@ -201,6 +203,56 @@ GATE 10 acceptance: PASS — 14/14 REQ verified
|
|
|
201
203
|
abstained: 2 (1 partial · 1 cannot-verify) · unlooked: 3 dormant
|
|
202
204
|
```
|
|
203
205
|
|
|
206
|
+
## A `verified by` name is a claim until it resolves
|
|
207
|
+
|
|
208
|
+
Reported from another project. Two rows in one run named checks that did not exist — a
|
|
209
|
+
locale-parity test for a project with ten locales and no such test, an index-resolution
|
|
210
|
+
test that had never been written. Both rows carried a status, an owner and an evidence
|
|
211
|
+
cell. **Nothing in the artefact distinguishes *"this check exists and passed"* from *"this
|
|
212
|
+
is the name a check would have if someone wrote it"*.**
|
|
213
|
+
|
|
214
|
+
This file already requires the evidence to come from a check seen failing once. That
|
|
215
|
+
requirement is about the **check**; nothing walks back from the **name** to ask whether a
|
|
216
|
+
check by that name is on disk. The ladder walk found both, because it re-derives coverage
|
|
217
|
+
from the artefact instead of reading the table — which also means the table was wrong for
|
|
218
|
+
the whole run until its last gate.
|
|
219
|
+
|
|
220
|
+
**So every name in a `verified by` cell resolves before the table is accepted** — to a
|
|
221
|
+
file, a test name a runner will select, or a command that exits. A cell naming nothing is
|
|
222
|
+
a REQ with status **`unknown`**, never `verified`.
|
|
223
|
+
|
|
224
|
+
The coverage table is this pipeline's own record of what was proven. When it can carry an
|
|
225
|
+
unresolvable name it stops measuring the run and starts recording the author's intent,
|
|
226
|
+
which is [`gates.md`](gates.md)'s false success living inside the pipeline's own artefact.
|
|
227
|
+
|
|
228
|
+
## A seam is not a deliverable, and REQ rows are written against deliverables
|
|
229
|
+
|
|
230
|
+
Also reported. Two halves of a feature shipped in one run, each correct alone, each with a
|
|
231
|
+
passing unit test. Together they formed a closed loop: a guard turned away users who had
|
|
232
|
+
not reached a state, and the new flow that would put them into that state sat behind the
|
|
233
|
+
guard. **The defect was in the seam, and a seam has no file.** The coverage table had a
|
|
234
|
+
row per artefact and both rows were green.
|
|
235
|
+
|
|
236
|
+
The blindness one layer down is already named — a handler test proves the handler, not the
|
|
237
|
+
request path. This is that shape one layer up.
|
|
238
|
+
|
|
239
|
+
**So when a run replaces a component that another component branches on, stage 2 writes an
|
|
240
|
+
explicit REQ for the boundary** —
|
|
241
|
+
not *"A works"* and *"B works"* but **"a user in state X reaches Y"**. Phrased as a
|
|
242
|
+
journey it is testable; phrased as two artefacts it is not.
|
|
243
|
+
|
|
244
|
+
**This does not contradict [`decomposition.md`](decomposition.md), and the wording matters
|
|
245
|
+
because a first draft did.** That file says a REQ appearing in two modules means the seam
|
|
246
|
+
runs *through* a requirement, and tells you to re-cut. A boundary REQ is not that: it is a
|
|
247
|
+
single requirement about the transition, owned by **one** module — the one that consumes
|
|
248
|
+
the boundary — and it maps to exactly one module like every other. Cite it as a journey
|
|
249
|
+
owned by the downstream module, and both rules hold.
|
|
250
|
+
|
|
251
|
+
**And where no check can span the seam** — a server-rendered redirect on one side, a
|
|
252
|
+
client write on the other — the table says so under `unlooked` rather than showing two
|
|
253
|
+
green rows. Two green halves reporting a working whole is exactly the shape this file
|
|
254
|
+
spends its length refusing.
|
|
255
|
+
|
|
204
256
|
## GATE (manual)
|
|
205
257
|
|
|
206
258
|
All of:
|
|
@@ -31,6 +31,8 @@ elsewhere and is not restated here:
|
|
|
31
31
|
- Writing the check itself
|
|
32
32
|
- Probing — plant, run, restore
|
|
33
33
|
- The neighbour probe — plant the evidence outside the subject
|
|
34
|
+
- A ratchet's matcher is itself a check, and it needs a near-miss
|
|
35
|
+
- A green probe is evidence only if the mutation is known to have landed
|
|
34
36
|
- The false-positive budget
|
|
35
37
|
- Ratchets
|
|
36
38
|
- Disclosures — counted like a ratchet, and deliberately not monotone
|
|
@@ -347,6 +349,79 @@ the item, then match on flattened text so an emphasis marker cannot hide the bou
|
|
|
347
349
|
where that ends*. It costs nothing and it is the only part of a check a later reader can
|
|
348
350
|
disagree with before the defect arrives.
|
|
349
351
|
|
|
352
|
+
## A ratchet's matcher is itself a check, and it needs a near-miss
|
|
353
|
+
|
|
354
|
+
Reported from another project through `retro.publish`, and it is the neighbour probe's
|
|
355
|
+
own class arrived at independently — which is the strongest evidence either has.
|
|
356
|
+
|
|
357
|
+
A run built a ratchet to hold a coverage debt: a list of units with no test, a guard that
|
|
358
|
+
fails when the list grows, a count printed at the gate. Exactly the shape
|
|
359
|
+
[`audit.md`](audit.md) asks for instead of a deferred TODO. The guard decided whether a
|
|
360
|
+
unit was covered by asking whether its identifier appeared **anywhere** in the test
|
|
361
|
+
corpus. The identifiers were path-like and many were prefixes of longer ones, so every
|
|
362
|
+
unit that happened to be the parent of another was credited with its child's coverage.
|
|
363
|
+
|
|
364
|
+
**A ratchet whose matcher is looser than its subject shrinks itself.** It reports progress
|
|
365
|
+
for work nobody did, and because a ratchet is trusted precisely so that nobody re-derives
|
|
366
|
+
it, the error compounds for as long as the ratchet exists.
|
|
367
|
+
|
|
368
|
+
Both existing rules were satisfied. The ratchet was printed. The guard had been seen going
|
|
369
|
+
red when the list grew. Neither asks whether the matcher can tell its subject from a near
|
|
370
|
+
neighbour, and that is the only question that would have caught it.
|
|
371
|
+
|
|
372
|
+
**So before a ratchet is kept, feed its matcher a near-miss it must reject** — the prefix,
|
|
373
|
+
the parent, the same name in a comment or an import, the longer extension. Seeing a guard
|
|
374
|
+
go red on a real change proves it **reacts**; seeing it stay green on a look-alike proves
|
|
375
|
+
it **discriminates**. Only the second makes its number worth trusting.
|
|
376
|
+
|
|
377
|
+
**And when a matcher is corrected, re-derive the whole ratchet and print both numbers with
|
|
378
|
+
the reason.** In the reporting project the corrected count was *identical* to the old one
|
|
379
|
+
and the composition was not: rows credited falsely came back in as rows genuinely paid off
|
|
380
|
+
went out. A single number with no delta reads as a run where nothing happened.
|
|
381
|
+
|
|
382
|
+
## A green probe is evidence only if the mutation is known to have landed
|
|
383
|
+
|
|
384
|
+
Also reported from another project, three times in one day, each caught only because the
|
|
385
|
+
result was too good:
|
|
386
|
+
|
|
387
|
+
1. a scripted substitution missed on indentation — the file was unchanged and the probe
|
|
388
|
+
measured nothing;
|
|
389
|
+
2. an assertion written against a bare identifier kept matching the **import line** after
|
|
390
|
+
the field it guarded was deleted;
|
|
391
|
+
3. a file-extension alternation matched the longer extension as though it were the
|
|
392
|
+
shorter, reporting nine live files as missing.
|
|
393
|
+
|
|
394
|
+
In all three the observable was identical to success. *"See it fail once"* has an unstated
|
|
395
|
+
precondition — **that the thing you changed is the thing the check reads** — and a planted
|
|
396
|
+
defect that did not land produces the same green as a check that cannot fail.
|
|
397
|
+
|
|
398
|
+
**So a probe that mutates an existing file asserts its plant landed, in the same breath as
|
|
399
|
+
planting it.** A probe that writes a whole file has no such question: the file exists or
|
|
400
|
+
the command failed. This repository measured itself while writing this section and got the
|
|
401
|
+
number wrong three times. A hand-rolled classifier said *206 of 206 already carry it*.
|
|
402
|
+
The guard written from the rule said **22 did not** — and was itself too narrow, matching
|
|
403
|
+
one spelling of the assertion, so six probes that already had it in lower case were
|
|
404
|
+
called defective. A sweep then "fixed" those six and **corrupted five**, splitting live
|
|
405
|
+
statements. The true figure was **16**, and it took the guard, a compile check and a
|
|
406
|
+
restore from git to find it.
|
|
407
|
+
|
|
408
|
+
Two things are worth keeping from that. **The check corrected the measurement that
|
|
409
|
+
motivated it** — which is the argument for writing checks rather than counting by hand.
|
|
410
|
+
And **a check keyed to one spelling of a rule is the class two sections above**: it
|
|
411
|
+
reported as defective the probes that obeyed the rule in different words. **Every**
|
|
412
|
+
mutating probe carries the assertion now — the figure is deliberately not
|
|
413
|
+
written here. A first draft said *201*, which was true of the branch point and false in
|
|
414
|
+
the same commit, because the twelve probes added for this release are themselves mutating
|
|
415
|
+
probes. The guard computes it; a number in prose beside a check that can count is the
|
|
416
|
+
class this bundle calls restating instead of computing. Probes that write a whole file
|
|
417
|
+
need none: the file exists or the command
|
|
418
|
+
failed.
|
|
419
|
+
|
|
420
|
+
**Prefer an assertion that names the construct over one that names a substring of it.** A
|
|
421
|
+
guard written against a bare identifier survives the deletion of everything it guarded,
|
|
422
|
+
because the identifier still appears in an import. That is case 2 above and it is the same
|
|
423
|
+
class as the section before this one, one level down.
|
|
424
|
+
|
|
350
425
|
## The false-positive budget
|
|
351
426
|
|
|
352
427
|
Run a new heuristic over the **real corpus** before shipping it and count the false
|
|
@@ -33,6 +33,7 @@ file exists to stop.
|
|
|
33
33
|
- Write the entry only for a divergence — and name the layer that owned it
|
|
34
34
|
- Every lesson carries its commit
|
|
35
35
|
- The stamp table is capped at ten, and *one line per run* was never a cap
|
|
36
|
+
- `publish:` is a line in the verdict, not a silence
|
|
36
37
|
- Rotation — the archive is how pruning stops losing things
|
|
37
38
|
- Three grades of fix — take the highest one that can work
|
|
38
39
|
- Stamp first, then prune, then write
|
|
@@ -100,6 +101,42 @@ like every other rotation. **The count is printed at the prune**, beside the sta
|
|
|
100
101
|
instructions' own count, so a table that stops rotating is visible rather than merely
|
|
101
102
|
large.
|
|
102
103
|
|
|
104
|
+
## `publish:` is a line in the verdict, not a silence
|
|
105
|
+
|
|
106
|
+
Reported from another project, and the report is about this file: an operator asked, after
|
|
107
|
+
many runs, why nothing had ever been published.
|
|
108
|
+
|
|
109
|
+
The floor is right and does not move — publishing is opt-in per project, off by default,
|
|
110
|
+
because an outward act taken from a generic flag is an outward act nobody authorized. The
|
|
111
|
+
gap is what happens next. A project with no configuration produces, run after run,
|
|
112
|
+
retrospective entries carrying lessons about **the skill**, and the mechanism reports
|
|
113
|
+
nothing, because it was never armed. **An unarmed mechanism and a mechanism with nothing
|
|
114
|
+
to say are indistinguishable from the outside** — [`gates.md`](gates.md)'s false success,
|
|
115
|
+
applied to this bundle's own learning path. In the reporting project several runs had
|
|
116
|
+
produced skill-level lessons over months; the count of published insights was zero and no
|
|
117
|
+
gate had ever mentioned it.
|
|
118
|
+
|
|
119
|
+
Stage 10 prints ratchets and two disclosures — what the run declined to claim, and what a
|
|
120
|
+
check never looked at. Publishing is neither, so its absence is not observable at the only
|
|
121
|
+
moment anyone is reading.
|
|
122
|
+
|
|
123
|
+
**So stage 10's block carries one line for publication:**
|
|
124
|
+
|
|
125
|
+
```
|
|
126
|
+
publish: <issue url> — opened this run
|
|
127
|
+
publish: 0 (configured, nothing insight-grade)
|
|
128
|
+
publish: not configured (N insight-grade entries stayed local)
|
|
129
|
+
```
|
|
130
|
+
|
|
131
|
+
It arms nothing and authorizes nothing; it makes the silence legible. A count of zero
|
|
132
|
+
beside *configured* is a fine answer. A **blank** where configuration is absent is how an
|
|
133
|
+
instruction went unread for eight releases.
|
|
134
|
+
|
|
135
|
+
**The failure mode survived its own fix, in a quieter form.** This section once said
|
|
136
|
+
*"open an issue upstream"* while naming no repository, no trigger and no authorization,
|
|
137
|
+
and every reader took it as done. The mechanism that replaced it is correct — and until
|
|
138
|
+
this line existed it still had no way to say it never ran.
|
|
139
|
+
|
|
103
140
|
## Rotation — the archive is how pruning stops losing things
|
|
104
141
|
|
|
105
142
|
At the prune, entries older than the last five run stamps **move** to
|
|
@@ -672,7 +672,12 @@ never that the work was skipped quietly.
|
|
|
672
672
|
string, and the five redaction rules applied
|
|
673
673
|
([`retrospective.md`](retrospective.md) → *What may leave the project*). Absent, the
|
|
674
674
|
step does not exist and is not asked about: publishing to another repository is an
|
|
675
|
-
outward act and silence authorizes none
|
|
675
|
+
outward act and silence authorizes none. **Either way the verdict carries a `publish:`
|
|
676
|
+
line** — the issue url, `0 (configured, nothing insight-grade)`, or `not configured
|
|
677
|
+
(N insight-grade entries stayed local)`: an unarmed path and one with nothing to say
|
|
678
|
+
are otherwise indistinguishable, which is how this instruction went unread for eight
|
|
679
|
+
releases** ([`retrospective.md`](retrospective.md) → *`publish:` is a line in the
|
|
680
|
+
verdict*)**; **the documentation gate has been seen
|
|
676
681
|
failing once against a planted defect and its ratchet counts are printed**
|
|
677
682
|
([`gates.md`](gates.md)); **every repository is closed — the parent included:
|
|
678
683
|
`git submodule status` shows no `+`, each repo clean and pushed**; **every check this gate leans on has been seen failing
|
|
@@ -15,6 +15,7 @@ into this skill; nothing to install.
|
|
|
15
15
|
- Tests that stay honest
|
|
16
16
|
- Stage 6 — consolidation and the suite gate
|
|
17
17
|
- When stuck
|
|
18
|
+
- What a case consumes, and why a timeout is unclassified
|
|
18
19
|
- Rationalizations
|
|
19
20
|
- Red flags — stop and start over
|
|
20
21
|
|
|
@@ -134,6 +135,52 @@ honestly instead.
|
|
|
134
135
|
| Setup is enormous | Extract helpers; if it's still huge, the design is the problem. |
|
|
135
136
|
| Fixing a bug | Write the failing test that reproduces it first. The test proves the fix and prevents the regression. |
|
|
136
137
|
|
|
138
|
+
## What a case consumes, and why a timeout is unclassified
|
|
139
|
+
|
|
140
|
+
Reported from another project after hours spent reading environmental noise as product
|
|
141
|
+
defects. An end-to-end suite registered a fresh account in every case. The product
|
|
142
|
+
rate-limits registration to a handful per minute per address. **A suite of twenty-odd
|
|
143
|
+
cases cannot avoid tripping its own product's limiter.**
|
|
144
|
+
|
|
145
|
+
A throttled registration does not fail loudly. The form never advances, the case sits
|
|
146
|
+
until its own timeout, and it reports **as a timeout** — which reads exactly like
|
|
147
|
+
slowness. Cold compilation, hydration and a stale cache were each investigated and each
|
|
148
|
+
was independently true; none was the cause.
|
|
149
|
+
|
|
150
|
+
**A check that cannot run to completion in its own environment reports noise, and noise
|
|
151
|
+
costs more than silence, because it looks like data.** Silence gets investigated. Noise
|
|
152
|
+
gets interpreted.
|
|
153
|
+
|
|
154
|
+
The neighbouring rule this bundle already has — *a check counts only where it runs* — is
|
|
155
|
+
about **availability**: does the guard execute on the gate. This is about **capacity**:
|
|
156
|
+
the harness is part of the system under test, and a suite that exhausts a production limit
|
|
157
|
+
is measuring the limit.
|
|
158
|
+
|
|
159
|
+
**So at the tests gate, name what each case consumes from the product** — accounts,
|
|
160
|
+
rate-limited endpoints, external quota, seats, tokens — and confirm the suite's total
|
|
161
|
+
stays under the product's own bound. Where it cannot, the suite **shares** the resource
|
|
162
|
+
across cases instead of acquiring it per case.
|
|
163
|
+
|
|
164
|
+
**Where the bound comes from, and what to do when it does not exist.** In order: the
|
|
165
|
+
product's own configuration or code; the provider's documented limit; the operator. Write
|
|
166
|
+
the answer into the brief's source ledger like any other fetched fact — a limit an agent
|
|
167
|
+
remembered is a limit nobody can check. **Where none of the three answers, the row reads
|
|
168
|
+
`bound: unknown` and the count goes to `unlooked`** rather than to a guess: this file's
|
|
169
|
+
whole argument is that an unmeasured resource reports as a timeout, and an unmeasured
|
|
170
|
+
*bound* does the same one level up.
|
|
171
|
+
|
|
172
|
+
**And it does not override *The green from residue*.** That rule is about state a case
|
|
173
|
+
inherits — a database, a volume, a clone — and it still says acquire fresh. This rule is
|
|
174
|
+
about a resource **the product itself meters**. Where the two meet, the product's bound
|
|
175
|
+
wins and the suite shares that one resource while everything else stays fresh; say which
|
|
176
|
+
resource is shared and why.
|
|
177
|
+
|
|
178
|
+
**And a timeout in an end-to-end suite is an unclassified result, not a slow one.** Before
|
|
179
|
+
it is read as a performance signal the resource question above must have an answer, or the
|
|
180
|
+
run is interpreting its own harness. In the reporting project this was also the most
|
|
181
|
+
likely reason that suite had never once finished inside its CI time cap — so the cost was
|
|
182
|
+
not only the hours, it was every defect the suite never got far enough to find.
|
|
183
|
+
|
|
137
184
|
## Rationalizations
|
|
138
185
|
|
|
139
186
|
| Excuse | Reality |
|