@rubytech/create-maxy-code 0.1.65 → 0.1.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-maxy-code",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "description": "Install Maxy — AI for Productive People",
   "bin": {
     "create-maxy-code": "./dist/index.js"

package/payload/platform/plugins/admin/PLUGIN.md

@@ -129,7 +129,7 @@ Tools are available via the `admin` MCP server.
 - `hooks/pre-tool-use.sh` — enforces admin agent write boundaries
 - `hooks/playwright-file-guard.sh` — rewrites file:// URLs to a backgrounded loopback http.server before Playwright sees them
 - `hooks/webfetch-preflight.mjs` — short-circuits WebFetch on JS-SPA shells with a structured `WEBFETCH_CANNOT_READ_JS_SPA` error so the agent surfaces a loud failure to the owner instead of paying the 60s extraction timeout. Fail-open on any internal error.
-- `hooks/turn-completed-graph-write.sh` — Stop hook fired once per completed admin-agent turn. Gates on `MAXY_SESSION_ROLE=admin` + `MAXY_IS_RECORDER!=1` so it never recurses into the recorder PTY or fires on public sessions. **Task 134 redesign** — the recorder is spawned via the same route Sidebar uses. ONE POST to `POST /api/admin/claude-sessions`, body carries `{specialist:'database-operator', initialMessage:'<instruction>\n\n<last-turn-text>', originatingSessionId:<op>}` — no synthetic `senderId: 'turn-recorder'` marker. The Hono wrapper bypasses cookie auth on this exact method+path when the request originates from `127.0.0.1` (same trust boundary the claude-session-manager itself relies on), looks up the operator's senderId from the manager's `/<originatingSessionId>/meta`, and forwards a Sidebar-shape spawn body. The `/recorder-spawn` sibling route is gone. The hook reads its UI port from `MAXY_UI_INTERNAL_PORT` (stamped on the manager systemd unit) — no fallback; absence emits `[turn-recorder] spawn-failed reason=missing-env env=MAXY_UI_INTERNAL_PORT` to stderr instead of silently 19199-ing. **Task 153** — `initialMessage` rides on the `/spawn` body as a trailing positional argv to `claude`, so the database-operator session's JSONL first `role=user` line equals `"update the graph with any new or missing information or intent\n\n<last-turn-text>"` verbatim. No separate `POST /:id/input` call, no bracketed-paste, no keystroke injection. The recorder-auto-archive subscriber stops the recorder PTY as soon as its JSONL contains an assistant message with `stop_reason === "end_turn"`. **Task 129** — every emit goes through `POST /api/admin/log-ingest` so the lines land in `server.log` keyed by the operator session id. The chain is `trigger` → `spawn-request` → `spawn-success` → `input-delivered` → `tool-call` × N → `tool-result` × N → `write-complete` → `auto-archive`; each gated-off path emits one `trigger-skipped reason=<role-not-admin|is-recorder|empty-stdin|missing-transcript|last-turn-empty>` line. The spawn body carries `originatingSessionId` as a structural top-level field so downstream loggers read the operator id without parsing prose. Failure modes — `spawn-failed`, `tool-surface-missing`, `input-failed`, `write-empty`, `auto-archive reason=stale-recorder` — each emit one named line; absence is itself a defect.
+- `hooks/turn-completed-graph-write.sh` — Stop hook fired once per completed admin-agent turn. Gates on `MAXY_SESSION_ROLE=admin` + `MAXY_SPECIALIST!=database-operator` so it never recurses into the recorder PTY or fires on public sessions. **Task 147** — the recorder is spawned via the same route Sidebar uses. ONE POST to `POST /api/admin/claude-sessions`, body carries `{specialist:'database-operator', model:'haiku', initialMessage:<json-envelope>, adminSessionId:<op>}` — no synthetic `senderId: 'turn-recorder'` marker. The Hono wrapper bypasses cookie auth on this exact method+path when the request originates from `127.0.0.1` (same trust boundary the claude-session-manager itself relies on), looks up the operator's senderId from the manager's `/<adminSessionId>/meta`, and forwards a Sidebar-shape spawn body. The `/recorder-spawn` sibling route is gone. The hook reads its UI port from `MAXY_UI_INTERNAL_PORT` (stamped on the manager systemd unit) — no fallback; absence emits `[turn-recorder] spawn-failed reason=missing-env env=MAXY_UI_INTERNAL_PORT` to stderr instead of silently 19199-ing. **Task 177** — `initialMessage` is a JSON-stringified envelope conforming to the database-operator agent file's `## Input shape`. Top-level keys exactly: `turns`, `conversationId`, `accountId`, `occurredAt`. `turns` is the full conversation transcript, oldest first, newest last, with each entry `{ role: "user"|"assistant", text, ts, toolCalls? }`. No windowing, no truncation. Multi-record assistant messages collapse on `message.id`. `tool_use` and matching `tool_result` blocks attach as a single `toolCalls` entry on the owning assistant turn; the user record carrying only the `tool_result` does not create a separate user turn. No leading instruction prose. `toolCalls[].input` and `toolCalls[].output` are native JSON values, never re-stringified. (Replaces Task 175's `(operatorMessage, assistantReply)` pair, which asserted a temporal Q→A relationship the walker never enforced.) One observability line `[turn-recorder] envelope sessionId=<op> turnsCount=<n> userTurns=<n> assistantTurns=<n> toolCallTurns=<n>` precedes `spawn-request`. The envelope rides on the `/spawn` body as a trailing positional argv to `claude`, so the database-operator session's JSONL first `role=user` line is the JSON object verbatim. No separate `POST /:id/input` call, no bracketed-paste, no keystroke injection. The recorder-auto-archive subscriber stops the recorder PTY as soon as its JSONL contains an assistant message with `stop_reason === "end_turn"`. **Task 129** — every emit goes through `POST /api/admin/log-ingest` so the lines land in `server.log` keyed by the operator session id. The chain is `trigger` → `spawn-request` → `spawn-success` → `input-delivered` → `tool-call` × N → `tool-result` × N → `write-complete` → `auto-archive`; each gated-off path emits one `trigger-skipped reason=<role-not-admin|is-recorder|empty-stdin|missing-transcript|conversation-empty>` line. Failure modes — `spawn-failed`, `tool-surface-missing`, `input-failed`, `write-empty`, `auto-archive reason=stale-recorder` — each emit one named line; absence is itself a defect.
 
 ## Session identifiers (Task 135)
 

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

@@ -1,18 +1,24 @@
 #!/usr/bin/env bash
-# Task 129/131 regression test for the Stop hook.
+# Task 129/131/165/175/177 regression test for the Stop hook.
 #
 # 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).
+#     missing-transcript | conversation-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.
+#     `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 a JSON-stringified object with EXACTLY the four keys declared by
+#     the Task 177 envelope: turns, conversationId, accountId, occurredAt.
+#     `turns` is the chronologically-ordered list of conversation turns.
+#     No top-level operatorMessage. No top-level assistantReply.
+#     No leading instruction prose. No `Conversation id:` prose.
+#   - The hook emits one `[turn-recorder] envelope ...` log line before
+#     `spawn-request`, naming turnsCount / userTurns / assistantTurns /
+#     toolCallTurns.
 #   - The hook never writes the legacy `spawn-with-input` / `fired` stderr
 #     lines.
 #
@@ -30,6 +36,7 @@ if [[ ! -x "$HOOK" ]]; then
 fi
 
 OP_ID='aaaaaaaa-1111-2222-3333-bbbbbbbbbbbb'
+ACCT_ID='acct-test-0001'
 
 TMPFILES=()
 LISTENER_PIDS=()
@@ -92,6 +99,7 @@ run_hook() {
     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")
@@ -114,15 +122,12 @@ for raw in sys.stdin:
 ' || true
 }
 
-# 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
+# Simple two-turn transcript with timestamps. One user, one assistant text.
 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'
+  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
@@ -177,20 +182,33 @@ else
   fail "case-4 expected trigger-skipped missing-transcript, got: $(ingest_lines)"
 fi
 
-# --- Case 5: happy path -------------------------------------------------
+# --- 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, conversationId, 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" "" "$ENVELOPE"
+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
-#     and `conversationBytes=<n>` (Task 165 — full transcript walker
-#     replaces last-turn-only extractor; field is renamed for clarity).
+# 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 emitted via log-ingest carrying operator id + conversationBytes"
+  pass "case-5a exactly one trigger line via log-ingest"
 else
-  fail "case-5a expected exactly 1 trigger line carrying ${OP_ID}, got $TRIGGER_COUNT (lines: $(ingest_lines))"
+  fail "case-5a expected exactly 1 trigger line, got $TRIGGER_COUNT (lines: $(ingest_lines))"
 fi
 
 # 5b. exactly ONE POST to /api/admin/claude-sessions
@@ -201,40 +219,57 @@ else
   fail "case-5b expected exactly 1 recorder-spawn POST, got $RECORDER_LINES"
 fi
 
-# 5c. Sidebar-shape body with three overrides (specialist, model,
-#     initialMessage); adminSessionId carries the operator's session id as
-#     the loopback-bypass lookup key. No senderId on the wire (the wrapper
-#     resolves it from the manager's /meta).
+# 5c. Envelope has exactly four keys (turns, conversationId, accountId,
+#     occurredAt). `turns` carries 4 entries in record order; each has
+#     role/text/ts. No `toolCalls` on turns where there were no tool_use
+#     blocks (omitted-when-empty rule).
 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
+import sys, json, re
 op = sys.argv[1]
-INSTRUCTION = "update the graph with any new or missing information or intent"
-# Task 165 — initialMessage carries the full transcript layout
-# "user: <text>\nassistant: <text>\n…", not just the last assistant text.
-EXPECTED_CONVERSATION = "user: hello operator\nassistant: hello, assistant reply"
+acct = sys.argv[2]
 try:
-  b = json.load(sys.stdin)
-  msg = b.get("initialMessage") or ""
-  conds = (
-    "senderId" not in b,
-    b.get("specialist") == "database-operator",
-    b.get("model") == "haiku",
-    b.get("adminSessionId") == op,
-    b.get("channel") == "browser",
-    msg == INSTRUCTION + "\n\n" + EXPECTED_CONVERSATION,
-    "Conversation id:" not in msg,
-    "Conversation transcript:" not in msg,
-    "originatingSessionId" not in b,
-  )
-  print("yes" if all(conds) else "no:"+repr(conds)+"|msg="+repr(msg))
+  outer = json.load(sys.stdin)
+  msg_str = outer.get("initialMessage")
+  if not isinstance(msg_str, str):
+    print("no:initialMessage-not-string:"+repr(type(msg_str).__name__))
+    sys.exit(0)
+  msg = json.loads(msg_str)
+  keys = set(msg.keys())
+  turns = msg.get("turns") or []
+  conds = []
+  conds.append(("envelope-keys", keys == {"turns", "conversationId", "accountId", "occurredAt"}))
+  conds.append(("turns-len", len(turns) == 4))
+  conds.append(("conversationId", msg.get("conversationId") == op))
+  conds.append(("accountId", msg.get("accountId") == acct))
+  conds.append(("occurredAt-shape", bool(re.match(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.000Z$", msg.get("occurredAt") or ""))))
+  conds.append(("no-operatorMessage", "operatorMessage" not in keys))
+  conds.append(("no-assistantReply", "assistantReply" not in keys))
+  if len(turns) >= 4:
+    conds.append(("t0-role", turns[0].get("role") == "user"))
+    conds.append(("t0-text", turns[0].get("text") == "New Real Agent session"))
+    conds.append(("t0-ts", turns[0].get("ts") == "2026-05-19T21:27:42.258Z"))
+    conds.append(("t0-no-toolCalls", "toolCalls" not in turns[0]))
+    conds.append(("t1-role", turns[1].get("role") == "assistant"))
+    conds.append(("t1-text", turns[1].get("text") == "Session noted. What would you like to work on?"))
+    conds.append(("t1-ts", turns[1].get("ts") == "2026-05-19T21:27:45.158Z"))
+    conds.append(("t1-no-toolCalls", "toolCalls" not in turns[1]))
+    conds.append(("t2-role", turns[2].get("role") == "user"))
+    conds.append(("t2-text", turns[2].get("text") == "you tell me"))
+    conds.append(("t3-role", turns[3].get("role") == "assistant"))
+    conds.append(("t3-text", turns[3].get("text") == "One question to anchor the next move: what is your name?"))
+  conds.append(("outer-specialist", outer.get("specialist") == "database-operator"))
+  conds.append(("outer-model", outer.get("model") == "haiku"))
+  conds.append(("outer-adminSessionId", outer.get("adminSessionId") == op))
+  failed = [name for name, ok in conds if not ok]
+  print("yes" if not failed else "no:"+repr(failed)+"|turns="+repr(turns))
 except Exception as e:
   print("parse-fail:"+str(e))
-' "$OP_ID" 2>/dev/null)
+' "$OP_ID" "$ACCT_ID" 2>/dev/null)
 if [[ "$BODY_OK" == "yes" ]]; then
-  pass "case-5c body carries full transcript layout (user: …\\nassistant: …) — Task 165"
+  pass "case-5c envelope is { turns, conversationId, accountId, occurredAt }; turns is the 4-entry ordered list"
 else
-  fail "case-5c body shape wrong ($BODY_OK): $RECORDER_BODY"
+  fail "case-5c envelope shape wrong ($BODY_OK): $RECORDER_BODY"
 fi
 
 # 5d. exactly ONE `spawn-request` log-ingest line
@@ -245,67 +280,268 @@ else
   fail "case-5d expected 1 spawn-request, got $SPAWN_REQ_COUNT (lines: $(ingest_lines))"
 fi
 
-# 5e. no legacy stderr emissions
+# 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-5e legacy stderr line emitted: $HOOK_STDERR"
+  fail "case-5g legacy stderr line emitted: $HOOK_STDERR"
+else
+  pass "case-5g no legacy stderr emissions"
+fi
+
+# --- Case 6 (Task 177): multi-block assistant collapse -----------------
+# Two assistant JSONL records sharing `message.id`: first is thinking-only,
+# second carries the text. Walker collapses both into ONE `turns` entry
+# whose text is the text-record's text. Thinking records contribute no
+# text and do not establish the turn; `ts` is the first CONTRIBUTING
+# record's ts (here, the text record's ts).
+MULTI_TRANSCRIPT=$(mktemp); TMPFILES+=("$MULTI_TRANSCRIPT")
+{
+  printf '{"type":"user","timestamp":"2026-05-19T21:30:00.000Z","message":{"role":"user","content":"think then answer"}}\n'
+  printf '{"type":"assistant","timestamp":"2026-05-19T21:30:01.000Z","message":{"id":"msg_multi","role":"assistant","content":[{"type":"thinking","thinking":"considering..."}]}}\n'
+  printf '{"type":"assistant","timestamp":"2026-05-19T21:30:02.000Z","message":{"id":"msg_multi","role":"assistant","content":[{"type":"text","text":"answer is 42"}]}}\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"
+MULTI_BODY=$(grep -E '^/api/admin/claude-sessions	' "$REQ_LOG" | head -1 | cut -f2-)
+MULTI_OK=$(printf '%s' "$MULTI_BODY" | python3 -c '
+import sys, json
+try:
+  outer = json.load(sys.stdin)
+  msg = json.loads(outer.get("initialMessage"))
+  turns = msg.get("turns") or []
+  conds = []
+  conds.append(("turns-len-2", len(turns) == 2))
+  if len(turns) >= 2:
+    conds.append(("t0-user", turns[0].get("role") == "user" and turns[0].get("text") == "think then answer"))
+    conds.append(("t1-assistant", turns[1].get("role") == "assistant"))
+    conds.append(("t1-text", turns[1].get("text") == "answer is 42"))
+    conds.append(("t1-ts-text-record", turns[1].get("ts") == "2026-05-19T21:30:02.000Z"))
+    conds.append(("t1-no-toolCalls", "toolCalls" not in turns[1]))
+  failed = [name for name, ok in conds if not ok]
+  print("yes" if not failed else "no:"+repr(failed)+"|turns="+repr(turns))
+except Exception as e:
+  print("parse-fail:"+str(e))
+' 2>/dev/null)
+if [[ "$MULTI_OK" == "yes" ]]; then
+  pass "case-6 multi-block assistant collapses to one turn entry; ts is the first record's ts"
+else
+  fail "case-6 multi-block collapse wrong ($MULTI_OK): $MULTI_BODY"
+fi
+
+# --- Case 7 (Task 177): tool-call pairing on owning assistant turn -----
+# Assistant tool_use followed by user tool_result. Both attach as ONE
+# `toolCalls` entry on the assistant turn that owned the tool_use.
+# The tool_result-only user record does NOT create a separate user turn.
+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"
+TOOL_BODY=$(grep -E '^/api/admin/claude-sessions	' "$REQ_LOG" | head -1 | cut -f2-)
+TOOL_OK=$(printf '%s' "$TOOL_BODY" | python3 -c '
+import sys, json
+try:
+  outer = json.load(sys.stdin)
+  msg = json.loads(outer.get("initialMessage"))
+  turns = msg.get("turns") or []
+  conds = []
+  # Expected 3 turns: user "please write a node", assistant tool_use (text=""),
+  # assistant "done". The user tool_result record carries no separate user turn.
+  conds.append(("turns-len-3", len(turns) == 3))
+  if len(turns) >= 3:
+    conds.append(("t0", turns[0].get("role") == "user" and turns[0].get("text") == "please write a node"))
+    conds.append(("t1-role", turns[1].get("role") == "assistant"))
+    conds.append(("t1-text-empty", turns[1].get("text") == ""))
+    conds.append(("t1-toolCalls-len", len(turns[1].get("toolCalls") or []) == 1))
+    tc = (turns[1].get("toolCalls") or [{}])[0]
+    conds.append(("tc-tool", tc.get("tool") == "mcp__memory__memory-write"))
+    conds.append(("tc-input", tc.get("input") == {"nodeType":"LocalBusiness","name":"Smalleys","nested":{"k":1}}))
+    conds.append(("tc-output", tc.get("output") == "ok: wrote LocalBusiness"))
+    conds.append(("t2", turns[2].get("role") == "assistant" and turns[2].get("text") == "done"))
+    conds.append(("t2-no-toolCalls", "toolCalls" not in turns[2]))
+  failed = [name for name, ok in conds if not ok]
+  print("yes" if not failed else "no:"+repr(failed)+"|turns="+repr(turns))
+except Exception as e:
+  print("parse-fail:"+str(e))
+' 2>/dev/null)
+if [[ "$TOOL_OK" == "yes" ]]; then
+  pass "case-7 tool_use + tool_result land as one toolCalls entry on owning assistant turn; no extra user turn"
 else
-  pass "case-5e no legacy stderr emissions"
+  fail "case-7 tool pairing wrong ($TOOL_OK): $TOOL_BODY"
 fi
 
-# --- Case 6 (Task 165): transcript has zero qualifying records → --------
-#     trigger-skipped reason=conversation-empty. The hook emits the
-#     trigger line first (conversationBytes=0) and then the new skip
-#     reason.
+# 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"
+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 (Task 177): long-conversation 100 turns ------------------
+# Transcript with 100 turns (50 user + 50 assistant, interleaved) →
+# turns.length === 100. No drop, no truncation, no env-knob override.
+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"
+LONG_BODY=$(grep -E '^/api/admin/claude-sessions	' "$REQ_LOG" | head -1 | cut -f2-)
+LONG_OK=$(printf '%s' "$LONG_BODY" | python3 -c '
+import sys, json
+try:
+  outer = json.load(sys.stdin)
+  msg = json.loads(outer.get("initialMessage"))
+  turns = msg.get("turns") or []
+  conds = []
+  conds.append(("turns-len-100", len(turns) == 100))
+  if len(turns) == 100:
+    conds.append(("first-user-0", turns[0].get("role") == "user" and turns[0].get("text") == "user msg 0"))
+    conds.append(("last-asst-49", turns[99].get("role") == "assistant" and turns[99].get("text") == "asst reply 49"))
+    # ts strictly non-decreasing
+    tss = [t.get("ts","") for t in turns]
+    conds.append(("ts-ordered", tss == sorted(tss)))
+  failed = [name for name, ok in conds if not ok]
+  print("yes" if not failed else "no:"+repr(failed)+"|len="+str(len(turns)))
+except Exception as e:
+  print("parse-fail:"+str(e))
+' 2>/dev/null)
+if [[ "$LONG_OK" == "yes" ]]; then
+  pass "case-8 100-turn transcript → turns.length === 100, oldest first, no truncation"
+else
+  fail "case-8 long-conversation wrong ($LONG_OK)"
+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' > "$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-6 rc=$HOOK_RC"
+[[ "$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-6 zero user/assistant records → trigger-skipped reason=conversation-empty emitted"
+  pass "case-9 thinking-only transcript → trigger-skipped reason=conversation-empty"
 else
-  fail "case-6 expected trigger-skipped conversation-empty, got: $(ingest_lines)"
+  fail "case-9 expected trigger-skipped conversation-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 conversation-empty"
+  fail "case-9 recorder-spawn must NOT be called when conversation-empty"
+else
+  pass "case-9 no recorder-spawn POST"
 fi
 
-# --- Case 7 (Task 165): three-turn conversation walks user/assistant/user
-#     in transcript order; layout is "user: …\nassistant: …\nuser: …". ---
-THREE_TURN_TRANSCRIPT=$(mktemp); TMPFILES+=("$THREE_TURN_TRANSCRIPT")
-{
-  printf '{"type":"user","message":{"role":"user","content":"hello"}}\n'
-  printf '{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"what'"'"'s your business?"}]}}\n'
-  printf '{"type":"user","message":{"role":"user","content":"Smalleys"}}\n'
-} > "$THREE_TURN_TRANSCRIPT"
-THREE_ENVELOPE=$(python3 -c '
+# --- Case 10 (Task 177): escaping round-trip --------------------------
+# Quotes, backslashes, newlines, non-ASCII all round-trip cleanly through
+# the JSON envelope's `turns[*].text` field.
+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" "$THREE_TURN_TRANSCRIPT")
+' "$OP_ID" "$ESC_TRANSCRIPT")
 : > "$REQ_LOG"
-run_hook "admin" "" "$THREE_ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-7 rc=$HOOK_RC stderr=$HOOK_STDERR"
-THREE_BODY=$(grep -E '^/api/admin/claude-sessions	' "$REQ_LOG" | head -1 | cut -f2-)
-THREE_OK=$(printf '%s' "$THREE_BODY" | python3 -c '
+run_hook "admin" "" "$ESC_ENVELOPE"
+[[ "$HOOK_RC" -eq 0 ]] || fail "case-10 rc=$HOOK_RC stderr=$HOOK_STDERR"
+ESC_BODY=$(grep -E '^/api/admin/claude-sessions	' "$REQ_LOG" | head -1 | cut -f2-)
+ESC_OK=$(printf '%s' "$ESC_BODY" | python3 -c '
 import sys, json
-INSTRUCTION = "update the graph with any new or missing information or intent"
-EXPECTED = "user: hello\nassistant: what'"'"'s your business?\nuser: Smalleys"
+EXPECTED_OP = "hello \"world\"\\nline2\nlast — café \U0001F98A"
+EXPECTED_ASST = "reply with backslash \\\\ and newline\nhere"
 try:
-  b = json.load(sys.stdin)
-  msg = b.get("initialMessage") or ""
-  print("yes" if msg == INSTRUCTION + "\n\n" + EXPECTED else "no:"+repr(msg))
+  outer = json.load(sys.stdin)
+  msg = json.loads(outer.get("initialMessage"))
+  turns = msg.get("turns") or []
+  conds = []
+  conds.append(("len-2", len(turns) == 2))
+  if len(turns) == 2:
+    conds.append(("op-text", turns[0].get("text") == EXPECTED_OP))
+    conds.append(("asst-text", turns[1].get("text") == EXPECTED_ASST))
+  failed = [name for name, ok in conds if not ok]
+  print("yes" if not failed else "no:"+repr(failed)+"|turns="+repr(turns))
 except Exception as e:
   print("parse-fail:"+str(e))
 ' 2>/dev/null)
-if [[ "$THREE_OK" == "yes" ]]; then
-  pass "case-7 three-turn conversation walks user/assistant/user in order"
+if [[ "$ESC_OK" == "yes" ]]; then
+  pass "case-10 escaping: quotes/backslashes/newlines/non-ASCII round-trip cleanly through turns[*].text"
 else
-  fail "case-7 expected multi-turn layout, got: $THREE_OK | body: $THREE_BODY"
+  fail "case-10 escaping wrong ($ESC_OK): $ESC_BODY"
 fi
 
 # --- Summary ------------------------------------------------------------