@rubytech/create-maxy-code 0.1.66 → 0.1.68

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

@@ -1,14 +1,14 @@
 #!/usr/bin/env bash
 # Stop hook — fires on every completed admin-agent turn and dispatches one
-# headless database-operator session against the operator's most recent
-# turn payload. The recorder is the only writer to the Neo4j graph; the
-# admin agent stays focused on the operator's request.
+# headless database-operator session against the operator's full
+# conversation transcript. The recorder is the only writer to the Neo4j
+# graph; the admin agent stays focused on the operator's request.
 #
 # Task 147 — the recorder spawn is byte-for-byte equivalent to a Sidebar
 # "New session" body, with three overrides:
 #   - specialist:     "database-operator"
 #   - model:          "haiku"
-#   - initialMessage: JSON-stringified envelope (Task 175)
+#   - initialMessage: JSON-stringified envelope (Task 177)
 #
 # It POSTs to the SAME route the Sidebar uses
 # (`POST /api/admin/claude-sessions`). The wrapper accepts the loopback
@@ -16,10 +16,16 @@
 # manager's `/<adminSessionId>/meta`, and forwards a Sidebar-shape spawn
 # body. No recorder-only carving on the manager side.
 #
-# Task 175 — `initialMessage` is now a JSON object stringified to a
-# string. Top-level keys EXACTLY match the database-operator agent file
-# `## Input shape`: operatorMessage, assistantReply, toolCalls,
-# conversationId, accountId, occurredAt. No leading instruction prose.
+# Task 177 — `initialMessage` is a JSON object stringified to a string.
+# Top-level keys EXACTLY: turns, conversationId, accountId, occurredAt.
+# `turns` is the chronologically-ordered conversation window — every
+# user / assistant message in the operator's JSONL, oldest first, no
+# windowing or truncation. Each entry:
+#     { role: "user"|"assistant", text: string, ts: string, toolCalls?: [...] }
+# `toolCalls` (assistant-only, omitted when empty) carries
+# `[{ tool, input, output }]` for tool_use/tool_result pairs in that turn.
+# Replaces the Task 175 `(operatorMessage, assistantReply)` pair contract,
+# which asserted a temporal pairing the walker never enforced.
 #
 # Gating (emits a `trigger-skipped` line via `/api/admin/log-ingest`;
 # stderr stays silent on the success path):
@@ -28,8 +34,7 @@
 #     "database-operator"   (recursion guard)
 #   - Stop-hook stdin must be non-empty           → reason=empty-stdin
 #   - transcript_path must exist on disk          → reason=missing-transcript
-#   - operatorMessage, assistantReply, toolCalls   → reason=conversation-empty
-#     all empty after the walker runs
+#   - turns array is empty after walker runs      → reason=conversation-empty
 #
 # Input: Claude Code's Stop hook stdin shape
 #   { "session_id": "<intrinsic>", "transcript_path": "<jsonl path>", ... }
@@ -96,16 +101,17 @@ if [ -z "$ADMIN_SESSION_ID" ] || [ -z "$TRANSCRIPT_PATH" ] || [ ! -f "$TRANSCRIP
   exit 0
 fi
 
-# Task 175 — build the JSON envelope the database-operator agent file
-# declares as its stdin contract. One Python pass walks the transcript
-# and emits:
+# Task 177 — build the envelope the database-operator agent file declares
+# as its stdin contract. One Python pass walks the transcript and emits:
 #   {
-#     "operatorMessage": <last role=user text>,
-#     "assistantReply":  <last role=assistant text>,
-#     "toolCalls":       [ {tool, input, output}, ... ],
-#     "conversationId":  <session_id>,
-#     "accountId":       <ACCOUNT_ID env>,
-#     "occurredAt":      <hook fire time, ISO-8601 UTC, .000Z>
+#     "turns": [
+#       { "role": "user"|"assistant", "text": "...", "ts": "...",
+#         "toolCalls"?: [{ "tool": "...", "input": {...}, "output": ... }] },
+#       ...
+#     ],
+#     "conversationId": "<session_id>",
+#     "accountId":      "<ACCOUNT_ID env>",
+#     "occurredAt":     "<hook fire time, ISO-8601 UTC, .000Z>"
 #   }
 # `python3 json.dumps` handles every escape so the hook never has to
 # concatenate strings into JSON by hand.
@@ -115,26 +121,26 @@ ACCOUNT_ID_ENV="${ACCOUNT_ID:-}"
 ENVELOPE=$(python3 - "$TRANSCRIPT_PATH" "$ADMIN_SESSION_ID" "$ACCOUNT_ID_ENV" "$OCCURRED_AT" <<'PY'
 import sys, json
 
-def last_text(content):
-    """Return the last `text` block string in a content list, or '' if none."""
+def concat_text(content):
+    """Concatenate every `text` block in a content list (or return the
+    string content as-is). `thinking` blocks contribute nothing."""
     if isinstance(content, str):
         return content
     if not isinstance(content, list):
         return ""
-    last = ""
+    out = []
     for b in content:
         if isinstance(b, dict) and b.get("type") == "text":
             t = b.get("text")
             if isinstance(t, str):
-                last = t
-    return last
+                out.append(t)
+    return "".join(out)
 
 path, conversation_id, account_id, occurred_at = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
 
-last_user_text = ""
-last_assistant_text = ""
-pending_calls = {}  # tool_use_id -> {tool, input}
-tool_calls = []     # ordered as tool_results arrive
+turns = []                  # ordered output: { role, text, ts, toolCalls? }
+msg_id_to_turn_index = {}   # collapse rule for assistant message.id
+pending_tool_calls = {}     # tool_use_id -> (turn_index, toolCalls_index)
 
 try:
     with open(path, "r", encoding="utf-8") as f:
@@ -153,74 +159,99 @@ try:
             if not isinstance(msg, dict):
                 continue
             content = msg.get("content")
+            ts = rec.get("timestamp", "") or ""
+
             if t == "user":
-                text = last_text(content)
-                if text:
-                    last_user_text = text
+                # tool_result blocks attach to the assistant turn that
+                # owned the corresponding tool_use; they never create a
+                # separate user turn entry.
                 if isinstance(content, list):
                     for b in content:
                         if isinstance(b, dict) and b.get("type") == "tool_result":
                             tu_id = b.get("tool_use_id")
                             if not isinstance(tu_id, str):
                                 continue
-                            pending = pending_calls.pop(tu_id, None)
-                            if pending is None:
+                            slot = pending_tool_calls.pop(tu_id, None)
+                            if slot is None:
                                 continue
-                            tool_calls.append({
-                                "tool": pending["tool"],
-                                "input": pending["input"],
-                                "output": b.get("content"),
-                            })
-            elif t == "assistant":
-                text = last_text(content)
+                            turn_idx, call_idx = slot
+                            turns[turn_idx]["toolCalls"][call_idx]["output"] = b.get("content")
+
+                text = concat_text(content)
                 if text:
-                    last_assistant_text = text
+                    turns.append({
+                        "role": "user",
+                        "text": text,
+                        "ts": ts,
+                    })
+                # No user turn emitted when content is empty or only
+                # carries tool_result blocks — those landed on the
+                # owning assistant turn above.
+
+            elif t == "assistant":
+                msg_id = msg.get("id") if isinstance(msg.get("id"), str) else None
+                text = concat_text(content)
+                tool_use_blocks = []
                 if isinstance(content, list):
                     for b in content:
                         if isinstance(b, dict) and b.get("type") == "tool_use":
-                            tu_id = b.get("id")
-                            if not isinstance(tu_id, str):
-                                continue
-                            pending_calls[tu_id] = {
-                                "tool": b.get("name"),
-                                "input": b.get("input"),
-                            }
+                            tool_use_blocks.append(b)
+
+                # Thinking-only assistant records contribute nothing and
+                # do NOT create a turn entry on their own.
+                if not text and not tool_use_blocks:
+                    continue
+
+                # Multi-block collapse: if a prior record with the same
+                # message.id created a turn, extend that one. Otherwise
+                # open a new assistant turn.
+                if msg_id is not None and msg_id in msg_id_to_turn_index:
+                    idx = msg_id_to_turn_index[msg_id]
+                    entry = turns[idx]
+                    if text:
+                        entry["text"] = (entry["text"] or "") + text
+                else:
+                    entry = {
+                        "role": "assistant",
+                        "text": text,
+                        "ts": ts,
+                    }
+                    turns.append(entry)
+                    idx = len(turns) - 1
+                    if msg_id is not None:
+                        msg_id_to_turn_index[msg_id] = idx
+
+                for b in tool_use_blocks:
+                    tc_list = entry.setdefault("toolCalls", [])
+                    tc_list.append({
+                        "tool":   b.get("name"),
+                        "input":  b.get("input"),
+                        "output": None,
+                    })
+                    tu_id = b.get("id")
+                    if isinstance(tu_id, str):
+                        pending_tool_calls[tu_id] = (idx, len(tc_list) - 1)
 except Exception:
     pass
 
-# Unanswered tool_use blocks (tool_result never landed) still surface, so
-# the recorder sees the call attempt; `output` is null.
-for tu_id, pending in pending_calls.items():
-    tool_calls.append({
-        "tool": pending["tool"],
-        "input": pending["input"],
-        "output": None,
-    })
-
 envelope = {
-    "operatorMessage": last_user_text,
-    "assistantReply":  last_assistant_text,
-    "toolCalls":       tool_calls,
-    "conversationId":  conversation_id,
-    "accountId":       account_id,
-    "occurredAt":      occurred_at,
+    "turns":          turns,
+    "conversationId": conversation_id,
+    "accountId":      account_id,
+    "occurredAt":     occurred_at,
 }
 print(json.dumps(envelope, ensure_ascii=False), end="")
 PY
 )
 
-# Skip when the envelope carries no user text, no assistant text, and no
-# tool calls — same skip surface as the prior `conversation-empty` reason.
+# Skip when turns is empty — no user text, no assistant text, no tool_use
+# in the operator JSONL. Same skip surface as the prior `conversation-empty`
+# reason; the meaning is now binary on turns.length === 0.
 EMPTY_CHECK=$(printf '%s' "$ENVELOPE" | python3 -c '
 import sys, json
 try:
     e = json.load(sys.stdin)
-    empty = (
-        not (e.get("operatorMessage") or "")
-        and not (e.get("assistantReply") or "")
-        and not (e.get("toolCalls") or [])
-    )
-    print("empty" if empty else "ok")
+    print("empty" if not (e.get("turns") or []) else "ok")
 except Exception:
     print("empty")
 ')
@@ -235,6 +266,23 @@ if [ "$EMPTY_CHECK" = "empty" ]; then
   exit 0
 fi
 
+# Task 177 observability — one envelope summary line per recorder fire,
+# emitted BEFORE the spawn POST so a future audit reads counts from
+# server.log without re-walking the JSONL. `turnsCount` is monotone
+# across spawns in the same operator session — flat or decreasing is
+# the regression signature for "windowing crept back in".
+ENVELOPE_COUNTS=$(printf '%s' "$ENVELOPE" | python3 -c '
+import sys, json
+e = json.load(sys.stdin)
+turns = e.get("turns") or []
+u = sum(1 for t in turns if t.get("role") == "user")
+a = sum(1 for t in turns if t.get("role") == "assistant")
+tc = sum(1 for t in turns if (t.get("toolCalls") or []))
+print(f"{len(turns)} {u} {a} {tc}")
+')
+read -r TURNS_COUNT USER_TURNS ASST_TURNS TC_TURNS <<<"$ENVELOPE_COUNTS"
+emit_log "envelope sessionId=${ADMIN_SESSION_ID} turnsCount=${TURNS_COUNT} userTurns=${USER_TURNS} assistantTurns=${ASST_TURNS} toolCallTurns=${TC_TURNS}"
+
 # Compose the Sidebar-shape spawn body. Three overrides relative to a
 # plain Sidebar "New session" click: specialist, model, initialMessage.
 # `adminSessionId` is the loopback-bypass key the wrapper uses to resolve

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

@@ -77,7 +77,7 @@ grep '\[client-acquire\]' ~/.${brand}/logs/claude-agent-stream-*.log
 
 The Hono route `POST /api/admin/claude-sessions` at [`platform/ui/server/routes/admin/claude-sessions.ts`](../../../ui/server/routes/admin/claude-sessions.ts) is the single canonical entry point for any caller — UI click handler or programmatic — that needs to open an admin PTY session with a first user prompt. Direct calls to the session-manager's `/spawn` are not allowed; the wrapper owns the per-spawn enrichment (`aboutOwner`, `dormantPlugins`, `activePlugins`, `specialistDomains`, `tunnelUrl`) and the `senderId` resolution from the admin session cookie. The session manager binds to `127.0.0.1` only so the wrapper is the sole authorised caller; any ad-hoc spawn that bypasses it duplicates this contract and is a bug.
 
-**Body schema.** `{channel?, permissionMode?, initialMessage?, specialist?, model?}` for the cookie path (Sidebar — `senderId` resolved from the admin session cookie, `hidden: false`). The Stop-hook loopback caller adds `adminSessionId` and uses three overrides: `specialist: 'database-operator'`, `model: 'haiku'`, plus `initialMessage`. The wrapper rejects nothing structurally on the cookie path — string fields are coerced or defaulted (`channel` → `'browser'`, `permissionMode` → undefined, `initialMessage` → null if empty/whitespace). The loopback path refuses with `400 admin-session-id-required` if `adminSessionId` is missing or non-UUID, and `404 admin-session-not-found` if the manager has no StoredSession for it.
+**Body schema.** `{channel?, permissionMode?, initialMessage?, specialist?, model?}` for the cookie path (Sidebar — `senderId` resolved from the admin session cookie, `hidden: false`). `permissionMode` accepts one of five values matching Claude Code's CLI: `'default'`, `'acceptEdits'`, `'plan'`, `'auto'`, `'bypassPermissions'`. The Stop-hook loopback caller adds `adminSessionId` and uses three overrides: `specialist: 'database-operator'`, `model: 'haiku'`, plus `initialMessage`. The wrapper rejects nothing structurally on the cookie path — string fields are coerced or defaulted (`channel` → `'browser'`, `permissionMode` → undefined, `initialMessage` → null if empty/whitespace). The loopback path refuses with `400 admin-session-id-required` if `adminSessionId` is missing or non-UUID, and `404 admin-session-not-found` if the manager has no StoredSession for it.
 
 **Auth surfaces.** Two: `cookie` (Sidebar — `requireAdminSession` validates `session_key` and resolves `senderId` from the in-memory session store) and `loopback` (Stop hook — `requireAdminSessionOrLoopback` skips cookie auth when method is `POST`, path is exactly `/api/admin/claude-sessions`, and the TCP peer is `127.0.0.1`/`::1`; the handler then resolves the operator's `senderId` from `GET {managerBase}/<adminSessionId>/meta`). Both the manager and the UI server bind to `127.0.0.1` only for internal traffic, so the trust boundary is reachable only from a process running on the device. Task 147 — one route, one body shape (the loopback variant differs only by overrides), no `/recorder-spawn` sibling, no XFF disambiguation.
 
@@ -96,20 +96,25 @@ Body overrides relative to a plain Sidebar click:
 
 **Spawn body.** The hook POSTs `{adminSessionId, channel: 'browser', specialist: 'database-operator', model: 'haiku', initialMessage}` to `POST /api/admin/claude-sessions`. `adminSessionId` is the loopback-bypass key — the wrapper resolves the operator's real `senderId` from `GET <managerBase>/<adminSessionId>/meta` and forwards a Sidebar-shape body to the manager.
 
-**`initialMessage` JSON envelope (Task 175).** A single JSON object stringified to a string. Top-level keys exactly match the database-operator agent file `## Input shape`:
+**`initialMessage` JSON envelope (Task 177).** A single JSON object stringified to a string. Top-level keys exactly match the database-operator agent file `## Input shape`:
 
 ```
 {
-  "operatorMessage": "<last role=user text block>",
-  "assistantReply":  "<last role=assistant text block, or '' if none>",
-  "toolCalls":       [ { "tool": "...", "input": {...}, "output": ... }, ... ],
-  "conversationId":  "<operator session_id>",
-  "accountId":       "<ACCOUNT_ID env, stamped on the manager systemd unit>",
-  "occurredAt":      "<hook fire time, ISO-8601 UTC, .000Z>"
+  "turns": [
+    { "role": "user",      "text": "...", "ts": "<ISO-8601>" },
+    { "role": "assistant", "text": "...", "ts": "<ISO-8601>",
+      "toolCalls": [ { "tool": "...", "input": {...}, "output": ... } ] },
+    ...
+  ],
+  "conversationId": "<operator session_id>",
+  "accountId":      "<ACCOUNT_ID env, stamped on the manager systemd unit>",
+  "occurredAt":     "<hook fire time, ISO-8601 UTC, .000Z>"
 }
 ```
 
-`toolCalls[].input` and `toolCalls[].output` are native JSON values, not re-stringified — `jq -r '.toolCalls[0].input.foo'` reaches the inner field directly. `tool_use` and `tool_result` blocks are paired by `tool_use_id`; unanswered `tool_use` calls surface with `output: null`. No leading instruction prose — the agent file's system prompt teaches the model what to do with the payload. If `operatorMessage`, `assistantReply`, and `toolCalls` are all empty after the walker runs, the hook emits `trigger-skipped reason=conversation-empty` and no recorder is spawned.
+`turns` is the operator's full conversation transcript, oldest first, newest last — every user / assistant message in the operator's JSONL from session start to the moment the recorder fired. No windowing, no truncation, no env knob. The walker collapses multi-record assistant messages on `message.id` (e.g. one `thinking` record + one `text` record from the same message become one `turns` entry with combined text). `toolCalls` is assistant-only and omitted on turns that called no tools. `toolCalls[].input` and `toolCalls[].output` are native JSON values, not re-stringified — `jq -r '.toolCalls[0].input.foo'` reaches the inner field directly. `tool_use` and `tool_result` blocks are paired by `tool_use_id` and attach to the assistant turn that owned the `tool_use`; the user record carrying only the `tool_result` does not create a separate user turn. Unanswered `tool_use` calls surface with `output: null`. No leading instruction prose — the agent file's system prompt teaches the model what to do with the payload. If `turns` is empty after the walker runs, the hook emits `trigger-skipped reason=conversation-empty` and no recorder is spawned. (Task 175's earlier `(operatorMessage, assistantReply)` pair contract was superseded — the pair asserted a temporal Q→A relationship the walker never enforced, so Task 177 replaced it with the ordered window.)
+
+The hook also emits one summary line per fire immediately before `spawn-request`: `[turn-recorder] envelope sessionId=<op> turnsCount=<n> userTurns=<n> assistantTurns=<n> toolCallTurns=<n>`. `turnsCount` is monotone across spawns in the same operator session — a flat or decreasing series is the regression signature for "windowing crept back in".
 
 **Manager-side specialist branches.** The recorder is the first specialist subagent that exercises the full specialist flag matrix:
 - The bundled `platform/templates/specialists/agents/database-operator.md` template is symlinked into `$CLAUDE_CONFIG_DIR/agents/database-operator.md` by the installer; without that link `claude --agent database-operator` silently falls back to the admin agent.
@@ -122,16 +127,17 @@ Body overrides relative to a plain Sidebar click:
 
 **Hook recursion gate.** `pty-spawner` stamps `MAXY_SPECIALIST=<specialist>` on every PTY env. The Stop hook short-circuits when `MAXY_SPECIALIST=database-operator` so the recorder's own end-of-turn does not re-fire the hook.
 
-**Observability.** The hook emits exactly two lines per operator turn via `/api/admin/log-ingest`: `[turn-recorder] trigger sessionId=<op> turnIndex=0 transcriptBytes=<n> conversationBytes=<n>` and `[turn-recorder] spawn-request sessionId=<op> specialist=database-operator initialMessageBytes=<n>`. The manager adds `pty-spawn-allowlist specialist=database-operator count=11 stripped=0 sourced-from=agent-frontmatter` and `pty-spawn-start … specialist=database-operator append-system-prompt-bytes=0` before the PTY launches. The remainder of the recorder lifecycle is covered by the Sidebar's existing lines (`pty-spawned`, JSONL events, `auto-archive`). Failure-mode names: `trigger-skipped reason=…` enumerates `role-not-admin | is-recorder | empty-stdin | missing-transcript | conversation-empty`. Hook-side spawn errors emit `[turn-recorder] spawn-failed reason=loopback-http http=<code>`.
+**Observability.** The hook emits exactly two lines per operator turn via `/api/admin/log-ingest`: `[turn-recorder] trigger sessionId=<op> turnIndex=0 transcriptBytes=<n> conversationBytes=<n>` and `[turn-recorder] spawn-request sessionId=<op> specialist=database-operator initialMessageBytes=<n>`. The manager adds `pty-spawn-allowlist specialist=database-operator count=11 stripped=0 sourced-from=agent-frontmatter`, `pty-spawn-start … specialist=database-operator append-system-prompt-bytes=0` before the PTY launches, and one `[pty-spawn-tool-inventory] sessionId=<rec> specialist=database-operator argv-tools=<n> mcp-listed-tools=<n> exposed=<csv> not-exposed=<csv>` line per spawn once the shadow probe of each MCP server returns. The remainder of the recorder lifecycle is covered by the Sidebar's existing lines (`pty-spawned`, JSONL events, `auto-archive`). Failure-mode names: `trigger-skipped reason=…` enumerates `role-not-admin | is-recorder | empty-stdin | missing-transcript | conversation-empty`. Hook-side spawn errors emit `[turn-recorder] spawn-failed reason=loopback-http http=<code>`. Probe-side failure on the inventory line emits `[pty-spawn-tool-inventory-failed] sessionId=<rec> specialist=<name> err=<json>`.
 
 ### Recorder lifecycle diagnostic
 
-When the operator reports "the recorder did nothing this turn", run these six greps in order. The first absent line names the phase that failed. `<op>` is the admin operator's session id from the original Stop hook; `<rec>` is the recorder session id returned in phase 2's response and reused across phases 3–6.
+When the operator reports "the recorder did nothing this turn", run these seven greps in order. The first absent line names the phase that failed. `<op>` is the admin operator's session id from the original Stop hook; `<rec>` is the recorder session id returned in phase 2's response and reused across phases 3–6.
 
 1. **Stop hook fired.** `grep '\[turn-recorder\] trigger sessionId=<op>' ~/.<brand>/logs/server.log` — expects one line of shape `[turn-recorder] trigger sessionId=<op> turnIndex=0 transcriptBytes=<n> conversationBytes=<n>`. Absent: the Stop hook didn't run; check that `MAXY_SESSION_ROLE=admin` was set on the operator PTY and that `MAXY_SPECIALIST!=database-operator` (recursion gate).
 2. **/spawn accepted.** `grep '\[turn-recorder\] spawn-request sessionId=<op>' ~/.<brand>/logs/server.log` — expects `[turn-recorder] spawn-request sessionId=<op> specialist=database-operator initialMessageBytes=<n>`. The response body of this POST carries `<rec>`. Absent: the hook fired but `/api/admin/claude-sessions` rejected; look for `[turn-recorder] spawn-failed reason=loopback-http http=<code>` on the next line.
 3. **PTY started.** `grep 'pty-spawn-start .* specialist=database-operator' ~/.<brand>/logs/server.log` — expects `pty-spawn-start claudeBin=<…> argv-count=<n> append-system-prompt-bytes=0 … specialist=database-operator prompt-positional=yes prompt-bytes=<n>`. Absent: the wrapper accepted but the manager rejected before exec; check the spawn-failure surfaces (`which-claude-not-found | pty-spawn-failed | pid-file-timeout | host-context-unresolved | identity-unresolved | mcp-config-write-failed`).
 4. **Agent file resolved.** `grep 'pty-spawn-allowlist specialist=database-operator count=11 stripped=0 sourced-from=agent-frontmatter' ~/.<brand>/logs/server.log` — expects exactly one line per recorder spawn. Absent (or `count` not equal to the frontmatter's tool count, or `stripped>0` meaning the brand excluded a plugin the recorder template references — Task 173): the agent file at `$CLAUDE_CONFIG_DIR/agents/database-operator.md` is missing the `tools:` line, the symlink the installer creates never landed, or the brand-aware drift filter dropped tools. Re-run the installer; cross-reference `brand.json#plugins.excluded` against the agent frontmatter.
+4b. **Tool inventory exposed to the model.** `grep '\[pty-spawn-tool-inventory\] sessionId=<rec>' ~/.<brand>/logs/server.log` — expects one line of shape `[pty-spawn-tool-inventory] sessionId=<rec> specialist=database-operator argv-tools=11 mcp-listed-tools=<n> exposed=<csv> not-exposed=<csv>`. The line lands once per spawn after the manager's shadow probe finishes a `tools/list` against each MCP server in the per-spawn `mcp.json`. The four fields decode the recorder's runtime tool surface directly: `argv-tools` is the allowlist on the `claude` argv (= phase 4's `count`); `mcp-listed-tools` is the sum across servers of names the probe captured; `exposed` is the intersection (in frontmatter order); `not-exposed` is the allowlist minus `exposed`. The regression query for "model says no tools" is `exposed=$|exposed= ` — when the line ends `exposed= not-exposed=<all 11>`, the allowlist landed on the argv but none of the names came back from any MCP server (cause space: frontmatter format, name canonicalisation, MCP handshake repair). Absent line: probe is fire-and-forget, so absence either means the spawn was not a specialist (operator chat) or the probe itself crashed — in which case `[pty-spawn-tool-inventory-failed] sessionId=<rec> specialist=… err=…` is the partner line to grep. Note: the probe captures what each MCP server offers, not what claude code's own tools/list saw — CLI-side filtering after handshake is a separate observability concern.
 5. **Graph write outcome.** `grep '\[mcp:memory\] memory-write .* session=<rec>' ~/.<brand>/logs/server.log` — expects one line ending `result=ok elementId=<id>` or `result=error reason=<slug>` (slug enumerated by the memory MCP write-path observability work). Absent: the recorder loaded but produced no tool calls — model-side decision, not infra. Read the recorder JSONL at `<accountDir>/.claude/projects/<slug>/<rec>.jsonl` to see what the LLM did.
 6. **Auto-archive.** `grep 'auto-archive .* sessionId=<rec> .* specialist=database-operator reason=end-turn' ~/.<brand>/logs/server.log` — expects one line. Absent: the recorder finished but the manager's end-turn watcher didn't fire; the fs-watcher row will get reaped on its TTL but the recorder hung longer than expected. Investigate `pty-spawn-stop` and `pid-file-removed` lines on the same `<rec>`.
 
@@ -178,6 +184,43 @@ The existing `mcp-memory-stderr-<date>.log` capture is unchanged on error paths
 
 **Test contract (Task 168).** Each of the 20 wired tools carries a `*-emit.test.ts` fixture under `platform/plugins/memory/mcp/src/tools/__tests__/` that mocks `fetch` and asserts the wire body. A refactor that drops `withWriteEvent` from any tool fails the matching tool's tests with a clear `expected "vi.fn()" to be called 1 times, but got 0 times` error, naming the tool. A shared helper at `__tests__/_helpers/emit-capture.ts` standardises the fetch capture + Neo4j Session stub so each tool test stays a few lines of mocks + one happy + one error assertion. Drift between the helper's body shape and the route's validator is pinned by an end-to-end test at `platform/ui/server/routes/admin/__tests__/log-ingest-mcp-end-to-end.test.ts`, which routes the helper's POST through the real Hono `log-ingest` route with a loopback `remoteAddress` shim.
 
+## Diagnosing missing tools in production (Task 183)
+
+When a database-operator spawn fails to call any of its 11 tools, the question is which of two layers dropped them:
+
+- **Outcome A — tools missing at the model boundary.** The CLI / SDK exposes fewer tools than the framework's `--allowed-tools` argv listed. The model never sees the missing names, so it cannot call them and writes nothing to the graph.
+- **Outcome B — tools present, model abstains.** The SDK exposes all 11 tools; the model has them but chooses not to call any.
+
+Three log-line shapes, all keyed on the same recorder `sessionId`, distinguish the two:
+
+```
+[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|—>
+```
+
+- `[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.
+- `[recorder-session-init]` (Task 183 — emitted by the JSONL tail in `claude-session-manager`) measures the **CLI/SDK** layer — what the SDK actually exposed to the model. The set difference `toolsArgvMissingFromExposed` is the Outcome A fingerprint:
+  - `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.
+  - `error=init-record-not-found probedTypes=system.init,command_permissions,deferred_tools_delta` ⇒ no init-shaped record was found in the JSONL by the time the first assistant turn landed. The miss itself is the observable; iterate the probe list against the live JSONL to learn the new record shape.
+- `[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.
+
+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:
+
+```bash
+SID=<rec-sessionId>
+grep -E "\[(pty-spawn-tool-inventory|recorder-session-init|recorder-turn|mcp:(memory|contacts|tasks))\] .*sessionId=${SID}" ~/.${brand}/logs/server.log
+```
+
+**Reading the output.**
+
+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.
+
+**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.
+
 ## Out of scope
 
 - Public/WhatsApp/Telegram sessions — out of scope. Their sessionKeys remain `crypto.randomUUID()` and follow the existing rejection-on-restart contract.

package/payload/platform/plugins/docs/references/deployment.md

@@ -64,7 +64,7 @@ Every PTY spawn injects an `--append-system-prompt` block composed of these sent
 | `<attachment-ceiling>` | hard-coded 30 MiB rule | always present |
 | `<identity>` | `<accountDir>/agents/<role>/IDENTITY.md` | spawn refuses with `identity-unresolved` |
 | `<soul>` | `<accountDir>/agents/<role>/SOUL.md` | spawn refuses with `identity-unresolved` |
-| `<about-owner>` | upstream `loadUserProfile` + `formatProfileSummary` (UI process) | sentinel carries `coverage-unresolved: <reason>`; spawn proceeds |
+| `<about-owner>` | upstream `loadUserProfile` + `formatProfileSummary` (UI process) | sentinel renders the prose body with `NOTHING (operator-data source unavailable: \`<reason>\`)` on line one; spawn proceeds |
 | `<specialist-domains>` | `<accountDir>/specialists/agents/*.md` frontmatter (UI process) | sentinel omitted when set is empty |
 | `<plugin-manifest>` | enabled plugins' PLUGIN.md frontmatter + skill SKILL.md frontmatter (UI process) | sentinel omitted when set is empty |
 | `<dormant-plugins>` | installed-minus-enabled set from `platform/plugins/` and `account.json` | sentinel omitted when set is empty |
@@ -77,7 +77,7 @@ Diagnostic line per spawn (`~/.<brand>/logs/server.log`):
 
 The `pty-spawn-start` line additionally carries `hooksResolved=<event1,event2,…>` — the hook event names Claude Code would actually load for that PTY (resolved by walking the same `$CLAUDE_CONFIG_DIR/settings.json` plus the cwd-to-.git path Claude Code itself uses). A Stop hook registered in a settings file outside the loader's scope shows up as a missing event in this list.
 
-Zero `aboutOwnerBytes` on a fresh-account spawn (sparse profile) is a regression: the upstream resolver returned ok:false with a reason, and the operator should see `coverage-unresolved: <reason>` in the agent's first turn. Zero `dormantPluginsBytes` on a Maxy install with `cloudflare` not enabled is likewise a regression. Zero `pluginManifestBytes` on any account with enabled plugins means the upstream walker failed silently.
+Zero `aboutOwnerBytes` on any admin spawn is a regression: the upstream resolver dropped the field entirely. The prose body always carries the unconditional MAXIMISE imperative on line two, so the byte count is positive even on a fresh-account spawn whose line one is `NOTHING`. Zero `dormantPluginsBytes` on a Maxy install with `cloudflare` not enabled is likewise a regression. Zero `pluginManifestBytes` on any account with enabled plugins means the upstream walker failed silently.
 
 The manager also runs a boot-time self-test that renders a fixture compose call against synthetic inputs and refuses to start if any sentinel is missing:
 

package/payload/platform/plugins/docs/references/internals.md

@@ -504,6 +504,8 @@ This gate was Task 173. The `brand-excluded` branch closes the recurring crash-r
 
 **Recorder auto-archive (lifecycle, not user-initiated).** The session manager's `attachRecorderAutoArchive` ([`platform/services/claude-session-manager/src/http-server.ts:178`](../../../services/claude-session-manager/src/http-server.ts)) wires every spawn whose `senderId === 'turn-recorder'` to a JSONL watcher: as soon as the recorder's JSONL contains `"stop_reason":"end_turn"`, the manager calls `stopSession`, the PTY exits, the PID file is removed, and `fs-watcher.ts:275-297` demotes the row to `state: 'archived'`. This is the lifecycle archive path — the row stays in place, the JSONL stays on disk, no directory move. It is structurally distinct from the user-initiated `POST /api/admin/claude-sessions/:id/archive` route, which actually `mv`s the JSONL between `<slugDir>` and `<slugDir>/archive/`; that path is the operator pruning their visible session list, not the recorder's per-turn cleanup.
 
+**Resume idempotency and specialist propagation (Task 179).** `POST /resume` accepts an optional `idempotencyKey` on the body; two POSTs sharing the same `${senderId}:${idempotencyKey}` within 5 seconds return the cached payload without spawning a second PTY. The client (`platform/ui/app/lib/session-actions.ts`) generates a fresh `crypto.randomUUID()` per Resume click and forwards it through the proxy. A synchronous `useRef` guard inside `resume()` short-circuits a same-frame re-fire (React StrictMode, rapid double-click) before the network is touched, and `Sidebar.tsx` disables the Resume button while `inFlight === 'resume'`. The resume route also accepts a `specialist` field on the body, validated by the same regex `/^[A-Za-z0-9_-]{1,64}$/` that `/spawn` uses; when absent, the route falls back to `resolveRow(deps.watcher, sessionId).agent` so a `database-operator` resume always lands as a `database-operator` session rather than collapsing to an admin row. Forensic log lines: `resume-dedup senderId=… idempotencyKey=… cacheHit=yes age-ms=<n>` on a deduplicated POST, and `resume-specialist-propagated source=<sid> specialist=<name>` on a resume that carried a non-default specialist.
+
 ## Tool Call Audit Trail
 
 Every tool invocation by the admin agent produces a durable `ToolCall` node in the knowledge graph, linked to the `Conversation` that triggered it. This covers all admin agent tool calls — the full history of what the agent did, when, and in what context.

package/payload/platform/plugins/docs/references/platform.md

@@ -88,7 +88,7 @@ The sidebar row's displayed name is `tail.aiTitle` verbatim, parsed by `jsonl-en
 
 **Stop vs. delete.** `POST /<id>/stop` sends SIGTERM, leaves the JSONL on disk for audit, and is idempotent against an already-dead row. `DELETE /<id>` removes the JSONL + per-session subdir and returns 409 if the PTY is still alive (stop first). Any unknown id returns 404; nothing returns a silent 204 against an id the manager does not know.
 
-**stopSession fd contract (Task 170).** Before `/stop` returns, the manager explicitly releases the pty master file descriptor by calling `pty.destroy()` on node-pty's `UnixTerminal` — the only path that synchronously closes the internal tty socket. Without the explicit call, the master fd waits on V8 GC finalising the IPty object, which is non-deterministic and accumulates under heavy operator-stop traffic until the kernel pty cap (Linux 3072, macOS 511) refuses new spawns. The release is verified by the `stop-session-fd-release` integration test, and every `kill … reason=operator-request` log line now ends in `master-fd=closed` (or `master-fd=close-failed err=<msg>` on the rescued throw branch — a graceful degradation so a corner-case socket-state failure cannot turn a logically-successful stop into a 500).
+**PTY lifecycle contract (Tasks 170 + 176).** A PTY reaches its end via one of two branches: **operator-request** (operator clicks End or the auto-archive Stop hook calls `stopSession`) or **natural-exit** (the claude child exits on its own — operator typed `/quit`, SIGINT in the PTY, crash, network drop on `--remote-control`). Both branches honour a single invariant: the pty master file descriptor is released by an explicit `pty.destroy()` and the SessionStore row is removed before the next `/list` or `/events` tick. Without the explicit destroy, the master fd lingers in node-pty's internal socket until V8 GC finalises the IPty object — non-deterministic and accumulates under load until the kernel pty cap (Linux 3072, macOS 511) refuses new spawns. Without the explicit row removal, the manager shutdown loop SIGTERMs PIDs that already logged `process-exited`, masking the leak only because the manager restarts every few hours. When both branches fire on the same exit (operator clicks End and node-pty's `onExit` fans out the SIGTERM to both listeners), a per-row `fdReleased` flag short-circuits the second branch so `pty.destroy()` runs exactly once on the live socket — without the flag, the second call throws "socket already destroyed" and the operator-request line would falsely log `master-fd=close-failed`. If the first branch's destroy throws and is rescued, the flag stays unset and the second branch retries (defense in depth). Every `kill … pid=<n>` log line carries a `master-fd=closed` suffix (or `master-fd=close-failed err=<msg>` on the rescued throw branch — a graceful degradation so a corner-case socket-state failure cannot turn a logically-successful exit into a 500); the operator-request line additionally identifies `reason=operator-request`, the natural-exit line identifies `reason=process-exited`. Both branches are verified by the `stop-session-fd-release` and `endpoint-stop-delete` integration tests (operator-request live and already-exited cycles + natural-exit cycle + throw-then-retry coordination, Linux kernel-level ptmx fd accounting on each).
 
 The metadata pane subscribes to the same /list projection. When an operator clicks End on an alive row, the DELETE returns 200 and the post-mutation refetch decides what happens next: a session that wrote a JSONL surfaces as a dehydrated `status: 'ended'` row (the pane swaps `End session` for `Purge JSONL` plus `Resume`), and a session that never wrote a JSONL (`Turns: 0`) leaves the list entirely (the pane shows a `Session ended without a transcript. Close this pane.` banner with a Close button and no destructive action). The manager's `/list` and `/meta` are the only authorities on post-End state; the client does not pre-empt either response with an optimistic mutation.
 

package/payload/platform/plugins/memory/mcp/dist/tools/__tests__/profile-update-not-applicable.test.js

@@ -12,8 +12,9 @@
  *
  * Write contract (covered by load-user-profile-sparse.test.ts via
  * loadUserProfile + formatProfileSummary integration):
- *   - notApplicable rows count as covered for Coverage purposes.
- *   - notApplicable rows are filtered from the user-facing body.
+ *   - notApplicable rows count as covered for observability (sparse-state
+ *     log only — the body never enumerates absent fields).
+ *   - notApplicable rows are filtered from the user-facing prose body.
  *
  * Validation throws BEFORE any session.run / embed call, so these tests
  * don't need to mock neo4j-driver or the embeddings module — the throw

package/payload/platform/plugins/memory/mcp/dist/tools/__tests__/profile-update-not-applicable.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"profile-update-not-applicable.test.js","sourceRoot":"","sources":["../../../src/tools/__tests__/profile-update-not-applicable.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,MAAM,IAAI,GAAG,sCAAsC,CAAC;AACpD,MAAM,IAAI,GAAG,qBAAqB,CAAC;AAEnC,QAAQ,CAAC,2CAA2C,EAAE,GAAG,EAAE;IACzD,EAAE,CAAC,sEAAsE,EAAE,KAAK,IAAI,EAAE;QACpF,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,eAAe;YACzB,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,aAAa;YACpB,aAAa,EAAE,IAAI;SACpB,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gDAAgD,EAAE,KAAK,IAAI,EAAE;QAC9D,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,eAAe;YACzB,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,EAAE;YACT,IAAI,EAAE,OAAO;YACb,aAAa,EAAE,IAAI;SACpB,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qDAAqD,EAAE,KAAK,IAAI,EAAE;QACnE,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,eAAe;YACzB,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,EAAE;YACT,IAAI,EAAE,YAAY;YAClB,aAAa,EAAE,IAAI;SACpB,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6EAA6E,EAAE,KAAK,IAAI,EAAE;QAC3F,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,eAAe;YACzB,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,EAAE;SACV,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;QAEvC,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,eAAe;YACzB,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,KAAK;YACZ,aAAa,EAAE,KAAK;SACrB,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2DAA2D,EAAE,KAAK,IAAI,EAAE;QACzE,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,gBAAgB;YAC1B,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,EAAE;YACT,aAAa,EAAE,IAAI;SACpB,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}
+{"version":3,"file":"profile-update-not-applicable.test.js","sourceRoot":"","sources":["../../../src/tools/__tests__/profile-update-not-applicable.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,MAAM,IAAI,GAAG,sCAAsC,CAAC;AACpD,MAAM,IAAI,GAAG,qBAAqB,CAAC;AAEnC,QAAQ,CAAC,2CAA2C,EAAE,GAAG,EAAE;IACzD,EAAE,CAAC,sEAAsE,EAAE,KAAK,IAAI,EAAE;QACpF,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,eAAe;YACzB,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,aAAa;YACpB,aAAa,EAAE,IAAI;SACpB,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gDAAgD,EAAE,KAAK,IAAI,EAAE;QAC9D,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,eAAe;YACzB,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,EAAE;YACT,IAAI,EAAE,OAAO;YACb,aAAa,EAAE,IAAI;SACpB,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qDAAqD,EAAE,KAAK,IAAI,EAAE;QACnE,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,eAAe;YACzB,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,EAAE;YACT,IAAI,EAAE,YAAY;YAClB,aAAa,EAAE,IAAI;SACpB,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6EAA6E,EAAE,KAAK,IAAI,EAAE;QAC3F,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,eAAe;YACzB,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,EAAE;SACV,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;QAEvC,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,eAAe;YACzB,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,KAAK;YACZ,aAAa,EAAE,KAAK;SACrB,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2DAA2D,EAAE,KAAK,IAAI,EAAE;QACzE,MAAM,MAAM,CACV,aAAa,CAAC;YACZ,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,gBAAgB;YAC1B,GAAG,EAAE,kBAAkB;YACvB,KAAK,EAAE,EAAE;YACT,aAAa,EAAE,IAAI;SACpB,CAAC,CACH,CAAC,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/payload/platform/plugins/memory/mcp/dist/tools/profile-read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"profile-read.d.ts","sourceRoot":"","sources":["../../src/tools/profile-read.ts"],"names":[],"mappings":"AAcA,UAAU,iBAAiB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,gBAAgB;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IAInB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,UAAU,cAAc;IACtB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,wBAAyB,SAAQ,gBAAgB;IACzD,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B;AAED,UAAU,iBAAiB;IACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,uBAAuB;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,WAAW,EAAE,wBAAwB,EAAE,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE;QACL,gBAAgB,EAAE,MAAM,CAAC;QACzB,aAAa,EAAE,MAAM,CAAC;QACtB,gBAAgB,EAAE,MAAM,CAAC;QACzB,cAAc,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,wBAAsB,WAAW,CAC/B,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,iBAAiB,GAAG,uBAAuB,CAAC,CAmHtD;AA2CD,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAyC5D,CAAC;AA0CX,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAcjE;AASD,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAyC1B;AAID,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,WAAW,EAAE,gBAAgB,EAAE,EAC/B,cAAc,GAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAM,GACrD,MAAM,CA+DR"}
+{"version":3,"file":"profile-read.d.ts","sourceRoot":"","sources":["../../src/tools/profile-read.ts"],"names":[],"mappings":"AAcA,UAAU,iBAAiB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,UAAU,gBAAgB;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IAInB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,UAAU,cAAc;IACtB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,wBAAyB,SAAQ,gBAAgB;IACzD,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B;AAED,UAAU,iBAAiB;IACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,uBAAuB;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,WAAW,EAAE,wBAAwB,EAAE,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE;QACL,gBAAgB,EAAE,MAAM,CAAC;QACzB,aAAa,EAAE,MAAM,CAAC;QACtB,gBAAgB,EAAE,MAAM,CAAC;QACzB,cAAc,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,wBAAsB,WAAW,CAC/B,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,iBAAiB,GAAG,uBAAuB,CAAC,CAmHtD;AA4CD,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAyC5D,CAAC;AA0CX,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAcjE;AASD,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,GAChB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAyC1B;AAQD,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,WAAW,EAAE,gBAAgB,EAAE,EAE/B,cAAc,GAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAM,GACrD,MAAM,CAMR"}