@techierathore/techieflow 1.0.4 → 1.1.1

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]
@@ -966,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:
@@ -987,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 {}
@@ -1005,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()
@@ -1054,20 +1128,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 +1168,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 +1185,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):
@@ -1407,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
@@ -1418,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"},
@@ -1431,6 +1512,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`).
@@ -1461,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
@@ -1588,7 +1676,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

@@ -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]
 #
@@ -15,18 +16,25 @@
 #
 # 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.
+# --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 ;;
@@ -37,14 +45,21 @@ 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
-[[ -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'
+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):
@@ -71,45 +86,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") 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)
+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") == cmd}
+wrote = had = 0
+for i, (s, e) in enumerate(gaps):
+    first = i == 0
+    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
+    # 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"{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:
+        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"{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
 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"