@rubytech/create-maxy-code 0.1.81 → 0.1.82

package/package.json

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

package/payload/platform/plugins/admin/hooks/__tests__/pre-tool-use-memory-write-revoke.test.sh

@@ -0,0 +1,130 @@
+#!/usr/bin/env bash
+# Task 213 regression test for the memory-write / memory-update revoke
+# block in pre-tool-use.sh. The block sits at the top of the admin branch
+# and ensures any admin tool_use targeting the two writers exits 2 with
+# stderr explaining the recorder ownership, and emits one structured
+# `admin-tool-revoke` line through `/api/admin/log-ingest`.
+
+set -u
+
+HOOK="$(cd "$(dirname "$0")/.." && pwd)/pre-tool-use.sh"
+if [[ ! -x "$HOOK" ]]; then
+  echo "FAIL: $HOOK not executable" >&2
+  exit 1
+fi
+
+TMPFILES=()
+LISTENER_PIDS=()
+cleanup() {
+  for pid in "${LISTENER_PIDS[@]:-}"; do
+    [[ -n "$pid" ]] && kill "$pid" 2>/dev/null || true
+    [[ -n "$pid" ]] && wait "$pid" 2>/dev/null || true
+  done
+  for f in "${TMPFILES[@]:-}"; do
+    [[ -n "$f" ]] && rm -f "$f" 2>/dev/null || true
+  done
+}
+trap cleanup 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
+port = int(sys.argv[1]); log = 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,'a',encoding='utf-8') as f:
+      f.write(self.path + '\t' + body + '\n')
+    self.send_response(200); self.end_headers(); self.wfile.write(b'{}')
+http.server.HTTPServer(('127.0.0.1', port), H).serve_forever()
+PY
+  LISTENER_PIDS+=("$!")
+  for _ in $(seq 1 20); do
+    curl -sS --max-time 1 -X POST "http://127.0.0.1:${LISTENER_PORT}/ping" -d '{}' >/dev/null 2>&1 && break
+    sleep 0.1
+  done
+  : > "$REQ_LOG"
+}
+
+run_with_tool() {
+  local tool="$1"
+  local sid="$2"
+  local stdout_file; stdout_file=$(mktemp); TMPFILES+=("$stdout_file")
+  local stderr_file; stderr_file=$(mktemp); TMPFILES+=("$stderr_file")
+  python3 -c '
+import json, sys
+print(json.dumps({
+  "hook_event_name": "PreToolUse",
+  "session_id": sys.argv[1],
+  "tool_name": sys.argv[2],
+  "tool_input": {"name":"Smalleys","accountId":"acct-x","scope":"shared"},
+}, separators=(",", ":")))
+' "$sid" "$tool" | \
+    MAXY_UI_INTERNAL_PORT="$LISTENER_PORT" \
+    bash "$HOOK" admin >"$stdout_file" 2>"$stderr_file"
+  HOOK_RC=$?
+  HOOK_STDERR=$(cat "$stderr_file")
+  sleep 0.1  # let listener flush
+}
+
+start_listener
+
+# --- memory-write rejected ---------------------------------------------
+: > "$REQ_LOG"
+run_with_tool "mcp__plugin_memory_memory__memory-write" "sess-abc"
+[[ "$HOOK_RC" -eq 2 ]] || fail "memory-write expected exit 2, got $HOOK_RC"
+echo "$HOOK_STDERR" | grep -qF "admin agent does not write to the graph" \
+  || fail "memory-write stderr missing rationale, got: $HOOK_STDERR"
+if grep -qE '/api/admin/log-ingest	.*"tag":\s*"admin-tool-revoke".*sessionId=sess-abc.*tool=mcp__plugin_memory_memory__memory-write.*source=permission-hook' "$REQ_LOG"; then
+  pass "memory-write rejection emits admin-tool-revoke with sessionId, tool, source"
+else
+  fail "memory-write rejection did not emit admin-tool-revoke; log: $(cat "$REQ_LOG")"
+fi
+
+# --- memory-update rejected --------------------------------------------
+: > "$REQ_LOG"
+run_with_tool "mcp__plugin_memory_memory__memory-update" "sess-xyz"
+[[ "$HOOK_RC" -eq 2 ]] || fail "memory-update expected exit 2, got $HOOK_RC"
+if grep -qE '/api/admin/log-ingest	.*"tag":\s*"admin-tool-revoke".*sessionId=sess-xyz.*tool=mcp__plugin_memory_memory__memory-update.*source=permission-hook' "$REQ_LOG"; then
+  pass "memory-update rejection emits admin-tool-revoke with sessionId, tool, source"
+else
+  fail "memory-update rejection did not emit admin-tool-revoke; log: $(cat "$REQ_LOG")"
+fi
+
+# --- memory-search (allowed read tool) NOT rejected --------------------
+: > "$REQ_LOG"
+run_with_tool "mcp__plugin_memory_memory__memory-search" "sess-read"
+[[ "$HOOK_RC" -eq 0 ]] || fail "memory-search expected exit 0, got $HOOK_RC stderr: $HOOK_STDERR"
+if grep -qE '"tag":\s*"admin-tool-revoke"' "$REQ_LOG"; then
+  fail "memory-search must NOT emit admin-tool-revoke; log: $(cat "$REQ_LOG")"
+else
+  pass "memory-search passes through; no admin-tool-revoke emitted"
+fi
+
+# --- the old mcp__memory__ namespace is NOT matched -------------------
+# The revoke block targets the current runtime namespace literally; the
+# old namespace was never the surface admin saw, so matching it would
+# be a regression.
+: > "$REQ_LOG"
+run_with_tool "mcp__memory__memory-write" "sess-old-ns"
+[[ "$HOOK_RC" -eq 0 ]] || fail "pre-209 namespace expected exit 0, got $HOOK_RC"
+if grep -qE '"tag":\s*"admin-tool-revoke"' "$REQ_LOG"; then
+  fail "pre-209 namespace must NOT emit admin-tool-revoke"
+else
+  pass "pre-209 mcp__memory__memory-write passes through (block is namespace-literal)"
+fi
+
+# --- Summary ------------------------------------------------------------
+echo "---"
+echo "PASSED: $PASS  FAILED: $FAIL"
+[[ "$FAIL" -eq 0 ]] || exit 1
+exit 0

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

@@ -14,10 +14,11 @@
 #     is the FILLED database-operator paragraph — the four-sentence
 #     template with `{schema}` replaced by `schema-base.md` (plus the
 #     brand-declared vertical when set) and `{conversation}` replaced by
-#     a flat `role: text` rendering of the envelope's `turns` array with
-#     inline `[tool: name(args)]` markers on assistant turns that called
-#     tools. The initialMessage is a plain string, not a JSON-stringified
-#     envelope; no instruction prose, no leading JSON.
+#     a flat `role: text` rendering of the envelope's `turns` array.
+#     Task 213 strips the prior `[tool: name(args)]` markers — they
+#     taught the recorder to copy the shape into prose. The initialMessage
+#     is a plain string, not a JSON-stringified envelope; no instruction
+#     prose, no leading JSON.
 #   - The hook emits exactly one `[turn-recorder] envelope ...` line and
 #     one `[turn-recorder] substitution ...` line before `spawn-request`.
 #     The substitution line carries `schemaBytes`, `conversationBytes`,
@@ -406,10 +407,12 @@ 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.
+# --- Case 7 (Task 177 + Task 213): tool-call pairing kept in envelope, -
+# stripped from the transcript. Assistant tool_use + user tool_result still
+# fold into one `toolCalls` entry on the assistant turn (envelope-level
+# observability via `[turn-recorder] envelope … toolCallTurns=N`). The
+# rendered transcript carries NO `[tool: …]` markers — pre-213 they taught
+# the recorder to emit `<tool_call>` as text.
 TOOL_TRANSCRIPT=$(mktemp); TMPFILES+=("$TOOL_TRANSCRIPT")
 python3 - "$TOOL_TRANSCRIPT" <<'PY'
 import json, sys
@@ -454,14 +457,13 @@ try:
   # text body), one carrying "done".
   conds.append(("two-asst-lines", msg.count("\nassistant: ") == 2))
   conds.append(("has-asst-done", "\nassistant: done" in msg))
-  # Tool-call marker on the owning assistant turn — name and full JSON
-  # input round-trip inline.
-  conds.append(("has-tool-marker", "[tool: mcp__memory__memory-write(" in msg))
-  conds.append(("tool-marker-name", "\"name\": \"Smalleys\"" in msg or "\"name\":\"Smalleys\"" in msg))
-  conds.append(("tool-marker-nested", "\"nested\"" in msg))
-  conds.append(("tool-marker-nodeType", "\"nodeType\": \"LocalBusiness\"" in msg or "\"nodeType\":\"LocalBusiness\"" in msg))
-  # The tool_result content does NOT bleed in (the rendering chose
-  # input-only markers; output goes nowhere in the filled prompt).
+  # Task 213 — no `[tool: …]` markup in the rendered transcript.
+  conds.append(("no-tool-marker", "[tool:" not in msg))
+  conds.append(("no-tool-input-leak", "Smalleys" not in msg))
+  # The owning assistant turn lands as an empty-bodied line: the tool_use
+  # block contributed no text, and the marker that used to fill it is gone.
+  conds.append(("has-empty-asst-line", "\nassistant: \n" in msg))
+  # The tool_result content does not bleed in either.
   conds.append(("no-output-leakage", "ok: wrote LocalBusiness" not in msg))
   failed = [name for name, ok in conds if not ok]
   print("yes" if not failed else "no:"+repr(failed))
@@ -469,7 +471,7 @@ except Exception as e:
   print("parse-fail:"+str(e))
 ' 2>/dev/null)
 if [[ "$TOOL_OK" == "yes" ]]; then
-  pass "case-7 assistant tool_use renders as [tool: name(args)] marker on the owning turn; tool_result does not create a separate user line"
+  pass "case-7 assistant tool_use leaves no [tool: …] markup in transcript; tool_result does not create a separate user line; toolCallTurns count survives via envelope log"
 else
   fail "case-7 tool pairing wrong ($TOOL_OK): $TOOL_BODY"
 fi

package/payload/platform/plugins/admin/hooks/pre-tool-use.sh

@@ -21,6 +21,40 @@ TOOL_NAME=$(echo "$INPUT" | grep -o '"tool_name":"[^"]*"' | head -1 | cut -d'"'
 # ---------------------------------------------------------------------------
 if [ "$AGENT_TYPE" = "admin" ]; then
 
+  # ── Task 213: memory-write/memory-update revocation ──────────────────────
+  # The admin agent does not write to the graph; the Stop-hook recorder
+  # (database-operator specialist) owns these tools. Session d2aaa85e
+  # 2026-05-21 showed admin emitting `tool_use: memory-update`, filling in
+  # when the recorder produced no tool_use. `pty-spawner.ts` already passes
+  # `--disallowed-tools` on the spawn argv; this hook is the observability
+  # surface — every relapse lands in server.log as `[admin-tool-revoke]`,
+  # which the `--disallowed-tools` path itself does not produce.
+  case "$TOOL_NAME" in
+    mcp__plugin_memory_memory__memory-write|mcp__plugin_memory_memory__memory-update)
+      SESSION_ID=$(printf '%s' "$INPUT" | python3 -c '
+import sys, json
+try:
+  d = json.load(sys.stdin)
+  print(d.get("session_id", "") or "unknown")
+except Exception:
+  print("unknown")
+' 2>/dev/null || echo "unknown")
+      UI_PORT="${MAXY_UI_INTERNAL_PORT:-}"
+      if [ -n "$UI_PORT" ]; then
+        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":"admin-tool-revoke","level":"info","line":f"role=admin sessionId={sys.argv[1]} tool={sys.argv[2]} result=rejected source=permission-hook"}))
+' "$SESSION_ID" "$TOOL_NAME")" \
+          "http://127.0.0.1:${UI_PORT}/api/admin/log-ingest" 2>/dev/null || true
+      fi
+      echo "Blocked: admin agent does not write to the graph. The Stop-hook database-operator recorder owns memory-write and memory-update." >&2
+      exit 2
+      ;;
+  esac
+
   # ── Code directory protection ────────────────────────────────────────────
   case "$TOOL_NAME" in
     Write|Edit)

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

@@ -336,9 +336,13 @@ fi
 #     `{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`, with inline `[tool: name(args)]`
-#     markers where the assistant called tools (so the model sees the
-#     tool-shape it has been calling without having to read JSON);
+#     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`.
@@ -372,19 +376,7 @@ lines = []
 for t in turns:
     role = t.get("role", "?")
     text_t = t.get("text", "") or ""
-    marks = []
-    for tc in (t.get("toolCalls") or []):
-        tool = tc.get("tool", "?")
-        inp = tc.get("input")
-        try:
-            inp_s = json.dumps(inp, ensure_ascii=False) if inp is not None else ""
-        except Exception:
-            inp_s = str(inp)
-        marks.append(f"[tool: {tool}({inp_s})]")
-    if marks:
-        lines.append(f"{role}: {text_t} {' '.join(marks)}".rstrip())
-    else:
-        lines.append(f"{role}: {text_t}")
+    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

package/payload/platform/plugins/admin/skills/access-manager/SKILL.md

@@ -17,9 +17,9 @@ Applies when the business owner wants to control who can access a gated or paid
 
 ## Constraints
 
-- **Admin-scope only.** All AccessGrant nodes must be written with `scope: "admin"`. Credential data must never be visible to public agents.
+- **Admin-scope only.** Every AccessGrant node lands with `scope: "admin"`. Credential data must never be visible to public agents — the recorder enforces the scope tag on its write turn.
 - **Agent must exist.** Before any grant operation, verify the target agent directory exists under `agents/` and read its `config.json`.
-- **Confirm before mutating.** Present a `confirm` component before creating grants, revoking access, or changing access modes.
+- **Confirm before mutating.** Present a `confirm` component before grants are created, access is revoked, or access modes change. The recorder writes off the confirmed transcript.
 - **Domain required for email invitations.** Resolve the public hostname via `tunnel-status`. Without a confirmed hostname, magic link URLs cannot be constructed.
 - **Deterministic grant queries.** AccessGrant nodes are not vector-indexed. Query them via `cypher-shell` (password at `~/.maxy/.neo4j-password`), not via `memory-search`.
 

package/payload/platform/plugins/admin/skills/access-manager/references/operations.md

@@ -25,7 +25,7 @@ Use these exact property names when creating or updating grants:
 | `contactValue` | string | Yes | No | Email address (lowercase) or phone number (E.164) |
 | `status` | string | Yes | Yes | `"invited"` / `"active"` / `"expired"` / `"revoked"` |
 | `expiresAt` | datetime | Yes | Yes | ISO 8601 datetime. `null` means no expiry |
-| `createdAt` | datetime | Auto | No | Auto-set by `memory-write` |
+| `createdAt` | datetime | Auto | No | Stamped at write time by the recorder |
 | `magicToken` | string | Email only | Yes | Cryptographically random UUID. Nulled after first use |
 | `magicTokenExpiresAt` | datetime | Email only | Yes | 15 minutes from generation |
 | `otpCode` | string | Phone only | Yes | Random 6-digit numeric code |
@@ -34,11 +34,9 @@ Use these exact property names when creating or updating grants:
 | `otpAttempts` | integer | Phone only | Yes | Failed OTP entries. Max 3 before regeneration required |
 | `scope` | `"admin"` | Yes | No | **Mandatory.** Omitting scope exposes grants to public agents |
 
-### Tool Parameters
+### Recorder write shape
 
-`memory-write` requires `labels`, `properties`, `accountId`, `scope`, and optionally `relationships`. The `accountId` and `scope` are top-level parameters — not inside `properties`.
-
-`memory-update` requires `nodeId` (element ID from a prior query), `properties` (fields to update), and `accountId`. Always include all three.
+Each AccessGrant write the recorder produces names a label (`AccessGrant`), the property bag from the table above, the operator's `accountId`, `scope: "admin"`, and the inbound `HAS_ACCESS` relationship from the Person. Admin's job is to confirm those five things in conversation; the recorder reads them off the transcript and writes the node. Updates name the existing `AccessGrant` by element ID (from the most recent `cypher-shell` lookup) and the new properties.
 
 ### Querying Grants
 
@@ -71,24 +69,11 @@ RETURN elementId(p) AS personId, p.givenName AS name
 
 ### Person node
 
-Search for an existing Person by email using a `cypher-shell` query. If found, reuse its element ID. If not found, create one via `memory-write`:
-
-- Labels: `["Person"]`
-- Properties: `givenName` (if the admin provided a name), `email` (lowercase)
-- `accountId`: from `account.json`
-- `scope`: `"admin"`
+Search for an existing Person by email using a `cypher-shell` query. If found, reuse its element ID. If not found, name the new Person in the confirmation — labels `["Person"]`, `givenName` (when the admin provided a name), `email` (lowercase), `accountId` from `account.json`, `scope: "admin"`. The recorder writes it on its next turn.
 
 ### AccessGrant node
 
-Create via `memory-write`:
-
-- Labels: `["AccessGrant"]`
-- Properties: all fields from the data model table. Set `status` to `"invited"`, generate the `magicToken` (random UUID), calculate `magicTokenExpiresAt` (15 minutes from now), and calculate `expiresAt` from the admin's requested duration (or `null` for no expiry).
-- `accountId`: from `account.json`
-- `scope`: `"admin"`
-- Relationships: `[{ type: "HAS_ACCESS", direction: "incoming", targetNodeId: "<person-element-id>" }]`
-
-The `incoming` direction creates `(Person)-[:HAS_ACCESS]->(AccessGrant)`.
+Confirm the grant with the operator carrying all fields from the data model table — `status: "invited"`, the freshly-generated `magicToken` (random UUID), the `magicTokenExpiresAt` (15 minutes from now), and the `expiresAt` from the admin's requested duration (or `null` for no expiry) — together with `accountId` from `account.json`, `scope: "admin"`, and the inbound `HAS_ACCESS` edge from the Person. The `incoming` direction yields `(Person)-[:HAS_ACCESS]->(AccessGrant)` once the recorder writes it.
 
 ### Magic link
 
@@ -160,15 +145,15 @@ If no grants exist for the agent, say so in text rather than emitting an empty l
 
 **Outcome:** Grant status is `"revoked"`. The visitor is blocked on their next login attempt.
 
-Find the grant via `cypher-shell` to get its element ID. Update via `memory-update` with `properties: { status: "revoked" }`.
+Find the grant via `cypher-shell` to get its element ID. Confirm the revocation with the operator naming the element ID and the new `status: "revoked"`; the recorder writes the status change in its next turn.
 
-Present a `confirm` component before revoking. Explain that active sessions continue until they naturally expire (max 24 hours) — revocation takes effect on the visitor's next login.
+Present a `confirm` component before the revocation lands. Explain that active sessions continue until they naturally expire (max 24 hours) — revocation takes effect on the visitor's next login.
 
 ## Extend Access
 
 **Outcome:** Grant's `expiresAt` is pushed forward by the requested duration.
 
-Find the grant via `cypher-shell`. Calculate the new `expiresAt` by adding the requested duration to the current `expiresAt` (or to now, if the grant has already expired). Update via `memory-update` with the new `expiresAt` value.
+Find the grant via `cypher-shell`. Calculate the new `expiresAt` by adding the requested duration to the current `expiresAt` (or to now, if the grant has already expired). Confirm the new `expiresAt` and the grant's element ID with the operator; the recorder folds the new property in.
 
 Present a `confirm` component showing the current expiry date and the new expiry date after extension.
 
@@ -192,6 +177,6 @@ Present a `confirm` component before changing, explaining the current mode, the
 
 Find the existing grant via `cypher-shell`. The grant must be in `invited` or `active` status.
 
-**For email grants:** Generate a new UUID for `magicToken`, set `magicTokenExpiresAt` to 15 minutes from now. Update via `memory-update`. Send the invitation email using the same format as the original invite.
+**For email grants:** Generate a new UUID for `magicToken`, set `magicTokenExpiresAt` to 15 minutes from now. Confirm both with the operator and the grant's element ID — the recorder folds them in. Send the invitation email using the same format as the original invite.
 
-**For phone grants:** Generate a new 6-digit `otpCode`, reset `otpAttempts` to `0`, set `otpExpiresAt` to 10 minutes from now. Update via `memory-update`. Then deliver the new OTP via the SMS delivery command described in the "Invite by Phone" section.
+**For phone grants:** Generate a new 6-digit `otpCode`, reset `otpAttempts` to `0`, set `otpExpiresAt` to 10 minutes from now. Confirm all three with the operator and the grant's element ID — the recorder folds them in. Then deliver the new OTP via the SMS delivery command described in the "Invite by Phone" section.

package/payload/platform/plugins/admin/skills/business-profile/SKILL.md

@@ -10,28 +10,28 @@ Applies when the business owner wants to set up, complete, or update their busin
 ## When to Activate
 
 - Admin asks to set up, edit, or complete their business profile
-- Onboarding step 9 delegates here on first run **only when the operator picked `business-owner` mode**. Personal mode bootstraps a `Person` with `role: "admin-personal"` directly inside step 9 and does NOT invoke this skill.
+- Onboarding step 9 delegates here on first run **only when the operator picked `business-owner` mode**. Personal mode bootstraps a personal-profile `Person` directly inside step 9 and does NOT invoke this skill.
 - Session-start graph check shows a `LocalBusiness` node with missing data (no hours, no services, empty description)
-- A `memory-write` or `memory-update` returns `no-admin-user` or `no-local-business` — the error message directs the agent here. (For personal-mode accounts, this rejection should not fire because the personal-profile `Person` already satisfies the precondition — if it does fire, the personal-profile node is missing or its `role` is wrong.)
+- A recorder cycle reports `no-admin-user` or `no-local-business` — the graph lacks the prerequisite node. (For personal-mode accounts, this signal should not fire because the personal-profile `Person` already satisfies the precondition — if it does fire, the personal-profile node is missing or its `role` is wrong.)
 - Admin asks questions like "update my address", "add our opening hours", "change the phone number"
 
 ## First-run path (no LocalBusiness yet)
 
-The `AdminUser` and the operator's personal-profile `Person` are written deterministically at PIN setup time, so this skill no longer creates the AdminUser. When onboarding step 9 invokes this skill in `business-owner` mode, or when a write returns `no-local-business`, create the LocalBusiness:
+The `AdminUser` and the operator's personal-profile `Person` are written deterministically at PIN setup time, so this skill no longer creates the AdminUser. When onboarding step 9 invokes this skill in `business-owner` mode, or when the operator's graph has no `LocalBusiness`:
 
-1. **LocalBusiness.** Ask the user for the business name first — this is the only mandatory property. Call `memory-write` with `labels: ["LocalBusiness"]`, minimal `properties: { name }`, `scope: "shared"`, `relationships: [{ type: "OWNS", direction: "incoming", targetNodeId: "<AdminUser-elementId>" }]`. Find the AdminUser elementId via `memory-search` for the operator's name; the AdminUser already exists from PIN setup.
-2. **Capture the remaining domains** (address, hours, services, FAQs, brand assets) via `memory-update` on the `LocalBusiness` node and `memory-write` for related nodes (`OpeningHoursSpecification`, `Service`, `FAQPage`, `ImageObject`).
+1. **LocalBusiness.** Ask the operator for the business name first — this is the only mandatory property. Confirm the name and the OWNS link to the AdminUser. The recorder writes the `LocalBusiness` node with `scope: "shared"` and the OWNS edge in its next turn.
+2. **Capture the remaining domains** (address, hours, services, FAQs, brand assets) in conversation. After the operator confirms each batch, the recorder folds those properties onto the `LocalBusiness` and adds the related nodes (`OpeningHoursSpecification`, `Service`, `FAQPage`, `ImageObject`).
 
-Adapt the order if the user provides data in a different sequence — the invariant is: `LocalBusiness` must exist before any subsequent write. Confirm each batch with the user before writing.
+Adapt the order if the operator provides data in a different sequence — the invariant is: the `LocalBusiness` is named and confirmed before any related-node batch is discussed. Confirm each batch with the operator before moving on; the recorder reads the confirmation off the transcript.
 
 ## Constraints
 
-- **Schema-first.** Before any write, load `memory/references/schema-base.md` via `plugin-read`. If `businessType` is known on the `LocalBusiness` node, also load the matching vertical schema. Confirm which schemas were loaded.
-- **Read-first.** Search for the existing `LocalBusiness` node and its related entities before asking the user anything. Do not re-ask for data that is already in the graph — reference it and confirm it is still correct. On first run (no `LocalBusiness` yet), skip the search and proceed with the first-run path above.
-- **Confirm before writing.** Present each batch of data back to the user and get explicit confirmation before calling `memory-write` or `memory-update`.
+- **Schema-first.** Before discussing a batch, load `memory/references/schema-base.md` via `plugin-read`. If `businessType` is known on the `LocalBusiness` node, also load the matching vertical schema. Confirm which schemas were loaded so the recorder uses the right property names.
+- **Read-first.** Search for the existing `LocalBusiness` node and its related entities before asking the operator anything. Do not re-ask for data that is already in the graph — reference it and confirm it is still correct. On first run (no `LocalBusiness` yet), skip the search and proceed with the first-run path above.
+- **Confirm before recording.** Present each batch of data back to the operator and get explicit confirmation. The recorder writes off the confirmed transcript; unconfirmed prose is not a record.
 - **Exact property names.** Use Schema.org camelCase property names exactly as defined in the loaded schema reference. No synonyms, no abbreviations.
-- **No placeholders.** Never write empty strings, "TBD", or "unknown" as property values — they degrade search quality via poor embeddings. If a value is unknown, skip it.
-- **Conversational, not a form.** Adapt to what the user provides. Accept partial input and infer where reasonable (e.g. "9-5 weekdays" means Mon-Fri 09:00-17:00). Allow skipping sections and returning later.
+- **No placeholders.** Never propose empty strings, "TBD", or "unknown" as property values — they degrade search quality via poor embeddings. If a value is unknown, skip it.
+- **Conversational, not a form.** Adapt to what the operator provides. Accept partial input and infer where reasonable (e.g. "9-5 weekdays" means Mon-Fri 09:00-17:00). Allow skipping sections and returning later.
 
 ## Data Domains
 
@@ -46,8 +46,8 @@ Six categories of operational data, each mapping to graph nodes defined in `sche
 | FAQs (question + answer pairs) | `FAQPage` → `Question` | `HAS_FAQ`, then `CONTAINS` |
 | Services (name, description, offers/pricing) | `Service` | `OFFERS` (from LocalBusiness) |
 
-## Writing Nodes
+## Recording Nodes
 
-When creating new related nodes (hours, FAQs, assets, services), capture the `LocalBusiness` element ID from the initial search result and use it as `targetNodeId` in the `memory-write` relationships array. For FAQ questions, first create the `FAQPage` node, then create `Question` nodes related to the `FAQPage` via `CONTAINS`.
+When the operator confirms a new related node (hours, FAQs, assets, services), make sure the conversation names the `LocalBusiness` it attaches to and the edge type — the recorder reads this off the transcript and writes the node with the right adjacency. For FAQ questions, that means the operator confirms the `FAQPage` first, then the individual `Question`s that hang off it via `CONTAINS`.
 
-When updating existing data (changing a phone number, correcting an address), use `memory-update` with the node's element ID from the search result.
+When the operator changes existing data (a phone number, an address), reference the existing node by name in conversation; the recorder finds it via search and folds the new properties in.

package/payload/platform/plugins/admin/skills/public-agent-manager/SKILL.md

@@ -67,7 +67,7 @@ During creation (Step 7) and editing, offer image upload when the user has an im
 
 Nodes in the graph can be directly tagged for a specific agent by adding the agent's slug to the node's `agents` array property. This is the explicit tagging mode — the admin decides exactly which nodes an agent can see. Direct tagging and keyword subscriptions (`knowledgeKeywords`) are independent routing mechanisms — each is configured and approved separately, and neither implies the other.
 
-To tag nodes: use `memory-update` to add the agent's slug to a node's `agents` array (read current array first via `memory-search` to avoid overwriting existing slugs). To untag: read the current `agents` array, remove the slug, and update. To see what's tagged for an agent: search with `memory-search` (no `agentSlug` param) and identify results whose `agents` property contains the target slug.
+To tag nodes: read the node's current `agents` array via `memory-search` (no `agentSlug` param), confirm with the operator which nodes get the new slug, and the recorder folds the slug onto each `agents` array in its next turn. To untag: same shape — read the current array, confirm removal, and the recorder rewrites the array without the slug. To see what's tagged for an agent: search with `memory-search` (no `agentSlug` param) and identify results whose `agents` property contains the target slug.
 
 ### Model Options
 
@@ -189,8 +189,8 @@ After creation, no template metadata persists in the agent's files. The resultin
 
    Ask the user whether any specific knowledge nodes should be tagged with this agent's slug. Explain that direct tagging makes specific nodes always visible to this agent regardless of keyword matches, and is useful for content that doesn't match any keyword but should still be available. If keyword subscriptions already cover the desired content, tagging is unnecessary.
 
-   - If the user approves: present the knowledge discovery results from Step 4 for selection, then tag selected nodes (add slug to `agents` array via `memory-update`). Read each node's current `agents` array first to avoid overwriting existing slugs.
-   - If the user declines: skip tagging entirely. Do not tag nodes without explicit approval.
+   - If the user approves: present the knowledge discovery results from Step 4 for selection, read each node's current `agents` array first, and confirm the new slug-tag set with the user. The recorder folds the slug onto each node's `agents` array in its next turn.
+   - If the user declines: skip tagging entirely. Do not propose tagging without explicit approval.
 9. **KNOWLEDGE.md generation** — populate from the now-tagged set plus keyword matches using the `update-knowledge` skill workflow
 10. Write `config.json` with selected model, plugins, status "active", `liveMemory`, and `knowledgeKeywords`. This is the last gated write — placed after IDENTITY.md, SOUL.md, and KNOWLEDGE.md to prevent cascade failure if one gate stalls.
 11. Check context budget — auto-summarise if over threshold
@@ -226,7 +226,7 @@ For agent image changes:
 
 For knowledge scope changes:
 - Show currently tagged nodes (search `memory-search` without `agentSlug`, identify results whose `agents` property contains the agent's slug) and active keyword subscriptions (from `config.json`).
-- Allow adding/removing direct tags (add/remove the slug from nodes' `agents` arrays via `memory-write`).
+- Allow adding/removing direct tags. Read each node's current `agents` array first, confirm the change with the operator, and the recorder updates the arrays in its next turn.
 - Allow adding/removing keyword subscriptions (update `knowledgeKeywords` in `config.json`).
 - Allow toggling `liveMemory` on/off (update `config.json`).
 - After changes, offer to refresh KNOWLEDGE.md using the `update-knowledge` skill.
@@ -248,7 +248,7 @@ Deletion removes the entire agent directory (`agents/{slug}/`) — not individua
 - Verify the directory no longer exists
 - Report what was removed (list the files that were in the directory)
 
-**Graph tag cleanup (optional):** Knowledge nodes in the graph may have the deleted agent's slug in their `agents` array. These tags become orphaned after deletion — no agent will query them, so they are inert. Offer the user the choice: clean up the orphaned tags (remove the slug from each node's `agents` array via `memory-update`, reading the current array first to preserve other agents' tags) or leave them. If the user declines, note that the tags are harmless and can be cleaned up later.
+**Graph tag cleanup (optional):** Knowledge nodes in the graph may have the deleted agent's slug in their `agents` array. These tags become orphaned after deletion — no agent will query them, so they are inert. Offer the operator the choice: clean up the orphaned tags (read each affected node's current `agents` array first, confirm the slug removal, and the recorder rewrites the arrays in its next turn) or leave them. If the operator declines, note that the tags are harmless and can be cleaned up later.
 
 ### Set as Default
 

package/payload/platform/plugins/docs/references/admin-session.md

@@ -108,7 +108,7 @@ You are not user-facing and your text goes nowhere — do not emit it.
 At fire time the Stop hook substitutes both placeholders and sends the filled paragraph as `initialMessage` — a plain string, not a JSON envelope, no instruction prose, no leading object.
 
 - `{schema}` ← the concatenated text of `platform/plugins/memory/references/schema-base.md` plus, when `brand.json#vertical` names a vertical file that exists in the same directory, that file's content joined with a blank-line separator (Task 193). When the brand declares `vertical: null`, the field is missing, or the named file is absent, the schema is `schema-base.md` alone — never loud-fail here; Task 193 owns the brand-config gate.
-- `{conversation}` ← a flat rendering of the envelope's `turns` array. Format: one line per turn, `role: text`, wrapped in leading and trailing newlines so each line lands on its own line in the filled prompt. Assistant turns that called tools carry inline `[tool: name(args)]` markers at the end of their line, with `args` being the call's input as a JSON literal. Tool outputs are not included — only the call shape the model has been emitting. The user record carrying only `tool_result` blocks does not create a separate transcript line; thinking-only records contribute nothing.
+- `{conversation}` ← a flat rendering of the envelope's `turns` array. Format: one line per turn, `role: text`, wrapped in leading and trailing newlines so each line lands on its own line in the filled prompt. Task 213 strips the prior inline `[tool: name(args)]` markers on assistant turns — they taught the recorder to copy the shape and emit `<tool_call>` as text instead of real `tool_use` blocks (evidence in sessions d2aaa85e / 481799d1). Assistant turns that only called tools land as an empty-bodied `assistant: ` line; the `toolCallTurns` counter on `[turn-recorder] envelope …` remains the independent observability surface. The user record carrying only `tool_result` blocks does not create a separate transcript line; thinking-only records contribute nothing.
 
 The envelope walker still runs (so `[turn-recorder] envelope ...` continues to land for observability and the `trigger-skipped reason=conversation-empty` gate still fires on a turns-empty transcript), but its JSON shape never reaches the model.
 
@@ -200,7 +200,7 @@ Three log-line shapes, all keyed on the same recorder `sessionId`, distinguish t
 ```
 [pty-spawn-tool-inventory] sessionId=<id> specialist=<name> argv-tools=<n> mcp-listed-tools=<n> exposed=<csv> not-exposed=<csv>
 [recorder-session-init]    sessionId=<id> specialist=<name> toolsExposedCount=<n> toolsExposed=<csv> toolsArgvCount=<n> toolsArgvMissingFromExposed=<csv|—> source=<probe>
-[recorder-turn]            sessionId=<id> turnIndex=<n> stopReason=<r> textBytes=<n> textHead=<json-escaped first 240 chars> toolUseNames=<csv|—>
+[recorder-turn]            sessionId=<id> turnIndex=<n> stopReason=<r> textBytes=<n> text=<full json-escaped> toolUseNames=<csv|—> containsToolCallText=true|false
 ```
 
 - `[pty-spawn-tool-inventory]` (Task 178) measures the **framework** layer — the argv built and the MCP servers' published tools. Argv-tools count must be 11; mcp-listed-tools must be ≥ 11.
@@ -209,7 +209,7 @@ Three log-line shapes, all keyed on the same recorder `sessionId`, distinguish t
   - `source=headless-argv-fallback` ⇒ Task 185 finding (2026-05-20): headless `claude --verbose` PTY mode (which the database-operator recorder uses) does **not** write any tool-list record to the JSONL — none of the three probe shapes ever appears. The tail falls back to the spawner's `--allowed-tools` argv as the exposed set, independently verified by `[pty-spawn-tool-inventory]`'s `exposed=` field. Treat this source identically to a positive JSONL match: the argv set is authoritative for headless spawns.
   - `toolsArgvMissingFromExposed=—` ⇒ all argv tools made it through; Outcome A is ruled out.
   - Any non-`—` value enumerates the names the SDK dropped and is the diagnosis. Only meaningful when `source` is JSONL-derived; under `headless-argv-fallback` the exposed set equals argv by construction, so this field is always `—`.
-- `[recorder-turn]` measures the **model** layer — Haiku's verbatim words (`textHead`) and the tool names it actually called (`toolUseNames`). `toolUseNames=—` paired with `toolsArgvMissingFromExposed=—` is the Outcome B signature: tools present, model abstained.
+- `[recorder-turn]` measures the **model** layer — Haiku's verbatim words (Task 213: full `text=`, not the prior 240-char `textHead`) and the tool names it actually called (`toolUseNames`). `toolUseNames=—` paired with `toolsArgvMissingFromExposed=—` is the Outcome B signature: tools present, model abstained. `containsToolCallText=true` flags any assistant text that contains `<tool_call>`, `<function_calls>`, or `</invoke>` — the recorder model copying the tool-call shape into prose (the regression Task 213 closed).
 
 The three lines are emitted into `server.log` via the platform UI's `/api/admin/log-ingest` loopback route, so a single grep against `server.log` answers the question for any past, present, or future recorder spawn:
 
@@ -222,7 +222,7 @@ grep -E "\[(pty-spawn-tool-inventory|recorder-session-init|recorder-turn|mcp:(me
 
 1. The single `[pty-spawn-tool-inventory]` line proves what the framework provisioned. If `argv-tools < 11`, the bug is upstream of this evidence chain — the agent file or the spawn site.
 2. The single `[recorder-session-init]` line proves what the model received. If `toolsArgvMissingFromExposed` is non-`—`, the named tools were dropped by the CLI/SDK; that is Outcome A and the fix lives in the `--mcp-config` resolution or the CLI/SDK handshake.
-3. Each `[recorder-turn]` line records one assistant turn. If `toolUseNames=—` across every turn AND `toolsArgvMissingFromExposed=—`, the model could call the tools and chose not to; `textHead` carries the model's verbatim reasoning and is the next surface to read.
+3. Each `[recorder-turn]` line records one assistant turn. If `toolUseNames=—` across every turn AND `toolsArgvMissingFromExposed=—`, the model could call the tools and chose not to; `text=` carries the model's verbatim reasoning (Task 213 dropped the 240-char head cap so the whole turn is observable from server.log) and is the next surface to read. A `containsToolCallText=true` row is the recorder-relapse signature: the model emitted tool-call shape as prose instead of a real `tool_use` block.
 
 **Loopback gate.** The `/api/admin/log-ingest` route is loopback-only on both the socket address and (when present) the `X-Forwarded-For` header. A LAN client whose request reaches the route via a proxy still gets a 403 because XFF tokens are required to be loopback when XFF is set. Without this gate the evidence chain would be worthless — any LAN client could forge `[recorder-session-init]` lines under a spoofed sessionId.
 

package/payload/platform/services/claude-session-manager/dist/jsonl-tail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsonl-tail.d.ts","sourceRoot":"","sources":["../src/jsonl-tail.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAKxC;;;uDAGuD;AACvD,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;AAEjG,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,aAAa,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;CAC7B;AAED,MAAM,WAAW,SAAS;IACxB;;qDAEiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,qBAAqB,GAAG,IAAI,CAAA;IAC9D;;;8CAG0C;IAC1C,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACzD,iDAAiD;IACjD,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,0EAA0E;IAC1E,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,OAAO,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CACxG;AAkBD;;oDAEoD;AACpD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAY3F;AAoHD,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,CAgL9D"}
+{"version":3,"file":"jsonl-tail.d.ts","sourceRoot":"","sources":["../src/jsonl-tail.ts"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAWxC;;;uDAGuD;AACvD,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;AAEjG,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,aAAa,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;CAC7B;AAED,MAAM,WAAW,SAAS;IACxB;;qDAEiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,qBAAqB,GAAG,IAAI,CAAA;IAC9D;;;8CAG0C;IAC1C,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACzD,iDAAiD;IACjD,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,0EAA0E;IAC1E,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,OAAO,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CACxG;AAkBD;;oDAEoD;AACpD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAY3F;AA4GD,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,CAkL9D"}

package/payload/platform/services/claude-session-manager/dist/jsonl-tail.js

@@ -22,11 +22,17 @@
 //         with argvTools as the exposed set and tag the source.
 //
 //   Line 2 — `[recorder-turn] sessionId=<id> turnIndex=<n> stopReason=<r>
-//             textBytes=<n> textHead=<json-escaped first 240 chars>
-//             toolUseNames=<csv|—>`
+//             textBytes=<n> text=<full json-escaped>
+//             toolUseNames=<csv|—> containsToolCallText=true|false`
 //     Emitted once per newly-appended `assistant` record. Records with the
 //     same `message.id` collapse to one line (only the first sighting
 //     emits). Records that contain only `thinking` blocks emit nothing.
+//     `text=` is the full assistant text, json-escaped — Task 213 dropped
+//     the 240-char head cap so a recorder relapse that emits
+//     `<tool_call>{…}</tool_call>` as text is observable from server.log
+//     without downloading the jsonl. `containsToolCallText=true` flags any
+//     assistant text containing `<tool_call>`, `<function_calls>`, or
+//     `</invoke>` — the recorder model copying tool-call shape into prose.
 //
 // The cursor is append-only: `cursorOffset` is the byte position past the
 // last `\n` we successfully parsed; the trailing fragment lives in
@@ -35,7 +41,13 @@
 // record — exactly the failure mode this task closes.
 import { existsSync, openSync, closeSync, readSync, statSync } from 'node:fs';
 const HEAD_READ_CHUNK = 64 * 1024;
-const TEXT_HEAD_CHARS = 240;
+// Task 213 — regex against assistant text. Matches `<tool_call>`,
+// `<function_calls>`, and `</invoke>` — three shapes the recorder model
+// emitted as prose in sessions d2aaa85e / 481799d1 (and similar evidence
+// in 596a42bc, c3539844, 4d4775bd, bad79fb9, 06ac2eb3, 6828bae0,
+// c4c10cf3, 5cb8fd16) instead of real `tool_use` blocks. `\b` against the
+// `>` boundary keeps the match precise.
+const TOOL_CALL_TEXT_PATTERN = /<tool_call\b|<function_calls\b|<\/invoke\b/;
 /** Production implementation of LogLinePoster. POSTs to the brand UI's
  *  loopback log-ingest route. Fire-and-forget; failure is logged via the
  *  manager's own logger and otherwise swallowed. */
@@ -118,18 +130,10 @@ function probeInitTools(rec) {
 /** JSON-escape a string for inclusion in a log line. Renders control
  *  characters as `\uXXXX`, quotes the result. Callers strip the quotes
  *  if they want; this module keeps them so the boundaries of
- *  `textHead=...` are explicit on screen. */
+ *  `text=...` are explicit on screen. */
 function jsonEscape(s) {
     return JSON.stringify(s);
 }
-/** First N CHARACTERS (not bytes) of a string. The 240-char cap is per
- *  spec; we operate on UTF-16 code units which is what JavaScript's
- *  default substring semantics already give us. */
-function head(s, max) {
-    if (s.length <= max)
-        return s;
-    return s.slice(0, max);
-}
 function summarizeAssistantRecord(rec) {
     if (rec.type !== 'assistant')
         return null;
@@ -210,11 +214,13 @@ export function createJsonlTail(deps) {
         state.nextTurnIndex += 1;
         const textBytes = Buffer.byteLength(summary.text, 'utf8');
         const namesField = summary.toolUseNames.length === 0 ? '—' : summary.toolUseNames.join(',');
+        const containsToolCallText = TOOL_CALL_TEXT_PATTERN.test(summary.text);
         const line = `sessionId=${state.sessionId} turnIndex=${idx}` +
             ` stopReason=${summary.stopReason || '—'}` +
             ` textBytes=${textBytes}` +
-            ` textHead=${jsonEscape(head(summary.text, TEXT_HEAD_CHARS))}` +
-            ` toolUseNames=${namesField}`;
+            ` text=${jsonEscape(summary.text)}` +
+            ` toolUseNames=${namesField}` +
+            ` containsToolCallText=${containsToolCallText}`;
         deps.postLogLine('recorder-turn', 'info', line);
     }
     function processRecord(state, rec) {