fix(toolkit): JSON-escape-aware command extract + repo-agnostic verify (DOJ-4872)

Round-4 bot review at 3/5 confidence flagged 1 P2 + 3 P3. All four addressed.

P2 — hooks/pre-tool-use-claim-verification.sh JSON command extractor
  - The jq-less fallback regex `"[^"]*"` stops at the first inner quote.
    For a bash command like `grep -rn \"Symbol\" src/`, the JSON envelope
    embeds it as `"command": "grep -rn \\\"Symbol\\\" src/"`, and the
    naive regex truncates at the first `\"`. Subsequent detector / suggester
    logic then sees a partial command and emits the wrong replacement.
  - Switched to the escape-aware JSON-string body
    `([^"\\]|\\.)*` which accepts any non-quote-non-backslash byte OR a
    backslash followed by any byte. Verified with an envelope containing
    `grep -rn \"Symbol\" src/` — the full command extracts cleanly and
    the suggester emits the right line.

P3 — hooks/pre-tool-use-claim-verification.sh cross-platform quote handling
  - The bot flagged that the explicit single-quoted-pattern grep extractor
    (added in round 3) used embedded-quote shell escaping that can drift
    between GNU and BSD grep. Simplified by removing the explicit single-
    quoted branch entirely: the awk fallback already strips both `"` and
    `'` from the extracted token, so it covers both quote styles without
    embedded escapes. Net code reduction; same behavior across the four
    smoke-tested variants (single/double quoted, single/multi flag).

P3 — commands/verify.md repo-agnostic grep path
  - The behavior section hardcoded `-- src/` as the path filter, which
    would fail with a `fatal: pathspec` error in toolkit consumers that
    have a different layout (`lib/`, `app/`, `packages/`, flat). Added a
    detect-or-fallback step: if `src/` exists on the resolved ref, use
    it as the path filter; otherwise pass no path filter and grep the
    whole tree.

P3 — commands/verify.md remote-only tag resolution
  - The normalization step probed `git rev-parse --verify refs/tags/<tag>`
    which only sees LOCAL tags. A remote-only tag (e.g. `v1.31.0` just
    pushed by a teammate but not yet fetched locally) would fall through
    to the bare-branch branch and resolve to a nonexistent
    `origin/v1.31.0`. Added a `git ls-remote --tags --exit-code origin
    refs/tags/<tag>` probe between the local-tag and SHA branches; on hit,
    runs `git fetch origin tag <tag> --quiet` before resolving. Comment
    documents the failure mode.

Verification:
  - shellcheck → 0 issues
  - JSON envelope with escaped quotes:
      `{"tool_input":{"command":"grep -rn \\\"Symbol\\\" src/"}}` →
      Command: `grep -rn "Symbol" src/`  (was: `grep -rn `)
      Suggested: `git grep "Symbol" origin/<branch> -- src/` (was: garbled)
  - "grep -rn 'Symbol' src/"       → Suggested: "Symbol"  (regression)
  - "grep -rn \"Symbol\" src/"       → Suggested: "Symbol"  (regression)
  - "grep -i -r \"Symbol\" src/"     → Suggested: "Symbol"  (regression)
  - "ls src/foo.tsx"               → Suggested: src/foo.tsx (regression)
  - "echo hello"                   → silent             (regression)

Created by Claude Code on behalf of @lapc506.

Author: lapc506

commands/verify.md

@@ -42,17 +42,25 @@ pipeline handles bare branch names, `origin/<branch>`, tags, and SHAs
 uniformly.
 
 1. **Normalize the ref.** Decide which fully-qualified ref to query, and
-   whether a remote fetch makes sense for that ref:
+   whether a remote fetch makes sense for that ref. Tag resolution probes
+   the remote via `git ls-remote` first so remote-only tags (not yet
+   fetched locally) don't fall through to the bare-branch branch and
+   resolve to a nonexistent `origin/<tag>`:
 
    ```bash
    RAW_REF="$1"
    FETCH_TARGET=""   # what to pass to `git fetch origin <…> --quiet`; empty = skip
    RESOLVED_REF=""   # what to pass to git show / ls-tree / grep
 
    if   git rev-parse --verify --quiet "refs/tags/$RAW_REF" >/dev/null; then
-     # Annotated/lightweight tag, e.g. v1.31.0
+     # Local annotated/lightweight tag, e.g. v1.31.0 (already fetched).
      RESOLVED_REF="refs/tags/$RAW_REF"
      FETCH_TARGET="tag $RAW_REF"
+   elif git ls-remote --tags --exit-code origin "refs/tags/$RAW_REF" >/dev/null 2>&1; then
+     # Remote-only tag — refresh it locally before resolving.
+     git fetch origin "tag $RAW_REF" --quiet
+     RESOLVED_REF="refs/tags/$RAW_REF"
+     FETCH_TARGET=""  # already fetched in the probe step
    elif [[ "$RAW_REF" =~ ^[0-9a-f]{7,40}$ ]] \
         && git cat-file -e "$RAW_REF" 2>/dev/null; then
      # Commit SHA (short or long) that already exists locally — no fetch.
@@ -100,12 +108,20 @@ uniformly.
      git show "$RESOLVED_REF:$ARG" | head -50
      ```
 
-   - Otherwise, treat it as a regex/pattern to grep across `src/`:
+   - Otherwise, treat it as a regex/pattern to grep across the repo. Use
+     `src/` as the path filter when it exists at the repo root; otherwise
+     grep the whole tree so the command stays repo-agnostic (toolkit
+     consumers may have `lib/`, `app/`, `packages/`, or a flat layout):
 
      ```bash
-     git grep -nF -- "$ARG" "$RESOLVED_REF" -- src/
+     if git ls-tree --name-only "$RESOLVED_REF" -- src 2>/dev/null | grep -q .; then
+       PATH_FILTER=(-- src/)
+     else
+       PATH_FILTER=()
+     fi
+     git grep -nF -- "$ARG" "$RESOLVED_REF" "${PATH_FILTER[@]}"
      # If the user passes a regex (contains regex metachars), drop -F:
-     git grep -nE -- "$ARG" "$RESOLVED_REF" -- src/
+     git grep -nE -- "$ARG" "$RESOLVED_REF" "${PATH_FILTER[@]}"
      ```
 
 6. **Emit a single verdict line** in this exact shape so it can be pasted

hooks/pre-tool-use-claim-verification.sh

@@ -76,9 +76,13 @@ esac
 
 # Fallback command extraction if jq is missing or input is shaped oddly.
 if [ -z "$COMMAND" ] && [ -n "$INPUT_RAW" ]; then
-  # Tolerant single-line extract — does not need jq.
+  # Tolerant single-line extract — does not need jq. Escape-aware: the
+  # `([^"\\]|\\.)*` body of the JSON string accepts any non-quote-non-
+  # backslash char, OR a backslash followed by any char (so embedded
+  # `\"` sequences inside a bash command like `grep -rn \"Symbol\" src/`
+  # don't truncate the extraction at the first inner quote).
   COMMAND="$(printf '%s' "$INPUT_RAW" \
-    | grep -oE '"command"[[:space:]]*:[[:space:]]*"[^"]*"' \
+    | grep -oE '"command"[[:space:]]*:[[:space:]]*"([^"\\]|\\.)*"' \
     | head -1 \
     | sed -E 's/^"command"[[:space:]]*:[[:space:]]*"(.*)"$/\1/')"
 fi
@@ -165,27 +169,17 @@ if printf '%s' "$COMMAND" | grep -qE '(^|[;&|][[:space:]]*)ls([[:space:]]|$)'; t
     SUGGESTED="git fetch origin <branch> --quiet && git ls-tree origin/<branch> -- <path>"
   fi
 elif printf '%s' "$COMMAND" | grep -qE 'grep[[:space:]]+-[rRnliN]+'; then
-  # First try the double-quoted form: `grep -rn "Symbol" src/`.
+  # Single extractor handles both quote styles + multi-flag forms.
+  # Nested awk loop: locate the `-FLAGS` token, then walk forward
+  # skipping additional flag tokens before emitting the first non-flag
+  # one. Strip both " and ' so the unquoted token comes out clean
+  # regardless of which quote style the original command used.
+  # Cross-platform note: no escaped quotes inside the shell quoting
+  # (the bot flagged literal-backslash drift between GNU and BSD grep
+  # implementations in round 4).
   pattern_arg="$(printf '%s' "$COMMAND" \
-    | grep -oE 'grep[[:space:]]+-[rRnliN]+[[:space:]]+"[^"]+"' \
-    | head -1 \
-    | sed -E 's/^grep[[:space:]]+-[rRnliN]+[[:space:]]+"(.+)"$/\1/')"
-  # Then the single-quoted form: `grep -rn 'Symbol' src/`.
-  if [ -z "$pattern_arg" ]; then
-    pattern_arg="$(printf '%s' "$COMMAND" \
-      | grep -oE "grep[[:space:]]+-[rRnliN]+[[:space:]]+'[^']+'" \
-      | head -1 \
-      | sed -E "s/^grep[[:space:]]+-[rRnliN]+[[:space:]]+'(.+)'$/\\1/")"
-  fi
-  if [ -z "$pattern_arg" ]; then
-    # Nested awk loop: skip subsequent flag tokens so multi-flag forms
-    # like `grep -i -r "Symbol" src/` don't mis-extract `-r` as the pattern.
-    # Strip both " and ' so unquoted-token output is clean regardless of
-    # whether the original command used double or single quotes.
-    pattern_arg="$(printf '%s' "$COMMAND" \
-      | awk '{for(i=1;i<=NF;i++) if ($i ~ /^-[rRnliN]+$/) {for(j=i+1;j<=NF;j++) if ($j !~ /^-/) {print $j; exit}}}' \
-      | tr -d "\"'")"
-  fi
+    | awk '{for(i=1;i<=NF;i++) if ($i ~ /^-[rRnliN]+$/) {for(j=i+1;j<=NF;j++) if ($j !~ /^-/) {print $j; exit}}}' \
+    | tr -d "\"'")"
   if [ -n "$pattern_arg" ]; then
     SUGGESTED="git fetch origin <branch> --quiet && git grep \"$pattern_arg\" origin/<branch> -- src/"
   else