@techierathore/techieflow 1.0.4 → 1.1.0

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

@@ -23,6 +23,8 @@
 #                                               # marks a WRONG run record as not to be counted: both
 #                                               # records stay, every figure skips it and says how many
 #                                               # and why (SCHEMA.md §2.7). Refuses if no such run.
+#   tf-emit.sh --void-miss MISS-App-20260919-01 "logged again from an earlier triage's leftovers"
+#                                               # the same for a WRONG miss (SCHEMA.md §5.5.11)
 #   tf-emit.sh --origin-of REQ-UI-014           # prints "<started> <cmd> <agent>" of the last build or fix
 #                                               # run that touched the row, nothing when there is none
 #   tf-emit.sh --where                          # prints the resolved docs/metrics dir
@@ -292,7 +294,7 @@ if [[ "$1" == "--open-misses" ]]; then
 import json, os, sys
 DOC = {"brd", "architecture", "uidesign", "checklist", "devguide"}
 app, klass = os.environ.get("TF_OMAPP") or "", os.environ.get("TF_OMCLASS") or ""
-opened, fixes = [], {}
+opened, fixes, voided = [], {}, set()
 try:
     with open(sys.argv[1], encoding="utf-8") as fh:
         for line in fh:
@@ -305,6 +307,8 @@ try:
                 continue
             if r.get("kind") == "miss":
                 opened.append(r)
+            elif r.get("kind") == "miss-void":
+                voided.add(r.get("miss_id"))
             elif r.get("kind") == "miss-fix":
                 mid = r.get("miss_id")
                 if mid:
@@ -314,6 +318,8 @@ try:
 except FileNotFoundError:
     pass
 for r in opened:
+    if r.get("miss_id") in voided:
+        continue
     if app and r.get("app") and r.get("app") != app:
         continue
     art = r.get("artifact") or ""
@@ -335,7 +341,7 @@ if [[ "$1" == "--open-miss" ]]; then
   python3 - "$MET_DIR/misses.jsonl" "$REQ" 2>"$TF_ERR" <<'PY' || true
 import json, sys
 path, req = sys.argv[1], sys.argv[2]
-opened, fixes = [], {}
+opened, fixes, voided = [], {}, set()
 try:
     with open(path, encoding="utf-8") as fh:
         for line in fh:
@@ -348,6 +354,8 @@ try:
                 continue
             if r.get("kind") == "miss" and r.get("req_id") == req:
                 opened.append(r)
+            elif r.get("kind") == "miss-void":
+                voided.add(r.get("miss_id"))
             elif r.get("kind") == "miss-fix":
                 mid = r.get("miss_id")
                 if mid:
@@ -357,6 +365,8 @@ try:
 except FileNotFoundError:
     pass
 for r in reversed(opened):                     # most recent first
+    if r.get("miss_id") in voided:
+        continue
     fix = fixes.get(r.get("miss_id"))
     if fix is None or fix.get("verdict_after") != "Verified":
         print("%s %s" % (r.get("miss_id"), r.get("miss_class") or "other"))
@@ -458,6 +468,45 @@ PY
   exit 0
 fi
 
+# --- write helper: withdraw a miss that should never have been written -----
+# SCHEMA.md §5.5.11 — --void-run's answer for the misses stream (TrBlazeUI TF-001).
+if [[ "$1" == "--void-miss" ]]; then
+  VMID="$2"; VWHY="$3"
+  VREC="$(python3 - "$MET_DIR/misses.jsonl" "$VMID" "$VWHY" 2>"$TF_ERR" <<'PY' || true
+import json, sys
+path, mid, why = sys.argv[1], sys.argv[2], sys.argv[3]
+found, voided = False, False
+try:
+    for line in open(path, encoding="utf-8"):
+        try:
+            r = json.loads(line)
+        except Exception:
+            continue
+        if r.get("miss_id") == mid:
+            found = found or r.get("kind") == "miss"
+            voided = voided or r.get("kind") == "miss-void"
+except FileNotFoundError:
+    pass
+if not found:
+    print("REFUSED no miss record %s on this stream" % mid)
+elif voided:
+    print("REFUSED %s is already voided — one void is enough" % mid)
+elif not why.strip():
+    print("REFUSED a void needs a reason a reader can check")
+else:
+    print("OK " + json.dumps({"kind": "miss-void", "miss_id": mid, "reason": why.strip()},
+                             separators=(",", ":"), ensure_ascii=False))
+PY
+)"
+  case "$VREC" in
+    "OK "*) printf '%s' "${VREC#OK }" | bash "${BASH_SOURCE[0]}" misses
+            echo "tf-emit: voided $VMID — $VWHY" ;;
+    "REFUSED "*) echo "tf-emit: void refused — ${VREC#REFUSED }" ;;
+    *) echo "tf-emit: void could not be evaluated — nothing written" ;;
+  esac
+  exit 0
+fi
+
 # --- write helper: mark a run record as not to be counted -----------------
 # SCHEMA.md §2.7. The same doctrine as --amend, one stream over: a run record that
 # is WRONG cannot be edited or deleted, because the stream is append-only and the
@@ -536,7 +585,7 @@ esac
 
 # The program is captured into a variable rather than fed on stdin — a heredoc
 # on `python3 -` would REPLACE the caller's piped JSON and silently drop every event.
-TF_PROG="$(cat <<'PY'
+IFS= read -r -d '' TF_PROG <<'PY' || true   # bash 3.2 misreads a here-document inside a command substitution
 import json, os, sys, datetime, glob, re, subprocess, time
 
 met_dir, stream, root = sys.argv[1], sys.argv[2], sys.argv[3]
@@ -1054,20 +1103,25 @@ def _prior_runs():
 # (MISS-TechieFlow-20260910-04, sorted `ignored`: it was written down and not followed).
 #
 # A stream is append-only, so the only place to stop it is before the write. The rule: for one
-# app, a live `run` record may not begin before the last live `run` record ended. Voided and
-# backfilled records are ignored, which is what makes the void-then-re-emit flow work. Records
-# with no `started` are untouched.
+# app, a live `run` record's window may not OVERLAP another live `run` record's window. It is the
+# windows that are compared, not the order of writing: a command that chains another one inside
+# itself -- *build-phase chaining *verify -- finishes last but did its own first segment before the
+# inner run started, and comparing against the newest record alone meant that segment could never be
+# recorded at all (TfLens TF-040, 80 minutes and five builder clusters on no record). Two windows
+# that merely touch at a boundary do not overlap. Voided and backfilled records are ignored, which
+# is what makes the void-then-re-emit flow work. Records with no `started` are untouched.
 #
 # The one legitimate overlap is two machines appending to the same merge=union stream, so
 # `--allow-overlap` exists and the refusal message names it. It is deliberately a flag and not a
 # fallback: the mistake this refuses is easy to make and invisible afterwards.
-_LAST_END = None
+_LIVE = None
 
 
-def _last_live_end(app):
-    global _LAST_END
-    if _LAST_END is None:
-        _LAST_END = {}
+def _live_windows(app):
+    """[(started, ended, cmd)] of every live run record for this app, oldest first."""
+    global _LIVE
+    if _LIVE is None:
+        _LIVE = {}
         voided = set()
         rows = []
         try:
@@ -1089,6 +1143,9 @@ def _last_live_end(app):
         for r in rows:
             if (r.get("app"), r.get("cmd"), r.get("started")) in voided:
                 continue
+            start = r.get("started")
+            if not start:
+                continue
             # `ended` ONLY. `ts` is when the record was WRITTEN, not when the run finished, so
             # falling back to it would make every historical record emitted today look like an
             # overlap with the record written a second ago. A run with no `ended` has no window
@@ -1103,38 +1160,37 @@ def _last_live_end(app):
             end = r.get("ended")
             if not end:
                 continue
-            a = r.get("app")
-            if a not in _LAST_END or end > _LAST_END[a][0]:
-                _LAST_END[a] = (end, r.get("cmd"), r.get("started"))
-    return _LAST_END.get(app)
+            _LIVE.setdefault(r.get("app"), []).append((start, end, r.get("cmd")))
+    return _LIVE.get(app, [])
 
 
 def _overlap_ok(rec):
-    """False (and the reason printed) when this run would start before the last one ended."""
+    """False (and the reason printed) when this run's window overlaps a live one's."""
     if stream != "runs" or rec.get("kind", "run") != "run" or rec.get("backfilled"):
         return True
     if os.environ.get("TF_ALLOW_OVERLAP") == "1":
         return True
-    started = rec.get("started")
+    started, ended = rec.get("started"), rec.get("ended")
     if not started:
         return True
-    prev = _last_live_end(rec.get("app"))
-    if not prev:
-        return True
-    a, b = _iso_ms(started), _iso_ms(prev[0])
-    if a is not None and b is not None:
-        if a >= b:
-            return True
-    elif started >= prev[0]:        # unparseable timestamp: fall back to the string order
-        return True
-    sys.stdout.write(
-        "tf-emit: REFUSED — this run starts at %s, before the previous run for %s ended at %s "
-        "(%s started %s). The two would overlap and every total over them would be that much too "
-        "big. Use the previous run's `ended` as this one's `started`, or pass --allow-overlap if "
-        "they really did run at the same time (a second machine on the same stream). "
-        "Nothing was appended.\n"
-        % (started, rec.get("app"), prev[0], prev[1], prev[2]))
-    return False
+    def key(v):
+        k = _iso_ms(v)
+        return k if k is not None else v      # unparseable: compare as strings, as before
+    s, e = key(started), key(ended or started)
+    for (ps, pe, pcmd) in _live_windows(rec.get("app")):
+        a, b = key(ps), key(pe)
+        if type(a) is not type(s) or type(b) is not type(e):
+            continue
+        if s < b and a < e:                   # windows that only touch at a boundary are fine
+            sys.stdout.write(
+                "tf-emit: REFUSED — this run (%s to %s) overlaps the %s run of %s already on the "
+                "stream (%s to %s). Every total over the two would be that much too big. Record the "
+                "part that did not overlap -- a command that chained another one records its own "
+                "segment before the inner run started -- or pass --allow-overlap if they really did "
+                "run at the same time (a second machine on the same stream). Nothing was appended.\n"
+                % (started, ended or "now", pcmd, rec.get("app"), ps, pe))
+            return False
+    return True
 
 
 def stamp_attempt(rec):
@@ -1431,6 +1487,8 @@ _ALLOWED = {
                              "tokens_cache_write", "cost_usd", "tokens_scope", "model",
                              "billing_mode", "cost_source"},
     ("misses", "miss-amend"): {"miss_id", "field", "value"},
+    # a miss that should never have been written, withdrawn by --void-miss (SCHEMA.md §5.5.11)
+    ("misses", "miss-void"): {"miss_id", "reason"},
     # an owner review of a phase's output (FR-36, built 2026-09-06): how many corrections were
     # given, what producing the reviewed output cost, what applying the corrections cost. The two
     # costs are copied from the runs named by reviewed_run_id and correction_run_id (their `started`).
@@ -1588,7 +1646,6 @@ except Exception as e:
     warn("append failed (%s) — event dropped" % e)
     raise SystemExit(0)
 PY
-)"
 python3 -c "$TF_PROG" "$MET_DIR" "$STREAM" "$ROOT" 2>"$TF_ERR"
 
 # The readable miss list beside the record (FR-31, Session 5 2026-09-07): after any write to the

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

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# tf-feedback.sh — the state of every entry in this project's upstream feedback files, and the
+# one way to mark an entry closed once its fix has been re-checked here (2026-09-11).
+#
+#   bash .tfcore/utils/tf-feedback.sh <App>                     every entry: open, fixed upstream, closed
+#   bash .tfcore/utils/tf-feedback.sh <App> --waiting           fixed upstream, not yet re-checked here
+#   bash .tfcore/utils/tf-feedback.sh <App> --close <ID> "<what you ran and what it showed>"
+#
+# Details: tf_feedback.py. Writes nothing except the one closing line --close adds.
+set -u
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+command -v python3 >/dev/null 2>&1 || { echo "tf-feedback: python3 is required" >&2; exit 2; }
+exec python3 "$HERE/tf_feedback.py" "$@"

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

@@ -15,13 +15,17 @@
 #
 # Emits, in this order, through tf-emit.sh only:
 #   1. the fix-issues run record (cmd fix-issues, mode fix, the rows touched) — first, because the
-#      miss-fix records below carry no numbers of their own: the emitter copies this run's token window
-#   2. one miss-fix per row that has an open miss, with verdict_after taken from the verify ledger
-#      docs/.last-verify.json written by the verify the fix chained, mapped to a checklist status (PASS →
-#      Verified; FAIL → FAIL; any other failing verdict or an absent row → Needs re-verify). A row with no open miss is listed,
+#      miss-fix records below carry no numbers of their own: the emitter copies this run's token window.
+#      A run the fix chained (the inline verify) keeps its own record, so the fix is recorded in the gaps
+#      around it; the first gap carries the rows and the fix's start (TF-052).
+#   2. one miss-fix per row that has an open miss, with verdict_after taken from every verify the fix
+#      chained: the gate records written since the fix started, then the ledger docs/.last-verify.json
+#      when it belongs to this fix (PASS → Verified; FAIL → FAIL; any other failing verdict → Needs
+#      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.
-# --reqs defaults to every row in the ledger. Telemetry never blocks: refusals are printed, exit 0.
+# --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; }
@@ -40,7 +44,12 @@ while [[ $# -gt 0 ]]; do
     *) echo "tf-fix-close: unknown argument $1" >&2; exit 3 ;;
   esac
 done
-[[ -z "$STARTED" ]] && STARTED="$(bash "$HERE/tf-phase.sh" show 2>/dev/null | sed -n 's/.*"started":"\([^"]*\)".*/\1/p')"
+# the fix's start: its own marker, or the "outer" one when a verify it chained has replaced the marker
+[[ -z "$STARTED" ]] && STARTED="$(bash "$HERE/tf-phase.sh" show 2>/dev/null | python3 -c "import json,sys
+try: m=json.load(sys.stdin)
+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'
 import datetime, json, os, subprocess
@@ -71,45 +80,86 @@ if direct:
           % (fix_cmd, closed, len(direct)))
     raise SystemExit(0)
 
+met = q("--where") or "docs/metrics"
+def jsonl(name):
+    try:
+        for line in open(os.path.join(met, name), encoding="utf-8", errors="replace"):
+            try: yield json.loads(line)
+            except Exception: pass
+    except OSError:
+        return
+# The verdicts: every verify this fix chained, not only the last. docs/.last-verify.json holds one scoped
+# verify, so a fix that verified a Phase 3 scope and then a --phase 1 scope read the Phase 3 rows as absent
+# and wrote Needs re-verify on their misses (TF-052). The gate records each verify wrote since the fix
+# started come first; the ledger fills in only when it belongs to this fix.
+rows = {}   # rid -> checklist status
+if started:
+    for g in jsonl("gates.jsonl"):
+        if g.get("kind") == "gate" and g.get("app") in (None, app) and not g.get("backfilled") and g.get("gate") != "escaped" \
+                and (g.get("run_id") or "") >= started and g.get("req_id"):
+            rows[g["req_id"].upper()] = g.get("verdict")
 ledger = {}
 try:
     ledger = json.load(open(os.path.join("docs", ".last-verify.json"), encoding="utf-8"))
 except Exception:
     pass
-rows = ledger.get("rows") or {}
+if not started or not ledger.get("run_id") or ledger["run_id"] >= started:
+    row_runs = ledger.get("row_runs")   # a ledger kept row by row also holds older runs' rows (Lekhak TF-007)
+    for rid, v in (ledger.get("rows") or {}).items():
+        if started and isinstance(row_runs, dict) and rid not in (ledger.get("this_run") or []) \
+                and (row_runs.get(rid) or "") < started:
+            continue
+        # verdict_after takes a checklist status (SCHEMA §5.5): the ledger's verdict is mapped, never passed raw
+        # (MISS-TechieFlow-20260906-25: RENDER-FAIL was refused and twenty miss-fix records never landed)
+        rows.setdefault(rid.upper(), "Verified" if v == "PASS" else "FAIL" if v in ("FAIL", "BUILD-FAIL") else "Needs re-verify")
 reqs = [r.strip().upper() for r in os.environ["TF_REQS"].split(",") if r.strip()] or sorted(rows)
 subs = [s.strip() for s in os.environ["TF_SUBS"].split(",") if s.strip()]
 files = os.environ["TF_FILES"]
-run = {"kind": "run", "app": app, "cmd": "fix-issues", "mode": "fix", "ended": now, "reqs_touched": reqs, "reqs_count": len(reqs),
-       "subagents": subs, "files_written": int(files) if files.isdigit() else len(reqs), "build_result": os.environ["TF_BUILD"]}
-if started: run["started"] = started
-# one run record per start: a close called twice must not count the fix twice
-runs_path = os.path.join(q("--where") or "docs/metrics", "runs.jsonl")
-already = False
-if started and os.path.isfile(runs_path):
-    for line in open(runs_path, encoding="utf-8", errors="replace"):
-        if '"cmd":"fix-issues"' in line and f'"started":"{started}"' in line:
-            already = True
-            break
-ok = True if already else emit("runs", run)
-if already:
-    print(f"fix-issues: run record for start {started} already exists; not written again")
-closed, none = 0, []
+# The fix's own time only: a run it chained (the inline verify) has its own record, so the fix is recorded
+# in the gaps around it, the first gap keyed on the fix's start with the rows (its miss-fixes name that start).
+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") \
+            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)
+gaps, t = [], started
+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"}
+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 [],
+           "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
+    # one run record per start: a close called twice must not count the fix twice
+    if s and s in existing:
+        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)")
+closed, none, unverified = 0, [], []
 for rid in reqs:
+    if rid not in rows:
+        unverified.append(rid); continue
     opened = q("--open-miss", rid)
     if not opened:
         none.append(rid); continue
     mid = opened.split()[0]
     fa = q("--next-fix-attempt", mid) or "1"
-    v = rows.get(rid)
-    # verdict_after takes a checklist status (SCHEMA §5.5): the ledger's verdict is mapped, never passed raw
-    # (MISS-TechieFlow-20260906-25: RENDER-FAIL was refused and twenty miss-fix records never landed)
-    after = ("Verified" if v == "PASS" else "FAIL" if v in ("FAIL", "BUILD-FAIL") else "Needs re-verify")
     rec = {"kind": "miss-fix", "miss_id": mid, "req_id": rid, "fix_cmd": "fix-issues", "fix_attempt": int(fa) if fa.isdigit() else 1,
-           "verdict_after": after, "reopened": False}
+           "verdict_after": rows[rid], "reopened": False}
     if started: rec["fix_run_id"] = started
     if emit("misses", rec): closed += 1
-print(f"fix-issues: run record {'already there' if already else 'written' if ok else 'not written'}; {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 ""))
+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"
+      + (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
 exit 0

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

@@ -68,6 +68,8 @@
 #   Override command lines with TF_GOAL_CLAUDE_FLAGS / TF_GOAL_OPENCODE_FLAGS /
 
 set -u
+# GNU-only commands (setsid, stat -c, date -d) go through the shim, so a stock Mac runs this too.
+source "$(dirname "${BASH_SOURCE[0]}")/tf-portable.sh"
 
 HARNESS="claude"; MODEL=""; BUFFER_MIN=15; DEFAULT_WAIT_MIN=60; MAX_CYCLES=60; IDLE_RETRY=30
 PROBE_MIN=15; PROBE_MAX_H=8; STALL_MIN=15
@@ -162,7 +164,7 @@ else
     _lr="$(state_get last_reason)"
     case "$_lr" in
       done:*|max-cycles|stopped|"") ;;
-      *) echo "tf-goal: a run looks active in $APP_DIR (goal.json last_reason=$_lr, touched $(date -u -r "$STATE" +%H:%MZ)). Wait for it, or continue it with --resume." >&2; exit 2 ;;
+      *) echo "tf-goal: a run looks active in $APP_DIR (goal.json last_reason=$_lr, touched $(tf_date_from -u "@$(tf_stat_mtime "$STATE")" +%H:%MZ)). Wait for it, or continue it with --resume." >&2; exit 2 ;;
     esac
   fi
   CYCLE=0; SESSION_ID=""; STALLS=0
@@ -436,11 +438,11 @@ probe_until_clear() {
     else
       ( cd "$APP_DIR" && opencode run --auto "Reply with the single word OK." ) > "$pout" 2>&1; prc=$?
     fi
-    if [[ $prc -eq 0 ]] && ! grep -qiE 'usage limit|hit your limit|rate[ _-]?limit|limit (has been )?(reached|exceeded)|too many requests|\b429\b|overloaded|weekly limit|resets? (at|in)\b' "$pout"; then
+    if [[ $prc -eq 0 ]] && ! grep -qiE 'usage limit|hit your limit|rate[ _-]?limit|limit (has been )?(reached|exceeded)|too many requests|(^|[^[:alnum:]_])429([^[:alnum:]_]|$)|overloaded|weekly limit|resets? (at|in)([^[:alnum:]_]|$)' "$pout"; then
       log "probe #$n OK"; return 0
     fi
     log "probe #$n still limited (rc=$prc: $(head -c 120 "$pout" | tr '\n' ' ')) — next in ${PROBE_MIN}m"
-    state_set resume_at "probe #$((n+1)) at $(date -d "+${PROBE_MIN} min" '+%H:%M' 2>/dev/null)"
+    state_set resume_at "probe #$((n+1)) at $(tf_date_from "+${PROBE_MIN} min" '+%H:%M' 2>/dev/null)"
     if [[ $(date +%s) -ge $deadline ]]; then log "probe window (${PROBE_MAX_H}h) exhausted — resuming anyway"; return 1; fi
     nap $(( PROBE_MIN * 60 ))
   done
@@ -450,7 +452,7 @@ sleep_until() { # epoch
   local target="$1" now left
   while :; do
     now=$(date +%s); left=$(( target - now )); [[ $left -le 0 ]] && break
-    state_set resume_at "$(date -u -d "@$target" +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo "$target")"
+    state_set resume_at "$(tf_date_from -u "@$target" +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo "$target")"
     if [[ $left -gt 300 ]]; then nap 300; else nap "$left"; fi
   done
   state_set resume_at ""
@@ -482,16 +484,14 @@ run_cycle() { # runs "${CMD[@]}" in $APP_DIR, output to $OUT and $LOG; sets RC,
   STALLED=0
   local quiet=0 prev=-1 size
   if [[ -n "${TF_GOAL_FAKE_CMD:-}" ]]; then CMD=(bash -c "$TF_GOAL_FAKE_CMD"); fi
-  if command -v setsid >/dev/null 2>&1; then
-    ( cd "$APP_DIR" && TF_YOLO=1 exec setsid "${CMD[@]}" ) > >(tee -a "$LOG" > "$OUT") 2>&1 &
-  else
-    ( cd "$APP_DIR" && TF_YOLO=1 exec "${CMD[@]}" ) > >(tee -a "$LOG" > "$OUT") 2>&1 &
-  fi
+  # Its own session and process group (tf_setsid: setsid(1), or python3/perl on a Mac), so
+  # kill_child can stop the whole tree.
+  ( cd "$APP_DIR" && TF_YOLO=1 tf_setsid --exec "${CMD[@]}" ) > >(tee -a "$LOG" > "$OUT") 2>&1 &
   CHILD=$!
   while kill -0 "$CHILD" 2>/dev/null; do
     nap "$STALL_TICK"
     kill -0 "$CHILD" 2>/dev/null || break
-    size="$(stat -c %s "$OUT" 2>/dev/null || echo 0)"
+    size="$(tf_stat_size "$OUT" 2>/dev/null || echo 0)"
     if [[ "$size" == "$prev" ]]; then quiet=$(( quiet + STALL_TICK )); else quiet=0; prev="$size"; fi
     if [[ "$STALL_SEC" -gt 0 && $quiet -ge "$STALL_SEC" ]]; then
       log "STALL: no output for $(( quiet / 60 ))m$(( quiet % 60 ))s (cycle $CYCLE, ${size} bytes) — stopping the harness, re-prompting"
@@ -569,7 +569,7 @@ while :; do
   OUT="$STATE_DIR/goal-cycle-$CYCLE.out"
   if [[ $DRY -eq 1 ]]; then echo "dry run — would launch cycle $CYCLE ($KIND):" >&2; printf '  %q' "${CMD[@]}"; echo; exit 0; fi
   state_set cycle "$CYCLE"; CYCLE_START="$(date +%s)"
-  log "cycle $CYCLE ($KIND) → ${CMD[*]:0:6} … (prompt ${#CMD[-1]} chars)"
+  log "cycle $CYCLE ($KIND) → ${CMD[*]:0:6} … (prompt ${#CMD[${#CMD[@]}-1]} chars)"
 
   # The run's start is now, not when the agent reaches step 0: write an unclaimed marker the
   # first command's `tf-phase.sh start` claims (MISS-TechieFlow-20260905-20).
@@ -620,7 +620,7 @@ while :; do
         log "probe succeeded — resuming session ${SESSION_ID:-(--continue)} after a ${BUFFER_MIN}m buffer"
         nap $(( BUFFER_MIN * 60 ))
       else
-        WHEN="$(date -d "@$DETAIL" '+%Y-%m-%d %H:%M %Z' 2>/dev/null || echo "$DETAIL")"
+        WHEN="$(tf_date_from "@$DETAIL" '+%Y-%m-%d %H:%M %Z' 2>/dev/null || echo "$DETAIL")"
         log "USAGE LIMIT hit (cycle $CYCLE) — RETRY AT $WHEN (stated reset + ${BUFFER_MIN}m buffer). Sleeping."
         state_set last_reason "limit" resume_at "$WHEN"
         sleep_until "$DETAIL"

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

@@ -48,13 +48,18 @@ _detect() {
   fi
   local k
   for k in $(compgen -v | grep '^OPENCODE' 2>/dev/null); do printf 'opencode'; return; done
-  # /proc ancestry walk (Linux/WSL); bounded
+  # ancestry walk, bounded: /proc on Linux/WSL, ps where there is no /proc (macOS)
   local pid=$PPID name ppid seen=0 stat
   while [[ -n "$pid" && "$pid" -gt 1 && $seen -lt 12 ]]; do
     seen=$((seen + 1))
-    stat="$(cat /proc/$pid/stat 2>/dev/null)" || break
-    name="${stat#*(}"; name="${name%%)*}"
-    ppid="$(printf '%s' "${stat##*) }" | awk '{print $2}')"
+    if [[ -d /proc/self ]]; then
+      stat="$(cat /proc/$pid/stat 2>/dev/null)" || break
+      name="${stat#*(}"; name="${name%%)*}"
+      ppid="$(printf '%s' "${stat##*) }" | awk '{print $2}')"
+    else
+      ppid="$(ps -o ppid= -p "$pid" 2>/dev/null | tr -d ' ')"; [[ -n "$ppid" ]] || break
+      name="$(ps -o comm= -p "$pid" 2>/dev/null)"; name="${name##*/}"
+    fi
     case "$name" in
       *opencode*) printf 'opencode'; return ;;
       *claude*)   printf 'claude-code'; return ;;

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

@@ -0,0 +1,29 @@
+# tf-lock.sh — one build or browser check at a time per repository. Sourced, not run.
+#   source "$HERE/tf-lock.sh"; tf_take_lock <label>     waits for the lock, then holds it until exit
+# A directory, because mkdir is atomic on every drive this runs on. A lock whose process has gone
+# is taken over. A script started by the holder (tf-verify-tests.sh running tf-build.sh) shares it
+# through TF_REPO_LOCK_PID. TF_BUILD_LOCK_MAX seconds to wait (1800). (TF-043, TfLens TF-048)
+TF_LOCK="tests/.artifacts/build/.lock"
+tf_release_lock() { [[ "$(cut -d' ' -f1 "$TF_LOCK/owner" 2>/dev/null)" == "$$" ]] && rm -rf "$TF_LOCK"; }
+tf_take_lock() {
+  local label="${1:-}" waited=0 max="${TF_BUILD_LOCK_MAX:-1800}" said=0 owner opid ohost
+  if [[ -n "${TF_REPO_LOCK_PID:-}" ]] && kill -0 "$TF_REPO_LOCK_PID" 2>/dev/null; then return 0; fi
+  mkdir -p "$(dirname "$TF_LOCK")"
+  while ! mkdir "$TF_LOCK" 2>/dev/null; do
+    owner="$(cat "$TF_LOCK/owner" 2>/dev/null)"; opid="$(cut -d' ' -f1 <<<"$owner")"; ohost="$(cut -d' ' -f2 <<<"$owner")"
+    if [[ -z "$owner" ]]; then
+      [[ -n "$(find "$TF_LOCK" -maxdepth 0 -mmin +1 2>/dev/null)" ]] && { rm -rf "$TF_LOCK"; continue; }
+    elif [[ "$ohost" == "$(hostname)" ]] && ! kill -0 "$opid" 2>/dev/null; then
+      rm -rf "$TF_LOCK"; continue
+    fi
+    [[ $said -eq 0 ]] && { echo "wait  another build or browser check is running in this repository (${owner:-starting}); this one starts when it finishes" >&2; said=1; }
+    if [[ $waited -ge $max ]]; then
+      echo "NOT-RUN another build or browser check held this repository for $((max / 60)) minutes ($owner). If nothing is running, remove $TF_LOCK and run again. Not a code error"
+      exit 2
+    fi
+    sleep 3; waited=$((waited + 3))
+  done
+  echo "$$ $(hostname) $label $(date -u +%Y-%m-%dT%H:%M:%SZ)" > "$TF_LOCK/owner"
+  export TF_REPO_LOCK_PID=$$
+  trap tf_release_lock EXIT
+}

package/.tfcore/utils/tf-log-miss.py

@@ -16,7 +16,8 @@ re-logged; a null why_missed or sort on it is completed with --amend); the origi
 (tf-emit.sh --origin-of); the miss record with the sentence as `what` and the sort; the checklist line
 (the row demoted to Needs re-verify with "⚠ miss <date>: <sentence>", or a new Not Started row with
 BRD-pending when nothing owns it; nothing when the repo has no checklist); with --fixed, a miss-fix
-record instead of a demotion; then the run record (cmd log-miss). The emitter rewrites the readable
+record instead of a demotion; then the run record (cmd log-miss) — none when another command is
+running, because that command's own record covers the time (TF-029). The emitter rewrites the readable
 docs/<App>-Misses.md. Prints the report block. Exit 0 · 2 could not run.
 """
 import datetime
@@ -91,11 +92,31 @@ def main(argv):
     found_by = opt(argv, "--found-by", "owner")
     fixed = "--fixed" in argv
     started = opt(argv, "--started") or ""
+    now = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    # The command whose run record covers this time. Called inside another command (*amend-docs
+    # step 10), that command's record covers it, so this script writes none: a log-miss run over
+    # the enclosing command's window made the enclosing record overlap and be refused (TF-029).
+    # A marker older than 24 h belongs to a session that died, and is ignored as every reader does.
+    running = "log-miss"
     if not started:
+        # The marker's own cmd and started, never its "outer" block: a command started after another
+        # one keeps that one as "outer", written first, and a first-match read took it for this one
+        # (TF-052 follow-up: log-miss after *triage-issues wrote no run record).
         mk = subprocess.run(["bash", os.path.join(HERE, "tf-phase.sh"), "show"], capture_output=True, text=True).stdout
-        m = re.search(r'"started":"([^"]*)"', mk)
-        started = m.group(1) if m else datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-    now = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        try:
+            marker = json.loads(mk) if mk.strip().startswith("{") else {}
+        except ValueError:
+            marker = {}
+        m_started, m_cmd = marker.get("started") or "", marker.get("cmd") or ""
+        try:
+            age = (datetime.datetime.now(datetime.timezone.utc)
+                   - datetime.datetime.strptime(m_started, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=datetime.timezone.utc))
+            fresh = age < datetime.timedelta(hours=24)
+        except ValueError:
+            fresh = False
+        started = m_started if fresh else now
+        if fresh and m_cmd and m_cmd not in ("log-miss", "goal"):
+            running = m_cmd
 
     spec = importlib.util.spec_from_file_location("tf_checklist_edit", os.path.join(HERE, "tf-checklist-edit.py"))
     ce = importlib.util.module_from_spec(spec)
@@ -165,10 +186,14 @@ def main(argv):
         fix_ok, _ = emit("misses", fr)
         fix_line = ("closed in the same run" + (f" against run {fr['fix_run_id']}" if "fix_run_id" in fr else " (fix run unknown: costed none)")) if fix_ok else "miss-fix not written"
 
-    # 5. the run record
-    run = {"kind": "run", "app": app, "cmd": "log-miss", "mode": None, "started": started, "ended": now,
-           "reqs_touched": [req] if req else [], "reqs_count": 1 if req else 0, "subagents": [], "files_written": 1 if has_cl else 0, "build_result": "not-run"}
-    emit("runs", run)
+    # 5. the run record — only when log-miss is the command running
+    if running == "log-miss":
+        run = {"kind": "run", "app": app, "cmd": "log-miss", "mode": None, "started": started, "ended": now,
+               "reqs_touched": [req] if req else [], "reqs_count": 1 if req else 0, "subagents": [], "files_written": 1 if has_cl else 0, "build_result": "not-run"}
+        emit("runs", run)
+        run_line = f"log-miss, {started} to {now}"
+    else:
+        run_line = f"none written — the running *{running}'s own record covers this time"
 
     if not ok:
         print(f"# Miss NOT recorded — {app}")
@@ -189,6 +214,7 @@ def main(argv):
     print(f"Docs       : {doc_line}; docs/{app}-Misses.md rewritten")
     if fix_line:
         print(f"Fix        : {fix_line}")
+    print(f"Run record : {run_line}")
     print(f"Next       : *fix-issues {app}" + (f" {req}" if req and not fixed else ""))
     return 0