@techierathore/techieflow 1.1.0 → 1.2.0

package/.tfcore/utils/tf-doc-check.py

@@ -30,6 +30,7 @@ Schema grammar (one `key: value` per line inside the comment):
 from __future__ import annotations
 
 import argparse
+import glob
 import json
 import os
 import re
@@ -70,7 +71,9 @@ DOC_NAME = re.compile(
     r"^(.+?)(?:-P(\d+))?-(BRD|Deployment-Checklist(?:-[\w]+)?|Checklist|UIDesign|DevGuide|Architecture|Coding-Standards|UsageGuide|Usage-Guide|ProductGuide|Phases)\.md$",
     re.I)
 PHASE_FORM = re.compile(r"^(\d+)\s+of\s+(\d+)$", re.I)
-PHASE_STATUS = {"planned", "building", "done"}
+# kept-whole: a phase finished before the size cap that the owner chose to keep as one document;
+# its cap and word maximum are reported as WARN, not FAIL (Lekhak TF-029)
+PHASE_STATUS = {"planned", "building", "done", "kept-whole"}
 BRD_RANGE = re.compile(r"(?:BRD-)?(\d+)\s*(?:to|-|–|—)\s*(?:BRD-)?(\d+)", re.I)
 
 SIZE_NAMES = {"s": "S", "small": "S", "m": "M", "medium": "M", "l": "L", "large": "L"}
@@ -96,9 +99,10 @@ NAMES_SCREEN = re.compile(r"\b(on|opens?|from|in)\b", re.I)
 
 
 def acceptance_words(line: str) -> int:
-    """Words in an acceptance line, without the "Acceptance:" label and without a perf-budget tail."""
+    """Words in an acceptance line, without the "Acceptance:" label and without a perf-budget or
+    zoom-check tail (the markers the verifier reads)."""
     t = re.sub(r"^\s*[-*]\s*\*?Acceptance:?\*?:?\s*", "", line)
-    t = re.split(r"perf-budget:", t, flags=re.I)[0]
+    t = re.split(r"perf-budget:|zoom-check:", t, flags=re.I)[0]
     return len(re.findall(r"\S+", t))
 
 
@@ -331,7 +335,7 @@ def read_core_config(root: str) -> dict:
     if os.path.exists(p):
         with open(p, encoding="utf-8") as fh:
             for line in fh:
-                m = re.match(r"^(appSize|appKind|appPhase):\s*(\S+)", line)
+                m = re.match(r"^(appSize|appKind|appPhase):\s*(\S+)", line) or re.match(r"^\s+(project_type):\s*(\S+)", line)
                 if m and m.group(2) not in ("null", "~", "''", '""'):
                     out[m.group(1)] = m.group(2).strip("'\"")
     return out
@@ -356,6 +360,24 @@ def foreign_prefix(path: str):
     return app if app and apps and app.lower() not in apps else None
 
 
+def phase_status(path: str, app: str, phase: int):
+    """The Status cell of this phase's row in docs/{App}-Phases.md beside it, lower-cased; None when
+    there is no Phases document or no row for the phase."""
+    p = os.path.join(os.path.dirname(path), f"{app}-Phases.md")
+    if not app or not os.path.isfile(p):
+        return None
+    with open(p, encoding="utf-8") as fh:
+        txt = strip_noise(fh.read())
+    for header, rows in tables_in(txt):
+        low = [h.lower() for h in header]
+        if "phase" in low and "status" in low:
+            ip, ist = low.index("phase"), low.index("status")
+            for r in rows:
+                if len(r) > max(ip, ist) and r[ip].strip("`* ") == str(phase):
+                    return r[ist].strip("`* ").lower()
+    return None
+
+
 def phase_file(app: str, phase: int, suffix: str) -> str:
     return f"{app}-{suffix}.md" if phase <= 1 else f"{app}-P{phase}-{suffix}.md"
 
@@ -391,6 +413,17 @@ def resolve_kind(header, brd_header, cfg) -> str:
     return "library" if raw.startswith("lib") else "app"
 
 
+def signs_in_through_appmanager(root, app):
+    """the Architecture's authentication row (Q4, Auth…, Identity) names AppManager"""
+    for f in glob.glob(os.path.join(root or ".", "docs", f"{app}-Architecture.md")):
+        for _h, rows in tables_in(open(f, encoding="utf-8", errors="replace").read()):
+            for r in rows:
+                head = " ".join(r[:2]).lower()
+                if re.search(r"\bq4\b|auth|identity|sign-in", head) and re.search(r"(?i)app ?manager", " ".join(r[1:3])):
+                    return True
+    return False
+
+
 def section_text(present, name):
     key = norm_heading(name)
     return next((txt for k, _h, txt in present if key_matches(key, k)), None)
@@ -450,6 +483,10 @@ def check_document(path: str, rep: Report, cli_size=None, root=None):
             rep.fail(rel, f'a phase-{phase} file needs the header row "Phase | {phase} of <m>"')
         elif os.path.exists(phases_doc):
             rep.fail(rel, f'the project has phases ({os.path.relpath(phases_doc, root)}); this file needs the header row "Phase | 1 of <m>"')
+    # a phase the owner kept whole past the cap: its size findings are WARN, never a gate failure (Lekhak TF-029)
+    kept = doc in PHASED_DOCS and bool(app) and phase_status(path, app, phase) == "kept-whole"
+    size_finding = rep.warn if kept else rep.fail
+    kept_why = f"; phase {phase} is kept-whole in {app}-Phases.md, so this is reported, not blocking" if kept else ""
 
     # 2. sections: strangers, order, presence
     present = [(norm_heading(h), h, txt) for h, txt in split_sections(clean, 2) if h is not None]
@@ -502,7 +539,7 @@ def check_document(path: str, rep: Report, cli_size=None, root=None):
             target, mx = target + extra * schema.per_entry[0], mx + extra * schema.per_entry[1]
             why = f", with {extra} entries past the cap of {SCREEN_CAP[size]}" if extra else ""
         if total > mx:
-            rep.fail(rel, f"{total:,} words; the {SIZE_LONG[size]} maximum is {mx:,} (target {target:,}{why}). Shorten prose; never drop a screen, field or requirement to fit")
+            size_finding(rel, f"{total:,} words; the {SIZE_LONG[size]} maximum is {mx:,} (target {target:,}{why}). Shorten prose; never drop a screen, field or requirement to fit{kept_why}")
         elif total > target:
             rep.warn(rel, f"{total:,} words; the {SIZE_LONG[size]} target is {target:,} (maximum {mx:,}{why})")
     for key, h, txt in present:
@@ -564,7 +601,7 @@ def check_document(path: str, rep: Report, cli_size=None, root=None):
     # 5. document rules
     ctx = dict(doc=doc, body=body, clean=clean, nocomment=nocomment, present=present, header=header,
                size=size, kind=kind, root=root, path=path, rel=rel, entry_names=entry_names,
-               app=app, phase=phase)
+               app=app, phase=phase, size_finding=size_finding, kept_why=kept_why)
     for rule in schema.rules:
         if not rule.startswith("entry-"):
             check_doc_rule(rule, ctx, rep)
@@ -653,7 +690,7 @@ def check_doc_rule(rule, c, rep):
         if dupes:
             rep.fail(rel, "duplicate requirement ids: " + ", ".join(f"BRD-{d}" for d in sorted(dupes, key=int)))
         if len(seen) > REQ_CAP[size]:
-            rep.fail(rel, f"{len(seen)} requirements; the {SIZE_LONG[size]} cap is {REQ_CAP[size]}. Split into phases (each phase its own BRD) instead of growing this one")
+            c["size_finding"](rel, f"{len(seen)} requirements; the {SIZE_LONG[size]} cap is {REQ_CAP[size]}. Split into phases (each phase its own BRD) instead of growing this one{c['kept_why']}")
         c["brd_ids"] = seen
         req = section_text(present, "Requirements") or ""
         cur = None
@@ -774,6 +811,35 @@ def check_doc_rule(rule, c, rep):
         if txt is not None and not has_table_with(txt, "user", "role"):
             rep.fail(rel, 'the "Test users" section needs a table with User and Role columns')
 
+    elif rule == "appmanager-test-users":
+        # An app that signs in through AppManager has its own three test users there, registered through
+        # AppManager's register call, each password kept in the git-ignored secrets and never written in
+        # the guide; never the owner's personal account (stack answer Q4a, owner 2026-10-18).
+        txt = section_text(present, "Test users")
+        app = c.get("app")
+        if txt is None or c["kind"] != "app" or not app or app.lower() == "appmanager" or not signs_in_through_appmanager(c["root"], app):
+            return
+        users = []
+        for hdr, rows in tables_in(txt):
+            low = [h.lower() for h in hdr]
+            if not any("user" in h for h in low):
+                continue
+            pw = next((i for i, h in enumerate(low) if "password" in h), None)
+            users += [(r, r[pw] if pw is not None and pw < len(r) else "") for r in rows if "@" in " ".join(r)]
+        whole = lambda r: " ".join(r).lower()
+        want = (("owner", r"owner|account holder"), ("second user", r"second"), ("unattended-run user", r"unattended|yolo"))
+        missing = [n for n, pat in want if not any(re.search(pat, whole(r)) for r, _p in users)]
+        if missing:
+            rep.fail(rel, f'{app} signs in through AppManager: the Test users table lists no {", no ".join(missing)} '
+                          f'(stack answer Q4a: owner walkthrough, second user, unattended runs, registered through AppManager\'s register call)')
+        for r, cell in users:
+            if not re.search(r"(?i)secret|\.env|credential|keychain", cell):
+                who = re.search(r"[\w.+-]+@[\w-]+(?:\.[\w-]+)*", " ".join(r)).group(0)
+                rep.fail(rel, f'test user {who}: the Password cell names no git-ignored secret; keep the password in the project\'s '
+                              f'secrets and name the key here, never the password (stack answer Q4a)')
+        if users and not re.search(r"(?i)regist", txt):
+            rep.fail(rel, "the Test users section does not say the users were registered through AppManager's register call (stack answer Q4a)")
+
     elif rule == "next-command-blocks":
         seg = re.search(r"(?ms)^## Next command to run\s*\n(.*?)(?=^## |\Z)", nocomment)
         if not seg:
@@ -986,7 +1052,7 @@ def check_doc_rule(rule, c, rep):
                             rep.fail(rel, f"phase {n} BRD range runs backwards ({x} to {y})")
                 st = r[ist].strip("`* ").lower()
                 if st not in PHASE_STATUS:
-                    rep.fail(rel, f'phase {n} status "{r[ist]}" must be planned, building or done')
+                    rep.fail(rel, f'phase {n} status "{r[ist]}" must be planned, building, done or kept-whole')
                 rows_out.append(dict(n=n, name=r[iname].strip("`* "), screens=screens, lo=lo, hi=hi, ranges=ranges, status=st))
         nums = [p["n"] for p in rows_out]
         if nums != list(range(1, len(nums) + 1)):
@@ -1033,10 +1099,12 @@ def check_checklist(c, rep):
         row_status[rid] = status.strip("`* ").lower()
         if not re.fullmatch(r"REQ-(UI|FN|RAG|NFR)-\d{3}", rid):
             rep.fail(rel, f'id "{rid}" is not REQ-UI/FN/RAG/NFR- plus three digits')
+        removed = " A removed row reads N/A with % 0, and the date goes in Remarks"
         if status.strip("`* ").lower() not in STATUS_VALUES:
-            rep.fail(rel, f'{rid} status "{status}" is not one of the fixed values')
+            rep.fail(rel, f'{rid} status "{status}" is not one of the fixed values.'
+                          + (removed if status.strip("`* ").lower().startswith("n/a") else ""))
         if pct.strip("`* ").rstrip("%").strip() not in ("0", "25", "50", "75", "100"):
-            rep.fail(rel, f'{rid} % "{pct}" must be 0, 25, 50, 75 or 100')
+            rep.fail(rel, f'{rid} % "{pct}" must be 0, 25, 50, 75 or 100.' + removed)
         n = len(re.findall(r"\S+", remarks))
         if n > 60:
             rep.fail(rel, f"{rid} Remarks is {n} words; at most 60, current state only (history lives in the telemetry streams)")
@@ -1046,6 +1114,10 @@ def check_checklist(c, rep):
         said = re.sub(r"`[^`]*(?:`|$)", " ", remarks)
         if NOT_PRESENT.search(said) and not NAMES_PATH.search(remarks):
             rep.fail(rel, f"{rid} Remarks says something is not present without naming the path that was tried; search tools skip .tfcore/, so read the literal path first")
+        if row_status[rid] == "n/a":
+            # a removed or reserved row is kept for traceability; it has no screen, mockup or BRD item to
+            # point at, so the detail-entry rules do not apply to it (Lekhak TF-028)
+            continue
         m = re.search(r"\(#([^)]+)\)", details)
         if not m:
             rep.fail(rel, f"{rid} Details cell has no link to its detail entry")
@@ -1054,7 +1126,7 @@ def check_checklist(c, rep):
     if not ids:
         rep.fail(rel, "the Requirements Status table has no REQ- rows")
     if len(ids) > REQ_CAP[size]:
-        rep.fail(rel, f"{len(ids)} rows; the {SIZE_LONG[size]} cap is {REQ_CAP[size]}. Split into phases instead of growing this checklist")
+        c["size_finding"](rel, f"{len(ids)} rows; the {SIZE_LONG[size]} cap is {REQ_CAP[size]}. Split into phases instead of growing this checklist{c['kept_why']}")
     dupes = sorted({i for i in ids if ids.count(i) > 1})
     if dupes:
         rep.fail(rel, "duplicate rows: " + ", ".join(dupes))
@@ -1076,6 +1148,9 @@ def check_checklist(c, rep):
             start = pos + own.end()
         nxt = re.search(r"\n\s*(?:[-*]\s*)?<a id=|\n## |\n### ", body[start:])   # an entry is a list item: the dash precedes the anchor (miss 21)
         entry = body[pos: start + nxt.start()] if nxt else body[pos:]
+        if row_status.get(rid) == "n/a":
+            brd_refs.update(re.findall(r"BRD-(\d+)", entry))   # a retired BRD item still has its row
+            continue
         acc = [l for l in entry.splitlines() if ACCEPT_LINE.search(l)]
         if len(acc) != 1:
             rep.fail(rel, f"{rid} must have exactly one acceptance line; found {len(acc)}")
@@ -1100,7 +1175,10 @@ def check_checklist(c, rep):
         brd_refs.update(refs)
         if rid.startswith("REQ-UI"):
             links = links_to(entry, "mockups")
-            if not links:
+            # a library or docs project (metrics.project_type, or kind: library) has no screens and no
+            # docs/mockups/: its UI rows map to components, so a missing link is not a finding there; a
+            # link it does carry must still resolve (TrBlazeUI TF-003)
+            if not links and c.get("kind") == "app" and read_core_config(root).get("project_type", "app").lower() not in ("library", "docs"):
                 rep.fail(rel, f"{rid} is a UI row without a mockup link")
             for l in sorted(links):
                 if not resolve(root, path, l):
@@ -1275,14 +1353,18 @@ NAV_ITEM = re.compile(r"""<(div|li|span|button)\b[^>]*\bclass\s*=\s*["'][^"']*(?
 
 
 def _mock_target(mock_dir: str, t: str):
-    """Resolve a link the way a browser opening docs/mockups/<file> would. Returns the file
-    name when it lands on an existing file inside the mockup folder, else None."""
+    """Resolve a link the way a browser opening docs/mockups/<file> would. Returns the path
+    relative to the mockup folder when it lands on an existing file inside it, at any depth
+    (Lekhak TF-008: index.html linking to admin/connection-settings.html opens, and was
+    failed), else None. A leading slash, or a path that leaves docs/mockups/, is still None."""
     if re.match(r"^(https?:|mailto:|tel:|javascript:|data:)", t, re.I) or t.startswith("/"):
         return None
+    t = re.split(r"[?#]", t, maxsplit=1)[0]
+    base = os.path.normpath(mock_dir)
     p = os.path.normpath(os.path.join(mock_dir, t))
-    if os.path.dirname(p) != os.path.normpath(mock_dir) or not os.path.isfile(p):
+    if not (p == base or p.startswith(base + os.sep)) or not os.path.isfile(p):
         return None
-    return os.path.basename(p)
+    return os.path.relpath(p, base).replace(os.sep, "/")
 
 
 def check_mockups(root: str, rep: Report):
@@ -1315,7 +1397,8 @@ def check_mockups(root: str, rep: Report):
                 continue
             name = _mock_target(mock_dir, t)
             if name is None:
-                hint = "write the file name alone, not a folder or a leading slash" if ("/" in t) else "the file does not exist"
+                hint = ("a leading slash opens from the disk's root; write the path from docs/mockups/" if t.startswith("/")
+                        else "the file does not exist inside docs/mockups/")
                 rep.fail(rel, f'links to "{t}", which does not open from docs/mockups/ ({hint})')
             else:
                 targets.append(name)
@@ -1420,6 +1503,7 @@ def main(argv=None):
     if a.app:
         root = root or os.getcwd()
         files += app_files(root, a.app)
+        files = list(dict.fromkeys(os.path.abspath(f) for f in files))   # a file given and listed by --app once
         if not files:
             print(f"tf-doc-check: no documents for app {a.app} under {root}", file=sys.stderr)
             return 2
@@ -1452,9 +1536,16 @@ def main(argv=None):
                 base = json.load(fh) or {}
         except Exception:
             base = {}
-        for f in files:
-            r = os.path.relpath(f, root)
-            base[r] = sorted({l.split(": ", 1)[1] for l in rep.lines if l.startswith("FAIL ") and l.split(": ", 1)[0].endswith(" " + r)})
+        # every finding, under whatever it names: the mockup-folder and cross-document checks name
+        # docs/mockups/index.html or another document, not one of the files given, and were never
+        # recorded, so ~60 old findings read as new on every *amend-docs (Lekhak TF-023)
+        new = {os.path.relpath(f, root): set() for f in files}
+        for l in rep.lines:
+            if l.startswith("FAIL ") and ": " in l:
+                head, msg = l.split(": ", 1)
+                new.setdefault(head[len("FAIL "):], set()).add(msg)
+        for r, msgs in new.items():
+            base[r] = sorted(msgs)
         os.makedirs(os.path.dirname(base_path), exist_ok=True)
         with open(base_path, "w", encoding="utf-8") as fh:
             json.dump(base, fh, indent=1)
@@ -1468,11 +1559,23 @@ def main(argv=None):
                 with open(base_path, encoding="utf-8") as fh:
                     base = json.load(fh) or {}
                 relined = []
+                # A size finding carries its count ("20,677 words; the Small maximum is 8,000"), so any
+                # edit to an over-limit document, a cut included, changed the text and read as new
+                # (Lekhak TF-023). The same finding with a count no larger than the old one is old;
+                # a document that grew past its maximum still FAILs.
+                def _shape(m):
+                    return re.sub(r"\d[\d,]*", "#", m)
+                def _first(m):
+                    n = re.search(r"\d[\d,]*", m)
+                    return int(n.group(0).replace(",", "")) if n else None
                 for l in rep.lines:
                     if l.startswith("FAIL "):
                         head, msg = l.split(": ", 1)
                         r = head[len("FAIL "):]
-                        if msg in set(base.get(r, [])):
+                        was = base.get(r, [])
+                        same = msg in set(was) or (re.match(r"^\d[\d,]* (words|lines|rows|requirements|KB|screens)", msg) and any(
+                            _shape(o) == _shape(msg) and _first(o) is not None and _first(msg) <= _first(o) for o in was))
+                        if same:
                             relined.append("OLD  " + l[5:])
                             rep.fails -= 1
                             old += 1

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

@@ -7,7 +7,8 @@
 # docs/Lekhak-UsageGuide.md and fails when the REQ-NFR-042 paragraph is gone. *amend-docs removed that
 # paragraph, ran no test, closed green, and only CI noticed. This script looks for test source files
 # (a path containing "test") that name one of the documents, by file name or by name without ".md".
-# When one does, it runs the unit tests through tf-build.sh test. Prints ONE line:
+# When one does, it runs the test projects holding those files, each on its own through tf-build.sh
+# test (TechieRag TF-004), or the solution's tests one project at a time. Prints ONE line:
 #   NONE     no test reads <docs>; nothing to run                             exit 0
 #   PASS     <n> test file(s) read <docs> (<files>); the unit tests pass — <build line>   exit 0
 #   FAIL     <n> test file(s) read <docs> (<files>); the unit tests fail — <build line>   exit 1
@@ -20,7 +21,7 @@ DOCS=(); TARGET=""
 while [[ $# -gt 0 ]]; do
   case "$1" in
     --target) TARGET="${2:-}"; shift 2 ;;
-    -h|--help) sed -n '2,15p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    -h|--help) sed -n '2,16p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
     *) DOCS+=("$1"); shift ;;
   esac
 done
@@ -71,7 +72,43 @@ if [[ -z "$TARGET" && -z "$ROOTSLN" ]]; then
   fi
   exit 2
 fi
-LINE="$(bash "$HERE/tf-build.sh" test ${TARGET:+"$TARGET"} 2>&1 | grep -m1 -E '^(PASS|FAIL|NOT-RUN)' || true)"
+# Only the test projects that hold a reader, each on its own (TechieRag TF-004): the whole solution at
+# once let the local-model tests take the memory, and TechieRag.Tests failed with "Cannot allocate
+# memory" on a test that passes alone. A reader in no .NET test project (a browser spec) falls back to
+# the solution run, which tf-build.sh also splits into one test project at a time.
+OWNERS="$(TF_READERS="$READERS" python3 - <<'PY'
+import glob, os, sys
+out = []
+for r in os.environ.get("TF_READERS", "").split("\n"):
+    if not r.strip():
+        continue
+    d = os.path.dirname(r)
+    while d and d not in (".", "/"):
+        projs = glob.glob(os.path.join(d, "*.csproj"))
+        if projs:
+            p = projs[0]
+            if p not in out:
+                out.append(p)
+            break
+        d = os.path.dirname(d)
+print("\n".join(out))
+PY
+)"
+if [[ -n "$OWNERS" && -z "$TARGET" ]]; then
+  fails=(); notrun=(); passed=0; vl=()
+  while IFS= read -r p; do
+    [[ -z "$p" ]] && continue
+    v="$(bash "$HERE/tf-build.sh" test "$p" 2>&1 | grep -m1 -E '^(PASS|FAIL|NOT-RUN)' || true)"
+    vl+=("$(basename "$p" .csproj): ${v:-no verdict}")
+    case "$v" in PASS*) passed=$((passed+1)) ;; FAIL*) fails+=("$(basename "$p" .csproj)") ;; *) notrun+=("$(basename "$p" .csproj)") ;; esac
+  done <<<"$OWNERS"
+  k="$(grep -c . <<<"$OWNERS")"
+  if [[ ${#fails[@]} -gt 0 ]]; then LINE="FAIL  ${fails[*]} failed ($k test project(s) holding a reader, each run on its own) — ${vl[*]}"
+  elif [[ ${#notrun[@]} -gt 0 ]]; then LINE="NOT-RUN ${notrun[*]} could not run — ${vl[*]}"
+  else LINE="PASS  $k test project(s) holding a reader, each run on its own — ${vl[*]}"; fi
+else
+  LINE="$(bash "$HERE/tf-build.sh" test ${TARGET:+"$TARGET"} 2>&1 | grep -m1 -E '^(PASS|FAIL|NOT-RUN)' || true)"
+fi
 case "$LINE" in
   PASS*)    echo "PASS     $N test file(s) read ${DOCS[*]} ($LIST); the unit tests pass — $LINE"; exit 0 ;;
   FAIL*)    echo "FAIL     $N test file(s) read ${DOCS[*]} ($LIST); the unit tests fail — $LINE"; exit 1 ;;

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

@@ -1015,16 +1015,34 @@ def _window_opencode(t0, t1):
         return None
     dbp = ptr.get("db_path")
     sid = ptr.get("session_id")
-    if not dbp or not sid or not os.path.isfile(dbp):
+    if not dbp or not os.path.isfile(dbp):
         return None
     try:
         import sqlite3
         db = sqlite3.connect("file:%s?mode=ro" % dbp, uri=True)
-        pairs = db.execute("SELECT id, parent_id FROM session").fetchall()
+        # OpenCode 2 keeps sessions in session_v2 and messages in session_message; the old tables
+        # stopped on 2026-09-27, so every OpenCode record since read tokens_scope "none". Both are read.
+        tables = {r[0] for r in db.execute("SELECT name FROM sqlite_master WHERE type='table'")}
+        pairs = db.execute("SELECT id, parent_id FROM session").fetchall() if "session" in tables else []
+        if "session_v2" in tables:
+            pairs += db.execute("SELECT id, parent_id FROM session_v2").fetchall()
         kids = {}
         for i, p in pairs:
             kids.setdefault(p, []).append(i)
-        tree, queue = {sid}, [sid]
+        # The roots: the pointer's session, and every root session OpenCode 2 recorded in THIS project's
+        # folder. Each *develop-end-to-end phase runs in a new session and the plugin's pointer kept the
+        # first one, so the later phases read "none" (2026-10-08). Messages are still taken only inside
+        # the record's own window.
+        roots = {sid} if sid else set()
+        if "session_v2" in tables:
+            here = os.path.realpath(root)
+            for i, p_, dr in db.execute("SELECT id, parent_id, directory FROM session_v2"):
+                if not p_ and dr and os.path.realpath(dr) == here:
+                    roots.add(i)
+        if not roots:
+            db.close()
+            return None
+        tree, queue = set(roots), list(roots)
         while queue:
             for c in kids.get(queue.pop(), []):
                 if c not in tree:
@@ -1036,15 +1054,20 @@ def _window_opencode(t0, t1):
         # Same rule as the Claude branch: a CHILD session counts as a subagent run
         # for THIS window only if it produced output inside it.
         child_out = {}
-        q = "SELECT session_id, data FROM message WHERE time_created BETWEEN ? AND ?"
-        for msid, data in db.execute(q, (t0, t1)):
+        rows = []
+        if "message" in tables:
+            rows += db.execute("SELECT session_id, data FROM message WHERE time_created BETWEEN ? AND ?", (t0, t1)).fetchall()
+        if "session_message" in tables:
+            rows += [(a, b) for a, b in db.execute(
+                "SELECT session_id, data FROM session_message WHERE type = 'assistant' AND time_created BETWEEN ? AND ?", (t0, t1))]
+        for msid, data in rows:
             if msid not in tree:
                 continue
             try:
                 d = json.loads(data)
             except Exception:
                 continue
-            if d.get("role") != "assistant":
+            if d.get("role") not in (None, "assistant"):
                 continue
             t = d.get("tokens") or {}
             cache = t.get("cache") or {}
@@ -1054,9 +1077,11 @@ def _window_opencode(t0, t1):
             tot["cr"] += cache.get("read") or 0
             tot["cw"] += cache.get("write") or 0
             cost += d.get("cost") or 0
-            if msid != sid and o:
+            if msid not in roots and o:
                 child_out[msid] = child_out.get(msid, 0) + o
-            m = (d.get("providerID", "") + "/" if d.get("providerID") else "") + (d.get("modelID") or "")
+            mo = d.get("model") if isinstance(d.get("model"), dict) else {}
+            prov = d.get("providerID") or mo.get("providerID") or ""
+            m = (prov + "/" if prov else "") + (d.get("modelID") or mo.get("id") or "")
             if m:
                 models[m] = models.get(m, 0) + o
         db.close()
@@ -1463,7 +1488,7 @@ _ALLOWED = {
                       "routed", "tokens_in", "tokens_out", "tokens_cache_read", "tokens_cache_write",
                       "cost_usd", "tokens_scope", "attempt", "subagent_runs", "tokens_out_subagents",
                       "model_tokens_out", "session_id", "usage_start_event_ts", "usage_end_event_ts",
-                      "billing_mode", "cost_source", "fallback_from"},
+                      "billing_mode", "cost_source", "fallback_from", "app_phase"},
     # A correction, not a deletion: it names a run record that is wrong by the pair every
     # run carries (`cmd` + `started`) and says why, so every figure can skip it while the
     # record itself stays where it is. Written by --void-run, which refuses one that names
@@ -1474,7 +1499,7 @@ _ALLOWED = {
                         "tier", "tier_model", "model", "models", "tokens_in", "tokens_out", "tokens_cache_read",
                         "tokens_cache_write", "cost_usd", "tokens_scope", "model_tokens_out", "routed",
                         "subagent_runs", "tokens_out_subagents", "session_id",
-                        "billing_mode", "cost_source", "fallback_from"},
+                        "billing_mode", "cost_source", "fallback_from", "app_phase"},
     ("sessions", "session"): {"session_id", "model", "duration_s", "input_tokens", "output_tokens",
                               "cache_read_tokens", "cache_creation_tokens", "cost_usd", "children_sessions"},
     ("commits", "commit"): {"sha", "files", "insertions", "deletions", "subject_prefix", "branch"},
@@ -1519,6 +1544,11 @@ def _shape_ok(rec):
     if kind == "run" and rec.get("build_result") not in (None, "pass", "fail", "not-run"):
         sys.stdout.write("tf-emit: REFUSED — build_result must be pass, fail or not-run (SCHEMA.md §2); got %r. Put the detail in the checklist Remarks or Known blockers, not here. Nothing was appended.\n" % (rec.get("build_result"),))
         return False
+    # one REQ's verdict, never a suite note: Lekhak hand-wrote four {"gate":"verify-suite","result":…}
+    # records with neither, and the report counted each as a failure (TF-020)
+    if kind == "gate" and not rec.get("backfilled") and not (rec.get("req_id") and rec.get("verdict")):
+        sys.stdout.write("tf-emit: REFUSED — a gate record is one REQ's verdict and needs both req_id and verdict (SCHEMA.md §3). A suite result (unit tests, the whole browser run) belongs in the run record's notes, not here. Nothing was appended.\n")
+        return False
     if kind == "miss" and not rec.get("miss_id"):
         sys.stdout.write("tf-emit: REFUSED — a miss record needs a miss_id; get one with: bash .tfcore/utils/tf-emit.sh --next-miss-id. Nothing was appended.\n")
         return False

package/.tfcore/utils/tf-fix-close.sh

@@ -3,6 +3,7 @@
 #
 #   bash .tfcore/utils/tf-fix-close.sh <App> [--started <ISO>] [--reqs REQ-UI-009,REQ-FN-014]
 #                                            [--subagents trblazeui,builder] [--build pass|fail|not-run] [--files N]
+#                                            [--cmd triage-and-fix]   # the command the run record is filed under
 #   bash .tfcore/utils/tf-fix-close.sh <App> --misses MISS-App-20260901-06,MISS-App-20260830-03 \
 #                                            --fix-cmd amend-docs [--verdict Verified]
 #
@@ -24,13 +25,16 @@
 #      re-verify). A row no verify graded gets no miss-fix and is listed. A row with no open miss is listed,
 #      not invented: a fix on a defect nobody logged is a triage gap, so open it first with tf-triage.sh
 #      demote or tf-log-miss.sh, then re-run this.
+# --cmd names the command the run record is filed under (default fix-issues): *triage-and-fix passes
+# --cmd triage-and-fix, so its run is counted as itself and no second record over the same window is
+# needed, which the overlap rule refused (TrBlazeUI TF-004). The miss-fix records keep fix_cmd fix-issues.
 # --reqs defaults to every row those verifies graded. The start defaults to the fix's marker, or its
 # "outer" entry when a chained verify replaced it. Telemetry never blocks: refusals are printed, exit 0.
 set -u
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 [[ $# -ge 1 && "$1" != "-h" && "$1" != "--help" ]] || { sed -n '2,17p' "$0" | sed 's/^# \{0,1\}//'; exit 3; }
 APP="$1"; shift
-STARTED=""; REQS=""; SUBS=""; BUILD="pass"; FILES=""; MISSES=""; FIXCMD="fix-issues"; VERDICT=""
+STARTED=""; REQS=""; SUBS=""; BUILD="pass"; FILES=""; MISSES=""; FIXCMD="fix-issues"; VERDICT=""; RUNCMD="fix-issues"
 while [[ $# -gt 0 ]]; do
   case "$1" in
     --started) STARTED="${2:-}"; shift 2 ;;
@@ -41,6 +45,7 @@ while [[ $# -gt 0 ]]; do
     --misses) MISSES="${2:-}"; shift 2 ;;
     --fix-cmd) FIXCMD="${2:-}"; shift 2 ;;
     --verdict) VERDICT="${2:-}"; shift 2 ;;
+    --cmd) RUNCMD="${2:-}"; shift 2 ;;
     *) echo "tf-fix-close: unknown argument $1" >&2; exit 3 ;;
   esac
 done
@@ -51,9 +56,10 @@ except Exception: m={}
 o=m.get('outer') or {}
 print(m.get('started','') if m.get('cmd')!='verify-phase' or not o.get('started') else o['started'])" 2>/dev/null)"
 TF_APP="$APP" TF_STARTED="$STARTED" TF_REQS="$REQS" TF_SUBS="$SUBS" TF_BUILD="$BUILD" TF_FILES="$FILES" \
-TF_MISSES="$MISSES" TF_FIXCMD="$FIXCMD" TF_VERDICT="$VERDICT" TF_EMIT="$HERE/tf-emit.sh" python3 - <<'PY'
+TF_MISSES="$MISSES" TF_FIXCMD="$FIXCMD" TF_RUNCMD="$RUNCMD" TF_VERDICT="$VERDICT" TF_EMIT="$HERE/tf-emit.sh" python3 - <<'PY'
 import datetime, json, os, subprocess
 EMIT = os.environ["TF_EMIT"]; app = os.environ["TF_APP"]; started = os.environ["TF_STARTED"]
+cmd = os.environ.get("TF_RUNCMD") or "fix-issues"
 now = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 def q(*a): return subprocess.run(["bash", EMIT, *a], capture_output=True, text=True).stdout.strip()
 def emit(stream, rec):
@@ -121,7 +127,7 @@ inner, voided = [], set()
 for r in jsonl("runs.jsonl"):
     if r.get("kind") == "run-void":
         voided.add((r.get("cmd"), r.get("started")))
-    elif r.get("kind", "run") == "run" and r.get("app") == app and r.get("cmd") != "fix-issues" and not r.get("backfilled") \
+    elif r.get("kind", "run") == "run" and r.get("app") == app and r.get("cmd") not in ("fix-issues", cmd) and not r.get("backfilled") \
             and started and (r.get("started") or "") >= started and (r.get("ended") or "") and r["ended"] <= now:
         inner.append((r["started"], r["ended"], r.get("cmd")))
 inner = sorted(w for w in inner if (w[2], w[0]) not in voided)
@@ -130,11 +136,11 @@ for s, e, _c in inner:
     if t and s > t: gaps.append((t, s))
     t = max(t, e) if t else e
 if not started or not gaps or t < now: gaps.append((t, now))
-existing = {r.get("started") for r in jsonl("runs.jsonl") if r.get("kind", "run") == "run" and r.get("cmd") == "fix-issues"}
+existing = {r.get("started") for r in jsonl("runs.jsonl") if r.get("kind", "run") == "run" and r.get("cmd") == cmd}
 wrote = had = 0
 for i, (s, e) in enumerate(gaps):
     first = i == 0
-    run = {"kind": "run", "app": app, "cmd": "fix-issues", "mode": "fix", "ended": e, "reqs_touched": reqs if first else [],
+    run = {"kind": "run", "app": app, "cmd": cmd, "mode": "fix", "ended": e, "reqs_touched": reqs if first else [],
            "reqs_count": len(reqs) if first else 0, "subagents": subs if first else [],
            "files_written": (int(files) if files.isdigit() else len(reqs)) if first else 0, "build_result": os.environ["TF_BUILD"]}
     if s: run["started"] = s
@@ -143,7 +149,7 @@ for i, (s, e) in enumerate(gaps):
         had += 1; continue
     wrote += emit("runs", run)
 if inner:
-    print(f"fix-issues: recorded around {len(inner)} chained run(s) ({', '.join(sorted({c for _s, _e, c in inner}))}) in {len(gaps)} segment(s)")
+    print(f"{cmd}: recorded around {len(inner)} chained run(s) ({', '.join(sorted({c for _s, _e, c in inner}))}) in {len(gaps)} segment(s)")
 closed, none, unverified = 0, [], []
 for rid in reqs:
     if rid not in rows:
@@ -158,7 +164,7 @@ for rid in reqs:
     if started: rec["fix_run_id"] = started
     if emit("misses", rec): closed += 1
 state = "already there" if had == len(gaps) else "written" if wrote + had == len(gaps) else "not written"
-print(f"fix-issues: run record {state}; {closed} miss-fix record(s) with the verifier's verdict"
+print(f"{cmd}: run record {state}; {closed} miss-fix record(s) with the verifier's verdict"
       + (f"; no open miss on {', '.join(none)} (log it first, then re-run)" if none else "")
       + (f"; no verify graded {', '.join(unverified)} during this fix, so its miss stays open with no miss-fix" if unverified else ""))
 PY