@rubytech/create-maxy-code 0.1.66 → 0.1.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-maxy-code",
-  "version": "0.1.66",
+  "version": "0.1.68",
   "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_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 175** — `initialMessage` is now a JSON-stringified envelope conforming to the database-operator agent file's `## Input shape`. Top-level keys exactly: `operatorMessage`, `assistantReply`, `toolCalls`, `conversationId`, `accountId`, `occurredAt`. No leading instruction prose. `toolCalls[].input` and `toolCalls[].output` are native JSON values, never re-stringified. 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.
+- `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,5 +1,5 @@
 #!/usr/bin/env bash
-# Task 129/131/165/175 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
@@ -11,11 +11,14 @@
 #     `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 six keys declared by
-#     the database-operator agent file: operatorMessage, assistantReply,
-#     toolCalls, conversationId, accountId, occurredAt. No leading
-#     instruction prose. No `Conversation id:` prose. No
-#     `user:`/`assistant:` walk format.
+#     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.
 #
@@ -119,14 +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.
 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
@@ -181,19 +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>`.
+# 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
@@ -204,10 +219,10 @@ else
   fail "case-5b expected exactly 1 recorder-spawn POST, got $RECORDER_LINES"
 fi
 
-# 5c. Task 175 — `initialMessage` is a JSON-stringified object with
-#     EXACTLY the six declared top-level keys. No instruction prose.
-#     `operatorMessage` / `assistantReply` carry the last user / assistant
-#     text blocks. `toolCalls` is `[]` (no tool_use in this transcript).
+# 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, re
@@ -216,36 +231,43 @@ acct = sys.argv[2]
 try:
   outer = json.load(sys.stdin)
   msg_str = outer.get("initialMessage")
-  # initialMessage must be a string carrying a JSON-stringified object.
   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())
-  conds = (
-    keys == {"operatorMessage", "assistantReply", "toolCalls", "conversationId", "accountId", "occurredAt"},
-    msg.get("operatorMessage") == "hello operator",
-    msg.get("assistantReply") == "hello, assistant reply",
-    msg.get("toolCalls") == [],
-    msg.get("conversationId") == op,
-    msg.get("accountId") == acct,
-    bool(re.match(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.000Z$", msg.get("occurredAt") or "")),
-    "update the graph" not in msg_str,
-    "user:" not in msg_str.lower() or "user:" not in (msg.get("operatorMessage") or "").lower(),
-    "Conversation id:" not in msg_str,
-    outer.get("specialist") == "database-operator",
-    outer.get("model") == "haiku",
-    outer.get("adminSessionId") == op,
-    outer.get("channel") == "browser",
-    "senderId" not in outer,
-    "originatingSessionId" not in outer,
-  )
-  print("yes" if all(conds) else "no:"+repr([(i,c) for i,c in enumerate(conds) if not c])+"|msg="+repr(msg))
+  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" "$ACCT_ID" 2>/dev/null)
 if [[ "$BODY_OK" == "yes" ]]; then
-  pass "case-5c initialMessage is JSON envelope with exactly 6 declared keys"
+  pass "case-5c envelope is { turns, conversationId, accountId, occurredAt }; turns is the 4-entry ordered list"
 else
   fail "case-5c envelope shape wrong ($BODY_OK): $RECORDER_BODY"
 fi
@@ -258,51 +280,95 @@ 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-5e no legacy stderr emissions"
+  pass "case-5g no legacy stderr emissions"
 fi
 
-# --- Case 6 (Task 175): conversation-empty skip when there's no user/
-#     assistant text AND no tool_use. The hook emits the trigger line
-#     first (conversationBytes=0) and then the skip reason.
-EMPTY_TRANSCRIPT=$(mktemp); TMPFILES+=("$EMPTY_TRANSCRIPT")
-printf '{"type":"system","summary":"noop"}\n' > "$EMPTY_TRANSCRIPT"
-EMPTY_ENVELOPE=$(python3 -c '
+# --- 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" "$EMPTY_TRANSCRIPT")
+' "$OP_ID" "$MULTI_TRANSCRIPT")
 : > "$REQ_LOG"
-run_hook "admin" "" "$EMPTY_ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-6 rc=$HOOK_RC"
-if ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=conversation-empty$"; then
-  pass "case-6 zero user/assistant/tool records → trigger-skipped reason=conversation-empty emitted"
+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 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-6 multi-block collapse wrong ($MULTI_OK): $MULTI_BODY"
 fi
 
-# --- Case 7 (Task 175): tool-call passthrough — tool_use + tool_result
-#     pair surfaces in `toolCalls[]` with `input` and `output` as native
-#     JSON values, never re-stringified.
+# --- 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","message":{"role":"user","content":"please write a node"}},
-  {"type":"assistant","message":{"role":"assistant","content":[
+  {"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","message":{"role":"user","content":[
+  {"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","message":{"role":"assistant","content":[
+  {"type":"assistant","timestamp":"2026-05-19T21:32:03.000Z","message":{"id":"msg_done","role":"assistant","content":[
     {"type":"text","text":"done"}
   ]}},
 ]
@@ -322,29 +388,117 @@ import sys, json
 try:
   outer = json.load(sys.stdin)
   msg = json.loads(outer.get("initialMessage"))
-  calls = msg.get("toolCalls") or []
-  if len(calls) != 1:
-    print("no:expected-1-call:"+repr(calls)); sys.exit(0)
-  c = calls[0]
-  conds = (
-    c.get("tool") == "mcp__memory__memory-write",
-    c.get("input") == {"nodeType":"LocalBusiness","name":"Smalleys","nested":{"k":1}},
-    c.get("output") == "ok: wrote LocalBusiness",
-    msg.get("operatorMessage") == "please write a node",
-    msg.get("assistantReply") == "done",
-  )
-  print("yes" if all(conds) else "no:"+repr([(i,c) for i,c in enumerate(conds) if not c])+"|call="+repr(c))
+  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 toolCalls passthrough: input/output are JSON values, not strings"
+  pass "case-7 tool_use + tool_result land as one toolCalls entry on owning assistant turn; no extra user turn"
 else
-  fail "case-7 toolCalls shape wrong ($TOOL_OK): $TOOL_BODY"
+  fail "case-7 tool pairing wrong ($TOOL_OK): $TOOL_BODY"
 fi
 
-# --- Case 8 (Task 175): escaping — quotes, backslashes, newlines, non-ASCII
-#     all round-trip cleanly through the JSON envelope.
+# 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'
+  printf '{"type":"assistant","timestamp":"2026-05-19T21:40:00.000Z","message":{"id":"msg_t","role":"assistant","content":[{"type":"thinking","thinking":"silent"}]}}\n'
+} > "$EMPTY_TRANSCRIPT"
+EMPTY_ENVELOPE=$(python3 -c '
+import json, sys
+print(json.dumps({"session_id": sys.argv[1], "transcript_path": sys.argv[2]}))
+' "$OP_ID" "$EMPTY_TRANSCRIPT")
+: > "$REQ_LOG"
+run_hook "admin" "" "$EMPTY_ENVELOPE"
+[[ "$HOOK_RC" -eq 0 ]] || fail "case-9 rc=$HOOK_RC"
+if ingest_lines | grep -qE "^trigger-skipped sessionId=${OP_ID} reason=conversation-empty$"; then
+  pass "case-9 thinking-only transcript → trigger-skipped reason=conversation-empty"
+else
+  fail "case-9 expected trigger-skipped conversation-empty, got: $(ingest_lines)"
+fi
+if grep -qE '^/api/admin/claude-sessions	' "$REQ_LOG"; then
+  fail "case-9 recorder-spawn must NOT be called when conversation-empty"
+else
+  pass "case-9 no recorder-spawn POST"
+fi
+
+# --- Case 10 (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
@@ -352,8 +506,8 @@ out = sys.argv[1]
 op_msg = 'hello "world"\\nline2\nlast — café 🦊'
 asst_msg = 'reply with backslash \\\\ and newline\nhere'
 recs = [
-  {"type":"user","message":{"role":"user","content":op_msg}},
-  {"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":asst_msg}]}},
+  {"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")
@@ -364,7 +518,7 @@ print(json.dumps({"session_id": sys.argv[1], "transcript_path": sys.argv[2]}))
 ' "$OP_ID" "$ESC_TRANSCRIPT")
 : > "$REQ_LOG"
 run_hook "admin" "" "$ESC_ENVELOPE"
-[[ "$HOOK_RC" -eq 0 ]] || fail "case-8 rc=$HOOK_RC stderr=$HOOK_STDERR"
+[[ "$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
@@ -373,18 +527,21 @@ EXPECTED_ASST = "reply with backslash \\\\ and newline\nhere"
 try:
   outer = json.load(sys.stdin)
   msg = json.loads(outer.get("initialMessage"))
-  conds = (
-    msg.get("operatorMessage") == EXPECTED_OP,
-    msg.get("assistantReply") == EXPECTED_ASST,
-  )
-  print("yes" if all(conds) else "no:"+repr([(i,c) for i,c in enumerate(conds) if not c])+"|op="+repr(msg.get("operatorMessage"))+"|asst="+repr(msg.get("assistantReply")))
+  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 [[ "$ESC_OK" == "yes" ]]; then
-  pass "case-8 escaping: quotes/backslashes/newlines/non-ASCII round-trip cleanly"
+  pass "case-10 escaping: quotes/backslashes/newlines/non-ASCII round-trip cleanly through turns[*].text"
 else
-  fail "case-8 escaping wrong ($ESC_OK): $ESC_BODY"
+  fail "case-10 escaping wrong ($ESC_OK): $ESC_BODY"
 fi
 
 # --- Summary ------------------------------------------------------------