crewforth 3.0.1 → 3.0.2

package/CHANGELOG.md

@@ -5,6 +5,29 @@ Crewforth was named Claude Starter Kit until 3.0.0.
 Notable changes to this project are recorded here. Format follows [Keep a Changelog](https://keepachangelog.com/en/),
 versioning follows [SemVer](https://semver.org/).
 
+## [3.0.2] — 2026-10-03
+
+### Security
+
+- **Under a Turkish system locale the gates missed what they are written to catch.** There `i` and `I` are not each
+  other's other case, and every case-insensitive match in the gates is written in ASCII. Measured under `tr_TR.UTF-8`
+  with GNU grep and bash 5 on Linux: `grep -i` did not find `INIT` with `init`, bash's `nocasematch` did not match
+  `GIT` against `git`, and a range like `[A-Za-z]` did not hold `i` or `I`, so a recursive `Remove-Item`, `git config
+  --remove-section core`, a read of a nested `.env`, a staged key and a vendor name in capitals all passed;
+  Crewforth's own suite, run whole under that locale, went from 2 failures to 23. In Git Bash on Windows `grep -iF`
+  aborted (exit 134) and the pre-commit scan for private strings read that as "no match". macOS folds the two letters
+  the ASCII way and was not affected. Every gate (`pre-commit`, `commit-msg`, `guard-commit-scan.sh`, `guard-bash.sh`,
+  `guard-write.sh`, `guard-powershell.sh`) now sets the C locale before it matches anything. A private string or a
+  pattern that holds a letter outside ASCII is still looked for under the session's own locale as well.
+- **A scan that could not run is no longer a clean scan.** In `pre-commit` and `commit-msg`, grep failing for any
+  reason but a pattern that does not compile stops the commit and says so; the private-string scan used to read every
+  failure as "no match", `commit-msg` read a broken pattern as one too, silently, and a staged diff that could not be
+  collected was scanned as an empty one. A pattern that does not compile still only warns, now in `commit-msg` as well.
+- **The approval prompt could carry invalid UTF-8.** The command it shows is cut to 300 a line with `cut -c`, and GNU
+  cut counts bytes in every locale: a two-byte letter across byte 300 left the prompt's JSON invalid (measured on
+  Linux under `en_US.UTF-8`, and on macOS under the C locale; Git Bash ships GNU cut too, not measured there). The cut
+  steps back over an unfinished letter now.
+
 ## [3.0.1] — 2026-10-01
 
 ### Security

package/VERSION

@@ -1 +1 @@
-3.0.1
+3.0.2

package/kit/eval/smoke-test.sh

@@ -2,6 +2,12 @@
 # Kit smoke-test: structural validation (without running Claude Code).
 # Usage: bash .claude/eval/smoke-test.sh   (from the repo root or from inside .claude/eval)
 set -uo pipefail
+# The suite measures in the C locale, whatever the session's is. Its own patterns are ASCII, and under a Turkish
+# locale a range like [a-z] does not hold `i`: run whole under tr_TR.UTF-8 on Linux, assertions failed for that
+# reason alone (`skill-trust.sh` read as `ll-trust.sh`), and one more because start.sh answers in Turkish there,
+# which is its design. A measurement that depends on who runs it is not one. The gates are handed a Turkish locale
+# on purpose in section 12e.
+export LC_ALL=C
 HERE="$(cd "$(dirname "$0")" && pwd)"
 ROOT="$(cd "$HERE/.." && pwd)"       # .claude/
 AGENTS="$ROOT/agents"; SKILLS="$ROOT/skills"; HOOKS="$ROOT/hooks"
@@ -1347,6 +1353,8 @@ _blk_gate(){   # $1 = marker name, $2 = what the block is, in words
 }
 _blk_gate CREW-TRANSCRIPT-DIR "the duplicated transcript-dir resolver"
 _blk_gate CREW-JSON-PARSE     "the duplicated JSON parser"
+_blk_gate CREW-LOCALE         "the locale block every gate matches under"
+_blk_gate CREW-SCAN           "the scan that tells 'could not look' from 'nothing there'"
 # End to end: called by hand from this repo, the hook must produce a reading rather than "transcript not found".
 cu_hand="$(cd "$ROOT/.." && bash "$HOOKS/context-usage.sh" 2>&1)"
 # The three arms used to be pass / note / note, and `note` touches no counter — so on any machine without a
@@ -6406,6 +6414,159 @@ for _c in "rm /Users/u/.claude/plugins/cache/acme/tool/1.0/hooks/x.sh" "diff $PG
 done
 [ -z "$PGF$_pgok" ] && pass "plugin gate files: $PGN writes, deletes, renames and links refused (this version, another cached version, ~/\$HOME/glob/..//. spellings, Windows spellings, a root outside the cache, the sourced crew-env.sh, Write tool); each negative twin — reading, running board.sh, a source tree, another plugin — stays free" \
                     || fail "plugin gate files:$PGF${_pgok:+ | wrongly refused:$_pgok}"
+if [ "$UNITS" = 1 ]; then
+sec "== 12e) the gates answer the same under a Turkish locale: there i and I are not each other's other case =="
+# Under tr_TR.UTF-8 the partners are i/İ and ı/I. Every case-insensitive match in the gates is written in ASCII, so
+# with the locale left as the session had it: GNU grep -i did not find INIT with `init`, bash's nocasematch did not
+# match GIT against git, [A-Za-z] did not hold I, and in Git Bash `grep -iF` aborted (exit 134) and the
+# private-string scan read that as "no match". macOS folds i and I the ASCII way under tr_TR, so there the locale
+# rows below cannot fail whatever the gates do — the line says which kind of platform it ran on.
+# Every gate now sets LC_ALL=C before it matches anything (the CREW-LOCALE block).
+_thq="'"; _thbad=""; _thn=0
+for _h in pre-commit commit-msg guard-commit-scan.sh guard-bash.sh guard-write.sh guard-powershell.sh; do
+  _thn=$((_thn+1))
+  # the first line of code after `set -…` is the block: nothing matches before the locale is set
+  _n="$(LC_ALL=C awk '/^[[:space:]]*(#|$)/{next} /^set -/{next} {print; exit}' "$HOOKS/$_h")"
+  [ "$_n" = '_CREW_LOCALE="${LC_ALL:-${LC_CTYPE:-${LANG:-}}}"' ] && grep -q '^export LC_ALL=C$' "$HOOKS/$_h" || _thbad="$_thbad $_h"
+done
+[ -z "$_thbad" ] && pass "all $_thn gates set the C locale before their first line of matching (pre-commit, commit-msg, guard-commit-scan, guard-bash, guard-write, guard-powershell)" \
+                 || fail "a gate matches before it sets the C locale, or does not set it:$_thbad"
+
+# A scan that could not run is not a clean scan. grep is shadowed by one that aborts for -iF (what Git Bash's grep does
+# under a Turkish locale), for -iE, and for the grep that collects the added lines. Runs on every platform.
+_TH="$(mktemp -d)"; _TH="$(cd -P "$_TH" && pwd)"
+_th_repo(){  # $1 = directory -> a repository with the two git hooks beside their lists, nothing staged
+  rm -rf "$1"; mkdir -p "$1"
+  ( cd "$1" && git init -q && git config user.email t@example.com && git config user.name t \
+    && cp "$HOOKS/pre-commit" "$HOOKS/commit-msg" "$HOOKS/trace-blocklist.txt" "$HOOKS/secret-blocklist.txt" "$HOOKS/floor-blocklist.txt" . ) >/dev/null 2>&1; }
+# $1 = repository, $2 = hook, $3 = locale or empty, $4 = a directory to put first on PATH or empty, $5 = the hook's argument -> _thr, output in $_TH/out
+_th_hook(){ ( cd "$1" && env ${3:+LC_ALL=$3} ${4:+PATH="$4:$PATH"} bash "./$2" ${5:+"$5"} ) > "$_TH/out" 2>&1; _thr=$?; }
+_thg="$(command -v grep)"
+mkdir -p "$_TH/bin" "$_TH/bin2" "$_TH/bin3"
+printf '#!/bin/sh\ncase " $* " in *" -qiF "*) kill -ABRT $$ ;; esac\nexec "%s" "$@"\n' "$_thg" > "$_TH/bin/grep"
+printf '#!/bin/sh\ncase " $* " in *" -qiE "*) kill -ABRT $$ ;; esac\nexec "%s" "$@"\n' "$_thg" > "$_TH/bin2/grep"
+printf '#!/bin/sh\n[ "$1" = -E ] && [ "$2" = "^\\+" ] && kill -ABRT $$\nexec "%s" "$@"\n' "$_thg" > "$_TH/bin3/grep"
+chmod +x "$_TH/bin/grep" "$_TH/bin2/grep" "$_TH/bin3/grep"
+_th_repo "$_TH/r"
+printf 'acme-internal-host\n' > "$_TH/r/.private-terms.txt"
+( cd "$_TH/r" && printf 'see ACME-INTERNAL-HOST for the dump\n' > notes.md && git add notes.md ) >/dev/null 2>&1
+_thbad=""
+_th_hook "$_TH/r" pre-commit ""; { [ "$_thr" = 1 ] && grep -q 'PRIVATE-PATH SCANNER: a staged line contains' "$_TH/out"; } \
+  || _thbad="$_thbad [FIXTURE: with a working grep the private string is not reported: rc=$_thr]"
+_th_hook "$_TH/r" pre-commit "" "$_TH/bin"; { [ "$_thr" = 1 ] && grep -q 'could not run' "$_TH/out"; } \
+  || _thbad="$_thbad [grep aborting for -iF: rc=$_thr, want 1 and 'could not run' — $(sed -n 1p "$_TH/out" | cut -c1-120)]"
+_th_repo "$_TH/e"; ( cd "$_TH/e" && printf 'an ordinary line\n' > a.txt && git add a.txt && printf 'docs: an ordinary message\n' > msg.txt ) >/dev/null 2>&1
+_th_hook "$_TH/e" pre-commit "" "$_TH/bin2"; { [ "$_thr" = 1 ] && grep -q 'TRACE-SCANNER: the look for .* could not run' "$_TH/out"; } \
+  || _thbad="$_thbad [pre-commit, grep aborting for -iE: rc=$_thr, want 1 and 'could not run' — $(sed -n 1p "$_TH/out" | cut -c1-120)]"
+_th_hook "$_TH/e" commit-msg "" "$_TH/bin2" msg.txt; { [ "$_thr" = 1 ] && grep -q 'could not run' "$_TH/out"; } \
+  || _thbad="$_thbad [commit-msg, grep aborting for -iE: rc=$_thr, want 1 and 'could not run' — $(sed -n 1p "$_TH/out" | cut -c1-120)]"
+_th_hook "$_TH/r" pre-commit "" "$_TH/bin3"; { [ "$_thr" = 1 ] && grep -q 'the staged diff could not be read' "$_TH/out"; } \
+  || _thbad="$_thbad [pre-commit, the grep that collects the added lines aborting: rc=$_thr, want 1 and 'could not be read' — $(sed -n 1p "$_TH/out" | cut -c1-120)]"
+# a pattern that does not compile is a typo, not a failed look: it warns, in both git hooks, and the commit goes on
+_th_repo "$_TH/b"; printf 'unclosed[\n' >> "$_TH/b/trace-blocklist.txt"
+( cd "$_TH/b" && printf 'an ordinary line\n' > a.txt && git add a.txt && printf 'docs: an ordinary message\n' > msg.txt ) >/dev/null 2>&1
+_th_hook "$_TH/b" pre-commit ""; { [ "$_thr" = 0 ] && grep -q 'is not a valid regular expression' "$_TH/out"; } \
+  || _thbad="$_thbad [pre-commit with a pattern that does not compile: rc=$_thr, want 0 and the warning]"
+_th_hook "$_TH/b" commit-msg "" "" msg.txt; { [ "$_thr" = 0 ] && grep -q 'is not a valid regular expression' "$_TH/out"; } \
+  || _thbad="$_thbad [commit-msg with a pattern that does not compile: rc=$_thr, want 0 and the warning]"
+[ -z "$_thbad" ] && pass "a scan that could not run stops the commit: with grep aborting for -iF (what Git Bash's grep does under a Turkish locale) or for -iE, or while the added lines are collected, pre-commit and commit-msg exit 1 and say so; a pattern that does not compile still only warns, in both" \
+                 || fail "a scan that could not run:$_thbad"
+
+# guard-bash under a locale: $1 = locale or empty, $2 = tool, $3 = command as JSON text, $4 = mode -> _thr, stdout in $_TH/gb.out
+_th_gb(){ printf '{"tool_name":"%s","permission_mode":"%s","cwd":"%s","tool_input":{"command":"%s"}}' "$2" "${4:-auto}" "$_TH/w" "$3" > "$_TH/pl.json"
+  ( cd "$_TH/w" && CREW_GATE_LOG=/dev/null env -u CLAUDE_GIT_OK ${1:+LC_ALL=$1} bash "$HOOKS/guard-bash.sh" < "$_TH/pl.json" > "$_TH/gb.out" 2>"$_TH/gb.err" ); _thr=$?; }
+# a repository with one change staged and a review record that matches it, so a plain commit reaches the prompt
+rm -rf "$_TH/w"; mkdir -p "$_TH/w"
+( cd "$_TH/w" && git init -q && git config user.email t@example.com && git config user.name t && mkdir -p .claude \
+  && echo one > a.txt && git add a.txt && git -c core.hooksPath=/dev/null commit -qm init && echo two >> a.txt && git add a.txt \
+  && printf '{"diff_oid":"%s","head":"%s"}\n' "$(git diff --cached | git hash-object --stdin)" "$(git rev-parse HEAD)" > .claude/review-pass.json ) >/dev/null 2>&1
+
+# The command shown in the approval prompt is cut to 300 bytes a line and goes into JSON. `cut -c` did it: GNU cut
+# counts bytes in every locale, so a two-byte letter across byte 300 left the JSON invalid UTF-8 (measured on Linux
+# under en_US.UTF-8). The cut steps back over an unfinished letter now, in any locale.
+_thutf=""; for _l in en_US.UTF-8 C.UTF-8 C.utf8; do
+  [ "$(LC_ALL=$_l bash -c 'x=ş; printf %s "${#x}"' 2>/dev/null)" = 1 ] && { _thutf="$_l"; break; }
+done
+if ! command -v iconv >/dev/null 2>&1; then skip tool "the approval prompt's text is never cut inside a letter (no iconv to check UTF-8 with)"
+else
+  _thbad=""
+  for _l in "" ${_thutf:+"$_thutf"}; do
+    # `git commit -m '` is 15 bytes; 284 a's bring it to 299, so byte 300 is the first half of the first ş
+    _tha="$(printf '%*s' 284 '' | tr ' ' a)"; _th_gb "$_l" Bash "git commit -m ${_thq}${_tha}şşşşşşşşşş${_thq}" default
+    { [ "$(gdec "$(cat "$_TH/gb.out")")" = ask ] && iconv -f UTF-8 -t UTF-8 < "$_TH/gb.out" >/dev/null 2>&1 && grep -q 'a…' "$_TH/gb.out"; } \
+      || _thbad="$_thbad [locale '${_l:-C}', a cut that falls inside a letter: rc=$_thr, valid UTF-8: $(iconv -f UTF-8 -t UTF-8 < "$_TH/gb.out" >/dev/null 2>&1 && echo yes || echo NO)]"
+    # a three-byte letter with two of its bytes before the cut: 283 a's, then € across bytes 299-301
+    _tha="$(printf '%*s' 283 '' | tr ' ' a)"; _th_gb "$_l" Bash "git commit -m ${_thq}${_tha}€€€€${_thq}" default
+    { [ "$(gdec "$(cat "$_TH/gb.out")")" = ask ] && iconv -f UTF-8 -t UTF-8 < "$_TH/gb.out" >/dev/null 2>&1 && grep -q 'a…' "$_TH/gb.out"; } \
+      || _thbad="$_thbad [locale '${_l:-C}', a cut two bytes into a three-byte letter: rc=$_thr, valid UTF-8: $(iconv -f UTF-8 -t UTF-8 < "$_TH/gb.out" >/dev/null 2>&1 && echo yes || echo NO)]"
+    # exactly 300 bytes: shown whole, no ellipsis
+    _tha="$(printf '%*s' 264 '' | tr ' ' a)"; _th_gb "$_l" Bash "git commit -m ${_thq}şşşşşşşşşş${_tha}${_thq}" default
+    { [ "$(gdec "$(cat "$_TH/gb.out")")" = ask ] && ! grep -q "a${_thq}…" "$_TH/gb.out" && grep -q "şa" "$_TH/gb.out"; } \
+      || _thbad="$_thbad [locale '${_l:-C}', a command of exactly 300 bytes: rc=$_thr, want it whole and no ellipsis]"
+  done
+  [ -z "$_thbad" ] && pass "the command in the approval prompt is cut at 300 bytes a line and never inside a letter, under C${_thutf:+ and $_thutf}: the JSON stays UTF-8, and 300 bytes exactly are shown whole" \
+                   || fail "the approval prompt's text:$_thbad"
+fi
+
+# The locale itself, where this machine has one.
+_th=""; for _l in tr_TR.UTF-8 tr_TR.utf8 az_AZ.UTF-8 az_AZ.utf8; do
+  [ "$(LC_ALL=$_l bash -c 'x=ş; printf %s "${#x}"' 2>/dev/null)" = 1 ] && { _th="$_l"; break; }
+done
+if [ -z "$_th" ]; then
+  skip platform "the gates under a Turkish locale (this machine has no tr_TR.UTF-8 or az_AZ.UTF-8)" 2
+else
+  # What plain matching does under it here: this is what says whether the rows below can fail on this platform.
+  _thc="$(LC_ALL=$_th bash -c 'shopt -s nocasematch; [[ GIT == git ]] && printf folds || printf "does not fold"' 2>/dev/null)"
+  # in a subshell: where grep aborts, the shell that waits for it reports the job ("Aborted"), and that line is
+  # not grep's stderr, so a redirection on the pipeline does not silence it
+  _thx=0; ( printf 'INIT\n' | LC_ALL=$_th grep -qiF init ) >/dev/null 2>&1 || _thx=$?
+  _thkind="here plain bash $_thc I to i and grep -iF exits $_thx for INIT/init"
+  case "$_thc/$_thx" in folds/0) _thkind="$_thkind, so these rows cannot fail on this platform" ;; esac
+  # (1) guard-bash: each of these gave another verdict under the locale before the block
+  THT='2 @@ PowerShell @@ Remove-Item -Recurse -Force C:\\\\proj\\\\*
+2 @@ Bash @@ git config --remove-section core
+2 @@ Bash @@ git config --rename-section core x
+2 @@ Bash @@ cat config/.env.production
+2 @@ Bash @@ cat ~/.ssh/ID_RSA
+0 @@ Bash @@ cat ~/.ssh/id_rsa.pub
+0 @@ Bash @@ cat ~/.ssh/id_rsa.pub | ssh-keygen -lf -
+0 @@ Bash @@ ls -la'
+  _thbad=""; _thn=0
+  while IFS= read -r _cl; do [ -z "$_cl" ] && continue
+    _cw="${_cl%% @@ *}"; _cc="${_cl#* @@ }"; _ct="${_cc%% @@ *}"; _cc="${_cc#* @@ }"; _thn=$((_thn+1))
+    _th_gb "$_th" "$_ct" "$_cc"; _thl="$_thr"; _th_gb "" "$_ct" "$_cc"
+    { [ "$_thl" = "$_cw" ] && [ "$_thr" = "$_cw" ]; } || _thbad="$_thbad [$_ct: $_cc → $_thl under $_th, $_thr under C, want $_cw]"
+  done <<< "$THT"
+  if [ "$_thn" != 8 ]; then fail "FIXTURE: the gate table under $_th ran $_thn rows, not 8"
+  elif [ -z "$_thbad" ]; then pass "under $_th guard-bash gives the verdicts it gives under C: 8 rows (a recursive Remove-Item, core.hooksPath removed or renamed away, a nested .env, ID_RSA by case refused; id_rsa.pub, alone and piped, and ls allowed) — $_thkind"
+  else fail "verdicts that change under $_th:$_thbad"; fi
+  # (2) the two git hooks
+  _thbad=""
+  _th_repo "$_TH/t"
+  ( cd "$_TH/t" && printf 'notes generated by %s\n' 'COPI''LOT' > t.md && git add t.md ) >/dev/null 2>&1
+  _th_hook "$_TH/t" pre-commit "$_th"; { [ "$_thr" = 1 ] && grep -q 'TRACE-SCANNER' "$_TH/out"; } || _thbad="$_thbad [pre-commit, a vendor name in capitals in an added line: rc=$_thr, want 1]"
+  _th_repo "$_TH/s"
+  ( cd "$_TH/s" && printf 'aws_key = AKIA%s\n' 'IOSFODNN7EXAMPLE' > leak.txt && git add leak.txt ) >/dev/null 2>&1
+  _th_hook "$_TH/s" pre-commit "$_th"; { [ "$_thr" = 1 ] && grep -q 'SECRET-SCANNER' "$_TH/out"; } || _thbad="$_thbad [pre-commit, a staged key that holds an I: rc=$_thr, want 1]"
+  _th_hook "$_TH/r" pre-commit "$_th"; { [ "$_thr" = 1 ] && grep -q 'PRIVATE-PATH SCANNER: a staged line contains' "$_TH/out"; } || _thbad="$_thbad [pre-commit, a private string in another case: rc=$_thr, want 1 — $(sed -n 1p "$_TH/out" | cut -c1-100)]"
+  _th_hook "$_TH/e" pre-commit "$_th"; [ "$_thr" = 0 ] || _thbad="$_thbad [pre-commit, an ordinary line: rc=$_thr, want 0]"
+  ( cd "$_TH/t" && printf 'docs: notes\n\nWritten with %s\n' 'COPI''LOT' > msg.txt ) >/dev/null 2>&1
+  _th_hook "$_TH/t" commit-msg "$_th" "" msg.txt; [ "$_thr" = 1 ] || _thbad="$_thbad [commit-msg, a vendor name in capitals in the message: rc=$_thr, want 1]"
+  _th_hook "$_TH/e" commit-msg "$_th" "" msg.txt;  [ "$_thr" = 0 ] || _thbad="$_thbad [commit-msg, an ordinary message: rc=$_thr, want 0]"
+  # a letter outside ASCII keeps its other case: the second look, under the session's locale
+  _th_repo "$_TH/n"; printf 'şirket-gizli\n' > "$_TH/n/.private-terms.txt"
+  ( cd "$_TH/n" && printf 'see ŞİRKET-GİZLİ\n' > n.md && git add n.md ) >/dev/null 2>&1
+  _th_hook "$_TH/n" pre-commit "$_th"; _thna="$_thr"
+  # required where this platform's grep folds such a letter under the locale at all (GNU grep does, BSD grep does not)
+  if ( printf 'ŞİRKET\n' | LC_ALL=$_th grep -qiF 'şirket' ) >/dev/null 2>&1; then
+    [ "$_thna" = 1 ] || _thbad="$_thbad [pre-commit, a private string of non-ASCII letters in another case: rc=$_thna, want 1 (this grep folds them under $_th)]"
+  fi
+  [ -z "$_thbad" ] && pass "under $_th the git hooks stop what they stop under C: a vendor name in another case in an added line and in the message, a staged key that holds an I, a private string in another case; an ordinary line and message pass (a private string of non-ASCII letters in another case: exit $_thna, 1 = caught by the second look)" \
+                   || fail "the git hooks under $_th:$_thbad"
+fi
+rm -rf "$_TH"
+fi   # UNITS
+
 sec "== 13) pre-commit cost — the gate people route around is the one that is slow =="
 # Measured on a 373-file merge: the old file loop spawned ~7 processes per file (three `printf | grep` pairs and
 # a `git cat-file`), 2,643 in total. At the 62-135 ms a Git Bash process was measured to cost on a Windows 11

package/kit/hooks/commit-msg

@@ -4,6 +4,49 @@
 #  (2) team board claim gate — a commit that names an item must be backed by a live claim held by YOU.
 # Skipping either requires an explicit request per §4.5 (git commit --no-verify).
 set -euo pipefail
+# ---- CREW-LOCALE -----------------------------------------------------------------------------------------
+# Everything this gate matches with runs in the C locale, whatever the session's own is. Under a Turkish locale
+# the letters i and I are not each other's other case (their partners are İ and ı), and every case-insensitive
+# match here is written in ASCII. Measured under tr_TR.UTF-8 with the locale left as it came:
+#   GNU grep 3.11 / bash 5.2 on Linux: `grep -i init` does not find INIT (-F, -E and plain alike);
+#     bash's nocasematch does not match GIT against git; `[A-Za-z]` in a regex does not hold I; awk's tolower
+#     turns GIT into gıt. The suite, run whole under that locale, went from 2 failures to 23: a recursive
+#     Remove-Item, a write to a gate file, `git config --remove-section core`, a read of a nested .env and a
+#     staged key all passed.
+#   GNU grep 3.0 in Git Bash on Windows: `grep -iF` with an ASCII pattern aborts (exit 134), and the pre-commit
+#     scan for private strings read that as "no match".
+#   macOS (BSD grep, bash 3.2): none of it; tr_TR.UTF-8 folds i and I the ASCII way there.
+# The cost: a letter outside ASCII has no other case in the C locale. The two git hooks that scan a user's own
+# words look a second time under the session's locale for a pattern that holds such a letter (_CREW_LOCALE).
+# Byte-identical in every gate; the suite pins it.
+_CREW_LOCALE="${LC_ALL:-${LC_CTYPE:-${LANG:-}}}"
+case "$_CREW_LOCALE" in C|POSIX) _CREW_LOCALE="" ;; esac
+export LC_ALL=C
+# ---- /CREW-LOCALE
+# ---- CREW-SCAN -------------------------------------------------------------------------------------------
+# One scan of one file for one pattern, with "could not look" kept apart from "nothing there". grep exits 1 for
+# no match and 2 or more when it could not answer: a pattern that does not compile, a file it could not read, or
+# grep itself dying (exit 134 for `grep -iF` under a Turkish locale in Git Bash, measured). Read as "no match",
+# that is a scan that passes whatever it was shown.
+#   0  a match          1  no match
+#   2  the pattern does not compile (grep says exactly 2, and says it again for empty input) - the caller warns:
+#      a typo in a hand-edited list must not lock every commit, and the other patterns still ran
+#   3  could not look   - the caller stops the commit
+# A pattern that holds a letter outside ASCII is looked for a second time under the session's own locale when
+# the first look finds nothing and the match ignores case: in the C locale such a letter has no other case.
+_crew_scan(){  # $1 = grep's flags after -q (iE, E, iF) · $2 = pattern · $3 = file
+  local r=0
+  grep -q"$1" -- "$2" "$3" 2>/dev/null || r=$?
+  if [ "$r" = 1 ] && [ -n "$_CREW_LOCALE" ]; then
+    case "$1" in *i*) case "$2" in *[!$'\t'\ -~]*) r=0; LC_ALL="$_CREW_LOCALE" grep -q"$1" -- "$2" "$3" 2>/dev/null || r=$? ;; esac ;; esac
+  fi
+  [ "$r" -ge 2 ] || return "$r"
+  case "$1" in *F*) return 3 ;; esac
+  r=0; grep -q"$1" -- "$2" /dev/null 2>/dev/null || r=$?
+  [ "$r" != 2 ] || return 2
+  return 3
+}
+# ---- /CREW-SCAN
 HERE="$(cd "$(dirname "$0")" && pwd)"
 BL="$HERE/trace-blocklist.txt"
 MSG_FILE="${1:-}"
@@ -36,9 +79,15 @@ while IFS= read -r pat || [ -n "$pat" ]; do
                                             # project, Git for Windows defaults core.autocrlf=true,
                                             # and this file is meant to be edited by hand.
   if [ -n "$AL" ] && grep -qxF -- "$pat" "$AL"; then continue; fi
-  if grep -iqE -- "$pat" "$MSG_FILE"; then
+  _gr=0; _crew_scan iE "$pat" "$MSG_FILE" || _gr=$?
+  if [ "$_gr" = 0 ]; then
     echo "TRACE-SCANNER (message): forbidden expression -> '$pat' (§4.1)"
     HIT=1
+  elif [ "$_gr" = 2 ]; then
+    echo "TRACE-SCANNER (message): /$pat/ in $BL is not a valid regular expression, so it matches NOTHING. Every other pattern still ran; fix or remove this line."
+  elif [ "$_gr" -ge 3 ]; then
+    echo "TRACE-SCANNER (message): the look for '$pat' could not run, so the message is not known to be clean and the commit is stopped (§4.1)."
+    HIT=1
   fi
 done < "$BL"
 

package/kit/hooks/guard-bash.sh

@@ -39,6 +39,25 @@
 # CLAUDE_GIT_OK=1, exported by the user before the session starts, pre-authorises the session. It exists for
 # headless/CI runs where no one is at the keyboard. It does NOT replace approval: present the message first.
 set -uo pipefail
+# ---- CREW-LOCALE -----------------------------------------------------------------------------------------
+# Everything this gate matches with runs in the C locale, whatever the session's own is. Under a Turkish locale
+# the letters i and I are not each other's other case (their partners are İ and ı), and every case-insensitive
+# match here is written in ASCII. Measured under tr_TR.UTF-8 with the locale left as it came:
+#   GNU grep 3.11 / bash 5.2 on Linux: `grep -i init` does not find INIT (-F, -E and plain alike);
+#     bash's nocasematch does not match GIT against git; `[A-Za-z]` in a regex does not hold I; awk's tolower
+#     turns GIT into gıt. The suite, run whole under that locale, went from 2 failures to 23: a recursive
+#     Remove-Item, a write to a gate file, `git config --remove-section core`, a read of a nested .env and a
+#     staged key all passed.
+#   GNU grep 3.0 in Git Bash on Windows: `grep -iF` with an ASCII pattern aborts (exit 134), and the pre-commit
+#     scan for private strings read that as "no match".
+#   macOS (BSD grep, bash 3.2): none of it; tr_TR.UTF-8 folds i and I the ASCII way there.
+# The cost: a letter outside ASCII has no other case in the C locale. The two git hooks that scan a user's own
+# words look a second time under the session's locale for a pattern that holds such a letter (_CREW_LOCALE).
+# Byte-identical in every gate; the suite pins it.
+_CREW_LOCALE="${LC_ALL:-${LC_CTYPE:-${LANG:-}}}"
+case "$_CREW_LOCALE" in C|POSIX) _CREW_LOCALE="" ;; esac
+export LC_ALL=C
+# ---- /CREW-LOCALE
 # The 2.x names of the variables a user can set still work (one helper: eval/lib/crew-env.sh).
 _crew_d="${BASH_SOURCE%/*}"; [ "$_crew_d" = "${BASH_SOURCE}" ] && _crew_d=.
 [ -f "$_crew_d/../eval/lib/crew-env.sh" ] && . "$_crew_d/../eval/lib/crew-env.sh"; unset _crew_d
@@ -1221,6 +1240,25 @@ case "$CMD" in *[Rr][Mm]*) : ;; *) false ;; esac && echo "$CMD" | grep -qE '(rm|
 #   - fold a surviving tab to a space (display-only text; the command Claude runs is untouched);
 #   - escape backslash and double quote;
 #   - fold newlines to the two-character \n escape.
+# Each line of a text cut to at most N bytes, never inside a letter. This is the command as the approval prompt
+# shows it, and it goes into JSON. `cut -c1-300` did this job: GNU cut counts BYTES whatever the locale (measured on
+# Linux under en_US.UTF-8: a two-byte letter across byte 300 left the prompt's JSON invalid UTF-8), and BSD cut
+# counts characters only while the session's locale says so. Here the cut is by bytes and then steps back over an
+# unfinished letter: a UTF-8 letter is one lead byte (0xC0 and up) followed by continuation bytes (0x80-0xBF).
+_utf8_cut(){  # $1 = text, $2 = bytes per line -> _UC
+  local LC_ALL=C
+  local l out="" nl=""
+  while IFS= read -r l || [ -n "$l" ]; do
+    if [ "${#l}" -gt "$2" ]; then
+      l="${l:0:$2}"
+      while :; do case "$l" in *[$'\x80'-$'\xbf']) l="${l%?}" ;; *) break ;; esac; done
+      case "$l" in *[$'\xc0'-$'\xff']) l="${l%?}" ;; esac
+    fi
+    out="$out$nl$l"; nl=$'\n'
+  done <<< "$1"
+  while :; do case "$out" in *$'\n') out="${out%?}" ;; *) break ;; esac; done
+  _UC="$out"
+}
 json_escape(){
   printf '%s' "$1" \
     | tr -d '\000-\010\013-\037\177' \
@@ -1560,7 +1598,7 @@ if git_has "$CMD" 'commit|push'; then
     default|acceptEdits)
       # A prompt provably reaches the user in these modes: ask, and let them approve in one keypress.
       SHORT="$CMD"
-      [ "${#SHORT}" -gt 300 ] && SHORT="$(printf '%s' "$SHORT" | cut -c1-300)…"
+      [ "${#SHORT}" -gt 300 ] && { _utf8_cut "$SHORT" 300; SHORT="$_UC…"; }
       # §4.4 branch guard: committing straight onto main/master is not blocked (a fresh project legitimately
       # lives on main), but it is surfaced in the approval prompt so the user can send it to a branch instead.
       BRANCH_WARN=""

package/kit/hooks/guard-commit-scan.sh

@@ -19,6 +19,25 @@
 # Deliberately NOT covered: `--no-verify`. It is §4.5 and `guard-bash.sh` blocks it outright, so it never
 # reaches this hook.
 set -uo pipefail
+# ---- CREW-LOCALE -----------------------------------------------------------------------------------------
+# Everything this gate matches with runs in the C locale, whatever the session's own is. Under a Turkish locale
+# the letters i and I are not each other's other case (their partners are İ and ı), and every case-insensitive
+# match here is written in ASCII. Measured under tr_TR.UTF-8 with the locale left as it came:
+#   GNU grep 3.11 / bash 5.2 on Linux: `grep -i init` does not find INIT (-F, -E and plain alike);
+#     bash's nocasematch does not match GIT against git; `[A-Za-z]` in a regex does not hold I; awk's tolower
+#     turns GIT into gıt. The suite, run whole under that locale, went from 2 failures to 23: a recursive
+#     Remove-Item, a write to a gate file, `git config --remove-section core`, a read of a nested .env and a
+#     staged key all passed.
+#   GNU grep 3.0 in Git Bash on Windows: `grep -iF` with an ASCII pattern aborts (exit 134), and the pre-commit
+#     scan for private strings read that as "no match".
+#   macOS (BSD grep, bash 3.2): none of it; tr_TR.UTF-8 folds i and I the ASCII way there.
+# The cost: a letter outside ASCII has no other case in the C locale. The two git hooks that scan a user's own
+# words look a second time under the session's locale for a pattern that holds such a letter (_CREW_LOCALE).
+# Byte-identical in every gate; the suite pins it.
+_CREW_LOCALE="${LC_ALL:-${LC_CTYPE:-${LANG:-}}}"
+case "$_CREW_LOCALE" in C|POSIX) _CREW_LOCALE="" ;; esac
+export LC_ALL=C
+# ---- /CREW-LOCALE
 DIR="$(cd "$(dirname "$0")" && pwd)"
 
 # ---- CREW-JSON-PARSE ------------------------------------------------------------------------------------

package/kit/hooks/guard-powershell.sh

@@ -18,6 +18,25 @@
 # Wired ONLY on the PowerShell matcher (both editions; smoke pins it). On `Bash` it would block the very commands it
 # points to.
 set -uo pipefail
+# ---- CREW-LOCALE -----------------------------------------------------------------------------------------
+# Everything this gate matches with runs in the C locale, whatever the session's own is. Under a Turkish locale
+# the letters i and I are not each other's other case (their partners are İ and ı), and every case-insensitive
+# match here is written in ASCII. Measured under tr_TR.UTF-8 with the locale left as it came:
+#   GNU grep 3.11 / bash 5.2 on Linux: `grep -i init` does not find INIT (-F, -E and plain alike);
+#     bash's nocasematch does not match GIT against git; `[A-Za-z]` in a regex does not hold I; awk's tolower
+#     turns GIT into gıt. The suite, run whole under that locale, went from 2 failures to 23: a recursive
+#     Remove-Item, a write to a gate file, `git config --remove-section core`, a read of a nested .env and a
+#     staged key all passed.
+#   GNU grep 3.0 in Git Bash on Windows: `grep -iF` with an ASCII pattern aborts (exit 134), and the pre-commit
+#     scan for private strings read that as "no match".
+#   macOS (BSD grep, bash 3.2): none of it; tr_TR.UTF-8 folds i and I the ASCII way there.
+# The cost: a letter outside ASCII has no other case in the C locale. The two git hooks that scan a user's own
+# words look a second time under the session's locale for a pattern that holds such a letter (_CREW_LOCALE).
+# Byte-identical in every gate; the suite pins it.
+_CREW_LOCALE="${LC_ALL:-${LC_CTYPE:-${LANG:-}}}"
+case "$_CREW_LOCALE" in C|POSIX) _CREW_LOCALE="" ;; esac
+export LC_ALL=C
+# ---- /CREW-LOCALE
 # Read with the builtin: `INPUT="$(cat)"` is a subshell plus a process on EVERY PowerShell call, and on Git Bash a
 # process costs 62-135 ms. With this, a command that cannot match (no `bash` in the payload) opens no process at all
 # (measured with the xtrace counter: `cat` 1 -> 0). `read` returns 1 at end of input; the text is read regardless.

package/kit/hooks/guard-write.sh

@@ -30,6 +30,25 @@
 # Normalise first, match second — and normalise with parameter expansion only, because this hook runs before
 # EVERY Write/Edit and a fork per call is a freeze on Windows (Git Bash charges 62-135 ms per process, measured).
 set -uo pipefail
+# ---- CREW-LOCALE -----------------------------------------------------------------------------------------
+# Everything this gate matches with runs in the C locale, whatever the session's own is. Under a Turkish locale
+# the letters i and I are not each other's other case (their partners are İ and ı), and every case-insensitive
+# match here is written in ASCII. Measured under tr_TR.UTF-8 with the locale left as it came:
+#   GNU grep 3.11 / bash 5.2 on Linux: `grep -i init` does not find INIT (-F, -E and plain alike);
+#     bash's nocasematch does not match GIT against git; `[A-Za-z]` in a regex does not hold I; awk's tolower
+#     turns GIT into gıt. The suite, run whole under that locale, went from 2 failures to 23: a recursive
+#     Remove-Item, a write to a gate file, `git config --remove-section core`, a read of a nested .env and a
+#     staged key all passed.
+#   GNU grep 3.0 in Git Bash on Windows: `grep -iF` with an ASCII pattern aborts (exit 134), and the pre-commit
+#     scan for private strings read that as "no match".
+#   macOS (BSD grep, bash 3.2): none of it; tr_TR.UTF-8 folds i and I the ASCII way there.
+# The cost: a letter outside ASCII has no other case in the C locale. The two git hooks that scan a user's own
+# words look a second time under the session's locale for a pattern that holds such a letter (_CREW_LOCALE).
+# Byte-identical in every gate; the suite pins it.
+_CREW_LOCALE="${LC_ALL:-${LC_CTYPE:-${LANG:-}}}"
+case "$_CREW_LOCALE" in C|POSIX) _CREW_LOCALE="" ;; esac
+export LC_ALL=C
+# ---- /CREW-LOCALE
 # The 2.x names of the variables a user can set still work (one helper: eval/lib/crew-env.sh).
 _crew_d="${BASH_SOURCE%/*}"; [ "$_crew_d" = "${BASH_SOURCE}" ] && _crew_d=.
 [ -f "$_crew_d/../eval/lib/crew-env.sh" ] && . "$_crew_d/../eval/lib/crew-env.sh"; unset _crew_d

package/kit/hooks/pre-commit

@@ -5,6 +5,59 @@
 #  (3) private-path scanner  — this machine's $HOME + .private-terms.txt (§4.3)
 # Skipping requires an explicit request per §4.5 (git commit --no-verify).
 set -euo pipefail
+# ---- CREW-LOCALE -----------------------------------------------------------------------------------------
+# Everything this gate matches with runs in the C locale, whatever the session's own is. Under a Turkish locale
+# the letters i and I are not each other's other case (their partners are İ and ı), and every case-insensitive
+# match here is written in ASCII. Measured under tr_TR.UTF-8 with the locale left as it came:
+#   GNU grep 3.11 / bash 5.2 on Linux: `grep -i init` does not find INIT (-F, -E and plain alike);
+#     bash's nocasematch does not match GIT against git; `[A-Za-z]` in a regex does not hold I; awk's tolower
+#     turns GIT into gıt. The suite, run whole under that locale, went from 2 failures to 23: a recursive
+#     Remove-Item, a write to a gate file, `git config --remove-section core`, a read of a nested .env and a
+#     staged key all passed.
+#   GNU grep 3.0 in Git Bash on Windows: `grep -iF` with an ASCII pattern aborts (exit 134), and the pre-commit
+#     scan for private strings read that as "no match".
+#   macOS (BSD grep, bash 3.2): none of it; tr_TR.UTF-8 folds i and I the ASCII way there.
+# The cost: a letter outside ASCII has no other case in the C locale. The two git hooks that scan a user's own
+# words look a second time under the session's locale for a pattern that holds such a letter (_CREW_LOCALE).
+# Byte-identical in every gate; the suite pins it.
+_CREW_LOCALE="${LC_ALL:-${LC_CTYPE:-${LANG:-}}}"
+case "$_CREW_LOCALE" in C|POSIX) _CREW_LOCALE="" ;; esac
+export LC_ALL=C
+# ---- /CREW-LOCALE
+# ---- CREW-SCAN -------------------------------------------------------------------------------------------
+# One scan of one file for one pattern, with "could not look" kept apart from "nothing there". grep exits 1 for
+# no match and 2 or more when it could not answer: a pattern that does not compile, a file it could not read, or
+# grep itself dying (exit 134 for `grep -iF` under a Turkish locale in Git Bash, measured). Read as "no match",
+# that is a scan that passes whatever it was shown.
+#   0  a match          1  no match
+#   2  the pattern does not compile (grep says exactly 2, and says it again for empty input) - the caller warns:
+#      a typo in a hand-edited list must not lock every commit, and the other patterns still ran
+#   3  could not look   - the caller stops the commit
+# A pattern that holds a letter outside ASCII is looked for a second time under the session's own locale when
+# the first look finds nothing and the match ignores case: in the C locale such a letter has no other case.
+_crew_scan(){  # $1 = grep's flags after -q (iE, E, iF) · $2 = pattern · $3 = file
+  local r=0
+  grep -q"$1" -- "$2" "$3" 2>/dev/null || r=$?
+  if [ "$r" = 1 ] && [ -n "$_CREW_LOCALE" ]; then
+    case "$1" in *i*) case "$2" in *[!$'\t'\ -~]*) r=0; LC_ALL="$_CREW_LOCALE" grep -q"$1" -- "$2" "$3" 2>/dev/null || r=$? ;; esac ;; esac
+  fi
+  [ "$r" -ge 2 ] || return "$r"
+  case "$1" in *F*) return 3 ;; esac
+  r=0; grep -q"$1" -- "$2" /dev/null 2>/dev/null || r=$?
+  [ "$r" != 2 ] || return 2
+  return 3
+}
+# ---- /CREW-SCAN
+_crew_looked(){  # $1 = what a pipeline collects for the scans · the rest = the exit status of each of its commands
+  # Every status, not the pipeline's own: with pipefail that is the LAST command that failed, and the last grep
+  # exits 1 whenever nothing reaches it - which is exactly what an abort further up leaves behind.
+  local what="$1" r; shift
+  for r in "$@"; do
+    [ "$r" -lt 2 ] && continue
+    echo "PRE-COMMIT: $what could not be read (exit $r), so nothing was scanned and the commit is stopped."
+    exit 1
+  done
+}
 # The 2.x names of the variables a user can set still work (one helper: eval/lib/crew-env.sh).
 _crew_d="${BASH_SOURCE%/*}"; [ "$_crew_d" = "${BASH_SOURCE}" ] && _crew_d=.
 [ -f "$_crew_d/../eval/lib/crew-env.sh" ] && . "$_crew_d/../eval/lib/crew-env.sh"; unset _crew_d
@@ -47,7 +100,7 @@ trap '_crew_cleanup; exit 143' INT TERM
 git diff --cached --unified=0 -- . \
   ':(top,exclude,glob)**/trace-blocklist.txt' ':(top,exclude,glob)**/secret-blocklist.txt' \
   ':(top,exclude)trace-blocklist.txt' ':(top,exclude)secret-blocklist.txt' \
-  | grep -E '^\+' | grep -Ev '^\+\+\+' > "$SECRET_F" || true
+  | grep -E '^\+' | grep -Ev '^\+\+\+' > "$SECRET_F" || _crew_looked "the staged diff" "${PIPESTATUS[@]}"
 
 # Traces (§4.1/§4.2) are scanned in the PROJECT's own files only. `.claude/` is Crewforth's tree: it configures the
 # assistant, it legitimately names the tool it configures, and an update overwrites it — it is not an artifact the
@@ -56,7 +109,7 @@ git diff --cached --unified=0 -- . \
 # falls under .claude/, but in Crewforth's own repo it sits at kit/hooks/ where that exclusion misses it.
 git diff --cached --unified=0 -- . ':(top,exclude).claude' \
   ':(top,exclude,glob)**/trace-blocklist.txt' ':(top,exclude)trace-blocklist.txt' \
-  | grep -E '^\+' | grep -Ev '^\+\+\+' > "$TRACE_F" || true
+  | grep -E '^\+' | grep -Ev '^\+\+\+' > "$TRACE_F" || _crew_looked "the staged diff" "${PIPESTATUS[@]}"
 
 # `git commit -a` stages tracked changes as part of the commit. As a git hook that is invisible — git stages
 # first, so --cached already contains them by the time this runs. Called AHEAD of the commit (the plugin
@@ -67,10 +120,10 @@ if [ "${CREW_SCAN_UNSTAGED:-0}" = 1 ]; then
   git diff --unified=0 -- . \
     ':(top,exclude,glob)**/trace-blocklist.txt' ':(top,exclude,glob)**/secret-blocklist.txt' \
     ':(top,exclude)trace-blocklist.txt' ':(top,exclude)secret-blocklist.txt' \
-    | grep -E '^\+' | grep -Ev '^\+\+\+' >> "$SECRET_F" || true
+    | grep -E '^\+' | grep -Ev '^\+\+\+' >> "$SECRET_F" || _crew_looked "the unstaged diff" "${PIPESTATUS[@]}"
   git diff --unified=0 -- . ':(top,exclude).claude' \
     ':(top,exclude,glob)**/trace-blocklist.txt' ':(top,exclude)trace-blocklist.txt' \
-    | grep -E '^\+' | grep -Ev '^\+\+\+' >> "$TRACE_F" || true
+    | grep -E '^\+' | grep -Ev '^\+\+\+' >> "$TRACE_F" || _crew_looked "the unstaged diff" "${PIPESTATUS[@]}"
 fi
 
 HIT=0
@@ -300,16 +353,21 @@ done < <({ _floor_diff --cached; [ "${CREW_SCAN_UNSTAGED:-0}" = 1 ] && _floor_di
 # secrets newly passed. Also checked structurally: no pattern in either shipped blocklist carries a bare
 # top-level `|` (every one is inside a group) and none uses a back-reference, so joining cannot reshape them.
 _crew_any(){   # $1 = pattern list  $2 = corpus  $3 = grep flags  $4 = 1 for newline-joined fixed strings
-  local pat alt="" sep="|"
+  local pat alt="" sep="|" na=0 r=0
   [ "$4" = 1 ] && sep="
 "
   while IFS= read -r pat || [ -n "$pat" ]; do
     pat="${pat%$'\r'}"
     case "$pat" in ''|\#*) continue;; esac
     alt="${alt:+$alt$sep}$pat"
+    case "$pat" in *[!$'\t'\ -~]*) na=1 ;; esac
   done < "$1"
   [ -n "$alt" ] || return 1
-  grep -q$3 -- "$alt" "$2" 2>/dev/null
+  grep -q$3 -- "$alt" "$2" 2>/dev/null || r=$?
+  # Nothing found, but a pattern holds a letter outside ASCII and the match ignores case: the per-pattern loop looks
+  # again under the session's own locale (_crew_scan), so send the caller there.
+  if [ "$r" = 1 ] && [ "$na" = 1 ] && [ -n "$_CREW_LOCALE" ]; then case "$3" in *i*) return 4 ;; esac; fi
+  return "$r"
 }
 # (1) trace scan — case-INsensitive (vendor / AI-authorship strings), project files only
 # `!= 1` AND NOT `= 0`, AND THE DIFFERENCE IS THE WHOLE GATE. _crew_any joins every pattern into ONE
@@ -345,12 +403,15 @@ if [ -f "$BL" ] && [ -s "$TRACE_F" ] && [ "$_dec" != 1 ]; then
     # `|| _gr=$?` and not a bare call: `set -e` is in force at the top of this file, and a grep that simply
     # does not match exits 1, which would kill the hook on the first clean pattern. Measured the wrong way once
     # already -- the bare form made every commit exit 1 with no output at all.
-    _gr=0; grep -iqE -- "$pat" "$TRACE_F" 2>/dev/null || _gr=$?
+    _gr=0; _crew_scan iE "$pat" "$TRACE_F" || _gr=$?
     if [ "$_gr" = 0 ]; then
       echo "TRACE-SCANNER: forbidden expression in added code -> '$pat' (§4.1/§4.2)"
       HIT=1
-    elif [ "$_gr" -ge 2 ]; then
+    elif [ "$_gr" = 2 ]; then
       echo "TRACE-SCANNER: /$pat/ in $BL is not a valid regular expression, so it matches NOTHING. Every other pattern still ran; fix or remove this line."
+    elif [ "$_gr" -ge 3 ]; then
+      echo "TRACE-SCANNER: the look for '$pat' could not run, so the added lines are not known to be clean and the commit is stopped (§4.1/§4.2)."
+      HIT=1
     fi
   done < "$BL"
 fi
@@ -361,11 +422,14 @@ if [ -f "$SL" ] && [ -s "$SECRET_F" ] && [ "$_dec" != 1 ]; then
     pat="${pat%$'\r'}"                       # tolerate a CRLF blocklist (Windows/autocrlf checkout)
     case "$pat" in ''|\#*) continue;; esac
     if [ -n "$SAL" ] && grep -qxF -- "$pat" "$SAL"; then continue; fi
-    _gr=0; grep -qE -- "$pat" "$SECRET_F" 2>/dev/null || _gr=$?
+    _gr=0; _crew_scan E "$pat" "$SECRET_F" || _gr=$?
     if [ "$_gr" = 0 ]; then
       echo "SECRET-SCANNER: a staged line matches a secret pattern -> /$pat/"
       HIT=1
-    elif [ "$_gr" -ge 2 ]; then
+    elif [ "$_gr" -ge 3 ]; then
+      echo "SECRET-SCANNER: the look for /$pat/ could not run, so the staged lines are not known to be clean and the commit is stopped."
+      HIT=1
+    elif [ "$_gr" = 2 ]; then
       # Same reasoning as the trace loop above; the comment there is the long form.
       echo "SECRET-SCANNER: /$pat/ in $SL is not a valid regular expression, so it matches NOTHING. Every other pattern still ran; fix or remove this line."
     fi
@@ -411,11 +475,17 @@ if [ -s "$PTERM_F" ] && [ -s "$SECRET_F" ] && [ "$_dec" != 1 ]; then
     term="${term%$'\r'}"
     [ -n "$term" ] || continue
     if [ -n "$PAL" ] && grep -qxF -- "$term" "$PAL"; then continue; fi
-    if grep -qiF -- "$term" "$SECRET_F"; then
+    _gr=0; _crew_scan iF "$term" "$SECRET_F" || _gr=$?
+    if [ "$_gr" = 0 ]; then
       # The term is echoed back deliberately: unlike a secret, the author has to see WHICH private string to
       # replace, and it is already sitting in their own working tree.
       echo "PRIVATE-PATH SCANNER: a staged line contains a machine-private string -> '$term' (§4.3)"
       HIT=1
+    elif [ "$_gr" -ge 2 ]; then
+      # This loop used to read every exit status but 0 as "no match": under a Turkish locale in Git Bash grep -iF
+      # aborted (134) for each term and the commit went through with both private strings in it (measured).
+      echo "PRIVATE-PATH SCANNER: the look for a machine-private string could not run, so the staged lines are not known to be clean and the commit is stopped (§4.3)."
+      HIT=1
     fi
   done < "$PTERM_F"
 fi
@@ -535,7 +605,14 @@ EOF_FLOOR_CAND2
       esac
       _gr=0; hits="$(grep -nE -- "$pat" "$FLOOR_F" 2>/dev/null)" || _gr=$?
       if [ "$_gr" -ge 2 ]; then
-        echo "FLOOR-GUARD: /$pat/ in $FL is not a valid regular expression, so it matches NOTHING. Every other pattern still ran; fix or remove this line."
+        # Does the pattern compile? Tried against empty input: 1 = it does, so it was the look that failed.
+        _gv=0; grep -qE -- "$pat" /dev/null 2>/dev/null || _gv=$?
+        if [ "$_gv" = 2 ]; then
+          echo "FLOOR-GUARD: /$pat/ in $FL is not a valid regular expression, so it matches NOTHING. Every other pattern still ran; fix or remove this line."
+        else
+          echo "FLOOR-GUARD: the look for /$pat/ could not run, so the staged lines are not known to be clean and the commit is stopped."
+          HIT=1
+        fi
         continue
       fi
       [ -n "$hits" ] || continue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewforth",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Crewforth \u2014 your engineering crew for Claude Code: agents, skills and tool-level gates, in any stack.",
   "bin": {
     "crewforth": "bin/cli.js"