@techierathore/techieflow 1.0.3 → 1.1.0

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

@@ -4,19 +4,33 @@
 #   bash .tfcore/utils/tf-verify-screens.sh --list tests/.artifacts/verify/list.json --base http://localhost:5099 \
 #        [--login-path /login --user ravi --password '…'] [--cookie 'k=v'] [--storage-state file]
 #   bash .tfcore/utils/tf-verify-screens.sh --screen home=/ --screen posts=/posts --base URL   # a smoke: changed screens only
-#   bash .tfcore/utils/tf-verify-screens.sh --list … --cdp http://172.18.144.1:9223               # a Blazor Hybrid Windows head
+#   bash .tfcore/utils/tf-verify-screens.sh --list … --cdp http://172.18.144.1:9223               # an embedded-browser desktop head
+#   … --error-selector '.my-crash-banner'   # the banner THIS stack shows when its client side falls over
+#                                           # (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
+#   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.
 #
 # 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). Saves a screenshot per screen and width under tests/.artifacts/verify/screens/ and
+# (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,
+# 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.
 # Exit 0 every screen OK · 5 a screen failed · 2 the app was unreachable · 4 Playwright missing.
 set -uo pipefail
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-case "${1:-}" in -h|--help|"") sed -n '2,18p' "$0" | sed 's/^# \{0,1\}//'; exit "${1:+0}${1:-3}" ;; esac
+# `--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 ;;
+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; }
 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; }
-exec node "$HERE/tf-verify-screens.mjs" "$@"
+source "$HERE/tf-lock.sh"; tf_take_lock verify-screens   # one browser check at a time (TF-048)
+node "$HERE/tf-verify-screens.mjs" "$@"

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

@@ -2,37 +2,162 @@
 # tf-verify-tests.sh — run the acceptance tests and map them to rows (Sitting 4c, 2026-09-06).
 #
 #   bash .tfcore/utils/tf-verify-tests.sh [--base URL] [--target <sln|csproj>] [--no-browser] [--no-unit]
+#                                         [--shard N/M] [--spec <file or glob>]… [--list <list.json>] [--all-specs]
 #                                         [--json-out tests/.artifacts/verify/tests.json]
+#   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 every test carrying its id passed, FAIL when one
-# failed (the reason and the screenshot, when the reporter kept one, are recorded), and absent
-# when no test carries its id. Writes tests/.artifacts/verify/tests.json for the verdict script.
+# the row's id (REQ-UI-004 …). 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
+# not exist in the data, which is not a defect (TF-022). Writes tests/.artifacts/verify/tests.json.
+# A suite too long for one command runs in parts (AppManager TF-013): `--shard N/M` runs Playwright's
+# shard N of M (browser only; run the unit tests once with --no-browser), `--spec` names files, and
+# each part writes its own playwright-<part>.json and tests-<part>.json. `--merge` then combines the
+# parts' rows and totals into one tests.json; a later run of the same test stands for it (Lekhak TF-007).
+# 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.
 # Exit 0 ran (whatever the results) · 2 nothing could run.
 set -uo pipefail
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-BASE=""; TARGET=""; BROWSER=1; UNIT=1; OUT="tests/.artifacts/verify/tests.json"
+source "$HERE/tf-portable.sh"   # tf_read_lines, for bash 3.2 on a stock Mac
+BASE=""; TARGET=""; BROWSER=1; UNIT=1; OUT=""; SHARD=""; SPECS=(); MERGE=(); LIST="tests/.artifacts/verify/list.json"; ALLSPECS=0
 while [[ $# -gt 0 ]]; do
   case "$1" in
     --base) BASE="${2:-}"; shift 2 ;;
     --target) TARGET="${2:-}"; shift 2 ;;
     --no-browser) BROWSER=0; shift ;;
     --no-unit) UNIT=0; shift ;;
+    --shard) SHARD="${2:-}"; UNIT=0; shift 2 ;;
+    --spec) SPECS+=("${2:-}"); shift 2 ;;
+    --list) LIST="${2:-}"; shift 2 ;;
+    --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,13p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    -h|--help) sed -n '2,22p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
     *) echo "tf-verify-tests: unknown argument $1" >&2; exit 2 ;;
   esac
 done
+PART=""
+if [[ -n "$SHARD" ]]; then
+  [[ "$SHARD" =~ ^([1-9][0-9]*)/([1-9][0-9]*)$ ]] || { echo "tf-verify-tests: --shard takes N/M, such as 2/4" >&2; exit 2; }
+  PART="${BASH_REMATCH[1]}of${BASH_REMATCH[2]}"
+fi
+[[ -n "$OUT" ]] || OUT="tests/.artifacts/verify/tests${PART:+-$PART}.json"
 mkdir -p "$(dirname "$OUT")" tests/.artifacts/verify
-PWJSON="tests/.artifacts/verify/playwright.json"; PWLOG="tests/.artifacts/verify/playwright.log"; UNITLOG=""; UNITLINE=""
+
+# ---- --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
+# 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
+# written before tests carried their own outcome counts each of its tests as the row's result.
+loaded = []
+for i, p in enumerate(sys.argv[1:]):
+    try:
+        loaded.append((json.load(open(p, encoding="utf-8")), i, p))
+    except Exception as e:
+        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
+for d, _i, p in loaded:
+    parts.append(p)
+    for rid, r in d.get("reqs", {}).items():
+        oc = r.get("outcomes")
+        if oc is None:   # an older part: every test it lists carries the row's result
+            res = {"PASS": "pass", "FAIL": "fail"}.get(r.get("result"), "skip")
+            oc = {t: {"outcome": res, "reason": r.get("reason", "") if res == "fail" else "", "screenshot": r.get("screenshot", "")} for t in r.get("tests", [])}
+            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():
+            old = o.get(name)
+            if old and rec["outcome"] == "skip" and old["outcome"] != "skip":
+                continue
+            if old and old["outcome"] != rec["outcome"]:
+                superseded += 1
+            o[name] = rec
+        src = sources.get(rid)
+        sources[rid] = r.get("source", "") if src in (None, r.get("source", "")) else "browser+unit"
+    b = d.get("browser", {})
+    if b.get("ran"):
+        browser["ran"] = True
+        for k in ("passed", "failed", "skipped", "tests"):
+            browser[k] += b.get(k, 0)
+    u = d.get("unit", {})
+    if u.get("ran") and not unit["ran"]:
+        unit = u
+for rid, o in outs.items():
+    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 "")
+    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},
+          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")
+print(f"merged {len(parts)} part(s): rows with a test: {len(reqs)} — {p} PASS, {f} FAIL, {ns} NOT-TESTED (every clause skipped)"
+      + (f" (browser {browser['passed']}/{browser['tests']} tests passed, {browser['skipped']} skipped)" if browser["ran"] else "")
+      + (f"; {superseded} test(s) ran again in a later part, and the later run stands" if superseded else ""))
+for rid, r in sorted(reqs.items()):
+    if r["result"] == "FAIL":
+        print(f"  FAIL {rid} — {r['reason']}" + (f" — {r['screenshot']}" if r["screenshot"] else ""))
+print(f"JSON: {os.environ['TF_OUT']}")
+PY
+  exit 0
+fi
+
+source "$HERE/tf-lock.sh"; tf_take_lock "verify-tests${PART:+ $PART}"   # one browser check at a time (TF-048)
+PWJSON="tests/.artifacts/verify/playwright${PART:+-$PART}.json"; PWLOG="tests/.artifacts/verify/playwright${PART:+-$PART}.log"; UNITLOG=""; UNITLINE=""
 ran_any=0
 
 if [[ $BROWSER -eq 1 ]]; then
   if ls tests/verify/*.spec.* >/dev/null 2>&1 || ls tests/verify/**/*.spec.* >/dev/null 2>&1; then
-    if node -e "require.resolve('@playwright/test')" >/dev/null 2>&1; then
-      BASE_URL="$BASE" PLAYWRIGHT_JSON_OUTPUT_NAME="$PWJSON" npx playwright test --reporter=json > "$PWLOG" 2>&1
-      echo "browser tests: ran (log $PWLOG)"; ran_any=1
+    # --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
+    # may still be running and pass in the new one's name (TfLens TF-031, 2026-09-11): refuse instead.
+    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 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)
+      # Lekhak TF-017: a verify of a list of ids runs only the browser tests carrying those ids, and
+      # none when no row in scope has a screen and no file under tests/verify/ names one of them. A
+      # verify of one no-screen NFR row ran the whole suite and was stopped at 30 minutes. ui,
+      # functional and all run everything; so do --spec, --all-specs and a run without list.json.
+      SCOPE=""
+      [[ $ALLSPECS -eq 0 && ${#SPECS[@]} -eq 0 && -f "$LIST" ]] && SCOPE="$(python3 - "$LIST" <<'SCOPEPY'
+import json, sys
+try:
+    d = json.load(open(sys.argv[1], encoding="utf-8"))
+except Exception:
+    sys.exit(0)
+if str(d.get("scope", "")).strip().lower() in ("", "ui", "functional", "all"):
+    sys.exit(0)
+rows = d.get("rows", [])
+ids = [r["id"] for r in rows if r.get("id")]
+if ids:
+    print(("screen " if any(r.get("screen") for r in rows) else "none ") + "|".join(ids))
+SCOPEPY
+)"
+      if [[ "$SCOPE" == none\ * ]] && ! grep -rqsE "${SCOPE#none }" tests/verify; then
+        echo "browser tests: skipped — no row in scope (${SCOPE#none }) has a screen and no file under tests/verify/ names one; its tests are unit tests (--all-specs runs every spec anyway)"
+        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
+        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
       echo "browser tests: @playwright/test is not installed here (bash .tfcore/utils/tf-verify-env.sh); skipped"; rm -f "$PWJSON"
     fi
@@ -42,29 +167,96 @@ if [[ $BROWSER -eq 1 ]]; then
 else rm -f "$PWJSON"; fi
 
 if [[ $UNIT -eq 1 ]]; then
-  if [[ -n "$TARGET" ]] || ls *.sln *.slnx >/dev/null 2>&1 || ls tests/*/*.csproj >/dev/null 2>&1; then
-    UNITLINE="$(bash "$HERE/tf-build.sh" test ${TARGET:+"$TARGET"} -- --logger "console;verbosity=normal" 2>&1 | head -1)"
+  # Each pattern on its own: `ls *.sln *.slnx` fails when either matches nothing, so a .slnx-only
+  # solution read as none; and a test project may sit at any depth under tests/, not one folder down
+  # (AppManager TF-007: tests/unit/AppManager.UnitTests/). tf-build.sh finds a root solution itself;
+  # without one it is handed the only test project, and several are named rather than guessed between.
+  ROOTSLN="$(compgen -G '*.sln'; compgen -G '*.slnx'; compgen -G '*.csproj')"
+  tf_read_lines TESTPROJ < <(find tests -name '*.csproj' -not -path 'tests/.artifacts/*' -not -path '*/bin/*' -not -path '*/obj/*' -not -path '*/node_modules/*' 2>/dev/null | sort)
+  [[ -z "$TARGET" && -z "$ROOTSLN" && ${#TESTPROJ[@]} -eq 1 ]] && TARGET="${TESTPROJ[0]}"
+  if [[ -z "$TARGET" && -z "$ROOTSLN" && ${#TESTPROJ[@]} -gt 1 ]]; then
+    echo "unit tests: NOT RUN — no solution here and ${#TESTPROJ[@]} test projects under tests/ (${TESTPROJ[*]}); name one with --target"
+  elif [[ -n "$TARGET" || -n "$ROOTSLN" ]]; then
+    # the VERDICT line, not the first line: tf-build.sh may print a note before it, and a note read
+    # as the verdict left 975 passing TfLens tests recorded as never run (TF-037)
+    # A test project on Microsoft.Testing.Platform ignores --logger and prints no line per test, so no
+    # unit test ever reached a row (AppManager TF-005, xunit.v3, 286 tests). Such a project is asked for
+    # a TRX report, the per-test record both platforms write, through the property `dotnet test` passes
+    # to it. One switch serves every project or none is passed: an unknown switch stops a test app.
+    MTP="$(python3 - <<'PY'
+import os, re
+flags, mtp = set(), 0
+for root, dirs, files in os.walk("."):
+    dirs[:] = [d for d in dirs if d not in ("bin", "obj", "node_modules", ".git") and not (root == "./tests" and d == ".artifacts")]
+    for fn in files:
+        if not fn.endswith(".csproj"):
+            continue
+        t = open(os.path.join(root, fn), encoding="utf-8", errors="replace").read()
+        if not re.search(r"<(TestingPlatformDotnetTestSupport|UseMicrosoftTestingPlatformRunner|EnableMSTestRunner|EnableNUnitRunner)>\s*true", t, re.I) and 'Sdk="MSTest.Sdk' not in t:
+            continue
+        mtp += 1
+        if re.search(r'Include="xunit\.v3"', t, re.I):
+            flags.add("--report-xunit-trx")
+        elif re.search(r'Include="Microsoft\.Testing\.Extensions\.TrxReport"|Sdk="MSTest\.Sdk', t, re.I):
+            flags.add("--report-trx")
+        else:
+            flags.add("?")
+print(next(iter(flags)) if mtp and len(flags) == 1 and "?" not in flags else ("mixed" if mtp else ""))
+PY
+)"
+    UARGS=(--logger "console;verbosity=normal")
+    case "$MTP" in
+      --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)"
+    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"
     echo "unit tests: $UNITLINE"; [[ "$UNITLINE" != NOT-RUN* ]] && ran_any=1
   else
     echo "unit tests: no solution or test project found; skipped"
   fi
 fi
 
-TF_PWJSON="$PWJSON" TF_UNITLOG="$UNITLOG" TF_UNITLINE="$UNITLINE" TF_OUT="$OUT" python3 - <<'PY'
+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)
-reqs, browser, unit = {}, {"ran": False, "passed": 0, "failed": 0, "tests": 0}, {"ran": False, "line": os.environ.get("TF_UNITLINE", "")}
+reqs = {}
+browser = {"ran": False, "passed": 0, "failed": 0, "skipped": 0, "tests": 0}
+unit = {"ran": False, "line": os.environ.get("TF_UNITLINE", "")}
 
-def add(rid, ok, name, source, reason="", shot=""):
-    r = reqs.setdefault(rid.upper(), {"result": "PASS", "source": source, "tests": [], "reason": "", "screenshot": ""})
-    r["tests"].append(name)
-    if not ok:
-        r["result"] = "FAIL"
+def add(rid, outcome, name, source, reason="", shot=""):
+    """Record one test against a row. `outcome` is "pass", "fail" or "skip".
+
+    A SKIPPED clause is the third outcome and neither of the other two. A conditional
+    `test.skip(!SEEDED, "needs the seeded dataset")` says the state does not exist in the
+    data yet: that is not a pass, and it is not a defect either. Counting it as a failure
+    put FAIL on rows no code could clear and sent build-phase back into FIX mode against
+    them (TF-022, TfLens 2026-09-09). A row whose clauses were ALL skipped ends
+    NOT-TESTED, which the verdict script reads as not measured — never Verified, never a
+    defect. tests/regression/run.sh tf_022."""
+    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}
+    if outcome == "skip":
+        r["skipped"].append(name)
         if not r["reason"]:
+            r["reason"] = (reason or "the test was skipped")[:200]
+        return
+    r["tests"].append(name)
+    if outcome == "pass":
+        r["passed"] += 1
+    else:
+        if r["result"] != "FAIL":          # the first real failure owns the reason
             r["reason"] = reason[:200]
+        r["failed"] += 1
         if shot and not r["screenshot"]:
             r["screenshot"] = shot
+    r["result"] = "FAIL" if r["failed"] else "PASS"
 
 pw = os.environ.get("TF_PWJSON", "")
 if pw and os.path.isfile(pw):
@@ -78,11 +270,21 @@ if pw and os.path.isfile(pw):
                     res = t.get("results", [])
                     last = res[-1] if res else {}
                     status = last.get("status", t.get("status", "unexpected"))
-                    ok = status in ("passed", "expected") or t.get("status") == "expected"
+                    # skipped is read FIRST: it is neither a pass nor a failure (TF-022)
+                    if status == "skipped" or t.get("status") == "skipped":
+                        outcome = "skip"
+                    elif status in ("passed", "expected") or t.get("status") == "expected":
+                        outcome = "pass"
+                    else:
+                        outcome = "fail"
                     browser["tests"] += 1
-                    browser["passed" if ok else "failed"] += 1
+                    browser[{"pass": "passed", "fail": "failed", "skip": "skipped"}[outcome]] += 1
                     err = ""
-                    if last.get("error"):
+                    if outcome == "skip":
+                        why = [a.get("description") for a in (t.get("annotations") or [])
+                               if a.get("type") == "skip" and a.get("description")]
+                        err = "skipped" + (": " + str(why[0]) if why else "")
+                    elif last.get("error"):
                         err = re.sub(r"\x1b\[[0-9;]*m", "", str(last["error"].get("message", "")).split("\n")[0])
                     shot = ""
                     for a in last.get("attachments", []):
@@ -91,7 +293,7 @@ if pw and os.path.isfile(pw):
                             shot = shot[shot.find("tests/"):] if "tests/" in shot else shot
                             break
                     for rid in set(ID.findall(title)):
-                        add(rid, ok, title.strip(), "browser", err, shot)
+                        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)
         for s in data.get("suites", []):
@@ -99,25 +301,67 @@ if pw and os.path.isfile(pw):
     except Exception as e:
         browser["error"] = str(e)
 
+seen = set()   # one test read from both a TRX report and the console is counted once
+for trx in [p for p in os.environ.get("TF_TRX", "").splitlines() if p.strip()]:
+    try:
+        tree = ET.parse(trx).getroot()
+    except Exception as e:
+        unit.setdefault("trx_unreadable", []).append(f"{trx}: {str(e)[:80]}")
+        continue
+    unit["ran"] = True
+    unit.setdefault("trx", []).append(trx)
+    for el in tree.iter():
+        if not el.tag.endswith("UnitTestResult"):
+            continue
+        name = (el.get("testName") or "").strip()
+        oc = (el.get("outcome") or "").lower()          # Passed / Failed / NotExecuted …, any case (TF-005)
+        outcome = "pass" if oc == "passed" else "skip" if oc in ("notexecuted", "inconclusive", "pending", "notrunnable", "disconnected") else "fail"
+        if (name, outcome) in seen:
+            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)):
+            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 "")
+
 ul = os.environ.get("TF_UNITLOG", "")
 if ul and os.path.isfile(ul):
     unit["ran"] = True
     for line in open(ul, encoding="utf-8", errors="replace"):
-        m = re.match(r"\s*(Passed|Failed|Skipped)\s+(\S.*?)\s*(\[[^\]]*\])?\s*$", line)
-        if not m or m.group(1) == "Skipped":
+        # any case, and a "(133ms)" tail: the Testing Platform's own log writes "failed REQ-NFR-007 … (133ms)" (TF-005)
+        m = re.match(r"\s*(passed|failed|skipped)\s+(\S.*?)\s*(?:\[[^\]]*\]|\(\d+(?:\.\d+)?\s*m?s\))?\s*$", line, re.I)
+        if not m:
             continue
+        # a skipped unit test is recorded as skipped, not dropped: the row then reads
+        # NOT-TESTED with the evidence, rather than looking as if no test exists (TF-022)
+        outcome = {"passed": "pass", "failed": "fail", "skipped": "skip"}[m.group(1).lower()]
         name = m.group(2).strip()
+        if (name, outcome) in seen:
+            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)):
-            add(rid, m.group(1) == "Passed", name, "unit", "unit test failed: " + name[:120])
+            add(rid, outcome, name, "unit",
+                "unit test failed: " + name[:120] if outcome == "fail"
+                else "unit test skipped: " + name[:120] if outcome == "skip" else "")
 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")
 
-json.dump({"reqs": reqs, "browser": browser, "unit": unit}, open(os.environ["TF_OUT"], "w"), indent=1)
-p = sum(1 for r in reqs.values() if r["result"] == "PASS"); f = len(reqs) - p
-print(f"rows with a test: {len(reqs)} — {p} PASS, {f} FAIL" + (f" (browser {browser['passed']}/{browser['tests']} tests passed)" if browser["ran"] else ""))
+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)
+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")
+print(f"rows with a test: {len(reqs)} — {p} PASS, {f} FAIL, {ns} NOT-TESTED (every clause skipped)"
+      + (f" (browser {browser['passed']}/{browser['tests']} tests passed, {browser['skipped']} skipped)" if browser["ran"] else ""))
 for rid, r in sorted(reqs.items()):
     if r["result"] == "FAIL":
         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']}")
 print(f"JSON: {os.environ['TF_OUT']}")
 PY
 [[ $ran_any -eq 1 ]] && exit 0 || exit 2

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

@@ -19,9 +19,12 @@ For each row, the seven checks in order, and the first that fails is the verdict
   (standards has no script yet and is never listed as run)
 
 Verdicts: PASS · FAIL (acceptance) · BUILD-FAIL · RENDER-FAIL · ASSET-FAIL · VISUAL-FAIL · MOCKUP-FAIL ·
-PERF-FAIL · NOT-TESTED (no test carried the id; the screen checks passed or did not run) ·
+PERF-FAIL · NOT-TESTED (no test carried the id, or every test carrying it was skipped; the screen
+checks passed or did not run) ·
 NOT-OBSERVABLE (an NFR row with no budget and no unit test) · NOT-DRIVEN (its screen was never driven:
-the head could not be booted, or has no driver). A row is Verified only on PASS. NOT-* rows keep their
+the head could not be booted, or has no driver) · DEFECT-OPEN (every check passed, but the old Remarks
+carry a defect no verify can see, tf_defect.py: the row goes to Needs re-verify, and so to a fix, with
+the defect kept; AppManager TF-021). A row is Verified only on PASS. NOT-* rows keep their
 status and get a Remark saying so; nothing is ever written as a static-only pass.
 
 Writes docs/.last-verify.json (the ledger the verify hook reads: date, app, scope, booted, the checks
@@ -37,6 +40,8 @@ import re
 import sys
 
 HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+import tf_defect  # 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",
@@ -70,6 +75,14 @@ def norm_route(r):
     return r or "/"
 
 
+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
+    not-present rule on every verify (Lekhak TF-012)."""
+    s = re.sub(r"\s+", " ", (s or "").replace("`", "'").replace("|", "/")).strip()
+    return f"`{s[:n] if n else s}`" if s else ""
+
+
 def words(s, n=60):
     w = s.split()
     return s if len(w) <= n else " ".join(w[:n]) + "…"   # the ellipsis rides on the last word: the checker counts words, and a bare "…" was a 61st (miss 29)
@@ -91,6 +104,8 @@ def main(argv):
     tests_ran = os.path.isfile(os.path.join(d, "tests.json"))
     screens = load(os.path.join(d, "screens.json")) or {}
     scr_by_name = {s["name"]: s for s in screens.get("screens", [])}
+    # screens tf-verify-screens did not drive because their route needs a sample value (Lekhak TF-005)
+    scr_skipped = {s["name"]: s for s in screens.get("skipped", []) or []}
     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 {}
@@ -114,6 +129,13 @@ def main(argv):
         scr = scr_by_name.get(r.get("screen") or "")
         driven = bool(scr) and scr.get("render") != "UNREACHABLE"
         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
+        # all — never Verified, no gate record (TF-022). `t` is kept for the note.
+        skipped_only = bool(t) and t.get("result") == "NOT-TESTED"
+        if skipped_only:
+            notes.append(f"acceptance not measured ({len(t.get('skipped') or [])} test(s) skipped, none ran)")
+            t = None
         # every check on its own: (name, ran, failed, verdict, class, detail, evidence); the first failure wins
         checks = []
 
@@ -121,7 +143,7 @@ def main(argv):
         checks.append(("build", booted or build_failed, build_failed, "BUILD-FAIL", "build-error", boot.get("reason", "build failed"), ""))
         # 2 acceptance
         if t:
-            checks.append(("acceptance", True, t["result"] != "PASS", "FAIL", "assert-fail", t.get("reason") or "test failed", t.get("screenshot") or ""))
+            checks.append(("acceptance", True, t["result"] != "PASS", "FAIL", "assert-fail", quoted(t.get("reason")) or "test failed", t.get("screenshot") or ""))
         # 3 render
         if scr:
             if scr.get("render") == "UNREACHABLE":
@@ -184,17 +206,21 @@ def main(argv):
                 detail = "NFR row with no perf-budget and no unit test carrying its id"
             elif not t and r.get("screen") and not driven:
                 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: 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"no test named {rid} ran" + (f"; screen {r['screen']} renders and looks right" if driven else "")
+                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:
                 verdict = "NOT-DRIVEN"
                 detail = f"test passed but {boot.get('head', 'the app')} was not driven: {boot.get('reason')}"
             else:
                 verdict = "PASS"
-                parts = [f"test {t['tests'][0][:60]}" if t and t.get("tests") else "test passed"]
+                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'])}")
                 if "mockup-parity" in ran:
@@ -203,22 +229,29 @@ def main(argv):
                     parts.append("within its speed budget")
                 detail = "; ".join(parts)
 
-        status = STATUS.get(verdict, prior)
+        # A defect found by the guide, the owner's testing or production is not in the acceptance line, so
+        # a pass cannot clear it and a rewrite must not erase it (TF-021). tests/regression/run.sh am_021.
+        kept = tf_defect.unseen(r.get("remarks"))
+        if kept and verdict == "PASS":
+            verdict = "DEFECT-OPEN"
+        status = STATUS.get(verdict, "Needs re-verify" if verdict == "DEFECT-OPEN" else prior)
         pct = r.get("pct")
         if verdict == "PASS":
             pct = 100
-        elif verdict in ("RENDER-FAIL", "ASSET-FAIL", "VISUAL-FAIL", "MOCKUP-FAIL", "PERF-FAIL"):
+        elif verdict in ("DEFECT-OPEN", "RENDER-FAIL", "ASSET-FAIL", "VISUAL-FAIL", "MOCKUP-FAIL", "PERF-FAIL"):
             pct = min(pct if pct is not None else 75, 75)
         gate = FAILING.get(verdict)
         marks = {"FAIL": "⚠ acceptance", "BUILD-FAIL": "⚠ build", "RENDER-FAIL": "⚠ render", "ASSET-FAIL": "⚠ assets",
                  "VISUAL-FAIL": "⚠ visual", "MOCKUP-FAIL": "⚠ mockup-parity", "PERF-FAIL": "⚠ perf",
-                 "NOT-TESTED": "not verified", "NOT-OBSERVABLE": "not observable", "NOT-DRIVEN": "not verified", "PASS": "PASS"}
+                 "NOT-TESTED": "not verified", "NOT-OBSERVABLE": "not observable", "NOT-DRIVEN": "not verified", "PASS": "PASS",
+                 "DEFECT-OPEN": "checks pass, defect open"}
         remark = f"{today} verify: {marks[verdict]} — {detail}"
         if evidence:
             remark += f" ({evidence})"
         if notes:
             remark += "; " + "; ".join(notes[:2])
-        remark = words(remark.replace("|", "/"), 60)
+        carried = words(" ".join(kept).replace("|", "/"), 30) if kept else ""
+        remark = words(remark.replace("|", "/"), 60 - len(carried.split())) + (f" {carried}" if carried else "")
         emit = verdict == "PASS" or gate is not None
         row = {"id": rid, "class": r["class"], "verdict": verdict, "gate": gate, "gates_run": ran, "failure_class": cls if gate else None,
                "prior_verdict": prior or None, "status": status, "pct": pct, "remark": remark, "screen": r.get("screen"),
@@ -231,8 +264,23 @@ def main(argv):
     for c in ("build", "acceptance", "render", "assets", "visual", "mockup-parity", "perf"):
         if any(c in x["gates_run"] for x in rows_out):
             checks.append(c)
+    # Lekhak TF-007: a targeted verify rewrote the ledger with its own rows only (395 became 1), so every
+    # other row lost its last verdict. The ledger is kept row by row: a row this run graded is replaced,
+    # 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.
+    all_rows, row_dates, row_runs = dict(ledger_rows), {k: today for k in ledger_rows}, {k: started 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) \
+            and isinstance(prev.get("rows"), dict) and prev.get("mode") != "reconcile":
+        for k, v in prev["rows"].items():
+            if k not in all_rows:
+                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,
-              "evidence": d, "run_id": started, "rows": ledger_rows}
+              "evidence": d, "run_id": started, "rows": all_rows, "row_dates": row_dates, "row_runs": row_runs,
+              "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)
@@ -274,7 +322,7 @@ def main(argv):
     for t in table:
         print("| " + " | ".join(str(x).replace("|", "/") for x in t) + " |")
     print()
-    print(f"Ledger: docs/.last-verify.json ({len(ledger_rows)} rows). Verdicts: {os.path.join(d, 'verdicts.json')}."
+    print(f"Ledger: docs/.last-verify.json ({len(ledger_rows)} rows graded now, {len(all_rows)} in all). Verdicts: {os.path.join(d, 'verdicts.json')}."
           + (f" Checklist: {applied} row(s) rewritten in {lst.get('checklist')}." if apply else " Checklist untouched (no --apply)."))
     return 0
 

package/.tfcore/utils/tf_defect.py

@@ -0,0 +1,27 @@
+"""tf_defect.py — the defect marks the framework's own writers put in a checklist row's Remarks.
+
+devguide.md writes `⚠ DevGuide`, tf-checklist-edit's demote `⚠ UAT bug` / `⚠ prod bug` / `⚠ miss`,
+tf-verify-verdict one mark per failing check, the smoke policy `⚠ visual`, security findings
+`⚠ SECURITY`. A bare ⚠ is not a defect: hand-written remarks use it for "not verifiable here".
+
+Imported by tf-status-facts.py (TF-019), tf-build-list.py (TF-020) and tf-verify-verdict.py (TF-021).
+tests/regression/run.sh am_019, am_020, am_021.
+"""
+import re
+
+# found by a verify check: a new verify grades it again, so its verdict replaces the old mark
+VERIFY = r"acceptance|build|render|assets|visual|mockup-parity|perf"
+# found by another step (guide, owner's testing, production, a miss, a review): no verify sees it
+OTHER = r"DevGuide|UAT bug|prod bug|miss \d{4}-|SECURITY"
+DEFECT = re.compile(rf"⚠\s*(?:{OTHER}|{VERIFY})\b")
+UNSEEN = re.compile(rf"⚠\s*(?:{OTHER})\b")
+
+
+def clauses(remarks, pattern=DEFECT):
+    """The defect clauses of a Remarks cell: each runs from its ⚠ mark to the next ⚠ or the end."""
+    return [c.strip().rstrip(";").strip() for c in re.split(r"(?=⚠)", remarks or "") if pattern.match(c)]
+
+
+def unseen(remarks):
+    """The clauses a verify cannot see, so a verify must neither erase them nor pass over them."""
+    return clauses(remarks, UNSEEN)