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_report_check.sh

@@ -50,7 +50,6 @@
 #   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
 
 # shellcheck source=plugin/hooks/scribe_defs.sh
@@ -58,11 +57,12 @@ command -v curl >/dev/null 2>&1 || exit 0
 
 # Stop delivers { session_id, transcript_path, cwd, hook_event_name, stop_hook_active }.
 event=$(cat 2>/dev/null || true)
-transcript=$(printf '%s' "$event" | jq -r '.transcript_path // empty' 2>/dev/null) || exit 0
+event_flat=$(printf '%s' "$event" | scribe_json_flat)
+transcript=$(scribe_json_pick "$event_flat" '.transcript_path')
 [ -n "$transcript" ] && [ -f "$transcript" ] || exit 0
-session_id=$(printf '%s' "$event" | jq -r '.session_id // empty' 2>/dev/null) || session_id=""
-active=$(printf '%s' "$event" | jq -r '.stop_hook_active // false' 2>/dev/null) || active="false"
-event_cwd=$(printf '%s' "$event" | jq -r '.cwd // empty' 2>/dev/null) || event_cwd=""
+session_id=$(scribe_json_pick "$event_flat" '.session_id')
+active=$(scribe_json_pick "$event_flat" '.stop_hook_active')
+event_cwd=$(scribe_json_pick "$event_flat" '.cwd')
 
 safe_sid=$(printf '%s' "${session_id:-nosession}" | tr -c 'A-Za-z0-9._-' '_')
 state_dir="${TMPDIR:-/tmp}/scribe-reportcheck"
@@ -78,48 +78,67 @@ grep -q -E '"name":[[:space:]]*"([^"]*__)?(update|create)_task"' < <(tail -c 200
   exit 0
 }
 
-# The turn, parsed once. A window of recent lines, slurped raw and split inside
-# jq (a line-by-line `-R` read is the #2198 trap). A first line cut mid-record
-# fails to parse and is dropped. If the window holds no prompt, the turn cannot
-# be bounded, so the hook reports nothing and stays out of the way.
-facts=$(tail -n 3000 "$transcript" 2>/dev/null | jq -sRc '
-  split("\n") | map(try fromjson catch empty)
-  | map(select((.isSidechain // false) | not))
-  | . as $lines
-  | [range(0; length) | select(
-      $lines[.].type == "user" and ($lines[.].isMeta // false | not)
-      and ($lines[.].message.content | type) == "string")] as $prompts
-  | if ($prompts | length) == 0 then {bounded: false} else
-    $lines[($prompts | last) + 1:] as $turn
-    | [ $turn[] | select(.type == "assistant") | .message.content[]?
-        | select(.type == "tool_use"
-                 and ((.name // "") | test("(^|__)(update|create)_task$"))
-                 and (.input.status? == "done"))
-        | {id, task: (.input.task_id? // null)} ] as $closes
-    | [ $turn[] | select(.type == "user") | .message.content[]?
-        | select(type == "object" and .type == "tool_result" and .is_error == true)
-        | .tool_use_id ] as $errors
-    | [ $closes[] | select(.id as $i | ($errors | index($i)) | not) ] as $closed
-    | ([range(0; $turn | length) | select(
-          $turn[.].type == "user"
-          or ($turn[.].type == "assistant"
-              and ([$turn[.].message.content[]?.type] | index("tool_use"))))]
-        | last // -1) as $last_act
-    | {bounded: true,
-       closed: ($closed | length),
-       task_ids: [$closed[].task | select(. != null)],
-       reply: ([ $turn[$last_act + 1:][] | select(.type == "assistant")
-                 | .message.content[]? | select(.type == "text") | .text ] | join("\n"))}
-    end' 2>/dev/null) || exit 0
+# The turn, parsed once. A window of recent lines, flattened record by record
+# and then read by scribe_turn.awk, which carries the turn-bounding rules. A
+# line that does not parse is dropped and the rest are still read — the first
+# line of a `tail -n 3000` window is routinely half a record. If the window
+# holds no prompt, the turn cannot be bounded, so the hook reports nothing and
+# stays out of the way.
+window() { tail -n 3000 "$transcript" 2>/dev/null; }
+turn_facts() { window | tail -n +"${1:-1}" | scribe_json_flat_lines \
+  | awk -f "$SCRIBE_HOOK_DIR/scribe_turn.awk" 2>/dev/null; }
 
-[ "$(printf '%s' "$facts" | jq -r '.bounded // false')" = "true" ] || exit 0
-closed=$(printf '%s' "$facts" | jq -r '.closed // 0')
+# WHERE THE TURN STARTS, FOUND BEFORE PARSING RATHER THAN AFTER. The window is
+# 3000 lines and routinely 7MB, of which a turn is the last few hundred lines
+# and about a sixth of the bytes — the rest is tool results this check never
+# looks at. The predecessor parsed all of it and threw most away, which jq
+# could afford and a parser written in awk cannot: measured at 6.5s for a 7MB
+# window against 94ms, on a hook that runs at the end of every turn.
+#
+# So grep — C, and reading a FIXED string — narrows first. A prompt record is
+# `"type":"user"` whose `content` is a STRING; a tool result is the same type
+# with an ARRAY, and the two are told apart by the character after `"content":`.
+#
+# WHY A FIXED STRING IS EXACT HERE, and not the usual regex-over-JSON guess.
+# Every quote inside a JSON string is backslash-escaped, so a needle carrying
+# UNESCAPED quotes cannot occur inside any string value — it can only match at
+# a record's own top level. `"message":{"role":"user","content":"` therefore
+# matches real prompt records and nothing else. Measured over a 27MB transcript
+# against a full JSON parse: 152 prompt records, 152 matches, no misses and no
+# extras. The looser `"content":"` matched 1101 lines, because a tool_result
+# block has a `content` key of its own — which is the trap this avoids.
+#
+# THE LAST MATCH, not a few before it, because the margin is not free: the
+# lines between two prompts are mostly tool results, and backing off three
+# matches took the window from 53KB to 1.3MB and the parse from 21ms to 2.6s.
+# The fallback below is the safety net instead — it is exact where a margin is
+# only approximate, and it costs nothing in the case that actually happens.
+#
+# The needle assumes a key ORDER that a future Claude Code could change. If it
+# does, grep matches nothing, `start` stays 1, and the whole window is read the
+# slow way — correct, and slow, which is the right way round for a check that
+# can block a stop.
+start=$(window | grep -n -F '"message":{"role":"user","content":"' 2>/dev/null \
+  | cut -d: -f1 | awk 'END { if (NR) print $0 }')
+case "$start" in ''|*[!0-9]*) start=1 ;; esac
+
+facts=$(turn_facts "$start")
+fact() { printf '%s\n' "$facts" | awk -F'\t' -v k="$1" '$1 == k { print substr($0, index($0, "\t") + 1); exit }'; }
+
+if [ "$(fact bounded)" != "1" ] && [ "$start" != "1" ]; then
+  facts=$(turn_facts 1)
+fi
+
+[ "$(fact bounded)" = "1" ] || exit 0
+closed=$(fact closed)
 if [ "${closed:-0}" = "0" ]; then
   rm -f "$marker" 2>/dev/null || true
   exit 0
 fi
-reply=$(printf '%s' "$facts" | jq -r '.reply // ""')
-task_ids=$(printf '%s' "$facts" | jq -r '.task_ids | map(tostring) | join(",")')
+# Escaped on one line coming out of awk, so the format survives a multi-line
+# reply; decoded here, once, where it is about to be read as text.
+reply=$(fact reply | scribe_json_unescape)
+task_ids=$(fact task_ids)
 
 # The reply may not be written to the transcript yet when the hook fires. An
 # empty reply is "cannot tell", not "missing everything" — stay out of the way.
@@ -146,7 +165,7 @@ report() {
   q="outcome=$1&task_ids=${task_ids}"
   m=$(IFS=,; printf '%s' "${missing[*]:-}")
   if [ -n "$m" ]; then
-    enc=$(printf '%s' "$m" | jq -sRr '@uri' 2>/dev/null) || enc=""
+    enc=$(printf '%s' "$m" | scribe_urlenc) || enc=""
     q="${q}&missing=${enc}"
   fi
   scope=$(scribe_scope_query "${event_cwd:-${CLAUDE_PROJECT_DIR:-$PWD}}")
@@ -176,8 +195,8 @@ fi
 # a hook carries timing and transport). No reason back → nothing recorded →
 # no block.
 answer=$(report blocked) || exit 0
-reason=$(printf '%s' "$answer" | jq -r '.reason // empty' 2>/dev/null) || reason=""
+reason=$(scribe_json_pick "$(printf '%s' "$answer" | scribe_json_flat)" '.reason')
 [ -n "$reason" ] || exit 0
 : > "$marker" 2>/dev/null || true
-jq -n --arg r "$reason" '{decision: "block", reason: $r}'
+printf '{"decision":"block","reason":"%s"}\n' "$(printf '%s' "$reason" | scribe_json_escape)"
 exit 0