@techierathore/techieflow 1.0.4 → 1.1.0

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

@@ -117,7 +117,7 @@ else:
 # TF-019: a row can sit at `Needs re-verify` forever, which pinned the mode and dropped
 # every not-started row out of the list AND out of the counts, so a build pass could report
 # a phase finished with rows at 0%. The arithmetic is the check: every row lands in exactly
-# one of open / terminal / Blocked.
+# one of open / terminal / Blocked / roadmap.
 apps = app_names()
 if not apps:
     skip("tf-build-list", "no checklist in docs/ yet")
@@ -128,7 +128,7 @@ for app, phase, path in apps:
     if rc not in (0, 2):
         broken("tf-build-list", "%s: exited %d" % (label, rc), out.strip().splitlines()[0][:120] if out.strip() else "")
         continue
-    m = re.search(r"Mode: (\w+) — (\d+) row\(s\) to build; (\d+) terminal, (\d+) Blocked, (\d+) total", out)
+    m = re.search(r"Mode: (\w+) — (\d+) row\(s\) to build; (\d+) terminal, (\d+) Blocked, (?:(\d+) roadmap, )?(\d+) total", out)
     if not m:
         if "has no REQ rows" in out:
             skip("tf-build-list", "%s: checklist has no requirement rows yet" % label)
@@ -136,11 +136,11 @@ for app, phase, path in apps:
             broken("tf-build-list", "%s: no counts line to check" % label,
                    "the output shape changed; the arithmetic can no longer be verified")
         continue
-    mode, work, term, blocked, total = m.group(1), *(int(x) for x in m.groups()[1:])
-    if work + term + blocked != total:
+    mode, work, term, blocked, roadmap, total = m.group(1), *(int(x or 0) for x in m.groups()[1:])
+    if work + term + blocked + roadmap != total:
         broken("tf-build-list",
-               "%s: %d rows are in no category (%d open + %d terminal + %d blocked ≠ %d total)"
-               % (label, total - work - term - blocked, work, term, blocked, total),
+               "%s: %d rows are in no category (%d open + %d terminal + %d blocked + %d roadmap ≠ %d total)"
+               % (label, total - work - term - blocked - roadmap, work, term, blocked, roadmap, total),
                "a build pass trusting this list would leave those rows at 0%")
     else:
         ok("tf-build-list", "%s: %d rows, all accounted for (%s)" % (label, total, mode))
@@ -288,12 +288,45 @@ for name, cmd in (("tf-doc-check", ["bash", os.path.join(UTILS, "tf-doc-check.sh
         first = next((l for l in out.splitlines() if l.strip()), "")
         ok(name, "runs (exit %d)" % rc)
 
+# ---- 8. the upstream feedback files read as they are ------------------------------------
+# 2026-09-11: PROJECT-STATUS counted every ### heading as an entry and nothing as fixed, so
+# TfLens read "62 open of 62" and its agent told the owner two problems fixed two days earlier
+# were open (MISS-TechieFlow-20260911-04). The one reader is run here, on the real files, and
+# whatever an upstream team has fixed and this project has not re-checked is named below.
+waiting = []
+sys.path.insert(0, UTILS)
+try:
+    import tf_feedback
+    fb = tf_feedback.files(REPO)
+    if not fb:
+        skip("tf_feedback", "no upstream feedback files in this project")
+    else:
+        n = 0
+        for f in fb:
+            for e in tf_feedback.entries(f):
+                n += 1
+                if e["state"] == "fixed":
+                    waiting.append((e["id"], e["since"], os.path.basename(f)))
+        ok("tf_feedback", "%d feedback file(s), %d entries read; %d fixed upstream, not yet re-checked"
+           % (len(fb), n, len(waiting)))
+except Exception as e:
+    broken("tf_feedback", "crashed on this project's feedback files", str(e)[:120])
+
 # ---- output -----------------------------------------------------------------------------
 proj = os.path.basename(REPO.rstrip(os.sep))
 print("# tf-selfcheck — %s — the framework's own scripts against this project's real files" % proj)
 for l in lines:
     print(l)
 print()
+if waiting:
+    # Not a defect and not a failure: work this project owes. An upstream fix counts only once it
+    # has been re-checked here; until then it must never be reported to the owner as open.
+    print("Fixed upstream, not yet re-checked here — never report these as open problems:")
+    for rid, since, f in waiting:
+        print("  %-12s fixed %-10s %s" % (rid, since or "", f))
+    print("Re-check each with its entry's \"Verify from here\" step, then close it:")
+    print('  bash .tfcore/utils/tf-feedback.sh <App> --close <ID> "<what you ran and what it showed>"')
+    print()
 if not findings:
     print("Every framework script works on this project. Nothing to file.")
     raise SystemExit(0)

package/.tfcore/utils/tf-split-brd.py

@@ -223,7 +223,17 @@ def run(app, phase, force, add_missing, in_order=False):
     existing = read(cl_p) if os.path.isfile(cl_p) else ""
     if existing and not force and not add_missing:
         die(f"{cl_p} already exists; use --add-missing to append rows for new BRD items, or --force to rewrite", 1)
-    mapped = set(re.findall(r"\*BRD:\*\s*(BRD-\d+)", existing)) | set(re.findall(r"\((BRD-\d+)\)", existing))
+    # A BRD item already has a row when any row names it: on its `*BRD:*` detail line, or anywhere on
+    # its status-table line. The table form used to be read only as a bracket holding exactly one id,
+    # so "(BRD-76, Phase 3)" and "(BRD-118, BRD-120, Phase 3)" were invisible and --add-missing
+    # appended 44 rows to TfLens phase 3 for 13 new items, 31 of them copies of Verified rows (TF-025).
+    mapped = {b for line in re.findall(r"(?m)^.*\*BRD:\*.*$", existing) for b in re.findall(r"BRD-\d+", line)}
+    mapped |= {b for row in re.findall(r"(?m)^\|\s*REQ-.*$", existing) for b in re.findall(r"BRD-\d+", row)}
+    # ...and on the requirement's own line in its detail entry, with the lines indented under it. A
+    # checklist migrated from an older plan names its items there, as "(BRD-1, BRD-2)" or
+    # "*(BRD-84, BRD-85)*", with no *BRD:* line: AppManager's run appended a row for all 88 items (TF-001).
+    for block in re.findall(r"(?m)^\s*[-*]\s*(?:<a id=[^>]*>\s*</a>\s*)?\*\*REQ-[A-Z]+-\d{3}\*\*.*(?:\n[ \t]+\S.*)*", existing):
+        mapped |= set(re.findall(r"BRD-\d+", block))
     counters = other_phase_counters(app, cl_p, below=phase if in_order else None)
     if add_missing:
         for m in re.finditer(r"REQ-(UI|FN|RAG|NFR)-(\d{3})", existing):

package/.tfcore/utils/tf-status-evidence.sh

@@ -12,6 +12,7 @@
 #   4. the build verdict from tf-build.sh (skipped with --no-build)
 # Then the agent decides the interruption signature and runs tf-status-facts.sh for the gate.
 set -uo pipefail
+source "$(dirname "${BASH_SOURCE[0]}")/tf-portable.sh"   # GNU-only commands, for a stock Mac
 APP="${1:-}"; [[ -z "$APP" ]] && { sed -n '2,12p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 2; }
 shift
 BUILD=1; PHASE=""
@@ -22,7 +23,7 @@ while [[ $# -gt 0 ]]; do
     *) shift ;;
   esac
 done
-[[ -z "$PHASE" ]] && PHASE="$(grep -oE '^appPhase:\s*[0-9]+' .tfcore/core-config.yaml 2>/dev/null | grep -oE '[0-9]+' || echo 1)"
+[[ -z "$PHASE" ]] && PHASE="$(grep -oE '^appPhase:[[:space:]]*[0-9]+' .tfcore/core-config.yaml 2>/dev/null | grep -oE '[0-9]+' || echo 1)"
 [[ "$PHASE" -le 1 ]] && CL="docs/${APP}-Checklist.md" || CL="docs/${APP}-P${PHASE}-Checklist.md"
 ST="PROJECT-STATUS.md"
 
@@ -31,19 +32,20 @@ echo
 echo "## 1. What the stale status file claims (a hypothesis, not a fact)"
 if [[ -f "$ST" ]]; then
   grep -E '^(last_updated|current_phase|last_verified_build|last_verified_date):' "$ST" | sed 's/^/- /'
-  awk '/^## Next command to run/{p=1;next} /^## /{p=0} p' "$ST" | grep -E '^\s*/' | sed 's/^\s*/- next: /' | head -2
-  echo "- written: $(date -u -r "$ST" +%Y-%m-%dT%H:%M:%SZ)"
+  awk '/^## Next command to run/{p=1;next} /^## /{p=0} p' "$ST" | grep -E '^[[:space:]]*/' | sed 's/^[[:space:]]*/- next: /' | head -2
+  echo "- written: $(tf_date_from -u "@$(tf_stat_mtime "$ST")" +%Y-%m-%dT%H:%M:%SZ)"
 else
   echo "- no PROJECT-STATUS.md; treat as never written"
 fi
 echo
 echo "## 2. Files changed after the status file was written (src/ and tests/, newest first)"
 if [[ -f "$ST" ]]; then
-  mapfile -t NEWER < <(find src tests -type f -newer "$ST" \
-      -not -path '*/bin/*' -not -path '*/obj/*' -not -path '*/node_modules/*' -not -path '*/.artifacts/*' 2>/dev/null \
-      | xargs -r ls -t 2>/dev/null)
+  # xargs runs ls only when find listed something (GNU xargs -r; BSD xargs has no -r)
+  NEWER=(); _found="$(find src tests -type f -newer "$ST" \
+      -not -path '*/bin/*' -not -path '*/obj/*' -not -path '*/node_modules/*' -not -path '*/.artifacts/*' 2>/dev/null)"
+  [[ -n "$_found" ]] && tf_read_lines NEWER < <(printf '%s\n' "$_found" | xargs ls -t 2>/dev/null)
   echo "- ${#NEWER[@]} file(s)"
-  printf -- '- %s\n' "${NEWER[@]:0:30}"
+  printf -- '- %s\n' ${NEWER[@]+"${NEWER[@]:0:30}"}
   [[ ${#NEWER[@]} -gt 30 ]] && echo "- (${#NEWER[@]} in total; the rest with: find src tests -type f -newer PROJECT-STATUS.md)"
 else
   echo "- no status file to compare against"
@@ -51,9 +53,9 @@ fi
 echo
 echo "## 3. Checklist rows that look interrupted ($CL)"
 if [[ -f "$CL" ]]; then
-  grep -E '^\s*\|\s*`?REQ-' "$CL" | awk -F'|' '{id=$2; st=$4; gsub(/^[ `*]+|[ `*]+$/,"",id); gsub(/^[ ]+|[ ]+$/,"",st); print id" — "st}' \
+  grep -E '^[[:space:]]*\|[[:space:]]*`?REQ-' "$CL" | awk -F'|' '{id=$2; st=$4; gsub(/^[ `*]+|[ `*]+$/,"",id); gsub(/^[ ]+|[ ]+$/,"",st); print id" — "st}' \
     | grep -iE ' — (Implemented|In Progress|Needs re-verify|PARTIAL|FAIL)' | sed 's/^/- /' | head -40
-  n=$(grep -E '^\s*\|\s*`?REQ-' "$CL" | awk -F'|' '{print $4}' | grep -ciE 'Implemented|In Progress|Needs re-verify|PARTIAL|FAIL' || true)
+  n=$(grep -E '^[[:space:]]*\|[[:space:]]*`?REQ-' "$CL" | awk -F'|' '{print $4}' | grep -ciE 'Implemented|In Progress|Needs re-verify|PARTIAL|FAIL' || true)
   [[ "$n" == "0" ]] && echo "- none: every row is terminal, Blocked or not started"
 else
   echo "- $CL does not exist"

package/.tfcore/utils/tf-status-facts.py

@@ -27,6 +27,7 @@ import re
 import sys
 
 TERMINAL = {"verified", "done (pre-existing)", "n/a"}
+NA = {"n/a"}                         # terminal, but never counted as verified (TF-018)
 PASS_THROUGH = {"blocked"}           # a library gap; counts as closed for the ladder
 BUILT = {"implemented", "needs re-verify"}
 OWNER = {"owner-uat"}                # only the owner can close it, from the UsageGuide test plan
@@ -61,6 +62,9 @@ def read(path):
 
 
 def checklist_rows(text):
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    import tf_roadmap
+    marked = tf_roadmap.ids(text)
     rows = []
     for line in text.splitlines():
         if not re.match(r"^\s*\|\s*`?REQ-", line):
@@ -69,10 +73,34 @@ def checklist_rows(text):
         if len(cells) < 3:
             continue
         rid = cells[0].strip("`* ")
-        rows.append({"id": rid, "name": cells[1].strip("`* "), "status": norm_status(cells[2])})
+        status = norm_status(cells[2])
+        rows.append({"id": rid, "name": cells[1].strip("`* "), "status": status,
+                     "remarks": cells[4] if len(cells) > 4 else "",
+                     "roadmap": rid.upper() in marked and status.lower() not in TERMINAL})
     return rows
 
 
+def figures(rows):
+    """(verified, counted, not applicable). An N/A row is terminal but was never verified, so it is
+    left out of both numbers and named: AppManager read "89 of 89 verified" with REQ-NFR-008 at N/A
+    (TF-018). tests/regression/run.sh am_018."""
+    na = sum(1 for r in rows if r["status"].lower() in NA)
+    return sum(1 for r in rows if r["status"].lower() in TERMINAL - NA), len(rows) - na, na
+
+
+# The defect marks live in tf_defect.py. A bare ⚠ is not enough: sending "not verifiable here" to a
+# build is the TfLens loop again.
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from tf_defect import DEFECT  # noqa: E402
+
+
+def has_defect(r):
+    """A Needs re-verify row whose Remarks carry a framework defect mark holds a defect no fix has
+    cleared, and a verify of the acceptance line cannot see it. So it is fix work, as build-phase step 7
+    and tf-build-list say, never a verify (AppManager TF-019). tests/regression/run.sh am_019."""
+    return r["status"].lower() == "needs re-verify" and bool(DEFECT.search(r.get("remarks", "")))
+
+
 def ladder_rank(status):
     return LADDER.index(status) if status in LADDER else 0
 
@@ -147,19 +175,13 @@ def handoff_ran(log_rows):
 
 
 def feedback_lines(root, app):
-    out = []
-    for path in sorted(glob.glob(os.path.join(root, "docs", f"{app}-*-Feedback.md"))):
-        lib = re.sub(rf"^{re.escape(app)}-(.+)-Feedback\.md$", r"\1", os.path.basename(path))
-        text = read(path)
-        entries = re.split(r"(?m)^###\s+", text)[1:]
-        open_n = 0
-        for e in entries:
-            closed = re.search(r"(?im)^\s*[-*]\s*\*\*(status|resolved|fixed)[^:]*:\*\*\s*(fixed|resolved|closed|done)", e)
-            if not closed:
-                open_n += 1
-        rel = os.path.relpath(path, root).replace(os.sep, "/")
-        out.append(f"- {lib}: {open_n} open of {len(entries)} — {rel}")
-    return out or ["- None"]
+    # One reader for every script (tf_feedback.py). This function used to count every `###`
+    # heading as an entry and accept only a closing line no file used, so TfLens's status read
+    # "TechieFlow: 62 open of 62" for 27 entries, 19 of them fixed or closed, and the agent told
+    # the owner two fixed problems were open (MISS-TechieFlow-20260911-04).
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    import tf_feedback
+    return [tf_feedback.summary_line(p, app) for p in tf_feedback.files(root, app)] or ["- None"]
 
 
 def config_phase(root):
@@ -191,6 +213,15 @@ def phase_row(root, app, phase):
     return name, total
 
 
+def usage_guide(app):
+    """UsageGuide or Usage-Guide, whichever exists: tf-verify-list.py's reader (AppManager TF-022)."""
+    import importlib.util
+    spec = importlib.util.spec_from_file_location("tf_verify_list", os.path.join(os.path.dirname(os.path.abspath(__file__)), "tf-verify-list.py"))
+    vl = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(vl)
+    return vl.usage_guide(app)
+
+
 def next_command(app, rows, log_rows, phase=1, verdicts=None):
     """Returns (phase, qualifier, cc_line, oc_line, reason)."""
     verdicts = verdicts or {}
@@ -207,17 +238,23 @@ def next_command(app, rows, log_rows, phase=1, verdicts=None):
                 f"{CC}analyst *day1-greenfield {app}", f"{OC}flow-analyst *day1-greenfield {app}",
                 "no BRD and no checklist exist; day-1 stage 1 has not run")
 
-    unbuilt = [r for r in rows if r["status"].lower() not in TERMINAL | PASS_THROUGH | BUILT | OWNER]
-    built = [r for r in rows if r["status"].lower() in BUILT]
-    owner = [r for r in rows if r["status"].lower() in OWNER]
-    total = len(rows)
-    closed = sum(1 for r in rows if r["status"].lower() in TERMINAL)
-    q = f"{closed} of {total} verified"
-
-    if unbuilt:
-        return ("Build", f"{len(unbuilt)} not built, {q}",
-                f"{CC}flow-master *build-phase {app}", f"{OC}flow-master *build-phase {app}",
-                f"{len(unbuilt)} rows are not built yet: {ids(unbuilt)}")
+    # A roadmap row is not this phase's work, so it never decides the next command (TF-017).
+    now = [r for r in rows if not r.get("roadmap")]
+    unbuilt = [r for r in now if r["status"].lower() not in TERMINAL | PASS_THROUGH | BUILT | OWNER]
+    defects = [r for r in now if has_defect(r)]
+    built = [r for r in now if r["status"].lower() in BUILT and r not in defects]
+    owner = [r for r in now if r["status"].lower() in OWNER]
+    verified, counted, na = figures(rows)
+    q = f"{verified} of {counted} verified" + (f", {na} not applicable" if na else "")
+
+    if unbuilt or defects:
+        qual = ", ".join(x for x in (f"{len(unbuilt)} not built" if unbuilt else "",
+                                     f"{len(defects)} to fix" if defects else "") if x)
+        why = "; ".join(x for x in (f"{len(unbuilt)} rows are not built yet: {ids(unbuilt)}" if unbuilt else "",
+                                    f"{len(defects)} rows carry a defect (⚠ in Remarks) that a fix must clear before "
+                                    f"a verify: {ids(defects)}" if defects else "") if x)
+        return ("Build", f"{qual}, {q}",
+                f"{CC}flow-master *build-phase {app}", f"{OC}flow-master *build-phase {app}", why)
     if built:
         # A row the last verify could not MEASURE is not a row waiting for another verify.
         # Its tests declined — the state they need does not exist in this environment — so
@@ -243,7 +280,7 @@ def next_command(app, rows, log_rows, phase=1, verdicts=None):
                 reason)
     if owner:
         if handoff_ran(log_rows):
-            line = f"(owner-run) docs/{app}-UsageGuide.md — {ids(owner)}"
+            line = f"(owner-run) {usage_guide(app)} — {ids(owner)}"
             return ("UAT", f"{len(owner)} owner-run, {q}", line, line,
                     f"{len(owner)} rows are Owner-UAT and handoff has run; the owner closes them")
         return ("Handoff", f"{len(owner)} owner-run, {q}",
@@ -252,10 +289,10 @@ def next_command(app, rows, log_rows, phase=1, verdicts=None):
     if handoff_ran(log_rows):
         line = "(owner) set current_phase to Released after UAT — no agent command"
         return ("UAT", f"handoff done, {q}", line, line,
-                "every row is terminal and handoff has run; waiting on the owner")
+                "every row in this phase's scope is terminal and handoff has run; waiting on the owner")
     return ("Handoff", q,
             f"{CC}flow-master *handoff-phase {app}", f"{OC}flow-master *handoff-phase {app}",
-            "every row is terminal and handoff has not run yet")
+            "every row in this phase's scope is terminal and handoff has not run yet")
 
 
 def main(argv):
@@ -284,14 +321,17 @@ def main(argv):
     log_rows = existing_log_rows(st_text)
     vdate, vresult = last_verify(root, app)
     phase, qual, cc, oc, reason = next_command(app, rows, log_rows, phase_n, ledger_verdicts(root))
+    roadmap = [r["id"] for r in rows if r["roadmap"]]
+    if roadmap:
+        reason += (f"; {len(roadmap)} roadmap row(s) are not in this phase's scope and are left for the owner "
+                   f"(*amend-docs): {', '.join(roadmap)}")
     pname, ptotal = phase_row(root, app, phase_n)
     if ptotal or phase_n > 1:
         tag = f"Phase {phase_n} of {ptotal or '?'}" + (f" ({pname})" if pname else "")
         phase = f"{tag} · {phase}"
         reason = f"{reason}; working {cl_rel}"
 
-    total = len(rows)
-    closed = sum(1 for r in rows if r["status"].lower() in TERMINAL)
+    verified, counted, na = figures(rows)
     counts = {}
     for r in rows:
         counts[r["status"]] = counts.get(r["status"], 0) + 1
@@ -322,7 +362,7 @@ def main(argv):
     print()
     if open_rows:
         for r in open_rows[:10]:
-            print(f"- [ ] {r['id']} — {r['name']} ({r['status']})")
+            print(f"- [ ] {r['id']} — {r['name']} ({r['status']}{', roadmap — not in this phase' if r['roadmap'] else ''})")
         if len(open_rows) > 10:
             print(f"- ({len(open_rows) - 10} more open rows in {cl_rel})")
     else:
@@ -332,7 +372,7 @@ def main(argv):
     print("Last five passes; older passes live in `docs/metrics/gates.jsonl`.")
     print()
     print("| Date | Phase | Result | Status table |\n|---|---|---|---|")
-    new_row = f"| {today} | {label} | {closed}/{total} Verified | {cl_rel}#requirements-status |"
+    new_row = f"| {today} | {label} | {verified}/{counted} Verified{f', {na} N/A' if na else ''} | {cl_rel}#requirements-status |"
     for r in (log_rows[-4:] if len(log_rows) > 4 else log_rows):
         print(r)
     print(new_row)

package/.tfcore/utils/tf-triage.py

@@ -8,6 +8,9 @@
     bash .tfcore/utils/tf-triage.sh <App> note <REQ> "<could not reproduce: what was tried>"
     bash .tfcore/utils/tf-triage.sh <App> close [--started <ISO>] [--verify-ran] [--cmd triage-issues|fix-issues]
 
+demote, new and note take --phase N for another phase's checklist; without it demote and note find the
+row in whichever docs/<App>-Checklist.md or docs/<App>-P<N>-Checklist.md holds it.
+
 demote  the row goes to Needs re-verify (% capped at 75) with a dated Remark holding the symptom in the
         reporter's words, the evidence path and the kind.
 new     a defect no row covers: the next free id in the prefix, a Not Started row, a detail entry with the
@@ -20,7 +23,8 @@ close   what triage owes the telemetry, from the actions above (tests/.artifacts
         spec for a new row, which the spec never had) (duplicates collapsed through
         tf-emit.sh --open-miss; the origin run looked up with --origin-of), then the run record. It also
         lists every file under src/, source/ or tests/ changed since the start: a triage that edited code
-        is reported and logged as an instruction-ignored miss (FR-28).
+        is reported and logged as an instruction-ignored miss (FR-28). Only actions logged since the start
+        count, and a close empties the list (TrBlazeUI TF-001).
 Exit 0 · 2 could not run.
 """
 import datetime
@@ -58,12 +62,36 @@ def cfg_phase():
     return 1
 
 
-def checklist(app):
-    ph = cfg_phase()
-    p = os.path.join("docs", f"{app}-Checklist.md" if ph <= 1 else f"{app}-P{ph}-Checklist.md")
-    if not os.path.isfile(p):
-        die(f"{p} does not exist")
-    return p
+def phase_checklist(app, ph):
+    return os.path.join("docs", f"{app}-Checklist.md" if ph <= 1 else f"{app}-P{ph}-Checklist.md")
+
+
+def checklist(app, argv, ce, rid=None):
+    """--phase N names the checklist, as tf-verify-list.py takes it. Without it: the appPhase
+    checklist, or, for a row that is not there, the one earlier-phase checklist that holds it —
+    a Phase 3 verify finds Phase 1 rows failing, and demote could not reach them (TF-051)."""
+    if "--phase" in argv:
+        v = opt(argv, "--phase", "")
+        if not v.isdigit():
+            die("--phase needs a number")
+        p = phase_checklist(app, int(v))
+        if not os.path.isfile(p):
+            die(f"{p} does not exist")
+        return p
+    p = phase_checklist(app, cfg_phase())
+    if rid is None or (os.path.isfile(p) and rid in ce.rows(ce.read(p))):
+        if not os.path.isfile(p):
+            die(f"{p} does not exist")
+        return p
+    import glob
+    every = sorted(set(glob.glob(os.path.join("docs", f"{app}-Checklist.md")) + glob.glob(os.path.join("docs", f"{app}-P*-Checklist.md"))))
+    hits = [c for c in every if rid in ce.rows(ce.read(c))]
+    if len(hits) == 1:
+        print(f"note: {rid} is a row of {hits[0]}, not of {p}; written there")
+        return hits[0]
+    if len(hits) > 1:
+        die(f"{rid} is a row of {', '.join(hits)}; name one with --phase N")
+    die(f"{rid} is not a row of {', '.join(every) or p}")
 
 
 def log_load():
@@ -112,7 +140,6 @@ def main(argv):
         return 0 if len(argv) > 1 else 2
     app, verb = argv[1], argv[2]
     ce = mod()
-    cl = checklist(app)
     log = log_load()
     log.setdefault("app", app)
     now = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
@@ -121,6 +148,7 @@ def main(argv):
         if len(argv) < 5:
             die("demote needs <REQ> \"<symptom>\"")
         rid, symptom = argv[3].upper(), argv[4]
+        cl = checklist(app, argv, ce, rid)
         kind = opt(argv, "--kind"); ev = opt(argv, "--evidence"); src = opt(argv, "--source", "owner")
         prior = ce.demote(cl, rid, symptom, kind=kind, evidence=ev, source=src, prefix="⚠ prod bug" if src == "production" else "⚠ UAT bug")
         if prior is None:
@@ -136,6 +164,7 @@ def main(argv):
         if len(argv) < 5:
             die("new needs \"<title>\" \"<acceptance>\"")
         title, acc = argv[3], argv[4]
+        cl = checklist(app, argv, ce)
         prefix = opt(argv, "--prefix", "FN").upper(); section = opt(argv, "--section"); ev = opt(argv, "--evidence")
         src = opt(argv, "--source", "owner"); mockup = opt(argv, "--mockup")
         if prefix == "UI" and not mockup:
@@ -152,6 +181,7 @@ def main(argv):
         if len(argv) < 5:
             die("note needs <REQ> \"<text>\"")
         rid = argv[3].upper()
+        cl = checklist(app, argv, ce, rid)
         if ce.note(cl, rid, argv[4]) is None:
             die(f"{rid} is not a row of {cl}")
         log["actions"].append({"verb": "note", "req_id": rid, "symptom": argv[4], "ts": now})
@@ -162,9 +192,11 @@ def main(argv):
     if verb == "close":
         started = opt(argv, "--started") or subprocess.run(["bash", os.path.join(HERE, "tf-phase.sh"), "show"], capture_output=True, text=True).stdout
         if started.startswith("{"):
-            import re
-            m = re.search(r'"started":"([^"]*)"', started)
-            started = m.group(1) if m else ""
+            # the marker's own started, never its "outer" block's (TF-052 follow-up)
+            try:
+                started = (json.loads(started) or {}).get("started") or ""
+            except ValueError:
+                started = ""
         started = started.strip() if started and not started.startswith("none") else ""
         cmd = opt(argv, "--cmd", "triage-issues")
         # code untouched?
@@ -173,16 +205,25 @@ def main(argv):
             t0 = datetime.datetime.strptime(started, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=datetime.timezone.utc).timestamp()
             for top in ("src", "source", "tests"):
                 for d, dirs, files in os.walk(top):
-                    dirs[:] = [x for x in dirs if x not in ("bin", "obj", "node_modules", ".artifacts", "TestResults")]
+                    # a running app's own log files are not code (AppManager TF-026)
+                    dirs[:] = [x for x in dirs if x not in ("bin", "obj", "node_modules", ".artifacts", "TestResults")
+                               and x.lower() not in ("logs", "log")]
                     for f in files:
+                        if f.lower().endswith(".log"):
+                            continue
                         p = os.path.join(d, f)
                         try:
                             if os.path.getmtime(p) > t0:
                                 changed.append(p.replace("\\", "/"))
                         except OSError:
                             pass
-        acts = [a for a in log.get("actions", []) if a["verb"] in ("demote", "new")]
+        # only this triage's actions: an earlier run's leftovers were logged again under today's run (TrBlazeUI TF-001)
+        stale = [a for a in log.get("actions", []) if started and (a.get("ts") or "") < started]
+        if stale:
+            print(f"  skipped {len(stale)} action(s) from before {started} — an earlier triage's, already closed or abandoned")
+        acts = [a for a in log.get("actions", []) if a["verb"] in ("demote", "new") and a not in stale]
         gates = misses = 0
+        failed = []
         for a in acts:
             rid = a["req_id"]; cls_req = rid.split("-")[1]
             att = q("--next-attempt", rid) or "1"
@@ -192,7 +233,9 @@ def main(argv):
                    "gate": "escaped", "gates_run": [], "failure_class": fc, "prior_verdict": a.get("prior")}
             if emit("gates", rec):
                 gates += 1
-            mc = ("unspecified-gap" if a["verb"] == "new" else "regression" if (a.get("prior") or "").lower().startswith("verified") else "wrong-behaviour")
+            else:
+                failed.append(a)
+            mc =("unspecified-gap" if a["verb"] == "new" else "regression" if (a.get("prior") or "").lower().startswith("verified") else "wrong-behaviour")
             opened = q("--open-miss", rid)
             if opened and opened.split()[-1] == mc:
                 print(f"  {rid}: already open as {opened.split()[0]} ({mc}); no second miss")
@@ -210,9 +253,11 @@ def main(argv):
             if emit("misses", m):
                 misses += 1
                 a["miss_id"] = mid
-        if changed and cmd == "triage-issues" and not log.get("code_miss_id"):
+            elif a not in failed:
+                failed.append(a)
+        if changed and cmd == "triage-issues" and log.get("code_miss_run") != started:
             mid = q("--next-miss-id")
-            log["code_miss_id"] = mid
+            log["code_miss_id"] = mid; log["code_miss_run"] = started
             emit("misses", {"kind": "miss", "miss_id": mid, "req_id": None, "req_class": None, "miss_class": "other", "artifact": "src",
                             "severity": "major", "why_missed": "instruction-ignored", "origin_phase": "triage-issues", "origin_agent": "flow-master",
                             "found_by": "gate", "found_phase": "triage-issues", "found_gate": None, "found_run_id": started, "failure_class": "other",
@@ -232,6 +277,7 @@ def main(argv):
         else:
             ok = None
         log["closed"] = now
+        log["actions"] = failed          # a closed action is never closed again; one whose record was refused waits for the next close
         log_save(log)
         print(f"triage: {len(acts)} row(s) logged — {gates} gate record(s) (escaped), {misses} miss(es)"
               + (f", run record {'written' if ok else 'not written'}" if ok is not None else "") + f"; code untouched: {'yes' if not changed else 'NO'}")

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

@@ -6,6 +6,8 @@
 #   bash .tfcore/utils/tf-triage.sh <App> note <REQ> "<could not reproduce: what was tried>"
 #   bash .tfcore/utils/tf-triage.sh <App> close [--started <ISO>] [--cmd triage-issues|fix-issues]
 #
+# demote, new and note take --phase N; without it a row of an earlier phase's checklist is found (TF-051).
+#
 # demote: Needs re-verify with a dated Remark in the reporter's words. new: a Not Started row with its
 # acceptance line and BRD-pending. note: a remark, no status change. close: the escaped gate records,
 # one miss per row (found by the owner, the symptom as `what`, duplicates collapsed), the run record,