@techierathore/techieflow 1.1.0 → 1.2.0

package/.tfcore/utils/tf_feedback.py

@@ -39,9 +39,34 @@ EVERYTHING = re.compile(r"(?i)\beverything else is (?:now )?fixed\b|\ball (?:the
 CLOSED = re.compile(r"(?i)(✅|\bclosed (?:on )?\d{4}-\d{2}-\d{2}|is \*\*closed\*\*|\bwill not fix\b|\bwont-fix\b)")
 MERGED = re.compile(r"(?i)^\s*merged into\b")
 FIXED_IN_BODY = re.compile(r"(?i)\bfixed upstream\b")
+STILL_OPEN = re.compile(r"(?i)\bopen\b|\bnot (?:yet )?(?:fixed|resolved)\b|\bunfixed\b")
 BLOCKS = re.compile(r"(?im)^\s*[-*]\s*\*\*Blocks:?\*\*:?\s*(yes|no)\b")
 
 
+def ids_in(t):
+    """Every id the text names, shorthand included: "TR-RAG-028/029/030" and "TR-RAG-031..034"
+    (or "031–034") name each id they cover, not only the first."""
+    out = []
+    for m in re.finditer(r"(?<![\w-])([A-Z][A-Z0-9]*(?:-[A-Z]+)*)-(\d{2,})(?!\d)((?:/\d{2,})+|(?:\.\.|…|–|—)\d{2,})?", t):
+        pre, n, tail = m.group(1), m.group(2), m.group(3) or ""
+        out.append(f"{pre}-{n}")
+        w = len(n)
+        if tail.startswith("/"):
+            out += [f"{pre}-{x.zfill(w)}" for x in tail.strip("/").split("/")]
+        elif tail:
+            hi = int(re.sub(r"^\D+", "", tail))
+            if int(n) < hi <= int(n) + 50:
+                out += [f"{pre}-{str(x).zfill(w)}" for x in range(int(n) + 1, hi + 1)]
+    return out
+
+
+def unquoted(t):
+    """The text without fenced code, inline code and double-quoted phrases."""
+    t = re.sub(r"(?ms)^[ \t]*```.*?^[ \t]*```", "", t)
+    t = re.sub(r"`[^`\n]*`", "", t)
+    return re.sub(r"[\"“][^\"”\n]*[\"”]", "", t)
+
+
 def entries(path):
     """-> [{id, title, state, since, blocks, start, end}] in file order."""
     text = open(path, encoding="utf-8", errors="replace").read()
@@ -51,9 +76,12 @@ def entries(path):
         end = heads[i + 1].start() if i + 1 < len(heads) else len(text)
         nxt = re.search(r"(?m)^#{1,%d}\s" % len(m.group(1)), text[m.end():end])
         body = text[m.end(): m.end() + nxt.start()] if nxt else text[m.end():end]
-        head = body[:2500]
-        state = ("closed" if CLOSED.search(head) or MERGED.search(m.group(3))
-                 else "fixed" if FIXED_IN_BODY.search(head) else "open")
+        # quoted or code text is somebody's words, not a mark: `fixed upstream` in a repro, a test name
+        head = unquoted(body[:2500])
+        title = unquoted(m.group(3))
+        # the mark is read in the heading as well (TechieRag TF-001: "— **fixed upstream 2026-10-03**")
+        state = ("closed" if CLOSED.search(head) or CLOSED.search(title) or MERGED.search(m.group(3))
+                 else "fixed" if FIXED_IN_BODY.search(head) or FIXED_IN_BODY.search(title) else "open")
         b = BLOCKS.search(body)
         out.setdefault(m.group(2), {"id": m.group(2), "title": m.group(3).strip(" `"), "state": state,
                                     "since": "", "blocks": b.group(1).lower() if b else "",
@@ -73,18 +101,33 @@ def reply_blocks(text):
     "## Resolution status (TechieFlow team, 2026-09-09)", "## Replies from …", or a quoted
     "> ## ✅ RESOLVED LIBRARY-SIDE 2026-08-31" — and runs to the next heading of its level,
     or, when quoted, to the end of the quote."""
-    out = []
+    out, seen = [], set()
+    date_of = lambda h: (re.search(r"\d{4}-\d{2}-\d{2}", h) or [""])[0]
     for m in REPLY_HEAD.finditer(text):
+        if m.start() in seen:
+            continue
         rest = text[m.end():]
         if m.group(1):   # quoted: the block is the run of '>' lines after the heading's own line
             rest = rest[1:] if rest.startswith("\n") else rest
             q = re.match(r"(?:[ \t]*>[^\n]*\n?)*", rest)
-            body = re.sub(r"(?m)^[ \t]*>[ \t]?", "", q.group(0))
+            out.append((date_of(m.group(0)), re.sub(r"(?m)^[ \t]*>[ \t]?", "", q.group(0))))
+            continue
+        level = len(re.match(r"[ \t]*(#+)", m.group(0)).group(1))
+        nxt = re.search(r"(?m)^#{1,%d}\s" % level, rest)
+        section = rest[: nxt.start()] if nxt else rest
+        if level == 2:
+            # A "## Replies from …" section holds dated "### " blocks, written months apart. Each is its
+            # own reply: an "all others fixed" kept in an old one must not reach entries a newer block
+            # merely names (TechieRag TF-001: Sevak's TR-RAG-047 read fixed when TR-RAG-048 was replied to).
+            subs = list(re.finditer(r"(?m)^###[ \t]+[^\n]*", section))
+            out.append((date_of(m.group(0)), section[: subs[0].start()] if subs else section))
+            for j, sm in enumerate(subs):
+                end = subs[j + 1].start() if j + 1 < len(subs) else len(section)
+                seen.add(m.end() + sm.start())
+                # the heading line stays in: "### TF-025 — fixed 2026-09-19" names the entry it answers
+                out.append((date_of(sm.group(0)) or date_of(m.group(0)), section[sm.start(): end]))
         else:
-            nxt = re.search(r"(?m)^##\s", rest)
-            body = rest[: nxt.start()] if nxt else rest
-        d = re.search(r"\d{4}-\d{2}-\d{2}", m.group(0))
-        out.append((d.group(0) if d else "", body))
+            out.append((date_of(m.group(0)), section))
     return out
 
 
@@ -98,24 +141,44 @@ def replied_fixed(text, known):
         items = re.split(r"\n\s*\n|\n(?=\s*[-*]\s)|\n(?=\s*\|)", body)
         mentioned = []
         for it in items:
-            ids = ANY_ID.findall(it)
+            ids = ids_in(it)
             mentioned += ids
             if not ids:
                 continue
             if it.lstrip().startswith("|"):
-                first = ANY_ID.findall(it.split("|")[1] if it.count("|") > 1 else "")
+                first = ids_in(it.split("|")[1] if it.count("|") > 1 else "")
                 out += [(i, date) for i in first]
-            elif FIXED_WORDS.search(it):
-                out += [(i, date) for i in ids]
+            elif FIXED_WORDS.search(unquoted(it)) and not EVERYTHING.search(unquoted(it)):
+                # "Open: TR-RAG-001, TR-RAG-002. All others fixed": the ids are the exceptions.
+                # Read clause by clause: "1 OPEN: TR-RAG-001 …; 2 FIXED: TR-RAG-005 …" fixes 005 only,
+                # and "TR-RAG-035 (minor, OPEN)" beside "TR-RAG-034 (minor, FIXED)" stays open.
+                # A "fixed" clause naming no id answers the clause before it: "TR-RAG-010: every
+                # assembly carries its version. Fixed in 1.1.2." And "TR-RAG-017/019 → BRD-126 (fixed);
+                # TR-RAG-020…022 → BRD-127" fixes 017 and 019 only.
+                prev = []
+                for cl in re.split(r"(?<=[.;])\s+|\s+·\s+", it):
+                    own_ids = ids_in(cl)
+                    bare = unquoted(cl)
+                    if FIXED_WORDS.search(bare) and not STILL_OPEN.search(bare):
+                        out += [(i, date) for i in (own_ids or prev)]
+                    if own_ids:
+                        prev = [] if STILL_OPEN.search(bare) else own_ids
         for it in items:
-            if EVERYTHING.search(it) and mentioned:
+            # a quoted or code "all others fixed" is somebody's words being cited, not this reply's
+            # claim: "…only because of the July "All others fixed app-side" line" fixed 13 entries the
+            # same block listed as still open (TechieRag TF-002)
+            if EVERYTHING.search(unquoted(it)) and mentioned:
+                # bounded by the ids of its own item, which it never covers ("all others"); an item
+                # naming none takes the block's. A running log in one block once let a July "all
+                # others fixed" reach every entry its later lines named (TechieRag TF-001).
+                own = ids_in(it)
                 top = {}
-                for i in mentioned:
+                for i in own or mentioned:
                     p, n = i.rsplit("-", 1)
                     top[p] = max(top.get(p, 0), int(n))
                 for k in known:
                     p, n = k.rsplit("-", 1)
-                    if p in top and int(n) <= top[p]:
+                    if p in top and int(n) <= top[p] and k not in own:
                         out.append((k, date))
     return out
 
@@ -132,12 +195,17 @@ def upstream_of(path, app=None):
 
 
 def state_map(root):
-    """Every entry id across the project's feedback files -> (state, "<file>, <date>")."""
+    """Every entry id across the project's feedback files -> [(state, "<file>, <date>", names)], one
+    item per file holding it. Every consumer numbers its own entries from 1, so a library with nine
+    consumer files can hold nine TR-002s (TrBlazeUI TF-006); `names` are the two project names in the
+    file's name (Lekhak and TrBlazeUI in Lekhak-TrBlazeUI-Feedback.md), which a line names to say whose."""
     out = {}
     for f in files(root):
         rel = os.path.relpath(f, root).replace(os.sep, "/")
+        names = tuple(os.path.basename(f)[: -len("-Feedback.md")].split("-"))
         for e in entries(f):
-            out[e["id"]] = (e["state"], f"{rel}" + (f", Resolution status {e['since']}" if e["since"] else ""))
+            out.setdefault(e["id"], []).append(
+                (e["state"], f"{rel}" + (f", Resolution status {e['since']}" if e["since"] else ""), names))
     return out
 
 

package/.tfcore/utils/tf_stack_check.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""tf_stack_check.py — does the code use the packages the Architecture requires? (2026-10-08)
+
+    bash .tfcore/utils/tf-stack-check.sh <App> [--json-out <file>]
+
+Reads the `Required packages:` line of docs/<App>-Architecture.md (Stack decisions), which copies the
+answer set's own line: each package in backticks, or "none". Then looks for each package in the
+project's dependency files, whatever the stack: .csproj/.fsproj/.vbproj, Directory.*.props,
+packages.config, package.json, requirements*.txt, pyproject.toml, Pipfile, go.mod, Cargo.toml, Gemfile,
+pom.xml, build.gradle(.kts), composer.json, pubspec.yaml. Build output, dependencies, tests/.artifacts
+and the framework itself are not searched.
+
+Why: in the first *develop-end-to-end proof on OpenCode the model searched for a package by the wrong
+name, decided the mandated UI library was not published, built the screen with plain components and
+had every row Verified. Nothing checked that the code used what the Stack decisions named.
+
+Prints PASS (every package referenced), FAIL (with the packages missing), or NONE (no line, or
+"none"). tf-verify-verdict.py runs it itself and fails every row's build check on FAIL.
+Exit 0 PASS or NONE · 1 FAIL · 2 could not run. Python 3 standard library only.
+"""
+import json
+import os
+import re
+import sys
+
+PRUNE = {"bin", "obj", "node_modules", ".git", ".artifacts", ".tfcore", ".claude", ".opencode", "dist",
+         "packages", "TestResults", ".venv", "venv", "target", "vendor", "OldDocs"}
+NAMES = re.compile(r"(?i)^(?:.*\.(?:cs|fs|vb)proj|directory\.(?:packages|build)\.props|packages\.config|package\.json|"
+                   r"requirements[\w.-]*\.txt|pyproject\.toml|pipfile|go\.mod|cargo\.toml|gemfile|pom\.xml|"
+                   r"build\.gradle(?:\.kts)?|composer\.json|pubspec\.yaml)$")
+
+
+def required(root, app):
+    """-> (list of packages, the Architecture path) ; [] when there is no line or it says none."""
+    p = os.path.join(root, "docs", f"{app}-Architecture.md")
+    if not os.path.isfile(p):
+        return [], p
+    for line in open(p, encoding="utf-8", errors="replace"):
+        m = re.match(r"\s*(?:[-*]\s*)?\**Required packages:?\**:?\s*(.*)$", line, re.I)
+        if m:
+            return re.findall(r"`([^`\s]+)`", m.group(1)), p
+    return [], p
+
+
+def manifests(root):
+    for d, dirs, files in os.walk(root):
+        dirs[:] = [x for x in dirs if x not in PRUNE and not x.startswith(".")]
+        for f in files:
+            if NAMES.match(f):
+                yield os.path.join(d, f)
+
+
+def check(root, app):
+    pkgs, arch = required(root, app)
+    if not pkgs:
+        return {"verdict": "NONE", "architecture": os.path.relpath(arch, root), "required": [], "missing": [], "found": {}}
+    found = {}
+    files = list(manifests(root))
+    for f in files:
+        try:
+            text = open(f, encoding="utf-8", errors="replace").read()
+        except OSError:
+            continue
+        for pk in pkgs:
+            if re.search(r"(?<![A-Za-z0-9._-])%s(?![A-Za-z0-9._-])" % re.escape(pk), text, re.I):
+                found.setdefault(pk, os.path.relpath(f, root))
+    missing = [pk for pk in pkgs if pk not in found]
+    return {"verdict": "FAIL" if missing else "PASS", "architecture": os.path.relpath(arch, root),
+            "required": pkgs, "missing": missing, "found": found, "files_searched": len(files)}
+
+
+def main(argv):
+    if len(argv) < 2 or argv[1] in ("-h", "--help"):
+        print(__doc__)
+        return 0 if len(argv) >= 2 else 2
+    app = argv[1]
+    r = check(os.getcwd(), app)
+    if "--json-out" in argv:
+        out = argv[argv.index("--json-out") + 1]
+        os.makedirs(os.path.dirname(out) or ".", exist_ok=True)
+        json.dump(r, open(out, "w"), indent=1)
+    if r["verdict"] == "NONE":
+        print(f"NONE {app}: {r['architecture']} lists no required packages")
+    elif r["verdict"] == "PASS":
+        print(f"PASS {app}: " + ", ".join(f"{k} in {v}" for k, v in r["found"].items()))
+    else:
+        print(f"FAIL {app}: the Architecture requires {', '.join(r['missing'])}; no project file references "
+              + ("it" if len(r["missing"]) == 1 else "them") + f" ({r['files_searched']} searched). Add the package; never replace it with a workaround")
+    return 1 if r["verdict"] == "FAIL" else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/README.md

@@ -86,7 +86,7 @@ flowchart TD
 
 **An existing application** is the same after day-1: `*day1-brownfield` reads the code, writes the same documents plus the DevGuide, and migrates any existing plan into the one checklist.
 
-**Which command next?** Pick by the weakest open row: anything unbuilt means `*build-phase`; all built but not verified means `*verify all`; all verified means `*handoff-phase`. When in doubt, build. If a session died mid-phase, the status file is stale — run `*refresh-status {App}` first, which rebuilds it from the checklist, the working tree and a fresh build.
+**Which command next?** Pick by the weakest open row: anything unbuilt means `*build-phase`; all built but not verified means `*verify all`; all verified means `*handoff-phase`. When in doubt, build. A project in phases verifies one phase at a time: `*verify all {App} --phase 1` grades phase 1's checklist, and `--phase all` grades every phase in turn. Without `--phase` it grades the phase in progress. PROJECT-STATUS prints the exact line to paste. If a session died mid-phase, the status file is stale — run `*refresh-status {App}` first, which rebuilds it from the checklist, the working tree and a fresh build.
 
 **Running unattended.** Do not start a long run as a bare harness command. The supervisor survives a usage limit, a crash and an agent that stops early:
 
@@ -110,7 +110,7 @@ Replace `{App}` with your application name. Claude Code takes the long persona p
 | A change to an existing project | `… analyst *amend-docs {App} "<what changed>"` | `/flow-analyst *amend-docs {App} "…"` |
 | Brainstorm, brief, research | `… analyst *brainstorm {topic}` · `*create-project-brief` · `*research-prompt {topic}` | same, on `/flow-analyst` |
 | Build everything open | `/TechieFlow:agents:flow-master *build-phase {App}` | `/flow-master *build-phase {App}` |
-| Verify | `/TechieFlow:agents:verifier *verify ui\|functional\|all` | `/flow-verifier *verify all` |
+| Verify | `/TechieFlow:agents:verifier *verify ui\|functional\|all {App} [--phase N\|all]` | `/flow-verifier *verify all {App} [--phase N\|all]` |
 | Bugs: log and analyse only | `… flow-master *triage-issues {App} {evidence} [verify]` | `/flow-master *triage-issues …` |
 | Bugs: fix them | `… flow-master *fix-issues {App} {folder}` | `/flow-master *fix-issues …` |
 | Bugs: the whole sequence unattended | `… flow-master *triage-and-fix {App} {evidence}` | `/flow-master *triage-and-fix …` |

package/opencode.jsonc

@@ -589,7 +589,7 @@
           "sudo *": "ask"
         }
       },
-      "description": "Vidur — autonomous verification (*verify ui|functional|all); writes verdicts into the checklist Requirements Status tables"
+      "description": "Vidur — autonomous verification (*verify ui|functional|all [--phase N|all]); writes verdicts into the checklist Requirements Status tables"
     },
     "trblazeui": {
       "prompt": "You are the TrBlazeUI sub-agent. Read `.opencode/command/trblazeui.md` (fall back, in order, to `.claude/commands/trblazeui.md`, `.claude/trblazeui.md`, `.trblazeui/TrBlazeUI-AI-Reference.md`) and fully adopt that persona and its operating guidelines — it is the authoritative persona. NuGet credentials are user-level (Windows native `%AppData%\\NuGet\\NuGet.Config`, macOS/Linux `$HOME/.nuget/NuGet/NuGet.Config`, Docker `/root/.nuget/NuGet/NuGet.Config` from `%USERPROFILE%\\.opencode-docker\\nuget\\NuGet.Config`); never put a PAT in the repository. In Docker, never assume a Windows config is decryptable and never install `maui-tizen`; verify the mounted config and use the Docker build ladder. If neither file exists (TrBlazeUI NuGet not yet deployed), report the exact source/auth failure instead of blindly running `dotnet build`. Otherwise act as an expert .NET/Blazor developer specializing in the TrBlazeUI component library: build UI screens to match the approved mockups (`docs/{AppName}-UIDesign.md` + `docs/mockups/*.html`), follow `docs/{AppName}-Coding-Standards.md`, tag work with `[REQ-UI-N]` in the checklist Remarks, log TrBlazeUI gaps to `docs/{AppName}-TrBlazeUI-Feedback.md`. Never run git or gh.",
@@ -833,6 +833,10 @@
       "template": "{file:./.tfcore/tasks/split-brd.md}",
       "description": "Split the BRD into the one docs/{App}-Checklist.md (REQ-UI/FN/RAG/NFR-* in a single Requirements Status table)."
     },
+    "techieflow:tasks:develop-end-to-end": {
+      "template": "{file:./.tfcore/tasks/develop-end-to-end.md}",
+      "description": "A new app from a brief to UAT, unattended: Day 1 both stages, build with inline verify and fixes, handoff; tf-develop.sh commits and pushes after each phase and writes the Build Report with time and tokens per phase. Driven by /flow-master."
+    },
     "techieflow:tasks:build-phase": {
       "template": "{file:./.tfcore/tasks/build-phase.md}",
       "description": "The single unified build: implement every open REQ (UI/FN/RAG/NFR) from the one Checklist by clustering and calling /trblazeui (from mockups) + /techierag as sub-agents; self-smoke (data + visual); chain the verifier. Driven by /flow-master."
@@ -855,7 +859,7 @@
     },
     "techieflow:tasks:verify-phase": {
       "template": "{file:./.tfcore/tasks/verify-phase.md}",
-      "description": "Verifies every checklist row in a scope (ui | functional | all | REQ list) against the running app: boots it, runs the seven checks in order through the tf-verify-* scripts, writes the verdicts into the checklist and the telemetry. YOLO by default. Driven by /verifier."
+      "description": "Verifies every checklist row in a scope (ui | functional | all | REQ list) of one phase's checklist, or each phase in turn with --phase all, against the running app: boots it, runs the seven checks in order through the tf-verify-* scripts, writes the verdicts into the checklist and the telemetry. YOLO by default. Driven by /verifier."
     },
     "techieflow:tasks:handoff-phase": {
       "template": "{file:./.tfcore/tasks/handoff-phase.md}",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techierathore/techieflow",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "TechieFlow: a spec-driven development framework for AI coding agents, for Claude Code and OpenCode. One command installs it into any project.",
   "license": "Apache-2.0",
   "repository": {

package/scripts/install.mjs

@@ -313,7 +313,7 @@ const canonicalSettings = String.raw`{
     ],
     "ask": [],
     "deny": [
-      "Bash(rm -rf /)", "Bash(rm -rf /*)", "Bash(rm -rf ~)", "Bash(rm -rf ~/*)",
+      "Bash(rm -rf /)", "Bash(rm -rf ~)",
       "Bash(git commit*)", "Bash(git push*)", "Bash(git add*)", "Bash(git rm*)",
       "Bash(git mv*)", "Bash(git reset*)", "Bash(git checkout*)", "Bash(git switch*)",
       "Bash(git restore*)", "Bash(git merge*)", "Bash(git rebase*)", "Bash(git cherry-pick*)",
@@ -392,6 +392,15 @@ const canonicalSettings = String.raw`{
             "command": "bash \"$CLAUDE_PROJECT_DIR/.tfcore/hooks/guard-verify.sh\""
           }
         ]
+      },
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash \"$CLAUDE_PROJECT_DIR/.tfcore/hooks/yolo-allow.sh\""
+          }
+        ]
       }
     ],
     "SessionStart": [
@@ -723,7 +732,9 @@ function migrateLegacyLayout() {
   const rootConfig = join(target, "opencode.jsonc");
   if (existsSync(rootConfig) && legacyConfigPattern.test(read(rootConfig))) {
     copyFileSync(rootConfig, `${rootConfig}.bak`);
-    copyFileSync(join(sourceRoot, "opencode.jsonc"), rootConfig);
+    // the content only, as the shell's `cp` onto an existing file does: copyFileSync also copies the
+    // template's mode, so an executable checkout of opencode.jsonc gave a different file (CI, 2026-10-04)
+    writeFileSync(rootConfig, readFileSync(join(sourceRoot, "opencode.jsonc")));
     say("  opencode.jsonc — legacy version backed up to opencode.jsonc.bak, replaced with current template");
   }
   say("");
@@ -742,7 +753,7 @@ function refreshRootOpenCodeConfig() {
     if (dryRun) say("  opencode.jsonc — WOULD refresh from template (no project-only content; old file → .bak)");
     else {
       copyFileSync(rootConfig, `${rootConfig}.bak`);
-      copyFileSync(join(sourceRoot, "opencode.jsonc"), rootConfig);
+      writeFileSync(rootConfig, readFileSync(join(sourceRoot, "opencode.jsonc")));   // keeps its mode, as `cp` does
       say("  opencode.jsonc — refreshed from template (no project-only content; old file → opencode.jsonc.bak)");
       replaced = true;
     }