@techierathore/techieflow 1.0.3 → 1.1.0

package/.tfcore/utils/tf_feedback.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""tf_feedback.py — the one reader of a project's upstream feedback files (2026-09-11).
+
+    bash .tfcore/utils/tf-feedback.sh <App>                       every entry and its state
+    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>"
+
+An entry is one of three things, and every script that reports on these files reads them here:
+
+  open     nobody upstream has answered it
+  fixed    the upstream team's reply ("## Resolution status (…, <date>)") lists it, or its own body
+           says "fixed upstream" — the fix exists, and this project has not yet re-checked it
+  closed   this project re-checked it and marked it closed (✅, "Closed <date>", "will not fix")
+
+Why one reader. Until 2026-09-11 three scripts read these files three ways, and the one that writes
+PROJECT-STATUS counted every `###` heading as an entry and accepted only a closing format no file
+used: TfLens's status read "TechieFlow: 62 open of 62" for a file of 27 entries with 16 fixed, and
+the agent reported two fixed problems to the owner as open (MISS-TechieFlow-20260911-04).
+
+--close writes one line under the entry's heading and nothing else. Python 3 standard library only.
+"""
+from __future__ import annotations
+
+import datetime
+import glob
+import os
+import re
+import sys
+
+# a heading is one line: [ \t], never \s, which runs past the line break and makes the next line
+# of a bare "## TF-013" its title — its closing line included (TF-028)
+ENTRY_HEAD = re.compile(r"(?m)^(#{2,3})[ \t]+`?([A-Z][A-Z0-9]*(?:-[A-Z0-9]+)*-\d+)\b[` \t—–-]*(.*)$")
+REPLY_HEAD = re.compile(r"(?mi)^([ \t]*>[ \t]*)?#{2,3}[ \t]+[^\n]*\b(?:resolution status|resolved|repl(?:y|ies) from)\b[^\n]*")
+ANY_ID = re.compile(r"(?<![\w-])([A-Z][A-Z0-9]*(?:-[A-Z]+)*-\d{2,})(?!\d)")
+FIXED_WORDS = re.compile(r"(?i)\b(fixed|resolved|corrected|closes|closed|wired)\b")
+EVERYTHING = re.compile(r"(?i)\beverything else is (?:now )?fixed\b|\ball (?:the )?others? (?:are )?(?:now )?fixed\b")
+# a project's own mark that it re-checked the fix, that it will never be fixed, or that the entry
+# was folded into another
+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")
+BLOCKS = re.compile(r"(?im)^\s*[-*]\s*\*\*Blocks:?\*\*:?\s*(yes|no)\b")
+
+
+def entries(path):
+    """-> [{id, title, state, since, blocks, start, end}] in file order."""
+    text = open(path, encoding="utf-8", errors="replace").read()
+    heads = list(ENTRY_HEAD.finditer(text))
+    out = {}
+    for i, m in enumerate(heads):
+        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")
+        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 "",
+                                    "start": m.start(), "end": m.end() + len(body)})
+    # the upstream team's replies, in the shapes they have actually been written in
+    for rid, date in replied_fixed(text, list(out)):
+        e = out.get(rid)
+        if e and e["state"] == "open":
+            e["state"] = "fixed"
+        if e and not e["since"] and date:
+            e["since"] = date
+    return list(out.values())
+
+
+def reply_blocks(text):
+    """-> [(date, block text)]. A reply is a heading naming a resolution or a reply —
+    "## 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 = []
+    for m in REPLY_HEAD.finditer(text):
+        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))
+        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))
+    return out
+
+
+def replied_fixed(text, known):
+    """-> [(id, date)] for every entry a reply says is fixed. Inside a reply, an item — a table
+    row, a bullet, or a paragraph — fixes the ids it names when it is a table row or says fixed,
+    resolved, corrected or closes; "everything else is fixed" covers every entry up to the highest
+    number the reply mentions (entries filed after it stay open)."""
+    out = []
+    for date, body in reply_blocks(text):
+        items = re.split(r"\n\s*\n|\n(?=\s*[-*]\s)|\n(?=\s*\|)", body)
+        mentioned = []
+        for it in items:
+            ids = ANY_ID.findall(it)
+            mentioned += ids
+            if not ids:
+                continue
+            if it.lstrip().startswith("|"):
+                first = ANY_ID.findall(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]
+        for it in items:
+            if EVERYTHING.search(it) and mentioned:
+                top = {}
+                for i in 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]:
+                        out.append((k, date))
+    return out
+
+
+def files(root, app=None):
+    pat = f"{app}-*-Feedback.md" if app else "*-Feedback.md"
+    return sorted(glob.glob(os.path.join(root, "docs", pat)))
+
+
+def upstream_of(path, app=None):
+    base = os.path.basename(path)
+    m = re.match(rf"^{re.escape(app)}-(.+)-Feedback\.md$", base) if app else re.match(r"^[^-]+-(.+)-Feedback\.md$", base)
+    return m.group(1) if m else base
+
+
+def state_map(root):
+    """Every entry id across the project's feedback files -> (state, "<file>, <date>")."""
+    out = {}
+    for f in files(root):
+        rel = os.path.relpath(f, root).replace(os.sep, "/")
+        for e in entries(f):
+            out[e["id"]] = (e["state"], f"{rel}" + (f", Resolution status {e['since']}" if e["since"] else ""))
+    return out
+
+
+def summary_line(path, app):
+    es = entries(path)
+    n = {s: [e["id"] for e in es if e["state"] == s] for s in ("open", "fixed", "closed")}
+    rel = "docs/" + os.path.basename(path)
+    parts = [f"{len(n['open'])} open"]
+    if n["fixed"]:
+        ids = ", ".join(n["fixed"][:3]) + (" …" if len(n["fixed"]) > 3 else "")
+        parts.append(f"{len(n['fixed'])} fixed upstream, not yet re-checked ({ids})")
+    parts.append(f"{len(n['closed'])} closed")
+    return f"- {upstream_of(path, app)}: " + " · ".join(parts) + f" — {rel}"
+
+
+def close(path, rid, evidence):
+    text = open(path, encoding="utf-8").read()
+    e = next((x for x in entries(path) if x["id"] == rid), None)
+    if not e:
+        return f"tf-feedback: no entry {rid} in {os.path.basename(path)}", 2
+    if e["state"] == "closed":
+        return f"tf-feedback: {rid} is already closed; nothing written", 0
+    if not evidence.strip():
+        return "tf-feedback: say what you ran and what it showed; a close with no evidence is refused", 2
+    line_end = text.index("\n", e["start"]) + 1
+    today = datetime.date.today().isoformat()
+    mark = f"\n> ✅ **Closed {today}** — re-checked here: {evidence.strip()}\n"
+    open(path, "w", encoding="utf-8").write(text[:line_end] + mark + text[line_end:])
+    return f"tf-feedback: {rid} closed in {os.path.basename(path)}", 0
+
+
+def main(argv):
+    if not argv or argv[0] in ("-h", "--help"):
+        print(__doc__)
+        return 0 if argv else 2
+    app, rest = argv[0], argv[1:]
+    root = os.getcwd()
+    fs = files(root, app)
+    if not fs:
+        print(f"tf-feedback: no docs/{app}-*-Feedback.md here")
+        return 0
+    if rest[:1] == ["--close"]:
+        if len(rest) < 3:
+            print('usage: tf-feedback.sh <App> --close <ID> "<what you ran and what it showed>"')
+            return 2
+        for f in fs:
+            if any(e["id"] == rest[1] for e in entries(f)):
+                msg, rc = close(f, rest[1], rest[2])
+                print(msg)
+                return rc
+        print(f"tf-feedback: no entry {rest[1]} in any docs/{app}-*-Feedback.md")
+        return 2
+    waiting = rest[:1] == ["--waiting"]
+    for f in fs:
+        es = entries(f)
+        if waiting:
+            for e in es:
+                if e["state"] == "fixed":
+                    print(f"{e['id']}  fixed upstream{' ' + e['since'] if e['since'] else ''}, waiting to be "
+                          f"re-checked here — {os.path.basename(f)}")
+            continue
+        print(summary_line(f, app))
+        for e in es:
+            print(f"  {e['id']:<12} {e['state']:<7} {e['since'] or '':<10} {e['title'][:80]}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/.tfcore/utils/tf_roadmap.py

@@ -0,0 +1,35 @@
+"""tf_roadmap.py — which checklist rows are roadmap items, out of this phase's scope.
+
+A row is a roadmap item when its acceptance line in the checklist's detail section carries
+"Roadmap — not in this phase's scope" (any dash, any case). Such a row is not work for this
+phase: it stays off the build list and out of the "not built yet" count, and it never makes
+*build-phase the next command. Only the owner moves it, through *amend-docs.
+
+AppManager's REQ-NFR-008 carried the marker at In Progress; tf-build-list.py put it on the
+working list with a builder prompt, a builder built it against the owner's decision, and
+tf-status-facts.py named *build-phase as the next command for it forever (TF-017).
+tests/regression/run.sh am_017. Imported by tf-build-list.py and tf-status-facts.py.
+"""
+import re
+
+MARK = re.compile(r"roadmap\s*[—–-]+\s*not in this phase['’]?s scope", re.I)
+ACCEPTANCE = re.compile(r"\*Acceptance:?\*|^\s*[-*]\s*Acceptance:", re.I)
+OWNER = re.compile(r"<a id=['\"]d-(req-[a-z]+-\d+)['\"]|\*\*`?(REQ-[A-Z]+-\d+)`?\*\*", re.I)
+
+
+def ids(text):
+    """The set of REQ ids whose acceptance line carries the roadmap marker.
+
+    The owner of an acceptance line is the nearest REQ anchor or bold REQ id above it, in the
+    detail section; status-table rows (lines starting with `|`) are never read."""
+    out, owner = set(), None
+    for line in text.splitlines():
+        if line.lstrip().startswith("|"):
+            continue
+        if re.match(r"^#{1,2}\s", line):
+            owner = None
+        for m in OWNER.finditer(line):
+            owner = (m.group(1) or m.group(2)).upper()
+        if owner and ACCEPTANCE.search(line) and MARK.search(line):
+            out.add(owner)
+    return out

package/README.md

@@ -27,6 +27,8 @@ Three things make it different from prompting an agent by hand:
 - **Rules that were ignored became hooks.** Eight guards refuse an action outright and print why: any git write, a malformed status file, `Verified` without a verify run, a hand edit of a telemetry file, a database write outside build and fix, run material at the repository root, a backgrounded build in unattended mode, and ending a turn with the status gate incomplete.
 - **The work is measured.** Five append-only streams per project record what each command cost, which check caught which failure, and what each miss cost to fix.
 
+The framework has an opinion about how agents talk to people. Every project's `AGENTS.md` (written at day-1) tells the agent to tag each claim it is unsure of as Certain, Likely or Guessing; to say the thing you will not want to hear first; to skip warm-up and start with the most useful sentence; and to disagree in a fixed shape ("I disagree because … I would do … The risk in your approach is …") and then do what you decide.
+
 The framework is technology-neutral. It asks a set of stack questions at day-1 and records the answers in the project's Architecture document; an answer set can fill them in (the owner's .NET set ships as `docs/TechieFlow-Stack-Defaults-DotNet.md`).
 
 ---
@@ -35,6 +37,8 @@ The framework is technology-neutral. It asks a set of stack questions at day-1 a
 
 Prerequisites are one-time per machine and live in [`docs/TechieFlow-Setup.md`](docs/TechieFlow-Setup.md): the toolchain, headless Chromium, and — for mobile heads — the Appium device hosts. **`python3` is required**; the guard hooks fail open without it.
 
+It runs on Linux, WSL and a stock Mac. On a Mac the scripts use Apple's own bash 3.2 and BSD tools, so Homebrew, a newer bash and GNU coreutils are not needed; `python3` comes with the Command Line Tools (`xcode-select --install`).
+
 Copy the framework in; never `npm install` it. All three scripts locate the framework from their own directory, so invoke whichever machine's copy you are on.
 
 ```bash
@@ -126,10 +130,11 @@ Replace `{App}` with your application name. Claude Code takes the long persona p
 
 ## 5. What it produces
 
-Every per-project document is named after the application: `docs/<App>-BRD.md`, `-Architecture.md`, `-Checklist.md`, `-UIDesign.md`, `-Coding-Standards.md`, `-UsageGuide.md`, `-DevGuide.md`, `-ProductGuide.md`, `-Deployment-Checklist.md`, plus `PROJECT-STATUS.md` and `CLAUDE.md` at the root, mockups under `docs/mockups/`, and screenshots under `docs/screenshots/<App>/`.
+Every per-project document is named after the application: `docs/<App>-Brief.md`, `-BRD.md`, `-Architecture.md`, `-Checklist.md`, `-UIDesign.md`, `-Coding-Standards.md`, `-UsageGuide.md`, `-DevGuide.md`, `-ProductGuide.md`, `-Deployment-Checklist.md`, `-Misses.md`, `-Decision-Request.md`, `-<Upstream>-Feedback.md`, plus `PROJECT-STATUS.md` and `CLAUDE.md` at the root, mockups under `docs/mockups/`, and screenshots under `docs/screenshots/<App>/`.
 
 | Document | Who reads it |
 |---|---|
+| Brief | You, before anything is built. One page: what it is, who for, must do, out of scope. Day-1 reads it. |
 | BRD, Architecture, UIDesign and the mockups | You, at the day-1 review. This is the cheap moment to redirect. |
 | Checklist | Agents only. One table, one row per requirement, the single source of truth. Never rendered to HTML. |
 | Coding Standards | Every implementing agent, and the verifier's standards check. |
@@ -138,9 +143,11 @@ Every per-project document is named after the application: `docs/<App>-BRD.md`,
 | DevGuide | A developer tracing a bug: every screen to its code, with the line to break on. |
 | ProductGuide | The end user. |
 | Deployment Checklist | Whoever puts it on the host, after UAT. |
-| Library feedback, one file per library | That library's team. |
+| Misses | You and the agents. Rebuilt from the record whenever something is logged as missed. |
+| Decision Request | You. Every choice an agent cannot make: options, what each costs, a recommendation, and a block to paste back. It is never read back by an agent. |
+| Feedback, one file per upstream | That team — each library, and the framework itself. Every entry says in its first word whether it blocks your work. Reporting is never refused; a non-blocking entry never stops a run. |
 
-Each document has a required shape and a size budget for the application's size (Small, Medium or Large), enforced by `bash .tfcore/utils/tf-doc-check.sh --app {App}`. Add `--warn` to get a report instead of a refusal, which is what you want on a project that predates the schemas. Human documents render to HTML by script; the checklist never does.
+Each document has a required shape and a size budget for the application's size (Small, Medium or Large), enforced by `bash .tfcore/utils/tf-doc-check.sh --app {App}`. Add `--warn` to get a report instead of a refusal, which is what you want on a project that predates the schemas. Human documents render to HTML by script; an agent document never does — the checklist and the miss list are refused by name.
 
 ---
 
@@ -152,7 +159,7 @@ The shipped configuration allows every file operation and all of Bash with no pr
 
 Five append-only streams per project under `docs/metrics/`, read with `*metrics {App}`: command runs, verification verdicts, misses, chat sessions, and your own commits. They answer five questions — the first-pass rate, which check caught the failure, the escape rate, what misses cost to fix, and the effort per phase. Definitions, real figures and the sentence to say about each are in [`docs/TechieFlow-Telemetry-Explained.md`](docs/TechieFlow-Telemetry-Explained.md); the field contract is `.tfcore/telemetry/SCHEMA.md`.
 
-Standing rules: provenance never merges, only identifiers and counts are recorded, telemetry has no veto, and an agent never writes what it cannot know. Dollar figures exist only for OpenCode runs; Claude Code reports tokens and no rate card is ever applied.
+Standing rules: provenance never merges, only identifiers and counts are recorded, telemetry has no veto, and an agent never writes what it cannot know. **Tokens are what is recorded; money is worked out when the report runs.** A record stores what the provider itself charged — only a metered provider charges per token — and never a computed price. The report separately prints a **list price**, the published rate applied to the tokens actually measured, which is the one figure that compares a Claude phase with an OpenCode one. A price is never called a bill, and a monthly plan's allowance is counted apart from both.
 
 ## 8. Running phases on cheaper models
 
@@ -164,7 +171,14 @@ bash .tfcore/utils/tf-routing.sh on
 bash .tfcore/utils/tf-routing.sh set-tier verify-phase economy
 ```
 
-Drift is observed, never enforced: a run on the wrong model is recorded as such and nothing blocks. Full guide: [`docs/TechieFlow-Routing-Guide.md`](docs/TechieFlow-Routing-Guide.md).
+Each tier also names the models to try **instead**, while its own is out of quota. When a usage limit is hit, the supervisor parks that model until its stated reset, moves to the next model in the tier's chain, re-binds so the sub-agents move with it, and carries on; only when every model in the chain is limited does it wait. `--no-fallback` restores the old wait-for-reset behaviour.
+
+```bash
+bash .tfcore/utils/tf-model-pick.sh status               # what each tier would run right now
+bash .tfcore/utils/tf-model-pick.sh chain standard opencode   # the order it falls back in
+```
+
+Drift is observed, never enforced: a run on the wrong model is recorded as such and nothing blocks. The step-by-step setup, and what a cost figure means on each kind of plan, are in the full guide: [`docs/TechieFlow-Routing-Guide.md`](docs/TechieFlow-Routing-Guide.md).
 
 ---
 

package/docs/TechieFlow-Installation.md

@@ -16,14 +16,16 @@ You need four things on the machine.
 | Tool | Why | Check |
 |---|---|---|
 | Node.js 20 or newer | Runs the installer. Nothing is added to your project. | `node --version` |
-| bash | The framework's guard hooks and helper scripts run under bash. macOS and Linux have it. On Windows, work inside WSL or Git Bash. | `bash --version` |
+| bash | The framework's guard hooks and helper scripts run under bash. macOS and Linux have it; the bash 3.2 that comes with macOS is enough. On Windows, work inside WSL or Git Bash. | `bash --version` |
 | Python 3 | Powers the HTML renderer, the telemetry writer and the guard hooks. | `python3 --version` |
-| Claude Code or OpenCode | The harness that runs the agents. Either one. Both work from the same install. | `claude --version` or `opencode --version` |
+| Claude Code or OpenCode | The harness that runs the agents. Either one. Both work from the same install. The framework targets OpenCode 2; its plugin still loads on OpenCode 1.x. | `claude --version` or `opencode --version` |
 
 For a .NET project you also need the .NET SDK. Run `dotnet --version` to check.
 
 You do not need rsync, git on the command line, or a clone of this repository.
 
+**On a Mac.** A stock Mac is enough. The scripts run on Apple's own bash 3.2 and the `sed`, `date`, `stat` and `xargs` that come with macOS. You do not need Homebrew, a newer bash or GNU coreutils for them. The one thing to add is Python 3: it comes with Apple's Command Line Tools, so run `xcode-select --install` once if `python3 --version` asks for them. perl and rsync already ship with macOS. Your project's own tools, such as the .NET SDK, are installed as usual.
+
 ---
 
 ## 1. What gets installed
@@ -312,7 +314,7 @@ It installs the framework if it is not there yet, then removes the leftover pack
 |---|---|
 | The framework is under `node_modules/@techierathore/techieflow/` and nowhere else | You ran `npm install`. See section 9. Run `npx @techierathore/techieflow@latest install`. |
 | `bash was not found` | On Windows, run the command inside WSL or Git Bash. |
-| `python3 was not found` | Install Python 3 and run the command again. On macOS: `brew install python3`. On Ubuntu or WSL: `sudo apt-get install -y python3`. |
+| `python3 was not found` | Install Python 3 and run the command again. On macOS: `xcode-select --install` (Apple's Command Line Tools include python3), or `brew install python3`. On Ubuntu or WSL: `sudo apt-get install -y python3`. |
 | `Refusing to install into the framework itself` | You ran the command inside a clone of this repository. Pass `--target=<your project>`. |
 | `does not look installed` on update | The folder has no `.tfcore/`. Run `install` first. |
 | Claude Code does not show the `/TechieFlow:agents:analyst` command | Restart Claude Code in the project folder. Check that `.claude/commands/TechieFlow/agents/analyst.md` exists. |

package/opencode.jsonc

@@ -897,6 +897,30 @@
       "template": "{file:./.tfcore/tasks/create-doc.md}",
       "description": "Create a document from a YAML-driven TechieFlow template (interactive, section by section)."
     },
+    "techieflow:tasks:verify": {
+      "template": "{file:./.tfcore/tasks/verify-phase.md}",
+      "description": "The verifier's *verify. Boot the app, run the seven checks on every row in scope, write the verdicts."
+    },
+    "techieflow:tasks:metrics": {
+      "template": "{file:./.tfcore/tasks/metrics-report.md}",
+      "description": "The flow-master's *metrics. Read the telemetry streams and write the metrics report."
+    },
+    "techieflow:tasks:brainstorm": {
+      "template": "{file:./.tfcore/tasks/facilitate-brainstorming-session.md}",
+      "description": "The analyst's *brainstorm. Run a structured brainstorming session."
+    },
+    "techieflow:tasks:research-prompt": {
+      "template": "{file:./.tfcore/tasks/create-deep-research-prompt.md}",
+      "description": "The analyst's *research-prompt. Generate a well-structured research prompt."
+    },
+    "techieflow:tasks:research": {
+      "template": "{file:./.tfcore/tasks/create-deep-research-prompt.md}",
+      "description": "The architect's *research. Generate a well-structured research prompt."
+    },
+    "techieflow:tasks:create-project-brief": {
+      "template": "{file:./.tfcore/tasks/create-project-brief.md}",
+      "description": "Write the one-page project brief that day-1 takes as input: product, users, must-do, out of scope. The analyst's *create-project-brief."
+    },
     "techieflow:tasks:create-deep-research-prompt": {
       "template": "{file:./.tfcore/tasks/create-deep-research-prompt.md}",
       "description": "Generate well-structured research prompts."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techierathore/techieflow",
-  "version": "1.0.3",
+  "version": "1.1.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

@@ -369,6 +369,10 @@ const canonicalSettings = String.raw`{
           {
             "type": "command",
             "command": "bash \"$CLAUDE_PROJECT_DIR/.tfcore/hooks/guard-build.sh\""
+          },
+          {
+            "type": "command",
+            "command": "bash \"$CLAUDE_PROJECT_DIR/.tfcore/hooks/guard-verify-deps.sh\""
           }
         ]
       },