@onlooker-community/ecosystem 0.28.0 → 0.29.0

package/plugins/compass/scripts/lib/compass-evaluator.sh

@@ -1,20 +1,22 @@
 #!/usr/bin/env bash
-# N=5 parallel Haiku evaluator for Compass.
+# N=5 parallel `claude -p` evaluator for Compass.
 #
-# Launches N independent evaluator calls, aggregates scores, and returns
-# a decision (pass/fail) with confidence and stddev.
+# Launches N independent evaluator calls via `claude -p --max-turns 1`,
+# aggregates scores, and returns a decision (pass / fail / error) with
+# confidence and stddev.
 #
 # Exposes:
 #   compass_evaluate <tool_name> <file_path> <operation> \
 #                    <prior_turn> <context_excerpt> <session_id>
 #
-# Exits 0 if confidence >= threshold AND stddev <= stddev_threshold.
-# Exits 1 if confidence < threshold OR stddev > stddev_threshold (block).
-# Exits 2 on evaluator error (respects error_policy).
-#
 # Writes a JSON result object to stdout:
 #   {"decision":"pass|fail|error","confidence":<f>,"stddev":<f>,
 #    "primary_concern":"<str>","rationale":"<str>","sample_count":<n>}
+#
+# Exit codes:
+#   0  pass (confidence >= threshold AND stddev <= stddev_threshold)
+#   1  fail (block)
+#   2  error (respects error_policy)
 
 _COMPASS_EVAL_PROMPT_NO_PRIOR='You are evaluating whether a pending write operation has sufficient intent clarity.
 
@@ -78,87 +80,65 @@ path: FILE_PATH_PLACEHOLDER
 operation: OPERATION_PLACEHOLDER
 </tool_input>'
 
-# Run a single evaluator call. Writes JSON to a temp file at $output_file.
+# Strip leading/trailing markdown fences a model occasionally emits.
+_compass_strip_fences() {
+	printf '%s' "$1" | sed -e 's/^```json//' -e 's/^```//' -e 's/```$//'
+}
+
+# Run a single evaluator call via `claude -p`. Writes JSON to $output_file.
 # $1 — prompt text
 # $2 — model
-# $3 — temperature (as string, e.g. "0.3")
-# $4 — max_output_tokens
-# $5 — output file path
-# $6 — API key env var name (default: ANTHROPIC_API_KEY)
+# $3 — timeout (seconds)
+# $4 — output file path
 _compass_run_single_eval() {
 	local prompt="$1"
 	local model="$2"
-	local temperature="$3"
-	local max_tokens="$4"
-	local output_file="$5"
-	local api_key_var="${6:-ANTHROPIC_API_KEY}"
-	local api_key="${!api_key_var:-}"
-
-	[[ -z "$api_key" ]] && { printf '{"error":"no_api_key"}' > "$output_file"; return 1; }
-
-	local request_body
-	request_body=$(jq -n \
-		--arg model "$model" \
-		--argjson temp "$temperature" \
-		--argjson max_tokens "$max_tokens" \
-		--arg prompt "$prompt" \
-		'{
-			model: $model,
-			max_tokens: $max_tokens,
-			temperature: $temp,
-			messages: [{"role": "user", "content": $prompt}]
-		}' 2>/dev/null) || { printf '{"error":"request_build_failed"}' > "$output_file"; return 1; }
-
-	local http_response http_code response_body
-	http_response=$(curl -s -w '\n%{http_code}' \
-		-X POST "https://api.anthropic.com/v1/messages" \
-		-H "x-api-key: ${api_key}" \
-		-H "anthropic-version: 2023-06-01" \
-		-H "content-type: application/json" \
-		-d "$request_body" \
-		--max-time 15 \
-		2>/dev/null) || { printf '{"error":"curl_failed"}' > "$output_file"; return 1; }
-
-	http_code=$(printf '%s' "$http_response" | tail -n1)
-	response_body=$(printf '%s' "$http_response" | head -n -1)
-
-	if [[ "$http_code" == "429" ]]; then
-		sleep 2
-		http_response=$(curl -s -w '\n%{http_code}' \
-			-X POST "https://api.anthropic.com/v1/messages" \
-			-H "x-api-key: ${api_key}" \
-			-H "anthropic-version: 2023-06-01" \
-			-H "content-type: application/json" \
-			-d "$request_body" \
-			--max-time 15 \
-			2>/dev/null) || { printf '{"error":"curl_failed_retry"}' > "$output_file"; return 1; }
-		http_code=$(printf '%s' "$http_response" | tail -n1)
-		response_body=$(printf '%s' "$http_response" | head -n -1)
-	fi
+	local timeout_secs="$3"
+	local output_file="$4"
 
-	if [[ "$http_code" != "200" ]]; then
-		printf '{"error":"http_%s"}' "$http_code" > "$output_file"
+	if ! command -v claude >/dev/null 2>&1; then
+		printf '{"error":"claude_cli_missing"}' > "$output_file"
 		return 1
 	fi
 
-	local content
-	content=$(printf '%s' "$response_body" | jq -r '.content[0].text // empty' 2>/dev/null) || {
-		printf '{"error":"parse_failed"}' > "$output_file"
+	local prompt_file
+	prompt_file=$(mktemp -t compass-prompt.XXXXXX 2>/dev/null) || prompt_file="/tmp/compass-prompt.$$.${RANDOM}"
+	printf '%s' "$prompt" > "$prompt_file"
+
+	local args=(-p --max-turns 1)
+	[[ -n "$model" ]] && args+=(--model "$model")
+
+	local response=""
+	if command -v timeout >/dev/null 2>&1; then
+		response=$(COMPASS_NESTED=1 timeout "$timeout_secs" claude "${args[@]}" <"$prompt_file" 2>/dev/null) || response=""
+	elif command -v gtimeout >/dev/null 2>&1; then
+		response=$(COMPASS_NESTED=1 gtimeout "$timeout_secs" claude "${args[@]}" <"$prompt_file" 2>/dev/null) || response=""
+	else
+		response=$(COMPASS_NESTED=1 claude "${args[@]}" <"$prompt_file" 2>/dev/null) || response=""
+	fi
+
+	rm -f "$prompt_file" 2>/dev/null || true
+
+	if [[ -z "$response" ]]; then
+		printf '{"error":"empty_response"}' > "$output_file"
 		return 1
-	}
+	fi
 
-	# Validate the model returned parseable JSON with a score field.
+	local clean
+	clean=$(_compass_strip_fences "$response")
+
+	# Confirm the model returned a JSON object with a numeric score.
 	local score
-	score=$(printf '%s' "$content" | jq -r '.score // empty' 2>/dev/null) || score=""
+	score=$(printf '%s' "$clean" | jq -r '.score // empty' 2>/dev/null) || score=""
 	if [[ -z "$score" ]]; then
 		printf '{"error":"invalid_json_response"}' > "$output_file"
 		return 1
 	fi
 
-	printf '%s' "$content" > "$output_file"
+	printf '%s' "$clean" > "$output_file"
 }
 
-# Build the evaluator prompt.
+# Build the evaluator prompt by interpolating the data slots.
 _compass_build_prompt() {
 	local prior_turn="$1"
 	local context_excerpt="$2"
@@ -182,7 +162,7 @@ _compass_build_prompt() {
 	printf '%s' "$template"
 }
 
-# Compute mean of space-separated floats.
+# Mean of space-separated floats.
 _compass_mean() {
 	local scores=("$@")
 	local n="${#scores[@]}"
@@ -195,7 +175,7 @@ _compass_mean() {
 	awk "BEGIN {printf \"%.4f\", $sum / $n}" 2>/dev/null || printf '0'
 }
 
-# Compute population stddev of space-separated floats.
+# Population stddev of space-separated floats.
 _compass_stddev() {
 	local scores=("$@")
 	local n="${#scores[@]}"
@@ -213,7 +193,7 @@ _compass_stddev() {
 # Main evaluator entry point.
 # $1 — tool_name
 # $2 — file_path
-# $3 — operation  (write|edit|multi_edit|bash)
+# $3 — operation  (write|edit|multi_edit|bash_write)
 # $4 — prior_turn (may be empty)
 # $5 — context_excerpt
 # $6 — session_id
@@ -225,17 +205,11 @@ compass_evaluate() {
 	local context_excerpt="$5"
 	local session_id="${6:-unknown}"
 
-	local model
+	local model n_samples timeout_secs min_valid
 	model=$(compass_config_get '.compass.evaluator.model')
 	model="${model:-claude-haiku-4-5-20251001}"
-
-	local n_samples temperature max_tokens timeout_secs min_valid
 	n_samples=$(compass_config_get '.compass.evaluator.n')
 	n_samples="${n_samples:-5}"
-	temperature=$(compass_config_get '.compass.evaluator.temperature')
-	temperature="${temperature:-0.3}"
-	max_tokens=$(compass_config_get '.compass.evaluator.max_output_tokens')
-	max_tokens="${max_tokens:-128}"
 	timeout_secs=$(compass_config_get '.compass.evaluator.sample_timeout_seconds')
 	timeout_secs="${timeout_secs:-8}"
 	min_valid=$(compass_config_get '.compass.evaluator.min_valid_samples')
@@ -250,34 +224,22 @@ compass_evaluate() {
 	local prompt
 	prompt=$(_compass_build_prompt "$prior_turn" "$context_excerpt" "$tool_name" "$file_path" "$operation")
 
-	# Launch N parallel eval calls.
 	local tmp_dir
-	tmp_dir=$(mktemp -d -t compass-eval.XXXXXX 2>/dev/null) || tmp_dir="/tmp/compass-eval.$$"
+	tmp_dir=$(mktemp -d -t compass-eval.XXXXXX 2>/dev/null) || tmp_dir="/tmp/compass-eval.$$.${RANDOM}"
 	mkdir -p "$tmp_dir"
 
 	local pids=()
 	local i
 	for (( i=0; i<n_samples; i++ )); do
 		local out_file="${tmp_dir}/sample_${i}.json"
-		(
-			_compass_run_single_eval \
-				"$prompt" "$model" "$temperature" "$max_tokens" "$out_file"
-		) &
+		_compass_run_single_eval \
+			"$prompt" "$model" "$timeout_secs" "$out_file" &
 		pids+=($!)
 	done
 
-	# Collect with timeout watchdog.
-	local deadline=$(( $(date +%s) + timeout_secs ))
 	local pid
 	for pid in "${pids[@]}"; do
-		local now
-		now=$(date +%s)
-		local remaining=$(( deadline - now ))
-		if [[ "$remaining" -gt 0 ]]; then
-			wait "$pid" 2>/dev/null || true
-		else
-			kill "$pid" 2>/dev/null || true
-		fi
+		wait "$pid" 2>/dev/null || true
 	done
 
 	# Aggregate valid scores.
@@ -307,9 +269,7 @@ compass_evaluate() {
 		error_policy="${error_policy:-closed}"
 
 		local decision="error"
-		if [[ "$error_policy" == "open" ]]; then
-			decision="pass"
-		fi
+		[[ "$error_policy" == "open" ]] && decision="pass"
 
 		jq -n \
 			--arg decision "$decision" \

package/plugins/compass/scripts/lib/compass-gate.sh

@@ -92,21 +92,18 @@ _compass_matches_skip_glob() {
 	local globs_json="$2"
 	[[ -z "$file_path" || -z "$globs_json" ]] && return 1
 
-	# Convert JSON array to bash array and check each pattern.
-	local globs
-	mapfile -t globs < <(printf '%s' "$globs_json" | jq -r '.[]' 2>/dev/null) || return 1
-
-	local glob
-	for glob in "${globs[@]}"; do
-		# Use bash glob matching (extglob not needed for ** — use case).
-		# Convert ** to a catch-all for simple prefix/suffix matching.
-		local pattern="${glob//\*\*/DOUBLE_STAR}"
+	# Bash 3.2 (macOS) lacks mapfile, so stream via read-while.
+	local glob pattern
+	while IFS= read -r glob; do
+		[[ -z "$glob" ]] && continue
+		# Translate ** → .*  and *  → [^/]* for simple prefix/suffix matching.
+		pattern="${glob//\*\*/DOUBLE_STAR}"
 		pattern="${pattern//\*/[^/]*}"
 		pattern="${pattern//DOUBLE_STAR/.*}"
 		if [[ "$file_path" =~ $pattern ]]; then
 			return 0
 		fi
-	done
+	done < <(printf '%s' "$globs_json" | jq -r '.[]' 2>/dev/null)
 	return 1
 }
 
@@ -241,12 +238,13 @@ Choose a path:
 
 # -----------------------------------------------------------------------
 # Main gate function.
-# $1 — tool_name   (Write | Edit | MultiEdit | Bash)
-# $2 — file_path   (may be empty for Bash)
-# $3 — operation   (write | edit | multi_edit | bash_write)
-# $4 — context     (context excerpt or bash command string)
+# $1 — tool_name      (Write | Edit | MultiEdit | Bash)
+# $2 — file_path      (may be empty for Bash)
+# $3 — operation      (write | edit | multi_edit | bash_write)
+# $4 — context        (context excerpt or bash command string)
 # $5 — session_id
 # $6 — cwd
+# $7 — transcript_path (from hook JSON; may be empty)
 # -----------------------------------------------------------------------
 compass_run_gate() {
 	local tool_name="$1"
@@ -255,6 +253,7 @@ compass_run_gate() {
 	local context="$4"
 	local session_id="${5:-unknown}"
 	local cwd="${6:-}"
+	local transcript_path="${7:-}"
 
 	local _allow_exit=0
 	local _block_exit=0
@@ -348,14 +347,12 @@ compass_run_gate() {
 	_compass_increment_turn_count "$session_id" 2>/dev/null || true
 
 	# ---- Read prior assistant turn -----------------------------------
-	local prior_turn_chars_max transcript_max_age
+	local prior_turn_chars_max
 	prior_turn_chars_max=$(compass_config_get '.compass.transcript.prior_turn_chars_max')
 	prior_turn_chars_max="${prior_turn_chars_max:-800}"
-	transcript_max_age=$(compass_config_get '.compass.transcript.transcript_max_age_seconds')
-	transcript_max_age="${transcript_max_age:-300}"
 
 	local prior_turn=""
-	prior_turn=$(compass_read_prior_turn "$session_id" "$prior_turn_chars_max" "$transcript_max_age") \
+	prior_turn=$(compass_read_prior_turn "$transcript_path" "$prior_turn_chars_max") \
 		|| prior_turn=""
 
 	# ---- Symbolic skip layer -----------------------------------------

package/plugins/compass/scripts/lib/compass-sanitizer.sh

@@ -42,13 +42,13 @@ _compass_strip_control_chars() {
 }
 
 # Replace all occurrences of a literal string with [STRIPPED].
+# Uses bash native parameter expansion to avoid the sed delimiter trap —
+# needles like </prior_assistant_turn> contain '/' which breaks sed s///.
 _compass_strip_literal() {
 	local input="$1"
 	local needle="$2"
-	# Use printf + sed; escape needle for BRE (basic regex)
-	local escaped_needle
-	escaped_needle=$(printf '%s' "$needle" | sed 's/[[\.*^$()+?{|]/\\&/g' 2>/dev/null) || escaped_needle="$needle"
-	printf '%s' "$input" | sed "s/${escaped_needle}/[STRIPPED]/g" 2>/dev/null
+	[[ -z "$needle" ]] && { printf '%s' "$input"; return; }
+	printf '%s' "${input//"$needle"/[STRIPPED]}"
 }
 
 # Truncate a string to at most max_chars UTF-8 characters.

package/plugins/compass/scripts/lib/compass-transcript.sh

@@ -1,135 +1,102 @@
 #!/usr/bin/env bash
 # Prior assistant turn reader for Compass.
 #
-# Resolves the most recent assistant turn from the session transcript so
-# the evaluator can operate on the pair {prior_assistant_turn, context}
-# rather than context alone — avoiding false positives on question-answer
-# turns (see ADR-001).
+# Resolves the most recent assistant turn from the session transcript JSONL
+# so the evaluator can operate on the pair {prior_assistant_turn, context}
+# rather than context alone. Avoids false positives on question-answer
+# turns. See ADR-001 (plugins/compass/docs/adr/001-evaluate-prompts-in-context.md).
 #
-# Resolution order:
-#   1. CLAUDE_TRANSCRIPT_PATH env var → parse as JSONL, find most recent
-#      entry with role:"assistant"
-#   2. Onlooker JSONL event log (~/.onlooker/logs/onlooker-events.jsonl)
-#      filtered by session_id and event_type:"session.prompt", most recent
-#      assistant-role entry
-#   3. Empty string — degrades gracefully; evaluator runs on context alone
+# Source: the `transcript_path` field from the hook JSON payload. This is
+# the same field tribunal-stop-gate.sh reads (`jq -r '.transcript_path // ""'`).
+# When `transcript_path` is absent or unreadable, this function returns the
+# empty string and the evaluator runs on the current context alone.
 #
 # Exposes:
-#   compass_read_prior_turn <session_id> <max_chars> <max_age_seconds>
-#     Echoes the prior assistant turn text (possibly empty).
-
-_compass_transcript_from_path() {
-	local transcript_path="$1"
-	local session_id="$2"
-	local max_age_seconds="$3"
-
-	[[ -f "$transcript_path" ]] || return 1
-
-	local now
-	now=$(date +%s 2>/dev/null) || now=0
-
-	# Parse JSONL: find most recent entry with role=assistant within max_age_seconds.
-	# Each line is a JSON object. We want the last one matching our criteria.
-	local prior_turn=""
-	local line
-	while IFS= read -r line; do
-		[[ -z "$line" ]] && continue
-		local role ts content
-		role=$(printf '%s' "$line" | jq -r '.role // empty' 2>/dev/null) || continue
-		[[ "$role" == "assistant" ]] || continue
-
-		# Age check — skip entries older than max_age_seconds.
-		if [[ "$max_age_seconds" -gt 0 ]]; then
-			ts=$(printf '%s' "$line" | jq -r '.timestamp // empty' 2>/dev/null) || ts=""
-			if [[ -n "$ts" ]]; then
-				local entry_time
-				entry_time=$(date -d "$ts" +%s 2>/dev/null) \
-					|| entry_time=$(date -jf '%Y-%m-%dT%H:%M:%SZ' "$ts" +%s 2>/dev/null) \
-					|| entry_time=0
-				local age=$(( now - entry_time ))
-				[[ "$age" -gt "$max_age_seconds" ]] && continue
-			fi
-		fi
-
-		content=$(printf '%s' "$line" | jq -r '.content // .text // empty' 2>/dev/null) || continue
-		[[ -n "$content" ]] && prior_turn="$content"
-	done < "$transcript_path"
-
-	[[ -n "$prior_turn" ]] || return 1
-	printf '%s' "$prior_turn"
+#   compass_read_prior_turn <transcript_path> <max_chars>
+#     Echoes the sanitized, truncated prior assistant turn, or empty string.
+
+# Extract the text portion of a transcript line. The Claude Code session
+# transcript stores assistant messages as `{"type":"assistant","message":{...}}`
+# where `message.content` may be a string or an array of content blocks.
+_compass_transcript_extract_text() {
+	local line="$1"
+	# Prefer message.content[*].text for the array-of-blocks shape; fall back
+	# to message.content when it is already a string. Final fallback: any
+	# top-level .content or .text field (covers legacy/alternate writers).
+	printf '%s' "$line" | jq -r '
+		if (.message? // null) != null then
+			if (.message.content | type) == "array" then
+				[.message.content[]? | select(type == "object") | (.text // "")]
+				| map(select(. != "")) | join("\n")
+			elif (.message.content | type) == "string" then
+				.message.content
+			else "" end
+		else
+			(.content // .text // "")
+		end
+	' 2>/dev/null
 }
 
-_compass_transcript_from_event_log() {
-	local session_id="$1"
-	local max_age_seconds="$2"
-	local log_path="${ONLOOKER_EVENTS_LOG:-${ONLOOKER_DIR:-$HOME/.onlooker}/logs/onlooker-events.jsonl}"
-
-	[[ -f "$log_path" ]] || return 1
-	[[ -n "$session_id" && "$session_id" != "unknown" ]] || return 1
-
-	local now
-	now=$(date +%s 2>/dev/null) || now=0
-
-	local prior_turn=""
-	local line
-	while IFS= read -r line; do
-		[[ -z "$line" ]] && continue
-
-		local sid etype role
-		sid=$(printf '%s' "$line" | jq -r '.session_id // empty' 2>/dev/null) || continue
-		[[ "$sid" == "$session_id" ]] || continue
-
-		etype=$(printf '%s' "$line" | jq -r '.event_type // empty' 2>/dev/null) || continue
-		[[ "$etype" == "session.prompt" ]] || continue
-
-		role=$(printf '%s' "$line" | jq -r '.payload.role // empty' 2>/dev/null) || continue
-		[[ "$role" == "assistant" ]] || continue
+# Return the role for a transcript line, falling back to .message.role.
+_compass_transcript_role() {
+	local line="$1"
+	printf '%s' "$line" \
+		| jq -r '(.role // .message.role // .type // empty)' 2>/dev/null
+}
 
-		if [[ "$max_age_seconds" -gt 0 ]]; then
-			local ts entry_time
-			ts=$(printf '%s' "$line" | jq -r '.timestamp // empty' 2>/dev/null) || ts=""
-			if [[ -n "$ts" ]]; then
-				entry_time=$(date -d "$ts" +%s 2>/dev/null) \
-					|| entry_time=$(date -jf '%Y-%m-%dT%H:%M:%SZ' "$ts" +%s 2>/dev/null) \
-					|| entry_time=0
-				local age=$(( now - entry_time ))
-				[[ "$age" -gt "$max_age_seconds" ]] && continue
-			fi
-		fi
+# Walk a JSONL transcript file backwards to find the most recent assistant
+# turn with non-empty text. Avoids loading the entire file into memory by
+# streaming with `tac` when available; falls back to `tail -r` on BSD.
+_compass_transcript_read_from_file() {
+	local path="$1"
+	[[ -f "$path" ]] || return 1
+
+	local reverser=""
+	if command -v tac >/dev/null 2>&1; then
+		reverser="tac"
+	elif command -v tail >/dev/null 2>&1 && tail -r </dev/null >/dev/null 2>&1; then
+		reverser="tail -r"
+	fi
 
-		local content
-		content=$(printf '%s' "$line" | jq -r '.payload.content // .payload.text // empty' 2>/dev/null) || continue
-		[[ -n "$content" ]] && prior_turn="$content"
-	done < "$log_path"
+	local line role content
+	if [[ -n "$reverser" ]]; then
+		while IFS= read -r line; do
+			[[ -z "$line" ]] && continue
+			role=$(_compass_transcript_role "$line") || continue
+			[[ "$role" == "assistant" ]] || continue
+			content=$(_compass_transcript_extract_text "$line") || continue
+			[[ -n "$content" ]] && { printf '%s' "$content"; return 0; }
+		done < <(eval "$reverser" "\"$path\"" 2>/dev/null)
+	else
+		# Final fallback: forward scan, keep the last match.
+		local found=""
+		while IFS= read -r line; do
+			[[ -z "$line" ]] && continue
+			role=$(_compass_transcript_role "$line") || continue
+			[[ "$role" == "assistant" ]] || continue
+			content=$(_compass_transcript_extract_text "$line") || continue
+			[[ -n "$content" ]] && found="$content"
+		done < "$path"
+		[[ -n "$found" ]] && { printf '%s' "$found"; return 0; }
+	fi
 
-	[[ -n "$prior_turn" ]] || return 1
-	printf '%s' "$prior_turn"
+	return 1
 }
 
 # Read the prior assistant turn.
-#   $1 — session_id
+#   $1 — transcript_path (from hook JSON payload; may be empty)
 #   $2 — max_chars (from config: transcript.prior_turn_chars_max)
-#   $3 — max_age_seconds (from config: transcript.transcript_max_age_seconds)
-# Echoes the sanitized, truncated prior assistant turn, or empty string.
+# Echoes the sanitized, truncated prior assistant turn, or the empty string.
 compass_read_prior_turn() {
-	local session_id="${1:-unknown}"
+	local transcript_path="${1:-}"
 	local max_chars="${2:-800}"
-	local max_age_seconds="${3:-300}"
 
-	local raw=""
-
-	# Source 1: CLAUDE_TRANSCRIPT_PATH
-	if [[ -n "${CLAUDE_TRANSCRIPT_PATH:-}" ]]; then
-		raw=$(_compass_transcript_from_path "$CLAUDE_TRANSCRIPT_PATH" "$session_id" "$max_age_seconds") || raw=""
-	fi
-
-	# Source 2: Onlooker event log
-	if [[ -z "$raw" ]]; then
-		raw=$(_compass_transcript_from_event_log "$session_id" "$max_age_seconds") || raw=""
-	fi
+	[[ -z "$transcript_path" ]] && return 0
 
+	local raw=""
+	raw=$(_compass_transcript_read_from_file "$transcript_path") || raw=""
 	[[ -z "$raw" ]] && return 0
 
-	# Sanitize and truncate — compass-sanitizer.sh must be sourced by the caller.
+	# compass-sanitizer.sh is sourced by the caller (hook script).
 	compass_sanitize "$raw" "$max_chars"
 }

package/plugins/inspector/.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "inspector",
+  "version": "0.1.0",
+  "description": "Per-edit lint and typecheck gate. Runs the project's configured checks on just the touched file after every Write / Edit / MultiEdit, so the agent sees its own type errors before claiming success. Cheaper than proctor (which runs project-wide verification at Stop); complements assayer (which catches the agent lying about claims). Builds on the Onlooker ecosystem plugin.",
+  "author": {
+    "name": "Onlooker Community",
+    "url": "https://onlooker.dev"
+  },
+  "homepage": "https://onlooker.dev",
+  "repository": "https://github.com/onlooker-community/ecosystem",
+  "license": "MIT",
+  "skills": [],
+  "agents": []
+}