@techierathore/techieflow 1.0.4 → 1.1.1

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

@@ -11,6 +11,8 @@
 #                 the row, looked up in runs.jsonl, or left out when there is none
 #   runs.jsonl    one `run` record for the verify pass: cmd verify-phase, the rows touched, the build
 #                 result, whether YOLO was on
+# Run and gate records carry app_phase, the phase whose checklist was graded (list.json). A second pass
+# of one *verify --phase all starts where the first one's record ended (Sevak TF-005).
 # Rows the run could not grade (not tested, not observable, not driven) get no record. Telemetry
 # never blocks: a refused record is printed and the script still exits 0.
 set -u
@@ -39,32 +41,66 @@ v = json.load(open(os.path.join(d, "verdicts.json"), encoding="utf-8"))
 run_id = started or v.get("started") or ""
 now = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
-def emit(stream, rec):
-    p = subprocess.run(["bash", EMIT, stream], input=json.dumps(rec), capture_output=True, text=True)
-    msg = (p.stdout + p.stderr).strip()
-    if p.returncode != 0 or "refus" in msg.lower() or "error" in msg.lower():
-        print(f"  {stream}: not written — {msg.splitlines()[0][:160] if msg else 'no reason printed'}")
-        return False
-    return True
+# A verify chained inside another command is handed that command's start as "the step-0 time", and
+# its record then covered the caller's whole window, so the caller's own record was refused (TF-052).
+# This run's start is its own marker's; with no verify-phase marker (step 0 skipped), when the list
+# was written.
+mk = {}
+try:
+    pj = os.path.join(".tfcore", ".session", "phase.json")
+    if datetime.datetime.now().timestamp() - os.path.getmtime(pj) < 24 * 3600:
+        mk = json.load(open(pj, encoding="utf-8")) or {}
+except Exception:
+    pass
+own, caller = "", (mk.get("outer") or {}).get("cmd") or "an earlier command"
+if mk.get("cmd") == "verify-phase":
+    own = mk.get("started") or ""
+elif mk.get("started") and mk.get("started") == run_id and os.path.isfile(os.path.join(d, "list.json")):
+    own, caller = datetime.datetime.fromtimestamp(os.path.getmtime(os.path.join(d, "list.json")), datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"), mk.get("cmd")
+if own and run_id and own > run_id:
+    print(f"tf-verify-emit: {run_id} is when {caller} started; this verify started {own} and is recorded from then")
+    run_id = own
 
 def q(*args):
     p = subprocess.run(["bash", EMIT, *args], capture_output=True, text=True)
     return p.stdout.strip()
 
-# origin lookup: the last build-phase or fix-issues run that touched the row
 runs_path = os.path.join(q("--where") or "docs/metrics", "runs.jsonl")
-origin = {}
+runs = []
 if os.path.isfile(runs_path):
     for line in open(runs_path, encoding="utf-8", errors="replace"):
         try:
-            r = json.loads(line)
+            runs.append(json.loads(line))
         except Exception:
-            continue
-        if r.get("kind") != "run" or r.get("backfilled") or r.get("cmd") not in ("build-phase", "fix-issues"):
-            continue
-        for rid in r.get("reqs_touched") or []:
-            if r.get("started", "") >= origin.get(rid, ("", ""))[0]:
-                origin[rid] = (r.get("started", ""), r.get("cmd"), (r.get("subagents") or ["flow-master"])[0] if r.get("subagents") else "flow-master")
+            pass
+
+# Sevak TF-005: *verify --phase all is one pass per phase inside one command, all handed the same
+# step-0 time. A pass that finds a run of this app already recorded since that time starts where it
+# ended, so the second pass is not refused as an overlap (SCHEMA §2.7b) and no window is counted twice.
+if run_id:
+    after = [r.get("ended", "") for r in runs if r.get("kind") == "run" and not r.get("backfilled")
+             and r.get("app") in (None, app) and r.get("started", "") >= run_id and r.get("ended", "") > run_id]
+    if after:
+        print(f"tf-verify-emit: a run of {app} was recorded since {run_id}; this pass is recorded from its end, {max(after)}")
+        run_id = max(after)
+phase = v.get("phase")
+
+def emit(stream, rec):
+    p = subprocess.run(["bash", EMIT, stream], input=json.dumps(rec), capture_output=True, text=True)
+    msg = (p.stdout + p.stderr).strip()
+    if p.returncode != 0 or "refus" in msg.lower() or "error" in msg.lower():
+        print(f"  {stream}: not written — {msg.splitlines()[0][:160] if msg else 'no reason printed'}")
+        return False
+    return True
+
+# origin lookup: the last build-phase or fix-issues run that touched the row
+origin = {}
+for r in runs:
+    if r.get("kind") != "run" or r.get("backfilled") or r.get("cmd") not in ("build-phase", "fix-issues"):
+        continue
+    for rid in r.get("reqs_touched") or []:
+        if r.get("started", "") >= origin.get(rid, ("", ""))[0]:
+            origin[rid] = (r.get("started", ""), r.get("cmd"), (r.get("subagents") or ["flow-master"])[0] if r.get("subagents") else "flow-master")
 
 gates = misses = 0
 for row in v["rows"]:
@@ -75,6 +111,8 @@ for row in v["rows"]:
     rec = {"kind": "gate", "app": app, "run_id": run_id, "req_id": rid, "req_class": row["class"],
            "attempt": int(att) if att.isdigit() else 1, "verdict": row["status"], "gate": row["gate"],
            "gates_run": row["gates_run"], "failure_class": row["failure_class"], "prior_verdict": row["prior_verdict"]}
+    if phase:
+        rec["app_phase"] = phase
     if emit("gates", rec):
         gates += 1
     if not row["gate"]:
@@ -104,7 +142,9 @@ rec = {"kind": "run", "app": app, "cmd": "verify-phase", "mode": mode, "yolo": y
        "build_result": v.get("build_result", "not-run")}
 if run_id:
     rec["started"] = run_id
+if phase:
+    rec["app_phase"] = phase
 ok = emit("runs", rec)
-print(f"telemetry: {gates} gate record(s), {misses} new miss(es), run record {'written' if ok else 'not written'} (cmd verify-phase, yolo {str(yolo).lower()})")
+print(f"telemetry: {gates} gate record(s), {misses} new miss(es), run record {'written' if ok else 'not written'} (cmd verify-phase, phase {phase or '?'}, yolo {str(yolo).lower()})")
 PY
 exit 0

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

@@ -4,17 +4,30 @@
 #   bash .tfcore/utils/tf-verify-env.sh [--check]
 #
 # Ensures, in the current project: package.json; the playwright and @playwright/test packages;
-# the Chromium browser; playwright.config.ts with its output pinned under tests/.artifacts/;
+# the Chromium browser; playwright.config.ts with its output pinned under tests/.artifacts/ and its
+# address read from BASE_URL, which tf-verify-tests.sh --base sets (TF-031);
 # the .gitignore lines for everything this tooling generates. --check reports and changes nothing.
 # Prints one line per item and READY at the end, or NOT-READY with the one command the owner
 # must run once (only when a browser install needs sudo and sudo is unavailable).
 # Exit 0 ready · 1 not ready · 2 node or npm missing.
 set -u
+source "$(dirname "${BASH_SOURCE[0]}")/tf-portable.sh"   # tf_sed_inplace: GNU and BSD sed
 CHECK=0; [[ "${1:-}" == "--check" ]] && CHECK=1
 command -v node >/dev/null 2>&1 && command -v npm >/dev/null 2>&1 || { echo "NOT-READY node and npm are required"; exit 2; }
 ok=1
 
 say() { echo "  $*"; }
+# cfg_sub FILE ALL ERE TEXT: replace the first match of ERE on each line (ALL=1), or only on the
+# first line that matches (ALL=0, what GNU sed's 0,/re/ address did), with TEXT; \n in TEXT is a
+# newline. awk, so it reads the same on GNU and BSD systems.
+cfg_sub() {
+  local tmp
+  tmp="$(mktemp "$1.XXXXXX")" || return 1
+  awk -v all="$2" -v re="$3" -v rep="$4" '
+    (all == 1 || !done) && match($0, re) { $0 = substr($0, 1, RSTART - 1) rep substr($0, RSTART + RLENGTH); done = 1 }
+    { print }' "$1" > "$tmp" && cat "$tmp" > "$1"
+  rm -f "$tmp"
+}
 
 # package.json
 if [[ ! -f package.json ]]; then
@@ -55,7 +68,7 @@ export default defineConfig({
   testDir: '"'"'./tests/verify'"'"',
   outputDir: '"'"'./tests/.artifacts/test-results'"'"',
   reporter: '"'"'line'"'"',
-  use: { headless: true, screenshot: '"'"'only-on-failure'"'"', trace: '"'"'retain-on-failure'"'"' },
+  use: { baseURL: process.env.BASE_URL, headless: true, screenshot: '"'"'only-on-failure'"'"', trace: '"'"'retain-on-failure'"'"' },
 });'
 if [[ ! -f playwright.config.ts ]]; then
   if [[ $CHECK -eq 1 ]]; then say "playwright.config.ts: missing"; ok=0; else printf '%s\n' "$CFG" > playwright.config.ts; say "playwright.config.ts: written"; fi
@@ -63,13 +76,29 @@ elif ! grep -q "tests/.artifacts" playwright.config.ts; then
   if [[ $CHECK -eq 1 ]]; then say "playwright.config.ts: outputDir not under tests/.artifacts"; ok=0
   else
     if grep -q "outputDir" playwright.config.ts; then
-      sed -i "s#outputDir:[^,]*,#outputDir: './tests/.artifacts/test-results',#" playwright.config.ts
+      tf_sed_inplace "s#outputDir:[^,]*,#outputDir: './tests/.artifacts/test-results',#" playwright.config.ts
     else
-      sed -i "s#defineConfig({#defineConfig({\n  outputDir: './tests/.artifacts/test-results',#" playwright.config.ts
+      cfg_sub playwright.config.ts 1 "defineConfig[(][{]" "defineConfig({\n  outputDir: './tests/.artifacts/test-results',"
     fi
     say "playwright.config.ts: outputDir pinned under tests/.artifacts"
   fi
 else say "playwright.config.ts: present, output pinned"; fi
+# the address: tf-verify-tests.sh --base passes it as BASE_URL, which Playwright never reads by
+# itself; a config that ignores it tests whatever is on its default port, an older build included
+# (TfLens TF-031, 2026-09-11). A baseURL of the project's own is kept, as the fallback.
+if [[ -f playwright.config.ts ]] && ! grep -q "BASE_URL" playwright.config.ts; then
+  if [[ $CHECK -eq 1 ]]; then say "playwright.config.ts: does not read BASE_URL, so --base is ignored"; ok=0
+  elif grep -qE "baseURL[\"']?[[:space:]]*:" playwright.config.ts; then
+    tf_sed_inplace -E "s#(baseURL[\"']?[[:space:]]*:[[:space:]]*)#\1process.env.BASE_URL || #" playwright.config.ts
+    say "playwright.config.ts: baseURL now reads BASE_URL first, its own address after"
+  elif grep -qE "use[[:space:]]*:[[:space:]]*\{" playwright.config.ts; then
+    cfg_sub playwright.config.ts 0 "use[[:space:]]*:[[:space:]]*[{]" "use: { baseURL: process.env.BASE_URL,"
+    say "playwright.config.ts: baseURL added, read from BASE_URL"
+  else
+    cfg_sub playwright.config.ts 0 "defineConfig[(][{]" "defineConfig({\n  use: { baseURL: process.env.BASE_URL },"
+    say "playwright.config.ts: baseURL added, read from BASE_URL"
+  fi
+fi
 
 # .gitignore
 missing=()

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

@@ -1,19 +1,24 @@
 #!/usr/bin/env python3
 """tf-verify-list.py — the working list of a verify run (see tf-verify-list.sh).
 
-    bash .tfcore/utils/tf-verify-list.sh <App> <scope> [--phase N] [--json-out <file>]
+    bash .tfcore/utils/tf-verify-list.sh <App> <scope> [--phase N|all] [--json-out <file>]
 
 scope: ui (REQ-UI rows) · functional (REQ-FN, REQ-NFR, REQ-RAG) · all · a comma list of ids.
+--phase N grades phase N's checklist (default appPhase); --phase all only prints the phases that have
+a checklist, phase 1 first, as "PHASES 1 2 3", and writes nothing: the task runs one pass per phase.
 Reads the phase's checklist, the UIDesign, the BRD screens table and the UsageGuide, and prints:
   - every row in scope with its status, acceptance line, screen, route, mockup and perf budget;
     N/A rows are skipped, every other status is graded (a Verified row is re-confirmed)
   - the screens to drive, each with its route, its mockup and the rows it owns; a dialog row
     is listed under its parent screen (Schemas §2: a dialog is verified on its page)
   - rows whose screen could not be resolved (graded by their test only)
-  - the test users from the UsageGuide
+  - the test users from the UsageGuide, as plain text (no Markdown)
+  - for each screen, from the code: the page file that serves its route, that file's project, and
+    the labels of the links or buttons to click from the app's menu to reach it (Lekhak TF-027)
 Writes the same as JSON (default tests/.artifacts/verify/list.json) for the other verify scripts.
 Python 3 standard library only. Exit 0 printed, 2 could not run.
 """
+import html
 import json
 import os
 import re
@@ -71,14 +76,22 @@ def entries_of(text):
     out, current = {}, ""
     lines = text.splitlines()
     for i, line in enumerate(lines):
-        m = re.match(r"^##\s+(.+)$", line)
+        # a heading one level down (`### Page: …` under `## UI / Pages`) names the section too, and any
+        # other one (`### Cross-page: …`) ends the page above it
+        m = re.match(r"^#{2,3}\s+(.+)$", line)
         if m:
             current = re.sub(r"^(?:page|screen)\s*:\s*", "", m.group(1).strip(), flags=re.I)
             continue
         a = re.search(r"<a id=['\"]d-(req-[a-z]+-\d+)['\"]", line, re.I)
         if a:
             rid = a.group(1).upper()
-            e = {"section": current, "acceptance": "", "mockup": "", "brd": "", "perf_budget": ""}
+            # an anchor written above its own page heading belongs to that page, not the one before
+            # (AppManager's older entries: `<a id>` then `### Page:` then the row)
+            nxt = next((l for l in lines[i + 1:i + 3] if l.strip()), "")
+            h = re.match(r"^#{2,3}\s+(?:page|screen)\s*:\s*(.+)$", nxt, re.I)
+            if h:
+                current = h.group(1).strip()
+            e = {"section": current, "acceptance": "", "mockup": "", "brd": "", "perf_budget": "", "zoom_check": ""}
             for j in range(i, min(i + 14, len(lines))):
                 l = lines[j]
                 if re.search(r"\*Acceptance:?\*|^\s*[-*]\s*Acceptance:", l, re.I) and not e["acceptance"]:
@@ -92,6 +105,9 @@ def entries_of(text):
                 pb = re.search(r"perf-budget:\s*([^|`]+)", l)
                 if pb and not e["perf_budget"]:
                     e["perf_budget"] = pb.group(1).strip()
+                zc = re.search(r"zoom-check:\s*(keys|kept)\b", l)   # coding-standards-dotnet.md §9b
+                if zc and not e["zoom_check"]:
+                    e["zoom_check"] = zc.group(1)
                 if j > i and re.match(r"^\s*(?:[-*]\s*)?<a id=|^## ", l):
                     break   # the next entry starts: nothing below belongs to this row
             out[rid] = e
@@ -109,11 +125,62 @@ def screens_of_uidesign(path):
         m = re.match(r"###\s+Screen:\s*(.+?)\s*\(`?([^)`]+)`?\)\s*$", p.splitlines()[0] if p.strip() else "")
         if not m:
             continue
-        mk = re.search(r"((?:docs/)?mockups/[\w./-]+\.html)", p)
-        mock = mk.group(1) if mk else ""
-        if mock and not mock.startswith("docs/"):
-            mock = "docs/" + mock
-        out.append({"name": m.group(1).strip(), "route": m.group(2).strip(), "mockup": mock})
+        mocks = []
+        for mk in re.findall(r"((?:docs/)?mockups/[\w./-]+\.html)", p):
+            mk = mk if mk.startswith("docs/") else "docs/" + mk
+            if mk not in mocks:
+                mocks.append(mk)
+        name, route = m.group(1).strip(), m.group(2).strip()
+        tabs = split_by_mockup(name, route, mocks)
+        out.extend(tabs or [{"name": name, "route": route, "mockup": mocks[0] if mocks else ""}])
+    return out
+
+
+def split_by_mockup(name, route, mocks):
+    """One screen per mockup when the route takes one value and the entry links a mockup per value:
+    `/settings/{tab}` with settings-providers.html, settings-agents.html … is seven screens,
+    `/settings/providers` and so on. Kept as one screen it was never driven, and its rows were
+    Verified on their tests alone (Chatur TF-003). [] when the route or the mockups do not fit."""
+    params = re.findall(r"\{[^}]+\}", route)
+    if len(params) != 1 or len(mocks) < 2:
+        return []
+    stems = [os.path.basename(m)[:-5] for m in mocks]
+    prefix = os.path.commonprefix(stems)
+    prefix = prefix[:prefix.rfind("-") + 1] if "-" in prefix else ""
+    values = [s[len(prefix):] for s in stems]
+    if not prefix or not all(re.fullmatch(r"[a-z0-9][a-z0-9-]*", v) for v in values):
+        return []
+    return [{"name": f"{name} / {v}", "route": route.replace(params[0], v), "mockup": mk,
+             "route_pattern": route, "parent": name} for v, mk in zip(values, mocks)]
+
+
+def seed_of(screen):
+    """tests/verify/seed/<mockup name>.sh, when the project has one: it puts the running app in the
+    state the mockup draws before the screen is driven (Chatur TF-002). tf-verify-screens runs it."""
+    stem = os.path.basename(screen.get("mockup") or "")[:-5] or re.sub(r"[^a-z0-9]+", "-", screen["name"].lower()).strip("-")
+    p = os.path.join("tests", "verify", "seed", f"{stem}.sh")
+    return p if os.path.isfile(p) else ""
+
+
+def screens_of_checklist(text, ent):
+    """[{name, route, mockup}] from the checklist's own '## Page: Name (`/route`, …)' headings, at ## or
+    ###, for a project with no UIDesign: the first route that can be opened as typed (no `{id}`),
+    the mockup from the first entry under the heading. A heading with no such route names no screen.
+    Without this every UI row of such a project was graded by its test only (AppManager TF-016)."""
+    out, seen = [], set()
+    for line in text.splitlines():
+        m = re.match(r"^#{2,3}\s+(?:page|screen)\s*:\s*(.+?)\s*\((.*)\)\s*$", line, re.I)
+        if not m or norm_name(m.group(1)) in seen:
+            continue
+        inner = m.group(2)
+        cands = re.findall(r"`([^`]+)`", inner) or re.split(r"\s*,\s*", inner)
+        route = next((c.strip() for c in cands if c.strip().startswith("/") and "{" not in c and " " not in c.strip()), "")
+        if not route:
+            continue
+        section = re.sub(r"^#+\s+(?:page|screen)\s*:\s*", "", line.strip(), flags=re.I)
+        mock = next((e["mockup"] for e in ent.values() if e["section"] == section and e["mockup"]), "")
+        seen.add(norm_name(m.group(1)))
+        out.append({"name": m.group(1).strip(), "route": route, "mockup": mock, "section": section})
     return out
 
 
@@ -131,17 +198,158 @@ def dialogs_of_brd(path):
     return out
 
 
+def usage_guide(app):
+    """docs/{App}-UsageGuide.md, or docs/{App}-Usage-Guide.md: the two spellings tf-doc-check.py
+    accepts. Only the first was looked for, so AppManager's guide read as having no test users
+    (AppManager TF-009)."""
+    for name in (f"{app}-UsageGuide.md", f"{app}-Usage-Guide.md"):
+        p = os.path.join("docs", name)
+        if os.path.isfile(p):
+            return p
+    return os.path.join("docs", f"{app}-UsageGuide.md")
+
+
+def plain(cell):
+    """A Markdown table cell as plain text: code spans, emphasis and links unwrapped."""
+    t = re.sub(r"\[([^\]]*)\]\([^)]*\)", r"\1", cell)
+    t = re.sub(r"`([^`]*)`", r"\1", t).replace("`", "")
+    return re.sub(r"(\*\*|__|\*)", "", t).strip()
+
+
+# --- how each screen is reached, read from the code (Lekhak TF-027) ---------------------------------
+# A Blazor Hybrid head on a Mac shows mac2 no data-testid and no URL, so its screens are reached by
+# clicking what a person clicks. The code says what that is: a page declares its route with @page, and
+# a link or button anywhere names a route in href/Href with its visible text. A link in a file that is
+# not a page (a layout, the menu) is on every screen; a link on a page is on that page only. Only the
+# code of the screen's own project and the projects it references counts, so a website page is never
+# looked for in the desktop app's menu.
+CODE_DIRS = ("src", "source")
+SKIP_DIRS = {"bin", "obj", "node_modules", ".git", ".tfbuild", "tests", "wwwroot"}
+LINK = re.compile(r"<([A-Za-z][\w.]*)\b([^>]*?)\b[Hh]ref\s*=\s*\"([^\"]+)\"([^>]*)>(.*?)</\1\s*>", re.S)
+
+
+def route_key(r):
+    """'/admin/llm-signin/{ProviderId:long}' and 'admin/llm-signin/@p.Id' -> ('admin', 'llm-signin', '*')"""
+    r = re.split(r"[?#]", r.strip())[0].strip("/").lower()
+    return tuple("*" if ("{" in seg or "@" in seg) else seg for seg in r.split("/")) if r else ()
+
+
+def label_of(inner):
+    t = re.sub(r"<[^>]+>", " ", inner)
+    if "@" in t:
+        return ""                                    # a label the code computes is not known here
+    t = html.unescape(t)
+    t = "".join(ch for ch in t if ch.isalnum() or ch in " +-'&/.,()")   # icon glyphs out
+    return re.sub(r"\s+", " ", t).strip()
+
+
+def code_map():
+    """-> projects {dir: [referenced dirs]}, pages {route_key: (file, project dir)}, links [(file, own keys, project, key, label)]"""
+    projects, pages, links, files = {}, {}, [], []
+    for top in CODE_DIRS:
+        for d, subs, names in os.walk(top):
+            subs[:] = [x for x in subs if x not in SKIP_DIRS and not x.startswith(".")]
+            for n in names:
+                p = os.path.join(d, n)
+                if n.endswith(".csproj"):
+                    refs = re.findall(r'<ProjectReference\s+Include="([^"]+)"', read(p))
+                    projects[d] = [os.path.normpath(os.path.join(d, os.path.dirname(x.replace("\\", "/")))) for x in refs]
+                elif n.endswith(".razor") or n.endswith(".cshtml"):
+                    files.append(p)
+    def project_of(f):
+        d = os.path.dirname(f)
+        while d and d not in projects:
+            nd = os.path.dirname(d)
+            if nd == d:
+                return ""
+            d = nd
+        return d
+    for f in files:
+        t = read(f)
+        own = [route_key(r) for r in re.findall(r'(?m)^\s*@page\s+"([^"]+)"', t)]
+        for k in own:
+            pages.setdefault(k, (f, project_of(f)))
+        for m in LINK.finditer(t):
+            lab = label_of(m.group(5))
+            if lab and not m.group(3).startswith(("http:", "https:", "mailto:", "#")):
+                links.append((f, own, project_of(f), route_key(m.group(3)), lab))
+    return projects, pages, links
+
+
+def closure(projects, d):
+    seen, todo = [], [d]
+    while todo:
+        x = todo.pop()
+        if x in seen:
+            continue
+        seen.append(x)
+        todo.extend(projects.get(x, []))
+    return seen
+
+
+def matches(a, b):
+    return len(a) == len(b) and all(x == y or "*" in (x, y) for x, y in zip(a, b))
+
+
+def navigation(screens):
+    """Adds page, project and nav (labels to click, in order) to each screen the code serves."""
+    projects, pages, links = code_map()
+    for s in screens:
+        k = route_key(s["route"])
+        hit = next(((f, pr) for pk, (f, pr) in pages.items() if matches(pk, k)), None)
+        if not hit:
+            continue
+        s["page"], s["project"] = hit[0], hit[1]
+        scope = set(closure(projects, hit[1]))
+        mine = [l for l in links if l[2] in scope]
+        # breadth first, from the links on every screen (a layout, the menu: files that are not pages)
+        paths, todo = {}, []
+        for f, own, _, to, lab in mine:
+            if not own and to not in paths:
+                paths[to] = [lab]; todo.append(to)
+        while todo:
+            cur = todo.pop(0)
+            for f, own, _, to, lab in mine:
+                if any(matches(o, cur) for o in own) and to not in paths:
+                    paths[to] = paths[cur] + [lab]; todo.append(to)
+        nav = next((p for to, p in paths.items() if matches(to, k)), None)
+        if nav is not None:
+            s["nav"] = nav
+
+
 def test_users(path):
+    """The rows of the guide's Test users table. The heading may sit at ## or ### (a guide that
+    numbers its chapters nests it one level down), and the table may be the template's
+    `| # | User | Password source | Role |` or any table whose header names a user or email column
+    and a role column, read by those names (AppManager TF-009)."""
     users = []
     if not os.path.isfile(path):
         return users
-    m = re.search(r"(?ms)^##\s+(?:\d+[.)]\s*)?Test users[^\n]*\n(.*?)(?=^## |\Z)", read(path))
+    m = re.search(r"(?ms)^#{2,3}\s+(?:\d+[.)]\s*)?Test users[^\n]*\n(.*?)(?=^#{1,3} |\Z)", read(path))
     if not m:
         return users
+    cols = None
     for line in m.group(1).splitlines():
-        c = [x.strip().strip("`* ") for x in line.strip().strip("|").split("|")]
-        if len(c) >= 4 and c[0].isdigit():
-            users.append({"user": c[1], "password_source": c[2], "role": c[3]})
+        if not line.strip().startswith("|"):
+            continue
+        c = [x.strip() for x in line.strip().strip("|").split("|")]
+        if cols is None:
+            low = [x.lower() for x in c]
+            def col(*names):
+                return next((i for i, h in enumerate(low) if any(n in h for n in names)), None)
+            cols = {"user": col("user", "email", "login", "account"), "pw": col("password", "secret"), "role": col("role")}
+            if cols["user"] is None or cols["role"] is None:
+                cols = {"user": 1, "pw": 2, "role": 3}      # the template's numbered shape
+            continue
+        if set("".join(c)) <= set("-: "):
+            continue                                        # the header rule
+        if len(c) > max(cols["user"], cols["role"]) and plain(c[cols["user"]]) and not plain(c[cols["user"]]).isdigit():
+            # The cell is Markdown. The user is its first code span when it has one ("`a@b.c` (username
+            # `a`)" is a@b.c); every field is plain text, never with a stray backtick (Lekhak TF-027).
+            u = re.match(r"\s*`([^`]+)`", c[cols["user"]])
+            users.append({"user": u.group(1).strip() if u else plain(c[cols["user"]]),
+                          "password_source": plain(c[cols["pw"]]) if cols["pw"] is not None and len(c) > cols["pw"] else "",
+                          "role": plain(c[cols["role"]])})
     return users
 
 
@@ -166,32 +374,67 @@ def screen_from_acceptance(acc):
     return hits[-1].strip() if hits else ""
 
 
+def checklist_of(app, phase):
+    return os.path.join("docs", f"{app}-Checklist.md" if phase <= 1 else f"{app}-P{phase}-Checklist.md")
+
+
+def phases_of(app):
+    """The phase numbers that have a checklist, phase 1 first."""
+    found = [1] if os.path.isfile(checklist_of(app, 1)) else []
+    for f in os.listdir("docs") if os.path.isdir("docs") else []:
+        m = re.fullmatch(re.escape(app) + r"-P(\d+)-Checklist\.md", f)
+        if m and int(m.group(1)) > 1:
+            found.append(int(m.group(1)))
+    return sorted(set(found))
+
+
 def main(argv):
     if len(argv) < 3 or argv[1] in ("-h", "--help"):
         print(__doc__)
         return 0
     app, scope = argv[1], argv[2]
+    # Sevak TF-005: *verify graded only appPhase's checklist, so phases 1 and 2 (86 rows waiting) were
+    # never graded. --phase N grades that phase's checklist; --phase all prints the phases to grade, in
+    # order, and the task runs one pass per phase. Every later script reads the checklist from list.json.
+    have = phases_of(app)
     phase = int(cfg("appPhase", "1"))
     if "--phase" in argv:
-        phase = int(argv[argv.index("--phase") + 1])
+        val = argv[argv.index("--phase") + 1] if argv.index("--phase") + 1 < len(argv) else ""
+        if val == "all":
+            if not have:
+                die(f"no checklist for {app} under docs/")
+            print(f"# tf-verify-list — {app} — phase all — scope {scope}")
+            print("PHASES " + " ".join(str(p) for p in have))
+            print("Grade them one at a time, in this order: steps 1 and 4 to 6 of verify-phase.md with "
+                  + ", then ".join(f"--phase {p} ({checklist_of(app, p)})" for p in have) + ". Nothing was written.")
+            return 0
+        if not val.isdigit() or int(val) < 1:
+            die(f"--phase takes a phase number or all, not {val or 'nothing'}")
+        phase = int(val)
     out_path = os.path.join("tests", ".artifacts", "verify", "list.json")
     if "--json-out" in argv:
         out_path = argv[argv.index("--json-out") + 1]
     pfx = f"{app}-" if phase <= 1 else f"{app}-P{phase}-"
-    cl = os.path.join("docs", f"{pfx}Checklist.md")
+    cl = checklist_of(app, phase)
     if not os.path.isfile(cl):
-        die(f"{cl} does not exist")
+        die(f"{cl} does not exist" + (f"; the phases with a checklist are {', '.join(map(str, have))}" if have else ""))
     text = read(cl)
     rows = rows_of(text)
     if not rows:
         die(f"{cl} has no REQ rows")
     ent = entries_of(text)
-    screens = screens_of_uidesign(os.path.join("docs", f"{pfx}UIDesign.md"))
+    screens, source = screens_of_uidesign(os.path.join("docs", f"{pfx}UIDesign.md")), "UIDesign"
+    if not screens:
+        screens, source = screens_of_checklist(text, ent), "checklist's Page headings"
     dialogs = dialogs_of_brd(os.path.join("docs", f"{pfx}BRD.md"))
-    users = test_users(os.path.join("docs", f"{app}-UsageGuide.md"))
+    users = test_users(usage_guide(app))
     by_name = {norm_name(s["name"]): s for s in screens}
+    for s in screens:                   # a split screen's own name reaches its first tab (Chatur TF-003)
+        if s.get("parent"):
+            by_name.setdefault(norm_name(s["parent"]), s)
     by_mock = {s["mockup"]: s for s in screens if s["mockup"]}
     by_route = {s["route"].lower(): s for s in screens}
+    by_section = {s["section"]: s for s in screens if s.get("section")}
 
     work, skipped, unresolved = [], 0, []
     for r in rows:
@@ -200,10 +443,15 @@ def main(argv):
         if r["status"] in NA:
             skipped += 1
             continue
-        e = ent.get(r["id"], {"section": "", "acceptance": "", "mockup": "", "brd": "", "perf_budget": ""})
+        e = ent.get(r["id"], {"section": "", "acceptance": "", "mockup": "", "brd": "", "perf_budget": "", "zoom_check": ""})
         row = dict(r, acceptance=e["acceptance"], mockup=e["mockup"], brd=e["brd"], perf_budget=e["perf_budget"],
+                   zoom_check=e.get("zoom_check", ""),
                    section=e["section"], screen="", route="", dialog="")
         cand = [screen_from_acceptance(e["acceptance"]), e["section"], r["title"]]
+        if e["section"] in by_section:     # a screen read from the checklist: the heading the row sits under
+            s = by_section[e["section"]]
+            row["screen"], row["route"] = s["name"], s["route"]
+            cand = []
         for c in cand:
             n = norm_name(c)
             if not n:
@@ -218,6 +466,10 @@ def main(argv):
         if not row["screen"] and e["mockup"] in by_mock:
             s = by_mock[e["mockup"]]
             row["screen"], row["route"] = s["name"], s["route"]
+        # a row on a split screen belongs to the tab whose mockup it names
+        tab = by_mock.get(e["mockup"])
+        if row["screen"] and tab and tab.get("parent") and by_name.get(norm_name(row["screen"]), {}).get("parent") == tab["parent"]:
+            row["screen"], row["route"] = tab["name"], tab["route"]
         if not row["screen"] and row["class"] != "NFR":
             unresolved.append(row["id"])
         work.append(row)
@@ -226,7 +478,8 @@ def main(argv):
     for s in screens:
         owned = [r["id"] for r in work if r["screen"] == s["name"]]
         if owned:
-            screen_list.append(dict(s, rows=owned))
+            screen_list.append(dict(s, rows=owned, seed=seed_of(s)))
+    navigation(screen_list)
 
     print(f"# tf-verify-list — {app} — {cl} — phase {phase} — scope {scope}")
     counts = {}
@@ -236,14 +489,27 @@ def main(argv):
     if not work:
         print("NOTHING: no row in scope. Run the status gate and stop.")
     print()
-    print(f"## Screens to drive ({len(screen_list)} of {len(screens)} in the UIDesign)")
+    print(f"## Screens to drive ({len(screen_list)} of {len(screens)} in the {source})")
     for s in screen_list:
-        print(f"- {s['name']} ({s['route']}) — mockup {s['mockup'] or 'none'} — rows {', '.join(s['rows'])}")
+        print(f"- {s['name']} ({s['route']}) — mockup {s['mockup'] or 'none'}"
+              + (f" — seed {s['seed']}" if s["seed"] else "")
+              + (f" — served by {s['project']}" if s.get("project") else "")
+              + (f" — reached by clicking {' > '.join(repr(x) for x in s['nav'])}" if s.get("nav") else "")
+              + f" — rows {', '.join(s['rows'])}")
+    par = [f"--screen {os.path.basename(s['mockup'])[:-5]}={s['route']}" for s in screen_list
+           if s["mockup"] and "{" not in s["route"]]
+    if par:
+        # --list carries each screen's mockup path: the --screen name is the file's stem only, so
+        # docs/mockups/admin/prompt-manager.html read as NO-MOCKUP (Lekhak TF-022)
+        print(f"Mockup parity: {' '.join(par)} --list {out_path}")
     print()
     print("## Rows")
     for r in work:
         where = f"{r['screen']} {r['route']}" + (f" — dialog {r['dialog']}" if r["dialog"] else "") if r["screen"] else "no screen resolved"
-        extra = f" — perf-budget: {r['perf_budget']}" if r["perf_budget"] else ""
+        extra = (f" — perf-budget: {r['perf_budget']}" if r["perf_budget"] else "") \
+            + (f" — zoom-check: {r['zoom_check']} (bash .tfcore/utils/tf-verify-zoom.sh --appium|--cdp <url>"
+               + (" --expect-restored 1.3, after a run with --leave 3 and a restart" if r.get("zoom_check") == "kept" else "")
+               + f" --json-out tests/.artifacts/verify/zoom/{r['id']}.json)" if r.get("zoom_check") else "")
         print(f"- {r['id']} [{r['status_raw']}] {r['title']} — {where}{extra}")
         print(f"    acceptance: {r['acceptance'] or 'MISSING — the row cannot be graded; fix the checklist'}")
     if unresolved:
@@ -259,7 +525,7 @@ def main(argv):
     os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
     with open(out_path, "w", encoding="utf-8") as f:
         json.dump({"app": app, "scope": scope, "phase": phase, "kind": cfg("appKind", "app"), "checklist": cl,
-                   "rows": work, "screens": screen_list, "unresolved": unresolved, "test_users": users,
+                   "rows": work, "screens": screen_list, "screens_source": source, "unresolved": unresolved, "test_users": users,
                    "skipped_na": skipped, "total": len(rows)}, f, indent=1)
     print()
     print(f"JSON: {out_path}")

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

@@ -1,8 +1,10 @@
 #!/usr/bin/env bash
 # tf-verify-list.sh — the working list of a verify run (Sitting 4c, 2026-09-06).
 #
-#   bash .tfcore/utils/tf-verify-list.sh <App> <scope> [--phase N] [--json-out <file>]
+#   bash .tfcore/utils/tf-verify-list.sh <App> <scope> [--phase N|all] [--json-out <file>]
 #
+# --phase N grades phase N's checklist (default appPhase); --phase all prints the phases to grade, in
+# order, and writes nothing (Sevak TF-005).
 # scope: ui · functional · all · a comma list of REQ ids. Prints every row to grade with its
 # acceptance line, screen, route, mockup and perf budget, the screens to drive, and the test
 # users; writes tests/.artifacts/verify/list.json for the other verify scripts. Skips N/A rows