@onlooker-community/ecosystem 0.10.0 → 0.15.0

package/test/bats/prompt-rules.bats

@@ -0,0 +1,269 @@
+#!/usr/bin/env bats
+
+setup() {
+  # shellcheck source=../helpers/setup.bash
+  source "${BATS_TEST_DIRNAME}/../helpers/setup.bash"
+  load_validate_path
+  # shellcheck source=../../scripts/lib/prompt-rules.sh
+  source "${REPO_ROOT}/scripts/lib/prompt-rules.sh"
+  export CLAUDE_PLUGIN_ROOT="${REPO_ROOT}"
+
+  ensure_dir_exists "$ONLOOKER_PROMPT_RULES_SESSIONS_DIR"
+}
+
+write_global_rules() {
+  local body="$1"
+  printf '%s\n' "$body" > "$(prompt_rules_global_path)"
+}
+
+write_project_rules() {
+  local project_dir="$1"
+  local body="$2"
+  mkdir -p "${project_dir}/.claude"
+  printf '%s\n' "$body" > "${project_dir}/.claude/prompt-rules.json"
+}
+
+@test "load_merged returns empty array when no rule files exist" {
+  local rules
+  rules=$(prompt_rules_load_merged "$TEST_HOME")
+  [ "$(echo "$rules" | jq 'length')" = "0" ]
+}
+
+@test "load_merged surfaces global rules when only global exists" {
+  write_global_rules '{
+    "rules": [
+      {"id": "r1", "pattern": "foo", "guidance": "global rule", "enabled": true}
+    ]
+  }'
+  local rules
+  rules=$(prompt_rules_load_merged "$TEST_HOME")
+  [ "$(echo "$rules" | jq 'length')" = "1" ]
+  [ "$(echo "$rules" | jq -r '.[0].guidance')" = "global rule" ]
+}
+
+@test "load_merged: project overrides global by id" {
+  write_global_rules '{
+    "rules": [
+      {"id": "r1", "pattern": "foo", "guidance": "global version"},
+      {"id": "r2", "pattern": "bar", "guidance": "global only"}
+    ]
+  }'
+  write_project_rules "$TEST_HOME" '{
+    "rules": [
+      {"id": "r1", "pattern": "foo", "guidance": "project version"}
+    ]
+  }'
+  local rules
+  rules=$(prompt_rules_load_merged "$TEST_HOME")
+  [ "$(echo "$rules" | jq 'length')" = "2" ]
+  [ "$(echo "$rules" | jq -r '.[] | select(.id=="r1") | .guidance')" = "project version" ]
+  [ "$(echo "$rules" | jq -r '.[] | select(.id=="r2") | .guidance')" = "global only" ]
+}
+
+@test "load_merged filters out enabled: false rules" {
+  write_global_rules '{
+    "rules": [
+      {"id": "r1", "pattern": "foo", "guidance": "on"},
+      {"id": "r2", "pattern": "bar", "guidance": "off", "enabled": false}
+    ]
+  }'
+  local rules
+  rules=$(prompt_rules_load_merged "$TEST_HOME")
+  [ "$(echo "$rules" | jq 'length')" = "1" ]
+  [ "$(echo "$rules" | jq -r '.[0].id')" = "r1" ]
+}
+
+@test "pattern_matches: hit, miss, empty pattern" {
+  run prompt_rules_pattern_matches "hello world" "world"
+  [ "$status" -eq 0 ]
+  run prompt_rules_pattern_matches "hello world" "xyz"
+  [ "$status" -eq 1 ]
+  run prompt_rules_pattern_matches "hello world" ""
+  [ "$status" -eq 1 ]
+}
+
+@test "pattern_matches: invalid ERE returns non-match without leaking stderr" {
+  # Unbalanced bracket — bash would normally print "syntax error in regular
+  # expression" to stderr and return 2. The helper must swallow both.
+  run prompt_rules_pattern_matches "anything" "[unterminated"
+  [ "$status" -eq 1 ]
+  [ -z "$stderr" ] || [ -z "${stderr// /}" ]
+}
+
+@test "load_merged: tolerates non-array .rules and entries missing id" {
+  # Object instead of array, and rule entries with missing/non-string ids.
+  write_global_rules '{"rules": "not-an-array"}'
+  write_project_rules "$TEST_HOME" '{
+    "rules": [
+      {"pattern": "no-id"},
+      {"id": null, "pattern": "null-id"},
+      {"id": 42, "pattern": "non-string-id"},
+      {"id": "good", "pattern": "ok", "guidance": "ok"}
+    ]
+  }'
+  local rules
+  rules=$(prompt_rules_load_merged "$TEST_HOME")
+  [ "$(echo "$rules" | jq 'length')" = "1" ]
+  [ "$(echo "$rules" | jq -r '.[0].id')" = "good" ]
+}
+
+@test "mark_fired + load_fired round-trip is idempotent" {
+  prompt_rules_mark_fired "sess-A" "rule-1"
+  prompt_rules_mark_fired "sess-A" "rule-1"
+  prompt_rules_mark_fired "sess-A" "rule-2"
+  local fired
+  fired=$(prompt_rules_load_fired "sess-A")
+  [ "$(echo "$fired" | jq 'length')" = "2" ]
+  [ "$(echo "$fired" | jq -r '. | sort | join(",")')" = "rule-1,rule-2" ]
+}
+
+@test "hook injects additionalContext when prompt matches a rule" {
+  write_global_rules '{
+    "rules": [
+      {"id": "rule-no-verify", "pattern": "--no-verify", "guidance": "Skipping hooks usually masks the real issue."}
+    ]
+  }'
+  local fixture="${REPO_ROOT}/test/fixtures/hook-inputs/user-prompt-submit-rule-match.json"
+
+  run bash -c "cat '${fixture}' | '${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh' 2>/dev/null"
+  [ "$status" -eq 0 ]
+  echo "$output" | jq -e \
+    '.hookSpecificOutput.hookEventName == "UserPromptSubmit"
+     and (.hookSpecificOutput.additionalContext | contains("Skipping hooks"))' >/dev/null
+}
+
+@test "hook outputs nothing when no rule matches" {
+  write_global_rules '{
+    "rules": [
+      {"id": "rule-no-verify", "pattern": "--no-verify", "guidance": "Skipping hooks usually masks the real issue."}
+    ]
+  }'
+  local fixture="${REPO_ROOT}/test/fixtures/hook-inputs/user-prompt-submit-rule-nomatch.json"
+
+  run bash -c "cat '${fixture}' | '${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh' 2>/dev/null"
+  [ "$status" -eq 0 ]
+  [ -z "$output" ]
+}
+
+@test "hook fires a rule once per session" {
+  write_global_rules '{
+    "rules": [
+      {"id": "rule-no-verify", "pattern": "--no-verify", "guidance": "Skipping hooks usually masks the real issue."}
+    ]
+  }'
+  local fixture="${REPO_ROOT}/test/fixtures/hook-inputs/user-prompt-submit-rule-match.json"
+
+  # First invocation: injects
+  local first_output
+  first_output=$(cat "$fixture" | "${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh" 2>/dev/null)
+  echo "$first_output" | jq -e '.hookSpecificOutput.additionalContext | contains("Skipping hooks")' >/dev/null
+
+  # Second invocation with same session: no injection
+  local second_output
+  second_output=$(cat "$fixture" | "${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh" 2>/dev/null)
+  [ -z "$second_output" ]
+}
+
+@test "hook emits prompt_rule.matched and prompt_rule.applied to events log" {
+  write_global_rules '{
+    "rules": [
+      {"id": "rule-no-verify", "pattern": "--no-verify", "guidance": "Skipping hooks usually masks the real issue."}
+    ]
+  }'
+  : >"$ONLOOKER_EVENTS_LOG"
+  local fixture="${REPO_ROOT}/test/fixtures/hook-inputs/user-prompt-submit-rule-match.json"
+
+  cat "$fixture" | "${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh" >/dev/null 2>&1
+
+  grep -q '"event_type":"prompt_rule.matched"' "$ONLOOKER_EVENTS_LOG"
+  grep -q '"event_type":"prompt_rule.applied"' "$ONLOOKER_EVENTS_LOG"
+  grep -q '"rule_id":"rule-no-verify"' "$ONLOOKER_EVENTS_LOG"
+}
+
+@test "hook fires repeatedly when fire_once_per_session is false" {
+  write_global_rules '{
+    "rules": [
+      {"id": "rule-no-verify", "pattern": "--no-verify", "guidance": "Skipping hooks usually masks the real issue.", "fire_once_per_session": false}
+    ]
+  }'
+  local fixture="${REPO_ROOT}/test/fixtures/hook-inputs/user-prompt-submit-rule-match.json"
+
+  # Both invocations must inject — explicit false should not get coerced to true.
+  local first second
+  first=$(cat "$fixture" | "${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh" 2>/dev/null)
+  second=$(cat "$fixture" | "${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh" 2>/dev/null)
+
+  echo "$first" | jq -e '.hookSpecificOutput.additionalContext | contains("Skipping hooks")' >/dev/null
+  echo "$second" | jq -e '.hookSpecificOutput.additionalContext | contains("Skipping hooks")' >/dev/null
+}
+
+@test "hook still emits prompt_rule.matched on subsequent match but not prompt_rule.applied" {
+  write_global_rules '{
+    "rules": [
+      {"id": "rule-no-verify", "pattern": "--no-verify", "guidance": "msg"}
+    ]
+  }'
+  local fixture="${REPO_ROOT}/test/fixtures/hook-inputs/user-prompt-submit-rule-match.json"
+
+  cat "$fixture" | "${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh" >/dev/null 2>&1
+  : >"$ONLOOKER_EVENTS_LOG"
+  cat "$fixture" | "${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh" >/dev/null 2>&1
+
+  grep -q '"event_type":"prompt_rule.matched"' "$ONLOOKER_EVENTS_LOG"
+  ! grep -q '"event_type":"prompt_rule.applied"' "$ONLOOKER_EVENTS_LOG"
+}
+
+@test "hook respects per_turn_max_chars: drops overflowing rules" {
+  write_global_rules '{
+    "rules": [
+      {"id": "r1", "pattern": "no-verify", "guidance": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"},
+      {"id": "r2", "pattern": "no-verify", "guidance": "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"}
+    ]
+  }'
+  # Use a temp plugin root with a tiny char budget
+  local tmp_root="${BATS_TEST_TMPDIR}/tiny-budget-root"
+  mkdir -p "$tmp_root"
+  printf '%s\n' '{"plugin_name":"onlooker","prompt_rules":{"enabled":true,"per_turn_max_chars":120}}' > "$tmp_root/config.json"
+
+  local fixture="${REPO_ROOT}/test/fixtures/hook-inputs/user-prompt-submit-rule-match.json"
+  local output
+  output=$(CLAUDE_PLUGIN_ROOT="$tmp_root" cat "$fixture" | CLAUDE_PLUGIN_ROOT="$tmp_root" "${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh" 2>/dev/null)
+
+  # First rule fits (~98 chars); second pushes past 120, gets dropped.
+  echo "$output" | jq -e '.hookSpecificOutput.additionalContext | contains("AAAA") and (contains("BBBB") | not)' >/dev/null
+}
+
+@test "hook short-circuits when prompt_rules.enabled = false" {
+  write_global_rules '{
+    "rules": [
+      {"id": "r1", "pattern": "no-verify", "guidance": "should not fire"}
+    ]
+  }'
+  local tmp_root="${BATS_TEST_TMPDIR}/disabled-root"
+  mkdir -p "$tmp_root"
+  printf '%s\n' '{"plugin_name":"onlooker","prompt_rules":{"enabled":false}}' > "$tmp_root/config.json"
+
+  local fixture="${REPO_ROOT}/test/fixtures/hook-inputs/user-prompt-submit-rule-match.json"
+  local output
+  output=$(CLAUDE_PLUGIN_ROOT="$tmp_root" "${REPO_ROOT}/scripts/hooks/prompt-rule-injector.sh" < "$fixture" 2>/dev/null)
+  [ -z "$output" ]
+}
+
+@test "list_table reports active rules and per-session fire status" {
+  write_global_rules '{
+    "rules": [
+      {"id": "r1", "pattern": "foo", "guidance": "global one"},
+      {"id": "r2", "pattern": "bar", "guidance": "global two"}
+    ]
+  }'
+  prompt_rules_mark_fired "session-list" "r1"
+
+  local out
+  out=$(prompt_rules_list_table "session-list" "$TEST_HOME")
+  echo "$out" | grep -q "active rules: 2"
+  echo "$out" | grep -q "id: r1"
+  echo "$out" | grep -q "id: r2"
+  # r1 is fired, r2 is not
+  echo "$out" | grep -A2 "id: r1" | grep -q "fired: yes"
+  echo "$out" | grep -A2 "id: r2" | grep -q "fired: no"
+}

package/test/bats/tribunal-aggregate.bats

@@ -0,0 +1,77 @@
+#!/usr/bin/env bats
+
+setup() {
+	source "${BATS_TEST_DIRNAME}/../helpers/setup.bash"
+	setup_test_env
+
+	PLUGIN_ROOT="${REPO_ROOT}/plugins/tribunal"
+	export CLAUDE_PLUGIN_ROOT="$PLUGIN_ROOT"
+	# shellcheck disable=SC1091
+	source "${PLUGIN_ROOT}/scripts/lib/tribunal-aggregate.sh"
+}
+
+VERDICTS='[{"judge_id":"a","score":0.8},{"judge_id":"b","score":0.6},{"judge_id":"c","score":0.4}]'
+
+@test "mean of [0.8, 0.6, 0.4] is 0.6" {
+	local v
+	v=$(tribunal_aggregate "mean" "$VERDICTS")
+	awk -v v="$v" 'BEGIN { exit !(v > 0.59 && v < 0.61) }'
+}
+
+@test "median of three is the middle" {
+	local v
+	v=$(tribunal_aggregate "median" "$VERDICTS")
+	awk -v v="$v" 'BEGIN { exit !(v > 0.59 && v < 0.61) }'
+}
+
+@test "median of four averages the two middle scores" {
+	local four='[{"judge_id":"a","score":0.2},{"judge_id":"b","score":0.4},{"judge_id":"c","score":0.6},{"judge_id":"d","score":0.8}]'
+	local v
+	v=$(tribunal_aggregate "median" "$four")
+	awk -v v="$v" 'BEGIN { exit !(v > 0.49 && v < 0.51) }'
+}
+
+@test "min picks the lowest score" {
+	local v
+	v=$(tribunal_aggregate "min" "$VERDICTS")
+	awk -v v="$v" 'BEGIN { exit !(v > 0.39 && v < 0.41) }'
+}
+
+@test "weighted_mean degrades to mean in v0.1" {
+	local v
+	v=$(tribunal_aggregate "weighted_mean" "$VERDICTS")
+	awk -v v="$v" 'BEGIN { exit !(v > 0.59 && v < 0.61) }'
+}
+
+@test "unknown method falls back to mean with warning on stderr" {
+	run bash -c '
+		source "${REPO_ROOT}/plugins/tribunal/scripts/lib/tribunal-aggregate.sh"
+		tribunal_aggregate "lottery" "[{\"score\":0.5},{\"score\":0.7}]" 2>&1
+	'
+	[ "$status" -eq 0 ]
+	[[ "$output" == *"unknown method lottery"* ]]
+}
+
+@test "empty verdicts aggregates to 0" {
+	local v
+	v=$(tribunal_aggregate "mean" "[]")
+	[ "$v" = "0" ]
+}
+
+@test "disagreement of identical scores is 0" {
+	local d
+	d=$(tribunal_disagreement '[{"score":0.7},{"score":0.7}]')
+	awk -v d="$d" 'BEGIN { exit !(d < 0.01) }'
+}
+
+@test "disagreement of [0.2, 0.8] is 0.6" {
+	local d
+	d=$(tribunal_disagreement '[{"score":0.2},{"score":0.8}]')
+	awk -v d="$d" 'BEGIN { exit !(d > 0.59 && d < 0.61) }'
+}
+
+@test "disagreement of single verdict is 0" {
+	local d
+	d=$(tribunal_disagreement '[{"score":0.7}]')
+	[ "$d" = "0" ]
+}

package/test/bats/tribunal-config.bats

@@ -0,0 +1,86 @@
+#!/usr/bin/env bats
+
+setup() {
+	source "${BATS_TEST_DIRNAME}/../helpers/setup.bash"
+	setup_test_env
+
+	PLUGIN_ROOT="${REPO_ROOT}/plugins/tribunal"
+	export CLAUDE_PLUGIN_ROOT="$PLUGIN_ROOT"
+	# shellcheck disable=SC1091
+	source "${PLUGIN_ROOT}/scripts/lib/tribunal-config.sh"
+}
+
+@test "config defaults from plugin config.json: enabled" {
+	tribunal_config_load ""
+	run tribunal_config_enabled
+	[ "$status" -eq 0 ]
+}
+
+@test "stop_hook defaults to disabled" {
+	tribunal_config_load ""
+	run tribunal_config_stop_hook_enabled
+	[ "$status" -ne 0 ]
+}
+
+@test "user-level settings.json overlay can disable tribunal" {
+	mkdir -p "${HOME}/.claude"
+	printf '%s\n' '{"tribunal":{"enabled":false}}' > "${HOME}/.claude/settings.json"
+	tribunal_config_load ""
+	run tribunal_config_enabled
+	[ "$status" -ne 0 ]
+}
+
+@test "repo-level settings.json overrides user-level" {
+	mkdir -p "${HOME}/.claude"
+	printf '%s\n' '{"tribunal":{"enabled":false}}' > "${HOME}/.claude/settings.json"
+	local repo="${BATS_TEST_TMPDIR}/repo"
+	mkdir -p "${repo}/.claude"
+	printf '%s\n' '{"tribunal":{"enabled":true}}' > "${repo}/.claude/settings.json"
+	tribunal_config_load "$repo"
+	run tribunal_config_enabled
+	[ "$status" -eq 0 ]
+}
+
+@test "default judge_types is standard + adversarial" {
+	tribunal_config_load ""
+	local types
+	types=$(tribunal_config_get_json '.tribunal.session.judge_types')
+	[ "$types" = '["standard","adversarial"]' ]
+}
+
+@test "default gate_policy is majority" {
+	tribunal_config_load ""
+	local v
+	v=$(tribunal_config_get '.tribunal.session.gate_policy')
+	[ "$v" = "majority" ]
+}
+
+@test "judge model falls back to tribunal.judges.model when no per-type override" {
+	tribunal_config_load ""
+	local m
+	m=$(tribunal_config_judge_model "standard")
+	[ "$m" = "claude-opus-4-7" ]
+}
+
+@test "per-judge-type model override wins over fallback" {
+	mkdir -p "${HOME}/.claude"
+	printf '%s\n' '{"tribunal":{"judges":{"security":{"model":"claude-opus-4-7-deep"}}}}' > "${HOME}/.claude/settings.json"
+	tribunal_config_load ""
+	local m
+	m=$(tribunal_config_judge_model "security")
+	[ "$m" = "claude-opus-4-7-deep" ]
+	# Other types still fall through to the default.
+	m=$(tribunal_config_judge_model "standard")
+	[ "$m" = "claude-opus-4-7" ]
+}
+
+@test "deep-merge preserves unset defaults" {
+	mkdir -p "${HOME}/.claude"
+	printf '%s\n' '{"tribunal":{"session":{"max_iterations":7}}}' > "${HOME}/.claude/settings.json"
+	tribunal_config_load ""
+	local mi gp
+	mi=$(tribunal_config_get '.tribunal.session.max_iterations')
+	gp=$(tribunal_config_get '.tribunal.session.gate_policy')
+	[ "$mi" = "7" ]
+	[ "$gp" = "majority" ]
+}

package/test/bats/tribunal-events.bats

@@ -0,0 +1,209 @@
+#!/usr/bin/env bats
+
+# Validates every emitted tribunal.* event against @onlooker-community/schema
+# v2.1.0+. Builds a single event via the canonical emitter and asserts the
+# resulting JSONL line passes validate().
+
+setup() {
+	source "${BATS_TEST_DIRNAME}/../helpers/setup.bash"
+	setup_test_env
+
+	PLUGIN_ROOT="${REPO_ROOT}/plugins/tribunal"
+	export CLAUDE_PLUGIN_ROOT="$PLUGIN_ROOT"
+	export ONLOOKER_EVENTS_LOG="${ONLOOKER_DIR}/logs/onlooker-events.jsonl"
+	mkdir -p "$(dirname "$ONLOOKER_EVENTS_LOG")"
+
+	# tribunal-events.sh looks up onlooker-event.mjs relative to its plugin
+	# root, but tests set CLAUDE_PLUGIN_ROOT to plugins/tribunal — point the
+	# wrapper at the ecosystem copy directly so it does not have to walk.
+	export _ONLOOKER_EVENT_JS="${REPO_ROOT}/scripts/lib/onlooker-event.mjs"
+
+	# shellcheck disable=SC1091
+	source "${PLUGIN_ROOT}/scripts/lib/tribunal-events.sh"
+
+	export CLAUDE_SESSION_ID="bats-session-$$"
+}
+
+# Re-validate the latest event in the log against the schema.
+_validate_latest_event() {
+	local last
+	last=$(tail -n 1 "$ONLOOKER_EVENTS_LOG")
+	[ -n "$last" ] || return 1
+	printf '%s' "$last" | ONLOOKER_DIR="$ONLOOKER_DIR" \
+		node "${REPO_ROOT}/scripts/lib/onlooker-event.mjs" validate >/dev/null
+}
+
+TASK_ID="01J000000000000000000000TS"
+ITER_ID="01J000000000000000000000IT"
+JUDGE_ID="01J000000000000000000000JJ"
+
+@test "session.start validates" {
+	local p
+	p=$(jq -n --arg t "$TASK_ID" '{
+		task_id: $t,
+		judge_types: ["standard","adversarial"],
+		gate_policy: "majority",
+		score_threshold: 0.75,
+		max_iterations: 3,
+		actor_model_id: "claude-sonnet-4-6",
+		judge_model_ids: ["claude-opus-4-7","claude-opus-4-7"],
+		meta_model_id: "claude-opus-4-7"
+	}')
+	tribunal_emit_event "tribunal.session.start" "$p"
+	run _validate_latest_event
+	[ "$status" -eq 0 ]
+}
+
+@test "iteration.start validates" {
+	local p
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" \
+		'{task_id: $t, iteration_id: $i, iteration_number: 0, trigger: "initial"}')
+	tribunal_emit_event "tribunal.iteration.start" "$p"
+	run _validate_latest_event
+	[ "$status" -eq 0 ]
+}
+
+@test "actor.start + actor.complete validate" {
+	local p
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" \
+		'{task_id: $t, iteration_id: $i, iteration_number: 0, actor_model_id: "claude-sonnet-4-6"}')
+	tribunal_emit_event "tribunal.actor.start" "$p"
+	_validate_latest_event
+
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" \
+		'{task_id: $t, success: true, duration_ms: 4200, iteration_id: $i, iteration_number: 0, artifact_kind: "patch", actor_model_id: "claude-sonnet-4-6"}')
+	tribunal_emit_event "tribunal.actor.complete" "$p"
+	run _validate_latest_event
+	[ "$status" -eq 0 ]
+}
+
+@test "jury.empaneled validates" {
+	local p
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" --arg j "$JUDGE_ID" '{
+		task_id: $t,
+		iteration_id: $i,
+		judges: [
+			{judge_id: $j, judge_type: "standard", model_id: "claude-opus-4-7"},
+			{judge_id: ($j+"X"), judge_type: "adversarial", model_id: "claude-opus-4-7"}
+		],
+		panel_size: 2
+	}')
+	tribunal_emit_event "tribunal.jury.empaneled" "$p"
+	run _validate_latest_event
+	[ "$status" -eq 0 ]
+}
+
+@test "judge.start + verdict validate" {
+	local p
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" --arg j "$JUDGE_ID" \
+		'{task_id: $t, iteration_id: $i, judge_id: $j, judge_type: "standard", judge_model_id: "claude-opus-4-7"}')
+	tribunal_emit_event "tribunal.judge.start" "$p"
+	_validate_latest_event
+
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" --arg j "$JUDGE_ID" '{
+		task_id: $t,
+		score: 0.82,
+		passed: true,
+		judge_type: "standard",
+		iteration_id: $i,
+		judge_id: $j,
+		judge_model_id: "claude-opus-4-7",
+		criteria_evaluated: ["correctness","completeness","clarity"],
+		strengths_count: 3,
+		weaknesses_count: 1,
+		confidence: 0.85,
+		feedback_summary: "looks fine"
+	}')
+	tribunal_emit_event "tribunal.verdict" "$p"
+	run _validate_latest_event
+	[ "$status" -eq 0 ]
+}
+
+@test "meta.start + meta.complete validate (with bias_types)" {
+	local p
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" \
+		'{task_id: $t, iteration_id: $i, meta_model_id: "claude-opus-4-7", verdicts_reviewed: 2}')
+	tribunal_emit_event "tribunal.meta.start" "$p"
+	_validate_latest_event
+
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" '{
+		task_id: $t,
+		verdict_quality: "questionable",
+		bias_detected: true,
+		bias_types: ["verbosity","sycophancy"],
+		override_recommendation: "re-evaluate",
+		confidence: 0.7,
+		iteration_id: $i,
+		meta_model_id: "claude-opus-4-7"
+	}')
+	tribunal_emit_event "tribunal.meta.complete" "$p"
+	run _validate_latest_event
+	[ "$status" -eq 0 ]
+}
+
+@test "consensus.reached validates" {
+	local p
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" --arg j "$JUDGE_ID" '{
+		task_id: $t,
+		iteration_id: $i,
+		aggregated_score: 0.7,
+		passed: true,
+		aggregation_method: "weighted_mean",
+		judges: [{judge_id: $j, score: 0.8},{judge_id: ($j+"X"), score: 0.6}]
+	}')
+	tribunal_emit_event "tribunal.consensus.reached" "$p"
+	run _validate_latest_event
+	[ "$status" -eq 0 ]
+}
+
+@test "dissent.recorded validates with re-evaluate resolution" {
+	local p
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" --arg j "$JUDGE_ID" '{
+		task_id: $t,
+		iteration_id: $i,
+		disagreement_score: 0.5,
+		judges: [
+			{judge_id: $j, score: 0.85, passed: true},
+			{judge_id: ($j+"X"), score: 0.35, passed: false}
+		],
+		resolution: "re-evaluate"
+	}')
+	tribunal_emit_event "tribunal.dissent.recorded" "$p"
+	run _validate_latest_event
+	[ "$status" -eq 0 ]
+}
+
+@test "gate.passed and gate.blocked validate" {
+	local p
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" \
+		'{task_id: $t, iteration_id: $i, final_score: 0.82, iteration_number: 0, judges_consulted: 2}')
+	tribunal_emit_event "tribunal.gate.passed" "$p"
+	_validate_latest_event
+
+	p=$(jq -n --arg t "$TASK_ID" --arg i "$ITER_ID" '{
+		task_id: $t,
+		iteration_id: $i,
+		reason: "low_score",
+		final_score: 0.42,
+		iteration_number: 0,
+		will_retry: true,
+		retry_iteration_number: 1
+	}')
+	tribunal_emit_event "tribunal.gate.blocked" "$p"
+	run _validate_latest_event
+	[ "$status" -eq 0 ]
+}
+
+@test "session.complete validates with exhausted_iterations outcome" {
+	local p
+	p=$(jq -n --arg t "$TASK_ID" \
+		'{task_id: $t, outcome: "exhausted_iterations", final_score: 0.55, iterations_used: 3, total_duration_ms: 28000}')
+	tribunal_emit_event "tribunal.session.complete" "$p"
+	run _validate_latest_event
+	[ "$status" -eq 0 ]
+}
+
+@test "emission fails loudly on bogus event_type (schema rejects)" {
+	run tribunal_emit_event "tribunal.no.such.event" '{"task_id":"x"}'
+	[ "$status" -ne 0 ]
+}