@rubytech/create-realagent-code 0.1.255 → 0.1.256

package/payload/platform/plugins/admin/hooks/__tests__/insight.test.sh

@@ -1,395 +0,0 @@
-#!/usr/bin/env bash
-# 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 (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-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)/insight.sh"
-if [[ ! -x "$HOOK" ]]; then
-  echo "FAIL: $HOOK not executable" >&2
-  exit 1
-fi
-
-OP_ID='aaaaaaaa-1111-2222-3333-bbbbbbbbbbbb'
-
-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=$((39500 + 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()
-    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" \
-    bash "$HOOK" >"$stdout_file" 2>"$stderr_file"
-  HOOK_RC=$?
-  HOOK_STDERR=$(cat "$stderr_file")
-  HOOK_STDOUT=$(cat "$stdout_file")
-  sleep 0.1
-}
-
-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
-}
-
-# 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"
-  python3 - "$out" "$@" <<'PY'
-import sys, json
-out = sys.argv[1]
-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-06-05T10:00:00.000Z"}
-        if role == "user":
-            if extra == "tool_result":
-                rec["message"] = {
-                    "role": "user",
-                    "content": [
-                        {"type": "tool_result",
-                         "tool_use_id": "tu_x",
-                         "content": text or "ok"},
-                    ],
-                }
-            else:
-                rec["message"] = {"role": "user", "content": text}
-        else:
-            content_blocks = []
-            if text:
-                content_blocks.append({"type": "text", "text": text})
-            if extra.startswith("tool_use:"):
-                tool_name = extra.split(":", 1)[1]
-                content_blocks.append({
-                    "type": "tool_use",
-                    "id": f"toolu_{tool_name}",
-                    "name": tool_name,
-                    "input": {},
-                })
-            rec["message"] = {
-                "id": f"msg_{role}_{hash(text) & 0xffff:04x}",
-                "role": "assistant",
-                "content": content_blocks,
-            }
-        f.write(json.dumps(rec) + "\n")
-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],
-    "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
-write_transcript "$NEUTRAL_TRANSCRIPT" "user|hello|" "assistant|hi|"
-ENV_INSIGHT=$(envelope_for "$OP_ID" "$NEUTRAL_TRANSCRIPT" "/insight")
-: > "$REQ_LOG"
-run_hook "public" "" "$ENV_INSIGHT"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-1 rc=$HOOK_RC"
-[[ -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
-  fail "case-1 expected role-not-admin, got: $(ingest_lines)"
-fi
-
-# ---------------------------------------------------------------------------
-# Case 2: MAXY_SPECIALIST set → trigger-skipped is-specialist
-# ---------------------------------------------------------------------------
-: > "$REQ_LOG"
-run_hook "admin" "database-operator" "$ENV_INSIGHT"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-2 rc=$HOOK_RC"
-[[ -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
-  fail "case-2 expected is-specialist, 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"
-else
-  fail "case-3 expected empty-stdin, got: $(ingest_lines)"
-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], "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
-  pass "case-4 missing transcript → trigger-skipped reason=missing-transcript"
-else
-  fail "case-4 expected missing-transcript, got: $(ingest_lines)"
-fi
-
-# ---------------------------------------------------------------------------
-# Case 5: prompt has no /insight token → trigger-skipped reason=no-insight-token
-# ---------------------------------------------------------------------------
-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_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-insight-token, got: $(ingest_lines)"
-fi
-
-# ---------------------------------------------------------------------------
-# Case 6: prompt is exactly /insight → instruction on stdout, trigger logged
-# ---------------------------------------------------------------------------
-: > "$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: /insight as a standalone line among other lines → triggers
-# ---------------------------------------------------------------------------
-ENV_LINE=$(envelope_for "$OP_ID" "$NEUTRAL_TRANSCRIPT" $'here is some context\n/insight\nthanks')
-: > "$REQ_LOG"
-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 trigger, got: $(ingest_lines)"
-fi
-
-# ---------------------------------------------------------------------------
-# Case 8: case-insensitive — /INSIGHT triggers, logged as /insight
-# ---------------------------------------------------------------------------
-ENV_CASE=$(envelope_for "$OP_ID" "$NEUTRAL_TRANSCRIPT" "/INSIGHT")
-: > "$REQ_LOG"
-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 expected token=/insight, got: $(ingest_lines)"
-fi
-
-# ---------------------------------------------------------------------------
-# Case 9: embedded prose does NOT trigger
-# ---------------------------------------------------------------------------
-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_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
-  pass "case-10 prior /insight without sentinel → prior-incomplete"
-fi
-
-# ---------------------------------------------------------------------------
-# Case 11: reconciliation negative — prior /insight turn WITH a sentinel
-#           tool_use after it → no prior-incomplete
-# ---------------------------------------------------------------------------
-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_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
-  pass "case-11 prior /insight with sentinel → no prior-incomplete"
-fi
-
-# ---------------------------------------------------------------------------
-# 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_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_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-13 expected trigger without prior-incomplete, got: $(ingest_lines)"
-fi
-
-# ---------------------------------------------------------------------------
-# Case 12: no path returns exit 2 — /insight must not block the turn
-# ---------------------------------------------------------------------------
-: > "$REQ_LOG"
-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
-  pass "case-12 trigger path exits 0, never 2"
-fi
-
-# ---------------------------------------------------------------------------
-# Summary
-# ---------------------------------------------------------------------------
-echo
-echo "insight tests: $PASS passed, $FAIL failed"
-[[ "$FAIL" -eq 0 ]]

package/payload/platform/plugins/admin/hooks/insight.sh

@@ -1,219 +0,0 @@
-#!/usr/bin/env bash
-# UserPromptSubmit hook — on-demand `/insight`. When the operator types the
-# literal token `/insight` as a standalone message (or a standalone line), the
-# admin agent runs a four-pass review (technical learnings, operator-
-# relationship updates, graph-completeness sweep, typed-edge auto-extraction)
-# over the session so far and calls the deterministic
-# `session-retrospective-mark-complete` MCP sentinel — then the session
-# CONTINUES. Nothing is blocked, terminated, reset, or cleared. Task 634
-# replaced the Task 282 session-end Stop gate with this trigger; the four
-# passes and the sentinel call are byte-for-byte the same process — only the
-# trigger and timing changed.
-#
-# Trigger detection. The token is read from the `prompt` field of the
-# UserPromptSubmit stdin envelope, case-insensitively, matching the whole
-# message (after .strip()) OR a standalone line within it — never embedded in
-# prose. This is the same whole-message / standalone-line discipline the
-# session-end gate applied to its end-intent tokens; it keeps "give me some
-# /insight into the numbers" from false-triggering.
-#
-# Injection. On a match the four-pass instruction is printed to STDOUT.
-# UserPromptSubmit stdout is appended to the turn as additional context, so the
-# agent receives the instruction alongside the operator's `/insight` message.
-# Structured logs go through POST /api/admin/log-ingest (never stdout), so the
-# injected context stays clean. There is no exit-2 path and no stderr
-# instruction — UserPromptSubmit cannot and must not block the turn.
-#
-# Standing reconciliation (no-event failure detector). The run-and-continue
-# model removes the Stop gate that previously forced completion, so the
-# dominant failure mode is "triggered but never completed" — the agent injects
-# the instruction, returns prose, and never calls the sentinel. Because this
-# hook fires on every prompt, it scans the transcript (`transcript_path`) each
-# invocation for the latest real-user turn whose text matches `/insight`; when
-# no `session-retrospective-mark-complete` tool_use appears after that turn it
-# emits `[insight] prior-incomplete sessionId=<id> triggered-turn=<idx>`. This
-# surfaces an unfinished pass on the next prompt without waiting for session
-# end and without reproducing the failure.
-# [[feedback_no_stdout_parsing_for_control_flow]] — the trigger is a literal
-# token match, never prose parsing.
-#
-# Gating (common guards live in `lib/admin-graph-pass-common.sh`):
-#   - role-not-admin / is-specialist / empty-stdin / missing-transcript:
-#     handled by the shared helper, emit `trigger-skipped` and exit 0.
-#   - no-insight-token: the prompt carries no standalone `/insight` token,
-#     emit `trigger-skipped` and exit 0.
-#
-# Input: Claude Code's UserPromptSubmit stdin shape
-#   { "session_id": "<id>", "transcript_path": "<jsonl path>",
-#     "prompt": "<operator message>", "hook_event_name": "UserPromptSubmit" }
-
-set -uo pipefail
-
-AGP_LOG_TAG="insight"
-AGP_LIB="$(dirname "$0")/lib/admin-graph-pass-common.sh"
-if [ ! -f "$AGP_LIB" ]; then
-  echo "[${AGP_LOG_TAG}] trigger-skipped sessionId=unknown reason=missing-helper path=${AGP_LIB}" >&2
-  exit 0
-fi
-# shellcheck source=lib/admin-graph-pass-common.sh
-source "$AGP_LIB"
-
-agp_setup_logging
-agp_read_stdin
-agp_parse_stdin
-agp_guard_role_specialist
-agp_guard_transcript require-stdin
-
-# Extract the operator's raw prompt from the envelope. Empty when absent.
-PROMPT=$(printf '%s' "$INPUT" | python3 -c '
-import sys, json
-try:
-    d = json.load(sys.stdin)
-    p = d.get("prompt", "") or ""
-    sys.stdout.write(p if isinstance(p, str) else "")
-except Exception:
-    pass
-' 2>/dev/null)
-
-# Single Python pass reports two facts on one line:
-#   1. Whether PROMPT carries a standalone `/insight` token → token or empty.
-#   2. Reconciliation: the index of the latest real-user transcript turn whose
-#      text matches `/insight` that has NO subsequent
-#      `session-retrospective-mark-complete` tool_use → index or empty.
-# Output: <trigger-token-or-empty>\t<prior-incomplete-idx-or-empty>
-INSPECTION=$(PROMPT="$PROMPT" TRANSCRIPT_PATH="$TRANSCRIPT_PATH" python3 - <<'PY'
-import os, json
-
-SENTINEL_TOOL = "mcp__admin__session-retrospective-mark-complete"
-TOKEN = "/insight"
-
-def text_has_standalone_token(text):
-    # Case-insensitive: token is the whole message (after strip) OR a
-    # standalone line within it. Never matches the token embedded in prose.
-    if not text:
-        return False
-    haystacks = {text.strip().lower()}
-    for line in text.splitlines():
-        s = line.strip().lower()
-        if s:
-            haystacks.add(s)
-    return TOKEN in haystacks
-
-def is_real_user(rec):
-    if not isinstance(rec, dict) or rec.get("type") != "user":
-        return False
-    msg = rec.get("message")
-    if not isinstance(msg, dict) or msg.get("role") != "user":
-        return False
-    content = msg.get("content")
-    if isinstance(content, str):
-        return True
-    if isinstance(content, list):
-        for b in content:
-            if isinstance(b, dict) and b.get("type") != "tool_result":
-                return True
-        return False
-    return True
-
-def extract_user_text(rec):
-    msg = rec.get("message", {}) or {}
-    content = msg.get("content")
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        out = []
-        for b in content:
-            if isinstance(b, dict) and b.get("type") == "text":
-                t = b.get("text")
-                if isinstance(t, str):
-                    out.append(t)
-        return "".join(out)
-    return ""
-
-def is_assistant(rec):
-    return (isinstance(rec, dict) and rec.get("type") == "assistant"
-            and isinstance(rec.get("message"), dict)
-            and rec["message"].get("role") == "assistant")
-
-def assistant_tool_use_names(rec):
-    if not is_assistant(rec):
-        return []
-    content = rec["message"].get("content")
-    if not isinstance(content, list):
-        return []
-    return [b.get("name") for b in content
-            if isinstance(b, dict) and b.get("type") == "tool_use"
-            and isinstance(b.get("name"), str)]
-
-# Trigger — read from the prompt field, not the transcript.
-trigger = TOKEN if text_has_standalone_token(os.environ.get("PROMPT", "")) else ""
-
-# Reconciliation — scan the transcript for the latest real-user `/insight`
-# turn and check whether a sentinel tool_use follows it.
-records = []
-try:
-    with open(os.environ["TRANSCRIPT_PATH"], "r", encoding="utf-8") as f:
-        for raw in f:
-            raw = raw.strip()
-            if not raw:
-                continue
-            try:
-                records.append(json.loads(raw))
-            except Exception:
-                continue
-except Exception:
-    records = []
-
-latest_insight_idx = -1
-for i in range(len(records) - 1, -1, -1):
-    if is_real_user(records[i]) and text_has_standalone_token(extract_user_text(records[i])):
-        latest_insight_idx = i
-        break
-
-prior_incomplete = ""
-if latest_insight_idx != -1:
-    after = records[latest_insight_idx + 1:]
-    # "Triggered but never completed" means the agent RESPONDED to the
-    # `/insight` turn (≥1 assistant record after it) yet never called the
-    # sentinel. Requiring an assistant record excludes the just-submitted
-    # `/insight` turn — which has no response yet — so a genuine trigger
-    # never self-reports as incomplete, regardless of whether Claude Code
-    # has already written the current prompt to the transcript.
-    assistant_after = any(is_assistant(r) for r in after)
-    sentinel_after = any(SENTINEL_TOOL in assistant_tool_use_names(r) for r in after)
-    if assistant_after and not sentinel_after:
-        prior_incomplete = str(latest_insight_idx)
-
-print(f"{trigger}\t{prior_incomplete}")
-PY
-)
-TRIGGER_TOKEN="${INSPECTION%%	*}"
-PRIOR_INCOMPLETE_IDX="${INSPECTION#*	}"
-
-# Standing reconciliation emit — independent of the current trigger.
-if [ -n "$PRIOR_INCOMPLETE_IDX" ]; then
-  agp_emit_log "prior-incomplete sessionId=${SESSION_ID} triggered-turn=${PRIOR_INCOMPLETE_IDX}"
-fi
-
-if [ -z "$TRIGGER_TOKEN" ]; then
-  agp_emit_log "trigger-skipped sessionId=${SESSION_ID} reason=no-insight-token"
-  exit 0
-fi
-
-agp_emit_log "trigger sessionId=${SESSION_ID} token=${TRIGGER_TOKEN}"
-
-cat <<'INSTRUCTION'
-The operator requested an insight pass — run the four passes now over the session so far, then keep going in this same session. Do NOT call `session-reset`, do NOT clear the context, do NOT end the session: the conversation continues afterward and the operator (or a parallel session) keeps working against the same live state. Use the tools you already have.
-
-Pass 1 — Technical learnings. Walk this session for operator corrections and self-detected mistakes. For each one, delegate one graph write to `database-operator` via the Task tool, persisting a Learning or Correction node per the schema. Count what you write.
-
-Pass 2 — Operator-relationship updates. Walk this session for tonal signals, rejected phrasings, and working-style preferences. For each one worth carrying forward, Write the observation into `SOUL.md` at the account-scoped path. Count what you write.
-
-Pass 3 — Graph completeness sweep. Walk this session for any node, edge, or commitment that was discussed but not written to the graph in-flight. For each missing write, delegate to `database-operator` via the Task tool. Count what you write.
-
-Pass 4 — Typed-edge auto-extraction. Delegate to `database-operator` via the Task tool with a prompt naming the typed-edge pass and the session-start timestamp. The specialist calls `memory-typed-edge-pass` with that timestamp and returns the counters. Capture `nodesProcessed` and the accepted count from its reply.
-
-Then call `session-retrospective-mark-complete` with all five counts (learningsCount, preferencesCount, graphWriteCount, typedEdgesCount, nodesProcessed) and reply with one short paragraph in your house voice summarising what you wrote — then carry on with the operator's work.
-INSTRUCTION
-
-exit 0