fix(v2.0): address /code-review findings (7-angle high-effort, 40/42 survived → ~12 distinct)

CRITICAL:
- pre-commit gate was INVERTED: quality_score.py exits 2 on auto-fail (compile/syntax FAILURE) and 1 on score<80; the hook treated rc>=2 as a non-blocking "infra error", so an uncompilable deck sailed through while a 79/100 blocked. Now ANY nonzero rc blocks.

HIGH:
- git-guardrails bypassed by `git -C <dir>`/`git -c k=v` global options (patterns required git+subcommand adjacent) → added a global-options prefix; also catches `git add -- .` / `git add :/`. Verified: all bypass forms now DENY, safe forms (force-with-lease, commit, -C status) ALLOW.

MEDIUM:
- pre-compact + log-reminder classified plan status by WHOLE-FILE substring (APPROVED checked before DRAFT) → a DRAFT plan mentioning "APPROVED"/"COMPLETED" (a checklist item or the status legend) was mislabelled. Now parse the Status FIELD via regex.
- pre-compact DRAFT-block default reverted ON→OFF (opt-in): default-ON blocked the harness's AUTOMATIC compaction, which can strand a user at the context ceiling (post-compact-restore re-injects the plan anyway).
- statusline ctx-% path now mirrors context-monitor's CLAUDE_PROJECT_DIR-unset fallback (sessions/default/) exactly, instead of hashing the git toplevel.
- nightly-repro: date-only last_verified_on now treated as END-of-day, so a same-day file edit isn't flagged a false STALE drift.

Deferred (cleanup/altitude, no incorrect output): duplicated get_session_dir/passport helpers, redundant statusline subprocess spawns, the documented working-tree-on-partial-stage trade-off.

Author: pedrohcgs

.claude/hooks/git-guardrails.py

@@ -35,22 +35,29 @@
 import sys
 from pathlib import Path
 
+# Optional git GLOBAL options that can sit between `git` and the subcommand —
+# `git -C <dir>`, `git -c k=v`, `--git-dir=`, `--work-tree=`, `--no-pager`,
+# `--paginate`. Without this prefix, `git -C /repo reset --hard` (or `git -c x=y
+# clean -fd`) silently bypasses every guardrail.
+_GO = (r"(?:-C\s+\S+\s+|-c\s+\S+\s+|--git-dir(?:=\S+\s+|\s+\S+\s+)|"
+       r"--work-tree(?:=\S+\s+|\s+\S+\s+)|--no-pager\s+|--paginate\s+|-p\s+)*")
+
 # (compiled pattern, human reason, safe alternative)
 GIT_DENY = [
-    (re.compile(r"\bgit\s+reset\s+--hard\b"),
+    (re.compile(r"\bgit\s+" + _GO + r"reset\s+--hard\b"),
      "git reset --hard discards uncommitted work irrecoverably.",
      "Use `git stash` (recoverable) or reset specific paths."),
-    (re.compile(r"\bgit\s+clean\b.*(--force\b|(?<![\w-])-[a-z]*f)"),
+    (re.compile(r"\bgit\s+" + _GO + r"clean\b.*(--force\b|(?<![\w-])-[a-z]*f)"),
      "git clean -f/--force deletes UNTRACKED files — including data not yet committed.",
      "Inspect with `git clean -n` first; delete specific paths by hand."),
-    (re.compile(r"\bgit\s+push\b.*(--force(?![\w-])|(?<!-)\s-f\b)"),
+    (re.compile(r"\bgit\s+" + _GO + r"push\b.*(--force(?![\w-])|(?<!-)\s-f\b)"),
      "git push --force clobbers remote history.",
      "Use `git push --force-with-lease` if you truly must rewrite a branch."),
-    (re.compile(r"\bgit\s+add\s+(-A\b|--all\b|\.(?:\s|$))"),
-     "Blanket staging (git add -A / . ) can stage data, secrets, or settings.local.json. "
+    (re.compile(r"\bgit\s+" + _GO + r"add\s+(?:--\s+)?(-A\b|--all\b|\.(?:\s|$)|:/)"),
+     "Blanket staging (git add -A / . / -- . / :/) can stage data, secrets, or settings.local.json. "
      "The /commit skill forbids it.",
      "Stage specific files: `git add path/to/file ...`."),
-    (re.compile(r"\bgit\s+(checkout|restore)\s+(--\s+)?\.(?:\s|$)"),
+    (re.compile(r"\bgit\s+" + _GO + r"(checkout|restore)\s+(--\s+)?\.(?:\s|$)"),
      "Mass discard of working-tree changes is irreversible.",
      "Discard specific files, or `git stash` to keep them recoverable."),
 ]

.claude/hooks/log-reminder.py

@@ -35,6 +35,7 @@
 import os
 import sys
 import hashlib
+import re
 import subprocess
 from pathlib import Path
 from datetime import datetime
@@ -72,10 +73,15 @@ def active_plan(project_dir: str) -> str | None:
             text = p.read_text(encoding="utf-8", errors="replace")
         except Exception:
             continue
-        up = text.upper()
-        if "COMPLETED" in up and "STATUS" in up and "DRAFT" not in up and "APPROVED" not in up:
+        # Parse the Status FIELD, not a whole-file substring — a DRAFT plan that
+        # merely mentions "APPROVED"/"COMPLETED" must not be mis-labelled.
+        m = re.search(r"^\s*\**\s*status\s*\**\s*:\s*\**\s*"
+                      r"(draft|approved|completed|implemented|in[ -]?progress)",
+                      text, re.IGNORECASE | re.MULTILINE)
+        v = m.group(1).lower() if m else "in-progress"
+        if v.startswith(("completed", "implemented")):
             continue
-        status = "APPROVED" if "APPROVED" in up else ("DRAFT" if "DRAFT" in up else "in-progress")
+        status = "APPROVED" if v.startswith("approved") else ("DRAFT" if v.startswith("draft") else "in-progress")
         return f"{p.name} ({status})"
     return None
 

.claude/hooks/pre-compact.py

@@ -5,11 +5,13 @@
 Fires before context compaction to:
 1. Capture current state (active plan, current task, recent decisions)
    so post-compact-restore.py can surface it afterwards.
-2. Block compaction once when an active plan is still DRAFT, to avoid
-   losing mid-plan context before the user has approved it. ON by
-   default (v2.0); opt out via CLAUDE_PRECOMPACT_BLOCK_ON_DRAFT=0.
-   Blocks at most once per DRAFT plan, fail-open — a user can always
-   re-run compaction to proceed.
+2. OPTIONALLY block compaction once when an active plan is still DRAFT,
+   to avoid losing mid-plan context before approval. **Opt-in** via
+   CLAUDE_PRECOMPACT_BLOCK_ON_DRAFT=1 (default OFF — the v2.0 default-ON
+   flip was reverted: blocking the harness's *automatic* compaction can
+   strand a user at the context ceiling, and post-compact-restore.py
+   re-injects the plan afterward anyway). Blocks at most once per DRAFT
+   plan, fail-open.
 
 The blocking protocol follows modern Claude Code semantics:
   exit 0 + JSON {"decision": "block", "reason": "..."} on stdout.
@@ -61,16 +63,18 @@ def find_active_plan(project_dir: str) -> dict | None:
     for plan_file in plan_files[:3]:  # Check last 3 plans
         content = plan_file.read_text()
 
-        # Skip completed plans
-        if "COMPLETED" in content.upper():
-            continue
-
-        # Extract status
-        status = "in_progress"
-        if "APPROVED" in content.upper():
-            status = "approved"
-        elif "DRAFT" in content.upper():
-            status = "draft"
+        # Parse the plan's Status FIELD (e.g. "**Status:** DRAFT"), not a
+        # whole-file substring — a DRAFT plan whose body merely mentions
+        # "APPROVED" or "COMPLETED" (a checklist item, or the legend
+        # "Status (DRAFT/APPROVED/COMPLETED)") must not be mis-classified.
+        m = re.search(r"^\s*\**\s*status\s*\**\s*:\s*\**\s*"
+                      r"(draft|approved|completed|implemented|in[ -]?progress)",
+                      content, re.IGNORECASE | re.MULTILINE)
+        v = m.group(1).lower() if m else "in_progress"
+        if v.startswith(("completed", "implemented")):
+            continue  # skip finished plans
+        status = "approved" if v.startswith("approved") else (
+                 "draft" if v.startswith("draft") else "in_progress")
 
         # Find current task (first unchecked item)
         current_task = None
@@ -151,7 +155,7 @@ def should_block_draft(plan_info: dict | None) -> tuple[bool, str]:
     which would make this guard fire again on every subsequent
     compaction of the same DRAFT plan.
     """
-    if os.environ.get("CLAUDE_PRECOMPACT_BLOCK_ON_DRAFT", "1") != "1":
+    if os.environ.get("CLAUDE_PRECOMPACT_BLOCK_ON_DRAFT", "0") != "1":
         return False, ""
     if not plan_info or plan_info.get("status") != "draft":
         return False, ""

.claude/scripts/statusline.sh

@@ -64,11 +64,14 @@ fi
 # Context % — best-effort, persisted by context-monitor.py under the
 # session dir keyed by md5(project_dir)[:8].
 ctx=""
-# Hash the SAME key context-monitor.py writes under: CLAUDE_PROJECT_DIR if set,
-# else the git toplevel (the project root) — NOT the raw cwd, which differs in
-# a subdirectory and would point at the wrong sessions folder.
-proj="${CLAUDE_PROJECT_DIR:-$(git -C "$cwd" rev-parse --show-toplevel 2>/dev/null || printf '%s' "$cwd")}"
-hash="$(printf '%s' "$proj" | python3 -c 'import sys,hashlib; print(hashlib.md5(sys.stdin.read().encode()).hexdigest()[:8])' 2>/dev/null)"
+# Mirror context-monitor.py's get_session_dir() EXACTLY: CLAUDE_PROJECT_DIR set →
+# hash it; unset/empty → the writer falls back to sessions/default/, so do the same
+# (hashing the git toplevel here would point at the wrong folder on that path).
+if [ -n "${CLAUDE_PROJECT_DIR:-}" ]; then
+    hash="$(printf '%s' "$CLAUDE_PROJECT_DIR" | python3 -c 'import sys,hashlib; print(hashlib.md5(sys.stdin.read().encode()).hexdigest()[:8])' 2>/dev/null)"
+else
+    hash="default"
+fi
 pct_file="$HOME/.claude/sessions/${hash}/context-pct.txt"
 [ -f "$pct_file" ] && ctx="ctx $(cat "$pct_file" 2>/dev/null)%"
 set -e

.githooks/pre-commit

@@ -72,11 +72,12 @@ else
             [ -f "$f" ] || continue
             python3 scripts/quality_score.py "$f"
             rc=$?
-            if [ "$rc" -eq 1 ]; then
-                echo "✗ quality gate: '$f' scored below 80." >&2
+            # quality_score.py: rc 2 = auto-fail (compile/syntax FAILURE), rc 1 =
+            # score < 80 (or scorer error / file-not-found). BOTH must block — a
+            # file that fails to compile is the worst case, not an "infra error".
+            if [ "$rc" -ne 0 ]; then
+                echo "✗ quality gate: '$f' failed (rc=$rc — 2=compile/syntax failure, 1=score<80 or scorer error)." >&2
                 FAIL=1
-            elif [ "$rc" -ge 2 ]; then
-                echo "⚠ quality_score.py errored on '$f' (rc=$rc) — not blocking on infra error; review manually." >&2
             fi
         done <<< "$STAGED"
     else

scripts/nightly-repro-check.sh

@@ -26,9 +26,15 @@ if not pdir.is_dir():
     print("no quality_reports/passports/ — nothing to check"); sys.exit(0)
 
 def parse_iso(s):
-    s = s.strip().strip('"').strip("'").replace("Z", "+00:00")
-    try: return datetime.datetime.fromisoformat(s).timestamp()
-    except Exception: return None
+    s = s.strip().strip('"').strip("'")
+    date_only = ("T" not in s) and (":" not in s)   # e.g. "2026-06-01"
+    try:
+        dt = datetime.datetime.fromisoformat(s.replace("Z", "+00:00"))
+        if date_only:                                # treat as END of that day so a
+            dt = dt.replace(hour=23, minute=59, second=59)  # same-day edit isn't STALE
+        return dt.timestamp()
+    except Exception:
+        return None
 
 stale = []
 for pf in sorted(pdir.glob("*.yaml")):