fix(plugin): the hooks need no jq and no tac (#4107)

Every hook opened `command -v jq >/dev/null 2>&1 || exit 0`, so on a machine
without jq the operator got no session context, no rules, no prior art and no
process sync — and not one word saying why, because `exit 0` is
indistinguishable from "ran fine, nothing to say". jq is absent by default on
macOS, on the Debian/Ubuntu slim images, on Alpine and in most CI containers.
That is not a prerequisite to document; it is the plugin handing its own
packaging problem to whoever installs it.

`tac` was worse: GNU-only, so the prior-art hook's enclosing-definition arm
did nothing at all on every Mac, silently, from the day it shipped. It is not
replaced but removed — scribe_defs judges each line independently, so
extracting forward and taking `tail -1` is the same answer as reversing and
taking the head, and it drops the early-exit `head` that #4042 was filed for.

No server contract changed, so a lagging plugin cache keeps working.

  scribe_json.awk   JSON -> IDX<TAB>PATH<TAB>VALUE. Two modes: `whole` for an
                    event or a response body, `lines` for a transcript, where
                    an unparseable record is dropped and the rest still read —
                    the `map(try fromjson catch empty)` the jq program opened
                    with. Arrays also report their LENGTH at `[#]`, which is
                    what keeps "zero notes" distinct from "no answer" (#2932).
  scribe_turn.awk   the turn-bounding program, replacing the thirty lines of
                    jq in the Stop hook.
  scribe_defs.sh    scribe_json_flat / _pick / _list / _len / _list_minus read,
                    scribe_json_out writes the envelope (five copies of one
                    shape, gone), scribe_urlenc replaces `jq -sRr '@uri'`.

Percent-encoding goes through `od -tu1` rather than an awk character loop on
purpose: awk's idea of a character follows the locale, so gawk reads an
accented letter as one and mawk as two, and an encoder built on substr() would
emit a different URL depending on which awk is installed. Encoding is defined
on bytes. Verified byte-identical to `jq -sRr '@uri'`.

Measured, not assumed. The per-event path costs 8ms against jq's 3ms. The
transcript path was 70x slower until two fixes: the Stop hook now finds where
the turn starts with a fixed-string grep before parsing (a needle carrying
unescaped quotes cannot occur inside a JSON string, so it matches only at a
record's top level — checked against a full JSON parse of a 27MB transcript:
152 prompt records, 152 matches, no misses, no extras), and the parser reads
each token out of a 1024-byte window instead of copying the rest of the buffer
per token, which was quadratic in line length on the 400KB tool results a
transcript carries.

Differential-tested against the jq program it replaces over 724 windows cut
from three real transcripts — 724 identical, 0 mismatched, 45 of them
exercising a real task close and a real reply. That sweep is what caught
`scribe_turn.awk` never setting FS, which truncated every multi-word reply at
its first space and was invisible to a test whose replies were all empty.

check_plugin.py's `jq -R` lint becomes a guard against either binary coming
back, and three smoke checks lose their `shutil.which("jq")` skip. jq is not
in `ci-python` either, so those three announced a skip on every CI run and had
never once run there: removing the dependency from the product also closed a
permanent hole in its verification. They pass now across all ten hooks.

tests/test_hook_json_reader.py is a differential against Python's `json` over
nested objects, arrays, unicode, escapes, control characters, empty cases and
a value longer than the token window, plus the envelope, the encoder and the
turn analyzer. 139 cases.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01821k5B3Ysecp9fNYs92Kuy

plugin/hooks/scribe_prior_art.sh

@@ -33,29 +33,34 @@
 #   SCRIBE_URL / SCRIBE_TOKEN override for the settings.json dogfooding path.
 set -uo pipefail
 
-command -v jq   >/dev/null 2>&1 || exit 0
 command -v curl >/dev/null 2>&1 || exit 0
 
+# Shared with the after-write hook (#2901): the prose/data skip list, the
+# definition extractor and the local by-name duplicate arm live in
+# scribe_defs.sh so the two hooks cannot drift apart. Sourced FIRST because the
+# JSON reader is there too now (#4107).
+# shellcheck source=plugin/hooks/scribe_defs.sh
+. "$(dirname "${BASH_SOURCE[0]}")/scribe_defs.sh"
+
 # PreToolUse delivers { session_id, cwd, tool_name, tool_input: {...}, ... }
+# One parse, five fields. `.tool_input.content` on a Write is the entire file
+# being written, so parsing per field would mean reading it five times.
 event=$(cat 2>/dev/null || true)
-file_path=$(printf '%s' "$event" | jq -r '.tool_input.file_path // empty' 2>/dev/null) || exit 0
-session_id=$(printf '%s' "$event" | jq -r '.session_id // empty' 2>/dev/null) || session_id=""
-event_cwd=$(printf '%s' "$event" | jq -r '.cwd // empty' 2>/dev/null) || event_cwd=""
+event_flat=$(printf '%s' "$event" | scribe_json_flat)
+file_path=$(scribe_json_pick "$event_flat" '.tool_input.file_path')
+session_id=$(scribe_json_pick "$event_flat" '.session_id')
+event_cwd=$(scribe_json_pick "$event_flat" '.cwd')
 
 [ -n "$file_path" ] || exit 0
 
 # The code about to be written. Write and Edit name this field differently, and
 # the names have changed across Claude Code versions — take whichever is present
 # rather than betting on one shape.
-code=$(printf '%s' "$event" | jq -r '
-  .tool_input.content // .tool_input.file_content //
-  .tool_input.new_string // .tool_input.new_str // empty' 2>/dev/null) || code=""
+code=$(scribe_json_pick "$event_flat" '.tool_input.content')
+[ -n "$code" ] || code=$(scribe_json_pick "$event_flat" '.tool_input.file_content')
+[ -n "$code" ] || code=$(scribe_json_pick "$event_flat" '.tool_input.new_string')
+[ -n "$code" ] || code=$(scribe_json_pick "$event_flat" '.tool_input.new_str')
 
-# Shared with the after-write hook (#2901): the prose/data skip list, the
-# definition extractor and the local by-name duplicate arm live in
-# scribe_defs.sh so the two hooks cannot drift apart.
-# shellcheck source=plugin/hooks/scribe_defs.sh
-. "$(dirname "${BASH_SOURCE[0]}")/scribe_defs.sh"
 scribe_skip_path "$file_path" && exit 0
 
 # Snippet locations are recorded repo-relative, so send a repo-relative path —
@@ -102,15 +107,24 @@ fi
 # no pulled canon in play, nothing is recorded. Titles only still — this sends
 # names, not bodies.
 # ---------------------------------------------------------------------------
+#
+# THE ENCLOSING DEFINITION IS THE LAST ONE AT OR ABOVE THE EDIT, and taking it
+# needs no `tac`. This read `head -n $ln | tac | scribe_defs | head -1` — reverse
+# the lines, extract, take the first. `tac` is GNU-only: it is absent on macOS
+# (whose equivalent is `tail -r`), so the guard below it meant this arm did
+# nothing at all on every Mac, silently, since the day it shipped. scribe_defs
+# judges each line independently, so reversing first and taking the head is the
+# same answer as extracting forward and taking the tail — and `tail` also drops
+# the `head -1` whose early exit is the SIGPIPE trap #4042 was filed for.
 shapes="$names"
-if [ -z "$shapes" ] && [ -f "$file_path" ] && command -v tac >/dev/null 2>&1; then
-  old_first=$(printf '%s' "$event" \
-    | jq -r '.tool_input.old_string // .tool_input.old_str // empty' 2>/dev/null \
-    | grep -m1 -v '^[[:space:]]*$' || true)
+if [ -z "$shapes" ] && [ -f "$file_path" ]; then
+  old_first=$(scribe_json_pick "$event_flat" '.tool_input.old_string')
+  [ -n "$old_first" ] || old_first=$(scribe_json_pick "$event_flat" '.tool_input.old_str')
+  old_first=$(printf '%s' "$old_first" | grep -m1 -v '^[[:space:]]*$' || true)
   if [ -n "$old_first" ]; then
     ln=$(grep -nF -m1 -- "$old_first" "$file_path" 2>/dev/null | cut -d: -f1) || ln=""
     if [ -n "$ln" ]; then
-      shapes=$(head -n "$ln" "$file_path" | tac | scribe_defs | head -1 || true)
+      shapes=$(head -n "$ln" "$file_path" | scribe_defs | tail -1 || true)
     fi
   fi
 fi
@@ -118,7 +132,7 @@ shapes_q=""
 if [ -n "$shapes" ]; then
   enc=$(printf '%s\n' "$shapes" \
     | awk -F'\t' 'NF>=2 {printf "%s%s:%s", (n++?",":""), $1, $2}' \
-    | jq -sRr '@uri' 2>/dev/null) || enc=""
+    | scribe_urlenc) || enc=""
   [ -n "$enc" ] && shapes_q="&shapes=${enc}"
 fi
 
@@ -127,8 +141,7 @@ scribe_config || :   # sets url/token; unconfigured is handled just below
 # arm above already ran and may have something to say.
 if [ -z "$url" ] || [ -z "$token" ]; then
   if [ -n "$local_context" ]; then
-    jq -n --arg c "$local_context" \
-      '{hookSpecificOutput: {hookEventName: "PreToolUse", additionalContext: $c}}'
+    scribe_json_out PreToolUse "$local_context"
   fi
   exit 0
 fi
@@ -142,13 +155,15 @@ fi
 # built a URL from the whole payload. head -c caps the total, which is the point.
 q=$(printf '%s' "$code" | head -c 1200)
 
-# `-sRr`, not `-rR`: jq -R reads input LINE BY LINE, so a multi-line payload came
-# back as several separately-encoded lines joined by raw newlines — an invalid
-# URL that made curl fail, and this hook then exited 0 in silence. -s slurps the
-# whole input into one string first. Newlines are exactly what code contains, so
-# this hook could never have worked without it (issue #2198 / #2082).
-path_enc=$(printf '%s' "$rel_path" | jq -sRr '@uri' 2>/dev/null) || exit 0
-code_enc=$(printf '%s' "$q" | jq -sRr '@uri' 2>/dev/null) || code_enc=""
+# Encoded whole, never line by line. The predecessor (`jq -rR`) read input LINE
+# BY LINE, so a multi-line payload came back as several separately-encoded lines
+# joined by raw newlines — an invalid URL that made curl fail, and this hook then
+# exited 0 in silence. Newlines are exactly what code contains, so this hook
+# could never have worked that way (issue #2198 / #2082). scribe_urlenc reads
+# bytes and has no notion of a line.
+path_enc=$(printf '%s' "$rel_path" | scribe_urlenc)
+[ -n "$path_enc" ] || exit 0
+code_enc=$(printf '%s' "$q" | scribe_urlenc)
 
 # Scope to this directory's project — a `.scribe` marker, else the git remote.
 scope=$(scribe_scope_query "$lookup_dir")
@@ -199,7 +214,7 @@ if [ -n "$session_id" ]; then
     [ -n "$sync_seen" ] && sync_exclude_q="&exclude_sync_ids=${sync_seen}"
   fi
   if [ -f "$derivefile" ]; then
-    derive_seen=$(tr '\n' ',' < "$derivefile" 2>/dev/null | sed 's/,$//' | jq -sRr '@uri' 2>/dev/null) || derive_seen=""
+    derive_seen=$(tr '\n' ',' < "$derivefile" 2>/dev/null | sed 's/,$//' | scribe_urlenc) || derive_seen=""
     [ -n "$derive_seen" ] && derive_exclude_q="&exclude_derive=${derive_seen}"
   fi
   # Ageing, not a flat read (#3751), and the ONLY ledger here that ages: the
@@ -227,24 +242,25 @@ else
 fi
 
 context=""
+body_flat=""
 if [ -n "$body" ]; then
-  context=$(printf '%s' "$body" | jq -r '.context // empty' 2>/dev/null) || context=""
+  body_flat=$(printf '%s' "$body" | scribe_json_flat)
+  context=$(scribe_json_pick "$body_flat" '.context')
   # Remember what was surfaced so it isn't shown again this session — each
   # class into its own channel: sync ids (snippets recording the edited file)
   # to the sync file, everything else to the reuse file.
   if [ -n "$context" ]; then
     if [ -n "$idfile" ]; then
-      printf '%s' "$body" | jq -r '((.note_ids // []) - (.sync_note_ids // []))[]?' 2>/dev/null >> "$idfile" || true
+      scribe_json_list_minus "$body_flat" '.note_ids' '.sync_note_ids' >> "$idfile" || true
     fi
     if [ -n "$syncfile" ]; then
-      printf '%s' "$body" | jq -r '(.sync_note_ids // [])[]?' 2>/dev/null >> "$syncfile" || true
+      scribe_json_list "$body_flat" '.sync_note_ids' >> "$syncfile" || true
     fi
     if [ -n "$rulefile" ]; then
-      printf '%s' "$body" | jq -r '(.rule_ids // [])[]?' 2>/dev/null \
-        | scribe_rules_append "$rulefile"
+      scribe_json_list "$body_flat" '.rule_ids' | scribe_rules_append "$rulefile"
     fi
     if [ -n "$derivefile" ]; then
-      printf '%s' "$body" | jq -r '(.derive_keys // [])[]?' 2>/dev/null >> "$derivefile" || true
+      scribe_json_list "$body_flat" '.derive_keys' >> "$derivefile" || true
     fi
   fi
 fi
@@ -259,7 +275,7 @@ fi
 # of those copies is recorded" is a claim only an answer can back — the
 # unreached line says what actually happened instead.
 if [ -n "$local_lines" ] && [ "$reached" = 1 ]; then
-  n_recorded=$(printf '%s' "$body" | jq -r '.note_ids | length' 2>/dev/null) || n_recorded=0
+  n_recorded=$(scribe_json_len "$body_flat" '.note_ids')
   if [ "${n_recorded:-0}" = "0" ] || [ "$n_recorded" = "" ]; then
     local_context="${local_context}"$'\n'"> None of those existing copies is recorded in Scribe. If the version being written is the canonical one — or this edit is consolidating the copies — record it now with create_snippet (name, code, when-to-reach-for-it, location) so the next session is offered it instead of writing another copy."
   fi
@@ -280,6 +296,5 @@ fi
 [ -n "$combined" ] || exit 0
 
 # No permissionDecision: this is a nudge, not a gate. The write goes ahead.
-jq -n --arg c "$combined" \
-  '{hookSpecificOutput: {hookEventName: "PreToolUse", additionalContext: $c}}'
+scribe_json_out PreToolUse "$combined"
 exit 0