bvandeusenandClaude Opus 5.5
c6cdfc2172
CI & Build / Python lint (push) Successful in 2s
CI & Build / Plugin hooks (push) Successful in 14s
CI & Build / TypeScript typecheck (push) Successful in 55s
CI & Build / integration (push) Successful in 1m1s
CI & Build / Python tests (push) Failing after 1m25s
CI & Build / Build & push image (push) Skipped
The reply is the one act no tool call marks, and it is where "let me know if it works" gets said. A new Stop hook (scribe_reply_check.sh) sends the finished reply to POST /api/plugin/reply-rules, which checks it twice: - mounted: every unopened RULE on reply.report, plus reply.ask when the reply asks a question. Deterministic. - semantic: the reply's head and tail against every rule's trigger, on a new ranked surface, reply_rule. It is the backstop for whatever the earlier arms missed. Its floor is its stop bar (default 0.80, budget 1), with its own Settings dials. The new stop_only stage records surfacing for the rule that holds and nothing else, because nothing else reached anyone. Following the operator's ruling from 456 step 8, a rule that holds blocks once, in the server's words. The hook blocks only on a reason it was given, so an unreachable instance never stops a session, and it never holds the rewrite. The ledger is the act checkpoint's own, so a rule holds a session once across both doors and the per-session cap counts both. The turn reader moved from the report check into scribe_defs.sh (scribe_turn_facts / scribe_turn_fact), so the two Stop hooks read a turn the same way. The output was checked identical on a real transcript. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
156 lines
7.2 KiB
Bash
156 lines
7.2 KiB
Bash
#!/usr/bin/env bash
|
|
# Scribe plugin — Stop hook: a reply that closes a task carries the completion
|
|
# sections (milestone 409 step 5).
|
|
#
|
|
# Everything else the plugin does happens BEFORE the agent writes: context,
|
|
# retrieval, the reporting-back skill. This is the one moment the finished
|
|
# reply exists, so it is both the last chance to fix a report the operator
|
|
# cannot read and the only place adherence to the shape can be measured.
|
|
#
|
|
# DETERMINISTIC, NO MODEL CALL. Three questions, cheapest first:
|
|
#
|
|
# 1. Did this turn close a Scribe task? An `update_task` / `create_task` tool
|
|
# call with status "done" since the turn's prompt, whose result was not an
|
|
# error. Most turns stop here, silently.
|
|
# 2. Does the reply that ends the turn have the completion sections? Loosely:
|
|
# where the work sits (a record named by id and title, or step N of M),
|
|
# what needs the operator, and what comes next. Matched on the words that
|
|
# carry the meaning rather than exact headings, so the skill's wording can
|
|
# change without breaking this.
|
|
# 3. If sections are missing, block once with a reason naming them. The agent
|
|
# rewrites; the rewrite is checked and recorded, and never blocked again.
|
|
#
|
|
# MEASURED FROM THE FIRST CALL. Each checked reply is reported to the instance
|
|
# (`/api/plugin/report-check`): passed, blocked, and after a rewrite either
|
|
# passed_after_rewrite or missing_after_rewrite. Turns that closed no task are
|
|
# not reported — they would cost a request on every turn and add nothing to
|
|
# the rate step 6 reads (blocked among checked replies).
|
|
#
|
|
# IT BLOCKS ONLY WHEN THE BLOCK IS RECORDED, AND ONLY IN THE SERVER'S WORDS.
|
|
# The report goes out first; the instance answers a recorded `blocked` with
|
|
# the reason to send the agent back with, and the hook blocks only on that
|
|
# reason. An unconfigured or unreachable instance therefore never stops a
|
|
# session, every intervention is one the numbers can see, and the guidance
|
|
# text lives on the server (plugin/PACKAGING.md: hooks carry timing and
|
|
# transport).
|
|
#
|
|
# THE TRANSCRIPT FORMAT IS OBSERVED, NOT DOCUMENTED. Claude Code documents
|
|
# `transcript_path` and `stop_hook_active` for Stop, not the JSONL inside. As
|
|
# read from real transcripts (2026-09-14): one content block per line;
|
|
# `type: "assistant"` lines carry `message.content[]` blocks of `text` /
|
|
# `tool_use` ({id, name, input}); tool results arrive as `type: "user"` lines
|
|
# whose content is a `tool_result` array ({tool_use_id, is_error}); a turn's
|
|
# prompt — typed, or a background-task notification — is a `user` line whose
|
|
# content is a plain string and which is not `isMeta`. Anything that does not
|
|
# parse that way makes the hook stay out of the way rather than guess.
|
|
#
|
|
# Config (same as the other hooks):
|
|
# CLAUDE_PLUGIN_OPTION_API_ENDPOINT base URL, no trailing slash
|
|
# CLAUDE_PLUGIN_OPTION_API_TOKEN fmcp_ API key (sensitive)
|
|
# SCRIBE_URL / SCRIBE_TOKEN override for the settings.json dogfooding path.
|
|
set -uo pipefail
|
|
|
|
command -v curl >/dev/null 2>&1 || exit 0
|
|
|
|
# shellcheck source=plugin/hooks/scribe_defs.sh
|
|
. "$(dirname "${BASH_SOURCE[0]}")/scribe_defs.sh"
|
|
|
|
# Stop delivers { session_id, transcript_path, cwd, hook_event_name, stop_hook_active }.
|
|
event=$(cat 2>/dev/null || true)
|
|
event_flat=$(printf '%s' "$event" | scribe_json_flat)
|
|
transcript=$(scribe_json_pick "$event_flat" '.transcript_path')
|
|
[ -n "$transcript" ] && [ -f "$transcript" ] || exit 0
|
|
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"
|
|
mkdir -p "$state_dir" 2>/dev/null || true
|
|
marker="$state_dir/${safe_sid}.blocked"
|
|
|
|
# Cheap prefilter: no task tool anywhere in the recent transcript → nothing to
|
|
# check. Keeps the ordinary turn at one grep. Process substitution, NOT a pipe:
|
|
# under `pipefail`, `grep -q` exiting on the first match kills `tail` with
|
|
# SIGPIPE, and the pipeline then reports failure precisely when it matched.
|
|
grep -q -E '"name":[[:space:]]*"([^"]*__)?(update|create)_task"' < <(tail -c 2000000 "$transcript" 2>/dev/null) || {
|
|
rm -f "$marker" 2>/dev/null || true
|
|
exit 0
|
|
}
|
|
|
|
# The turn, parsed once — scribe_turn_facts, shared with the reply check.
|
|
facts=$(scribe_turn_facts "$transcript")
|
|
fact() { scribe_turn_fact "$facts" "$1"; }
|
|
|
|
[ "$(fact bounded)" = "1" ] || exit 0
|
|
closed=$(fact closed)
|
|
if [ "${closed:-0}" = "0" ]; then
|
|
rm -f "$marker" 2>/dev/null || true
|
|
exit 0
|
|
fi
|
|
# 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.
|
|
[ -n "$(printf '%s' "$reply" | tr -d '[:space:]')" ] || exit 0
|
|
|
|
missing=()
|
|
# Where the work sits: a record named by id AND title (#12 "…", milestone 3 "…"),
|
|
# or a step position. A bare id is exactly the homework this shape removes.
|
|
# shellcheck disable=SC2016 # backticks here are literal markdown, not an expansion
|
|
grep -q -i -E '(#[0-9]+|milestone [0-9]+|task [0-9]+)[*_`]*[[:space:]]*[*_`]*["“]|step [0-9]+ of [0-9]+' <<< "$reply" \
|
|
|| missing+=("where it sits")
|
|
# What needs the operator — "needs you: nothing" counts; it is an answer.
|
|
grep -q -i -E 'needs? (from )?you|nothing (is )?needed from you|your (call|decision)' <<< "$reply" \
|
|
|| missing+=("needs you")
|
|
# What comes next.
|
|
grep -q -i -E '\bnext\b' <<< "$reply" \
|
|
|| missing+=("next")
|
|
|
|
# Reports the outcome; prints the instance's reply and returns 0 only if the
|
|
# instance recorded it.
|
|
report() {
|
|
scribe_config || return 1
|
|
local q repo enc m
|
|
q="outcome=$1&task_ids=${task_ids}"
|
|
m=$(IFS=,; printf '%s' "${missing[*]:-}")
|
|
if [ -n "$m" ]; then
|
|
enc=$(printf '%s' "$m" | scribe_urlenc) || enc=""
|
|
q="${q}&missing=${enc}"
|
|
fi
|
|
scope=$(scribe_scope_query "${event_cwd:-${CLAUDE_PROJECT_DIR:-$PWD}}")
|
|
[ -n "$scope" ] && q="${q}&${scope}"
|
|
curl -fsS --max-time 4 \
|
|
-H "Authorization: Bearer ${token}" \
|
|
"${url%/}/api/plugin/report-check?${q}" 2>/dev/null
|
|
}
|
|
|
|
if [ "$active" = "true" ]; then
|
|
# A Stop hook already blocked this stop. If it was this one, the reply is
|
|
# the rewrite: record how it came out, and let the session stop whatever
|
|
# the answer. If it was another plugin's block, this hook has nothing to add.
|
|
[ -f "$marker" ] || exit 0
|
|
rm -f "$marker" 2>/dev/null || true
|
|
if [ ${#missing[@]} -eq 0 ]; then report passed_after_rewrite >/dev/null; else report missing_after_rewrite >/dev/null; fi
|
|
exit 0
|
|
fi
|
|
rm -f "$marker" 2>/dev/null || true
|
|
|
|
if [ ${#missing[@]} -eq 0 ]; then
|
|
report passed >/dev/null
|
|
exit 0
|
|
fi
|
|
|
|
# The words the agent is sent back with are the server's (plugin/PACKAGING.md:
|
|
# a hook carries timing and transport). No reason back → nothing recorded →
|
|
# no block.
|
|
answer=$(report blocked) || exit 0
|
|
reason=$(scribe_json_pick "$(printf '%s' "$answer" | scribe_json_flat)" '.reason')
|
|
[ -n "$reason" ] || exit 0
|
|
: > "$marker" 2>/dev/null || true
|
|
printf '{"decision":"block","reason":"%s"}\n' "$(printf '%s' "$reason" | scribe_json_escape)"
|
|
exit 0
|