@techierathore/techieflow 1.0.3 → 1.0.4

package/.tfcore/utils/tf-gitignore-audit.sh

@@ -74,7 +74,7 @@ DRY  = os.environ["TF_DRY"] == "1"
 # ones this audit exists to catch. The file system is the fact.
 STACKS = [
     ("dotnet", (".csproj", ".fsproj", ".vbproj", ".sln", ".slnx"),
-     ["bin/", "obj/", "*.user", "TestResults/"]),
+     ["bin/", "obj/", "*.user", "TestResults/", ".vs/"]),
     ("node",   ("package.json",),        ["dist/", "build/", ".next/", ".nuxt/", ".turbo/"]),
     ("python", ("pyproject.toml", "setup.py", "requirements.txt"),
      ["__pycache__/", "*.py[cod]", ".venv/", "venv/", ".pytest_cache/", "*.egg-info/"]),
@@ -83,6 +83,14 @@ STACKS = [
     ("java",   ("pom.xml", "build.gradle", "build.gradle.kts"), ["target/", "build/", ".gradle/"]),
 ]
 
+# Per-developer IDE state, wanted whatever the stack is. It is not build output, but it is
+# the same harm and this tool is the only thing looking: TfLens tracked three .bin files
+# under .vs/ProjectEvaluation/, one carrying 246 absolute paths out of one developer's
+# machine, while the audit ran on that repo every week and said nothing. `.vscode/` is NOT
+# here -- a team often commits it deliberately, and a rule that fights the owner gets
+# switched off. tests/regression/run.sh tf_014.
+IDE_STATE = [".vs/", ".idea/"]
+
 # `package.json` alone does NOT make a repo a Node project, and this exception is
 # load-bearing rather than fussy: verify-phase §1 runs `npm init -y` in EVERY repo
 # to provision Playwright, so a bare package.json sits in essentially every .NET
@@ -114,14 +122,19 @@ def _is_real_node(root, files):
     # `npm init -y` writes exactly one script: a `test` stub that echoes and exits 1.
     return any(k in scripts for k in ("build", "dist", "bundle", "compile"))
 
+# A NAME list, never a blanket dot-rule. `not d.startswith(".")` used to prune every
+# dot-directory from the walk -- .vs/, .idea/, .gradle/, .terraform/, .pytest_cache/ --
+# which is close to a complete list of the per-developer state a gitignore audit is FOR.
+# The tool cannot report a folder it never visits, and its silence read exactly like a pass.
 SKIP_DIRS = {".git", "node_modules", ".tfcore", "bin", "obj", "target", "dist",
-             "build", ".venv", "venv", "__pycache__", ".next"}
+             "build", ".venv", "venv", "__pycache__", ".next", ".claude", ".opencode",
+             ".vscode", ".github", ".husky", ".yarn"}
 
 
 def detect():
     found = set()
     for root, dirs, files in os.walk(REPO):
-        dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith(".")]
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
         if root.count(os.sep) - REPO.count(os.sep) > 3:
             dirs[:] = []
         for name, markers, _ in STACKS:
@@ -154,6 +167,24 @@ def covered(rule, lines):
     return False
 
 
+def child_only_rules(rule, lines):
+    """Rules that ignore something INSIDE `rule` while `rule` itself stays open.
+
+    This shape is more dangerous than no rule at all, because it looks deliberate:
+    TfLens carried `/.vs/App.slnx`, which covers the solution-named subfolder and
+    leaves `.vs/ProjectEvaluation/` tracked. The next folder the IDE creates is not
+    covered either, and nobody re-reads a line that already mentions the directory."""
+    core = rule.strip("/*").rstrip("/")
+    out = []
+    for l in lines:
+        if not l or l.startswith("#"):
+            continue
+        c = l.lstrip("!").strip().replace("**/", "").strip("/")
+        if c != core and (c.startswith(core + "/") or c.startswith(core + "\\")):
+            out.append(l.strip())
+    return out
+
+
 def tracked_paths():
     """Read .git/index directly. Returns the set of tracked paths, or None when the
     index cannot be read (a bare repo, a worktree file, a version we do not know) —
@@ -210,8 +241,18 @@ wanted = []
 for name, _, rules in STACKS:
     if name in stacks:
         wanted += [(name, r) for r in rules]
+if stacks:
+    wanted += [("ide", r) for r in IDE_STATE if not any(r == w for _n, w in wanted)]
 
 missing = [(s, r) for s, r in wanted if not covered(r, lines)]
+# A rule naming a child of a directory that is itself unignored: report it separately,
+# because "MISSING .vs/" reads like nobody thought about it when in fact somebody did
+# and got it half right, which is the harder thing to spot in a review.
+half_done = []
+for _s, r in missing:
+    kids = child_only_rules(r, lines)
+    if kids:
+        half_done.append((r, kids))
 
 tracked = tracked_paths()
 offenders = {}
@@ -244,6 +285,12 @@ else:
         print("    ⚠ MISSING build-output rules: %s" % names)
         print("      add them with: bash .tfcore/utils/tf-gitignore-audit.sh . --fix")
 
+for r, kids in half_done:
+    rc |= 1
+    print("    ⚠ %s is not ignored, but %s covers a child of it — the parent is open"
+          % (r, ", ".join(kids)))
+    print("      a rule on a child looks deliberate and leaves every sibling tracked")
+
 if tracked is None:
     print("    tracked-file check skipped (no readable .git/index) — rules alone do not")
     print("    prove build output is untracked; re-run where the index is readable")

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

@@ -2,9 +2,9 @@
 # tf-goal.sh — unattended GOAL runner / supervisor for TechieFlow (rule: .tfcore/tasks/_yolo-mode.md)
 #
 # Runs a goal headless in YOLO mode and keeps it running until the agent itself
-# declares the goal done — surviving the subscription 5-hour / weekly usage
-# limits (sleeps until the stated reset + a buffer, then RESUMES THE SAME
-# SESSION), crashes, and "I stopped early to ask you something" turns.
+# declares the goal done — surviving the subscription 5-hour / weekly usage limits (moves to the
+# next model in the tier's fallback chain, or sleeps until the stated reset + a buffer when there
+# is none, then RESUMES THE SAME SESSION), crashes, and "I stopped early to ask you something".
 #
 #   bash .tfcore/utils/tf-goal.sh [options] <app-dir> "<goal text>"
 #   bash .tfcore/utils/tf-goal.sh [options] <app-dir> @goal.md
@@ -12,6 +12,10 @@
 # Options
 #   --harness claude|opencode   default: claude
 #   --model <id>                claude: --model; opencode: -m
+#   --tier <tier>               which routing tier this run belongs to, for the fallback chain
+#                               (default standard) — .tfcore/routing.yaml `fallbacks:`
+#   --no-fallback               never switch model on a usage limit; sleep until the reset instead
+#                               (the behaviour before 2026-09-10)
 #   --buffer-min <n>            minutes added after a stated limit-reset time (default 15)
 #   --probe-min <n>             limit hit but NO reset time parseable → fire a one-turn probe every n
 #                               minutes until the API answers again, then resume (default 15)
@@ -41,6 +45,14 @@
 #   goal.log         everything the harness printed, all cycles, timestamped
 #   goal-done.json   the agent's completion sentinel (tf-yolo.sh done [complete|blocked])
 #
+# WHEN A MODEL RUNS OUT (added 2026-09-10, MISS-TechieFlow-20260910-01). A usage limit used to mean
+# one thing: sleep until the reset. It now means: park that model in the per-machine cooldown file
+# (tf-model-pick.sh), ask the tier for the next model in its `fallbacks:` chain, re-bind so the
+# sub-agents move too, and start the next cycle straight away on that model. Only when the whole
+# chain is parked does the supervisor sleep, exactly as before. If the fallback is limited as well
+# the next cycle parks that one too, so an account-wide limit — every Claude model at once — costs
+# one wasted cycle and then behaves as it always did. `--no-fallback` turns all of it off.
+#
 # How the agent is told to finish: the prompt preamble (below) instructs it to run
 # `bash .tfcore/utils/tf-yolo.sh done complete "<summary>"` when the goal is met,
 # or `... done blocked "<why>"` when only the owner can unblock it. A cycle that
@@ -59,11 +71,14 @@ set -u
 
 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
+TIER="standard"; FALLBACK=1
 RESUME=0; FRESH=0; DRY=0
 while [[ $# -gt 0 ]]; do
   case "$1" in
     --harness) HARNESS="$2"; shift 2 ;;
     --model) MODEL="$2"; shift 2 ;;
+    --tier) TIER="$2"; shift 2 ;;
+    --no-fallback) FALLBACK=0; shift ;;
     --buffer-min) BUFFER_MIN="$2"; shift 2 ;;
     --default-wait-min) DEFAULT_WAIT_MIN="$2"; shift 2 ;;
     --probe-min) PROBE_MIN="$2"; shift 2 ;;
@@ -74,7 +89,7 @@ while [[ $# -gt 0 ]]; do
     --resume) RESUME=1; shift ;;
     --fresh) FRESH=1; shift ;;
     --dry-run) DRY=1; shift ;;
-    -h|--help) sed -n '2,45p' "$0"; exit 0 ;;
+    -h|--help) sed -n '2,48p' "$0"; exit 0 ;;
     --) shift; break ;;
     -*) echo "unknown option $1" >&2; exit 2 ;;
     *) break ;;
@@ -88,11 +103,15 @@ fi
 APP_DIR="$(cd "$APP_DIR" 2>/dev/null && pwd)" || { echo "no such dir: $1" >&2; exit 2; }
 [[ -d "$APP_DIR/.tfcore" ]] || { echo "$APP_DIR has no .tfcore/ — scaffold it first" >&2; exit 2; }
 case "$HARNESS" in claude|opencode) ;; *) echo "--harness must be claude|opencode" >&2; exit 2 ;; esac
+case "$TIER" in frontier|standard|economy) ;; *) echo "--tier must be frontier|standard|economy" >&2; exit 2 ;; esac
 command -v python3 >/dev/null 2>&1 || { echo "python3 is required" >&2; exit 2; }
 
 STATE_DIR="$APP_DIR/.tfcore/.session"; mkdir -p "$STATE_DIR"
 STATE="$STATE_DIR/goal.json"; LOG="$STATE_DIR/goal.log"; DONE="$STATE_DIR/goal-done.json"
 YOLO_SH="$APP_DIR/.tfcore/utils/tf-yolo.sh"
+PICK_SH="$APP_DIR/.tfcore/utils/tf-model-pick.sh"
+BIND_SH="$APP_DIR/.tfcore/utils/tf-routing-bind.sh"
+[[ -f "$PICK_SH" ]] || FALLBACK=0   # a project that predates tf-model-pick.sh keeps the old behaviour
 
 if [[ "$GOAL_ARG" == @* ]]; then
   GOAL_FILE="${GOAL_ARG#@}"; [[ -f "$GOAL_FILE" ]] || { echo "goal file not found: $GOAL_FILE" >&2; exit 2; }
@@ -126,6 +145,10 @@ if [[ $RESUME -eq 1 ]]; then
   [[ -f "$STATE" ]] || { echo "--resume: no $STATE" >&2; exit 2; }
   [[ -z "$GOAL" ]] && GOAL="$(state_get goal)"
   HARNESS="$(state_get harness)"; HARNESS="${HARNESS:-claude}"
+  # A resume keeps the model a fallback moved to, and the tier its chain came from; an explicit
+  # --model on the resume command still wins.
+  _t="$(state_get tier)"; [[ -n "$_t" ]] && TIER="$_t"
+  _m="$(state_get model)"; [[ -n "$_m" && -z "$MODEL" ]] && MODEL="$_m"
   CYCLE="$(state_get cycle)"; CYCLE="${CYCLE:-0}"
   SESSION_ID="$(state_get session_id)"
   STALLS="$(state_get stalls)"; STALLS="${STALLS:-0}"
@@ -144,7 +167,7 @@ else
   fi
   CYCLE=0; SESSION_ID=""; STALLS=0
   if [[ $DRY -eq 0 ]]; then   # a dry run touches nothing: no state, no flag, no log line
-    state_set goal "$GOAL" harness "$HARNESS" cycle 0 session_id "" stalls 0 started "$(ts)" last_reason "start"
+    state_set goal "$GOAL" harness "$HARNESS" tier "$TIER" model "$MODEL" cycle 0 session_id "" stalls 0 started "$(ts)" last_reason "start"
     rm -f "$DONE"
   fi
 fi
@@ -346,6 +369,60 @@ print(sid)
 PY
 }
 
+extract_model() { # the model the harness reported for this cycle, from its own output
+  python3 - "$1" <<'PY' 2>/dev/null
+import sys, json, re
+m = ""
+try:
+    for line in open(sys.argv[1], errors="replace"):
+        line = line.strip()
+        if not line.startswith("{") or '"model"' not in line:
+            continue
+        try: d = json.loads(line)
+        except Exception: continue
+        if not isinstance(d, dict): continue
+        if isinstance(d.get("model"), str) and d["model"]:
+            m = d["model"]
+        msg = d.get("message")
+        if isinstance(msg, dict) and isinstance(msg.get("model"), str) and msg["model"]:
+            m = msg["model"]
+except Exception:
+    pass
+print(m)
+PY
+}
+
+# Park the model this cycle ran on and move to the next one in its tier. Prints nothing and
+# returns 1 when there is nowhere to go — the caller then sleeps, which is what it always did.
+#   $1 = epoch the limit is stated to reset at (or empty when it could not be parsed)
+#   $2 = why, for the cooldown record
+try_fallback() {
+  [[ $FALLBACK -eq 1 ]] || return 1
+  local until="${1:-}" why="${2:-usage limit}" cur next
+  cur="$MODEL"
+  [[ -z "$cur" ]] && cur="$(extract_model "$OUT")"
+  if [[ -z "$cur" ]]; then
+    cur="$(TF_PROJECT_DIR="$APP_DIR" bash "$PICK_SH" pick "$TIER" "$HARNESS" 2>/dev/null | tail -1)"
+    [[ "$cur" == inherit ]] && cur=""
+  fi
+  if [[ -z "$cur" ]]; then
+    log "no fallback: nothing here says which model this cycle ran on (no --model, no model id in the output, no routing answer for tier $TIER)"
+    return 1
+  fi
+  [[ -z "$until" ]] && until="probe"
+  TF_PROJECT_DIR="$APP_DIR" bash "$PICK_SH" cooldown "$HARNESS" "$cur" "$until" "$why" >>"$LOG" 2>&1
+  next="$(TF_PROJECT_DIR="$APP_DIR" bash "$PICK_SH" pick "$TIER" "$HARNESS" 2>/dev/null | tail -1)"
+  if [[ -z "$next" || "$next" == "inherit" ]]; then
+    log "no fallback left: every model in the $TIER chain is on cooldown — waiting for the reset instead"
+    return 1
+  fi
+  MODEL="$next"
+  state_set model "$MODEL" fallback_from "$cur" last_reason "fallback:$cur->$MODEL"
+  log "FALLBACK: $cur is limited ($why) — the next cycle runs on $MODEL (tier $TIER). Re-binding so the sub-agents move too."
+  [[ -f "$BIND_SH" ]] && bash "$BIND_SH" "$APP_DIR" 2>&1 | sed 's/^/    /' | tee -a "$LOG" >&2
+  return 0
+}
+
 # Fallback when a limit message carries no parseable reset time: fire a one-turn
 # probe every PROBE_MIN minutes until it comes back clean (exit 0 AND no limit
 # wording in its output). Gives up after PROBE_MAX_H hours and resumes anyway.
@@ -507,7 +584,14 @@ while :; do
     CLASS=IDLE; DETAIL="stalled ${STALL_MIN}m"; HOW=""
     PERR="$(opencode_log_error "$CYCLE_START")"
     if [[ -n "$PERR" ]] && grep -qiE "usage limit|monthly|balance|quota|rate limit|429|insufficient|billing|unauthorized|api key" <<<"$PERR"; then
-      log "the provider refused the model while the harness printed nothing (cycle $CYCLE): $PERR — the owner must act (enable balance, wait for the reset, or pick another model); stopping"
+      log "the provider refused the model while the harness printed nothing (cycle $CYCLE): $PERR"
+      # A monthly limit or an empty balance states no reset time, so the model is parked for the
+      # probe window and the run continues on the next model in the tier. Only when the chain is
+      # exhausted does this stay what it was before 2026-09-10: the owner's problem, exit 5.
+      if try_fallback "" "provider refused the model: ${PERR:0:120}"; then
+        STALLS=0; state_set stalls 0; BACKOFF=120; continue
+      fi
+      log "no other model in the $TIER chain is available — the owner must act (enable balance, wait for the reset, or pick another model); stopping"
       state_set last_reason "provider-limit" ended "$(ts)"
       exit 5
     fi
@@ -525,6 +609,9 @@ while :; do
   fi
   case "$CLASS" in
     LIMIT)
+      # Another model in the same tier beats waiting, when there is one.
+      if [[ "$HOW" == probe ]]; then _FB_UNTIL=""; else _FB_UNTIL="$DETAIL"; fi
+      if try_fallback "$_FB_UNTIL" "usage limit"; then BACKOFF=120; continue; fi
       if [[ "$HOW" == probe ]]; then
         log "USAGE LIMIT hit (cycle $CYCLE) but no reset time could be parsed from the message — probing every ${PROBE_MIN}m until the API answers again (max ${PROBE_MAX_H}h). Tail of the message:"
         tail -c 400 "$OUT" | tr '\n' ' ' | sed 's/^/    /' | tee -a "$LOG" >&2; echo >&2

package/.tfcore/utils/tf-misses-md.py

@@ -1,14 +1,16 @@
 #!/usr/bin/env python3
 """tf-misses-md.py — the readable miss list, docs/<App>-Misses.md (Session 5, 2026-09-07; FR-31).
 
-    python3 .tfcore/utils/tf-misses-md.py [--root <repo>] [--app <App>] [--no-html] [--quiet]
+    python3 .tfcore/utils/tf-misses-md.py [--root <repo>] [--app <App>] [--quiet]
 
 Rebuilds docs/<App>-Misses.md from docs/metrics/misses.jsonl: one row per `miss` record, newest first,
 in three tables (open, fixed, will not fix), each row holding the miss id, the owning row, when and
 by whom it was found, whose gap it was (the `sort` field, folded from any miss-amend) and the `what`
-sentence. Then renders the sibling HTML through tf-render-html.py. tf-emit.sh calls this after every
-write to the misses stream, so the file is never older than the record; run it by hand once on a
-project whose stream predates it. The file is derived: never edit it, edit nothing, log a miss.
+sentence. Markdown only — there is no HTML sibling: the miss log is read by agents and by the owner
+in markdown, and tf-render-html.py refuses it (owner, 2026-09-08; an HTML copy nobody opened was
+being re-rendered on every miss in every project). tf-emit.sh calls this after every write to the
+misses stream, so the file is never older than the record; run it by hand once on a project whose
+stream predates it. The file is derived: never edit it, edit nothing, log a miss.
 Exit 0 always (telemetry has no veto); the reason for a skipped write is printed unless --quiet.
 """
 import datetime
@@ -16,7 +18,6 @@ import glob
 import json
 import os
 import re
-import subprocess
 import sys
 
 HERE = os.path.dirname(os.path.abspath(__file__))
@@ -183,24 +184,20 @@ def main(argv):
                 old = fh.read()
         except FileNotFoundError:
             pass
+        stale = out[:-3] + ".html"                 # left by a pre-2026-09-08 run, before the miss
+        gone = ""                                  # log was ruled an agent document (owner)
+        if os.path.isfile(stale):
+            os.remove(stale)
+            gone = "; removed the stale HTML copy"
         same = lambda s: re.sub(r"\| Updated \| [0-9-]+ \|", "", s)   # everything but the date must match
-        if old is not None and same(old) == same(text) and os.path.isfile(out[:-3] + ".html"):
+        if old is not None and same(old) == same(text):
             if not quiet:
-                print(f"tf-misses-md: {rel} unchanged ({n} misses)")
+                print(f"tf-misses-md: {rel} unchanged ({n} misses){gone}")
             return 0
         with open(out, "w", encoding="utf-8", newline="\n") as fh:
             fh.write(text)
-        html = "skipped"
-        if "--no-html" not in argv:
-            r = os.path.join(HERE, "tf-render-html.py")
-            if os.path.isfile(r):
-                try:
-                    p = subprocess.run([sys.executable, r, out, "--quiet"], capture_output=True, text=True, timeout=120)
-                    html = "rendered" if p.returncode == 0 else "not rendered (" + (p.stderr or p.stdout).strip().splitlines()[-1:][0][:100] + ")" if (p.stderr or p.stdout).strip() else "not rendered"
-                except Exception as e:
-                    html = f"not rendered ({e})"
         if not quiet:
-            print(f"tf-misses-md: wrote {rel} ({n} misses); HTML {html}")
+            print(f"tf-misses-md: wrote {rel} ({n} misses){gone}")
     except Exception as e:
         if not quiet:
             print(f"tf-misses-md: nothing written ({e})")

package/.tfcore/utils/tf-misses-md.sh

@@ -1,9 +1,10 @@
 #!/usr/bin/env bash
-# tf-misses-md.sh — rebuild the readable miss list docs/<App>-Misses.md and its HTML from the
-# misses stream (Session 5, 2026-09-07; FR-31). tf-emit.sh runs it after every write to that
-# stream; run it by hand once on a project whose stream is older than this script.
+# tf-misses-md.sh — rebuild the readable miss list docs/<App>-Misses.md from the misses
+# stream (Session 5, 2026-09-07; FR-31). Markdown only: the miss log is never rendered to
+# HTML. tf-emit.sh runs it after every write to that stream; run it by hand once on a
+# project whose stream is older than this script.
 #
-#   bash .tfcore/utils/tf-misses-md.sh [--root <repo>] [--app <App>] [--no-html] [--quiet]
+#   bash .tfcore/utils/tf-misses-md.sh [--root <repo>] [--app <App>] [--quiet]
 #
 # Exit 0 always. Details: tf-misses-md.py.
 set -u