@techierathore/techieflow 1.1.0 → 1.2.0

package/.tfcore/utils/tf-verify-screens.sh

@@ -9,14 +9,23 @@
 #                                           # (repeatable; defaults cover one framework's id and [data-error-ui])
 #   … --route-value ProviderId=21           # a sample for /x/{ProviderId:long} (repeatable; or "route_values"
 #                                           # in the list); a screen whose route still needs one is SKIPped
+#   bash .tfcore/utils/tf-verify-screens.sh --list … --appium http://localhost:4723   # a MAUI Mac Catalyst head
+#        (tf-verify-native.mjs: AutomationId for data-testid, the app's window for the screenshot; the
+#        bundle id comes from boot.json or --bundle; no Playwright needed)
 #   A mockup control marked data-tf-state="<state>" (on it or a box around it) belongs to another state
 #   of the screen: it is not owed on the first view.
+#   … --themes light,dark | light | dark   # default auto: light, then dark once the app shows it has a
+#                                           # dark theme (what it paints changes when dark is put on it)
+#   … --min-contrast 3                      # the text contrast floor, ratio : 1 (Lekhak TF-024)
 #
 # For every screen, at 1280 and 390 px: every control the mockup anchors is present and shows
 # something, no header-only table, no blank page, no Blazor or console error (render); nothing
 # overlaps, nothing has zero size or sits off-screen, no sideways scroll, a stylesheet is loaded
-# (visual). Overlap and off-screen are measured on the rectangle an element paints in, clipped by
-# every scrolling ancestor, and the page is read only after its first render (--render-wait,
+# (visual); every text run reaches 3.0 : 1 against the colour painted behind it (disabled controls
+# exempt) and, in dark mode, no box over 2% of the window paints a light panel (visual). Each theme is
+# put on the page through prefers-color-scheme and the light/dark value of its data-*theme attributes
+# and mode classes, and taken off again after. Overlap and off-screen are measured on the rectangle an
+# element paints in, clipped by every scrolling ancestor, and the page is read only after its first render (--render-wait,
 # default 5000 ms). Saves a screenshot per screen and width under tests/.artifacts/verify/screens/ and
 # writes tests/.artifacts/verify/screens.json; that JSON is the evidence a smoke names before a
 # row is written Implemented, and what the verdict script reads. It decides no row's status.
@@ -26,10 +35,14 @@ HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # `--help` is a request and exits 0; no argument at all is a mistake and exits 3. (The one-line
 # form this replaces computed "0--help" as its exit code and printed a bash error under the help.)
 case "${1:-}" in
-  -h|--help) sed -n '2,23p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
-  "")        sed -n '2,23p' "$0" | sed 's/^# \{0,1\}//'; exit 3 ;;
+  -h|--help) sed -n '2,32p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+  "")        sed -n '2,32p' "$0" | sed 's/^# \{0,1\}//'; exit 3 ;;
 esac
 command -v node >/dev/null 2>&1 || { echo "tf-verify-screens: node is required (bash .tfcore/utils/tf-verify-env.sh)" >&2; exit 4; }
+case " $* " in *" --appium "*)
+  source "$HERE/tf-lock.sh"; tf_take_lock verify-screens
+  node "$HERE/tf-verify-native.mjs" "$@"; exit $? ;;
+esac
 node -e "import('playwright').then(()=>process.exit(0)).catch(()=>process.exit(1))" 2>/dev/null || {
   echo "tf-verify-screens: the 'playwright' package is not resolvable from this folder; run bash .tfcore/utils/tf-verify-env.sh" >&2; exit 4; }
 source "$HERE/tf-lock.sh"; tf_take_lock verify-screens   # one browser check at a time (TF-048)

package/.tfcore/utils/tf-verify-tests.sh

@@ -7,8 +7,10 @@
 #   bash .tfcore/utils/tf-verify-tests.sh --merge <tests-a.json> <tests-b.json>… [--json-out tests/.artifacts/verify/tests.json]
 #
 # Browser tests: `npx playwright test` over tests/verify/ (the JSON reporter). Unit tests:
-# `tf-build.sh test` with normal console verbosity. A test belongs to a row when its name contains
-# the row's id (REQ-UI-004 …). A row is PASS when a test carrying its id passed and none failed,
+# `tf-build.sh test` with normal console verbosity. A test belongs to a row when its name STARTS with
+# the row's id (REQ-UI-004 …; tf-req-ids.py): an id later in the name, or in a theory case's arguments,
+# is what the test is about, not what it proves, and a row only named that way is listed under
+# named_only_by_other_rows_tests (Chatur TF-012). A row is PASS when a test carrying its id passed and none failed,
 # FAIL when one failed (the reason and the screenshot, when the reporter kept one, are recorded),
 # NOT-TESTED when every test carrying its id was SKIPPED, and absent when no test carries its id.
 # A skipped clause is a third outcome, never a failure: `test.skip(!SEEDED, …)` says the state does
@@ -20,6 +22,9 @@
 # When tf-verify-list.sh was given a list of ids, the browser run keeps only the tests carrying them
 # (`--grep`), and is skipped when no row has a screen and no browser test names one (Lekhak TF-017).
 # `--list` names another list.json; `--all-specs` runs every browser test whatever the scope.
+# A desktop head's debugging address (--base answering /json/version, or boot.json mode=cdp) also
+# reaches the tests as CDP_URL; a suite that reads it nowhere is refused, not run (Lekhak TF-021).
+# A Mac Catalyst head (boot.json mode=appium) reaches them as APPIUM_URL, TF_BUNDLE_ID and TF_APP_PATH.
 # Exit 0 ran (whatever the results) · 2 nothing could run.
 set -uo pipefail
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -37,7 +42,7 @@ while [[ $# -gt 0 ]]; do
     --all-specs) ALLSPECS=1; shift ;;
     --merge) shift; while [[ $# -gt 0 && "$1" != --* ]]; do MERGE+=("$1"); shift; done ;;
     --json-out) OUT="${2:-}"; shift 2 ;;
-    -h|--help) sed -n '2,22p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    -h|--help) sed -n '2,26p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
     *) echo "tf-verify-tests: unknown argument $1" >&2; exit 2 ;;
   esac
 done
@@ -51,8 +56,11 @@ mkdir -p "$(dirname "$OUT")" tests/.artifacts/verify
 
 # ---- --merge: the parts into one tests.json, no test run ------------------------------------------
 if [[ ${#MERGE[@]} -gt 0 ]]; then
-  TF_OUT="$OUT" python3 - "${MERGE[@]}" <<'PY'
-import json, os, sys
+  TF_HERE="$HERE" TF_OUT="$OUT" python3 - "${MERGE[@]}" <<'PY'
+import json, os, re, sys
+import importlib.util
+_spec = importlib.util.spec_from_file_location("tf_req_ids", os.path.join(os.environ.get("TF_HERE", ".tfcore/utils"), "tf-req-ids.py"))
+rq = importlib.util.module_from_spec(_spec); _spec.loader.exec_module(rq)
 # Lekhak TF-007. The parts are read oldest first (by the time each ran, else in the order given), and
 # a later run of the SAME test stands for it: a test that failed because its service was not started,
 # run again once it was, clears the row. A later skip never replaces a run that happened. A part
@@ -65,7 +73,7 @@ for i, p in enumerate(sys.argv[1:]):
         print(f"merge: {p} unreadable ({str(e)[:80]}); skipped")
 loaded.sort(key=lambda x: (x[0].get("ran_at") or "", x[1]) if all(y[0].get("ran_at") for y in loaded) else (x[1],))
 reqs, browser, unit, parts = {}, {"ran": False, "passed": 0, "failed": 0, "skipped": 0, "tests": 0}, {"ran": False, "line": ""}, []
-outs, sources, superseded = {}, {}, 0
+outs, sources, superseded, elsewhere = {}, {}, 0, {}
 for d, _i, p in loaded:
     parts.append(p)
     for rid, r in d.get("reqs", {}).items():
@@ -76,6 +84,17 @@ for d, _i, p in loaded:
             oc.update({t: {"outcome": "skip", "reason": r.get("reason", ""), "screenshot": ""} for t in r.get("skipped", [])})
         o = outs.setdefault(rid, {})
         for name, rec in oc.items():
+            # a part read before Chatur TF-012 counted a test for every id its name carried: a test that
+            # does not claim this row is dropped here, and the row noted if that test passed
+            # (a browser test's name was stored with its describe titles joined on, so there each title is read)
+            segs = re.split(r"\s+(?=REQ-)", name) if rec.get("source", r.get("source")) == "browser" else [name]
+            if not any(rid in rq.ids_of(seg) for seg in segs):
+                if rec.get("outcome") == "pass":
+                    elsewhere.setdefault(rid, []).append(name[:160])
+                continue
+            # a part written before outcomes carried their source: the row's, when it had only one
+            if "source" not in rec:
+                rec = dict(rec, source=r.get("source") if r.get("source") in ("browser", "unit") else "")
             old = o.get(name)
             if old and rec["outcome"] == "skip" and old["outcome"] != "skip":
                 continue
@@ -92,16 +111,29 @@ for d, _i, p in loaded:
     u = d.get("unit", {})
     if u.get("ran") and not unit["ran"]:
         unit = u
+for d, _i, p in loaded:
+    for rid, names in (d.get("named_only_by_other_rows_tests") or {}).items():
+        elsewhere.setdefault(rid, []).extend(names)
 for rid, o in outs.items():
+    if not o:
+        continue
     fails = [(n, x) for n, x in o.items() if x["outcome"] == "fail"]
     npass = sum(1 for x in o.values() if x["outcome"] == "pass")
     skips = [(n, x) for n, x in o.items() if x["outcome"] == "skip"]
     result = "FAIL" if fails else "PASS" if npass else "NOT-TESTED"
     reason = fails[0][1]["reason"] if fails else (skips[0][1]["reason"] if skips and not npass else "")
+    # Sevak TF-004: a unit pass does not stand in for a row's on-app tests when they were all skipped
+    app = [x for x in o.values() if x.get("source") == "browser"]
+    if result == "PASS" and app and all(x["outcome"] == "skip" for x in app):
+        why = next((x["reason"] for x in app if x["reason"]), "the test was skipped")
+        result = "NOT-TESTED"
+        reason = ("on-app test skipped (" + why + "); a unit test does not measure on-app acceptance")[:200]
     reqs[rid] = {"result": result, "source": sources.get(rid, ""), "tests": [n for n, x in o.items() if x["outcome"] != "skip"],
                  "skipped": [n for n, _ in skips], "passed": npass, "failed": len(fails), "reason": reason,
                  "screenshot": fails[0][1].get("screenshot", "") if fails else "", "outcomes": o}
-json.dump({"reqs": reqs, "browser": browser, "unit": unit, "merged_from": parts, "superseded": superseded},
+mentioned = {rid: sorted(set(v))[:3] for rid, v in elsewhere.items() if rid not in reqs}
+json.dump({"reqs": reqs, "browser": browser, "unit": unit, "merged_from": parts, "superseded": superseded,
+           "named_only_by_other_rows_tests": mentioned},
           open(os.environ["TF_OUT"], "w"), indent=1)
 p = sum(1 for r in reqs.values() if r["result"] == "PASS"); f = sum(1 for r in reqs.values() if r["result"] == "FAIL")
 ns = sum(1 for r in reqs.values() if r["result"] == "NOT-TESTED")
@@ -111,6 +143,8 @@ print(f"merged {len(parts)} part(s): rows with a test: {len(reqs)} — {p} PASS,
 for rid, r in sorted(reqs.items()):
     if r["result"] == "FAIL":
         print(f"  FAIL {rid} — {r['reason']}" + (f" — {r['screenshot']}" if r["screenshot"] else ""))
+for rid, names in sorted(mentioned.items()):
+    print(f"  NO TEST {rid} — only named inside another row's passing test, which does not test it: {names[0]}")
 print(f"JSON: {os.environ['TF_OUT']}")
 PY
   exit 0
@@ -121,6 +155,25 @@ PWJSON="tests/.artifacts/verify/playwright${PART:+-$PART}.json"; PWLOG="tests/.a
 ran_any=0
 
 if [[ $BROWSER -eq 1 ]]; then
+  # A desktop head is reached over its debugging address (tf-verify-boot.sh prints mode=cdp). The tests
+  # get it as CDP_URL as well as BASE_URL: Lekhak's helper fell back to its own default port and every
+  # desktop test failed after ten minutes (Lekhak TF-021). --base is that address when it answers
+  # /json/version; without --base, boot.json's url when its mode is cdp.
+  CDPURL=""
+  if [[ -n "$BASE" ]]; then
+    curl -s -m 3 "${BASE%/}/json/version" 2>/dev/null | grep -q webSocketDebuggerUrl && CDPURL="${BASE%/}"
+  elif [[ -f tests/.artifacts/verify/boot.json ]]; then
+    CDPURL="$(python3 -c 'import json,sys
+b = json.load(open(sys.argv[1]))
+print(b.get("url", "") if b.get("mode") == "cdp" and not b.get("stopped") else "")' tests/.artifacts/verify/boot.json 2>/dev/null)"
+    [[ -n "$CDPURL" ]] && BASE="$CDPURL"
+  fi
+  # A Mac Catalyst head (boot.json mode=appium) is reached through Appium: its tests get APPIUM_URL
+  # TF_BUNDLE_ID and TF_APP_PATH, and open their session with .tfcore/utils/tf-appium.mjs.
+  APPIUMURL=""; BUNDLEID=""; APPPATH=""
+  [[ -f tests/.artifacts/verify/boot.json ]] && read -r APPIUMURL BUNDLEID APPPATH < <(python3 -c 'import json,sys
+b = json.load(open(sys.argv[1]))
+print(b.get("url", ""), b.get("bundle_id", ""), b.get("app_path", "")) if b.get("mode") == "appium" and not b.get("stopped") else print()' tests/.artifacts/verify/boot.json 2>/dev/null)
   if ls tests/verify/*.spec.* >/dev/null 2>&1 || ls tests/verify/**/*.spec.* >/dev/null 2>&1; then
     # --base reaches the tests only as BASE_URL, which Playwright never reads by itself. When neither
     # the config nor a spec reads it, every test opens the config's own address, where an older build
@@ -128,6 +181,9 @@ if [[ $BROWSER -eq 1 ]]; then
     if [[ -n "$BASE" ]] && ! grep -qs "BASE_URL" playwright.config.* tests/verify/*.spec.* tests/verify/**/*.spec.*; then
       echo "browser tests: NOT RUN — nothing reads BASE_URL, so the tests would open another address than --base $BASE; run bash .tfcore/utils/tf-verify-env.sh, which makes playwright.config.ts read it"
       rm -f "$PWJSON"
+    elif [[ -n "$CDPURL" ]] && ! grep -qsE "env(\.|\[['\"])CDP_URL" playwright.config.* tests/verify/*.ts tests/verify/**/*.ts; then
+      echo "browser tests: NOT RUN — $CDPURL is a desktop app's debugging address and no test reads CDP_URL, so they would attach to another address; make the connectOverCDP helper read process.env.CDP_URL first"
+      rm -f "$PWJSON"
     elif node -e "require.resolve('@playwright/test')" >/dev/null 2>&1; then
       PWARGS=(--reporter=json); [[ -n "$SHARD" ]] && PWARGS+=("--shard=$SHARD")
       # (the block below ends in SCOPEPY, not PY: tests/regression lifts the PY blocks out verbatim)
@@ -155,7 +211,7 @@ SCOPEPY
         rm -f "$PWJSON"
       else
         [[ -n "$SCOPE" ]] && PWARGS+=(--grep "${SCOPE#* }")
-        BASE_URL="$BASE" PLAYWRIGHT_JSON_OUTPUT_NAME="$PWJSON" npx playwright test "${PWARGS[@]}" ${SPECS[@]+"${SPECS[@]}"} > "$PWLOG" 2>&1
+        APPIUM_URL="$APPIUMURL" TF_BUNDLE_ID="$BUNDLEID" TF_APP_PATH="$APPPATH" CDP_URL="$CDPURL" BASE_URL="$BASE" PLAYWRIGHT_JSON_OUTPUT_NAME="$PWJSON" npx playwright test "${PWARGS[@]}" ${SPECS[@]+"${SPECS[@]}"} > "$PWLOG" 2>&1
         echo "browser tests: ran${SHARD:+ shard $SHARD}${SPECS:+ (${#SPECS[@]} spec argument(s))}${SCOPE:+ only the tests carrying ${SCOPE#* } (the scope in $LIST)} (log $PWLOG)"; ran_any=1
       fi
     else
@@ -209,7 +265,9 @@ PY
       --report-*) UARGS+=("-p:TestingPlatformCommandLineArguments=$MTP") ;;
       mixed) echo "unit tests: note  the Testing Platform projects here take different report switches, so none was passed; their tests are not mapped to rows" ;;
     esac
-    STAMP="$(mktemp)"
+    # the stamp sits on the project's own drive: one in /tmp takes its time from WSL's clock and the
+    # report on /mnt/c from Windows', which drift apart, so a fresh report could read as older (2026-10-02)
+    mkdir -p tests/.artifacts; STAMP="$(mktemp tests/.artifacts/.unit-stamp.XXXXXX)"
     UNITLINE="$(bash "$HERE/tf-build.sh" test ${TARGET:+"$TARGET"} -- "${UARGS[@]}" 2>&1 | grep -m1 -E '^(PASS|FAIL|NOT-RUN)' || true)"
     UNITLOG="$(sed -n 's/.*log \(tests\/\.artifacts\/build\/[^ ;]*\).*/\1/p' <<<"$UNITLINE" | head -1)"
     TRX="$(find . -name '*.trx' -newer "$STAMP" -not -path '*/node_modules/*' 2>/dev/null)"; rm -f "$STAMP"
@@ -219,10 +277,23 @@ PY
   fi
 fi
 
-TF_PWJSON="$PWJSON" TF_UNITLOG="$UNITLOG" TF_UNITLINE="$UNITLINE" TF_TRX="${TRX:-}" TF_OUT="$OUT" python3 - <<'PY'
+TF_HERE="$HERE" TF_PWJSON="$PWJSON" TF_UNITLOG="$UNITLOG" TF_UNITLINE="$UNITLINE" TF_TRX="${TRX:-}" TF_OUT="$OUT" python3 - <<'PY'
 import json, os, re
 import xml.etree.ElementTree as ET
-ID = re.compile(r"(REQ-(?:UI|FN|NFR|RAG)-\d{3})", re.I)
+import importlib.util
+_spec = importlib.util.spec_from_file_location("tf_req_ids", os.path.join(os.environ.get("TF_HERE", ".tfcore/utils"), "tf-req-ids.py"))
+rq = importlib.util.module_from_spec(_spec); _spec.loader.exec_module(rq)
+ID, ids_of = rq.ID, rq.ids_of   # Chatur TF-012: a test claims the ids its name starts with (tf-req-ids.py)
+elsewhere = {}   # row -> names of passing tests that mention it without claiming it
+def claims(names, outcome):
+    """the ids a test claims: the leading run of each name given (a browser test's describe titles and
+    its own title are separate names); the other ids it mentions are noted against those rows"""
+    own = {i for n in names for i in ids_of(n)}
+    for n in names:
+        for rid in {x.upper() for x in ID.findall(n)} - own:
+            if outcome == "pass":
+                elsewhere.setdefault(rid, []).append(" ".join(names).strip()[:160])
+    return own
 reqs = {}
 browser = {"ran": False, "passed": 0, "failed": 0, "skipped": 0, "tests": 0}
 unit = {"ran": False, "line": os.environ.get("TF_UNITLINE", "")}
@@ -240,8 +311,11 @@ def add(rid, outcome, name, source, reason="", shot=""):
     r = reqs.setdefault(rid.upper(), {"result": "NOT-TESTED", "source": source, "tests": [],
                                       "skipped": [], "passed": 0, "failed": 0,
                                       "reason": "", "screenshot": "", "outcomes": {}})
-    # each test's own outcome, so a merge can let a later run of the same test stand (Lekhak TF-007)
-    r["outcomes"][name] = {"outcome": outcome, "reason": (reason or "")[:200], "screenshot": shot}
+    # each test's own outcome, so a merge can let a later run of the same test stand (Lekhak TF-007),
+    # and where it ran, so a unit pass never stands in for a skipped on-app test (Sevak TF-004)
+    r["outcomes"][name] = {"outcome": outcome, "reason": (reason or "")[:200], "screenshot": shot, "source": source}
+    if r["source"] != source:
+        r["source"] = "browser+unit"
     if outcome == "skip":
         r["skipped"].append(name)
         if not r["reason"]:
@@ -292,7 +366,7 @@ if pw and os.path.isfile(pw):
                             shot = a["path"].replace("\\", "/")
                             shot = shot[shot.find("tests/"):] if "tests/" in shot else shot
                             break
-                    for rid in set(ID.findall(title)):
+                    for rid in claims(path + [sp.get("title", "")], outcome):
                         add(rid, outcome, title.strip(), "browser", err, shot)
             for s in suite.get("suites", []):
                 walk(s, path + [s.get("title", "")] if s.get("title") and not s["title"].endswith(".ts") and not s["title"].endswith(".js") and not s["title"].endswith(".mjs") else path)
@@ -320,7 +394,7 @@ for trx in [p for p in os.environ.get("TF_TRX", "").splitlines() if p.strip()]:
             continue
         seen.add((name, outcome))
         msg = next(((m.text or "").strip() for m in el.iter() if m.tag.endswith("Message") and (m.text or "").strip()), "")
-        for rid in set(ID.findall(name)):
+        for rid in claims([name], outcome):
             add(rid, outcome, name, "unit",
                 ("unit test failed: " + (msg.splitlines()[0] if msg else name))[:200] if outcome == "fail"
                 else ("unit test skipped: " + name[:120]) if outcome == "skip" else "")
@@ -341,17 +415,31 @@ if ul and os.path.isfile(ul):
             continue
         seen.add((name, outcome))
         # a pass has no reason: every non-failure was once written "unit test skipped" (Lekhak TF-018)
-        for rid in set(ID.findall(name)):
+        for rid in claims([name], outcome):
             add(rid, outcome, name, "unit",
                 "unit test failed: " + name[:120] if outcome == "fail"
                 else "unit test skipped: " + name[:120] if outcome == "skip" else "")
+# Sevak TF-004: a row that has an on-app test is accepted on the app. When every on-app test of the
+# row was skipped (`test.skip()`: not observable on this host) and none failed, a passing unit test
+# with the same id does not measure it: the row is NOT-TESTED, with the skip's reason. A failure, from
+# either side, still makes it FAIL; a row with no on-app test is graded on its unit tests as before.
+for rid, r in reqs.items():
+    app = [x for x in r["outcomes"].values() if x.get("source") == "browser"]
+    if app and all(x["outcome"] == "skip" for x in app) and r["result"] == "PASS":
+        why = next((x["reason"] for x in app if x["reason"]), "the test was skipped")
+        r["result"] = "NOT-TESTED"
+        r["reason"] = ("on-app test skipped (" + why + "); a unit test does not measure on-app acceptance")[:200]
+# a row no test claims, whose id a passing test about another row carries, is flagged: it was once
+# counted as tested on that name, and it is not
+mentioned = {rid: sorted(set(v))[:3] for rid, v in elsewhere.items() if rid not in reqs}
 unit["passed"] = sum(1 for r in reqs.values() if r["source"] == "unit" and r["result"] == "PASS")
 unit["failed"] = sum(1 for r in reqs.values() if r["source"] == "unit" and r["result"] == "FAIL")
 unit["not_tested"] = sum(1 for r in reqs.values() if r["source"] == "unit" and r["result"] == "NOT-TESTED")
 
 import datetime
 ran_at = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-json.dump({"reqs": reqs, "browser": browser, "unit": unit, "ran_at": ran_at}, open(os.environ["TF_OUT"], "w"), indent=1)
+json.dump({"reqs": reqs, "browser": browser, "unit": unit, "ran_at": ran_at, "named_only_by_other_rows_tests": mentioned},
+          open(os.environ["TF_OUT"], "w"), indent=1)
 p = sum(1 for r in reqs.values() if r["result"] == "PASS")
 f = sum(1 for r in reqs.values() if r["result"] == "FAIL")
 ns = sum(1 for r in reqs.values() if r["result"] == "NOT-TESTED")
@@ -362,6 +450,8 @@ for rid, r in sorted(reqs.items()):
         print(f"  FAIL {rid} — {r['reason']}" + (f" — {r['screenshot']}" if r["screenshot"] else ""))
     elif r["result"] == "NOT-TESTED":
         print(f"  NOT-TESTED {rid} — {len(r['skipped'])} test(s) skipped, none ran — {r['reason']}")
+for rid, names in sorted(mentioned.items()):
+    print(f"  NO TEST {rid} — only named inside another row's passing test, which does not test it: {names[0]}")
 print(f"JSON: {os.environ['TF_OUT']}")
 PY
 [[ $ran_any -eq 1 ]] && exit 0 || exit 2

package/.tfcore/utils/tf-verify-verdict.py

@@ -14,7 +14,10 @@ For each row, the seven checks in order, and the first that fails is the verdict
   render      every anchored control on its screen shows something — screens.json
   assets      every stylesheet and script its screen declares arrived — assets.json
   visual      nothing overlaps, nothing clipped or off-screen — screens.json
-  mockup      the screen carries the structure its mockup draws — parity.json
+  mockup      the screen carries the structure its mockup draws — parity.json, found by the screen's
+              name, its mockup's file name or its route ({id} in the row's route = one path segment, so
+              /processes/6/run counts for /processes/{id}/run); a driven screen with a mockup and no
+              comparison found FAILs this check, it is never skipped (Chatur TF-008)
   speed       within the row's perf-budget, only when it declares one — perf/<REQ>.json
   (standards has no script yet and is never listed as run)
 
@@ -42,6 +45,7 @@ import sys
 HERE = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, HERE)
 import tf_defect  # noqa: E402
+import tf_stack_check  # noqa: E402
 FAILING = {"BUILD-FAIL": "build", "FAIL": "acceptance", "RENDER-FAIL": "render", "ASSET-FAIL": "assets",
            "VISUAL-FAIL": "visual", "MOCKUP-FAIL": "mockup-parity", "PERF-FAIL": "perf"}
 STATUS = {"PASS": "Verified", "FAIL": "FAIL", "BUILD-FAIL": "FAIL", "RENDER-FAIL": "Needs re-verify", "ASSET-FAIL": "Needs re-verify",
@@ -75,6 +79,34 @@ def norm_route(r):
     return r or "/"
 
 
+def route_matches(pattern, route):
+    """A filled-in route against its pattern: /processes/6/run matches /processes/{id}/run, one path
+    segment per {…} (Chatur TF-008). A pattern with no {…} matches only itself. A query string on the
+    opened route (/start?all=1) is not part of the screen."""
+    p, r = norm_route(pattern), norm_route((route or "").split("?")[0].split("#")[0])
+    if "{" not in p:
+        return p == r
+    rx = "".join("[^/]+" if part.startswith("{") else re.escape(part) for part in re.split(r"(\{[^}]*\})", p))
+    return re.fullmatch(rx, r) is not None
+
+
+def stem(path):
+    return os.path.basename(path or "")[:-5].lower() if (path or "").lower().endswith(".html") else ""
+
+
+def parity_for(r, mockup, comparisons):
+    """The mockup comparison that graded a row's screen: named for the screen, for its mockup file
+    (the Mockup parity: line names each screen by its mockup's stem), or opened at the screen's route,
+    a {value} in it standing for any one segment. The worst one when several match: one per value
+    (Chatur TF-008)."""
+    screen, route = (r.get("screen") or "").lower(), r.get("route") or ""
+    hits = [s for s in comparisons
+            if (s.get("screen") or "").lower() in (screen, stem(mockup))
+            or (route and s.get("route") and route_matches(route, s.get("route")))]
+    order = {"FAIL": 0, "ERROR": 1, "UNGRADEABLE": 2, "NO-MOCKUP": 3, "PASS": 4}
+    return min(hits, key=lambda s: order.get(s.get("verdict"), 5)) if hits else None
+
+
 def quoted(s, n=None):
     """A test's own words — its title or its failure message — in backticks, so the Remark shows them as
     quoted and tf-doc-check reads them as quoted: a title saying "Found/Not found" failed the checker's
@@ -109,12 +141,20 @@ def main(argv):
     assets = load(os.path.join(d, "assets.json")) or {}
     pages = {norm_route(p.get("path")): p for p in assets.get("pages", [])}
     parity = load(os.path.join(d, "parity.json")) or {}
-    par_by_name = {s.get("screen"): s for s in parity.get("screens", [])}
-    par_by_route = {norm_route(s.get("route")): s for s in parity.get("screens", [])}
+    comparisons = parity.get("screens", []) or []
+    # the mockup each listed screen is graded against; a row's own *Mockup:* line when its screen has none
+    mock_of = {s.get("name"): s.get("mockup") or "" for s in lst.get("screens", []) or []}
     grade = perf_grader()
 
     booted = boot.get("mode") not in (None, "none")
     build_failed = boot.get("reason_kind") == "build-error"
+    # the packages the Architecture requires are in the code (tf_stack_check.py): a model once replaced the
+    # mandated UI library with plain components and had every row Verified
+    stack = tf_stack_check.check(os.getcwd(), app)
+    if stack["verdict"] == "FAIL":
+        build_failed = True
+        boot = dict(boot, reason=f"the Architecture requires {', '.join(stack['missing'])} and no project file references "
+                    + ("it" if len(stack["missing"]) == 1 else "them") + " (tf-stack-check.sh): add the package, never a workaround")
     boot_text = (f"{boot.get('head')} via {boot.get('rung')} at {boot.get('url')}" if booted
                  else f"not booted: {boot.get('reason')}")
     checks_ran = set()
@@ -128,6 +168,7 @@ def main(argv):
         notes = []
         scr = scr_by_name.get(r.get("screen") or "")
         driven = bool(scr) and scr.get("render") != "UNREACHABLE"
+        nonames = " (names not measured on a Mac)" if scr and scr.get("anchors_not_measured") else ""
         t = tests.get(rid)
         # A row whose every clause was SKIPPED is NOT-TESTED: the acceptance gate did not run on
         # it. It is neither a pass nor a defect, so it grades exactly like a row with no test at
@@ -136,6 +177,21 @@ def main(argv):
         if skipped_only:
             notes.append(f"acceptance not measured ({len(t.get('skipped') or [])} test(s) skipped, none ran)")
             t = None
+        # the OS zoom keys (coding-standards-dotnet.md §9b): a row whose acceptance carries "zoom-check: keys"
+        # or "zoom-check: kept" is graded by tf-verify-zoom.sh --json-out zoom/<REQ>.json, which stands as its
+        # test; a failing zoom outranks a passing test, and "kept" counts only a run made after a restart
+        if r.get("zoom_check"):
+            zf = load(os.path.join(d, "zoom", f"{rid}.json"))
+            if zf is None:
+                notes.append("zoom not measured (no tf-verify-zoom run for this row)")
+            elif r["zoom_check"] == "kept" and not zf.get("kept_checked"):
+                notes.append("zoom kept across a restart not measured (run with --expect-restored after a restart)")
+            else:
+                zfail = [c for c in zf.get("checks", []) if not c.get("ok")]
+                zt = {"result": "FAIL" if zfail else "PASS", "tests": [f"tf-verify-zoom {zf.get('head', '')}".strip()],
+                      "reason": f"zoom: {zfail[0]['text']}" if zfail else "", "screenshot": zf.get("evidence", "")}
+                if not t or (zfail and t.get("result") == "PASS"):
+                    t = zt
         # every check on its own: (name, ran, failed, verdict, class, detail, evidence); the first failure wins
         checks = []
 
@@ -154,6 +210,10 @@ def main(argv):
                 w, f = bad[0] if bad else (None, None)
                 checks.append(("render", True, bool(bad), "RENDER-FAIL", f["class"] if f else None,
                                f"{f['detail']} on {r['screen']} @{w['width']}" if f else "", w.get("screenshot", "") if w else ""))
+            # a Mac web view head: blank, error bar, overlap and the picture were checked, the
+            # controls by name were not (owner decision A, 2026-10-07): said, never counted as a pass
+            if scr.get("anchors_not_measured") and bad:
+                notes.append(f"control names not measured on {r['screen']} (a Mac web view does not show them)")
         # 4 assets
         pg = pages.get(norm_route(r.get("route"))) if r.get("route") else None
         if pg and pg.get("graded", 0) > 0:
@@ -169,16 +229,40 @@ def main(argv):
             checks.append(("visual", True, bool(bad), "VISUAL-FAIL", f["class"] if f else None,
                            f"{f['detail']} on {r['screen']}" if f else "", w.get("screenshot", "") if w else ""))
         # 6 mockup parity
-        ps = (par_by_name.get(r.get("screen")) or par_by_route.get(norm_route(r.get("route")))) if r.get("screen") else None
+        mockup = mock_of.get(r.get("screen")) or r.get("mockup") or ""
+        ps = parity_for(r, mockup, comparisons) if r.get("screen") else None
+        if not ps and driven and mockup and boot.get("mode") == "appium":
+            # a Mac head: tf-mockup-parity does not run there (verify-phase step 5), so no comparison is
+            # expected, and the row is never failed for its absence; said, not counted as a pass
+            notes.append("mockup not compared on a Mac head (compare it on the web or Windows head)")
+        elif not ps and driven and mockup:
+            # Chatur TF-008: /processes/6/run was compared and FAILed, but the row's route reads
+            # /processes/{id}/run and the comparison was named process-run, so it was never found and
+            # 11 rows were Verified without it. A driven screen that has a mockup and no comparison fails.
+            checks.append(("mockup-parity", True, True, "MOCKUP-FAIL", "other",
+                           f"mockup-parity not found: {r['screen']} ({r.get('route')}) has mockup {mockup} and "
+                           + ("parity.json has no comparison for it" if comparisons else "no mockup comparison ran")
+                           + f"; run tf-mockup-parity.sh --screen {stem(mockup) or 'name'}={r.get('route')} with its value filled in",
+                           os.path.join(d, "parity.json") if comparisons else ""))
         if ps:
             v = ps.get("verdict")
             if v in ("PASS", "FAIL"):
                 f = (ps.get("findings") or [{}])[0]
                 checks.append(("mockup-parity", True, v == "FAIL", "MOCKUP-FAIL", "mockup-drift",
-                               f"{f.get('class', 'drift')} on {f.get('key', ps.get('screen'))} @{f.get('width', '')}: {str(f.get('detail', ''))[:80]}",
+                               f"{f.get('class', 'drift')} on {f.get('key', ps.get('screen'))} @{f.get('width', '')}"
+                               + (f" in {f['theme']} mode" if f.get("theme") else "") + f": {str(f.get('detail', ''))[:80]}",
+                               os.path.join(d, "parity.json")))
+            elif v == "ERROR":
+                checks.append(("mockup-parity", True, True, "MOCKUP-FAIL", "other",
+                               f"mockup-parity could not open {ps.get('route')}: "
+                               + str(next((w.get("error") for w in ps.get("widths", []) if w.get("error")), "every width failed"))[:80],
                                os.path.join(d, "parity.json")))
             elif v == "UNGRADEABLE":
                 notes.append("mockup-parity UNGRADEABLE (add data-testid anchors to the mockup)")
+            nm = (ps.get("coverage") or {}).get("not_measured") or []
+            if nm:   # sample rows the app had no data for (Chatur TF-002)
+                notes.append(f"mockup-parity: {len(nm)} sample box(es) not measured, the app drew no data there "
+                             "(a tests/verify/seed/ script puts it in the drawn state)")
             elif v == "NO-MOCKUP":
                 notes.append("no mockup to compare")
         # 7 speed
@@ -208,21 +292,31 @@ def main(argv):
                 verdict = "NOT-DRIVEN"
                 sk = scr_skipped.get(r["screen"])
                 detail = (f"{boot.get('head', 'the app')} not driven: {boot.get('reason')}" if not booted
+                          else f"screen {r['screen']} was not driven: {sk['reason']}" if sk and sk.get("reason")
                           else f"screen {r['screen']} was not driven: its route {sk['route']} needs --route-value "
                                + ", ".join(f"{n}=<id>" for n in sk.get("needs", [])) if sk
                           else f"screen {r['screen']} was not driven in this run")
             elif not t:
                 verdict = "NOT-TESTED"
                 detail = (f"every test named {rid} was skipped" if skipped_only else f"no test named {rid} ran") \
-                    + (f"; screen {r['screen']} renders and looks right" if driven else "")
-            elif r.get("screen") and not driven and not booted:
+                    + (f"; screen {r['screen']} renders and looks right{nonames}" if driven else "")
+            elif r.get("screen") and not driven:
+                # a passing test is not a screen check: a row on a screen that was not driven is never
+                # Verified, booted or not. The Settings rows of /settings/{tab} were (Chatur TF-003).
                 verdict = "NOT-DRIVEN"
-                detail = f"test passed but {boot.get('head', 'the app')} was not driven: {boot.get('reason')}"
+                sk = scr_skipped.get(r["screen"])
+                detail = ("test passed but " + (f"{boot.get('head', 'the app')} was not driven: {boot.get('reason')}" if not booted
+                          else f"screen {r['screen']} was not driven: {sk['reason']}" if sk and sk.get("reason")
+                          else f"screen {r['screen']} was not driven: its route {sk['route']} needs --route-value "
+                               + ", ".join(f"{n}=<id>" for n in sk.get("needs", [])) if sk
+                          else f"screen {r['screen']} was not driven in this run"))
             else:
                 verdict = "PASS"
                 parts = [f"test {quoted(t['tests'][0], 60)}" if t and t.get("tests") else "test passed"]
                 if driven:
-                    parts.append(f"{r['screen']} renders and looks right @{'/'.join(str(w['width']) for w in scr['widths'])}")
+                    ws = list(dict.fromkeys(str(w['width']) for w in scr['widths']))
+                    th = list(dict.fromkeys(w['theme'] for w in scr['widths'] if w.get('theme')))
+                    parts.append(f"{r['screen']} renders and looks right @{'/'.join(ws)}" + (f" in {' and '.join(th)} mode" if len(th) > 1 else "") + nonames)
                 if "mockup-parity" in ran:
                     parts.append("matches its mockup")
                 if "perf" in ran:
@@ -269,23 +363,32 @@ def main(argv):
     # with the date and run it was graded in; the rest keep theirs. A scope-all run starts it afresh.
     # The verify guard unlocks a Verified only for a row graded today, and fix-close reads only the rows
     # graded since its fix began, by these dates.
+    # Sevak TF-005: every row carries the phase whose checklist it was graded in, and a scope-all run
+    # starts afresh only for its own phase. Phase 2's run used to wipe phase 1's verdicts. A row from an
+    # older ledger that names no phase is kept.
+    phase = lst.get("phase") or 1
     all_rows, row_dates, row_runs = dict(ledger_rows), {k: today for k in ledger_rows}, {k: started for k in ledger_rows}
+    row_phases = {k: phase for k in ledger_rows}
     prev = load(os.path.join("docs", ".last-verify.json")) if os.path.isfile(os.path.join("docs", ".last-verify.json")) else None
-    if lst.get("scope", "all") != "all" and isinstance(prev, dict) and prev.get("app") in (None, app) \
+    if isinstance(prev, dict) and prev.get("app") in (None, app) \
             and isinstance(prev.get("rows"), dict) and prev.get("mode") != "reconcile":
         for k, v in prev["rows"].items():
-            if k not in all_rows:
+            was = (prev.get("row_phases") or {}).get(k, prev.get("phase"))
+            if k not in all_rows and (lst.get("scope", "all") != "all" or was != phase):
                 all_rows[k] = v
                 row_dates[k] = (prev.get("row_dates") or {}).get(k, prev.get("date", ""))
                 row_runs[k] = (prev.get("row_runs") or {}).get(k, prev.get("run_id", ""))
-    ledger = {"date": today, "app": app, "scope": lst.get("scope", "all"), "booted": boot_text, "gates": checks,
+                if was is not None:
+                    row_phases[k] = was
+    ledger = {"date": today, "app": app, "scope": lst.get("scope", "all"), "phase": phase, "checklist": lst.get("checklist"),
+              "booted": boot_text, "gates": checks,
               "evidence": d, "run_id": started, "rows": all_rows, "row_dates": row_dates, "row_runs": row_runs,
-              "this_run": sorted(ledger_rows)}
+              "row_phases": row_phases, "this_run": sorted(ledger_rows)}
     os.makedirs("docs", exist_ok=True)
     with open(os.path.join("docs", ".last-verify.json"), "w", encoding="utf-8") as f:
         json.dump(ledger, f, indent=1)
     with open(os.path.join(d, "verdicts.json"), "w", encoding="utf-8") as f:
-        json.dump({"app": app, "scope": lst.get("scope", "all"), "date": today, "started": started, "booted": boot_text,
+        json.dump({"app": app, "scope": lst.get("scope", "all"), "phase": phase, "date": today, "started": started, "booted": boot_text,
                    "build_result": "fail" if build_failed else ("pass" if booted else "not-run"), "checks": checks,
                    "checklist": lst.get("checklist"), "rows": rows_out}, f, indent=1)
 
@@ -314,7 +417,7 @@ def main(argv):
     counts = {}
     for x in rows_out:
         counts[x["verdict"]] = counts.get(x["verdict"], 0) + 1
-    print(f"# tf-verify-verdict — {app} — scope {lst.get('scope')} — booted: {boot_text}")
+    print(f"# tf-verify-verdict — {app} — phase {phase} ({lst.get('checklist')}) — scope {lst.get('scope')} — booted: {boot_text}")
     print(f"Checks that ran: {', '.join(checks) or 'none'}. Rows: " + ", ".join(f"{v} {k}" for k, v in sorted(counts.items())))
     print()
     print("| ID | Verdict | First failing check | Status | Detail |")