@rubytech/create-realagent-code 0.1.249 → 0.1.250

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

@@ -1,441 +0,0 @@
-#!/usr/bin/env bash
-# Stop hook — fires on every completed admin-agent turn and dispatches one
-# headless database-operator session against the operator's full
-# conversation transcript. The recorder is the only writer to the Neo4j
-# graph; the admin agent stays focused on the operator's request.
-#
-# Task 147 — the recorder spawn is byte-for-byte equivalent to a Sidebar
-# "New session" body, with two overrides:
-#   - specialist:     "database-operator"
-#   - initialMessage: JSON-stringified envelope (Task 177)
-# The model is taken from the agent file frontmatter (Task 200).
-#
-# It POSTs to the SAME route the Sidebar uses
-# (`POST /api/admin/claude-sessions`). The wrapper accepts the loopback
-# request without a cookie, resolves the operator's `senderId` from the
-# manager's `/<adminSessionId>/meta`, and forwards a Sidebar-shape spawn
-# body. No recorder-only carving on the manager side.
-#
-# Task 177 — `initialMessage` is a JSON object stringified to a string.
-# Top-level keys EXACTLY: turns, sessionId, accountId, occurredAt.
-# `turns` is the chronologically-ordered conversation window — every
-# user / assistant message in the operator's JSONL, oldest first, no
-# windowing or truncation. Each entry:
-#     { role: "user"|"assistant", text: string, ts: string, toolCalls?: [...] }
-# `toolCalls` (assistant-only, omitted when empty) carries
-# `[{ tool, input, output }]` for tool_use/tool_result pairs in that turn.
-# Replaces the Task 175 `(operatorMessage, assistantReply)` pair contract,
-# which asserted a temporal pairing the walker never enforced.
-#
-# Gating (emits a `trigger-skipped` line via `/api/admin/log-ingest`;
-# stderr stays silent on the success path):
-#   - MAXY_SESSION_ROLE must equal "admin"        → reason=role-not-admin
-#   - MAXY_SPECIALIST must NOT equal              → reason=is-recorder
-#     "database-operator"   (recursion guard)
-#   - Stop-hook stdin must be non-empty           → reason=empty-stdin
-#   - transcript_path must exist on disk          → reason=missing-transcript
-#   - turns array is empty after walker runs      → reason=conversation-empty
-#
-# Input: Claude Code's Stop hook stdin shape
-#   { "session_id": "<intrinsic>", "transcript_path": "<jsonl path>", ... }
-
-set -uo pipefail
-
-UI_PORT="${MAXY_UI_INTERNAL_PORT:-}"
-if [ -z "$UI_PORT" ]; then
-  echo "[turn-recorder] spawn-failed sessionId=unknown reason=missing-env env=MAXY_UI_INTERNAL_PORT" >&2
-  exit 0
-fi
-UI_BASE="http://127.0.0.1:${UI_PORT}"
-LOG_INGEST_URL="${UI_BASE}/api/admin/log-ingest"
-
-emit_log() {
-  local line="$1"
-  curl -sS -o /dev/null -X POST \
-    -H 'Content-Type: application/json' \
-    --max-time 2 \
-    --data "$(python3 -c '
-import sys, json
-print(json.dumps({"tag": "turn-recorder", "level": "info", "line": sys.argv[1]}))
-' "$line")" \
-    "$LOG_INGEST_URL" 2>/dev/null || true
-}
-
-INPUT=""
-if [ -t 0 ]; then
-  INPUT=""
-else
-  INPUT=$(cat)
-fi
-
-PARSED=$(printf '%s' "$INPUT" | python3 -c '
-import sys, json
-try:
-    d = json.load(sys.stdin)
-    sid = d.get("session_id", "") or ""
-    tpath = d.get("transcript_path", "") or ""
-    print(f"{sid}\t{tpath}")
-except Exception:
-    print("\t")
-' 2>/dev/null)
-ADMIN_SESSION_ID="${PARSED%%	*}"
-TRANSCRIPT_PATH="${PARSED#*	}"
-
-if [ "${MAXY_SESSION_ROLE:-}" != "admin" ]; then
-  emit_log "trigger-skipped sessionId=${ADMIN_SESSION_ID:-unknown} reason=role-not-admin"
-  exit 0
-fi
-# Recursion guard. The recorder spawn carries
-# `specialist=database-operator`; pty-spawner stamps MAXY_SPECIALIST on the
-# PTY env. Skip recording the recorder's own turn.
-if [ "${MAXY_SPECIALIST:-}" = "database-operator" ]; then
-  emit_log "trigger-skipped sessionId=${ADMIN_SESSION_ID:-unknown} reason=is-recorder"
-  exit 0
-fi
-if [ -z "$INPUT" ]; then
-  emit_log "trigger-skipped sessionId=${ADMIN_SESSION_ID:-unknown} reason=empty-stdin"
-  exit 0
-fi
-if [ -z "$ADMIN_SESSION_ID" ] || [ -z "$TRANSCRIPT_PATH" ] || [ ! -f "$TRANSCRIPT_PATH" ]; then
-  emit_log "trigger-skipped sessionId=${ADMIN_SESSION_ID:-unknown} reason=missing-transcript"
-  exit 0
-fi
-
-# Task 177 — build the envelope the database-operator agent file declares
-# as its stdin contract. One Python pass walks the transcript and emits:
-#   {
-#     "turns": [
-#       { "role": "user"|"assistant", "text": "...", "ts": "...",
-#         "toolCalls"?: [{ "tool": "...", "input": {...}, "output": ... }] },
-#       ...
-#     ],
-#     "sessionId": "<session_id>",
-#     "accountId":      "<ACCOUNT_ID env>",
-#     "occurredAt":     "<hook fire time, ISO-8601 UTC, .000Z>"
-#   }
-# `python3 json.dumps` handles every escape so the hook never has to
-# concatenate strings into JSON by hand.
-OCCURRED_AT=$(date -u +%Y-%m-%dT%H:%M:%S.000Z)
-ACCOUNT_ID_ENV="${ACCOUNT_ID:-}"
-
-ENVELOPE=$(python3 - "$TRANSCRIPT_PATH" "$ADMIN_SESSION_ID" "$ACCOUNT_ID_ENV" "$OCCURRED_AT" <<'PY'
-import sys, json
-
-def concat_text(content):
-    """Concatenate every `text` block in a content list (or return the
-    string content as-is). `thinking` blocks contribute nothing."""
-    if isinstance(content, str):
-        return content
-    if not isinstance(content, list):
-        return ""
-    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)
-
-path, session_id, account_id, occurred_at = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
-
-turns = []                  # ordered output: { role, text, ts, toolCalls? }
-msg_id_to_turn_index = {}   # collapse rule for assistant message.id
-pending_tool_calls = {}     # tool_use_id -> (turn_index, toolCalls_index)
-
-try:
-    with open(path, "r", encoding="utf-8") as f:
-        for line in f:
-            line = line.strip()
-            if not line:
-                continue
-            try:
-                rec = json.loads(line)
-            except Exception:
-                continue
-            if not isinstance(rec, dict):
-                continue
-            t = rec.get("type")
-            msg = rec.get("message")
-            if not isinstance(msg, dict):
-                continue
-            content = msg.get("content")
-            ts = rec.get("timestamp", "") or ""
-
-            if t == "user":
-                # tool_result blocks attach to the assistant turn that
-                # owned the corresponding tool_use; they never create a
-                # separate user turn entry.
-                if isinstance(content, list):
-                    for b in content:
-                        if isinstance(b, dict) and b.get("type") == "tool_result":
-                            tu_id = b.get("tool_use_id")
-                            if not isinstance(tu_id, str):
-                                continue
-                            slot = pending_tool_calls.pop(tu_id, None)
-                            if slot is None:
-                                continue
-                            turn_idx, call_idx = slot
-                            turns[turn_idx]["toolCalls"][call_idx]["output"] = b.get("content")
-
-                text = concat_text(content)
-                if text:
-                    turns.append({
-                        "role": "user",
-                        "text": text,
-                        "ts": ts,
-                    })
-                # No user turn emitted when content is empty or only
-                # carries tool_result blocks — those landed on the
-                # owning assistant turn above.
-
-            elif t == "assistant":
-                msg_id = msg.get("id") if isinstance(msg.get("id"), str) else None
-                text = concat_text(content)
-                tool_use_blocks = []
-                if isinstance(content, list):
-                    for b in content:
-                        if isinstance(b, dict) and b.get("type") == "tool_use":
-                            tool_use_blocks.append(b)
-
-                # Thinking-only assistant records contribute nothing and
-                # do NOT create a turn entry on their own.
-                if not text and not tool_use_blocks:
-                    continue
-
-                # Multi-block collapse: if a prior record with the same
-                # message.id created a turn, extend that one. Otherwise
-                # open a new assistant turn.
-                if msg_id is not None and msg_id in msg_id_to_turn_index:
-                    idx = msg_id_to_turn_index[msg_id]
-                    entry = turns[idx]
-                    if text:
-                        entry["text"] = (entry["text"] or "") + text
-                else:
-                    entry = {
-                        "role": "assistant",
-                        "text": text,
-                        "ts": ts,
-                    }
-                    turns.append(entry)
-                    idx = len(turns) - 1
-                    if msg_id is not None:
-                        msg_id_to_turn_index[msg_id] = idx
-
-                for b in tool_use_blocks:
-                    tc_list = entry.setdefault("toolCalls", [])
-                    tc_list.append({
-                        "tool":   b.get("name"),
-                        "input":  b.get("input"),
-                        "output": None,
-                    })
-                    tu_id = b.get("id")
-                    if isinstance(tu_id, str):
-                        pending_tool_calls[tu_id] = (idx, len(tc_list) - 1)
-except Exception:
-    pass
-
-envelope = {
-    "turns":          turns,
-    "sessionId": session_id,
-    "accountId":      account_id,
-    "occurredAt":     occurred_at,
-}
-print(json.dumps(envelope, ensure_ascii=False), end="")
-PY
-)
-
-# Skip when turns is empty — no user text, no assistant text, no tool_use
-# in the operator JSONL. Same skip surface as the prior `conversation-empty`
-# reason; the meaning is now binary on turns.length === 0.
-EMPTY_CHECK=$(printf '%s' "$ENVELOPE" | python3 -c '
-import sys, json
-try:
-    e = json.load(sys.stdin)
-    print("empty" if not (e.get("turns") or []) else "ok")
-except Exception:
-    print("empty")
-')
-
-CONVERSATION_BYTES=$(printf '%s' "$ENVELOPE" | wc -c | tr -d ' ')
-TRANSCRIPT_BYTES=$(wc -c <"$TRANSCRIPT_PATH" 2>/dev/null | tr -d ' ' || echo 0)
-
-emit_log "trigger sessionId=${ADMIN_SESSION_ID} turnIndex=0 transcriptBytes=${TRANSCRIPT_BYTES} conversationBytes=${CONVERSATION_BYTES}"
-
-if [ "$EMPTY_CHECK" = "empty" ]; then
-  emit_log "trigger-skipped sessionId=${ADMIN_SESSION_ID} reason=conversation-empty"
-  exit 0
-fi
-
-# Task 177 observability — one envelope summary line per recorder fire,
-# emitted BEFORE the spawn POST so a future audit reads counts from
-# server.log without re-walking the JSONL. `turnsCount` is monotone
-# across spawns in the same operator session — flat or decreasing is
-# the regression signature for "windowing crept back in".
-ENVELOPE_COUNTS=$(printf '%s' "$ENVELOPE" | python3 -c '
-import sys, json
-e = json.load(sys.stdin)
-turns = e.get("turns") or []
-u = sum(1 for t in turns if t.get("role") == "user")
-a = sum(1 for t in turns if t.get("role") == "assistant")
-tc = sum(1 for t in turns if (t.get("toolCalls") or []))
-print(f"{len(turns)} {u} {a} {tc}")
-')
-read -r TURNS_COUNT USER_TURNS ASST_TURNS TC_TURNS <<<"$ENVELOPE_COUNTS"
-emit_log "envelope sessionId=${ADMIN_SESSION_ID} turnsCount=${TURNS_COUNT} userTurns=${USER_TURNS} assistantTurns=${ASST_TURNS} toolCallTurns=${TC_TURNS}"
-
-# Task 195 — substitute {schema} and {conversation} placeholders in the
-# database-operator agent body before spawning. The agent file on disk
-# carries the four-sentence template verbatim with both placeholders; the
-# hook renders the actual schema text and a flat `role: text` conversation
-# transcript here, then sends the filled paragraph as `initialMessage`.
-# The model's first input is the filled prompt — no JSON envelope, no
-# instruction prose, no placeholders.
-HOOK_DIR_RESOLVED="$(cd "$(dirname "$0")" && pwd)"
-PLATFORM_ROOT_RESOLVED="$(cd "${HOOK_DIR_RESOLVED}/../../.." && pwd)"
-SCHEMA_BASE_PATH="${PLATFORM_ROOT_RESOLVED}/plugins/memory/references/schema-base.md"
-BRAND_JSON_PATH="${PLATFORM_ROOT_RESOLVED}/config/brand.json"
-AGENT_BODY_PATH="${PLATFORM_ROOT_RESOLVED}/templates/specialists/agents/database-operator.md"
-
-if [ ! -f "$SCHEMA_BASE_PATH" ]; then
-  emit_log "spawn-failed sessionId=${ADMIN_SESSION_ID} reason=schema-base-missing path=${SCHEMA_BASE_PATH}"
-  exit 0
-fi
-if [ ! -f "$AGENT_BODY_PATH" ]; then
-  emit_log "spawn-failed sessionId=${ADMIN_SESSION_ID} reason=agent-body-missing path=${AGENT_BODY_PATH}"
-  exit 0
-fi
-
-# Brand-declared vertical (Task 193). Treated as null when brand.json is
-# absent, unparseable, lacks the field, or names a file that does not
-# exist — every one of those collapses to "schema-base only", never
-# loud-fails this hook. Task 193 itself is the loud-fail surface for
-# brand-config defects.
-VERTICAL_PATH=""
-if [ -f "$BRAND_JSON_PATH" ]; then
-  VERTICAL_NAME=$(python3 -c '
-import sys, json
-try:
-    with open(sys.argv[1]) as f:
-        b = json.load(f)
-    v = b.get("vertical")
-    print(v if isinstance(v, str) and v else "")
-except Exception:
-    print("")
-' "$BRAND_JSON_PATH")
-  if [ -n "$VERTICAL_NAME" ]; then
-    CANDIDATE="${PLATFORM_ROOT_RESOLVED}/plugins/memory/references/${VERTICAL_NAME}.md"
-    if [ -f "$CANDIDATE" ]; then
-      VERTICAL_PATH="$CANDIDATE"
-    fi
-  fi
-fi
-
-# One Python pass:
-#   - reads the agent file and strips the frontmatter to recover the
-#     paragraph (the literal four sentences with `{schema}` and
-#     `{conversation}` placeholders);
-#   - reads schema-base.md (and concatenates the vertical when set);
-#   - renders the envelope's `turns` array into a flat transcript — one
-#     line per turn, `role: text`. The recorder is the only writer to the
-#     graph; rendering the operator's tool_use blocks inline taught the
-#     model (Task 213 evidence in sessions d2aaa85e / 481799d1) to copy
-#     the shape and emit `<tool_call>{…}</tool_call>` as text instead of
-#     real tool_use blocks. The envelope's `toolCalls` are still captured
-#     for the `[turn-recorder] envelope … toolCallTurns=N` observability
-#     line; they no longer reach the spawn prompt;
-#   - substitutes both placeholders in the paragraph;
-#   - emits one tab-separated line of byte counts, then the
-#     spawn-body JSON containing the filled paragraph as `initialMessage`.
-# The envelope rides through a tmpfile (not stdin) so the python script
-# can be sourced from the heredoc; the two stdin redirections would
-# otherwise collide and Python would see an empty envelope.
-ENVELOPE_FILE=$(mktemp)
-printf '%s' "$ENVELOPE" > "$ENVELOPE_FILE"
-COMBINED=$(python3 - \
-  "$AGENT_BODY_PATH" "$SCHEMA_BASE_PATH" "$VERTICAL_PATH" "$ADMIN_SESSION_ID" "$ENVELOPE_FILE" <<'PY'
-import sys, json
-
-agent_path, schema_path, vertical_path, sid, envelope_path = sys.argv[1:6]
-
-with open(agent_path, "r", encoding="utf-8") as f:
-    raw = f.read()
-parts = raw.split("---", 2)
-body_template = parts[2].lstrip("\n").rstrip() if len(parts) >= 3 else raw.rstrip()
-
-with open(schema_path, "r", encoding="utf-8") as f:
-    schema_text = f.read()
-if vertical_path:
-    with open(vertical_path, "r", encoding="utf-8") as f:
-        schema_text = schema_text.rstrip() + "\n\n" + f.read()
-
-with open(envelope_path, "r", encoding="utf-8") as f:
-    envelope = json.load(f)
-account_id = envelope.get("accountId", "") or ""
-turns = envelope.get("turns") or []
-lines = []
-for t in turns:
-    role = t.get("role", "?")
-    text_t = t.get("text", "") or ""
-    lines.append(f"{role}: {text_t}")
-# Wrap the transcript block in newlines so each turn lands on its own
-# line in the filled prompt — the template's `{conversation}` sits
-# mid-sentence, so the leading newline separates the first transcript
-# line from the surrounding prose, and the trailing newline separates
-# the last one from the closing `, using the tools at your disposal.`
-conversation_text = "\n" + "\n".join(lines) + "\n"
-
-filled = (
-    body_template
-    .replace("{schema}", schema_text)
-    .replace("{accountId}", account_id)
-    .replace("{conversation}", conversation_text)
-)
-
-schema_bytes = len(schema_text.encode("utf-8"))
-conv_bytes = len(conversation_text.encode("utf-8"))
-body_bytes = len(filled.encode("utf-8"))
-account_id_present = "yes" if account_id else "no"
-
-spawn_body = {
-  "adminSessionId": sid,
-  "channel": "browser",
-  "specialist": "database-operator",
-  "initialMessage": filled,
-}
-# Task 500 — under the `claude rc` daemon, admin sessions are not
-# maxy-spawned, so the manager's `/<sid>/meta` carries no senderId. Pass
-# the hook's ACCOUNT_ID env as the authoritative senderId fallback. Empty
-# is omitted so the route's loopback guard rejects rather than minting an
-# empty-scope row.
-if account_id:
-    spawn_body["accountId"] = account_id
-
-print(f"{schema_bytes}\t{conv_bytes}\t{body_bytes}\t{account_id_present}")
-print(json.dumps(spawn_body))
-PY
-)
-rm -f "$ENVELOPE_FILE"
-
-BYTES_LINE=$(printf '%s' "$COMBINED" | head -n1)
-SPAWN_BODY=$(printf '%s' "$COMBINED" | tail -n +2)
-IFS=$'\t' read -r SCHEMA_BYTES CONV_BYTES BODY_BYTES ACCOUNT_ID_PRESENT <<<"$BYTES_LINE"
-
-emit_log "substitution sessionId=${ADMIN_SESSION_ID} schemaBytes=${SCHEMA_BYTES} conversationBytes=${CONV_BYTES} bodyBytes=${BODY_BYTES} accountIdPresent=${ACCOUNT_ID_PRESENT}"
-emit_log "spawn-request sessionId=${ADMIN_SESSION_ID} specialist=database-operator initialMessageBytes=${BODY_BYTES}"
-
-SPAWN_RES_FILE=$(mktemp)
-SPAWN_HTTP=$(curl -sS -o "$SPAWN_RES_FILE" -w '%{http_code}' -X POST \
-  -H 'Content-Type: application/json' \
-  --max-time 10 \
-  --data "$SPAWN_BODY" \
-  "${UI_BASE}/api/admin/claude-sessions" 2>/dev/null || echo 000)
-
-RES_BODY=$(cat "$SPAWN_RES_FILE" 2>/dev/null || true)
-rm -f "$SPAWN_RES_FILE"
-
-if [ "$SPAWN_HTTP" -lt 200 ] || [ "$SPAWN_HTTP" -ge 300 ]; then
-  ERR_SHORT=$(printf '%s' "$RES_BODY" | tr -d '\r\n' | cut -c1-200)
-  emit_log "spawn-failed sessionId=${ADMIN_SESSION_ID} reason=loopback-http http=${SPAWN_HTTP} err=$(python3 -c 'import sys,json; print(json.dumps(sys.argv[1]))' "${ERR_SHORT}")"
-fi
-
-exit 0