@rubytech/create-maxy-code 0.1.49 → 0.1.57

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

@@ -1,19 +1,25 @@
 #!/usr/bin/env bash
-# Regression test for the Stop-hook gate that fires the database-operator
-# per completed admin-agent turn (Task 114 redesign: normal admin session +
-# /input POST, replacing Task 106's `--print` + stdin-EOT shape which is
-# incompatible with OAuth).
+# Task 129/131 regression test for the Stop hook.
 #
-# Behaviour verified:
-#   1. MAXY_SESSION_ROLE!=admin → exit 0, no POST attempt, no log line.
-#   2. MAXY_HIDDEN_SPAWN=1     → exit 0, no POST attempt, no log line.
-#   3. Empty stdin            → exit 0 silently.
-#   4. Missing transcript_path → exit 0 silently.
-#   5. Happy path             → exactly ONE POST to /spawn (no stdinPayload
-#      field) and exactly ONE POST to /<id>/input whose `text` carries the
-#      Task 114 instruction string and the filtered transcript, plus the
-#      `[turn-recorder] spawn-with-input sessionId=<8> bytes=<n> filtered-from-records=<n> input-http=200`
-#      log line.
+# Contract:
+#   - 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 | last-turn-empty).
+#   - Happy path emits exactly ONE `trigger` line carrying
+#     `lastTurnBytes=<n>` (Task 131 replaces `filteredRecords`) and
+#     exactly ONE `recorder-spawn` POST. The body carries the operator
+#     session id as `originatingSessionId` and an `initialMessage` of
+#     the form `<instruction>\n\n<last-turn-text>` — no transcript tail,
+#     no `Conversation id:` prose.
+#   - 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
 
@@ -23,6 +29,8 @@ if [[ ! -x "$HOOK" ]]; then
   exit 1
 fi
 
+OP_ID='aaaaaaaa-1111-2222-3333-bbbbbbbbbbbb'
+
 TMPFILES=()
 LISTENER_PIDS=()
 cleanup_test_state() {
@@ -43,61 +51,10 @@ FAIL=0
 pass() { echo "PASS: $1"; PASS=$((PASS + 1)); }
 fail() { echo "FAIL: $1" >&2; FAIL=$((FAIL + 1)); }
 
-run_hook() {
-  local role="$1"; local hidden="$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_HIDDEN_SPAWN="$hidden" \
-    CLAUDE_SESSION_MANAGER_PORT="${MANAGER_PORT:-19400}" \
-    bash "$HOOK" >"$stdout_file" 2>"$stderr_file"
-  local rc=$?
-  HOOK_RC="$rc"
-  HOOK_STDERR=$(cat "$stderr_file")
-  HOOK_STDOUT=$(cat "$stdout_file")
-}
-
-# --- Case 1: role != admin → no fire --------------------------------------
-TRANSCRIPT=$(mktemp); TMPFILES+=("$TRANSCRIPT")
-printf '{"type":"user","message":{"content":"hi"}}\n' > "$TRANSCRIPT"
-ENVELOPE=$(python3 -c '
-import json, sys
-print(json.dumps({"session_id": "abcd1234-deadbeef", "transcript_path": sys.argv[1]}))
-' "$TRANSCRIPT")
-
-run_hook "public" "0" "$ENVELOPE"
-if [[ "$HOOK_RC" -ne 0 ]]; then fail "case-1 expected rc=0 got=$HOOK_RC"
-elif [[ -n "$HOOK_STDERR" ]]; then fail "case-1 expected empty stderr, got: $HOOK_STDERR"
-else pass "case-1 role=public → no fire (rc=0, stderr empty)"
-fi
-
-# --- Case 2: hidden=1 → no fire ----------------------------------------
-run_hook "admin" "1" "$ENVELOPE"
-if [[ "$HOOK_RC" -ne 0 ]]; then fail "case-2 expected rc=0 got=$HOOK_RC"
-elif [[ -n "$HOOK_STDERR" ]]; then fail "case-2 expected empty stderr, got: $HOOK_STDERR"
-else pass "case-2 hidden=1 → silent"
-fi
-
-# --- Case 3: empty stdin → silent --------------------------------------
-run_hook "admin" "0" ""
-if [[ "$HOOK_RC" -ne 0 ]]; then fail "case-3 expected rc=0 got=$HOOK_RC"
-elif [[ -n "$HOOK_STDERR" ]]; then fail "case-3 expected empty stderr, got: $HOOK_STDERR"
-else pass "case-3 empty stdin → silent (rc=0)"
-fi
-
-# --- Case 4: missing transcript_path → silent -------------------------
-BAD_ENVELOPE='{"session_id":"x"}'
-run_hook "admin" "0" "$BAD_ENVELOPE"
-if [[ "$HOOK_RC" -ne 0 ]]; then fail "case-4 expected rc=0 got=$HOOK_RC"
-elif [[ -n "$HOOK_STDERR" ]]; then fail "case-4 expected empty stderr, got: $HOOK_STDERR"
-else pass "case-4 missing transcript_path → silent (rc=0)"
-fi
-
-# --- Case 5: happy path → one /spawn (no stdinPayload) + one /<id>/input
-REQ_LOG=$(mktemp); TMPFILES+=("$REQ_LOG")
-LISTENER_PORT=39406
-python3 - "$LISTENER_PORT" "$REQ_LOG" <<'PY' &
+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]
@@ -111,115 +68,196 @@ class H(http.server.BaseHTTPRequestHandler):
     self.send_response(200)
     self.send_header('Content-Type','application/json')
     self.end_headers()
-    if self.path == '/spawn':
-      self.wfile.write(json.dumps({"sessionId":"rec00001-feedfeed"}).encode('utf-8'))
+    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+=("$!")
-
-# Wait up to 2s for the listener to bind.
-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
+  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"
+}
 
-# Clear the request log of the ping write.
-: > "$REQ_LOG"
+run_hook() {
+  local role="$1"; local is_recorder="$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_IS_RECORDER="$is_recorder" \
+    MAXY_UI_INTERNAL_PORT="$LISTENER_PORT" \
+    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
+}
 
-MANAGER_PORT="$LISTENER_PORT"
-run_hook "admin" "0" "$ENVELOPE"
-unset MANAGER_PORT
+# 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
+}
 
-# Give the listener time to flush.
-sleep 0.1
+# Common envelope: a valid Stop-hook stdin shape with a real UUID + a
+# transcript file the hook can read. Transcript has one user turn and
+# one assistant turn — Task 131 picks the most-recent assistant text as
+# the last-turn payload.
+start_listener
+TRANSCRIPT=$(mktemp); TMPFILES+=("$TRANSCRIPT")
+{
+  printf '{"type":"user","message":{"role":"user","content":"hello operator"}}\n'
+  printf '{"type":"assistant","message":{"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")
 
-if [[ "$HOOK_RC" -ne 0 ]]; then
-  fail "case-5 expected rc=0 got=$HOOK_RC stderr=$HOOK_STDERR"
+# --- Case 1: role != admin → trigger-skipped reason=role-not-admin -----
+: > "$REQ_LOG"
+run_hook "public" "0" "$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
-
-# Assert: spawn-with-input log line emitted.
-if ! echo "$HOOK_STDERR" | grep -qE '^\[turn-recorder\] spawn-with-input sessionId=rec00001 bytes=[0-9]+ filtered-from-records=[0-9]+ input-http=[0-9]+'; then
-  fail "case-5a expected spawn-with-input log line, got: $HOOK_STDERR"
+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-5a spawn-with-input log line emitted"
+  pass "case-1 no recorder-spawn POST"
 fi
 
-# Assert: no legacy spawn-with-stdin log line.
-if echo "$HOOK_STDERR" | grep -q 'spawn-with-stdin'; then
-  fail "case-5b legacy spawn-with-stdin line must not be emitted in Task 114"
+# --- Case 2: MAXY_IS_RECORDER=1 → trigger-skipped reason=is-recorder ----
+: > "$REQ_LOG"
+run_hook "admin" "1" "$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_IS_RECORDER=1 → trigger-skipped reason=is-recorder emitted"
 else
-  pass "case-5b legacy spawn-with-stdin log line absent"
+  fail "case-2 expected trigger-skipped is-recorder, got: $(ingest_lines)"
 fi
 
-# Assert: listener saw exactly one /spawn POST and exactly one /<id>/input POST.
-SPAWN_LINES=$(grep -c '^/spawn	' "$REQ_LOG" || true)
-INPUT_LINES=$(grep -cE '^/[A-Za-z0-9_-]+/input	' "$REQ_LOG" || true)
-STOP_LINES=$(grep -cE '^/[A-Za-z0-9_-]+/stop	' "$REQ_LOG" || true)
-if [[ "$SPAWN_LINES" -ne 1 ]]; then
-  fail "case-5c expected exactly 1 /spawn POST, got $SPAWN_LINES (log: $(cat "$REQ_LOG"))"
+# --- Case 3: empty stdin → trigger-skipped reason=empty-stdin ------------
+: > "$REQ_LOG"
+run_hook "admin" "0" ""
+[[ "$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
-  pass "case-5c exactly one /spawn POST observed"
+  fail "case-3 expected trigger-skipped empty-stdin, got: $(ingest_lines)"
 fi
-if [[ "$INPUT_LINES" -ne 1 ]]; then
-  fail "case-5d expected exactly 1 /<id>/input POST, got $INPUT_LINES"
+
+# --- 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" "0" "$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
-  pass "case-5d exactly one /<id>/input POST observed"
+  fail "case-4 expected trigger-skipped missing-transcript, got: $(ingest_lines)"
 fi
-if [[ "$STOP_LINES" -ne 0 ]]; then
-  fail "case-5e expected ZERO /<id>/stop POSTs from the hook (auto-archive is in-manager), got $STOP_LINES"
+
+# --- Case 5: happy path -------------------------------------------------
+: > "$REQ_LOG"
+run_hook "admin" "0" "$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
+#     and `lastTurnBytes=<n>` (Task 131 replaces `filteredRecords`).
+TRIGGER_COUNT=$(ingest_lines | grep -cE "^trigger sessionId=${OP_ID} turnIndex=0 transcriptBytes=[0-9]+ lastTurnBytes=[0-9]+$" || true)
+if [[ "$TRIGGER_COUNT" -eq 1 ]]; then
+  pass "case-5a exactly one trigger line emitted via log-ingest carrying operator id + lastTurnBytes"
 else
-  pass "case-5e zero /<id>/stop POSTs"
+  fail "case-5a expected exactly 1 trigger line carrying ${OP_ID}, got $TRIGGER_COUNT (lines: $(ingest_lines))"
 fi
 
-# Assert: the /spawn body has no stdinPayload field.
-SPAWN_BODY=$(grep '^/spawn	' "$REQ_LOG" | head -1 | cut -f2-)
-if [[ -z "$SPAWN_BODY" ]]; then
-  fail "case-5f /spawn body was empty"
+# 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
-  HAS_STDIN=$(printf '%s' "$SPAWN_BODY" | python3 -c '
-import sys, json
-try:
-  b = json.load(sys.stdin)
-  print("yes" if "stdinPayload" in b else "no")
-except Exception:
-  print("parse-fail")
-' 2>/dev/null)
-  if [[ "$HAS_STDIN" != "no" ]]; then
-    fail "case-5f /spawn body must NOT carry stdinPayload, got: $SPAWN_BODY"
-  else
-    pass "case-5f /spawn body has no stdinPayload field"
-  fi
+  fail "case-5b expected exactly 1 recorder-spawn POST, got $RECORDER_LINES"
 fi
 
-# Assert: the /input body's `text` carries the Task 114 instruction and the
-# transcript section header.
-INPUT_BODY=$(grep -E '^/[A-Za-z0-9_-]+/input	' "$REQ_LOG" | head -1 | cut -f2-)
-INPUT_OK=$(printf '%s' "$INPUT_BODY" | python3 -c '
+# 5c. recorder-spawn body has originatingSessionId == operator id; initialMessage
+#     equals "<instruction>\n\n<last-turn-text>" verbatim. No transcript prose.
+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]
+INSTRUCTION = "update the graph with any new or missing information or intent"
+EXPECTED_LAST = "hello, assistant reply"
 try:
   b = json.load(sys.stdin)
-  t = b.get("text", "")
-  has_instr = "update the graph with any missing information or intent that can be derived from this conversation" in t
-  has_tx = "Conversation transcript:" in t
-  print("yes" if (has_instr and has_tx) else "no")
-except Exception:
-  print("parse-fail")
-' 2>/dev/null)
-if [[ "$INPUT_OK" != "yes" ]]; then
-  fail "case-5g /input body missing instruction or transcript header: $INPUT_BODY"
+  msg = b.get("initialMessage") or ""
+  conds = (
+    # Task 134: no synthetic senderId marker — loopback bypass is
+    # method+path-scoped; the body only carries the recorder discriminators.
+    "senderId" not in b,
+    b.get("specialist") == "database-operator",
+    b.get("originatingSessionId") == op,
+    msg == INSTRUCTION + "\n\n" + EXPECTED_LAST,
+    "Conversation id:" not in msg,
+    "Conversation transcript:" not in msg,
+  )
+  print("yes" if all(conds) else "no:"+repr(conds)+"|msg="+repr(msg))
+except Exception as e:
+  print("parse-fail:"+str(e))
+' "$OP_ID" 2>/dev/null)
+if [[ "$BODY_OK" == "yes" ]]; then
+  pass "case-5c recorder-spawn body carries originatingSessionId + verbatim instruction + last-turn text"
 else
-  pass "case-5g /input body carries Task 114 instruction + transcript"
+  fail "case-5c body shape wrong ($BODY_OK): $RECORDER_BODY"
 fi
 
-# Assert: final fired log line still emitted.
-if ! echo "$HOOK_STDERR" | grep -qE '^turn-completed-graph-write fired conversationId=abcd1234 recorderSessionId=rec00001 filtered=[0-9]+ ms=[0-9]+'; then
-  fail "case-5h expected fired summary log line, got: $HOOK_STDERR"
+# 5d. no legacy stderr emissions
+if echo "$HOOK_STDERR" | grep -qE 'spawn-with-input|spawn-with-stdin|turn-completed-graph-write fired'; then
+  fail "case-5d legacy stderr line emitted: $HOOK_STDERR"
 else
-  pass "case-5h fired summary log line emitted"
+  pass "case-5d no legacy stderr emissions"
+fi
+
+# --- Case 6 (Task 131): transcript has no assistant/user text → ---------
+#     trigger-skipped reason=last-turn-empty. The hook emits the trigger
+#     line first (lastTurnBytes=0) and then the new skip reason.
+EMPTY_TRANSCRIPT=$(mktemp); TMPFILES+=("$EMPTY_TRANSCRIPT")
+printf '{"type":"system","summary":"noop"}\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" "0" "$EMPTY_ENVELOPE"
+[[ "$HOOK_RC" -eq 0 ]] || fail "case-6 rc=$HOOK_RC"
+if ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=last-turn-empty$"; then
+  pass "case-6 empty last-turn text → trigger-skipped reason=last-turn-empty emitted"
+else
+  fail "case-6 expected trigger-skipped last-turn-empty, got: $(ingest_lines)"
+fi
+# And no recorder-spawn POST is made.
+if grep -qE '^/api/admin/claude-sessions	' "$REQ_LOG"; then
+  fail "case-6 recorder-spawn must NOT be called when last-turn-empty"
 fi
 
 # --- Summary ------------------------------------------------------------