task-pipeline-skill 1.100.0 → 1.101.0

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+## v1.101.0 (2026-10-22)
+
+Guards: 530 → **530**; property checks 15 → **15**. No negative was added: the new checks are
+sixteen cases in `test/design_gate_test.py` (75 to 91) and two in
+`test/audit_regressions/diet_retro_budget.py`.
+
+**Cancel parity and one clear offer on every subscription surface** (hub milestone M2, G8 and
+R2, from GP Bullhound's *Consumer Subscription Software*, October 2025, p. 18).
+
+- **`design_gate.py report --subscription`** (or a `subscription` block in the report): the
+  surface sells, renews or cancels a subscription, so the report counts the steps to subscribe
+  and to cancel. Cancelling in more steps fails, a `pass` over a longer cancel path is refused, a
+  paywall without one clear offer fails, a check not walked is NOT_RUN with its reason, and a
+  missing pause is reported, not gated. `agents/design-tester.md` step 7 walks it;
+  `references/design-review.md` and the stage 6 gate in `references/stages.md` state it.
+- **The panel counts locals and tourists** (M2 R3): `design_gate.py panel` requires each
+  retention line to open with `local` or `tourist` and at least two of each, the rule super-ux
+  0.65.0's test panel template states.
+- **One rotation line per archive** (B-151, found as sshlg-skills B-246): `retro_budget.py
+  migrate` re-archives a quarter's earlier rotated stamps with the new ones as one block and
+  keeps one `Rotated out:` line per archive, so a floor that rotates every run no longer grows by
+  a line per run. A line whose block no longer hashes stays as its own line.
+- **Board:** B-044 collapsed into B-040 (the same finding); B-150 files the two fw07 branches
+  kept on purpose.
+- **A test that raced the clock:** `test/lessons_test.py` H1 waited a fixed 1.5 s for a rebuild
+  to reach its read; under a load average near 300 the add ran first and the tagged gate failed
+  on negative 502. The rebuild's read now blocks on a handshake until the add has landed (431
+  cases).
+
 ## v1.100.0 (2026-10-22)
 
 Guards: 530 → **530**; property checks 15 → **15**. No negative was added: the new checks are

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.100.0 |
+| **Version** | 1.101.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, and **one of two browser channels** — `playwright` (CLI or MCP) or `chrome-devtools` (MCP); either satisfies the browser step and neither is required. The engine is WebKit (Safari) first; `chrome-devtools` is Chrome-only, a stated exception. Every stage's doctrine ships in-repo; user-facing stage 3 requires a valid scenario artifact; super-ux is preferred, with equivalent-provider and inline-fallback paths under the provider contract |
 | **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

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

@@ -3,7 +3,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/judgment/manual gates, a frozen requirement spine that closes with evidence, a work board and a verification ledger that outlive a run, an exposure line naming what shipped unconfirmed, a progress rail computed from the project's own config, a proportional short path for small changes, a loop guard whose ceilings stop and record a blocker, 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); a third, `waves`, takes the whole board and closes it in waves that each finish in one pass. Retro insights can publish upstream as issues, opt-in and redacted.",
-  "version": "1.100.0",
+  "version": "1.101.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

package/plugins/task-pipeline/agents/design-tester.md

@@ -49,8 +49,14 @@ Your inputs, and nothing else is yours:
 5. **Close what you opened.** `resource_guard.py close` then `resource_guard.py verify --json`;
    its output is the report's `resources` block. A live process is a failed gate, not a note.
 6. **Gate yourself.** `python3 scripts/design_gate.py report <report> --class <surface_class>
-   --panel docs/ux/test-panel.md --scope <ids> --require design|build`. Quote its output as
-   your first evidence. NOT_RUN is said as NOT_RUN.
+   --panel docs/ux/test-panel.md --scope <ids> --require design|build`, plus `--subscription`
+   when the surface sells, renews or cancels a subscription. Quote its output as your first
+   evidence. NOT_RUN is said as NOT_RUN.
+7. **A subscription surface: walk the way out.** Count the steps from the paywall to an active
+   subscription and from the account to a confirmed cancellation, as one persona, in the same
+   pass. Cancelling takes no more steps than subscribing (California's click-to-cancel rule
+   from 2025-07-01 says the same), the paywall makes one clear offer, and note whether a pause
+   is offered. This is the report's `subscription` block.
 
 ## The report, `design-review/1`
 
@@ -63,9 +69,16 @@ Your inputs, and nothing else is yours:
                       "focus": "pass", "states": "na", "text_fit": "pass", "outcome": "pass"},
            "findings": [{"severity": "breaks", "what": "no way back from the summary",
                          "where": "summary screen", "status": "open"}]}],
- "resources": {"started": [], "live": [], "closed": true}}
+ "resources": {"started": [], "live": [], "closed": true},
+ "subscription": {"cancel_parity": "pass", "subscribe_steps": 3, "cancel_steps": 2,
+                  "cancel_path": "Settings > Subscription > Cancel", "single_offer": "pass",
+                  "pause": "offered"}}
 ```
 
+`subscription` is present only on a subscription surface. `cancel_parity` and `single_offer` are
+pass, fail or NOT_RUN (with `reason`); `pause` is offered, absent or na. A `pass` over a cancel
+path longer than the subscribe path is refused.
+
 `breaks` stops the user in a scenario step or contradicts the scenario's outcome. `risk` makes a
 step slower, unclear or easy to get wrong. `nit` is polish. Taste is none of them: a finding
 names the step, the persona and the checklist item it failed.

package/plugins/task-pipeline/skills/task-pipeline/references/design-review.md

@@ -26,9 +26,11 @@ unmentioned one does not. Waves and iterations owe it per UI node, never once pe
 `docs/ux/test-panel.md`, owned by super-ux (`ux-foundation` → *The test panel*): ten portraits,
 each with **basis** (`evidence RE-NN` or `hypothesis`), **situation**, **goals**, **features**,
 **scenarios** (composite chains by `SCR-` id), **activation** (steps to first value, and where
-it drops), **retention** (trigger → action → reward → what brings it back) and **needs**
-(device, engine, locale, accessibility). The operator confirms it once; a later change of the
-product revises it. `python3 scripts/design_gate.py panel docs/ux/test-panel.md` gates it.
+it drops), **retention** (opening with `local` or `tourist`, then trigger → action → reward →
+what brings it back) and **needs** (device, engine, locale, accessibility). At least two
+portraits are locals and two are tourists: lifetime value rests on the first, churn on the
+second (since 1.101.0). The operator confirms it once; a later change of the product revises
+it. `python3 scripts/design_gate.py panel docs/ux/test-panel.md` gates it.
 
 A portrait marked `hypothesis` chooses what to test, never what to build: the super-ux rule
 that a synthetic persona is never evidence still holds.
@@ -47,6 +49,16 @@ finding; a `breaks` finding names its failed item. NOT_RUN is never PASS.
 With Figma, pass D judges what the designer drew and pass B how it was built against it.
 Without Figma, pass D judges the mockups and pass B the build against them.
 
+## A subscription surface: cancel parity and one clear offer
+
+A surface that sells, renews or cancels a subscription (paywall, trial, pricing, cancel) adds
+`--subscription` to both gates. The report's `subscription` block counts the steps to subscribe
+and to cancel, walked by one persona in the same pass: cancelling takes no more steps than
+subscribing (the click-to-cancel standard, law in California from 2025-07-01), the paywall makes
+one clear offer, and whether a pause is offered is noted. A missing block, a longer cancel path
+or a paywall without one offer fails; a check not walked is NOT_RUN with its reason; a missing
+pause is reported, not gated. The block's fields are in `agents/design-tester.md`.
+
 ## The budget, and where findings go
 
 One pass D and one pass B per surface per round; a re-review reads only the steps the fix

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

@@ -208,7 +208,11 @@ narrative are how a capped list grows anyway.
   An older retro whose standing instructions are a numbered list and whose stamps are
   `- **date: title**` items is read the same way: the item keeps its bold rule and its
   `*(Retire ...)*` trigger, a stamp keeps its title, stamps past the cap rotate out by date,
-  and, over budget, the Run stamps section's loose prune paragraphs move.
+  and, over budget, the Run stamps section's loose prune paragraphs move. Rotation keeps
+  **one `Rotated out:` line per archive**: a later rotation re-archives the quarter's
+  earlier rotated stamps with its own as one block and the line names that block, so a
+  floor that rotates every run does not grow by a line per run. A line whose block no
+  longer hashes stays as its own line.
 - **A prune that retires nothing writes its count into the stamp row**, as
   `prune: 0 retired`, and no paragraph. Repeated "nothing to prune" notes were a
   measured share of the floor.

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

@@ -308,7 +308,9 @@ never that the work was skipped quietly.
   **On any class but `none` the design review's pass B ran over the build** (since
   1.100.0): the same `design_gate.py report` with `--require build` exits 0, every capture
   names its engine, and `python3 scripts/resource_guard.py verify <ledger>` is clean
-  ([`design-review.md`](design-review.md)).
+  ([`design-review.md`](design-review.md)). A subscription surface (paywall, trial, pricing,
+  cancel) adds `--subscription`: cancelling takes no more steps than subscribing and the
+  paywall makes one clear offer (since 1.101.0).
 - **What the look finds is fixed here.** A rendering defect found at stage 6 is a
   stage-6 finding: fix it, look again, then call the stage green. Filing it to the
   board and advancing is how a run reports *checked in a browser* for a page it has

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

@@ -6,14 +6,18 @@ with an exit code. Stdlib only.
         the test panel the design-tester walks: ten portraits (or --min), each with its
         basis, situation, goals, features, composite scenarios, activation funnel,
         retention loop and needs. A portrait without a basis line is refused: a panel is a
-        hypothesis instrument, and saying so is part of the portrait.
+        hypothesis instrument, and saying so is part of the portrait. Each retention line
+        opens with `local` or `tourist`, and the panel holds at least two of each (1.101.0).
     design_gate.py report <design-review.json> --class <surface_class>
                           [--panel <test-panel.md>] [--scope SCR-01,SCR-02] [--require build]
-                          [--max-passes 1] [--json]
+                          [--max-passes 1] [--subscription] [--json]
         stage 3 (`--require design`) and stage 6 (`--require build`): the report covers
         every scope scenario × every panel persona that uses it, every step carries the
         full checklist, no `breaks` finding is open, each round holds at most --max-passes
         passes of each kind, and the resource receipt shows every process it started closed.
+        `--subscription` (or a `subscription` block in the report): the surface sells, renews
+        or cancels a subscription, so cancelling takes no more steps than subscribing and the
+        paywall makes one clear offer (1.101.0).
 
     design_gate.py browser <pipeline.json> [--repo DIR] [--json]
         the recorded test browser: `browser.primary` is set (NOT_RUN when the block is
@@ -52,6 +56,7 @@ ALIASES = {"composite scenarios": "scenarios", "activation funnel": "activation"
 FIELD = re.compile(r"^\s*[-*]\s+\*\*(%s)\s*:?\*\*\s*[:—–-]?\s*(.+?)\s*$"
                    % "|".join(sorted(list(FIELDS) + list(ALIASES), key=len, reverse=True)), re.I)
 SCR = re.compile(r"\bSCR-\d+\b")
+SEGMENT = re.compile(r"^\s*(local|tourist)\b\s*:?", re.I)
 
 
 def read_text(path):
@@ -110,6 +115,17 @@ def panel_problems(panel, minimum):
             out.append("%s: basis is `evidence RE-NN` or `hypothesis`, not %r" % (pid, basis[:40]))
         if p.get("scenarios") and not SCR.search(p["scenarios"]):
             out.append("%s: composite scenarios cite no SCR- id" % pid)
+    # M2 R3 (1.101.0): lifetime value rests on locals and churn on tourists, so the panel
+    # walks both. The retention line opens with the segment (super-ux templates/test-panel.md).
+    seg = {pid: SEGMENT.match(p.get("retention", "")) for pid, p in panel.items()}
+    for pid, m in sorted(seg.items()):
+        if panel[pid].get("retention") and not m:
+            out.append("%s: the retention line opens with `local` or `tourist`" % pid)
+    locals_ = sum(1 for m in seg.values() if m and m.group(1).lower() == "local")
+    tourists = sum(1 for m in seg.values() if m and m.group(1).lower() == "tourist")
+    if panel and (locals_ < 2 or tourists < 2):
+        out.append("the panel carries %d local%s and %d tourist%s; it owes at least two of each"
+                   % (locals_, "" if locals_ == 1 else "s", tourists, "" if tourists == 1 else "s"))
     return out
 
 
@@ -174,10 +190,52 @@ def row_problems(r, i):
     return out
 
 
-def report_check(doc, surface_class, panel=None, scope=(), require=None, max_passes=1):
+PARITY = ("pass", "fail", "NOT_RUN")
+PAUSE = ("offered", "absent", "na")
+
+
+def subscription_problems(sub):
+    """M2 G8/R2: cancelling is as easy as subscribing, and the paywall makes one clear offer.
+    Returns (problems, notes, not_run)."""
+    if sub is None:
+        return (["a subscription surface carries its cancel parity check (`subscription` block: "
+                 "cancel_parity, subscribe_steps, cancel_steps, single_offer, pause)"], [], False)
+    if not isinstance(sub, dict):
+        return ["`subscription` is an object, not %r" % (sub,)], [], False
+    out, notes = [], []
+    for k in ("cancel_parity", "single_offer"):
+        if sub.get(k) not in PARITY:
+            out.append("subscription.%s is %r, not one of %s" % (k, sub.get(k), "/".join(PARITY)))
+    steps = {k: _posint(sub.get(k)) for k in ("subscribe_steps", "cancel_steps")}
+    for k, v in steps.items():
+        if v is None and sub.get("cancel_parity") != "NOT_RUN":
+            out.append("subscription.%s is a positive integer, not %r" % (k, sub.get(k)))
+    s, c = steps["subscribe_steps"], steps["cancel_steps"]
+    if sub.get("cancel_parity") == "fail":
+        out.append("cancelling takes %s steps against %s to subscribe: cancel parity fails" % (c, s))
+    elif sub.get("cancel_parity") == "pass" and s and c and c > s:
+        out.append("cancel_parity `pass` contradicts %d cancel steps against %d to subscribe" % (c, s))
+    if sub.get("single_offer") == "fail":
+        out.append("the paywall makes no single clear offer")
+    if sub.get("pause") not in PAUSE:
+        out.append("subscription.pause is offered, absent or na, not %r" % (sub.get("pause"),))
+    elif sub.get("pause") == "absent":
+        notes.append("no pause offered on the cancel path (a save offer, not gated)")
+    idle = [k for k in ("cancel_parity", "single_offer") if sub.get(k) == "NOT_RUN"]
+    if idle and not sub.get("reason"):
+        out.append("a NOT_RUN %s carries its reason" % " and ".join(idle))
+    return out, notes, bool(idle)
+
+
+def report_check(doc, surface_class, panel=None, scope=(), require=None, max_passes=1, subscription=False):
     problems, notes = [], []
     if not isinstance(doc, dict) or doc.get("schema") != "design-review/1":
         return "FAIL", ["the report is not design-review/1"], notes
+    sub_idle = False
+    if subscription or "subscription" in doc:
+        sp, sn, sub_idle = subscription_problems(doc.get("subscription"))
+        problems += sp
+        notes += sn
     rows = doc.get("rows") or []
     if not isinstance(rows, list) or any(not isinstance(r, dict) for r in rows):
         return "FAIL", ["`rows` is a list of objects"], notes
@@ -252,6 +310,8 @@ def report_check(doc, surface_class, panel=None, scope=(), require=None, max_pas
             return "NOT_RUN", ["every %s step is NOT_RUN: the %s pass did not run" % (k, k)], notes
         if k in kinds and not mine:
             return "NOT_RUN", ["no %s step in the report" % k], notes
+    if sub_idle:
+        return "NOT_RUN", ["the subscription checks were not walked: %s" % doc["subscription"].get("reason")], notes
     partial = ["%s step %s for %s (%s)" % (r.get("scenario"), r.get("step"), r.get("persona"), r.get("reason", "no reason"))
                for r in rows if any(v == "NOT_RUN" for v in (r.get("checks") or {}).values())]
     if partial:
@@ -322,6 +382,8 @@ def main(argv=None):
     p2.add_argument("--scope", default="")
     p2.add_argument("--require", choices=PASSES)
     p2.add_argument("--max-passes", type=int, default=1)
+    p2.add_argument("--subscription", action="store_true",
+                    help="the surface sells, renews or cancels a subscription: cancel parity and one clear offer are owed")
     p2.add_argument("--json", action="store_true")
     a = ap.parse_args(argv)
     if a.cmd == "panel":
@@ -354,7 +416,7 @@ def main(argv=None):
         return 2
     panel = parse_panel(read_text(a.panel)) if a.panel and os.path.exists(a.panel) else None
     scope = [s.strip() for s in a.scope.split(",") if s.strip()]
-    verdict, probs, notes = report_check(doc, a.cls, panel, scope, a.require, a.max_passes)
+    verdict, probs, notes = report_check(doc, a.cls, panel, scope, a.require, a.max_passes, a.subscription)
     return emit(verdict, probs, notes, a.json)
 
 

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

@@ -252,6 +252,32 @@ def block(kind, label, text):
                % (datetime.date.today().isoformat(), kind, label, h, text))
 
 
+ROTATED = re.compile(r"^Rotated out: ([0-9]+) oldest run stamps, verbatim in (\S+) sha256:([0-9a-f]{12,64})$")
+ARCHIVED = re.compile(r"<!-- sha256:([0-9a-f]{64}) -->\n(.*?)\n(?=\n#{2,3} |\Z)", re.S)
+
+
+def rotation_lines(lines, span, rel):
+    """(line index, stamp count, short sha) of each rotation pointer into `rel`."""
+    out = []
+    for k in range(span[0], span[1]):
+        r = ROTATED.match(lines[k])
+        if r and r.group(2) == rel:
+            out.append((k, int(r.group(1)), r.group(3)))
+    return out
+
+
+def archived_text(path, short):
+    """(offset, text) of the archive block whose text hashes to `short`, or None."""
+    try:
+        arch = read(path)
+    except Unmeasurable:
+        return None
+    for m in ARCHIVED.finditer(arch):
+        if m.group(1).startswith(short) and digest(m.group(2)) == m.group(1):
+            return m.start(), m.group(2)
+    return None
+
+
 def cmd_check(a):
     m = measure(read(a.retro), a.budget, a.row, a.stamp)
     print(summary(m, a.row, a.stamp))
@@ -332,11 +358,28 @@ def cmd_migrate(a):
                     j += 1
                 if all((r, r + 1) in rotated for r in range(k + 2, j)):
                     moved.append((k, k + 2, [], None, None))   # archived above, with its rows
-            h, b = block("stamps", "%d oldest rotated" % len(rotated), text)
+            # B-246: one pointer line per archive, not one per rotation. Earlier rotations
+            # into the same archive are re-archived with this one as a single block, and
+            # their lines give way to one line naming it. The archive stays append-only:
+            # the earlier blocks remain, only the floor stops pointing at them.
+            count, earlier = len(rotated), []
+            for k, n, short in rotation_lines(lines, m["spans"][STAMPS], rel):
+                prior = archived_text(archive, short)
+                if prior is None:
+                    print("migrate: the rotation line sha256:%s does not resolve in %s; "
+                          "it stays as its own line" % (short, rel))
+                    continue
+                earlier.append((prior[0], k, prior[1]))
+                count += n
+            for _, k, _ in earlier:
+                moved.append((k, k + 1, [], None, None))
+            if earlier:
+                text = "\n".join([t for _, _, t in sorted(earlier)] + [text])
+            h, b = block("stamps", "%d oldest rotated" % count, text)
             for sp in rotated:
                 moved.append((sp[0], sp[1], [], None, None))
             notes.append(("Rotated out: %d oldest run stamps, verbatim in %s sha256:%s"
-                          % (len(rotated), rel, h[:12]), b, "%d oldest run stamps rotated" % len(rotated)))
+                          % (count, rel, h[:12]), b, "%d oldest run stamps rotated" % len(rotated)))
     for sp in m["stm"]:
         i = sp[0]
         if sp in rotated or len("\n".join(lines[sp[0]:sp[1]])) <= a.stamp:
@@ -502,7 +545,7 @@ def verify(retro):
             bad.append("sha256:%s points at %s, which does not exist" % (short, rel))
             continue
         ok = False
-        for m in re.finditer(r"<!-- sha256:([0-9a-f]{64}) -->\n(.*?)\n(?=\n#{2,3} |\Z)", arch, re.S):
+        for m in ARCHIVED.finditer(arch):
             if m.group(1).startswith(short) and digest(m.group(2)) == m.group(1):
                 ok = True
                 break