@r1z4x/tezgah 1.9.2 → 1.11.0

package/bin/tezgah-setup

@@ -188,7 +188,7 @@ LOCAL_BIN = os.path.join(HOME, ".local", "bin")
 SKILLS = ["harness", "tezgah-contract", "ponytail", "i-have-adhd", "no-ai-slop",
           "analyze-app", "plan-add", "plan-status", "plan-sync", "research",
           "product-analysis", "product-flow", "feature-audit", "design-contract",
-          "design-library", "pm-frameworks", "ai-research", "rl-env"]
+          "design-library", "hallmark", "pm-frameworks", "ai-research", "rl-env"]
 
 
 def skills_linked(base):
@@ -209,6 +209,19 @@ RESEARCH_SKILLS = frozenset(("ai-research", "rl-env"))
 # explicit value wins.
 OPENCODE_IGNORE = [".git/**", "node_modules/**", "dist/**", "build/**",
                    ".venv/**", "__pycache__/**", ".ruff_cache/**"]
+
+
+def opencode_v2():
+    """opencode 2 keeps its terminal settings in cli.json (it migrates tui.json
+    into it once, on first start) and ignores tui.json afterwards."""
+    return os.path.isfile(os.path.join(OPENCODE, "cli.json"))
+
+
+# The opencode 2 status line: a link to the plugin directory hosts/opencode/tui/cli,
+# listed in cli.json `plugins` as file://<this path>.
+OPENCODE_CLI_PLUGIN = os.path.join(OPENCODE, "tui-plugins", "tezgah-cli")
+
+
 WORKFLOW_FILES = ["graph-map.js", "graph-review.js", "graph-impact.js"]
 ALL_HOSTS = ["claude", "codex", "opencode", "cursor", "dsh", "omp"]
 # orx ships an installable skill shim for four agents; dsh has no orx harness,
@@ -231,7 +244,8 @@ MATERIALISED = os.path.join(tp.CONFIG_DIR, "materialised")
 # copies die with ~/.config/tezgah; the pre-multi-host setup wrote them to
 # ~/.claude, which OFF_DIRS still honors, so a full uninstall sweeps those by
 # name too - a switch left behind is a rule that stays silent with no file saying why.
-OFF_SWITCH_NAMES = ("adhd-off", "agents-off", "consult-off", "docs-judge-off", "exec-mode.off",
+OFF_SWITCH_NAMES = ("adhd-off", "agents-off", "consult-off", "design-off", "docs-judge-off",
+                    "exec-mode.off",
                     "judge-off", "lang-off", "orchestrate-off", "ponytail-auto.off",
                     "pretooluse-off", "reminder-off", "research-off", "slices-off",
                     "spec-off", "task-off", "triage-off", "update-check-off", "verify-off",
@@ -1039,7 +1053,10 @@ def install_common(new_roots, hosts):
         (tp.roots() or [tp.DEFAULT_ROOT])
     if tp.codegraph_bin():
         cfg["codegraph_bin"] = tp.codegraph_bin()
-    cfg["hosts"] = hosts
+    # merged with the record, never replaced: arming one host must not drop
+    # the others, whose wiring stays on disk and which --upgrade reads from here
+    recorded = cfg.get("hosts") if isinstance(cfg.get("hosts"), list) else []
+    cfg["hosts"] = recorded + [h for h in hosts if h not in recorded]
     # The resolved selection, written beside roots/hosts: the next run reads one
     # persisted answer instead of the flags some earlier run happened to carry,
     # which is what lets --disable mean anything. A key absent here (and in the
@@ -1090,6 +1107,8 @@ def install_common(new_roots, hosts):
             ("tezgah-route", os.path.join(HERE, "bin", "tezgah-route")),
             ("tezgah-lessons", os.path.join(HERE, "bin", "tezgah-lessons")),
             ("tezgah-skill", os.path.join(HERE, "bin", "tezgah-skill")),
+            ("tezgah-review-quote", os.path.join(HERE, "bin", "tezgah-review-quote")),
+            ("tezgah-ocr-review", os.path.join(HERE, "bin", "tezgah-ocr-review")),
             # `tezgah` is this installer under the name `tezgah update` is typed
             # with (npm ships the same name). Not here on purpose: tezgah-dsh
             # (wired as ~/.local/bin/dsh, see dsh_launcher) and
@@ -1647,6 +1666,11 @@ def skill_description(path):
     else:
         inline = re.search(r"description:\s*(.+)", block.group(1))
         desc = inline.group(1).strip().strip("\"'") if inline else ""
+    return _trigger_line(desc)
+
+
+def _trigger_line(desc):
+    """The sentence of `desc` carrying its `Use when ...` trigger, cut at 140."""
     desc = re.sub(r"\s+", " ", desc).strip()
     sentences = re.split(r"(?<=[.!?])\s+", desc)
     line = next((s for s in sentences if re.match(r"(?:Also )?[Uu]se\b", s)),
@@ -1654,6 +1678,22 @@ def skill_description(path):
     return line[:137].rstrip() + "..." if len(line) > 140 else line
 
 
+def skill_when_line(path):
+    """The trigger line of a SKILL.md body's `## When to use` first paragraph.
+
+    The frontmatter description is a short bilingual trigger list now, too short
+    for two near-neighbours to share subject words; the long text it replaced
+    opens the body's `## When to use`, and that is what still tells them apart.
+    Best effort like skill_description: anything unreadable yields ""."""
+    try:
+        with open(path, encoding="utf-8", errors="replace") as fh:
+            text = fh.read()
+    except OSError:
+        return ""
+    para = re.search(r"^## When to use\n\s*\n(.*?)(?:\n\s*\n|\Z)", text, re.M | re.S)
+    return _trigger_line(para.group(1)) if para else ""
+
+
 def skill_category(name, path=""):
     if name in RESEARCH_SKILLS:
         return "research & papers"
@@ -1734,12 +1774,12 @@ under out up down off again more most other some such only own same too very can
 will just don should now read reads reading use used uses using also one two
 three every each any all both new old
 """.split())
-# Two skills a session could pick either way from: their router lines share this
-# many subject words, so the description alone cannot settle the choice. Three is
-# where the shipped set stops pairing near-neighbours - `plan-add` / `plan-status`
-# / `plan-sync` share four terms and `product-analysis` / `feature-audit` three,
-# while at two `harness` / `no-ai-slop` pair over "asks, user" and the section
-# reads as noise.
+# Two skills a session could pick either way from: the trigger lines of their
+# `## When to use` share this many subject words, so the description alone
+# cannot settle the choice. Three is where the shipped set pairs near-neighbours -
+# `plan-add` / `plan-status` / `plan-sync` share four or five terms,
+# `product-analysis` / `feature-audit` and `design-contract` / `design-library`
+# three - while `ponytail` / `i-have-adhd` stay apart.
 COLLISION_SHARED = 3
 
 
@@ -1758,7 +1798,7 @@ def skill_collisions(groups):
     router is what a session picks from when the descriptions tie. It reads the
     shipped names only: a vendored library's internal collisions are its own
     index's business, and a pair tezgah cannot rename is not a tezgah decision."""
-    lines = {name: skill_description(path)
+    lines = {name: skill_when_line(path)
              for cat in ROUTER_ORDER for name, path in groups[cat]
              if name in SKILLS}
     names = sorted(lines)
@@ -1778,7 +1818,8 @@ def _collision_section(pairs):
     out = [
         "## Collisions",
         "",
-        "Pairs a description alone cannot settle: both router lines carry the"
+        "Pairs a description alone cannot settle: both entries' `## When to use`"
+        " lines carry the"
         " words below, so a session could pick either way from them. Read both"
         " entries before choosing.",
         "",
@@ -1856,20 +1897,38 @@ def install_opencode():
     write_artifact(SKILL_ROUTER_FULL, full, write_if_changed)
     print("%s %s (always-on, %d chars)" % (OK, SKILL_ROUTER, len(always)))
     print("%s %s (on demand, %d chars)" % (OK, SKILL_ROUTER_FULL, len(full)))
-    # TUI status line: opencode has no command statusLine, only a TUI plugin
-    # declared in tui.json. Local path spec resolves relative to tui.json.
-    print(link(os.path.join(HERE, "hosts", "opencode", "tui", "tezgah-tui.tsx"),
-               os.path.join(OPENCODE, "tui-plugins", "tezgah-tui.tsx")))
-    tpath = os.path.join(OPENCODE, "tui.json")
-    tui = read_config(tpath, {"$schema": "https://opencode.ai/tui.json"})
-    if tui is not None:
-        plugins = tui.get("plugin") or []
-        spec = "./tui-plugins/tezgah-tui.tsx"
-        if spec not in [p if isinstance(p, str) else p[0] for p in plugins]:
-            plugins.append(spec)
-        tui["plugin"] = plugins
-        write_json(tpath, tui)
-        print("%s tui.json (status line plugin)" % OK)
+    # TUI status line: opencode has no command statusLine, only a TUI plugin.
+    # opencode 1 declares it in tui.json (a local spec resolves relative to it);
+    # opencode 2 ignores tui.json and lists CLI plugins in cli.json `plugins`. A
+    # local v2 entry must name a DIRECTORY whose `tui` module default-exports
+    # Plugin.define({id, setup}) - a spec naming a file is skipped (measured on
+    # v2.0.32) - so the directory hosts/opencode/tui/cli is what gets linked.
+    v2 = opencode_v2()
+    if v2:
+        dst = OPENCODE_CLI_PLUGIN
+        print(link(os.path.join(HERE, "hosts", "opencode", "tui", "cli"), dst))
+        cpath = os.path.join(OPENCODE, "cli.json")
+        cli = read_config(cpath, {})
+        if cli is not None:
+            plugins = cli.get("plugins") or []
+            if "file://" + dst not in plugins:
+                plugins.append("file://" + dst)
+            cli["plugins"] = plugins
+            write_json(cpath, cli)
+            print("%s cli.json (status line plugin)" % OK)
+    else:
+        print(link(os.path.join(HERE, "hosts", "opencode", "tui", "tezgah-tui.tsx"),
+                   os.path.join(OPENCODE, "tui-plugins", "tezgah-tui.tsx")))
+        tpath = os.path.join(OPENCODE, "tui.json")
+        tui = read_config(tpath, {"$schema": "https://opencode.ai/tui.json"})
+        if tui is not None:
+            plugins = tui.get("plugin") or []
+            spec = "./tui-plugins/tezgah-tui.tsx"
+            if spec not in [p if isinstance(p, str) else p[0] for p in plugins]:
+                plugins.append(spec)
+            tui["plugin"] = plugins
+            write_json(tpath, tui)
+            print("%s tui.json (status line plugin)" % OK)
     cfg = read_config(os.path.join(OPENCODE, "opencode.json"),
                       {"$schema": "https://opencode.ai/config.json"})
     if cfg is None:
@@ -1921,7 +1980,8 @@ def install_opencode():
     # Context hygiene: prune replaces old tool results in the prompt with
     # "[Old tool result content cleared]" so a long session stops re-sending
     # every output on every step. setdefault keeps a user's explicit choice.
-    cfg.setdefault("compaction", {}).setdefault("prune", True)
+    if not v2:  # opencode 2 omits it as an unsupported legacy setting
+        cfg.setdefault("compaction", {}).setdefault("prune", True)
     wat = cfg.setdefault("watcher", {})
     ign = wat.setdefault("ignore", [])
     for pat in OPENCODE_IGNORE:
@@ -1929,7 +1989,8 @@ def install_opencode():
             ign.append(pat)
     changed = write_json(os.path.join(OPENCODE, "opencode.json"), cfg)
     print("%s opencode.json (instructions + skill router + mcp + skill deny)" % OK)
-    print("%s opencode.json (compaction.prune + watcher.ignore)" % OK)
+    print("%s opencode.json (%swatcher.ignore)"
+          % (OK, "" if v2 else "compaction.prune + "))
     if changed or dropped:
         restart_hint("opencode", os.path.join(OPENCODE, "opencode.json"))
 
@@ -2945,6 +3006,20 @@ def _run_bounded(argv, timeout):
         except OSError:
             pass
         proc.wait()
+        # a member mid-fork as the kill swept the group can come out of the
+        # fork unsignalled (macOS under load: the orphan held the caller's
+        # pipes, plan 115), so signal the group again until it is empty. Each
+        # round catches what forked since the last and a healthy group is gone
+        # within a few; the 2 s cap only bounds one that will not die (a member
+        # stuck in uninterruptible I/O, a zombie nobody reaps) so the Ctrl-C
+        # still returns.
+        deadline = time.monotonic() + 2
+        while time.monotonic() < deadline:
+            try:
+                os.killpg(proc.pid, signal.SIGKILL)
+            except OSError:  # ESRCH: nothing left in the group
+                break
+            time.sleep(0.01)
         raise
 
 
@@ -3363,9 +3438,12 @@ def verify_uninstall(hosts, full):
     if "opencode" in hosts:
         claim("opencode plugin unlinked",
               [os.path.join(OPENCODE, d, "tezgah.js") for d in ("plugins", "plugin")]
-              + [os.path.join(OPENCODE, "tui-plugins", "tezgah-tui.tsx")])
+              + [os.path.join(OPENCODE, "tui-plugins", n)
+                 for n in ("tezgah-tui.tsx", "tezgah-cli")])
         clean("opencode opencode.json unwired",
               [os.path.join(OPENCODE, "opencode.json")])
+        clean("opencode cli.json unwired", [os.path.join(OPENCODE, "cli.json")],
+              needle=OPENCODE_CLI_PLUGIN)
         claim("opencode generated routers gone", [SKILL_ROUTER, SKILL_ROUTER_FULL])
     if "cursor" in hosts:
         clean("cursor hooks.json unwired", [os.path.join(CURSOR, "hooks.json")])
@@ -3499,6 +3577,14 @@ def unwire_opencode_config():
                 tj.pop("plugin", None)
             write_json(t, tj)
             print("%s removed tezgah TUI plugin from %s" % (OK, t))
+    cp = os.path.join(OPENCODE, "cli.json")
+    cj = read_json(cp, None)
+    if cj and isinstance(cj.get("plugins"), list):
+        kept = [x for x in cj["plugins"] if x != "file://" + OPENCODE_CLI_PLUGIN]
+        if kept != cj["plugins"]:
+            cj["plugins"] = kept
+            write_json(cp, cj)
+            print("%s removed tezgah CLI plugin from %s" % (OK, cp))
 
 
 def uninstall_claude():
@@ -3560,7 +3646,8 @@ def uninstall_opencode():
         unlink_tezgah(os.path.join(OPENCODE, "skills", s))
     for d in ("plugins", "plugin"):
         unlink_tezgah(os.path.join(OPENCODE, d, "tezgah.js"))
-    unlink_tezgah(os.path.join(OPENCODE, "tui-plugins", "tezgah-tui.tsx"))
+    for name in ("tezgah-tui.tsx", "tezgah-cli"):
+        unlink_tezgah(os.path.join(OPENCODE, "tui-plugins", name))
     unwire_opencode_config()
     for path in (SKILL_ROUTER, SKILL_ROUTER_FULL):
         try:
@@ -3714,6 +3801,13 @@ def uninstall(hosts, dry_run=False):
         remove_install_tree()
     elif armed:
         rest = sorted(set(armed) - set(hosts))
+        # install_common only ever merges into the record, so this is the one
+        # place a host leaves it; kept, it made every later uninstall partial
+        # and `tezgah update` re-armed it from the record
+        cfg = read_config(tp.CONFIG, {})
+        if cfg is not None:
+            cfg["hosts"] = [h for h in armed if h in rest]
+            write_json(tp.CONFIG, cfg)
         print("\n%s still armed: %s keeps its config and the install tree"
               % (NO, ", ".join(rest)))
     remaining = verify_uninstall(hosts, full)
@@ -4376,6 +4470,8 @@ def report(hosts):
         ("codegen provider key (OpenRouter, DeepSeek or Inception)",
          tp.have_provider_key()),
         ("orx on PATH (OpenResearch research routing)", bool(tp.orx_bin())),
+        ("ocr on PATH (open-code-review spec for the reviewer, opt-in)",
+         bool(tp.ocr_bin())),
         ("npx on PATH (app-analysis MCP servers)", bool(shutil.which("npx"))),
         ("app artifacts dir %s" % tezgah_apps.ARTIFACTS,
          os.path.isdir(tezgah_apps.ARTIFACTS)),
@@ -4694,6 +4790,7 @@ def host_checks_codex():
 def host_checks_opencode():
     cfg = read_json(os.path.join(OPENCODE, "opencode.json"), {})
     tui = read_json(os.path.join(OPENCODE, "tui.json"), {})
+    cli = read_json(os.path.join(OPENCODE, "cli.json"), {})
     instr = cfg.get("instructions") or []
     specs = [p if isinstance(p, str) else p[0] for p in (tui.get("plugin") or [])]
     return [
@@ -4711,14 +4808,20 @@ def host_checks_opencode():
     ] + mcp_rows(set(cfg.get("mcp") or {}), "opencode.json") + [
         mcp_row(TEZGAH_MCP_NAME, (cfg.get("mcp") or {}).get(TEZGAH_MCP_NAME),
                 "opencode.json", tezgah_mcp_command()),
+    ] + ([
+        ("status line plugin in cli.json + linked",
+         "file://" + OPENCODE_CLI_PLUGIN in (cli.get("plugins") or [])
+         and os.path.exists(OPENCODE_CLI_PLUGIN)),
+    ] if opencode_v2() else [
         ("context pruning armed (compaction.prune)",
          (cfg.get("compaction") or {}).get("prune") is True),
-        ("watcher ignores noisy trees",
-         bool(set(OPENCODE_IGNORE)
-              & set(((cfg.get("watcher") or {}).get("ignore") or [])))),
         ("status line plugin in tui.json + linked",
          any("tezgah-tui" in s for s in specs)
          and os.path.exists(os.path.join(OPENCODE, "tui-plugins", "tezgah-tui.tsx"))),
+    ]) + [
+        ("watcher ignores noisy trees",
+         bool(set(OPENCODE_IGNORE)
+              & set(((cfg.get("watcher") or {}).get("ignore") or [])))),
         # opencode's own registry declares INCEPTION_API_KEY for the inception
         # provider, so nothing needs adding to opencode.json - but the route is
         # only usable once a key resolves, and that is what this reports.
@@ -5923,7 +6026,7 @@ def hosts_row():
     host's first HOST_CHECKS row), as one report row. Reported, never changed:
     `--upgrade`, `--enable`/`--disable` and a full uninstall act on the recorded
     list, so a host wired but not recorded is one they skip, and which list is
-    right is the user's call (`--install --hosts ...` records it)."""
+    right is the user's call (`--install --hosts ...` adds to it)."""
     recorded = sorted(tp.config().get("hosts") or [])
     wired = sorted(h for h in ALL_HOSTS if HOST_CHECKS[h]()[0][1])
     return ("config.json hosts (%s) match the hosts wired (%s)"

package/bin/tezgah-skill

@@ -25,7 +25,7 @@ import json
 import os
 import sys
 
-HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+HERE = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
 sys.path.insert(0, os.path.join(HERE, "hooks"))
 import tezgah_skill_pick as sp  # noqa: E402
 

package/bin/tezgah-status

@@ -29,6 +29,22 @@ their status line; this CLI is how every host (and a human) gets it:
                            The MCP half of a retirement decision is manual:
                            `tezgah-setup --mcp-schemas` measures what a server
                            costs, this counts what it fires.
+  tezgah-status --rates --since DATE --until DATE [--json]
+                           every real ledger's rows in [since, until), folded per
+                           window and per calendar day: turns, `claim` rows and
+                           the Stop classes that blocked them, the shape flags
+                           every judged reply carried, denies by rule, and the
+                           rates (blocks per 100 turns, denies per 100 sessions,
+                           the claim block and Stop shape shares, blocked claims
+                           per 100 sessions by class). A repeated `--since`/
+                           `--until` pair prints one block each and the pp delta
+                           between adjacent windows - the unit plan 066's 056 row
+                           states its bar in. A window that read more than one
+                           row contract prints the split, and a delta across two
+                           contracts says so (plan 135). `--json` prints
+                           `{"windows": [...]}`.
+                           `--until` is exclusive, so adjacent windows partition
+                           their span.
   tezgah-status --skill-fitness
                            per shipped skill, over the recorded sessions: how
                            many opened it and which were never opened. A
@@ -78,6 +94,16 @@ their status line; this CLI is how every host (and a human) gets it:
                            the set renders as dim "no state" instead of claiming
                            "armed, not used yet". A host that cannot see a skill
                            read (dsh) passes the tool-use four.
+  tezgah-status --manifest=FILE
+                           read the repository extension from FILE instead of
+                           the `.tezgah/extension.json` discovered from PATH (a
+                           manifest outside the tree, e.g. an engagement's).
+                           With `statusline.override: true` in the manifest the
+                           project owns its line and points its own statusLine
+                           here: the host's status-line payload on stdin (its
+                           `cwd`/`workspace.current_dir` and `session_id`) is
+                           read when no PATH is given, so this is the only line
+                           and it keeps the built-in marks and the chips.
 
 The session id may be passed as the second argument or via TEZGAH_SESSION;
 without it the "used" marks cannot light up, so a host that knows the id should
@@ -97,6 +123,26 @@ from tezgah_context import (  # noqa: E402
 # the line and `--json` carries every row, so a reader can always see what was
 # cut.
 TOP = 15
+# The host payload an override reads on stdin: a status-line host writes one
+# small JSON object and closes the pipe, so the read is bounded in bytes and in
+# how long an empty pipe is waited for - a caller that never writes costs this
+# long, never a hang.
+PAYLOAD_MAX = 65536
+PAYLOAD_WAIT = 0.2
+
+
+def host_payload():
+    """The status-line host's JSON payload on stdin, or {} - a terminal, an
+    empty or silent pipe, malformed JSON or no stdin at all."""
+    import select
+    try:
+        if sys.stdin.isatty() or not select.select([sys.stdin], [], [],
+                                                   PAYLOAD_WAIT)[0]:
+            return {}
+        payload = json.loads(sys.stdin.read(PAYLOAD_MAX) or "{}")
+    except (OSError, ValueError, AttributeError):
+        return {}
+    return payload if isinstance(payload, dict) else {}
 
 
 def weeks_arg(args):
@@ -241,6 +287,115 @@ def print_orca(cwd, as_json):
     return 0
 
 
+def window_pairs(args):
+    """`args` with the `--since`/`--until` pairs folded out, and the pairs in the
+    order written. Each `--until` closes the `--since` before it, and a flag
+    without its partner is ValueError: half a window is a question the reader
+    did not finish asking.
+
+    The spaced form is read here for the reason `--weeks`' is: the split in
+    `main` sends every non-`--` argument to `pos`, where a date would be read as
+    a session id."""
+    out, pairs, since, i = [], [], None, 0
+    while i < len(args):
+        a = args[i]
+        name = a.split("=", 1)[0]
+        if name not in ("--since", "--until"):
+            out.append(a)
+            i += 1
+            continue
+        if "=" in a:
+            value, i = a.split("=", 1)[1], i + 1
+        else:
+            value = args[i + 1] if i + 1 < len(args) else ""
+            i += 2 if i + 1 < len(args) else 1
+        if name == "--since":
+            if since is not None:
+                raise ValueError("--since %s has no --until" % since)
+            since = value
+        else:
+            if since is None:
+                raise ValueError("--until %s has no --since" % value)
+            pairs.append((since, value))
+            since = None
+    if since is not None:
+        raise ValueError("--since %s has no --until" % since)
+    return out, pairs
+
+
+def share(value, numerator, denominator):
+    """A share in the unit 056's `+2 pp` bar reads, or `n/a` with no
+    denominator - a window that decided nothing has no rate."""
+    return ("n/a" if value is None
+            else "%.2f%% (%d/%d)" % (100 * value, numerator, denominator))
+
+
+def dominant_contract(window):
+    """The row contract that wrote most of a window's rows, or `-` for a window
+    that read none. `claims` is one quantity under a contract and another across
+    a change to it (plan 135), so the delta line names both sides' contract."""
+    counts = window.get("row_versions") or {}
+    if not counts:
+        return "-"
+    return max(sorted(counts), key=lambda name: counts[name])
+
+
+def print_rates(found):
+    """The windowed rates, for `--rates`: one block per window, then the pp delta
+    between each adjacent pair - the unit plan 066's rows state their bars in."""
+    for w in found:
+        rates = w["rates"]
+        print("window %s..%s: %d days, %d sessions, %d turns, %d claims, %d "
+              "replies" % (w["since"], w["until"], w["days"], w["sessions"],
+                           w["turns"], w["claims"], w["replies"]))
+        for key, label in (("blocked_claims", "blocked_claims"),
+                           ("shapes", "stop shapes"), ("denies", "denies")):
+            print("  %-15s %s" % (label, ", ".join(
+                "%s=%d" % kv for kv in sorted(w[key].items())) or "none"))
+        print("  %-15s %d" % ("shape_blocked", w["shape_blocked"]))
+        print("  %-15s blocks/100 turns %s, denies/100 sessions %s" % (
+            "rates", "n/a" if rates["blocks_per_100_turns"] is None
+            else "%.4f" % rates["blocks_per_100_turns"],
+            "n/a" if rates["denies_per_100_sessions"] is None
+            else "%.4f" % rates["denies_per_100_sessions"]))
+        print("  %-15s claim block %s, stop shape %s" % (
+            "shares", share(rates["claim_block_rate"],
+                            sum(w["blocked_claims"].values()), w["claims"]),
+            share(rates["stop_shape_rate"], w["shape_flagged"], w["replies"])))
+        print("  %-15s %s" % ("blocked/100 sess", ", ".join(
+            "%s=%.4f" % kv for kv in
+            sorted(rates["blocked_claims_per_100_sessions"].items()))
+            or "none"))
+        # Which row contract wrote the rows, printed only when a window mixes
+        # two: `claims` means "every judged reply" before ROW_VERSION 3 and "a
+        # reply that claimed" after it, so a share read off a mixed or shifted
+        # window is not the same quantity as its neighbour's (plan 135).
+        if len(w["row_versions"]) > 1:
+            print("  %-15s %s" % ("contracts", ", ".join(
+                "%s=%d" % kv for kv in sorted(w["row_versions"].items()))))
+    for before, after in zip(found, found[1:]):
+        parts, unknown, over = [], False, False
+        for key, label in (("claim_block_rate", "claim block"),
+                           ("stop_shape_rate", "stop shape")):
+            a, b = before["rates"][key], after["rates"][key]
+            if a is None or b is None:
+                unknown = True
+                parts.append("%s n/a" % label)
+                continue
+            parts.append("%s %+.2f pp" % (label, 100 * (b - a)))
+            over = over or round(b - a, 4) > 0.02
+        shift = dominant_contract(before) != dominant_contract(after)
+        print("delta %s..%s -> %s..%s: %s; 056 bar (+2 pp): %s%s" % (
+            before["since"], before["until"], after["since"], after["until"],
+            ", ".join(parts),
+            "unreadable (no denominator in a window)" if unknown
+            else "FAILS" if over else "holds",
+            "; the two windows' rows come from different contracts (%s vs %s), "
+            "so the shares are not one quantity" % (
+                dominant_contract(before), dominant_contract(after))
+            if shift else ""))
+
+
 def main():
     # `--` ends the options: what follows is PATH and SESSION_ID even when it
     # starts with a dash. The dsh route and the MCP tool hand caller-chosen
@@ -250,6 +405,11 @@ def main():
     rest = argv[argv.index("--") + 1:] if "--" in argv else []
     argv = argv[:argv.index("--")] if "--" in argv else argv
     args, weeks = weeks_arg(argv)
+    try:
+        args, windows = window_pairs(args)
+    except ValueError as err:
+        sys.stderr.write("tezgah-status: %s\n" % err)
+        return 2
     # A sanity bound, not a policy: ten years of weeks is longer than any ledger
     # this machine holds, and a number the reader mistyped should say so rather
     # than print a thousand rows of nothing.
@@ -260,9 +420,11 @@ def main():
     pos = [a for a in args if not a.startswith("--")] + rest
     known = {"--legend", "--json", "--color", "--no-color", "--counters",
              "--all", "--trend", "--skill-fitness", "--failure-shapes",
-             "--rule-yield", "--enforcers", "--orca", "--judge", "--help"}
+             "--rule-yield", "--enforcers", "--orca", "--judge", "--rates",
+             "--help"}
     unknown = sorted(f for f in flags
-                     if f not in known and not f.startswith("--observable="))
+                     if f not in known
+                     and not f.startswith(("--observable=", "--manifest=")))
     if unknown:
         sys.stderr.write("tezgah-status: unknown option(s): %s (try --help)\n"
                          % ", ".join(unknown))
@@ -293,6 +455,26 @@ def main():
         sys.stderr.write("tezgah-status: %s only means something with "
                          "--counters\n" % modifier)
         return 2
+    if windows and "--rates" not in flags:
+        sys.stderr.write("tezgah-status: --since/--until only mean something "
+                         "with --rates\n")
+        return 2
+    if "--rates" in flags and not windows:
+        sys.stderr.write("tezgah-status: --rates wants --since and --until\n")
+        return 2
+    if "--rates" in flags:
+        import tezgah_integrity as ti
+        try:
+            found = [ti.rates(since, until) for since, until in windows]
+        except ValueError as err:
+            sys.stderr.write("tezgah-status: %s\n" % err)
+            return 2
+        if "--json" in flags:
+            # one shape for one window and for many: a consumer never branches
+            print(json.dumps({"windows": found}, sort_keys=True))
+            return 0
+        print_rates(found)
+        return 0
     if "--judge" in flags:
         import tezgah_judge as tj
         last = tj.last_use()
@@ -430,7 +612,23 @@ def main():
     spec = next((f.split("=", 1)[1] for f in flags
                  if f.startswith("--observable=")), None)
     observable = set(spec.split(",")) if spec else None
-    segs = health_segments(cwd, session, observable=observable)
+    manifest = next((f.split("=", 1)[1] for f in flags
+                     if f.startswith("--manifest=")), None) or None
+    if not pos:
+        import tezgah_extension
+        if tezgah_extension.override(cwd, manifest):
+            # the project's own statusLine runs this renderer: the host says
+            # which directory and session the line is for
+            payload = host_payload()
+            workspace = payload.get("workspace")
+            where = ((workspace.get("current_dir")
+                      if isinstance(workspace, dict) else None)
+                     or payload.get("cwd"))
+            if isinstance(where, str) and where:
+                cwd = os.path.realpath(where)
+            if isinstance(payload.get("session_id"), str) and payload["session_id"]:
+                session = payload["session_id"]
+    segs = health_segments(cwd, session, observable=observable, manifest=manifest)
     if "--json" in flags:
         print(json.dumps(segs))
         return 0