@techierathore/techieflow 1.0.0

package/.tfcore/data/technical-preferences.md

@@ -0,0 +1,3 @@
+# User-Defined Preferred Patterns and Preferences
+
+None Listed

package/.tfcore/enhanced-ide-development-workflow.md

@@ -0,0 +1,248 @@
+# Enhanced IDE Development Workflow
+
+This is a simple step-by-step guide to help you efficiently manage your development workflow using the TechieFlow. The workflow integrates the Test Architect (QA agent) throughout the development lifecycle to ensure quality, prevent regressions, and maintain high standards. Refer to the **[<ins>User Guide</ins>](user-guide.md)** for any scenario that is not covered here.
+
+## Create New Branch
+
+1. **Start new branch**
+
+## Story Creation (Scrum Master)
+
+1. **Start new chat/conversation**
+2. **Load SM agent**
+3. **Execute**: `*draft` (runs create-next-story task)
+4. **Review generated story** in `docs/stories/`
+5. **Update status**: Change from "Draft" to "Approved"
+
+## Story Implementation (Developer)
+
+1. **Start new chat/conversation**
+2. **Load Dev agent**
+3. **Execute**: `*develop-story {selected-story}` (runs execute-checklist task)
+4. **Review generated report** in `{selected-story}`
+
+## Test Architect Integration Throughout Workflow
+
+The Test Architect (Quinn) provides comprehensive quality assurance throughout the development lifecycle. Here's how to leverage each capability at the right time.
+
+**Command Aliases:** Documentation uses short forms (`*risk`, `*design`, `*nfr`, `*trace`) for the full commands (`*risk-profile`, `*test-design`, `*nfr-assess`, `*trace-requirements`).
+
+### Quick Command Reference
+
+| **Stage**                | **Command** | **Purpose**                             | **Output**                                                      | **Priority**                |
+| ------------------------ | ----------- | --------------------------------------- | --------------------------------------------------------------- | --------------------------- |
+| **After Story Approval** | `*risk`     | Identify integration & regression risks | `docs/qa/assessments/{epic}.{story}-risk-{YYYYMMDD}.md`         | High for complex/brownfield |
+|                          | `*design`   | Create test strategy for dev            | `docs/qa/assessments/{epic}.{story}-test-design-{YYYYMMDD}.md`  | High for new features       |
+| **During Development**   | `*trace`    | Verify test coverage                    | `docs/qa/assessments/{epic}.{story}-trace-{YYYYMMDD}.md`        | Medium                      |
+|                          | `*nfr`      | Validate quality attributes             | `docs/qa/assessments/{epic}.{story}-nfr-{YYYYMMDD}.md`          | High for critical features  |
+| **After Development**    | `*review`   | Comprehensive assessment                | QA Results in story + `docs/qa/gates/{epic}.{story}-{slug}.yml` | **Required**                |
+| **Post-Review**          | `*gate`     | Update quality decision                 | Updated `docs/qa/gates/{epic}.{story}-{slug}.yml`               | As needed                   |
+
+### Stage 1: After Story Creation (Before Dev Starts)
+
+**RECOMMENDED - Set Developer Up for Success:**
+
+```bash
+# 1. RISK ASSESSMENT (Run FIRST for complex stories)
+@qa *risk {approved-story}
+# Identifies:
+#   - Technical debt impact
+#   - Integration complexity
+#   - Regression potential (1-9 scoring)
+#   - Mitigation strategies
+# Critical for: Brownfield, API changes, data migrations
+
+# 2. TEST DESIGN (Run SECOND to guide implementation)
+@qa *design {approved-story}
+# Provides:
+#   - Test scenarios per acceptance criterion
+#   - Test level recommendations (unit/integration/E2E)
+#   - Risk-based priorities (P0/P1/P2)
+#   - Test data requirements
+# Share with Dev: Include in story comments or attach to ticket
+```
+
+### Stage 2: During Development (Mid-Implementation Checkpoints)
+
+**Developer Self-Service Quality Checks:**
+
+```bash
+# 3. REQUIREMENTS TRACING (Verify coverage mid-development)
+@qa *trace {story-in-progress}
+# Validates:
+#   - All acceptance criteria have tests
+#   - No missing test scenarios
+#   - Appropriate test levels
+#   - Given-When-Then documentation clarity
+# Run when: After writing initial tests
+
+# 4. NFR VALIDATION (Check quality attributes)
+@qa *nfr {story-in-progress}
+# Assesses:
+#   - Security: Authentication, authorization, data protection
+#   - Performance: Response times, resource usage
+#   - Reliability: Error handling, recovery
+#   - Maintainability: Code quality, documentation
+# Run when: Before marking "Ready for Review"
+```
+
+### Stage 3: Story Review (Quality Gate Assessment)
+
+**REQUIRED - Comprehensive Test Architecture Review:**
+
+**Prerequisite:** All tests green locally; lint & type checks pass.
+
+```bash
+# 5. FULL REVIEW (Standard review process)
+@qa *review {completed-story}
+```
+
+**What Happens During Review:**
+
+1. **Deep Code Analysis**
+   - Architecture pattern compliance
+   - Code quality and maintainability
+   - Security vulnerability scanning
+   - Performance bottleneck detection
+
+2. **Active Refactoring**
+   - Improves code directly when safe
+   - Fixes obvious issues immediately
+   - Suggests complex refactoring for dev
+
+3. **Test Validation**
+   - Coverage at all levels (unit/integration/E2E)
+   - Test quality (no flaky tests, proper assertions)
+   - Regression test adequacy
+
+4. **Gate Decision**
+   - Creates: `docs/qa/gates/{epic}.{story}-{slug}.yml`
+   - Adds: QA Results section to story file
+   - Status: PASS/CONCERNS/FAIL/WAIVED
+
+### Stage 4: Post-Review (After Addressing Issues)
+
+**Update Gate Status After Fixes:**
+
+```bash
+# 6. GATE UPDATE (Document final decision)
+@qa *gate {reviewed-story}
+# Updates: Quality gate with new status
+# Use when: After addressing review feedback
+# Documents: What was fixed, what was waived
+```
+
+### Understanding Gate Decisions
+
+| **Status**   | **Meaning**                                  | **Action Required**     | **Can Proceed?** |
+| ------------ | -------------------------------------------- | ----------------------- | ---------------- |
+| **PASS**     | All critical requirements met                | None                    | ✅ Yes           |
+| **CONCERNS** | Non-critical issues found                    | Team review recommended | ⚠️ With caution  |
+| **FAIL**     | Critical issues (security, missing P0 tests) | Must fix                | ❌ No            |
+| **WAIVED**   | Issues acknowledged and accepted             | Document reasoning      | ✅ With approval |
+
+### Risk-Based Testing Strategy
+
+The Test Architect uses risk scoring to prioritize testing:
+
+| **Risk Score** | **Calculation**                | **Testing Priority**      | **Gate Impact**          |
+| -------------- | ------------------------------ | ------------------------- | ------------------------ |
+| **9**          | High probability × High impact | P0 - Must test thoroughly | FAIL if untested         |
+| **6**          | Medium-high combinations       | P1 - Should test well     | CONCERNS if gaps         |
+| **4**          | Medium combinations            | P1 - Should test          | CONCERNS if notable gaps |
+| **2-3**        | Low-medium combinations        | P2 - Nice to have         | Note in review           |
+| **1**          | Minimal risk                   | P2 - Minimal              | Note in review           |
+
+### Special Situations & Best Practices
+
+#### High-Risk or Brownfield Stories
+
+```bash
+# ALWAYS run this sequence:
+@qa *risk {story}    # First - identify dangers
+@qa *design {story}  # Second - plan defense
+# Then during dev:
+@qa *trace {story}   # Verify regression coverage
+@qa *nfr {story}     # Check performance impact
+# Finally:
+@qa *review {story}  # Deep integration analysis
+```
+
+#### Complex Integrations
+
+- Run `*trace` multiple times during development
+- Focus on integration test coverage
+- Use `*nfr` to validate cross-system performance
+- Review with extra attention to API contracts
+
+#### Performance-Critical Features
+
+- Run `*nfr` early and often (not just at review)
+- Establish performance baselines before changes
+- Document acceptable performance degradation
+- Consider load testing requirements in `*design`
+
+### Test Quality Standards Enforced
+
+Quinn ensures all tests meet these standards:
+
+- **No Flaky Tests**: Proper async handling, explicit waits
+- **No Hard Waits**: Dynamic strategies only (polling, events)
+- **Stateless**: Tests run independently and in parallel
+- **Self-Cleaning**: Tests manage their own test data
+- **Appropriate Levels**: Unit for logic, integration for interactions, E2E for journeys
+- **Clear Assertions**: Keep assertions in tests, not buried in helpers
+
+### Documentation & Audit Trail
+
+All Test Architect activities create permanent records:
+
+- **Assessment Reports**: Timestamped analysis in `docs/qa/assessments/`
+- **Gate Files**: Decision records in `docs/qa/gates/`
+- **Story Updates**: QA Results sections in story files
+- **Traceability**: Requirements to test mapping maintained
+
+## Commit Changes and Push
+
+1. **Commit changes**
+2. **Push to remote**
+
+## Complete Development Cycle Flow
+
+### The Full Workflow with Test Architect
+
+1. **SM**: Create next story → Review → Approve
+2. **QA (Optional)**: Risk assessment (`*risk`) → Test design (`*design`)
+3. **Dev**: Implement story → Write tests → Complete
+4. **QA (Optional)**: Mid-dev checks (`*trace`, `*nfr`)
+5. **Dev**: Mark Ready for Review
+6. **QA (Required)**: Review story (`*review`) → Gate decision
+7. **Dev (If needed)**: Address issues
+8. **QA (If needed)**: Update gate (`*gate`)
+9. **Commit**: All changes
+10. **Push**: To remote
+11. **Continue**: Until all features implemented
+
+### Quick Decision Guide
+
+**Should I run Test Architect commands?**
+
+| **Scenario**             | **Before Dev**                  | **During Dev**               | **After Dev**                |
+| ------------------------ | ------------------------------- | ---------------------------- | ---------------------------- |
+| **Simple bug fix**       | Optional                        | Optional                     | Required `*review`           |
+| **New feature**          | Recommended `*risk`, `*design`  | Optional `*trace`            | Required `*review`           |
+| **Brownfield change**    | **Required** `*risk`, `*design` | Recommended `*trace`, `*nfr` | Required `*review`           |
+| **API modification**     | **Required** `*risk`, `*design` | **Required** `*trace`        | Required `*review`           |
+| **Performance-critical** | Recommended `*design`           | **Required** `*nfr`          | Required `*review`           |
+| **Data migration**       | **Required** `*risk`, `*design` | **Required** `*trace`        | Required `*review` + `*gate` |
+
+### Success Metrics
+
+The Test Architect helps achieve:
+
+- **Zero regression defects** in production
+- **100% requirements coverage** with tests
+- **Clear quality gates** for go/no-go decisions
+- **Documented risk acceptance** for technical debt
+- **Consistent test quality** across the team
+- **Shift-left testing** with early risk identification

package/.tfcore/hooks/block-git.sh

@@ -0,0 +1,301 @@
+#!/usr/bin/env bash
+# TechieFlow PreToolUse hook for Bash — the git guard + the YOLO permission gate.
+#
+# Two jobs, one hook (wired in .claude/settings.json → hooks.PreToolUse, matcher
+# "Bash"; the OpenCode plugin .opencode/plugin/techieflow.js feeds it the same
+# Claude-shaped stdin for the `bash` tool):
+#
+#  1. GIT GUARD. Git is MANUAL in TechieFlow — agents never COMMIT, PUSH, STAGE,
+#     RESET, CHECKOUT or otherwise WRITE to git, ever (.tfcore/tasks/_smoke-test-policy.md
+#     §"Git is manual", _status-update-gate.md §"Never run git"). Outside YOLO,
+#     agents never READ git either (status/log/diff/blame) — status evidence is the
+#     checklist table + working tree + a fresh build. In YOLO mode (below) READ-ONLY
+#     git/gh is allowed; WRITES stay blocked in every mode. settings.json's deny
+#     rules list the write subcommands as a second layer (deny rules hold in every
+#     permission mode, bypass included); this hook catches the compound forms
+#     prefix-matching misses ("cd x && git log", "foo | git …", "bash -c 'git …'").
+#
+#  2. YOLO GATE (.tfcore/tasks/_yolo-mode.md). Claude Code honours settings.json
+#     `ask` rules EVEN in bypassPermissions mode and EVEN when a hook says allow —
+#     so `rm`/`rmdir`/`sudo` are NOT in settings.json `ask` any more; this hook is
+#     the only place that decides. Outside YOLO it returns permissionDecision=ask
+#     for them (same prompt the owner always had). In YOLO it stays silent and the
+#     bare "Bash" allow rule lets them run — an unattended goal run never stalls on
+#     a delete. Catastrophic `rm -rf /|~` stay in settings.json `deny` (every mode).
+#
+# YOLO is ON when any of: env TF_YOLO=1 · .tfcore/.session/yolo.json exists
+# (tf-yolo.sh on) · the hook payload's permission_mode is bypassPermissions/auto.
+#
+# Exit codes: 2 + stderr = BLOCK (both harnesses); 0 + JSON on stdout = decision
+# (Claude Code only; OpenCode ignores stdout and uses its own permission map).
+# Any internal failure → fall back to the ORIGINAL conservative behaviour
+# (block any command word git/gh via regex; leave rm to the harness).
+
+INPUT="$(cat)"
+ROOT="${CLAUDE_PROJECT_DIR:-${TF_PROJECT_DIR:-}}"
+STRICT_GIT="${TF_STRICT_GIT:-0}"
+
+YOLO=0
+[[ "${TF_YOLO:-0}" == "1" ]] && YOLO=1
+# The on-disk flag EXPIRES (tf-yolo.sh flag_live, same 24h default and the same
+# portable `find -mmin` test). `off`/`done` clear it, but a killed or crashed run
+# leaves it behind and an unnoticed flag silently suppresses delete prompts for as
+# long as it sits there — five repos were found in that state on 2026-08-28, one of
+# them 6 days old. TF_YOLO=1 is checked above and never expires, so a long
+# tf-goal.sh run (which exports it) is unaffected.
+if [[ $YOLO -eq 0 && -n "$ROOT" && -f "$ROOT/.tfcore/.session/yolo.json" ]]; then
+  TTL_HOURS="${TF_YOLO_TTL_HOURS:-24}"
+  if [[ "$TTL_HOURS" == "0" ]] || [[ -z "$(find "$ROOT/.tfcore/.session/yolo.json" -mmin "+$(( TTL_HOURS * 60 ))" 2>/dev/null)" ]]; then
+    YOLO=1
+  fi
+fi
+if [[ $YOLO -eq 0 ]] && printf '%s' "$INPUT" | grep -qE '"permission_mode"[[:space:]]*:[[:space:]]*"(bypassPermissions|auto)"'; then YOLO=1; fi
+
+block_git_msg() {
+  cat >&2 <<'MSG'
+BLOCKED by TechieFlow policy: agents NEVER WRITE to git or gh — no commit / push / add / reset / checkout / stash / tag / merge / rebase / branch edits / gh pr|issue create|merge|close. Git is manual, owner-only, in EVERY mode including YOLO.
+Do NOT retry with another git/gh form. Instead:
+- Status updates / "what changed": read the checklist Requirements Status table + the working-tree files (ls -lt, find -newer, Read/Glob/Grep) + a fresh dotnet build — never commit history (.tfcore/tasks/_status-update-gate.md).
+- Investigating code: read the files on disk at file:line — the working tree IS the as-built code.
+- Committing/tagging: never yours. Record REQ IDs in the checklist Remarks, not in commits. The owner commits manually.
+- If your command merely CONTAINS the word git (e.g. writing a doc, grepping for the string): use the Write/Edit/Grep tools instead of bash — that is the standing tool-preference rule anyway.
+MSG
+}
+block_read_msg() {
+  if [[ "$STRICT_GIT" == "1" ]]; then
+    cat >&2 <<'MSG'
+BLOCKED by TechieFlow Codex policy: agents do not run any git or gh command, including read-only status/log/diff/blame, in any mode.
+Use the checklist Requirements Status table, working-tree files, filesystem metadata, and fresh build/test evidence instead. The owner performs version-control operations manually.
+MSG
+    return
+  fi
+  cat >&2 <<'MSG'
+BLOCKED by TechieFlow policy: agents do not READ git outside YOLO mode (no status/log/diff/show/blame/grep) — git is manual, owner-only.
+Do NOT retry with another git/gh form. Instead:
+- Status updates / "what changed": read the checklist Requirements Status table + the working-tree files (ls -lt, find -newer, Read/Glob/Grep) + a fresh dotnet build — never commit history (.tfcore/tasks/_status-update-gate.md).
+- Investigating code: read the files on disk at file:line — the working tree IS the as-built code.
+- Read-only git (status/log/diff/blame) becomes available only in YOLO / goal mode (`*yolo` → bash .tfcore/utils/tf-yolo.sh on). Git WRITES are never available.
+MSG
+}
+
+if ! command -v python3 >/dev/null 2>&1; then
+  # Original conservative behaviour — no parser available.
+  if printf '%s' "$INPUT" | grep -qE '(^|[^[:alnum:]_./@-])(git|gh)([^[:alnum:]_.-]|$)'; then block_git_msg; exit 2; fi
+  exit 0
+fi
+
+# Verdicts: ALLOW | ASK_RM | BLOCK_WRITE | BLOCK_READ
+VERDICT="$(TF_HOOK_INPUT="$INPUT" TF_YOLO_ON="$YOLO" python3 - <<'PY' 2>/dev/null
+import json, os, re, shlex, sys
+
+raw = os.environ.get("TF_HOOK_INPUT", "")
+yolo = os.environ.get("TF_YOLO_ON") == "1"
+strict_git = os.environ.get("TF_STRICT_GIT") == "1"
+try:
+    data = json.loads(raw)
+    cmd = str((data.get("tool_input") or {}).get("command") or "")
+except Exception:
+    cmd = raw  # be conservative: scan whatever we got
+
+# ---- git / gh classification --------------------------------------------------
+GIT_READ = {
+    "status", "log", "diff", "show", "blame", "grep", "ls-files", "ls-tree", "rev-parse",
+    "rev-list", "describe", "shortlog", "cat-file", "name-rev", "merge-base", "cherry",
+    "whatchanged", "count-objects", "fsck", "var", "check-ignore", "check-attr",
+    "for-each-ref", "diff-tree", "diff-index", "diff-files", "show-ref", "show-branch",
+    "ls-remote", "version", "help", "range-diff", "annotate", "bisect", "reflog",
+}
+# read-only only with these arg shapes (no args == list/show)
+BRANCH_LIST_FLAGS = {"-a", "-r", "-v", "-vv", "--list", "--show-current", "--contains", "--no-contains",
+                     "--merged", "--no-merged", "--all", "--remotes", "--verbose", "--points-at", "--sort"}
+TAG_LIST_FLAGS = {"-l", "--list", "-n", "--contains", "--no-contains", "--points-at", "--sort", "--merged", "--no-merged"}
+
+def _listing(a, list_flags):
+    """read-only iff every flag is a listing flag AND (no positional args, or an explicit list flag is present)."""
+    flags = [t for t in a if t.startswith("-")]
+    pos = [t for t in a if not t.startswith("-")]
+    if any(t.split("=", 1)[0] not in list_flags and not t.startswith("-n") for t in flags):
+        return False
+    return not pos or any(t.split("=", 1)[0] in list_flags for t in flags)
+
+GIT_COND = {
+    "branch":   lambda a: _listing(a, BRANCH_LIST_FLAGS),
+    "tag":      lambda a: _listing(a, TAG_LIST_FLAGS),
+    "stash":    lambda a: bool(a) and a[0] in ("list", "show"),
+    "remote":   lambda a: (not a) or a[0] in ("-v", "--verbose", "show", "get-url"),
+    "config":   lambda a: any(t in ("--get", "--get-all", "--get-regexp", "--list", "-l") for t in a)
+                          and not any(t in ("--unset", "--unset-all", "--add", "--replace-all", "--edit", "-e",
+                                            "--remove-section", "--rename-section") for t in a),
+    "worktree": lambda a: bool(a) and a[0] == "list",
+    "submodule": lambda a: bool(a) and a[0] in ("status", "summary"),
+    "notes":    lambda a: (not a) or a[0] in ("list", "show"),
+    "reflog":   lambda a: (not a) or a[0] in ("show",) or a[0].startswith("-"),
+    "bisect":   lambda a: bool(a) and a[0] in ("log", "view", "visualize"),
+}
+GH_READ_VERBS = {"list", "view", "status", "checks", "diff", "watch", "download"}
+GH_READ_TOP = {"auth": {"status"}, "pr": GH_READ_VERBS, "issue": GH_READ_VERBS, "run": GH_READ_VERBS,
+               "release": GH_READ_VERBS, "repo": {"view", "list"}, "search": None, "browse": None,
+               "label": {"list"}, "workflow": {"list", "view"}, "gist": {"list", "view"},
+               "cache": {"list"}, "variable": {"list"}, "secret": {"list"}, "ruleset": {"list", "view"}}
+
+WRAPPERS = {"command", "exec", "sudo", "env", "nohup", "time", "nice", "stdbuf", "timeout", "xargs",
+            "winrun", "doas", "busybox", "ionice", "chronic", "unbuffer", "script"}
+SHELLS = {"bash", "sh", "zsh", "dash", "ksh", "fish"}
+SEPS = {";", "&&", "||", "|", "&", "(", ")", "{", "}", "\n", "|&"}
+
+def basename(tok):
+    tok = tok.strip("\"'")
+    return tok.rsplit("/", 1)[-1]
+
+def classify_git(args):
+    """args = tokens after 'git'. Returns 'read' or 'write'."""
+    i = 0
+    # skip global options like -C <path>, -c k=v, --git-dir=..., --no-pager
+    while i < len(args) and args[i].startswith("-"):
+        if args[i] in ("-C", "-c", "--git-dir", "--work-tree", "--namespace") and i + 1 < len(args):
+            i += 2
+        else:
+            i += 1
+    if i >= len(args):
+        return "read"  # bare `git` prints usage
+    sub = args[i]
+    rest = args[i + 1:]
+    if sub in GIT_READ:
+        return "read"
+    if sub in GIT_COND:
+        try:
+            return "read" if GIT_COND[sub](rest) else "write"
+        except Exception:
+            return "write"
+    return "write"
+
+def classify_gh(args):
+    a = [t for t in args if not t.startswith("-")] or [""]
+    top = a[0]
+    if top == "api":
+        flags = set(t for t in args if t.startswith("-"))
+        if any(f in flags for f in ("-X", "--method", "-f", "-F", "--field", "--raw-field", "--input")):
+            # explicit GET is fine
+            for k, t in enumerate(args):
+                if t in ("-X", "--method") and k + 1 < len(args) and args[k + 1].upper() == "GET":
+                    continue
+            if any(f in flags for f in ("-f", "-F", "--field", "--raw-field", "--input")):
+                return "write"
+            for k, t in enumerate(args):
+                if t in ("-X", "--method") and k + 1 < len(args) and args[k + 1].upper() != "GET":
+                    return "write"
+            return "read"
+        return "read"
+    if top in GH_READ_TOP:
+        verbs = GH_READ_TOP[top]
+        if verbs is None:
+            return "read"
+        return "read" if len(a) > 1 and a[1] in verbs else "write"
+    return "write"
+
+found = {"read": 0, "write": 0}
+found_rm = [False]
+found_sudo = [False]
+
+def scan(cmdline, depth=0):
+    if depth > 4:
+        return
+    try:
+        lexer = shlex.shlex(cmdline, posix=True, punctuation_chars=";&|()")
+        lexer.whitespace_split = True
+        lexer.commenters = ""
+        toks = list(lexer)
+    except Exception:
+        raise
+    # split into simple commands
+    groups, cur = [], []
+    for t in toks:
+        if t in SEPS or t in (";;", "&&", "||", "|&"):
+            if cur:
+                groups.append(cur)
+            cur = []
+        else:
+            # shlex keeps "$(git" / "`git" glued; split those too
+            for piece in re.split(r"(?:\$\(|`|<\(|>\()", t):
+                if piece:
+                    cur.append(piece)
+    if cur:
+        groups.append(cur)
+    for g in groups:
+        j = 0
+        # env assignments
+        while j < len(g) and re.match(r"^[A-Za-z_][A-Za-z0-9_]*=", g[j]):
+            j += 1
+        # wrappers
+        while j < len(g):
+            b = basename(g[j])
+            if b in WRAPPERS:
+                if b == "sudo" or b == "doas":
+                    found_sudo[0] = True
+                if b == "timeout" and j + 1 < len(g):
+                    j += 2; continue
+                if b == "env":
+                    j += 1
+                    while j < len(g) and re.match(r"^[A-Za-z_][A-Za-z0-9_]*=", g[j]):
+                        j += 1
+                    continue
+                j += 1
+                continue
+            break
+        if j >= len(g):
+            continue
+        head = basename(g[j])
+        args = g[j + 1:]
+        if head in SHELLS:
+            # bash -c "<string>" → recurse into the string
+            for k, t in enumerate(args):
+                if t in ("-c", "-lc", "-ic", "-ec", "-euc", "-exc") and k + 1 < len(args):
+                    scan(args[k + 1], depth + 1)
+            continue
+        if head == "eval":
+            scan(" ".join(args), depth + 1)
+            continue
+        if head in ("git", "git.exe"):
+            found[classify_git(args)] += 1
+        elif head in ("gh", "gh.exe"):
+            found[classify_gh(args)] += 1
+        elif head in ("rm", "rmdir", "unlink", "shred"):
+            found_rm[0] = True
+        elif head in ("find",) and ("-delete" in args or "-exec" in args and any(basename(x) == "rm" for x in args)):
+            found_rm[0] = True
+
+try:
+    scan(cmd)
+except Exception:
+    # unparsable (unbalanced quotes etc.) → conservative regex, as before
+    if re.search(r'(^|[^A-Za-z0-9_./@-])(git|gh)([^A-Za-z0-9_.-]|$)', cmd):
+        print("BLOCK_WRITE" if not yolo else "BLOCK_WRITE")
+    else:
+        print("ALLOW")
+    sys.exit(0)
+
+if found["write"]:
+    print("BLOCK_WRITE")
+elif found["read"] and (strict_git or not yolo):
+    print("BLOCK_READ")
+elif (found_rm[0] or found_sudo[0]) and not yolo:
+    print("ASK_RM")
+else:
+    print("ALLOW")
+PY
+)"
+
+case "$VERDICT" in
+  BLOCK_WRITE) block_git_msg; exit 2 ;;
+  BLOCK_READ)  block_read_msg; exit 2 ;;
+  ASK_RM)
+    # Claude Code: surface the owner's usual delete/sudo prompt (hook "ask"
+    # beats the bare "Bash" allow). OpenCode: its own `rm *: ask` map prompts.
+    printf '%s\n' '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"ask","permissionDecisionReason":"TechieFlow: delete/sudo asks unless YOLO is on (*yolo / tf-yolo.sh on)"}}'
+    exit 0 ;;
+  ALLOW|"")    exit 0 ;;
+  *)
+    # Unknown verdict text → original conservative behaviour.
+    if printf '%s' "$INPUT" | grep -qE '(^|[^[:alnum:]_./@-])(git|gh)([^[:alnum:]_.-]|$)'; then block_git_msg; exit 2; fi
+    exit 0 ;;
+esac