@rubytech/create-realagent-code 0.1.254 → 0.1.255

package/payload/platform/plugins/admin/hooks/__tests__/{session-end-retrospective.test.sh → insight.test.sh}

@@ -1,45 +1,40 @@
 #!/usr/bin/env bash
-# Task 282 — session-end retrospective Stop hook test suite.
+# Task 634 — on-demand `/insight` UserPromptSubmit hook test suite.
 #
 # Listener-mock pattern: a local Python HTTP server stands in for
 # /api/admin/log-ingest and records every POST so the assertions can read
 # every log line the hook emitted.
 #
-# Contract under test:
-#   - All log emissions go through POST /api/admin/log-ingest. Hook stderr
-#     stays silent on every path EXCEPT the gate-blocked path, which writes
-#     the three-pass retrospective instruction block to stderr (Stop-hook
-#     contract — that is how the agent receives the instruction).
-#   - Every gated-off path emits one `trigger-skipped reason=<r>` line and
-#     exits 0:
+# Contract under test (run-and-continue, no Stop gate):
+#   - Event is UserPromptSubmit. Trigger detection reads the `prompt` field
+#     of the stdin envelope, NOT the transcript. The token `/insight` is
+#     matched case-insensitively, as the whole message (after strip) OR as a
+#     standalone line — never embedded in prose.
+#   - On match: the four-pass instruction is printed to STDOUT (UserPromptSubmit
+#     stdout is injected as turn context), `trigger sessionId=<id> token=/insight`
+#     is emitted via log-ingest, exit 0. No stderr instruction, no exit 2.
+#   - Every gated-off / non-match path emits one `trigger-skipped reason=<r>`
+#     line and exits 0:
 #       role-not-admin | is-specialist | empty-stdin | missing-transcript |
-#       no-intent-match
-#   - End-intent triggers: `/end`, `/archive`, `end session`,
-#     `archive this session`, applied case-insensitively to the latest
-#     real-user message. `tool_result`-only user records are NOT the
-#     latest user message. Embedded prose ("I'll end session by 5pm")
-#     does NOT trigger.
-#   - When the intent matches and the sentinel `tool_use` of
-#     `session-retrospective-mark-complete` is absent from the JSONL:
-#     exit 2, stderr carries the instruction block,
-#     `gate-blocked sessionId=<id> reason=sentinel-absent` emitted.
-#   - When the intent matches and the sentinel `tool_use` is present:
-#     exit 0, `gate-released sessionId=<id>` emitted.
-#   - Re-entry: a second Stop fired after the sentinel call still releases
-#     (the sentinel-grep is the re-entry guard).
-#   - Per-session scoping: a sentinel in a DIFFERENT session's JSONL does
-#     NOT release the active gate.
+#       no-insight-token
+#   - Standing reconciliation: on every invocation the hook scans the
+#     transcript (`transcript_path`) for the latest real-user turn whose text
+#     matches `/insight`; if no `session-retrospective-mark-complete` tool_use
+#     appears after that turn, it emits
+#     `prior-incomplete sessionId=<id> triggered-turn=<idx>`. A sentinel after
+#     the latest `/insight` turn suppresses the emit.
+#   - All log emissions go through POST /api/admin/log-ingest. The only stdout
+#     writer is the instruction block on the trigger path.
 
 set -u
 
-HOOK="$(cd "$(dirname "$0")/.." && pwd)/session-end-retrospective.sh"
+HOOK="$(cd "$(dirname "$0")/.." && pwd)/insight.sh"
 if [[ ! -x "$HOOK" ]]; then
   echo "FAIL: $HOOK not executable" >&2
   exit 1
 fi
 
 OP_ID='aaaaaaaa-1111-2222-3333-bbbbbbbbbbbb'
-OTHER_ID='99999999-7777-6666-5555-444444444444'
 
 TMPFILES=()
 LISTENER_PIDS=()
@@ -120,14 +115,11 @@ for raw in sys.stdin:
 ' || true
 }
 
-# Build a JSONL transcript from positional jq-style triples. Each triple is
-# role|text|extra where extra is one of:
-#   ""                                  → plain user/assistant text record
-#   "tool_use:<NAME>"                   → assistant record carrying a
-#                                          tool_use block of that name
-#   "tool_result"                       → user record carrying only a
-#                                          tool_result block (not a real
-#                                          user turn)
+# Build a JSONL transcript from positional triples. Each triple is
+#   role|text|extra where extra is one of:
+#   ""                  → plain user/assistant text record
+#   "tool_use:<NAME>"   → assistant record carrying a tool_use block
+#   "tool_result"       → user record carrying only a tool_result block
 write_transcript() {
   local out="$1"; shift
   : > "$out"
@@ -138,7 +130,7 @@ spec = sys.argv[2:]
 with open(out, "w", encoding="utf-8") as f:
     for entry in spec:
         role, text, extra = entry.split("|", 2)
-        rec = {"type": role, "timestamp": "2026-05-24T10:00:00.000Z"}
+        rec = {"type": role, "timestamp": "2026-06-05T10:00:00.000Z"}
         if role == "user":
             if extra == "tool_result":
                 rec["message"] = {
@@ -172,24 +164,33 @@ with open(out, "w", encoding="utf-8") as f:
 PY
 }
 
+# UserPromptSubmit envelope: session_id, transcript_path, prompt, hook_event_name.
 envelope_for() {
   python3 -c '
 import json, sys
-print(json.dumps({"session_id": sys.argv[1], "transcript_path": sys.argv[2]}))
-' "$1" "$2"
+print(json.dumps({
+    "session_id": sys.argv[1],
+    "transcript_path": sys.argv[2],
+    "prompt": sys.argv[3],
+    "hook_event_name": "UserPromptSubmit",
+}))
+' "$1" "$2" "$3"
 }
 
+# A transcript with no prior /insight turn — used whenever the test is about
+# trigger detection and reconciliation must stay silent.
+NEUTRAL_TRANSCRIPT=$(mktemp); TMPFILES+=("$NEUTRAL_TRANSCRIPT")
+
 # ---------------------------------------------------------------------------
 # Case 1: role != admin → trigger-skipped reason=role-not-admin
 # ---------------------------------------------------------------------------
 start_listener
-TRANSCRIPT_PUBLIC=$(mktemp); TMPFILES+=("$TRANSCRIPT_PUBLIC")
-write_transcript "$TRANSCRIPT_PUBLIC" "user|/end|"
-ENV_PUBLIC=$(envelope_for "$OP_ID" "$TRANSCRIPT_PUBLIC")
+write_transcript "$NEUTRAL_TRANSCRIPT" "user|hello|" "assistant|hi|"
+ENV_INSIGHT=$(envelope_for "$OP_ID" "$NEUTRAL_TRANSCRIPT" "/insight")
 : > "$REQ_LOG"
-run_hook "public" "" "$ENV_PUBLIC"
+run_hook "public" "" "$ENV_INSIGHT"
 [[ "$HOOK_RC" -eq 0 ]] || fail "case-1 rc=$HOOK_RC"
-[[ -z "$HOOK_STDERR" ]] || fail "case-1 stderr must be empty, got: $HOOK_STDERR"
+[[ -z "$HOOK_STDOUT" ]] || fail "case-1 stdout must be empty, got: $HOOK_STDOUT"
 if ingest_lines | grep -qE '^trigger-skipped sessionId=.* reason=role-not-admin$'; then
   pass "case-1 role=public → trigger-skipped reason=role-not-admin"
 else
@@ -200,9 +201,9 @@ fi
 # Case 2: MAXY_SPECIALIST set → trigger-skipped is-specialist
 # ---------------------------------------------------------------------------
 : > "$REQ_LOG"
-run_hook "admin" "database-operator" "$ENV_PUBLIC"
+run_hook "admin" "database-operator" "$ENV_INSIGHT"
 [[ "$HOOK_RC" -eq 0 ]] || fail "case-2 rc=$HOOK_RC"
-[[ -z "$HOOK_STDERR" ]] || fail "case-2 stderr must be empty, got: $HOOK_STDERR"
+[[ -z "$HOOK_STDOUT" ]] || fail "case-2 stdout must be empty, got: $HOOK_STDOUT"
 if ingest_lines | grep -qE '^trigger-skipped sessionId=.* reason=is-specialist specialist=database-operator$'; then
   pass "case-2 specialist=database-operator → trigger-skipped is-specialist"
 else
@@ -225,7 +226,7 @@ fi
 # Case 4: missing transcript_path → trigger-skipped missing-transcript
 # ---------------------------------------------------------------------------
 : > "$REQ_LOG"
-BAD_ENV=$(python3 -c 'import json,sys; print(json.dumps({"session_id": sys.argv[1]}))' "$OP_ID")
+BAD_ENV=$(python3 -c 'import json,sys; print(json.dumps({"session_id": sys.argv[1], "prompt": "/insight"}))' "$OP_ID")
 run_hook "admin" "" "$BAD_ENV"
 [[ "$HOOK_RC" -eq 0 ]] || fail "case-4 rc=$HOOK_RC"
 if ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=missing-transcript$"; then
@@ -235,162 +236,160 @@ else
 fi
 
 # ---------------------------------------------------------------------------
-# Case 5: no end-intent token → trigger-skipped reason=no-intent-match
+# Case 5: prompt has no /insight token → trigger-skipped reason=no-insight-token
 # ---------------------------------------------------------------------------
-TRANSCRIPT_BORING=$(mktemp); TMPFILES+=("$TRANSCRIPT_BORING")
-write_transcript "$TRANSCRIPT_BORING" \
-  "user|hello|" \
-  "assistant|hi|" \
-  "user|what's the weather|"
-ENV_BORING=$(envelope_for "$OP_ID" "$TRANSCRIPT_BORING")
+ENV_BORING=$(envelope_for "$OP_ID" "$NEUTRAL_TRANSCRIPT" "what's the weather today")
 : > "$REQ_LOG"
 run_hook "admin" "" "$ENV_BORING"
 [[ "$HOOK_RC" -eq 0 ]] || fail "case-5 rc=$HOOK_RC"
-[[ -z "$HOOK_STDERR" ]] || fail "case-5 stderr must be empty"
-if ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=no-intent-match$"; then
-  pass "case-5 no intent token → trigger-skipped reason=no-intent-match"
+[[ -z "$HOOK_STDOUT" ]] || fail "case-5 stdout must be empty"
+if ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=no-insight-token$"; then
+  pass "case-5 no token → trigger-skipped reason=no-insight-token"
 else
-  fail "case-5 expected no-intent-match, got: $(ingest_lines)"
+  fail "case-5 expected no-insight-token, got: $(ingest_lines)"
 fi
 
 # ---------------------------------------------------------------------------
-# Case 6: each intent token triggers gate-blocked (sentinel absent)
+# Case 6: prompt is exactly /insight → instruction on stdout, trigger logged
 # ---------------------------------------------------------------------------
-for TOKEN in "/end" "/archive" "end session" "archive this session"; do
-  T_FILE=$(mktemp); TMPFILES+=("$T_FILE")
-  write_transcript "$T_FILE" "user|hi|" "assistant|hello|" "user|${TOKEN}|"
-  ENV_BLOCK=$(envelope_for "$OP_ID" "$T_FILE")
-  : > "$REQ_LOG"
-  run_hook "admin" "" "$ENV_BLOCK"
-  if [[ "$HOOK_RC" -ne 2 ]]; then
-    fail "case-6:${TOKEN} expected rc=2, got $HOOK_RC"
-    continue
-  fi
-  if ! ingest_lines | grep -qE "^trigger sessionId=${OP_ID} token=${TOKEN}$"; then
-    fail "case-6:${TOKEN} missing trigger line, got: $(ingest_lines)"
-    continue
-  fi
-  if ! ingest_lines | grep -qE "^gate-blocked sessionId=${OP_ID} reason=sentinel-absent$"; then
-    fail "case-6:${TOKEN} missing gate-blocked line, got: $(ingest_lines)"
-    continue
-  fi
-  if ! printf '%s' "$HOOK_STDERR" | grep -q "session-retrospective-mark-complete"; then
-    fail "case-6:${TOKEN} instruction block missing sentinel tool name on stderr"
-    continue
-  fi
-  if ! printf '%s' "$HOOK_STDERR" | grep -q "database-operator"; then
-    fail "case-6:${TOKEN} instruction block missing database-operator reference"
-    continue
-  fi
-  pass "case-6:${TOKEN} triggers gate-blocked exit 2 + instruction stderr"
-done
+: > "$REQ_LOG"
+run_hook "admin" "" "$ENV_INSIGHT"
+[[ "$HOOK_RC" -eq 0 ]] || fail "case-6 expected rc=0, got $HOOK_RC"
+[[ -z "$HOOK_STDERR" ]] || fail "case-6 stderr must be empty (no exit-2 instruction path), got: $HOOK_STDERR"
+if ! printf '%s' "$HOOK_STDOUT" | grep -q "session-retrospective-mark-complete"; then
+  fail "case-6 instruction (stdout) missing sentinel tool name"
+fi
+if ! printf '%s' "$HOOK_STDOUT" | grep -q "database-operator"; then
+  fail "case-6 instruction (stdout) missing database-operator reference"
+fi
+if ! printf '%s' "$HOOK_STDOUT" | grep -qi "keep going\|continue"; then
+  fail "case-6 instruction (stdout) missing run-and-continue wording"
+fi
+if ingest_lines | grep -qE "^trigger sessionId=${OP_ID} token=/insight$"; then
+  pass "case-6 /insight whole-message → instruction on stdout + trigger logged"
+else
+  fail "case-6 expected trigger line, got: $(ingest_lines)"
+fi
 
 # ---------------------------------------------------------------------------
-# Case 7: intent token + sentinel present → gate-released exit 0
+# Case 7: /insight as a standalone line among other lines → triggers
 # ---------------------------------------------------------------------------
-T_RELEASE=$(mktemp); TMPFILES+=("$T_RELEASE")
-write_transcript "$T_RELEASE" \
-  "user|hi|" \
-  "assistant|hello|" \
-  "user|/end|" \
-  "assistant|running retrospective|" \
-  "assistant||tool_use:mcp__admin__session-retrospective-mark-complete"
-ENV_REL=$(envelope_for "$OP_ID" "$T_RELEASE")
+ENV_LINE=$(envelope_for "$OP_ID" "$NEUTRAL_TRANSCRIPT" $'here is some context\n/insight\nthanks')
 : > "$REQ_LOG"
-run_hook "admin" "" "$ENV_REL"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-7 expected rc=0, got $HOOK_RC"
-[[ -z "$HOOK_STDERR" ]] || fail "case-7 stderr must be empty, got: $HOOK_STDERR"
-if ingest_lines | grep -qE "^gate-released sessionId=${OP_ID}$"; then
-  pass "case-7 sentinel present → gate-released exit 0"
+run_hook "admin" "" "$ENV_LINE"
+[[ "$HOOK_RC" -eq 0 ]] || fail "case-7 rc=$HOOK_RC"
+if ingest_lines | grep -qE "^trigger sessionId=${OP_ID} token=/insight$"; then
+  pass "case-7 /insight standalone line → triggers"
 else
-  fail "case-7 expected gate-released, got: $(ingest_lines)"
+  fail "case-7 expected trigger, got: $(ingest_lines)"
 fi
 
 # ---------------------------------------------------------------------------
-# Case 8: re-entry — Stop fires twice after sentinel call, both release
+# Case 8: case-insensitive — /INSIGHT triggers, logged as /insight
 # ---------------------------------------------------------------------------
+ENV_CASE=$(envelope_for "$OP_ID" "$NEUTRAL_TRANSCRIPT" "/INSIGHT")
 : > "$REQ_LOG"
-run_hook "admin" "" "$ENV_REL"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-8 second-stop rc=$HOOK_RC"
-if ingest_lines | grep -qE "^gate-released sessionId=${OP_ID}$"; then
-  pass "case-8 re-entry: second Stop after sentinel still releases"
+run_hook "admin" "" "$ENV_CASE"
+[[ "$HOOK_RC" -eq 0 ]] || fail "case-8 rc=$HOOK_RC"
+if ingest_lines | grep -qE "^trigger sessionId=${OP_ID} token=/insight$"; then
+  pass "case-8 case-insensitive: /INSIGHT normalises to /insight"
 else
-  fail "case-8 second Stop did not emit gate-released, got: $(ingest_lines)"
+  fail "case-8 expected token=/insight, got: $(ingest_lines)"
 fi
 
 # ---------------------------------------------------------------------------
-# Case 9: per-session scoping — sentinel lives in a different session's
-#          JSONL; active gate must NOT release
+# Case 9: embedded prose does NOT trigger
 # ---------------------------------------------------------------------------
-T_OTHER=$(mktemp); TMPFILES+=("$T_OTHER")
-write_transcript "$T_OTHER" \
-  "user|/end|" \
-  "assistant||tool_use:mcp__admin__session-retrospective-mark-complete"
-# Active gate inspects only T_ACTIVE (no sentinel inside).
-T_ACTIVE=$(mktemp); TMPFILES+=("$T_ACTIVE")
-write_transcript "$T_ACTIVE" "user|/end|"
-ENV_ACTIVE=$(envelope_for "$OP_ID" "$T_ACTIVE")
+ENV_PROSE=$(envelope_for "$OP_ID" "$NEUTRAL_TRANSCRIPT" "can you give me some /insight into the numbers")
+: > "$REQ_LOG"
+run_hook "admin" "" "$ENV_PROSE"
+[[ "$HOOK_RC" -eq 0 ]] || fail "case-9 rc=$HOOK_RC"
+[[ -z "$HOOK_STDOUT" ]] || fail "case-9 stdout must be empty (prose must not trigger)"
+if ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=no-insight-token$"; then
+  pass "case-9 embedded '/insight' prose does not trigger"
+else
+  fail "case-9 expected no-insight-token, got: $(ingest_lines)"
+fi
+
+# ---------------------------------------------------------------------------
+# Case 10: reconciliation — prior /insight turn with NO sentinel after it →
+#           prior-incomplete emitted (and current non-token prompt skips)
+# ---------------------------------------------------------------------------
+T_INCOMPLETE=$(mktemp); TMPFILES+=("$T_INCOMPLETE")
+write_transcript "$T_INCOMPLETE" \
+  "user|hi|" \
+  "assistant|hello|" \
+  "user|/insight|" \
+  "assistant|here is a prose summary|"
+ENV_RECON=$(envelope_for "$OP_ID" "$T_INCOMPLETE" "what's next")
 : > "$REQ_LOG"
-run_hook "admin" "" "$ENV_ACTIVE"
-[[ "$HOOK_RC" -eq 2 ]] || fail "case-9 expected rc=2 (other session's sentinel must not release), got $HOOK_RC"
-if ingest_lines | grep -qE "^gate-blocked sessionId=${OP_ID} reason=sentinel-absent$"; then
-  pass "case-9 per-session scoping: sentinel in another transcript does not release"
+run_hook "admin" "" "$ENV_RECON"
+[[ "$HOOK_RC" -eq 0 ]] || fail "case-10 rc=$HOOK_RC"
+if ! ingest_lines | grep -qE "^prior-incomplete sessionId=${OP_ID} triggered-turn=[0-9]+$"; then
+  fail "case-10 expected prior-incomplete, got: $(ingest_lines)"
+elif ! ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=no-insight-token$"; then
+  fail "case-10 expected current prompt skip, got: $(ingest_lines)"
 else
-  fail "case-9 expected gate-blocked, got: $(ingest_lines)"
+  pass "case-10 prior /insight without sentinel → prior-incomplete"
 fi
 
 # ---------------------------------------------------------------------------
-# Case 10: `tool_result`-only user record is NOT the latest user message;
-#           the prior real user message wins.
+# Case 11: reconciliation negative — prior /insight turn WITH a sentinel
+#           tool_use after it → no prior-incomplete
 # ---------------------------------------------------------------------------
-T_TR_ONLY=$(mktemp); TMPFILES+=("$T_TR_ONLY")
-write_transcript "$T_TR_ONLY" \
-  "user|/end|" \
-  "assistant||tool_use:Read" \
-  "user|noise|tool_result"
-ENV_TR=$(envelope_for "$OP_ID" "$T_TR_ONLY")
+T_COMPLETE=$(mktemp); TMPFILES+=("$T_COMPLETE")
+write_transcript "$T_COMPLETE" \
+  "user|hi|" \
+  "user|/insight|" \
+  "assistant|running passes|" \
+  "assistant||tool_use:mcp__admin__session-retrospective-mark-complete"
+ENV_DONE=$(envelope_for "$OP_ID" "$T_COMPLETE" "what's next")
 : > "$REQ_LOG"
-run_hook "admin" "" "$ENV_TR"
-[[ "$HOOK_RC" -eq 2 ]] || fail "case-10 expected rc=2 (tool_result must not mask /end), got $HOOK_RC"
-if ingest_lines | grep -qE "^gate-blocked sessionId=${OP_ID} reason=sentinel-absent$"; then
-  pass "case-10 tool_result-only user record does not mask latest real user /end"
+run_hook "admin" "" "$ENV_DONE"
+[[ "$HOOK_RC" -eq 0 ]] || fail "case-11 rc=$HOOK_RC"
+if ingest_lines | grep -qE "^prior-incomplete"; then
+  fail "case-11 sentinel present must suppress prior-incomplete, got: $(ingest_lines)"
 else
-  fail "case-10 expected gate-blocked, got: $(ingest_lines)"
+  pass "case-11 prior /insight with sentinel → no prior-incomplete"
 fi
 
 # ---------------------------------------------------------------------------
-# Case 11: embedded prose does NOT trigger ("I'll end session by 5pm")
+# Case 13: the just-submitted /insight turn is already in the transcript with
+#           no assistant response yet → must NOT self-report prior-incomplete.
+#           (Guards against the false positive if Claude Code writes the
+#           current prompt to the transcript before UserPromptSubmit fires.)
 # ---------------------------------------------------------------------------
-T_PROSE=$(mktemp); TMPFILES+=("$T_PROSE")
-write_transcript "$T_PROSE" "user|I'll end session by 5pm|"
-ENV_PROSE=$(envelope_for "$OP_ID" "$T_PROSE")
+T_CURRENT=$(mktemp); TMPFILES+=("$T_CURRENT")
+write_transcript "$T_CURRENT" \
+  "user|hi|" \
+  "assistant|hello|" \
+  "user|/insight|"
+ENV_CURRENT=$(envelope_for "$OP_ID" "$T_CURRENT" "/insight")
 : > "$REQ_LOG"
-run_hook "admin" "" "$ENV_PROSE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-11 expected rc=0 (prose must not trigger), got $HOOK_RC"
-if ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=no-intent-match$"; then
-  pass "case-11 embedded prose 'end session' does not trigger gate"
+run_hook "admin" "" "$ENV_CURRENT"
+[[ "$HOOK_RC" -eq 0 ]] || fail "case-13 rc=$HOOK_RC"
+if ingest_lines | grep -qE "^prior-incomplete"; then
+  fail "case-13 current /insight turn must not self-report prior-incomplete, got: $(ingest_lines)"
+elif ingest_lines | grep -qE "^trigger sessionId=${OP_ID} token=/insight$"; then
+  pass "case-13 current /insight (in transcript, no response yet) → trigger only, no prior-incomplete"
 else
-  fail "case-11 expected no-intent-match, got: $(ingest_lines)"
+  fail "case-13 expected trigger without prior-incomplete, got: $(ingest_lines)"
 fi
 
 # ---------------------------------------------------------------------------
-# Case 12: case-insensitive match — `/END` triggers like `/end`
+# Case 12: no path returns exit 2 — /insight must not block the turn
 # ---------------------------------------------------------------------------
-T_CASE=$(mktemp); TMPFILES+=("$T_CASE")
-write_transcript "$T_CASE" "user|/END|"
-ENV_CASE=$(envelope_for "$OP_ID" "$T_CASE")
 : > "$REQ_LOG"
-run_hook "admin" "" "$ENV_CASE"
-[[ "$HOOK_RC" -eq 2 ]] || fail "case-12 expected rc=2 for /END, got $HOOK_RC"
-if ingest_lines | grep -qE "^trigger sessionId=${OP_ID} token=/end$"; then
-  pass "case-12 case-insensitive: /END normalises to /end"
+run_hook "admin" "" "$ENV_INSIGHT"
+if [[ "$HOOK_RC" -eq 2 ]]; then
+  fail "case-12 hook must never exit 2 (run-and-continue), got rc=$HOOK_RC"
 else
-  fail "case-12 expected token=/end, got: $(ingest_lines)"
+  pass "case-12 trigger path exits 0, never 2"
 fi
 
 # ---------------------------------------------------------------------------
 # Summary
 # ---------------------------------------------------------------------------
 echo
-echo "session-end-retrospective tests: $PASS passed, $FAIL failed"
+echo "insight tests: $PASS passed, $FAIL failed"
 [[ "$FAIL" -eq 0 ]]