@rubytech/create-realagent-code 0.1.248 → 0.1.250

package/payload/platform/plugins/admin/hooks/__tests__/turn-completed-graph-write.test.sh

@@ -1,601 +0,0 @@
-#!/usr/bin/env bash
-# Task 129/131/165/175/177/195/214/216 regression test for the Stop hook.
-#
-# Dormant since Task 214 — the Stop-hook registration was removed from
-# account `settings.json`; the script + this test remain as preserved
-# infrastructure (see PLUGIN.md). When the script does run (e.g. via this
-# test invoking it directly), the post-Task-214 `database-operator.md`
-# template carries no `{schema}` / `{conversation}` / `{accountId}`
-# placeholders, so the substitution layer is a no-op pass-through and
-# `initialMessage` is the literal post-frontmatter body of the agent file.
-#
-# Contract (post-214):
-#   - Every log emission goes through `POST /api/admin/log-ingest`. Hook
-#     stderr is silent on every path.
-#   - Every gated-off path emits one `trigger-skipped` line carrying a
-#     distinct `reason=` (role-not-admin | is-recorder | empty-stdin |
-#     missing-transcript | conversation-empty).
-#   - Happy path emits exactly ONE `trigger` line carrying
-#     `conversationBytes=<n>` and exactly ONE POST to
-#     `/api/admin/claude-sessions`. The body carries the operator
-#     session id as `adminSessionId` and an `initialMessage` whose value
-#     is the literal database-operator agent body (post-frontmatter).
-#     No placeholders are substituted because the post-Task-214 template
-#     has none. The walker still parses the JSONL, still emits the
-#     `envelope … turnsCount=N userTurns=U assistantTurns=A toolCallTurns=T`
-#     log line, and the schema file is still read and reported in the
-#     `substitution … schemaBytes=N` line — but neither the transcript
-#     nor the schema content reaches `initialMessage`.
-#   - The hook emits exactly one envelope line and one substitution line
-#     before `spawn-request`.
-#   - The hook never writes the legacy `spawn-with-input` / `fired` stderr
-#     lines.
-#
-# The mock listener accepts both routes:
-#   POST /api/admin/log-ingest                            — log-ingest
-#   POST /api/admin/claude-sessions        — wrapper
-# Both record their bodies (with route path) into REQ_LOG.
-
-set -u
-
-HOOK="$(cd "$(dirname "$0")/.." && pwd)/turn-completed-graph-write.sh"
-if [[ ! -x "$HOOK" ]]; then
-  echo "FAIL: $HOOK not executable" >&2
-  exit 1
-fi
-
-OP_ID='aaaaaaaa-1111-2222-3333-bbbbbbbbbbbb'
-ACCT_ID='acct-test-0001'
-
-TMPFILES=()
-LISTENER_PIDS=()
-cleanup_test_state() {
-  for pid in "${LISTENER_PIDS[@]:-}"; do
-    if [[ -n "$pid" ]]; then
-      kill "$pid" 2>/dev/null || true
-      wait "$pid" 2>/dev/null || true
-    fi
-  done
-  for f in "${TMPFILES[@]:-}"; do
-    [[ -n "$f" ]] && rm -f "$f" 2>/dev/null || true
-  done
-}
-trap cleanup_test_state EXIT
-
-PASS=0
-FAIL=0
-pass() { echo "PASS: $1"; PASS=$((PASS + 1)); }
-fail() { echo "FAIL: $1" >&2; FAIL=$((FAIL + 1)); }
-
-start_listener() {
-  REQ_LOG=$(mktemp); TMPFILES+=("$REQ_LOG")
-  LISTENER_PORT=$((39400 + RANDOM % 100))
-  python3 - "$LISTENER_PORT" "$REQ_LOG" <<'PY' &
-import sys, http.server, json
-port = int(sys.argv[1])
-log_path = sys.argv[2]
-class H(http.server.BaseHTTPRequestHandler):
-  def log_message(self, *a, **k): pass
-  def do_POST(self):
-    n = int(self.headers.get('Content-Length','0') or 0)
-    body = self.rfile.read(n).decode('utf-8','replace')
-    with open(log_path, 'a', encoding='utf-8') as f:
-      f.write(self.path + '\t' + body + '\n')
-    self.send_response(200)
-    self.send_header('Content-Type','application/json')
-    self.end_headers()
-    if self.path == '/api/admin/claude-sessions':
-      self.wfile.write(json.dumps({"sessionId":"rec00001-feedfeed","pid":99999}).encode('utf-8'))
-    else:
-      self.wfile.write(json.dumps({"ok": True}).encode('utf-8'))
-http.server.HTTPServer(('127.0.0.1', port), H).serve_forever()
-PY
-  LISTENER_PIDS+=("$!")
-  for _ in $(seq 1 20); do
-    if curl -sS --max-time 1 -X POST "http://127.0.0.1:${LISTENER_PORT}/ping" -d '{}' >/dev/null 2>&1; then
-      break
-    fi
-    sleep 0.1
-  done
-  : > "$REQ_LOG"
-}
-
-run_hook() {
-  local role="$1"; local specialist="$2"; local stdin_json="$3"
-  local stderr_file; stderr_file=$(mktemp); TMPFILES+=("$stderr_file")
-  local stdout_file; stdout_file=$(mktemp); TMPFILES+=("$stdout_file")
-  printf '%s' "$stdin_json" | \
-    MAXY_SESSION_ROLE="$role" \
-    MAXY_SPECIALIST="$specialist" \
-    MAXY_UI_INTERNAL_PORT="$LISTENER_PORT" \
-    ACCOUNT_ID="$ACCT_ID" \
-    bash "$HOOK" >"$stdout_file" 2>"$stderr_file"
-  HOOK_RC=$?
-  HOOK_STDERR=$(cat "$stderr_file")
-  HOOK_STDOUT=$(cat "$stdout_file")
-  sleep 0.1  # let listener flush
-}
-
-# Extract the `line` field of every log-ingest POST in REQ_LOG.
-ingest_lines() {
-  grep -E '^/api/admin/log-ingest	' "$REQ_LOG" 2>/dev/null | python3 -c '
-import sys, json
-for raw in sys.stdin:
-  try:
-    _, body = raw.rstrip("\n").split("\t", 1)
-    d = json.loads(body)
-    if isinstance(d, dict) and isinstance(d.get("line"), str):
-      print(d["line"])
-  except Exception:
-    pass
-' || true
-}
-
-start_listener
-# Simple two-turn transcript with timestamps. One user, one assistant text.
-TRANSCRIPT=$(mktemp); TMPFILES+=("$TRANSCRIPT")
-{
-  printf '{"type":"user","timestamp":"2026-05-19T21:27:00.000Z","message":{"role":"user","content":"hello operator"}}\n'
-  printf '{"type":"assistant","timestamp":"2026-05-19T21:27:01.000Z","message":{"id":"msg_001","role":"assistant","content":[{"type":"text","text":"hello, assistant reply"}]}}\n'
-} > "$TRANSCRIPT"
-ENVELOPE=$(python3 -c '
-import json, sys
-print(json.dumps({"session_id": sys.argv[1], "transcript_path": sys.argv[2]}))
-' "$OP_ID" "$TRANSCRIPT")
-
-# --- Case 1: role != admin → trigger-skipped reason=role-not-admin -----
-: > "$REQ_LOG"
-run_hook "public" "" "$ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-1 rc=$HOOK_RC"
-[[ -z "$HOOK_STDERR" ]] || fail "case-1 stderr must be empty, got: $HOOK_STDERR"
-if ingest_lines | grep -qE '^trigger-skipped sessionId=.* reason=role-not-admin$'; then
-  pass "case-1 role=public → trigger-skipped reason=role-not-admin emitted"
-else
-  fail "case-1 expected trigger-skipped role-not-admin, got log-ingest lines: $(ingest_lines)"
-fi
-if grep -qE '^/api/admin/claude-sessions	' "$REQ_LOG"; then
-  fail "case-1 recorder-spawn must NOT be called when role!=admin"
-else
-  pass "case-1 no recorder-spawn POST"
-fi
-
-# --- Case 2: MAXY_SPECIALIST=database-operator → trigger-skipped is-recorder ----
-: > "$REQ_LOG"
-run_hook "admin" "database-operator" "$ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-2 rc=$HOOK_RC"
-[[ -z "$HOOK_STDERR" ]] || fail "case-2 stderr must be empty, got: $HOOK_STDERR"
-if ingest_lines | grep -qE '^trigger-skipped sessionId=.* reason=is-recorder$'; then
-  pass "case-2 MAXY_SPECIALIST=database-operator → trigger-skipped reason=is-recorder emitted"
-else
-  fail "case-2 expected trigger-skipped is-recorder, got: $(ingest_lines)"
-fi
-
-# --- Case 3: empty stdin → trigger-skipped reason=empty-stdin ------------
-: > "$REQ_LOG"
-run_hook "admin" "" ""
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-3 rc=$HOOK_RC"
-if ingest_lines | grep -qE '^trigger-skipped sessionId=.* reason=empty-stdin$'; then
-  pass "case-3 empty stdin → trigger-skipped reason=empty-stdin emitted"
-else
-  fail "case-3 expected trigger-skipped empty-stdin, got: $(ingest_lines)"
-fi
-
-# --- Case 4: missing transcript_path → trigger-skipped missing-transcript -
-: > "$REQ_LOG"
-BAD_ENVELOPE=$(python3 -c 'import json,sys; print(json.dumps({"session_id": sys.argv[1]}))' "$OP_ID")
-run_hook "admin" "" "$BAD_ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-4 rc=$HOOK_RC"
-if ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=missing-transcript$"; then
-  pass "case-4 missing transcript → trigger-skipped reason=missing-transcript emitted"
-else
-  fail "case-4 expected trigger-skipped missing-transcript, got: $(ingest_lines)"
-fi
-
-# --- Case 5 (Task 177): ordered-turns happy path -----------------------
-# Transcript with four turns: user-A, asst-A-reply, user-B, asst-B-reply.
-# Envelope `turns` array must carry exactly that order, oldest first.
-# Envelope shape: { turns, sessionId, accountId, occurredAt } — no
-# top-level operatorMessage / assistantReply.
-ORDERED_TRANSCRIPT=$(mktemp); TMPFILES+=("$ORDERED_TRANSCRIPT")
-{
-  printf '{"type":"user","timestamp":"2026-05-19T21:27:42.258Z","message":{"role":"user","content":"New Real Agent session"}}\n'
-  printf '{"type":"assistant","timestamp":"2026-05-19T21:27:45.158Z","message":{"id":"msg_a","role":"assistant","content":[{"type":"text","text":"Session noted. What would you like to work on?"}]}}\n'
-  printf '{"type":"user","timestamp":"2026-05-19T21:27:57.314Z","message":{"role":"user","content":"you tell me"}}\n'
-  printf '{"type":"assistant","timestamp":"2026-05-19T21:28:00.847Z","message":{"id":"msg_b","role":"assistant","content":[{"type":"text","text":"One question to anchor the next move: what is your name?"}]}}\n'
-} > "$ORDERED_TRANSCRIPT"
-ORDERED_ENVELOPE=$(python3 -c '
-import json, sys
-print(json.dumps({"session_id": sys.argv[1], "transcript_path": sys.argv[2]}))
-' "$OP_ID" "$ORDERED_TRANSCRIPT")
-: > "$REQ_LOG"
-run_hook "admin" "" "$ORDERED_ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-5 rc=$HOOK_RC stderr=$HOOK_STDERR"
-[[ -z "$HOOK_STDERR" ]] || fail "case-5 stderr must be empty, got: $HOOK_STDERR"
-
-# 5a. exactly ONE `trigger` log-ingest line carrying the operator session id.
-TRIGGER_COUNT=$(ingest_lines | grep -cE "^trigger sessionId=${OP_ID} turnIndex=0 transcriptBytes=[0-9]+ conversationBytes=[0-9]+$" || true)
-if [[ "$TRIGGER_COUNT" -eq 1 ]]; then
-  pass "case-5a exactly one trigger line via log-ingest"
-else
-  fail "case-5a expected exactly 1 trigger line, got $TRIGGER_COUNT (lines: $(ingest_lines))"
-fi
-
-# 5b. exactly ONE POST to /api/admin/claude-sessions
-RECORDER_LINES=$(grep -cE '^/api/admin/claude-sessions	' "$REQ_LOG" || true)
-if [[ "$RECORDER_LINES" -eq 1 ]]; then
-  pass "case-5b exactly one recorder-spawn POST observed"
-else
-  fail "case-5b expected exactly 1 recorder-spawn POST, got $RECORDER_LINES"
-fi
-
-# 5c. (Task 216) initialMessage is the literal post-frontmatter body of
-#     `database-operator.md`. Task 214 stripped the `{schema}` /
-#     `{conversation}` / `{accountId}` placeholders from the template,
-#     so the substitution layer in the hook is now a no-op pass-through
-#     and the agent body lands in `initialMessage` verbatim. Assertions
-#     are property-based — they guard the regression class (substitution
-#     layer reintroduced, transcript leak, schema content leak, outer
-#     spawn-body drift) without coupling to the prompt's exact wording.
-RECORDER_BODY=$(grep -E '^/api/admin/claude-sessions	' "$REQ_LOG" | head -1 | cut -f2-)
-BODY_OK=$(printf '%s' "$RECORDER_BODY" | python3 -c '
-import sys, json
-op = sys.argv[1]
-acct = sys.argv[2]
-try:
-  outer = json.load(sys.stdin)
-  msg = outer.get("initialMessage")
-  if not isinstance(msg, str):
-    print("no:initialMessage-not-string:"+repr(type(msg).__name__))
-    sys.exit(0)
-  conds = []
-  # Template-header anchor — the post-Task-214 body opens with this
-  # sentence. A different opener means the agent file was renamed,
-  # rewritten, or its frontmatter parse drifted.
-  conds.append(("starts-with-template",
-                msg.startswith("You are an expert Neo4J graph operator.")))
-  # Placeholder-reintroduction guards. If any of these reappear, Task
-  # 214 was reverted without updating the template.
-  conds.append(("no-placeholder-schema", "{schema}" not in msg))
-  conds.append(("no-placeholder-conversation", "{conversation}" not in msg))
-  conds.append(("no-placeholder-accountid", "{accountId}" not in msg))
-  # Transcript-leak guard. The walker still parses the JSONL, but its
-  # `turns` array no longer reaches `initialMessage`. Any `\nuser: ` or
-  # `\nassistant: ` line means substitution crept back in.
-  conds.append(("no-transcript-user", "\nuser: " not in msg))
-  conds.append(("no-transcript-asst", "\nassistant: " not in msg))
-  # Schema-leak guard. schema-base.md is still read (and its bytes are
-  # reported in the substitution log line), but its content is no
-  # longer substituted into the body. `Schema Reference` is the
-  # opening header of `platform/plugins/memory/references/schema-base.md`
-  # (`# Schema Reference — Base`); its appearance in the body means
-  # `{schema}` re-entered the template.
-  conds.append(("no-schema-content", "Schema Reference" not in msg))
-  # AccountId-value leak guard. If `{accountId}` is re-added in
-  # isolation (no `{schema}` / `{conversation}` reintroduction), the
-  # placeholder guards above pass (because substitution replaces the
-  # token cleanly), but the operator accountId still leaks into the
-  # prompt. The test fixture passes ACCOUNT_ID="$ACCT_ID" into the
-  # hook env, so the literal acct id must NOT appear anywhere in the
-  # body.
-  conds.append(("no-accountid-value-leak", acct not in msg))
-  # Pre-Task-177 envelope-shape guard. `initialMessage` is a plain
-  # string, never a JSON envelope.
-  conds.append(("no-leading-json", not msg.lstrip().startswith("{")))
-  conds.append(("no-operatorMessage", "operatorMessage" not in msg))
-  conds.append(("no-assistantReply", "assistantReply" not in msg))
-  # Spawn-body outer-shape sanity (unchanged from Task 195/200).
-  conds.append(("outer-specialist", outer.get("specialist") == "database-operator"))
-  conds.append(("outer-no-model-key", "model" not in outer))
-  conds.append(("outer-adminSessionId", outer.get("adminSessionId") == op))
-  conds.append(("outer-channel", outer.get("channel") == "browser"))
-  failed = [name for name, ok in conds if not ok]
-  print("yes" if not failed else "no:"+repr(failed))
-except Exception as e:
-  print("parse-fail:"+str(e))
-' "$OP_ID" "$ACCT_ID" 2>/dev/null)
-if [[ "$BODY_OK" == "yes" ]]; then
-  pass "case-5c initialMessage is the literal template body (no placeholders, no transcript leak, no schema leak); outer spawn shape intact"
-else
-  fail "case-5c literal-body shape wrong ($BODY_OK)"
-fi
-
-# 5h. (Task 195 + 199) exactly one `substitution` log-ingest line carrying
-#     positive byte counts for schema / conversation / body AND
-#     accountIdPresent=yes (the envelope's accountId is non-empty here —
-#     run_hook always passes ACCOUNT_ID="$ACCT_ID" into the hook env).
-SUBST_LINE_COUNT=$(ingest_lines | grep -cE "^substitution sessionId=${OP_ID} schemaBytes=[1-9][0-9]* conversationBytes=[1-9][0-9]* bodyBytes=[1-9][0-9]* accountIdPresent=yes$" || true)
-if [[ "$SUBST_LINE_COUNT" -eq 1 ]]; then
-  pass "case-5h substitution log line emitted once with positive byte counts and accountIdPresent=yes"
-else
-  fail "case-5h expected exactly 1 substitution line w/ positive bytes + accountIdPresent=yes, got $SUBST_LINE_COUNT (lines: $(ingest_lines))"
-fi
-
-# 5i. (Task 195) substitution line lands between envelope and spawn-request.
-ALL_5I_LINES=$(ingest_lines)
-ENV_POS_5I=$(printf '%s\n' "$ALL_5I_LINES" | grep -nE "^envelope sessionId=${OP_ID}" | head -1 | cut -d: -f1)
-SUB_POS_5I=$(printf '%s\n' "$ALL_5I_LINES" | grep -nE "^substitution sessionId=${OP_ID}" | head -1 | cut -d: -f1)
-SPAWN_POS_5I=$(printf '%s\n' "$ALL_5I_LINES" | grep -nE "^spawn-request sessionId=${OP_ID}" | head -1 | cut -d: -f1)
-if [[ -n "$ENV_POS_5I" && -n "$SUB_POS_5I" && -n "$SPAWN_POS_5I" \
-      && "$ENV_POS_5I" -lt "$SUB_POS_5I" && "$SUB_POS_5I" -lt "$SPAWN_POS_5I" ]]; then
-  pass "case-5i envelope < substitution < spawn-request ordering preserved"
-else
-  fail "case-5i ordering wrong (env=$ENV_POS_5I sub=$SUB_POS_5I spawn=$SPAWN_POS_5I)"
-fi
-
-# 5j. (Task 195) `initialMessageBytes` on spawn-request equals `bodyBytes`
-#     on substitution — the two log lines are reading the same number.
-BODY_BYTES_5J=$(printf '%s\n' "$ALL_5I_LINES" | grep -E "^substitution sessionId=${OP_ID}" | head -1 \
-                 | sed -E 's/.*bodyBytes=([0-9]+).*/\1/')
-INIT_BYTES_5J=$(printf '%s\n' "$ALL_5I_LINES" | grep -E "^spawn-request sessionId=${OP_ID}" | head -1 \
-                 | sed -E 's/.*initialMessageBytes=([0-9]+).*/\1/')
-if [[ -n "$BODY_BYTES_5J" && "$BODY_BYTES_5J" == "$INIT_BYTES_5J" ]]; then
-  pass "case-5j substitution.bodyBytes == spawn-request.initialMessageBytes (=$BODY_BYTES_5J)"
-else
-  fail "case-5j bodyBytes ($BODY_BYTES_5J) does not match initialMessageBytes ($INIT_BYTES_5J)"
-fi
-
-# 5d. exactly ONE `spawn-request` log-ingest line
-SPAWN_REQ_COUNT=$(ingest_lines | grep -cE "^spawn-request sessionId=${OP_ID} specialist=database-operator initialMessageBytes=[0-9]+$" || true)
-if [[ "$SPAWN_REQ_COUNT" -eq 1 ]]; then
-  pass "case-5d exactly one spawn-request line emitted"
-else
-  fail "case-5d expected 1 spawn-request, got $SPAWN_REQ_COUNT (lines: $(ingest_lines))"
-fi
-
-# 5e. Task 177 observability — exactly ONE `[turn-recorder] envelope ...`
-#     line emitted before `spawn-request`. The line carries turnsCount,
-#     userTurns, assistantTurns, toolCallTurns.
-ENVELOPE_LINE_COUNT=$(ingest_lines | grep -cE "^envelope sessionId=${OP_ID} turnsCount=4 userTurns=2 assistantTurns=2 toolCallTurns=0$" || true)
-if [[ "$ENVELOPE_LINE_COUNT" -eq 1 ]]; then
-  pass "case-5e envelope log line emitted with correct counts"
-else
-  fail "case-5e expected exactly 1 envelope line w/ turnsCount=4 userTurns=2 assistantTurns=2 toolCallTurns=0, got $ENVELOPE_LINE_COUNT (lines: $(ingest_lines))"
-fi
-
-# 5f. envelope line precedes spawn-request line.
-ALL_LINES=$(ingest_lines)
-ENV_POS=$(printf '%s\n' "$ALL_LINES" | grep -nE "^envelope sessionId=${OP_ID}" | head -1 | cut -d: -f1)
-SPAWN_POS=$(printf '%s\n' "$ALL_LINES" | grep -nE "^spawn-request sessionId=${OP_ID}" | head -1 | cut -d: -f1)
-if [[ -n "$ENV_POS" && -n "$SPAWN_POS" && "$ENV_POS" -lt "$SPAWN_POS" ]]; then
-  pass "case-5f envelope line precedes spawn-request"
-else
-  fail "case-5f envelope line must precede spawn-request (env=$ENV_POS spawn=$SPAWN_POS)"
-fi
-
-# 5g. no legacy stderr emissions
-if echo "$HOOK_STDERR" | grep -qE 'spawn-with-input|spawn-with-stdin|turn-completed-graph-write fired'; then
-  fail "case-5g legacy stderr line emitted: $HOOK_STDERR"
-else
-  pass "case-5g no legacy stderr emissions"
-fi
-
-# --- Case 6: multi-block assistant collapse (walker coverage) ---------
-# Two assistant records sharing `message.id`, BOTH carrying text. The
-# walker's collapse branch (turn-completed-graph-write.sh, the
-# `msg_id in msg_id_to_turn_index` branch in the assistant arm) merges
-# them into ONE assistant turn whose text is the concatenation. Without
-# the collapse the walker would emit two assistant turns. Pre-Task-214
-# this was visible in `initialMessage` via a single `\nassistant: ...`
-# line carrying both fragments; post-Task-214 the transcript no longer
-# reaches the body, so coverage moves to the envelope log line —
-# `turnsCount=2 userTurns=1 assistantTurns=1 toolCallTurns=0` proves
-# the two assistant records collapsed to one (otherwise the line would
-# read assistantTurns=2). Fixture must use TEXT-bearing records on both
-# sides; a thinking-only first record would be skipped at line 202 of
-# the walker before the collapse branch ever runs, so the test would
-# only prove the skip path (already covered by case 9) instead of the
-# collapse path.
-MULTI_TRANSCRIPT=$(mktemp); TMPFILES+=("$MULTI_TRANSCRIPT")
-{
-  printf '{"type":"user","timestamp":"2026-05-19T21:30:00.000Z","message":{"role":"user","content":"split your answer"}}\n'
-  printf '{"type":"assistant","timestamp":"2026-05-19T21:30:01.000Z","message":{"id":"msg_multi","role":"assistant","content":[{"type":"text","text":"part one"}]}}\n'
-  printf '{"type":"assistant","timestamp":"2026-05-19T21:30:02.000Z","message":{"id":"msg_multi","role":"assistant","content":[{"type":"text","text":" and part two"}]}}\n'
-} > "$MULTI_TRANSCRIPT"
-MULTI_ENVELOPE=$(python3 -c '
-import json, sys
-print(json.dumps({"session_id": sys.argv[1], "transcript_path": sys.argv[2]}))
-' "$OP_ID" "$MULTI_TRANSCRIPT")
-: > "$REQ_LOG"
-run_hook "admin" "" "$MULTI_ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-6 rc=$HOOK_RC stderr=$HOOK_STDERR"
-echo "case-6 SKIPPED — dormant since Task 214; transcript no longer substituted into initialMessage. Walker collapse now asserted via envelope log line below."
-ENV_LINE_6=$(ingest_lines | grep -cE "^envelope sessionId=${OP_ID} turnsCount=2 userTurns=1 assistantTurns=1 toolCallTurns=0$" || true)
-if [[ "$ENV_LINE_6" -eq 1 ]]; then
-  pass "case-6 envelope log line counts multi-block collapse: turnsCount=2 userTurns=1 assistantTurns=1 toolCallTurns=0"
-else
-  fail "case-6 expected 1 envelope line w/ turnsCount=2 userTurns=1 assistantTurns=1 toolCallTurns=0, got $ENV_LINE_6 (lines: $(ingest_lines))"
-fi
-
-# --- Case 7: tool-call pairing (walker coverage) ----------------------
-# Assistant tool_use + user tool_result fold into one `toolCalls` entry
-# on the assistant turn; the user-record carrying only the tool_result
-# never creates its own user turn. Pre-Task-214 this was visible in
-# `initialMessage` as "exactly one user line, two assistant lines (one
-# empty-bodied)". Post-Task-214 the transcript no longer reaches the
-# body, so the pairing is now only observable through the envelope log
-# line — `turnsCount=3 userTurns=1 assistantTurns=2 toolCallTurns=1`
-# proves the tool_result was absorbed (no extra user turn) and the
-# tool_use was paired on the owning assistant turn (toolCallTurns=1).
-TOOL_TRANSCRIPT=$(mktemp); TMPFILES+=("$TOOL_TRANSCRIPT")
-python3 - "$TOOL_TRANSCRIPT" <<'PY'
-import json, sys
-out = sys.argv[1]
-recs = [
-  {"type":"user","timestamp":"2026-05-19T21:32:00.000Z","message":{"role":"user","content":"please write a node"}},
-  {"type":"assistant","timestamp":"2026-05-19T21:32:01.000Z","message":{"id":"msg_tu","role":"assistant","content":[
-    {"type":"tool_use","id":"toolu_001","name":"mcp__memory__memory-write","input":{"nodeType":"LocalBusiness","name":"Smalleys","nested":{"k":1}}}
-  ]}},
-  {"type":"user","timestamp":"2026-05-19T21:32:02.000Z","message":{"role":"user","content":[
-    {"type":"tool_result","tool_use_id":"toolu_001","content":"ok: wrote LocalBusiness"}
-  ]}},
-  {"type":"assistant","timestamp":"2026-05-19T21:32:03.000Z","message":{"id":"msg_done","role":"assistant","content":[
-    {"type":"text","text":"done"}
-  ]}},
-]
-with open(out,"w") as f:
-  for r in recs: f.write(json.dumps(r)+"\n")
-PY
-TOOL_ENVELOPE=$(python3 -c '
-import json, sys
-print(json.dumps({"session_id": sys.argv[1], "transcript_path": sys.argv[2]}))
-' "$OP_ID" "$TOOL_TRANSCRIPT")
-: > "$REQ_LOG"
-run_hook "admin" "" "$TOOL_ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-7 rc=$HOOK_RC stderr=$HOOK_STDERR"
-echo "case-7 SKIPPED — dormant since Task 214; transcript no longer substituted into initialMessage. Tool-call pairing now asserted via envelope log line below."
-
-# Envelope log line for case-7: turnsCount=3, userTurns=1, assistantTurns=2, toolCallTurns=1
-ENV_LINE_7=$(ingest_lines | grep -cE "^envelope sessionId=${OP_ID} turnsCount=3 userTurns=1 assistantTurns=2 toolCallTurns=1$" || true)
-if [[ "$ENV_LINE_7" -eq 1 ]]; then
-  pass "case-7 envelope log line counts tool-call turn correctly: turnsCount=3 userTurns=1 assistantTurns=2 toolCallTurns=1"
-else
-  fail "case-7 expected envelope line w/ turnsCount=3 userTurns=1 assistantTurns=2 toolCallTurns=1, got $ENV_LINE_7 (lines: $(ingest_lines))"
-fi
-
-# --- Case 8: long-conversation 100 turns (walker coverage) -----------
-# Transcript with 100 turns (50 user + 50 assistant, interleaved).
-# Pre-Task-214 the body had to contain all 100 transcript lines and
-# exceed 5_000 bytes. Post-Task-214 the transcript no longer reaches
-# the body, so the "no windowing" invariant is asserted via the
-# envelope log line: `turnsCount=100 userTurns=50 assistantTurns=50
-# toolCallTurns=0`. A flat or shrinking turnsCount means windowing or
-# truncation crept back into the walker.
-LONG_TRANSCRIPT=$(mktemp); TMPFILES+=("$LONG_TRANSCRIPT")
-python3 - "$LONG_TRANSCRIPT" <<'PY'
-import json, sys
-out = sys.argv[1]
-with open(out,"w") as f:
-  for i in range(50):
-    ts_u = f"2026-05-19T21:{(i*2)//60:02d}:{(i*2)%60:02d}.000Z"
-    ts_a = f"2026-05-19T21:{(i*2+1)//60:02d}:{(i*2+1)%60:02d}.000Z"
-    f.write(json.dumps({"type":"user","timestamp":ts_u,"message":{"role":"user","content":f"user msg {i}"}})+"\n")
-    f.write(json.dumps({"type":"assistant","timestamp":ts_a,"message":{"id":f"msg_{i}","role":"assistant","content":[{"type":"text","text":f"asst reply {i}"}]}})+"\n")
-PY
-LONG_ENVELOPE=$(python3 -c '
-import json, sys
-print(json.dumps({"session_id": sys.argv[1], "transcript_path": sys.argv[2]}))
-' "$OP_ID" "$LONG_TRANSCRIPT")
-: > "$REQ_LOG"
-run_hook "admin" "" "$LONG_ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-8 rc=$HOOK_RC stderr=$HOOK_STDERR"
-echo "case-8 SKIPPED — dormant since Task 214; transcript no longer substituted into initialMessage. No-windowing invariant now asserted via envelope log line below."
-ENV_LINE_8=$(ingest_lines | grep -cE "^envelope sessionId=${OP_ID} turnsCount=100 userTurns=50 assistantTurns=50 toolCallTurns=0$" || true)
-if [[ "$ENV_LINE_8" -eq 1 ]]; then
-  pass "case-8 envelope log line counts 100-turn transcript: turnsCount=100 userTurns=50 assistantTurns=50 toolCallTurns=0 (no windowing)"
-else
-  fail "case-8 expected 1 envelope line w/ turnsCount=100 userTurns=50 assistantTurns=50 toolCallTurns=0, got $ENV_LINE_8 (lines: $(ingest_lines))"
-fi
-
-# --- Case 9 (Task 177): empty-skip ------------------------------------
-# Transcript with no text content and no tool_use → turns array is empty
-# → trigger-skipped reason=conversation-empty, no spawn POST.
-EMPTY_TRANSCRIPT=$(mktemp); TMPFILES+=("$EMPTY_TRANSCRIPT")
-{
-  printf '{"type":"system","summary":"noop"}\n'
-  printf '{"type":"assistant","timestamp":"2026-05-19T21:40:00.000Z","message":{"id":"msg_t","role":"assistant","content":[{"type":"thinking","thinking":"silent"}]}}\n'
-} > "$EMPTY_TRANSCRIPT"
-EMPTY_ENVELOPE=$(python3 -c '
-import json, sys
-print(json.dumps({"session_id": sys.argv[1], "transcript_path": sys.argv[2]}))
-' "$OP_ID" "$EMPTY_TRANSCRIPT")
-: > "$REQ_LOG"
-run_hook "admin" "" "$EMPTY_ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-9 rc=$HOOK_RC"
-if ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=conversation-empty$"; then
-  pass "case-9 thinking-only transcript → trigger-skipped reason=conversation-empty"
-else
-  fail "case-9 expected trigger-skipped conversation-empty, got: $(ingest_lines)"
-fi
-if grep -qE '^/api/admin/claude-sessions	' "$REQ_LOG"; then
-  fail "case-9 recorder-spawn must NOT be called when conversation-empty"
-else
-  pass "case-9 no recorder-spawn POST"
-fi
-
-# --- Case 10: escaping round-trip (walker coverage) -------------------
-# User and assistant text with quotes / backslashes / em-dash / emoji.
-# Pre-Task-214 these had to survive interpolation into the body and
-# appear verbatim. Post-Task-214 the transcript no longer reaches the
-# body, but the walker still parses the JSONL — the envelope log line
-# `turnsCount=2 userTurns=1 assistantTurns=1 toolCallTurns=0` proves
-# the walker did NOT crash on the special-character text. A parser
-# regression would either drop a turn (zero counts) or fail the hook
-# (non-zero rc).
-ESC_TRANSCRIPT=$(mktemp); TMPFILES+=("$ESC_TRANSCRIPT")
-python3 - "$ESC_TRANSCRIPT" <<'PY'
-import json, sys
-out = sys.argv[1]
-op_msg = 'hello "world"\\nline2\nlast — café 🦊'
-asst_msg = 'reply with backslash \\\\ and newline\nhere'
-recs = [
-  {"type":"user","timestamp":"2026-05-19T21:50:00.000Z","message":{"role":"user","content":op_msg}},
-  {"type":"assistant","timestamp":"2026-05-19T21:50:01.000Z","message":{"id":"msg_esc","role":"assistant","content":[{"type":"text","text":asst_msg}]}},
-]
-with open(out,"w") as f:
-  for r in recs: f.write(json.dumps(r)+"\n")
-PY
-ESC_ENVELOPE=$(python3 -c '
-import json, sys
-print(json.dumps({"session_id": sys.argv[1], "transcript_path": sys.argv[2]}))
-' "$OP_ID" "$ESC_TRANSCRIPT")
-: > "$REQ_LOG"
-run_hook "admin" "" "$ESC_ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-10 rc=$HOOK_RC stderr=$HOOK_STDERR"
-echo "case-10 SKIPPED — dormant since Task 214; transcript no longer substituted into initialMessage. Walker-survives-special-chars now asserted via envelope log line below."
-ENV_LINE_10=$(ingest_lines | grep -cE "^envelope sessionId=${OP_ID} turnsCount=2 userTurns=1 assistantTurns=1 toolCallTurns=0$" || true)
-if [[ "$ENV_LINE_10" -eq 1 ]]; then
-  pass "case-10 envelope log line counts special-character transcript: turnsCount=2 userTurns=1 assistantTurns=1 toolCallTurns=0 (walker survived quotes/backslashes/em-dash/emoji)"
-else
-  fail "case-10 expected 1 envelope line w/ turnsCount=2 userTurns=1 assistantTurns=1 toolCallTurns=0, got $ENV_LINE_10 (lines: $(ingest_lines))"
-fi
-
-# --- Case 11 (Task 199): missing accountId → accountIdPresent=no, no crash ---
-# When ACCOUNT_ID env is empty, the envelope's accountId field is "" and
-# the {accountId} placeholder collapses to an empty string. The hook does
-# NOT loud-fail (the agent's new clarifier sentence + the server-side
-# validator on the writers handle the bad signal). The substitution log
-# line emits accountIdPresent=no — the regression signature for upstream
-# envelope-shape drift.
-: > "$REQ_LOG"
-NO_ACCT_STDIN_FILE=$(mktemp); TMPFILES+=("$NO_ACCT_STDIN_FILE")
-printf '%s' "$ORDERED_ENVELOPE" > "$NO_ACCT_STDIN_FILE"
-NO_ACCT_STDERR=$(mktemp); TMPFILES+=("$NO_ACCT_STDERR")
-NO_ACCT_STDOUT=$(mktemp); TMPFILES+=("$NO_ACCT_STDOUT")
-MAXY_SESSION_ROLE="admin" \
-  MAXY_SPECIALIST="" \
-  MAXY_UI_INTERNAL_PORT="$LISTENER_PORT" \
-  ACCOUNT_ID="" \
-  bash "$HOOK" <"$NO_ACCT_STDIN_FILE" >"$NO_ACCT_STDOUT" 2>"$NO_ACCT_STDERR"
-NO_ACCT_RC=$?
-sleep 0.1
-[[ "$NO_ACCT_RC" -eq 0 ]] || fail "case-11 rc=$NO_ACCT_RC stderr=$(cat "$NO_ACCT_STDERR")"
-[[ -z "$(cat "$NO_ACCT_STDERR")" ]] || fail "case-11 stderr must be empty, got: $(cat "$NO_ACCT_STDERR")"
-
-# 11a. substitution log line carries accountIdPresent=no
-SUBST_NO_COUNT=$(ingest_lines | grep -cE "^substitution sessionId=${OP_ID} schemaBytes=[1-9][0-9]* conversationBytes=[1-9][0-9]* bodyBytes=[1-9][0-9]* accountIdPresent=no$" || true)
-if [[ "$SUBST_NO_COUNT" -eq 1 ]]; then
-  pass "case-11a empty ACCOUNT_ID → substitution log carries accountIdPresent=no"
-else
-  fail "case-11a expected 1 substitution line w/ accountIdPresent=no, got $SUBST_NO_COUNT (lines: $(ingest_lines))"
-fi
-
-# 11b. recorder spawn still fires — the hook does NOT loud-fail on absent
-#      accountId. Pre-Task-214 the {accountId} placeholder collapsed to
-#      empty backticks in the body. Post-Task-214 the template has no
-#      {accountId} placeholder, so the body is the literal template
-#      regardless of ACCOUNT_ID — the regression surface for "hook
-#      survives empty ACCOUNT_ID" is now 11a (substitution log line
-#      carries accountIdPresent=no) plus the spawn POST landing at all.
-echo "case-11b SKIPPED — dormant since Task 214; {accountId} placeholder removed from template, body is literal regardless of ACCOUNT_ID. Survival on empty accountId is now asserted by 11a (substitution log line) + spawn-POST presence below."
-NO_ACCT_POST=$(grep -cE '^/api/admin/claude-sessions	' "$REQ_LOG" || true)
-if [[ "$NO_ACCT_POST" -eq 1 ]]; then
-  pass "case-11b spawn POST fires on empty ACCOUNT_ID (hook does not loud-fail)"
-else
-  fail "case-11b expected 1 spawn POST on empty ACCOUNT_ID, got $NO_ACCT_POST"
-fi
-
-# --- Summary ------------------------------------------------------------
-echo "---"
-echo "PASSED: $PASS  FAILED: $FAIL"
-[[ "$FAIL" -eq 0 ]] || exit 1
-exit 0